Business process visualization simulation method

Abstract

The invention discloses a business process visualization simulation method, and particularly relates to the technical field of business process visualization. Constructing a task dependency graph and a task path, calculating a task causal strength factor CIF and time drift tolerance TDT based on historical log data, recording a task event sequence in a simulation operation process, and judging whether the task has a causal relationship disorder behavior or not in real time; when the three conditions that the task is executed in advance, the offset exceeds TDT and the CIF is higher than a set threshold value are met, it is judged that the event is a causal disorder event, and dynamic adjustment processing is started; meanwhile, the detection result and the adjustment feedback are visually displayed in real time, a cause and effect consistency scoring model is constructed, and a process structure optimization suggestion is output; the method has the advantages of being high in disorder recognition precision, flexible in adjustment mechanism, closed in feedback path and the like, and is suitable for modeling and simulation platforms of various complex business processes.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of business process visualization, in particular to a business process visualization simulation method. BACKGROUND

[0002] The business process visualization simulation method refers to clearly displaying the business processes of an enterprise or organization in a graphical manner, and combining simulation technology to analyze the running of the processes. This method can help users intuitively understand the various links of the processes, resource allocation and execution logic, and predict the running effect of the processes under different conditions through simulation, thereby assisting in optimizing decisions, improving efficiency and discovering potential problems.

[0003] In the prior art, when simulating tasks are dynamically executed in chronological order, the event causal chain may be disordered. This situation often occurs in concurrent simulation or complex processes (such as containing nested sub-processes and parallel tasks), and due to the defects of the scheduling mechanism, some tasks may be triggered in advance, causing subsequent tasks to be executed before the preceding tasks are completed, thereby causing logical contradictions, distorted simulation results, chaotic animation playback and other problems, which may seriously affect the reliability of the performance analysis and optimization judgment of the entire process. SUMMARY

[0004] The purpose of the present application is to provide a business process visualization simulation method to solve the problems in the background art.

[0005] In order to achieve the above purpose, the present application provides the following technical solution: a business process visualization simulation method, comprising: analyzing the dependency relationship between each business task based on a preset process description language, forming a task dependency graph and generating a task path; quantifying the dependency strength of any target task on one or more preceding tasks, and calculating the task causal strength factor CIF between each group of tasks based on historical process data; setting the allowed deviation interval of the task execution time relative to the theoretical execution time in the simulation process, and calculating the time drift tolerance TDT; recording the event sequence during the process simulation running, including the actual execution time of the task, the completion state of the preceding task and the resource scheduling situation; real-time execution of causal consistency evaluation, when the execution time of any task is earlier than the completion time of its preceding task and earlier than the expected order by more than the set TDT, and its corresponding CIF is higher than the set threshold, it is determined as a causal relationship disorder event; based on the causal disorder determination result, performing dynamic adjustment processing, including withdrawing the target task, rearranging the scheduling order, triggering the compensation sub-process or marking the corresponding process instance as a failure record; The evaluation results are visualized in real time with the processing feedback, and the causal consistency score in the simulation process and the process optimization suggestions are output.

[0006] Preferably, the forming of the task dependency graph and the generating of the task path specifically include: The input business process model is parsed using a preset process description language; Based on the parsing result, the business task nodes, gateway nodes and their connection relationships are extracted, and each node is assigned a unique identification ID, and a structured data representation is established; A directed acyclic graph form task dependency graph is constructed, and the business task nodes are taken as the vertices in the graph, and the execution logic relationship between tasks is taken as the edge; On the basis of the task dependency graph, a depth-first search algorithm or a topological sorting algorithm is used to generate all feasible task execution paths, and they are stored as a task path set.

[0007] Preferably, the calculation of the task causal strength factor CIF specifically includes: The execution time, task state, instance identification and inter-task dependency information of each task are extracted from the historical business process execution log to form a time series execution data set for modeling, wherein the log data includes process instance ID, task start and completion time, task execution result and other fields; For any target task and one or more preceding tasks, the dependency characteristics are calculated based on statistical analysis methods, including: the influence degree of the average execution time of the preceding task on the target task start time; the probability of the target task state change under the failure or delay of the preceding task; The maximum time lag and the coordination frequency between the preceding task and the target task; According to a plurality of influence factors, a causal strength calculation model is constructed to quantitatively score the task pair, and the scoring method includes normalized mutual information, Granger causal analysis or dependency factor weighted model based on logistic regression, to generate the task causal strength factor CIF.

[0008] Preferably, the setting of the time drift tolerance TDT includes: The offset between the actual start time and the theoretical execution time of the same task in multiple process instances in the historical process execution log is collected, and the theoretical execution time is calculated based on the average completion time of the preceding task in the task path and the standard process duration; Statistical analysis is performed on the offset to construct a time offset distribution model at the task level, and the model includes offset mean, standard deviation, range and abnormal value distribution information; According to the time offset distribution model, a time drift tolerance interval TDT is set for each task.

