Rail transit emergency plan visual compilation and automatic execution method and related medium

Abstract

The invention provides a rail transit emergency plan visual compilation and automatic execution method and a related medium. The method comprises the following steps: constructing an emergency plan process model through components based on a rail transit ATS component library; in response to a plan triggering instruction, analyzing the emergency plan process model, and converting the emergency plan process model into a directed acyclic graph, nodes in the directed acyclic graph being task nodes; scripts corresponding to task nodes are automatically scheduled and executed based on the directed acyclic graph so as to call an application program interface (API) of an automatic train monitoring (ATS) system, a scheduling control instruction is issued to the ATS system, conversion of an emergency plan from'static document and manual scheduling 'to'visual editing and automatic execution' is achieved, and the speed and accuracy of emergency response are greatly improved; the visual process model is automatically converted into the executable task flow, and the task flow is deeply integrated with the ATS system, so that the problem of difficulty in cross-system collaboration is solved.

Description

Technical Field

[0001] This invention relates to the field of rail transit scheduling and control technology, and in particular to a method for visualizing and automatically executing rail transit emergency plans and related media. Background Technology

[0002] As the backbone of urban public transportation, the operational safety and efficiency of rail transit systems are of paramount importance. To cope with various emergencies that may occur during operation, such as equipment failures, surges in passenger flow, and weather impacts, operating units need to develop detailed and reliable emergency plans. Rail transit emergency plans include document-based plans and basic visual flowchart plans. Document-based plans are compiled and managed using document editing tools such as Word. In this type of plan, emergency procedures, handling steps, responsible persons, and other information are recorded in the document in textual description. When it is necessary to represent the process logic, the creator must manually draw flowcharts and embed them in the document. This type of plan has low visualization levels, and the lengthy textual descriptions are not intuitive enough, making it difficult for dispatchers to quickly and accurately understand the entire emergency logic and key nodes in emergency situations. Any modification to the process requires readjusting the document and diagrams, which is cumbersome, difficult to manage versions, and can easily lead to a disconnect between the plan content and actual operational conditions. During emergency response, dispatchers must manually read and interpret document steps and manually execute each operation (such as telephone notification and manually setting commands in the Automatic Train Control System (ATS)). The entire process is time-consuming and may cause them to miss the optimal response time. Furthermore, the lack of system coordination means that contingency plans remain at the document level, completely disconnected from the actual ATS and other core control systems. This prevents the automatic issuance of instructions and relies on manual dispatching, making it prone to errors or delays due to human factors. Basic visual flowchart solutions use graphical nodes and connections to illustrate emergency procedures, making the logical relationships clearer than plain text. However, general flowchart tools lack specialized component libraries for the rail transit sector (such as "detain train," "skip stop," "add train," "extend operation," etc.). Contingency plans still need to be built from scratch, lacking professionalism and incurring high learning costs. Flowcharts only "demonstrate" the logic; execution still requires manual operation in multiple independent systems, such as the ATS, based on flowchart instructions, failing to achieve automated transition from "viewing the diagram" to "execution." The activation of the contingency plan and the execution of tasks lack an automated triggering mechanism, cannot be linked with the monitoring system, and cannot achieve rapid automatic response based on real-time events. Summary of the Invention

[0003] This invention provides a method and related medium for the visualization and automatic execution of emergency plans for rail transit, which solves the defects of insufficient visualization of traditional rail transit emergency procedures, separation from the control system, and low response efficiency caused by reliance on manual execution.

[0004] This invention provides a method for the visualization and automatic execution of emergency response plans for rail transit, comprising: Emergency response plan process model based on rail transit ATS component library; In response to the contingency plan trigger command, the contingency plan process model is parsed and converted into a directed acyclic graph, where the nodes in the directed acyclic graph are task nodes; Based on the directed acyclic graph, the scripts corresponding to each task node are automatically scheduled and executed to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system.

[0005] According to the method for visualizing and automatically executing emergency plans for rail transit provided by the present invention, the emergency plan process model constructed based on the rail transit ATS component library includes: The visual editing interface provides a graphical editing canvas; In response to the user's drag-and-drop operation on the components in the ATS component library, a corresponding task node is generated in the graphical editing canvas; In response to the user's connection operation, multiple task nodes are connected according to the preset emergency response logic to form a visual emergency plan flowchart; In response to the user's configuration operation on any task node, a parameter configuration form corresponding to the node type is generated, and the execution parameters input by the user are received. The task nodes, logical relationships between nodes, and execution parameters are stored in a structured manner to generate an emergency response plan process model.

