A metro 35kV network intelligent self-healing control system and method
By constructing a causal event graph and a formalized contract for self-healing actions, the problem of insufficient traceability and interpretability of the fault propagation process in the 35kV network self-healing control system of the subway was solved, and the accurate location of fault branches and the verifiability of self-healing actions were achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- HEBEI ZHONGRAIL TRANSPORTATION TECH CO LTD
- Filing Date
- 2026-04-16
- Publication Date
- 2026-07-14
AI Technical Summary
The existing 35kV network self-healing control system for subways lacks traceability and interpretability during fault propagation, making it difficult to provide clear propagation path explanations and constraint support in complex propagation links.
The system generates a set of fault events through data acquisition and event processing modules, constructs a causal event graph, parses it into event symbol strings, performs syntax deduction and matching in a preset fault event syntax tree, generates a formal contract for self-healing actions, generates a sequence of self-healing actions by combining distributed constraint game decision-making, and performs closed-loop verification.
It enhances the traceability and interpretability of fault propagation, suppresses misjudgment of fault branches, and realizes the closed-loop verifiability of self-healing control and the ability to adaptively back off and re-decision under abnormal conditions.
Smart Images
Figure CN122393932A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of rail transit power supply system technology, specifically to an intelligent self-healing control system and method for a 35kV subway network. Background Technology
[0002] The 35 kV network of the subway is the high-voltage power distribution backbone network of the subway traction power supply system. It is usually composed of the 35 kV busbars, feeders and switching stations along the line of the traction substation. It is used to reliably send the upstream power supply to each traction power supply section and realize fault isolation and power supply reconstruction in a segmented and zoned manner. Due to the high density and high continuity of subway operation, once an abnormality or fault occurs in the 35 kV network, it will easily cause changes in busbar voltage, feeder current and switch status, resulting in power loss in the section and affecting train traction and station power supply. Therefore, it is necessary to have intelligent self-healing control capabilities that can quickly identify the fault propagation path and implement reasonable control actions after a fault occurs, so as to complete the fault handling and power supply restoration without relying on manual step-by-step analysis and ensure operational safety and continuity.
[0003] In existing technologies, self-healing control typically uses protection action information, switch position signals, and threshold judgments of some electrical quantities as triggering criteria. It combines preset fault handling logic or fixed control strategies to generate isolation and recovery actions, and confirms the results by whether a single device state or a single measurement quantity has recovered. Although this type of implementation can complete basic fault clearing and partial recovery operations, it lacks a unified event-based expression for continuous operating quantities such as bus voltage, feeder current, and switch state, as well as causal propagation constraint modeling across events, because it mostly uses scattered alarms or isolated signals as decision-making criteria. This makes it difficult to form a structured event chain and traceable propagation correlation in the fault evolution process. As a result, there is a problem that the traceability and interpretability of the fault propagation process are insufficient, making it difficult for subsequent self-healing control to provide a clear-based explanation and constraint support for the propagation path when facing complex propagation links. Summary of the Invention
[0004] To address the shortcomings of existing technologies, this invention provides an intelligent self-healing control system and method for a 35kV subway network, which solves the problems of insufficient traceability and interpretability of the fault propagation process.
[0005] To achieve the above objectives, the present invention provides the following technical solution: an intelligent self-healing control system and method for a 35kV subway network, comprising:
[0006] The data acquisition and event processing module is used to collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events.
[0007] The causal event graph construction module is used to construct a causal event graph based on the set of fault events and output the causal propagation relationship between the fault events;
[0008] The event parsing module is used to parse the set of fault events into event symbol strings;
[0009] The fault event syntax tree localization module is used to perform syntax deduction and matching on the event symbol string in a preset fault event syntax tree based on the causal propagation relationship, thereby determining the current fault branch state;
[0010] The self-healing action formal contract generation module is used to generate a self-healing action formal contract for candidate self-healing actions. The self-healing action formal contract includes preconditions, post-event signatures, and prohibited branch constraints, and the preconditions and prohibited branch constraints are determined by the current fault branch state.
[0011] The legal action filtering module is used to filter and obtain a set of legal actions based on the causal event graph and the formal contract of the self-healing action.
[0012] A distributed constrained game decision-making module is used to generate a self-healing action sequence within the set of legal actions.
[0013] The contract constraint execution and event closed-loop verification module is used to execute the self-healing action sequence and perform closed-loop verification on the execution result based on the post-event signature. If the post-event signature is not satisfied, the self-healing action sequence is regenerated.
[0014] Preferably, generating the fault event set includes the following steps:
[0015] The collected continuous measurements are segmented according to a preset sampling time window, and bus voltage abnormality events, feeder current abnormality events, and switch status change events are identified based on preset event triggering rules.
[0016] The identified abnormal events are encapsulated according to event type, occurrence time, and occurrence location to form the fault event set.
[0017] Preferably, the construction of the causal event graph includes the following steps:
[0018] The fault events in the fault event set are sorted according to their occurrence time. The adjacency association range between each fault event is determined based on the electrical topology association relationship of the 35kV metro network. Within the adjacency association range, candidate causal edges are generated according to the temporal relationship of the fault events.
[0019] The candidate causal edges are judged for causal consistency, and causal edges that do not conform to the fault propagation logic are filtered out. The remaining valid causal edges and their corresponding fault events are used to form the causal event graph, and the causal propagation relationship between the fault events is output.
[0020] Preferably, the parsing into an event symbol string includes the following steps:
[0021] The fault events in the fault event set are sequentially arranged according to their occurrence time. Corresponding event symbol mapping rules are preset for different types of fault events. Each fault event is converted into a corresponding event symbol according to the event symbol mapping rules. The converted event symbols are then concatenated in the order of the fault events to form the event symbol string.
[0022] Preferably, determining the current faulty branch status includes the following steps:
[0023] Multiple fault propagation branches and corresponding event symbol derivation rules are preset in the preset fault event syntax tree. The event symbol string is input into the preset fault event syntax tree for syntax derivation and matching. The fault propagation path corresponding to the event symbol string is determined by combining the causal propagation relationship. The syntax branch that is consistent with the fault propagation path is located in the preset fault event syntax tree. The located syntax branch is taken as the current fault branch state, and the current fault branch state is used as the syntax constraint basis for the self-healing action generation.
[0024] Preferably, the generation of the formal contract for self-healing actions includes the following steps:
[0025] A preset set of candidate self-healing actions is provided, including transfer actions, loop closing actions, segmentation actions, and load splitting actions. Based on the current fault branch state, the fault branch state that must be met before the execution of each candidate self-healing action is determined as the prerequisite.
[0026] Based on the causal event graph, the causal propagation relationships that must not be broken during the execution of each candidate self-healing action are determined as the causal consistency constraint.
[0027] Pre-defined fault event patterns that must be observed after each candidate self-healing action is executed, which serve as the post-event signature;
[0028] In the preset fault event syntax tree, determine the fault propagation branch that is prohibited from entering after each candidate self-healing action is executed, and use it as the prohibited branch constraint;
[0029] The preconditions, post-event signatures, and prohibited branch constraints are encapsulated to form the formal contract of the self-healing action.
[0030] Preferably, the process of filtering to obtain a set of legal actions includes the following steps:
[0031] Obtain the candidate self-healing action set and the corresponding formal contract of the self-healing action. Perform causal consistency verification on each candidate self-healing action based on the causal event graph, and exclude actions that do not meet the causal consistency verification. Determine the executable actions under the current fault branch state based on the preconditions of the formal contract of the self-healing action. Exclude actions that may enter the prohibited fault propagation branch after execution based on the prohibited branch constraints of the formal contract of the self-healing action. Gather the candidate self-healing actions that have passed the verification and constraint screening to form the legal action set.
[0032] Preferably, the generation of the self-healing action sequence includes the following steps:
[0033] A distributed collaborative decision-making communication relationship is established among multiple switch station control units. Each switch station control unit obtains the legal action set corresponding to its local location. Based on the distributed constraint game collaborative decision-making rules, the actions in the legal action set are combined and selected. During the action combination selection process, the preconditions of the formal contract of the self-healing action are consistently satisfied with the prohibited branch constraints. The action combination that satisfies the constraint consistency is output, and the self-healing action sequence is formed according to the execution order.
[0034] Preferably, the closed-loop verification of the execution result based on the post-event signature includes the following steps:
[0035] The self-healing actions in the sequence are executed sequentially, and new fault events are collected and the fault event set is updated in real time after each self-healing action is executed.
[0036] The newly added fault event is matched with the post-event signature of the formal contract of the corresponding self-healing action. If the newly added fault event satisfies the post-event signature, the next self-healing action is executed. If the newly added fault event does not satisfy the post-event signature, the self-healing action sequence is regenerated, and the process returns to the step of filtering to obtain a set of legal actions to regenerate the self-healing action sequence.
[0037] Preferably, a method for intelligent self-healing control of a 35kV subway network includes the following steps:
[0038] S1. Collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events;
[0039] S2. Construct a causal event graph based on the set of fault events, and parse the set of fault events into event symbol strings;
[0040] S3. Combine the causal event graph to perform syntax deduction and matching on the event symbol string in the preset fault event syntax tree, thereby determining the current fault branch state;
[0041] S4. Generate a formal contract for self-healing actions for candidate self-healing actions. The formal contract for self-healing actions includes preconditions, post-event signatures and prohibited branch constraints, and then filter to obtain a set of legal actions.
[0042] S5. Generate a self-healing action sequence through distributed constraint game collaborative decision-making within the set of legal actions;
[0043] S6. Execute the self-healing action sequence and perform closed-loop verification on the execution result based on the post-event signature. If the post-event signature is not satisfied, trigger the regeneration of the self-healing action sequence.
[0044] This invention provides an intelligent self-healing control system and method for a 35kV subway network. It has the following beneficial effects:
[0045] 1. This invention processes bus voltage, feeder current and switch status into a set of fault events, and further constructs a causal event graph to output causal propagation relationships, so that the fault evolution is transformed from a continuous quantity into a structured event chain and propagation constraints, thereby enhancing the traceability and explainability of fault propagation.
[0046] 2. This invention parses the set of fault events into event symbol strings and combines them with causal propagation relationships to perform syntax deduction and matching in a preset fault event syntax tree to determine the current fault branch state. This allows self-healing control to be carried out under clear fault branch constraints, thereby suppressing misjudgment of fault branches and the resulting erroneous recovery path selection.
[0047] 3. This invention generates a formal contract for self-healing actions that includes preconditions, post-event signatures, and prohibited branch constraints for candidate self-healing actions. This contract is then applied to the screening of legal actions, collaborative decision-making in distributed constraint games, and closed-loop verification of post-event signatures after execution. When the post-event signature is not satisfied, the self-healing action sequence is regenerated, thereby enhancing the verifiability of the closed loop of the self-healing action execution process and the ability to adaptively backtrack and re-decision in abnormal situations. Attached Figure Description
[0048] Figure 1 This is a system architecture diagram of the present invention;
[0049] Figure 2 This is a flowchart of the method of the present invention. Detailed Implementation
[0050] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0051] Example 1
[0052] This invention provides an intelligent self-healing control system for a 35kV subway network, comprising:
[0053] The data acquisition and event processing module is used to collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events.
[0054] Furthermore, generating a set of fault events includes the following steps:
[0055] The collected continuous measurements are segmented according to a preset sampling time window, and bus voltage abnormality events, feeder current abnormality events, and switch status change events are identified based on preset event triggering rules.
[0056] The identified abnormal events are encapsulated according to event type, occurrence time, and occurrence location to form a fault event set.
[0057] Specifically, the data acquisition and event processing module is deployed at the switching station or traction substation side of the subway power supply network to continuously monitor bus voltage, feeder current, and switch status. The acquired continuous measurements are segmented into time windows, forming corresponding state segments for voltage, current, and switch status within each time window. Abnormal states are identified according to preset event triggering rules. When the bus voltage deviates abnormally, the feeder current changes abruptly, or the switch status jumps, a corresponding abnormal event is generated. Event triggering can be represented as a mapping relationship between the input measurement and the triggering criterion, i.e., for any bus voltage sequence within a sampling time window... With feeder current sequence If the event discrimination function is satisfied Then output the exception event. ,in, Indicates the switch status. This represents an event discrimination function based on preset triggering rules, which outputs the event. It includes attributes such as event type, occurrence time, and occurrence location, thereby transforming continuous operational quantities into discrete fault events. Various abnormal events are encapsulated and aggregated according to event type, occurrence time, and occurrence location to form a fault event set, enabling the system to describe events with a unified event input. The network failure evolution process enabled the monitoring of the subway. The structured representation of network malfunctions enables direct fault branch localization and self-healing control sequence generation based on a set of fault events.
[0058] The causal event graph construction module is used to construct a causal event graph based on a set of fault events and output the causal propagation relationships between fault events.
[0059] Furthermore, constructing a causal event graph includes the following steps:
[0060] The fault events in the fault event set are sorted according to their occurrence time. The adjacency association range between each fault event is determined based on the electrical topology association relationship of the 35kV metro network. Within the adjacency association range, candidate causal edges are generated according to the time sequence of the fault events.
[0061] Perform causal consistency judgment on candidate causal edges, filter out causal edges that do not conform to the fault propagation logic, and construct a causal event graph together with the retained valid causal edges and corresponding fault events, and output the causal propagation relationship between fault events.
[0062] Specifically, after obtaining the set of fault events output by the data acquisition and event processing module, the fault events are sorted according to their occurrence time, and the set of fault events is represented as follows: Each fault event Corresponding to actual operational phenomena such as abnormal bus voltage, abnormal feeder current, or changes in switch status, and including the attributes of occurrence time and location, a set of candidate causal edges is generated within the topological adjacency range based on the temporal relationship of the events. and Representing events respectively With the event The occurrence time of the fault and the candidate causal edges reflect the possible propagation direction of the fault in the power supply network. Causal consistency is determined on the candidate causal edges to filter out associations that do not conform to the fault propagation logic. This consistency determination can be achieved through a causal discrimination function. Achieve, when Preserve causal edges when Causal edges are removed periodically, and the remaining valid causal edges, together with their corresponding failure events, form a causal event graph. ,in This represents the set of valid causal edges and outputs the causal propagation relationships between fault events, enabling the system to characterize the subway in a graph form. The propagation path of network failure events provides a traceable causal constraint basis for subsequent syntax tree branch location and self-healing action selection.
[0063] The event parsing module is used to parse a set of fault events into event symbol strings;
[0064] Furthermore, parsing into an event symbol string includes the following steps:
[0065] The fault events in the fault event set are sequentially arranged according to their occurrence time. Corresponding event symbol mapping rules are preset for different types of fault events. Each fault event is converted into a corresponding event symbol according to the event symbol mapping rules. The converted event symbols are then concatenated in the order of the fault events to form an event symbol string.
[0066] Specifically, the event parsing module, based on the fault event graph construction module's already formed fault event set and completed time-consistent sorting, further transforms the fault event set into event symbol strings that can be used for syntax deduction and matching using a preset fault event syntax tree. The fault event set is first represented as... Each fault event Corresponding subway Network events such as abnormal bus voltage, abnormal feeder current, or switch status changes are included, along with their occurrence time attributes to ensure the uniqueness of the serialized sequence. The event parsing module analyzes these events based on their occurrence time. Serialization yields an ordered sequence of events. in, This indicates the number after sorting by occurrence time. Each fault event: Then, pre-define event symbol mapping rules for different types of fault events. The mapping rules can be represented as mapping functions. This allows each fault event to be converted into a unique event symbol, i.e. in, Indicates fault events The corresponding event symbols are used to represent the type of fault event and maintain consistency with the location and time of occurrence. Finally, the corresponding event symbols are concatenated in chronological order according to the ordered event sequence to form an event symbol string. in, The output event symbol string serves as the input for the subsequent fault event syntax tree localization module to perform syntax deduction and matching, thereby enabling the system to represent the subway with a unified symbol sequence. The network's fault evolution process ensures the consistency of the order and type of fault events in syntax derivation.
[0067] The fault event syntax tree localization module is used to perform syntax deduction and matching of event symbol strings in a preset fault event syntax tree based on causal propagation relationships, thereby determining the current fault branch state.
[0068] Further, determining the current faulty branch status includes the following steps:
[0069] Multiple fault propagation branches and corresponding event symbol derivation rules are preset in the preset fault event syntax tree. The event symbol string is input into the preset fault event syntax tree for syntax derivation and matching. The fault propagation path corresponding to the event symbol string is determined by combining the causal propagation relationship. The syntax branch that is consistent with the fault propagation path is located in the preset fault event syntax tree. The located syntax branch is taken as the current fault branch state, and the current fault branch state is used as the syntax constraint basis for the self-healing action generation.
[0070] Specifically, based on the event parsing module outputting the event symbol string and the causal event graph construction module outputting the causal propagation relationship, the time-ordered symbol sequence formed by the bus voltage anomaly event, feeder current anomaly event, and switch state change event is matched with the fault propagation branch in the preset fault event syntax tree to obtain the current fault branch state, which serves as the grammatical constraint basis for the subsequent self-healing action generation. In specific implementation, the preset fault event syntax tree describes the reachable propagation structure of the fault from the initial anomaly to the protection action and then to the power supply state change through a set of event symbol derivation rules. The preset fault event syntax tree can be represented in set form as follows:
[0071] ;
[0072] in, Represents the set of fault propagation branch nodes. Represents a set of event symbols. This represents the set of rules for deducing event symbols. Indicates the starting fault node; the event symbol string is output by the event parsing module and denoted as...
[0073] ;
[0074] in Indicates connection with subway The event symbols corresponding to a certain type of fault event in the network are kept consistent with the chronological order of the fault events; the causal propagation relationship is output by the causal event graph construction module and denoted as...
[0075] ;
[0076] in, Represents the set of fault events, and each causal pair represents the event in the subway. Based on the propagation sequence within the electrical topology adjacency range, the fault event syntax tree localization module extracts a set of fault propagation paths consistent with the event symbol string from the causal propagation relationship and records them as:
[0077] ;
[0078] The event symbol string is then subjected to syntax deduction matching in a preset fault event syntax tree to determine whether it can be deduced from the starting fault node. The syntax deduction matching can be represented by the reachability criterion as follows:
[0079] ;
[0080] in, The value of 1 indicates that the event symbol string can be found in the inference rule set. The following is derived from the initial fault node. This represents a multi-step derivation relation based on a set of derivation rules; furthermore, to ensure that the grammatical derivation results are consistent with actual subway data... The network's fault propagation chain is consistent, and the module limits the syntax deduction matching to the set of fault propagation paths. On consistent branches, a branch consistency determination is formed and denoted as:
[0081] and ;
[0082] Make The corresponding event sequence and When the branch consistency determination is successful, locate the syntax branch in the preset fault event syntax tree that is consistent with the fault propagation path and output it as the current fault branch state. The current fault branch state is denoted as:
[0083] ;
[0084] in, This represents the process of branching and locating within a predefined fault event syntax tree based on the event symbol string and the fault propagation path, and the output is... Corresponding to a certain fault propagation branch and used to define the preconditions and prohibited branches of the formal contract for subsequent self-healing actions, the generation of self-healing actions is no longer based solely on isolated events but is influenced by the subway. The network causal propagation chain and syntactic branches jointly constrain the process, thereby structuring the fault evolution process into a localizable branch state in engineering implementation.
[0085] The self-healing action formal contract generation module is used to generate self-healing action formal contracts for candidate self-healing actions. The self-healing action formal contract includes preconditions, post-event signatures, and prohibited branch constraints, and the preconditions and prohibited branch constraints are determined by the current fault branch state.
[0086] Furthermore, generating a formal contract for self-healing actions includes the following steps:
[0087] A set of candidate self-healing actions is preset. The candidate self-healing actions include transfer actions, loop closing actions, segmentation actions, and load splitting actions. Based on the current fault branch state, the fault branch state that must be met before the action of each candidate self-healing action is executed is determined as a prerequisite.
[0088] Based on the causal event graph, the causal propagation relationships that must not be broken during the execution of each candidate self-healing action are determined as causal consistency constraints.
[0089] Pre-determine the fault event patterns that must be observed after the execution of each candidate self-healing action, as a post-event signature;
[0090] In the preset fault event syntax tree, identify the fault propagation branches that are prohibited from being entered after each candidate self-healing action is executed, and use them as prohibited branch constraints.
[0091] The preconditions, post-event signatures, and prohibited branch constraints are encapsulated to form a self-healing action formal contract.
[0092] Specifically, the preset set of candidate self-healing actions is denoted as... , of which each For corresponding transfer actions, loop closing actions, segmented actions, or load splitting actions, the current fault branch status is given by the syntax tree branch location result and recorded as follows: The causal propagation relationships are given by the causal event graph and denoted as:
[0093] ;
[0094] in, and The fault event in the fault event set and This indicates that within the electrical topology adjacency range, events occurring earlier have propagation constraints on subsequent events. The formal contract for self-healing actions specifies a contract for each candidate self-healing action. Generate a set of contract elements and encapsulate them as
[0095] ;
[0096] in, Indicates preconditions Indicates post-event signature This indicates a prohibited branch constraint, where the precondition is determined by the current failed branch state and can be represented as follows:
[0097] ;
[0098] in, This represents the action permission mapping rules based on syntax branches and allows actions to be performed only when they are associated with... Consistent fault branch states can be selected by subsequent modules. Post-event signatures are used to characterize the fault event patterns that must be observed after the action is executed and can be represented as:
[0099] ;
[0100] in The preset mapping rule representing the action-to-event pattern outputs a combination pattern of bus voltage anomaly events, feeder current anomaly events, or switch state change events that can be collected and eventified in the subway power supply network. The prohibited branch constraint is determined by the set of reachable branches of the current fault branch state in the preset fault event syntax tree and can be represented as:
[0101] ;
[0102] in, This represents the mapping rules from actions to prohibited fault propagation branches and is used to restrict actions from entering syntactic branches that conflict with the current fault propagation logic. Simultaneously, the module utilizes causal propagation relationships to perform constraint checks on the causal consistency of actions, which can be represented as... ,in, This represents a causal consistency discriminant function, meaning that the execution of an action will not introduce causal consistency. The contradictory sequence of events ensures consistency between the actions and the identified fault propagation correlations, ultimately satisfying the causal consistency judgment. and The self-healing action is encapsulated into a formal contract and output to the legal action filtering module. Since the contract carries the permission conditions before the action, the observable signature after the action, and the branch prohibition constraint, the system can realize the inspectable expression of the candidate self-healing action without changing the on-site data collection object.
[0103] The legitimate action filtering module is used to filter and obtain a set of legitimate actions based on the causal event graph and the formalized contract of self-healing actions.
[0104] Furthermore, the process of filtering to obtain the set of legal actions includes the following steps:
[0105] Obtain a set of candidate self-healing actions and their corresponding formal contracts. Perform causal consistency verification on each candidate self-healing action based on the causal event graph, and exclude actions that do not meet the causal consistency verification. Determine the executable actions under the current fault branch state based on the preconditions of the formal contracts of the self-healing actions. Exclude actions that may enter the prohibited fault propagation branch after execution based on the prohibited branch constraints of the formal contracts of the self-healing actions. Gather the candidate self-healing actions that have passed the verification and constraint screening to form a set of legal actions.
[0106] Specifically, the set of candidate self-healing actions is denoted as... Each action corresponds to a transfer action, a loop-closing action, a segmented action, or a load-splitting action. The formal contract for the self-healing action assigns a contract object to each action and is denoted as:
[0107] ;
[0108] in, As a prerequisite Signing post-events To prohibit branch constraints, the causal event graph is denoted as... ,in, It is a set of fault events, and each fault event corresponds to an observable event in the metro power supply network, such as an abnormal bus voltage event, an abnormal feeder current event, or a switch status change event. To establish the causal propagation relationships between fault events, the legitimate action filtering module first performs causal consistency verification on actions based on the causal event graph and represents it using a discriminant function: ,in, The input includes candidate self-healing actions With causal event graph Furthermore, an output of one indicates that the action is consistent with the current fault propagation, while an output of zero indicates inconsistency, thus eliminating actions that do not meet the causal consistency check. Subsequently, the module performs a satisfaction judgment on the preconditions based on the current fault branch state and expresses this judgment function as follows: ,in, The current fault branch status output by the fault event syntax tree location module and An output of 1 indicates that the precondition for the action is met in the current branch state, while an output of zero indicates that it is not met, thus filtering out actions that cannot be executed in the current faulty branch state; the module performs an exclusionary judgment on the branch risk of actions based on the prohibited branch constraint and expresses it as a decision function. ,in An output of 1 indicates that the action will not enter the prohibited fault propagation branch under the current fault branch state; an output of zero indicates that there is a possibility of entering the prohibited fault propagation branch, thus eliminating actions that violate the prohibited branch constraint. After the above causal consistency check and contract constraint judgment both pass, the module gathers the actions that meet the conditions to form a set of legal actions and represents it as:
[0109] ;
[0110] in, The output set of legal actions corresponds, in an engineering sense, to the range of self-healing operation candidates that can be executed under the current fault evolution branch of the subway high-voltage power supply network, and satisfies the consistency requirements of causal propagation correlation and branch prohibition constraints. This enables the subsequent distributed constraint game decision module to generate a self-healing action sequence only within the set of legal actions and form a coherent closed loop with the contract constraint execution and event closed-loop verification module, thereby achieving interpretable constraints and achievable convergence for the self-healing action selection process.
[0111] The distributed constrained game decision-making module is used to generate self-healing action sequences within the set of legal actions.
[0112] Furthermore, generating the self-healing action sequence includes the following steps:
[0113] A distributed collaborative decision-making communication relationship is established among multiple switch station control units. Each switch station control unit obtains its local set of legal actions and selects actions from the legal action set based on the distributed constraint game collaborative decision-making rules. During the action combination selection process, the preconditions of the formal contract of the self-healing action are consistently satisfied with the prohibited branch constraints. The action combination that satisfies the constraint consistency is output and a self-healing action sequence is formed according to the execution order.
[0114] Specifically, a distributed collaborative decision-making communication relationship is established among multiple switch station control units. This enables each switch station control unit to obtain its local set of legal actions based on the switch status and power supply section under its jurisdiction, and to participate in the generation of joint action combinations. The set of switch station control units is denoted as... Each control unit The corresponding set of local legal actions is denoted as And satisfy ,in, This represents the set of legal actions output by the legal action filtering module. The distributed collaborative decision-making communication relationship is used to exchange proposals for joint actions from each control unit and form a consistent combination of joint actions. The combination of joint actions is denoted as... ,in, Indicates control unit The chosen action, based on the distributed constraint game collaborative decision-making rule, takes the consistency of contract fulfillment as the core constraint and represents the feasibility of the action as a feasibility judgment function. ,in, A value of 1 indicates that the combination of joint actions satisfies the formal contract constraint of the self-healing action, while a value of zero indicates that it does not. The formal contract of the self-healing action applies to each action. Give the contract object ,in, As a prerequisite Signing post-events To disable branch constraints, the current fault branch state is output by the fault event syntax tree localization module and recorded as... Therefore, the feasibility of a combination of actions can be characterized by the following consistent satisfaction relation. ,in, This indicates the condition satisfaction determination, and its input is the action precondition and the current fault branch state, and the output is whether execution is allowed. This indicates a prohibited branch constraint determination, with inputs being the prohibited branch constraint and the current faulty branch state, and outputting whether there is a risk of entering a prohibited fault propagation branch. Distributed constraint game collaborative decision-making rules continuously filter out such constraints during communication and exchange. Combinations of actions with values of zero to form a set that satisfy... The combination of joint actions with a value of one is then arranged according to their execution order to form a self-healing action sequence, which is denoted as:
[0115] ;
[0116] in, The output is a self-healing action sequence, with each item being the action selection result from a certain control unit. This makes the generation of the self-healing action sequence independent of the global assumption of a single-point control unit. Instead, it is an action sequence generated and executed under the cooperative communication of multiple switch station control units, with the legal action set as the action space and the preconditions and prohibited branch constraints of the self-healing action formal contract as consistency constraints.
[0117] The contract constraint execution and event closed-loop verification module is used to execute the self-healing action sequence and perform closed-loop verification on the execution result based on the post-event signature. If the post-event signature is not satisfied, the self-healing action sequence is regenerated.
[0118] Furthermore, closed-loop verification of the execution result based on the post-event signature includes the following steps:
[0119] Execute the self-healing actions in sequence, and collect new fault events and update the fault event set in real time after each self-healing action is executed.
[0120] The newly added fault event is matched with the post-event signature of the formal contract of the corresponding self-healing action. If the newly added fault event satisfies the post-event signature, the next self-healing action is executed. If the newly added fault event does not satisfy the post-event signature, the self-healing action sequence is regenerated, and the process returns to the step of obtaining the set of legal actions to regenerate the self-healing action sequence.
[0121] Specifically, the self-healing action sequence is issued to the corresponding switch station control unit for execution according to a predetermined execution order. After each self-healing action is completed, the data acquisition and event processing module continues to collect data on bus voltage, feeder current, and switch status, thereby forming new fault events relative to the action execution time and updating the fault event set. This ensures that closed-loop verification is always based on observable events on-site. To establish a correspondence between the abstract post-event signature and the actual measurement data of the metro power supply network, the post-event signature is defined as a fault event pattern that must be observed after the action is executed. This fault event pattern is extracted and encapsulated from the aforementioned event processing process from bus voltage abnormality events, feeder current abnormality events, and switch status change events. Therefore, closed-loop verification takes the new fault event as input and the corresponding post-event signature as the output criterion, and records the new fault event set as... And record the post-event signature in the formalized contract of the corresponding self-healing action as The module uses a matching judgment function:
[0122] ;
[0123] Determine whether the newly added fault event satisfies the signature of the subsequent event, where, The input is a new set of fault events and the signature of the subsequent events, and the output is whether the match is true or false. When the match is true, the module continues to trigger the next self-healing action in the self-healing action sequence and repeats the process of collecting new fault events and updating the fault event set. When the match is false, the module does not continue to advance the subsequent actions, but triggers the regeneration of the self-healing action sequence and returns to the step of filtering to obtain a set of legal actions. This allows the system to re-filter the set of legal actions based on the updated set of fault events and the existing causal propagation relationship in the same fault evolution context and generate a new set of self-healing actions. This forms a closed-loop control link with the action execution result as feedback, transforming the execution of the self-healing action sequence from a one-time interruption operation into a process of step-by-step execution and verification. This avoids continuing to execute actions that may cause the fault propagation branch to deviate when the field state is inconsistent with the expectation. At the same time, by triggering regeneration, the decision can adaptively return to the legal action filtering and decision-making stage based on the latest new fault events.
[0124] Example 2
[0125] This invention provides an intelligent self-healing control method for a 35kV subway network, comprising the following steps:
[0126] S1. Collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events;
[0127] S2. Construct a causal event graph based on the set of fault events, and parse the set of fault events into event symbol strings;
[0128] S3. Combine the causal event graph to perform syntax deduction and matching on the event symbol string in the preset fault event syntax tree, thereby determining the current fault branch state;
[0129] S4. Generate a formal contract for self-healing actions for the candidate self-healing actions. The formal contract for self-healing actions includes preconditions, post-event signatures and prohibited branch constraints, and then filter to obtain a set of legal actions.
[0130] S5. Generate a self-healing action sequence through distributed constraint game collaborative decision-making within the set of legal actions;
[0131] S6. Execute the self-healing action sequence and perform closed-loop verification of the execution result based on the post-event signature. If the post-event signature is not satisfied, trigger the regeneration of the self-healing action sequence.
[0132] Specifically, firstly, continuous operational data is collected and converted into fault events with occurrence time and location attributes according to preset event triggering rules, forming a fault event set as a unified entry point for subsequent reasoning and decision-making. Then, a causal event graph is constructed based on this fault event set to characterize the propagation relationship between fault events within the electrical topology adjacency range. Within the same temporal framework, the fault event set is parsed into event symbol strings to interface with the derivation rules of the preset fault event syntax tree. Based on this, the event symbol strings, combined with the causal propagation relationship output by the causal event graph, are input into the preset fault event syntax tree for syntax derivation matching, thereby locating the syntax branch consistent with the actual propagation chain and determining the current fault branch state, enabling the system to obtain branch state semantics that can directly constrain the selection of self-healing actions. Next, a formal contract for self-healing actions is generated for candidate self-healing actions, and a set of legal actions is obtained through this selection. The formal contract for self-healing actions includes preconditions, post-event signatures, and prohibited branch constraints. Preconditions and prohibited branch constraints are determined by the current fault branch state, subjecting candidate actions to dual constraints of branch permission and prohibition before entering the decision-making stage. Simultaneously, the consistency of the action-fault propagation relationship is constrained by the causal event graph, thus forming a set of legal actions executable under the current fault branch state. Subsequently, within this set of legal actions, multiple switch station control units generate a self-healing action sequence through distributed constraint game collaborative decision-making. This sequence satisfies contractual constraints and aligns with the field executable boundary under distributed communication collaboration. Finally, the self-healing action sequence is executed sequentially, and after each action, bus voltage, feeder current, and switch status are continuously collected to generate new fault events and update the fault event set. The new fault events are matched with the post-event signatures in the corresponding action contract to complete closed-loop verification. If the match fails, the self-healing action sequence is regenerated, and the system returns to the legal action set generation and decision-making stage, allowing the system to reconverge the action space and action sequence based on the latest event state.
[0133] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.
Claims
1. A smart self-healing control system for a 35kV subway network, characterized in that, include: The data acquisition and event processing module is used to collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events. The causal event graph construction module is used to construct a causal event graph based on the set of fault events and output the causal propagation relationship between the fault events; The event parsing module is used to parse the set of fault events into event symbol strings; The fault event syntax tree localization module is used to perform syntax deduction and matching of the event symbol string in a preset fault event syntax tree based on the causal propagation relationship, thereby determining the current fault branch state; The self-healing action formal contract generation module is used to generate a self-healing action formal contract for candidate self-healing actions. The self-healing action formal contract includes preconditions, post-event signatures, and prohibited branch constraints, and the preconditions and prohibited branch constraints are determined by the current fault branch state. The legal action filtering module is used to filter and obtain a set of legal actions based on the causal event graph and the formal contract of the self-healing action. A distributed constrained game decision-making module is used to generate a self-healing action sequence within the set of legal actions. The contract constraint execution and event closed-loop verification module is used to execute the self-healing action sequence and perform closed-loop verification on the execution result based on the post-event signature. If the post-event signature is not satisfied, the self-healing action sequence is regenerated.
2. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The generation of the fault event set includes the following steps: The collected continuous measurements are segmented according to a preset sampling time window, and bus voltage abnormality events, feeder current abnormality events, and switch status change events are identified based on preset event triggering rules. The identified abnormal events are encapsulated according to event type, occurrence time, and occurrence location to form the fault event set.
3. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The construction of the causal event graph includes the following steps: The fault events in the fault event set are sorted according to their occurrence time. The adjacency association range between each fault event is determined based on the electrical topology association relationship of the 35kV metro network. Within the adjacency association range, candidate causal edges are generated according to the temporal relationship of the fault events. The candidate causal edges are judged for causal consistency, and causal edges that do not conform to the fault propagation logic are filtered out. The remaining valid causal edges and their corresponding fault events are used to form the causal event graph, and the causal propagation relationship between the fault events is output.
4. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The parsing into an event symbol string includes the following steps: The fault events in the fault event set are sequentially arranged according to their occurrence time. Corresponding event symbol mapping rules are preset for different types of fault events. Each fault event is converted into a corresponding event symbol according to the event symbol mapping rules. The converted event symbols are then concatenated in the order of the fault events to form the event symbol string.
5. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, Determining the current faulty branch status includes the following steps: Multiple fault propagation branches and corresponding event symbol derivation rules are preset in the preset fault event syntax tree. The event symbol string is input into the preset fault event syntax tree for syntax derivation and matching. The fault propagation path corresponding to the event symbol string is determined by combining the causal propagation relationship. The syntax branch that is consistent with the fault propagation path is located in the preset fault event syntax tree. The located syntax branch is taken as the current fault branch state, and the current fault branch state is used as the syntax constraint basis for the self-healing action generation.
6. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The generation of the formal contract for self-healing actions includes the following steps: A preset set of candidate self-healing actions is provided, including transfer actions, loop closing actions, segmentation actions, and load splitting actions. Based on the current fault branch state, the fault branch state that must be met before the execution of each candidate self-healing action is determined as the prerequisite. Based on the causal event graph, the causal propagation relationships that must not be broken during the execution of each candidate self-healing action are determined as the causal consistency constraint. Pre-defined fault event patterns that must be observed after each candidate self-healing action is executed, which serve as the post-event signature; In the preset fault event syntax tree, determine the fault propagation branch that is prohibited from entering after each candidate self-healing action is executed, and use it as the prohibited branch constraint; The preconditions, post-event signatures, and prohibited branch constraints are encapsulated to form the formal contract of the self-healing action.
7. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The process of filtering to obtain a set of legal actions includes the following steps: Obtain the candidate self-healing action set and the corresponding formal contract of the self-healing action. Perform causal consistency verification on each candidate self-healing action based on the causal event graph, and exclude actions that do not meet the causal consistency verification. Determine the executable actions under the current fault branch state based on the preconditions of the formal contract of the self-healing action. Exclude actions that may enter the prohibited fault propagation branch after execution based on the prohibited branch constraints of the formal contract of the self-healing action. Gather the candidate self-healing actions that have passed the verification and constraint screening to form the legal action set.
8. The intelligent self-healing control system for a 35kV subway network according to claim 1, characterized in that, The generation of the self-healing action sequence includes the following steps: A distributed collaborative decision-making communication relationship is established among multiple switch station control units. Each switch station control unit obtains the legal action set corresponding to its local location. Based on the distributed constraint game collaborative decision-making rules, the actions in the legal action set are combined and selected. During the action combination selection process, the preconditions of the formal contract of the self-healing action are consistently satisfied with the prohibited branch constraints. The action combination that satisfies the constraint consistency is output, and the self-healing action sequence is formed according to the execution order.
9. A 35kV network intelligent self-healing control system for subways according to claim 1, characterized in that, The closed-loop verification of the execution result based on the post-event signature includes the following steps: The self-healing actions in the sequence are executed sequentially, and new fault events are collected and the fault event set is updated in real time after each self-healing action is executed. The newly added fault event is matched with the post-event signature of the formal contract of the corresponding self-healing action. If the newly added fault event satisfies the post-event signature, the next self-healing action is executed. If the newly added fault event does not satisfy the post-event signature, the self-healing action sequence is regenerated, and the process returns to the step of filtering to obtain a set of legal actions to regenerate the self-healing action sequence.
10. A method for intelligent self-healing control of a 35kV subway network, characterized in that, The intelligent self-healing control system for a 35kV subway network as described in claims 1-9 includes the following steps: S1. Collect bus voltage, feeder current and switch status of the 35kV metro network and generate a set of fault events; S2. Construct a causal event graph based on the set of fault events, and parse the set of fault events into event symbol strings; S3. Combine the causal event graph to perform syntax deduction and matching on the event symbol string in the preset fault event syntax tree, thereby determining the current fault branch state; S4. Generate a formal contract for self-healing actions for candidate self-healing actions. The formal contract for self-healing actions includes preconditions, post-event signatures and prohibited branch constraints, and then filter to obtain a set of legal actions. S5. Generate a self-healing action sequence through distributed constraint game collaborative decision-making within the set of legal actions; S6. Execute the self-healing action sequence and perform closed-loop verification on the execution result based on the post-event signature. If the post-event signature is not satisfied, trigger the regeneration of the self-healing action sequence.