[0009] Preferably, the real-time execution causal consistency assessment specifically comprises: During the simulation running, the task execution events are monitored, and the actual execution time of each task is compared with the completion time of all its preceding tasks. If the actual start time of a task is found to be earlier than the completion time of any preceding task, a time precedence conflict event is recorded; For the task with a time precedence conflict, the time offset value of the task, i.e., the offset amount of the actual execution time relative to the theoretical execution time, is further calculated. If the offset value exceeds the time drift tolerance TDT interval range set for the task, it is marked as time drift overrun; The task causal intensity factor CIF between the task and its preceding tasks is retrieved. If CIF is higher than the set threshold, it indicates that the task has strong dependency on the preceding task; When the three conditions are met at the same time, it is determined that the task has a causal consistency anomaly, a causal relationship disorder event record is generated, and a preset abnormal handling mechanism is triggered.

[0010] Preferably, the dynamic adjustment processing based on the causal disorder judgment result comprises: After determining that the task has a causal relationship disorder event, the execution state of the task is immediately frozen, and its execution context is traced back. The task is withdrawn from the current running queue, and its allocated resources are released; Based on the constructed task dependency graph and the current process state, the affected task subgraph is topologically reordered, and the task scheduling order is rearranged to ensure that the preceding dependency relationship of all to-be-executed tasks is satisfied before scheduling; If the logical interruption caused by withdrawing the task cannot be solved by rearranging the scheduling, the corresponding compensation sub-process is triggered; When consecutive disorder behaviors or process logic structure failures that cannot be remedied occur, the current process instance is marked as a failure record, the process instance ID, disorder path, affected task, and triggering condition are recorded, and it is excluded from the simulation result statistics.

[0011] Preferably, the real-time visualization display of the evaluation result and processing feedback comprises: During the simulation execution process, a causal consistency monitoring view is generated in real time based on the task event sequence and the causal disorder detection result; The dynamic adjustment measures in the disorder event processing process are synchronously displayed in a graphical manner; A causal consistency scoring model is constructed, and the proportion of tasks satisfying the causal relationship constraint, the disorder event frequency, the disorder influence path length, and the recovery success rate in the task execution process are comprehensively counted to generate a normalized score value as the overall process consistency evaluation index; According to the score results and the distribution characteristics of the confusion events, combined with a predefined optimization rule library, optimization suggestions for specific process structures are output, including task path adjustment, resource configuration improvement, node merging or scheduling strategy replacement.

[0012] In the above technical solution, the present application provides technical effects and advantages: 1、The present application realizes the accurate identification and dynamic correction of potential task execution confusion behavior in process simulation by introducing a causal consistency evaluation mechanism, a time drift tolerance (TDT) model, and key parameters such as a task causal intensity factor (CIF). Through real-time monitoring of event sequences, multi-dimensional judgment of causal conflicts, and a compensation sub-process triggering mechanism, the logical consistency and operational stability of process simulation are effectively guaranteed, providing high reliability and controllability simulation support for complex business processes.

[0013] 2、The present application also visualizes the evaluation results and processing feedback, builds a causal consistency scoring model, and outputs structure optimization suggestions combined with confusion distribution characteristics, realizing a closed-loop feedback mechanism from simulation execution to result analysis to process optimization. Compared with existing technologies, the present application not only improves the intelligence and adaptability of process modeling, but also enhances the explanation ability, scheduling flexibility, and optimization guidance value of the simulation system, with a wide application prospect. BRIEF DESCRIPTION OF DRAWINGS

[0014] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings needed in the embodiments. Obviously, the drawings described below are only some embodiments of the present application, and other drawings can also be obtained by those skilled in the art based on these drawings.

[0015] Figure 1 The method flowchart of the present application. DETAILED DESCRIPTION

[0016] In order to make the purpose, technical scheme and advantages of the embodiments of the present application clearer, the technical scheme in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only some embodiments of the present application, not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application.

[0017] Embodiment, please refer to Figure 1 The business process visual simulation method described in the present embodiment includes: Based on the preset process description language, the dependency relationship between each business task is analyzed, a task dependency graph is formed, and a task path is generated. Quantify the dependency strength of any target task on its one or more predecessor tasks, and calculate the task causal intensity factor CIF between each pair of tasks based on historical process data; Set the allowed deviation interval of task execution time relative to theoretical execution time during simulation, and calculate the time drift tolerance TDT; Record the event sequence during the process simulation run, including the actual execution time of the task, the completion status of the predecessor task, and the resource scheduling situation; Real-time execution of causal consistency evaluation, when the execution time of any task is earlier than the completion time of its predecessor task and earlier than the expected order by more than the set TDT, and its corresponding CIF is higher than the set threshold, it is determined as a causal relationship disorder event; Based on the causal disorder determination result, dynamic adjustment processing is carried out, including withdrawing the target task, rearranging the scheduling order, triggering the compensation sub-process, or marking the corresponding process instance as invalid record; Real-time visualization of evaluation results and processing feedback, and output of causal consistency score and process optimization suggestions during simulation.