[0006] According to the method for visualizing and automatically executing rail transit emergency plans provided by the present invention, the configuration operation includes at least one of the following: skip station, additional train number, originating station, destination station, time and interval time.

[0007] According to the method for visualizing and automatically executing rail transit emergency plans provided by the present invention, the step of parsing the emergency plan process model and converting the emergency plan process model into a directed acyclic graph includes: Read the structured data of the emergency response plan process model to obtain the logical relationships between nodes; construct a directed acyclic graph based on the multiple task nodes and the logical relationships between the nodes.

[0008] According to the method for visualizing and automatically executing emergency plans for rail transit provided by the present invention, the step of automatically scheduling and executing the scripts corresponding to each task node based on the directed acyclic graph to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) includes: Based on the node dependencies defined in the directed acyclic graph (DAG), the execution order of task nodes is determined. According to the execution order, the workflow engine sequentially triggers the execution of the automated scripts corresponding to each task node, and initiates API calls to the Automatic Train Monitoring (ATS) system.

[0009] The method for visualizing and automatically executing rail transit emergency plans provided by the present invention further includes: The overall execution progress of the plan and / or the execution status of individual task nodes are displayed in real time on the visualization interface.

[0010] This invention also provides a system for visualizing and automatically executing emergency response plans for rail transit, comprising: The module is used to build emergency response plan process models based on the rail transit ATS component library; The conversion module is used to respond to the emergency plan triggering command, parse the emergency plan process model, and convert the emergency plan process model into a directed acyclic graph, wherein the nodes in the directed acyclic graph are task nodes; The execution module is used to automatically schedule each task node based on the directed acyclic graph through the workflow engine, and to call the application programming interface (API) of the Train Automatic Monitoring System (ATS) by executing the scripts corresponding to each task node, so as to issue scheduling control commands to the ATS system.

[0011] The rail transit emergency plan visualization and automatic execution system provided by the present invention further includes: The visualization layer provides an emergency plan editing interface and an emergency response interface. The emergency plan editing interface is used to build an emergency plan process model by dragging and dropping components. The emergency response interface is used to display a list of plans, trigger the execution of plans, and monitor the execution status. The execution layer is used to receive the triggered plan, convert it into a directed acyclic graph (DAG), and schedule the execution node tasks through the workflow engine. The execution layer is configured to call the API of external systems. The storage layer is used to store predefined ATS component libraries, constructed emergency response plan process models, and plan execution status data.

[0012] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, it implements the method for visual compilation and automatic execution of rail transit emergency plans as described in any of the preceding claims.

[0013] The present invention also provides a non-transitory readable storage medium storing a computer program thereon, wherein the computer program, when executed by a processor, implements the above-described method for visualizing and automatically executing rail transit emergency plans.

[0014] The present invention provides a method and related media for the visualization and automatic execution of rail transit emergency plans. It constructs an emergency plan process model based on components from a rail transit ATS component library. Responding to a plan trigger command, the method parses the emergency plan process model and converts it into a directed acyclic graph (DAG), where nodes are task nodes. Based on the DAG, it automatically schedules and executes scripts corresponding to each task node to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system. This transforms emergency plans from "static documents and manual scheduling" to "visual editing and automatic execution," significantly improving the speed and accuracy of emergency response. By automatically converting the visualized process model into an executable task flow and deeply integrating it with the ATS system, it solves the problem of difficult cross-system collaboration. Attached Figure Description

