Performance exp

.gitignore

@@ -12,4 +12,6 @@ bimp_test_examples/
 *.egg-info
 .pymon
 .DS_Store
-.vscode/
+.vscode/
+performance_exp/*/*/results
+performance_exp/events/generated_events

bpdfr_simulation_engine/control_flow_manager.py

@@ -95,6 +95,16 @@ def is_start_or_end_event(self):
     def is_event(self):
         return self.type in [BPMN.START_EVENT, BPMN.END_EVENT, BPMN.INTERMEDIATE_EVENT]
 
+    def delete_incoming_flow(self, flow_id):
+        "Delete incoming flow if it exists"
+        if flow_id in self.incoming_flows:
+            self.incoming_flows.remove(flow_id)
+
+    def delete_outgoing_flow(self, flow_id):
+        "Delete outgoing flow if it exists"
+        if flow_id in self.outgoing_flows:
+            self.outgoing_flows.remove(flow_id)
+
 
 class ProcessState:
     def __init__(self, bpmn_graph):
@@ -171,6 +181,12 @@ def add_bpmn_element(self, element_id, element_info):
         self.from_name[element_info.name] = element_id
         self.nodes_bitset[element_id] = (1 << len(self.element_info))
 
+    def remove_incoming_flow(self, element_id, flow_id):
+        self.element_info[element_id].delete_incoming_flow(flow_id)
+
+    def remove_outgoing_flow(self, element_id, flow_id):
+        self.element_info[element_id].delete_outgoing_flow(flow_id)
+
     def add_flow_arc(self, flow_id, source_id, target_id):
         for node_id in [source_id, target_id]:
             if node_id not in self.element_info:

bpdfr_simulation_engine/events_performance_experiments.py

@@ -0,0 +1,72 @@
+import os
+import string
+
+from bpdfr_simulation_engine.control_flow_manager import (
+    BPMN,
+    EVENT_TYPE,
+    BPMNGraph,
+    ElementInfo,
+)
+
+
+def _add_events(
+    bpmn_graph: BPMNGraph,
+    sequence_flow_list,
+    element_probability,
+    num_inserted_events: int,
+):
+    if len(sequence_flow_list) < num_inserted_events:
+        raise ValueError(
+            "A number of inserted events should not be higher than a number of sequence flows present in the BPMN model."
+        )
+
+    # keep track of the added events to the model
+    inserted_events_logs: string = ""
+
+    for i in range(num_inserted_events):
+        # the flow arc to be replaced
+        to_be_deleted_flow_arc = sequence_flow_list[i]
+        to_be_deleted_flow_arc_id = to_be_deleted_flow_arc.attrib["id"]
+
+        source_id = to_be_deleted_flow_arc.attrib["sourceRef"]
+        target_id = to_be_deleted_flow_arc.attrib["targetRef"]
+
+        new_event_id = f"event_{i}"
+
+        # log info about the newly added event
+        inserted_events_logs += f"{new_event_id} between {source_id} and {target_id}.\n"
+
+        # add intermediate event
+        bpmn_graph.add_bpmn_element(
+            new_event_id,
+            ElementInfo(
+                BPMN.INTERMEDIATE_EVENT,
+                new_event_id,
+                new_event_id,
+                EVENT_TYPE.TIMER,
+            ),
+        )
+
+        # remove previously referenced sequence flow in the source & target activity
+        bpmn_graph.remove_outgoing_flow(source_id, to_be_deleted_flow_arc_id)
+        bpmn_graph.remove_incoming_flow(target_id, to_be_deleted_flow_arc_id)
+
+        # add sequence flow to and from the newly added event
+        seq_flow_to_event = f"{source_id}_{new_event_id}"
+        bpmn_graph.add_flow_arc(seq_flow_to_event, source_id, new_event_id)
+        seq_flow_from_event = f"{new_event_id}_{target_id}"
+        bpmn_graph.add_flow_arc(seq_flow_from_event, new_event_id, target_id)
+
+        # duplicate the gateway probability if it existed before
+        if source_id in element_probability:
+            element_probability[source_id].update_candidate_key(
+                to_be_deleted_flow_arc_id, seq_flow_to_event
+            )
+
+    # save logs about events
+    logs_path = os.path.join(
+        os.path.dirname(__file__),
+        f"../performance_exp/events/generated_events/{num_inserted_events}_events_logs.txt",
+    )
+    with open(logs_path, "w+") as logs_file:
+        logs_file.write(inserted_events_logs)

bpdfr_simulation_engine/probability_distributions.py

@@ -175,6 +175,20 @@ def get_multiple_flows(self):
                 selected.append((self.candidates_list[i], None))
         return selected if len(selected) > 0 else [(self.get_outgoing_flow(), None)]
 
+    def update_candidate_key(self, old_candidate_id, new_candidate_id):
+        """
+        After inserting an event, we need to change the candidate id in the list of candidates
+        This needs to happen due to the fact that we removed one gateway and inserted a new one instead
+        """
+
+        try:
+            candidate_index = self.candidates_list.index(old_candidate_id)
+        except ValueError:
+            # in case candidate is not on the list, not updating anything
+            return
+
+        self.candidates_list[candidate_index] = new_candidate_id
+
 
 def random_uniform(start, end):
     return numpy.random.uniform(low=start, high=end)

bpdfr_simulation_engine/simulation_engine.py