[0018] In the field of business process simulation, process modeling is the basic link of the entire simulation system, directly determining the accuracy of subsequent simulation precision, causal reasoning, resource scheduling and performance evaluation.

[0019] The method is based on a standardized analytical process, including: Process Description Language: refers to a standardized modeling language used to describe the logic of business processes, commonly including BPMN (Business Process Model and Notation), Petri net language and UML activity diagram.

[0020] Task Node (Task Node): refers to the basic execution unit with actual business operation meaning in the process, such as "submit order", "approve application", etc., each task node will be assigned a unique identifier (Task_ID).

[0021] Task Dependency Graph (Task Dependency Graph): a directed acyclic graph (Directed Acyclic Graph, abbreviated as DAG) with task nodes as graph vertices and logical dependency relationships between tasks as graph edges, used to represent the order and logical structure of tasks in the process.

[0022] Task Path (Task Path): from the starting node of the process, according to the edges in the dependency graph, connect the task nodes in turn, until the end node of the process is formed. The task execution sequence reflects the possible execution path set of the process.

[0023] The process description file is written in a structured language, containing task nodes, event nodes, gateway nodes and their connection information.

[0024] Taking BPMN XML as an example, by parsing <bpmn:task> 、 <bpmn:sequenceflow> 、 <bpmn:exclusivegateway>Extract the element, task name, ID, connection relationship before and after, etc. Use open source BPMN parsing tools (such as bpmn.io or Camunda BPMN Parser) to parse node attributes and generate node object structures.

[0025] For each parsed <bpmn:task>Element, a Task_Node object Task_Node is generated, including attributes: Task_ID: unique identifier; Task_Name: task name; Predecessors[]: predecessor task ID array; Successors[]: successor task ID array; To <bpmn:sequenceflow>The elements are parsed, task connection pairs are extracted, and logical edges between tasks are constructed.

[0026] For example, if there are <bpmn:sequenceflow id="Flow_1" sourceref="Task_A" targetref="Task_B">If Task_A→Task_B, it means Task_A is the predecessor of Task_B, and record the edge relationship (Task_A→Task_B).

[0027] All task nodes are regarded as vertices in a directed graph, and the dependency relationship between nodes is regarded as an edge. Check if there is a loop, and if a closed loop is detected, refuse to enter the simulation process. The "Tarjan strongly connected component algorithm" can be used to detect graph loops. Ensure that the graph structure meets the properties of a directed acyclic graph, which is convenient for subsequent traversal and path calculation.

[0028] On the basis of the DAG structure, use the topological sorting algorithm or the depth-first search (DFS) algorithm to start from the starting task node and enumerate all feasible paths until the end node.

[0029] Example implementation steps: Initialize an empty path list Path_List[]. Start DFS from all nodes with no predecessors (starting nodes). Each recursive visit to a child node accumulates the path. When reaching a node with no successors (ending node), add the complete path to Path_List[]. Return all paths as a set of task paths.

[0030] Each path will be used for task scheduling and causal assessment in the simulation process.

[0031] Obtain the process execution logs recorded in the historical business process system to form the modeling data set. Log data is usually obtained from BPM systems (such as Camunda, Activiti, SAP BPM) or business platform log systems.

[0032] Each log record should at least contain the following fields: Field name Data type Description Process instance ID String To distinguish different process execution instances Task ID String Corresponds to the unique identification of the task node in business process modeling Task name String Optional, for visual display Start time Timestamp Actual time when the task starts execution Completion time Timestamp Actual time when the task is completed Execution result Enumeration type For example, success, failure, exception, timeout, etc. Preceding task ID list Array Dependency relationship between tasks provided by the modeling system The above data is summarized to form a multi-dimensional time series data set LogDataset, which can be represented in table structure or event stream structure. The subsequent steps will extract relevant statistical features from it.

[0033] For any pair of tasks (predecessor task→target task), the dependency behavior features in actual execution need to be extracted from LogDataset, which includes the following three aspects: Time dependency: assess whether the execution time of the predecessor task affects the start time of the target task.

[0034] Calculate the interval time distribution: target task start time - predecessor task completion time for each process instance. Whether the target task is accompanied by a synchronous delay if the predecessor task is delayed in completion time; The correlation of time series is performed using Pearson correlation coefficient or mutual information metric.

[0035] Specifically: Calculate the time difference sequence ΔT for each process instance; The normalized mutual information calculation method is defined as follows: Normalized mutual information = mutual information value / average of entropy; Entropy represents the uncertainty of the distribution of time difference, and mutual information metric represents the information dependence between the predecessor and target tasks. The higher the value, the stronger the dependence.