[0015] To more clearly illustrate the technical solutions in this invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0016] Figure 1 This is one of the flowcharts for the visual compilation and automatic execution method of rail transit emergency plans provided in this embodiment of the invention; Figure 2 This is the second flowchart of the method for visualizing and automatically executing emergency plans for rail transit provided in this embodiment of the invention; Figure 3 This is a schematic diagram of the temporary vehicle addition plan interface provided in an embodiment of the present invention; Figure 4 This is a functional structure diagram of the rail transit emergency plan visualization and automatic execution system provided in this embodiment of the invention; Figure 5 This is an architecture diagram of the rail transit emergency plan visualization and automatic execution system provided in this embodiment of the invention; Figure 6 This is a functional structure diagram of the electronic device provided in the embodiments of the present invention. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0018] Figure 1 The flowchart of the method for visualizing and automatically executing rail transit emergency plans provided in the embodiments of the present invention is as follows: Figure 1 As shown in the embodiment of the present invention, the method for visualizing and automatically executing rail transit emergency plans includes: Step 101: Construct an emergency response plan process model based on the rail transit ATS component library; Step 102: In response to the contingency plan trigger command, parse the emergency plan process model and convert the emergency plan process model into a directed acyclic graph, where the nodes in the directed acyclic graph are task nodes; Step 103: Based on the directed acyclic graph, automatically schedule and execute the scripts corresponding to each task node to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system.

[0019] Traditional contingency plan development relies on document management, which suffers from problems such as insufficient process visualization, complex development, low response efficiency, and difficulties in cross-system collaboration. Visualized processes lack component libraries for the rail transit field, contingency plan execution is disconnected from the ATS system, and there is a lack of automated triggering mechanisms.

[0020] The method for visualizing and automatically executing emergency plans for rail transit provided in this invention constructs an emergency plan process model based on components from a rail transit ATS component library. In response to a plan trigger command, the method parses the emergency plan process model and converts it into a directed acyclic graph (DAG), where nodes are task nodes. Based on the DAG, the method automatically schedules and executes scripts corresponding to each task node to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system. This transforms emergency plans from "static documents and manual scheduling" to "visualized editing and automatic execution," significantly improving the speed and accuracy of emergency response. By automatically converting the visualized process model into an executable task flow and deeply integrating it with the ATS system, the method solves the problem of difficult cross-system collaboration.

[0021] Based on any of the above embodiments, the component construction emergency plan process model based on the rail transit ATS component library includes: Step 201: In the visual editing interface, a graphical editing canvas is provided; Step 202: In response to the user's drag and drop operation on the components in the ATS component library, generate the corresponding task node in the graphical editing canvas; Step 203: In response to the user's connection operation, connect multiple task nodes according to the preset emergency response logic to form a visual emergency plan flowchart; Step 204: In response to the user's configuration operation on any task node, generate a parameter configuration form corresponding to the node type and receive the execution parameters input by the user; Step 205: Store the task nodes, logical relationships between nodes, and execution parameters in a structured manner to generate an emergency response plan process model.

[0022] In this embodiment of the invention, the configuration operations include, but are not limited to: skipping stops, adding train numbers, originating station, destination station, time, and interval time.

[0023] The embodiments of the present invention can realize the visualization of emergency plans by displaying the emergency plans in the form of flowcharts. In addition, through drag-and-drop components on the front-end page (such as operation nodes such as vehicle impoundment and skipping stops), parameterized configuration is supported, such as dynamically injecting fields such as skipping stop stations, additional vehicle numbers, and time.

[0024] Based on any of the above embodiments, the step of parsing the emergency response plan process model and converting the emergency response plan process model into a directed acyclic graph includes: Read the structured data of the emergency response plan process model to obtain the logical relationships between nodes; construct a directed acyclic graph based on the multiple task nodes and the logical relationships between the nodes.

[0025] In this embodiment of the invention, the step of automatically scheduling and executing the scripts corresponding to each task node based on the directed acyclic graph to call the application programming interface (API) of the Automatic Train Monitoring (ATS) system includes: Step 301: Determine the execution order of task nodes based on the node dependencies defined in the directed acyclic graph (DAG); Step 302: According to the execution order, the workflow engine sequentially triggers the execution of the automated scripts corresponding to each task node and initiates API calls to the Automatic Train Monitoring (ATS) system.

[0026] In this embodiment of the invention, the emergency plan is executed automatically. The dispatcher can trigger the Airflow task by clicking to execute at the front end, which automatically calls the ATS interface and finally realizes the control of the ATS, forming a closed loop of "configuration-execution-monitoring".

[0027] Based on any of the above embodiments, the method for visualizing and automatically executing rail transit emergency plans further includes: The overall execution progress of the plan and / or the execution status of individual task nodes are displayed in real time on the visualization interface.

[0028] like Figure 2 As shown, the automatic execution process after the emergency plan is triggered is as follows: (1) Start and trigger plan The system is ready; the process begins.