@@ -644,9 +644,10 @@ def run_simulation(
     log_out_path=None,
     starting_at=None,
     is_event_added_to_log=False,
+    num_generated_events=None,
 ):
     diffsim_info = SimDiffSetup(
-        bpmn_path, json_path, is_event_added_to_log, total_cases
+        bpmn_path, json_path, is_event_added_to_log, total_cases, num_generated_events
     )
 
     if not diffsim_info:

bpdfr_simulation_engine/simulation_properties_parser.py

@@ -11,6 +11,7 @@
     BPMNGraph,
     ElementInfo,
 )
+from bpdfr_simulation_engine.events_performance_experiments import _add_events
 from bpdfr_simulation_engine.prioritisation import AllPriorityRules
 from bpdfr_simulation_engine.prioritisation_parser import PrioritisationParser
 from bpdfr_simulation_engine.probability_distributions import *
@@ -27,7 +28,7 @@
 PRIORITISATION_RULES_SECTION = "prioritisation_rules"
 ARRIVAL_TIME_CALENDAR = "arrival_time_calendar"
 RESOURCE_CALENDARS = "resource_calendars"
-
+TASK_RESOURCE_DISTR_SECTON = "task_resource_distribution"
 
 def parse_json_sim_parameters(json_path):
     with open(json_path) as json_file:
@@ -38,7 +39,7 @@ def parse_json_sim_parameters(json_path):
         )
         calendars_map = parse_resource_calendars(json_data[RESOURCE_CALENDARS])
         task_resource_distribution = parse_task_resource_distributions(
-            json_data["task_resource_distribution"], res_pool
+            json_data[TASK_RESOURCE_DISTR_SECTON], res_pool
         )
 
         element_distribution = parse_arrival_branching_probabilities(
@@ -234,7 +235,13 @@ def parse_arrival_branching_probabilities(arrival_json, gateway_json):
     return element_distribution
 
 
-def parse_simulation_model(bpmn_path):
+def parse_simulation_model(
+    bpmn_path, element_probability={}, num_generated_events=None
+):
+    """
+    element_probability parameter is only used for adding probability for newly inserted sequence flows
+    when inserting events
+    """
     tree = ET.parse(bpmn_path)
     root = tree.getroot()
 
@@ -276,7 +283,8 @@ def parse_simulation_model(bpmn_path):
 
         # Counting incoming/outgoing flow arcs to handle cases of multiple in/out arcs simultaneously
         pending_flow_arcs = list()
-        for flow_arc in process.findall("xmlns:sequenceFlow", bpmn_element_ns):
+        sequence_flow_list = process.findall("xmlns:sequenceFlow", bpmn_element_ns)
+        for flow_arc in sequence_flow_list:
             # Fixing the case in which a task may have multiple incoming/outgoing flow-arcs
             pending_flow_arcs.append(flow_arc)
             if flow_arc.attrib["sourceRef"] in elements_map:
@@ -332,6 +340,14 @@ def parse_simulation_model(bpmn_path):
                 target_id = join_gateways[target_id]
             bpmn_graph.add_flow_arc(flow_arc.attrib["id"], source_id, target_id)
 
+        if num_generated_events != None:
+            _add_events(
+                bpmn_graph,
+                sequence_flow_list,
+                element_probability,
+                num_generated_events,
+            )
+
     bpmn_graph.encode_or_join_predecesors()
     bpmn_graph.validate_model()
     return bpmn_graph

bpdfr_simulation_engine/simulation_setup.py

@@ -8,21 +8,37 @@
 from bpdfr_simulation_engine.control_flow_manager import ProcessState, ElementInfo, BPMN
 from bpdfr_simulation_engine.probability_distributions import generate_number_from
 from bpdfr_simulation_engine.resource_calendar import RCalendar
-from bpdfr_simulation_engine.simulation_properties_parser import parse_simulation_model, parse_json_sim_parameters
+from bpdfr_simulation_engine.simulation_properties_parser import (
+    parse_simulation_model,
+    parse_json_sim_parameters,
+)
 
 
 class SimDiffSetup:
-    def __init__(self, bpmn_path, json_path, is_event_added_to_log, total_cases):
+    def __init__(
+        self,
+        bpmn_path,
+        json_path,
+        is_event_added_to_log,
+        total_cases,
+        num_generated_events=None,
+    ):
         self.process_name = ntpath.basename(bpmn_path).split(".")[0]
         self.start_datetime = datetime.datetime.now(pytz.utc)
 
         self.resources_map, self.calendars_map, self.element_probability, self.task_resource, self.arrival_calendar, \
             self.event_distibution, self.batch_processing, self.case_attributes, self.prioritisation_rules \
             = parse_json_sim_parameters(json_path)
 
-        self.bpmn_graph = parse_simulation_model(bpmn_path)
-        self.bpmn_graph.set_additional_fields_from_json(self.element_probability, \
-            self.task_resource, self.event_distibution, self.batch_processing)
+        self.bpmn_graph = parse_simulation_model(
+            bpmn_path, self.element_probability, num_generated_events
+        )
+        self.bpmn_graph.set_additional_fields_from_json(
+            self.element_probability,
+            self.task_resource,
+            self.event_distibution,
+            self.batch_processing
+        )
         if not self.arrival_calendar:
             self.arrival_calendar = self.find_arrival_calendar()