[0036] State response probability (abnormal transmission), used to measure whether the failure or delay of the predecessor task will increase the error probability of the target task.

[0037] Specifically: Construct the conditional probability matrix: P(success_target | success_predecessor); P(success_target | fail_predecessor); Compare the difference ΔP between the two, the greater the difference, the more significant the impact of the predecessor task exception on the target task; the abnormal transmission relationship can be modeled through a logistic regression model.

[0038] For example: if the failure probability of the target task increases to 0.65 when the predecessor task fails, and under normal circumstances it is only 0.12, it means that there is strong abnormal dependence.

[0039] Maximum time lag and coordination frequency (structural synergy), used to evaluate whether two tasks often "cooperate" or there is a strict maximum response time window.

[0040] Specifically: Statistical frequency of the task pair appearing simultaneously in the process instance (cooperative frequency); Calculate the maximum response time lag, defined as: the latest start time of the target task in the process - the earliest completion time of the predecessor task; If the maximum response time tends to be stable in most instances, it means that there is a strong time constraint coupling relationship between the two.

[0041] The CIF calculation of each task pair will consider the following features: Feature name Description F1 Execution time mutual information normalized value (0~1) F2 State response probability difference value (ΔP) F3 Collaboration frequency normalized value (appearance frequency) F4 Maximum time lag normalized value (reverse indicator) The method can use one of the following three algorithms or their combination: Normalized Mutual Information model, suitable for strong temporal coupling scenarios between tasks; all features are standardized and then weighted average, weights can be set based on expert experience; CIF = w1 x F1 + w2 x F2 + w3 x F3 + w4 x (1 - F4); Granger Causality Test model, based on the prediction ability of time series data, if the pre-task sequence can significantly improve the prediction ability of the target task start time, it is determined that there is Granger causality; suitable for determining the coupling between tasks that are continuous in time.

[0042] Logistic Regression Weighted Model, using the target variable as "task coupling strength / weakness" label; F1 ~ F4 features are used as input to train the logistic regression model, and the output probability value is used as CIF.

[0043] CIF value is defined in the interval [0, 1], representing the strength of causal dependence between tasks: CIF ≥ 0.8: strong dependence, cannot be skipped or executed in advance; 0.5 ≤ CIF < 0.8: moderate dependence, can be adjusted through conditional detection; CIF < 0.5: weak dependence, can be executed in parallel or ignore the order.

[0044] The setting of TDT is based on the modeling results of historical process execution data statistics. First, we need to collect business logs from the process system during real-time operation to form a time series data set for calculating the offset and modeling.

[0045] The log data needs to include the following key fields: Process instance ID (Instance_ID): identifies the unique execution process of the same process; Task ID (Task_ID): identifies each task node in the process; Actual start time of the task (Actual_Start_Time): the time when the task actually occurs in the process instance; Task predecessor task ID set (Predecessor_Tasks): defines the direct predecessor node of the task; Predecessor task actual completion time set (Predecessors_Actual_End_Times): records the completion time of the predecessor task in the instance.

[0046] These data can be obtained through the process instance execution logs exported by standard BPM engines (such as Camunda, Activiti, jBPM).

[0047] To calculate the drift of a task, its theoretical execution time must be defined first, which is the time point that the task should be scheduled to execute under the "ideal process execution state".

[0048] Definition of the theoretical execution time: for any task Task_T, its theoretical execution time T_theory in the process instance can be calculated by taking the average (or weighted average) of the completion times of all its predecessor tasks in the historical processes; plus the delay time (Delay_T) set in the standard process template for the task, such as the response time required by the SLA.

[0049] The formula is: T_theory = T_pred_avg + Delay_T; where T_pred_avg is the maximum or weighted average of the completion times of all predecessor tasks of the task in the current instance, and Delay_T is the preset business processing buffer time.

[0050] The drift (Drift) is the difference between the actual start time of the task and its theoretical execution time. For a task T in a process instance i, the drift is defined as: Drift_T(i) = Actual_Start_Time_T(i) - T_theory(i); a positive Drift indicates that the task is delayed in execution; a negative Drift indicates that the task is executed ahead of schedule; the larger the absolute value of the Drift, the more serious the deviation of the task from the theoretical trajectory.

[0051] Iterate through multiple historical process instances, and extract Drift_T(i) for each task node to form a task-level time drift sample set Drift_Samples_T[].

[0052] For example, suppose there is a task T that appears in 100 process instances, and 100 drift values are calculated, which are used as the data basis for subsequent modeling.

[0053] For Drift_Samples_T[], use standard statistical methods for modeling to extract the following key indicators: Average drift μ_T (average value); Drift standard deviation σ_T; Maximum drift value range (range); Drift value distribution histogram and box plot (for visualization); Proportion of drift outliers (such as the number of individuals exceeding 3σ / total sample size).