[0029] Triggering the plan: Dispatchers can manually activate a specific emergency plan by clicking the "Execute" button on the visual emergency response interface. The system then receives the trigger command for that plan.

[0030] (2) Select task node The system analyzes the triggered emergency response plan process model and determines the first or next batch of task nodes that need to be executed based on its logic (such as "adding vehicle information entry").

[0031] This step is represented as "selecting a task node" in the flowchart. In the system, it is an automated logical judgment process, rather than a manual selection.

[0032] (3) Triggering the DAG model The system places the selected task node within the context of the entire plan's directed acyclic graph (DAG).

[0033] Workflow engines (such as Airflow) automatically trigger scheduling of specific tasks corresponding to a node based on the dependencies defined in the DAG.

[0034] (4) Call the ATS interface The triggered task will automatically execute the Python script it is attached to.

[0035] This script encapsulates specific business logic, constructs standardized instruction data, and automatically calls the API interface of the Automatic Train Monitoring (ATS) system to perform actual operations such as detaining cars, stopping, and adding cars.

[0036] (5) Display of execution results After the system sends a command to the ATS system, it will continuously query and wait for the execution result returned by the ATS.

[0037] Regardless of success or failure, the execution status of the task (such as "in progress", "success", "failure") will be fed back and updated in real time on the front-end visualization interface for the scheduler to monitor.

[0038] (6) Decision-making: Has the task been completed? The system performs automated judgment based on the results returned by ATS: If the task is not completed successfully, the process will return along the "No" path, which may involve retrying or waiting for intervention, and then enter the "Execution Result Query and Display" step again.

[0039] If the task has been successfully completed, the process will proceed to the next step along the "Yes" path.

[0040] (7) Decision judgment: Are all nodes completed? The system checks if there are any remaining task nodes to be executed in the current plan's DAG. If there are, the process returns to the "Select Task Node" step and automatically starts the execution loop for the next task until all nodes are completed. If all nodes have been executed, the process ends.

[0041] The following uses a temporary vehicle addition plan as an example to illustrate the specific implementation method of the plan. The interface of the temporary vehicle addition plan is as follows: Figure 3 As shown. After the contingency plan is triggered, the "Start" node will be automatically activated, and the details page will display information such as the reason for triggering the plan, time, and type. The "Temporary Add-on Plan" node displays the operation steps of the current plan, including a preview of the current timetable, entry of add-on information, a preview of the adjusted timetable, and issuing a command to the ATS to adjust the timetable. After confirmation, proceed to the next node. The "Add-on Information Entry" node displays the timetable before adjustment and the add-on information form. The form information includes the originating station, destination station, time, interval, and quantity. After entering the add-on information, the add-on operation is executed, which can trigger the AirFlow task. After successful execution, proceed to the next node. The "Temporary Add-on Command Execution" node displays the adjusted timetable. After confirmation, the command can be issued to the ATS system. The "End" node displays the execution status of the plan. After confirmation, the plan process is completed.

[0042] This invention provides a method for the visual compilation and automatic execution of rail transit emergency plans. Through drag-and-drop components (such as operation nodes for train deactivation and stoppage), it supports parameterized configuration, dynamically injecting fields such as stoppage stations and additional train numbers, enabling visual configuration of train dispatching instructions. Based on AirFlow, Python scripts are orchestrated to construct a directed acyclic graph, decomposing the plan process into atomic task nodes. When executing the plan, corresponding operations (such as issuing train deactivation instructions to the ATS system) can be triggered through these process nodes. A cross-system triggering mechanism automatically calls the ATS system API when process nodes are executed, enabling operations such as train deactivation, stoppage, and timetable adjustments. The plan editing is achieved through a visual interface, simplifying operations and improving the efficiency of plan compilation; automatic execution of emergency plans shortens emergency response time.

[0043] The following describes the rail transit emergency plan visualization and automatic execution system provided by the present invention. The rail transit emergency plan visualization and automatic execution system described below and the rail transit emergency plan visualization and automatic execution method described above can be referred to and correspond to each other.

[0044] Figure 4 The functional structure diagram of the rail transit emergency plan visualization and automatic execution system provided in the embodiments of the present invention is as follows: Figure 4 As shown, the rail transit emergency plan visualization and automatic execution system provided in this embodiment of the invention includes: Module 401 is used to build modules for constructing emergency response plan process models based on the rail transit ATS component library. The conversion module 402 is used to respond to the emergency plan triggering command, parse the emergency plan process model, and convert the emergency plan process model into a directed acyclic graph, wherein the nodes in the directed acyclic graph are task nodes; The execution module 403 is used to automatically schedule each task node based on the directed acyclic graph through the workflow engine, and to call the application programming interface (API) of the Train Automatic Monitoring System (ATS) by executing the scripts corresponding to each task node, so as to issue scheduling control instructions to the ATS system.

[0045] In embodiments of the present invention, such as Figure 5 As shown, the rail transit emergency plan visualization and automatic execution system also includes: The visualization layer provides an emergency plan editing interface and an emergency response interface. The emergency plan editing interface is used to build an emergency plan process model by dragging and dropping components. The emergency response interface is used to display a list of plans, trigger the execution of plans, and monitor the execution status. The execution layer is used to receive the triggered plan, convert it into a directed acyclic graph (DAG), and schedule the execution node tasks through the workflow engine. The execution layer is configured to call the API of external systems. The storage layer is used to store predefined ATS component libraries, constructed emergency response plan process models, and plan execution status data.

[0046] For each task node, the DAG (Directed Acyclic Graph) model of Airflow is used to orchestrate Python scripts to automatically trigger the task, which is then sent to the ATS system.

[0047] Visualization layer: It adopts a B / S architecture, with the front end based on Vue3 and the back end based on JeecgBoot. The visualization layer includes two parts: contingency plan editing and emergency response.

[0048] Contingency Plan Editing: An ATS system component library (including stoppage, vehicle impoundment, vehicle addition, extended operation, etc.) and a BPMN process editor enable visual editing of emergency plans, allowing for task node-based management. For each step of the process, forms are generated using a component library, and detailed pages for each step are implemented through drag-and-drop functionality. The entire contingency plan creation process is achieved through visual drag-and-drop functionality.

[0049] Emergency Response: A visual interface is implemented using Vue3 to manage contingency plans, trigger contingency plans, and display execution status.

[0050] Execution layer: After the contingency plan is triggered, for each task node, the DAG (Directed Acyclic Graph) model of Airflow is used to arrange Python scripts to realize the automatic triggering of the task, and finally the task is sent to the ATS system.

[0051] The rail transit emergency plan visualization and automatic execution system provided in this invention constructs an emergency plan process model based on components from the rail transit ATS component library. Responding to a plan trigger command, the system parses the emergency plan process model and converts it into a directed acyclic graph (DAG), where nodes are task nodes. Based on the DAG, the system automatically schedules and executes scripts corresponding to each task node to call the application programming interface (API) of the Automatic Train Monitoring (ATS) system and issue scheduling control commands to the ATS system. This transforms emergency plans from "static documents and manual scheduling" to "visual editing and automatic execution," significantly improving the speed and accuracy of emergency response. By automatically converting the visualized process model into an executable task flow and deeply integrating it with the ATS system, the system solves the problem of difficult cross-system collaboration.

[0052] Figure 6 An example is a schematic diagram of the physical structure of a communication device, such as... Figure 6As shown, the communication device may include a processor 610, a communication interface 620, a memory 630, and a communication bus 640. The processor 610, communication interface 620, and memory 630 communicate with each other via the communication bus 640. The memory 630 includes computer programs, an operating system, and acquired data. The processor 610 can call logical instructions in the memory 630 to execute a method for visualizing and automatically executing rail transit emergency plans. This method includes: constructing an emergency plan process model based on components from a rail transit ATS component library; responding to a plan trigger command, parsing the emergency plan process model, converting the emergency plan process model into a directed acyclic graph (DAG), where nodes in the DAG are task nodes; and automatically scheduling and executing scripts corresponding to each task node based on the DAG to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system.

[0053] Furthermore, the logical instructions in the aforementioned memory 630 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to related technologies, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0054] On the other hand, the present invention also provides a non-transitory readable storage medium storing a computer program thereon. When executed by a processor, the computer program implements the method for visualizing and automatically executing rail transit emergency plans provided by the above methods. The method includes: constructing an emergency plan process model based on components of a rail transit ATS component library; in response to a plan triggering command, parsing the emergency plan process model and converting it into a directed acyclic graph, wherein the nodes in the directed acyclic graph are task nodes; and automatically scheduling and executing the scripts corresponding to each task node based on the directed acyclic graph to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system.