[0054] The above statistics are used to judge the execution time fluctuation characteristics of the task, and are the direct basis for setting TDT.

[0055] The purpose of TDT is to set a task level allowed offset interval for determining whether the actual execution of a task is still within the tolerance range during simulation. The setting method includes the following steps: Setting strategy one: confidence interval method (recommended way): using the statistical properties of normal distribution, set the TDT interval as: TDT_T = [μ_T - k × σ_T, μ_T + k × σ_T]; Where: μ_T is the average drift of task T; σ_T is the standard deviation; k is the confidence factor, the commonly used value is 2 (95% confidence interval) or 3 (99.7% confidence interval); TDT_T is the acceptable time offset range of task T. Example: if the average drift time of a task is 3 seconds, the standard deviation is 1.2 seconds, then the TDT is [0.6 seconds, 5.4 seconds], which means if the actual offset exceeds the interval, it will be considered as possible timing disorder.

[0056] Setting strategy two: percentile coverage method, according to the distribution of offset values in the sample, set TDT as the interval range covering 90% or 95% of the historical offset values. Calculate the 5th percentile and 95th percentile of the offset values; Define TDT_T = [P5, P95]; Suitable for tasks with non-normal offset distribution.

[0057] The so-called "event sequence" refers to a set of task-related events that occur in chronological order during simulation running. Each event object contains key data related to the status change of a task or resource. Event sequence not only reflects the real dynamic trajectory of process running, but also provides data support for subsequent time drift judgment, causal chain analysis, resource utilization statistics, etc.

[0058] Each event record is abstracted as a standardized data object SimEvent, which includes the following fields: Event timestamp (Event_Timestamp): the triggering time of the event in the simulation system, in milliseconds; Task ID (Task_ID): the unique identifier of the business task associated with this event; Process instance ID (Instance_ID): the identifier of the process instance to which the event belongs, ensuring clear event ownership; Event type (Event_Type): such as task start (Start), task completion (Complete), resource allocation (Allocate), resource release (Release), etc. Predecessor status list (Predecessor_Status[]): the completion status of each predecessor task before the task starts execution (such as completed, in progress, not started); Actual start time and actual end time (Actual_Start, Actual_End): If the event type is start or end, record the actual running time of the task; Resource usage (Resource_Assignment): Records the resource ID, resource type, quantity, etc. used when this task is executed; Scheduling policy flag (Scheduling_Flag): Indicates which scheduling policy was used to generate this schedule, such as FIFO, priority, preemption, etc.

[0059] All events are sorted in ascending order using timestamps as indexes to form a complete event sequence SimEventLog[]. After the simulation is completed, it can be exported as a table or database for subsequent analysis.

[0060] This method embeds an event listener module within the simulation engine to listen for and record the following key behaviors: Task scheduling event listener: When a task is scheduled to the execution queue, record its scheduling time and required resources; Task execution event listener: Record the start time when the task officially starts, and read the status of all preceding tasks; Task completion event listener: Write the actual completion time when the task is completed; Resource allocation and release event monitoring: When a task starts and finishes, the resource allocation and release behaviors are recorded respectively, forming a resource lifecycle tracking chain.

[0061] The event listening module, as a subsystem of the simulation engine, works in conjunction with the scheduling module and adopts an asynchronous non-blocking structure to ensure that event logging does not affect simulation performance.

[0062] During the simulation engine's operation, the system captures task scheduling and execution events in real time through the integrated event listener component, including information such as the actual start time of the task, task ID, and process instance ID.

[0063] When the simulation engine schedules a task to enter the execution state, it records its actual execution time (Actual_Start_Time). At the same time, query the completion time (Actual_End_Times) of all direct preceding tasks (Predecessor_Tasks) of this task in the current process instance.

[0064] For the currently executing task T, the time-ahead conflict judgment rule is defined as follows: If any predecessor task P satisfies: Actual_Start_Time(T) < Actual_End_Time(P); it means that the task has started execution before its upstream dependencies are completed, violating the basic causal order constraint. In this case, the system records a Causal Time Violation event.

[0065] If a task has a causal time violation, the system further judges whether the task significantly deviates from its theoretical execution time to distinguish between "acceptable minor disorder" and "serious execution advance".

[0066] Theoretical execution time calculation method: For task T, its theoretical execution time (T_theory) is calculated as follows: T_theory = max{Actual_End_Time(P1), Actual_End_Time(P2),..., Actual_End_Time(Pn)} + Delay_T; where: P1 to Pn are all direct predecessor tasks of T; Delay_T is the buffer delay defined in the standard process template; if Delay_T is not explicitly set, the default value is 0.

[0067] Drift value calculation: Drift_T = Actual_Start_Time(T) - T_theory; Drift_T > 0 indicates task delay; Drift_T < 0 indicates task advance execution; the larger the absolute value, the more significant the time drift.