[0055] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0056] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the parts that contribute to the related technology, can be embodied in the form of software products. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0057] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for the visual compilation and automatic execution of emergency response plans for rail transit, characterized in that, include: Emergency response plan process model based on rail transit ATS component library; In response to the contingency plan trigger command, the contingency plan process model is parsed and converted into a directed acyclic graph, where the nodes in the directed acyclic graph are task nodes; Based on the directed acyclic graph, the scripts corresponding to each task node are automatically scheduled and executed to call the application programming interface (API) of the Automatic Train Monitoring System (ATS) and issue scheduling control commands to the ATS system.

2. The method for visualizing and automatically executing emergency plans for rail transit according to claim 1, characterized in that, The component-based emergency response plan process model based on the rail transit ATS component library includes: The visual editing interface provides a graphical editing canvas; In response to the user's drag-and-drop operation on the components in the ATS component library, a corresponding task node is generated in the graphical editing canvas; In response to the user's connection operation, multiple task nodes are connected according to the preset emergency response logic to form a visual emergency plan flowchart; In response to the user's configuration operation on any task node, a parameter configuration form corresponding to the node type is generated, and the execution parameters input by the user are received. The task nodes, logical relationships between nodes, and execution parameters are stored in a structured manner to generate an emergency response plan process model.

3. The method for visualizing and automatically executing rail transit emergency plans according to claim 2, characterized in that, The configuration operation includes at least one of the following: skip station, add train number, origin station, destination station, time and interval time.

4. The method for visualizing and automatically executing rail transit emergency plans according to claim 2, characterized in that, The step of parsing the emergency response plan process model and converting it into a directed acyclic graph includes: Read the structured data of the emergency response plan process model to obtain the logical relationships between nodes; construct a directed acyclic graph based on the multiple task nodes and the logical relationships between the nodes.

5. The method for visualizing and automatically executing rail transit emergency plans according to claim 1, characterized in that, The automatic scheduling and execution of scripts corresponding to each task node based on the directed acyclic graph, in order to call the application programming interface (API) of the Automatic Train Monitoring (ATS) system, includes: Based on the node dependencies defined in the directed acyclic graph (DAG), the execution order of task nodes is determined. According to the execution order, the workflow engine sequentially triggers the execution of the automated scripts corresponding to each task node, and initiates API calls to the Automatic Train Monitoring (ATS) system.

6. The method for visualizing and automatically executing emergency plans for rail transit according to claim 1, characterized in that, Also includes: The overall execution progress of the plan and / or the execution status of individual task nodes are displayed in real time on the visualization interface.

7. A system for visualizing and automatically executing emergency response plans for rail transit, characterized in that, include: The module is used to build emergency response plan process models based on the rail transit ATS component library; The conversion module is used to respond to the emergency plan triggering command, parse the emergency plan process model, and convert the emergency plan process model into a directed acyclic graph, wherein the nodes in the directed acyclic graph are task nodes; The execution module is used to automatically schedule each task node based on the directed acyclic graph through the workflow engine, and to call the application programming interface (API) of the Train Automatic Monitoring System (ATS) by executing the scripts corresponding to each task node, so as to issue scheduling control commands to the ATS system.

8. The rail transit emergency plan visualization and automatic execution system according to claim 7, characterized in that, Also includes: The visualization layer provides an emergency plan editing interface and an emergency response interface. The emergency plan editing interface is used to build an emergency plan process model by dragging and dropping components. The emergency response interface is used to display a list of plans, trigger the execution of plans, and monitor the execution status. The execution layer is used to receive the triggered plan, convert it into a directed acyclic graph (DAG), and schedule the execution node tasks through the workflow engine. The execution layer is configured to call the API of external systems. The storage layer is used to store predefined ATS component libraries, constructed emergency response plan process models, and plan execution status data.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the method for visualizing and automatically executing rail transit emergency plans as described in any one of claims 1 to 6.

10. A non-transitory readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the method for visualizing and automatically executing rail transit emergency plans as described in any one of claims 1 to 6.

Images