[0068] Temporal Drift Tolerance (TDT) judgment: Each task establishes a TDT interval in historical process data, for example: TDT_T = [μ_T - 2σ_T, μ_T + 2σ_T]; where: μ_T is the historical drift mean; σ_T is the standard deviation; the interval range can be adjusted to adapt to different industry tolerance standards. If Drift_T < TDT_T[0], i.e. the offset is earlier than the lower bound of the TDT interval, it means that the task has executed in advance beyond the acceptable range of the system, and the system will mark it as a Temporal Drift Exceeding event.

[0069] Under the premise of time causal violation and offset exceeding, it is also necessary to judge whether the task has strong dependency on its predecessor tasks, i.e. whether the error advance execution will cause business logic conflict.

[0070] The task causal intensity factor CIF has been modeled by historical data during system initialization phase and stored in the dependency matrix: CIF(Task_T, Task_P) ∈ [0, 1]; the higher the value, the greater the dependency strength; the maximum CIF value of the task and all predecessor tasks is involved in the judgment.

[0071] Set the system threshold: CIF_Threshold = 0.8; If there exists P ∈ Predecessors(T) such that CIF(T, P) > CIF_Threshold; It means that the task T has a strong causal dependency on task P, and executing T in advance will cause process logic errors or system state inconsistencies.

[0072] When the following three conditions are met simultaneously: The actual execution time is earlier than the completion time of any predecessor task; The execution time offset exceeds the TDT interval; The CIF value between any predecessor task is higher than the set threshold; The system determines that there is a causal consistency violation and immediately performs the following operations: Generate a causal disorder event record (Causal_Disorder_Event) containing task ID, process instance ID, offset value, conflict predecessor task ID, corresponding CIF value, etc. Record in the simulation log system Violation_Log[]; Send a trigger signal to the exception handling module to perform dynamic scheduling rollback, task suspension, resource reallocation, or compensation sub-process insertion, etc.

[0073] When the causal consistency evaluation module detects that a task T has the following conditions: The actual start time is earlier than the completion time of any predecessor task; The offset exceeds the task set time drift tolerance (TDT); The causal intensity factor (CIF) with any predecessor task is greater than the set threshold (e.g. 0.8); The system determines that this event is a "serious causal disorder behavior" and immediately triggers the freezing of the process.

[0074] The freezing process includes: marking the execution state of task T as "Frozen", prohibiting it to continue passing the state to downstream tasks; removing T from the current running queue (Active_Task_Queue); revoking the event record of T in the system and keeping the context data snapshot; releasing the resources occupied by T, such as manpower, equipment, processing unit, etc., returning the resource pool for scheduling by other tasks. The process is completed through the engine-level scheduling interface, ensuring that the freezing process is non-blocking and thread-safe.

[0075] Based on the directed acyclic graph (DAG) structure of the current process model, a local subgraph G_sub containing task T and its downstream tasks is extracted for analyzing the impact of task rearrangement on downstream tasks. G_sub = {T, T1, T2,..., Tn}, where each Ti is a task dependent on T, and n is the total number of tasks; Extract all incomplete task nodes in the subgraph; Perform topological sorting on the subgraph to generate a new scheduling order.

[0076] The topological sorting algorithm is as follows: Build a mapping relationship between tasks and their predecessors; Calculate the in-degree of all tasks; Start traversing from the tasks with in-degree 0 and sequentially enter the scheduling sequence; If all the predecessor tasks of a task are in the queue, the task can be executed.

[0077] For the frozen task T, it re-enters the scheduling queue after its predecessor tasks are completed; For downstream task Ti, recalculate its earliest executable time; If scheduling fails due to time delay or resource conflict, delay scheduling and record the waiting state; All rescheduled tasks need to reverify their TDT compliance to avoid chain confusion.

[0078] If the task is withdrawn and one of the following conditions exists, it means that the process logic is interrupted and cannot be automatically repaired: The downstream tasks of task T have been partially executed; Logical islands (no path reachable) are formed after the dependency graph rearrangement; The frozen task is a critical process node or gateway task, and the path connectivity cannot be restored after rearrangement.

[0079] The system will trigger a compensation sub-process to replace the business function of the task or restore the integrity of the process logic.

[0080] The compensation process can be automatically generated or invoked in the following ways: Call predefined compensation templates (such as abnormal approval, manual review, emergency handling, etc.) from the business modeling platform; Dynamically select compensation strategies according to task classification and exception type; Instance the compensation process as an independent process instance and embed it in the current process context; The task execution information of the compensation process is also included in the event log system for unified management.

[0081] If two or more non-recoverable chaos events occur continuously in the same process instance, or one of the following conditions occurs: Three or more tasks have failed to be successfully recovered through the compensation mechanism due to causal chaos; The task dependency graph rearrangement fails, and the topology sequence cannot be reconstructed; The compensation process fails or cannot meet the process convergence conditions; The process instance Instance_ID is determined as a structurally invalid instance (Structurally Invalid Instance). Mark the instance as "Invalid" state and write it into the process instance control table (Instance_Control_Table); record its key parameters, including process instance ID, first chaotic task ID, impact path, CIF and TDT determination value; exclude it from subsequent statistical reports, including performance evaluation, efficiency analysis, resource utilization, etc.; for subsequent abnormal log analysis module for backtracking and modeling optimization reference.

[0082] This method presents the task execution status, chaos detection results and processing feedback in a graphical manner in real time through the process diagram visualization engine and event-driven update mechanism.

[0083] Based on the process modeling diagram, the following visualization elements are dynamically superimposed: Task status color coding: normal execution tasks are green; withdrawn tasks are yellow; causal chaos tasks are red; compensated tasks are blue; Timeline view: horizontal time axis displays the planned and actual execution time of all tasks; shows the degree of deviation; task node hover information popup: displays the causal intensity factor (CIF) value, time drift tolerance (TDT) interval, deviation value, conflict state, compensation flag, etc. Event record panel: Real-time scrolling display of disorder events and their handling logs; record task ID, process instance ID, trigger time, handling measures, etc. All simulation events and disorder detection results are written into the event queue; the visualization renderer listens to queue change events and refreshes the screen; high-performance drawing is supported using HTML5 Canvas or WebGL engine, supporting large-scale task graph rendering; user interactions such as process playback, task positioning, and disorder path highlighting are supported.

[0084] To evaluate the overall causal consistency level of the simulation process during execution, the method designs a task-level scoring model to quantify the local consistency state of each process instance and aggregate it into a global score.

[0085] Consistency score definition note: N_total: total number of tasks in the process instance; N_valid: number of tasks that meet the causal order requirements; N_disorder: number of tasks that are determined to be causally disordered; P_recovered: proportion of successfully repaired (e.g. rearranged or compensated) tasks among disorder tasks; L_disorder_avg: average impact depth of disorder paths (i.e. average number of downstream tasks affected by disorder tasks); then the causal consistency score Score_causal of the process instance is defined as: Score_causal = (N_valid / N_total) × α + P_recovered × β - L_disorder_avg × γ; where: α, β, γ are weight coefficients, default settings are α = 0.5, β = 0.3, γ = 0.2; Score_causal ranges from 0 to 1, the closer to 1 indicates higher consistency.

[0086] After each process instance simulation is completed, the above indicators are automatically counted; All scoring results are written into CausalScore_Table and associated with process model, execution parameters, disorder event number, etc. Support exporting scoring report, visualizing scoring trend chart, scoring distribution chart, etc.

[0087] The method proposes targeted optimization suggestions by analyzing scoring results and disorder event characteristics, combined with process structure diagram and scheduling records.

[0088] The system has a built-in process optimization rule library that matches rules and outputs suggestions based on scoring dimensions and disorder causes.

[0089] Optimization suggestion types include but are not limited to: Path structure optimization: if disorders are concentrated in parallel task intersections, suggest splitting paths or adding synchronization nodes; Resource configuration adjustment: If resource competition leads to confusion, it is recommended to increase the number of resource instances or use priority scheduling; Task merging or splitting: If high-CIF tasks are frequently confused, it is recommended to merge the previous and target tasks into atomic tasks; Scheduling strategy replacement: Replace the FIFO with priority scheduling, scheduling based on causal graph, and other strategies; Compensation process template optimization suggestion: If the compensation process frequently triggers failure, adjust the compensation strategy or delay the trigger opportunity.

[0090] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited to this. Any person skilled in the art can easily think of changes or replacements within the technical scope disclosed in the present application, which should be covered within the protection scope of the present application.< / bpmn:sequenceflow> < / bpmn:sequenceflow> < / bpmn:task> < / bpmn:exclusivegateway> < / bpmn:sequenceflow> < / bpmn:task>

Claims

1. A business process visualization simulation method, characterized by: include: Based on a pre-defined process description language, the dependencies between various business tasks are analyzed to form a task dependency graph and generate task paths; Quantify the dependence strength of any target task on one or more of its predecessor tasks, and calculate the task causality strength factor (CIF) between each pair of tasks based on historical process data; Define the allowable offset range of task execution time relative to theoretical execution time during the simulation process, and calculate the time drift tolerance (TDT). Record the event sequence during the process simulation, including the actual execution time of the task, the completion status of the preceding task, and the resource scheduling status; Real-time causal consistency assessment is performed. When the execution time of any task is earlier than the completion time of its predecessor task and earlier than the expected sequence, exceeding the set TDT, and its corresponding CIF is higher than the set threshold, it is judged as a causal relationship disorder event. Dynamic adjustments are made based on the causal disorder determination results, including withdrawing the target task, rearranging the scheduling order, triggering compensation sub-processes, or marking the corresponding process instance as a failure record. The evaluation results and processing feedback are visualized in real time, and the causal consistency score and process optimization suggestions are output during the simulation process.

2. The business process visualization simulation method according to claim 1, characterized in that: in, The process of forming a task dependency graph and generating task paths specifically includes: The input business process model is parsed using a pre-defined process description language; Based on the parsing results, business task nodes, gateway nodes and their connection relationships are extracted, and a unique identifier ID is assigned to each node to establish a structured data representation; Construct a task dependency graph in the form of a directed acyclic graph, with the business task nodes as vertices in the graph and the execution order logic relationship between tasks as edges; Based on the task dependency graph, a depth-first traversal algorithm or a topological sorting algorithm is used to generate all feasible task execution paths, and these paths are stored as a set of task paths.

3. The business process visualization simulation method according to claim 2, characterized in that: The computational task causality strength factor (CIF) specifically includes: The execution time, task status, instance identifier, and inter-task dependency information of each task are extracted from the historical business process execution logs to form a time-series execution dataset for modeling. The log data includes fields such as process instance ID, task start and finish time, and task execution result. For any target task and one or more of its prerequisite tasks, its dependency characteristics are calculated based on statistical analysis methods, including: the degree of influence of the average execution time of the prerequisite tasks on the start time of the target task; the probability of changes in the state of the target task in the event of failure or delay of the prerequisite tasks; and the maximum time delay and frequency of cooperation between the prerequisite tasks and the target task. Based on multiple influencing factors, a causal strength calculation model is constructed to quantitatively score task pairs. The scoring methods include normalized mutual information, Granger causal analysis, or a dependency factor weighted model based on logistic regression, generating a task causal strength factor (CIF).

4. The business process visualization simulation method according to claim 3, characterized in that: in, The set time drift tolerance (TDT) includes: The offset between the actual start time and the theoretical execution time of the same task in multiple process instances is collected from the historical process execution log. The theoretical execution time is calculated based on the average completion time of the preceding tasks in the task path and the standard process duration. Statistical analysis of the offset is performed to construct a task-level time offset distribution model, which includes the offset mean, standard deviation, range and outlier distribution information. Based on the time offset distribution model, a time drift tolerance interval (TDT) is set for each task.

5. The business process visualization simulation method according to claim 4, characterized in that: The real-time causal consistency assessment specifically includes: During the simulation, task execution events are monitored, and the actual execution time of each task is compared with the completion time of all its predecessor tasks. If the actual start time of a task is found to be earlier than the completion time of any predecessor task, it is recorded as a time-preceding conflict event. For tasks that have time-preceded conflicts, the time offset value of the task is further calculated, which is the offset of the actual execution time relative to the theoretical execution time. If the offset value exceeds the time drift tolerance (TDT) range set for the task, it is marked as time drift exceeding the limit. The task causality strength factor (CIF) between the retrieved task and its predecessor task is determined. If the CIF is higher than a set threshold, it indicates that the task has a strong dependency on its predecessor task. When all three conditions are met, the task is determined to have a causal consistency anomaly, a causal relationship disorder event record is generated, and a preset exception handling mechanism is triggered.

6. The business process visualization simulation method according to claim 5, characterized in that: The dynamic adjustment process based on the causal disorder determination result includes: Once a causal disorder event is determined to exist in a task, the execution status of the task is immediately frozen, its execution context is traced back, the task is withdrawn from the current run queue, and its allocated resources are released. Based on the constructed task dependency graph and the current process status, the affected task subgraphs are topologically reordered, and the task scheduling order is rearranged to ensure that the prerequisite dependencies of all tasks to be executed are satisfied before scheduling. If the logical interruption caused by the task withdrawal cannot be resolved by rescheduling, the corresponding compensation subprocess will be triggered. When an unrecoverable malfunction or a failure in the process logic structure occurs consecutively, the current process instance is marked as a failure record, and its process instance ID, malfunction path, affected tasks and triggering conditions are recorded, and it is removed from the simulation result statistics.

7. The business process visualization simulation method according to claim 6, characterized in that: The real-time visualization of evaluation results and processing feedback includes: During the simulation execution, a causal consistency monitoring view is generated in real time based on the task event sequence and the causal disorder detection results; The dynamic adjustment measures during the handling of chaotic events are displayed in a graphical manner in a synchronized manner; A causal consistency scoring model is constructed, which comprehensively analyzes the proportion of tasks that meet causal constraints, the frequency of disorder events, the length of the disorder impact path, and the recovery success rate during task execution, and generates a normalized score value as an overall process consistency evaluation indicator. Based on the scoring results and the distribution characteristics of disorder events, combined with a predefined optimization rule base, optimization suggestions are output for specific process structures, including task path adjustment, resource configuration improvement, node merging, or scheduling strategy replacement.

Images