def test_csv_export_order_processing_example(self): # TODO not working correctly, problem with nested splits bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file( os.path.abspath(self.example_directory + "order-processing.bpmn")) bpmn_graph.export_csv_file(self.output_directory, "order-processing.csv")
def test_layouter_manually_created_diagram_simple_case(self): """ Test for importing a simple BPMNEditor diagram example (as BPMN 2.0 XML) into inner representation and generating layout for it """ output_file = "layouter_simple_case.xml" bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="start_event") [task1_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1") bpmn_graph.add_sequence_flow_to_diagram(process_id, start_id, task1_id, "start_to_one") [task2_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2") [end_id, _] = bpmn_graph.add_end_event_to_diagram(process_id, end_event_name="end_event") bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_id, task2_id, "one_to_two") bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_id, end_id, "two_to_end") layouter.generate_layout(bpmn_graph) bpmn_graph.export_xml_file(self.output_directory, output_file)
def test_loadBPMNEditorDiagramAndVisualize(self): """ Test for importing a simple BPMNEditor diagram example (as BPMN 2.0 XML) into inner representation and later exporting it to XML file. Includes test for visualization functionality. """ bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(self.example_path)) bpmn_graph.export_xml_file(self.output_directory, self.output_file)
def test_loadCamundaSimpleDiagram(self): """ Test for importing a simple Camunda diagram example (as BPMN 2.0 XML) into inner representation and later exporting it to XML file """ bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(self.example_path)) bpmn_graph.export_xml_file(self.output_directory, self.output_file_with_di) bpmn_graph.export_xml_file_no_di(self.output_directory, self.output_file_no_di)
def test_csv_import_csv_export(self): processes = ["pizza-order", "airline-checkin", "order-processing"] for process in processes: bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_csv_file(os.path.abspath(self.input_directory + process + ".csv")) bpmn_graph.export_csv_file(self.output_directory, process + ".csv") cmp_result = filecmp.cmp(self.input_directory + process + ".csv", self.output_directory, process + ".csv") # unittest.TestCase.assertTrue(self, cmp_result) # unfortunatelly csv export has bugs bpmn_graph.export_xml_file_no_di(self.output_directory, process + ".bpmn")
def test_loadCamundaSimpleDiagramAndVisualize(self): """ Test for importing a simple Camunda diagram example (as BPMN 2.0 XML) into inner representation and later exporting it to XML file. Includes test for visualization functionality. """ bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(self.example_path)) # Uncomment line below to get a simple view of created diagram # visualizer.visualize_diagram(bpmn_graph) visualizer.bpmn_diagram_to_dot_file(bpmn_graph, self.output_directory + self.output_dot_file) visualizer.bpmn_diagram_to_png(bpmn_graph, self.output_directory + self.output_png_file) bpmn_graph.export_xml_file(self.output_directory, self.output_file_with_di) bpmn_graph.export_xml_file_no_di(self.output_directory, self.output_file_no_di)
def __init__(self, log): self.algorithm_name = "alpha" self.log = log self.footprint = footprint(self.log, self.algorithm_name) self.succession = self.footprint.succession self.bpmn_graph = diagram.BpmnDiagramGraph() self.bpmn_graph.create_new_diagram_graph( diagram_name="alpha_alogrithm_bpmn") self.process_id = self.bpmn_graph.add_process_to_diagram() self.node_ancestors = {} self.node_successors = {} self.event_incomes = [] self.event_outcomes = [] self.flows = []
def Translate(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="scenario") root_id = bpmn_graph.add_process_to_diagram() mapped = { 'root': bpmn_graph.add_start_event_to_diagram(root_id, start_event_name="root") } edges = [] cproc = 'root' maxdepth = None def recurtravel(node, depth): tasks = set( [i.split('-')[0] for i in self.scenario.phases[node].children]) pgate = ' '.join(tasks) if len(tasks) > 1 else None if pgate: if pgate not in mapped.keys(): mapped[pgate] = bpmn_graph.add_parallel_gateway_to_diagram( root_id, gateway_name=pgate) bpmn_graph.add_sequence_flow_to_diagram( root_id, mapped[node][0], mapped[pgate][0]) for i in tasks: if i not in mapped.keys(): mapped[i] = bpmn_graph.add_subprocess_to_diagram( root_id, subprocess_name=i) if pgate and not [pgate, i] in edges: bpmn_graph.add_sequence_flow_to_diagram( root_id, mapped[pgate][0], mapped[i][0]) edges.append([pgate, i]) else: bpmn_graph.add_sequence_flow_to_diagram( root_id, mapped[node][0], mapped[i][0]) for j in self.scenario.phases[node].children: if j not in mapped.keys() and i in j: mapped[j] = bpmn_graph.add_task_to_diagram(root_id, task_name=j) bpmn_graph.add_sequence_flow_to_diagram( root_id, mapped[i][0], mapped[j][0]) recurtravel( j, depth + 1) if depth == None or depth != maxdepth else None recurtravel('root', 0) self.mapped = mapped self.bpmn_graph = bpmn_graph return self
def create_bpmn_model(best_tree: Tree): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="Final model") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram(process_id, start_event_name="START") root_end = fill_bpmn_model(best_tree, bpmn_graph, start_id, process_id) [end_id, _] = bpmn_graph.add_end_event_to_diagram(process_id, end_event_name="END") bpmn_graph.add_sequence_flow_to_diagram(process_id, root_end, end_id, "s") layouter.generate_layout(bpmn_graph) visualizer.visualize_diagram(bpmn_graph) bpmn_graph.export_xml_file( "./", os.path.join("models", f"{FILE_NAME}-final_model.bpmn"))
def test_csv_export_manual_simple_diagram(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="Start event", start_event_definition="timer") [task1_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 1") [subprocess1_id, _] = bpmn_graph.add_subprocess_to_diagram( process_id, subprocess_name="Subprocess 1") [subprocess2_id, _] = bpmn_graph.add_subprocess_to_diagram( process_id, subprocess_name="Subprocess 2") [task2_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 2") [end_id, _] = bpmn_graph.add_end_event_to_diagram( process_id, end_event_name="End event", end_event_definition="message") bpmn_graph.add_sequence_flow_to_diagram( process_id, start_id, task1_id, sequence_flow_name="start_to_task_one") bpmn_graph.add_sequence_flow_to_diagram( process_id, task1_id, subprocess1_id, sequence_flow_name="task_one_to_subprocess_one") bpmn_graph.add_sequence_flow_to_diagram( process_id, subprocess1_id, subprocess2_id, sequence_flow_name="subprocess_one_to_subprocess_two") bpmn_graph.add_sequence_flow_to_diagram( process_id, subprocess2_id, task2_id, sequence_flow_name="subprocess_two_to_task_two") bpmn_graph.add_sequence_flow_to_diagram( process_id, task2_id, end_id, sequence_flow_name="task_two_to_end") bpmn_graph.export_csv_file(self.output_directory, "simple_diagram.csv") bpmn_graph.export_xml_file(self.output_directory, "simple_diagram.bpmn")
def recognize_patterns(self): # one process only self.bpmn_graph = diagram.BpmnDiagramGraph() self.bpmn_graph.create_new_diagram_graph(diagram_name="BP Diagram") process_id = self.bpmn_graph.add_process_to_diagram() for task in self.TI: self.bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="trigger_" + task, start_event_definition="timer") _ = self._check_create_task(process_id, task) # join triggering with first_task self._add_sequence_flow_by_names(process_id, "trigger_" + task, task) find_results = self.find_in_YL(task) if find_results: next_tasks = self.add_to_graph(process_id, find_results, task) else: print("No more tasks") continue while next_tasks: for task in next_tasks: # print("task:", task) find_results = self.find_in_YL(task) if find_results: next_tasks = self.add_to_graph(process_id, find_results, task) else: next_tasks = None for last_task in self.TO: self.bpmn_graph.add_end_event_to_diagram( process_id, end_event_name="end_" + task, end_event_definition="message") # join last_task with ending event self._add_sequence_flow_by_names(process_id, last_task, "end_" + task)
def __init__(self, log): self.algorithm_name = "split" self.log = log self.footprint = footprint(self.log, self.algorithm_name) self.succession = self.footprint.succession self.bpmn_graph = diagram.BpmnDiagramGraph() self.bpmn_graph.create_new_diagram_graph( diagram_name="split_miner_bpmn") self.process_id = self.bpmn_graph.add_process_to_diagram() self.node_ancestors = {} self.node_successors = {} self.event_incomes = [] self.event_outcomes = [] self.flows = [] self.frequency = [] self.significance = [] self.calculate_significance() self.significance_threshhold = 0.0 self.one_loop_threshhold = 0.0
def apply(net, initial_marking, final_marking, parameters=None): """ Convert the Petri net to a BPMN graph Parameters ----------- net Petri net initial_marking Initial marking of the Petri net final_marking Final marking of the Petri net parameters Parameters of the algorithm Returns ----------- bpmn_graph BPMN graph elements_correspondence Correspondence between meaningful elements of the Petri net (objects) and meaningful elements of the BPMN graph (dicts) inv_elements_correspondence Correspondence between meaningful elements of the BPMN graph (dicts) and meaningful elements of the Petri net (objects) el_corr_keys_map Correspondence between string-ed keys of elements_correspondence with the corresponding elements """ if parameters is None: parameters = {} del parameters bpmn_transitions_map = {} bpmn_graph = diagram.BpmnDiagramGraph() elements_correspondence = {} bpmn_graph.create_new_diagram_graph(diagram_name="diagram") process_id = bpmn_graph.add_process_to_diagram("1") [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="start", node_id=constants.START_EVENT_ID) [end_id, _] = bpmn_graph.add_end_event_to_diagram(process_id, end_event_name="end", node_id=constants.END_EVENT_ID) start_trans, start_involved_places, start_inv_arcs, start_inv_trans = get_start_trans_petri_given_imarking( initial_marking) final_trans, final_involved_places, final_inv_arcs, final_inv_trans = get_final_trans_petri_given_fmarking( final_marking) for trans in net.transitions: this_trans_id = str(uuid.uuid4()) this_trans_id_0 = this_trans_id[0] while not this_trans_id_0.isalpha(): this_trans_id = str(uuid.uuid4()) this_trans_id_0 = this_trans_id[0] if trans.label is not None: if trans in start_trans and len(start_trans) == 1: [task_id, task] = bpmn_graph.add_task_to_diagram(process_id, task_name=trans.label, node_id=this_trans_id) elif trans in final_trans and len(final_trans) == 1: [task_id, task] = bpmn_graph.add_task_to_diagram(process_id, task_name=trans.label, node_id=this_trans_id) else: [task_id, task] = bpmn_graph.add_task_to_diagram(process_id, task_name=trans.label, node_id=this_trans_id) bpmn_transitions_map[trans] = task_id elements_correspondence[trans] = task mapped_trans = {} mapped_arcs = {} mapped_places = {} for place in initial_marking: mapped_places[place] = start_id for place in final_marking: mapped_places[place] = end_id for place in net.places: if len(place.in_arcs) == 1 and len(place.out_arcs) == 1: in_trans = None out_trans = None in_arc = None out_arc = None for arc in place.in_arcs: in_arc = arc in_trans = arc.source for arc in place.out_arcs: out_arc = arc out_trans = arc.target if len(in_trans.out_arcs) > 1 and len(out_trans.in_arcs) == 1: if in_trans not in mapped_trans: gateway_name_split = in_trans.name gateway_id_split = in_trans.name [gateway_split, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name=gateway_name_split, node_id=gateway_id_split) mapped_trans[in_trans] = gateway_split elif len(out_trans.in_arcs) > 1 and len(in_trans.out_arcs) == 1: if out_trans not in mapped_trans: gateway_name_join = out_trans.name gateway_id_join = out_trans.name [gateway_join, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name=gateway_name_join, node_id=gateway_id_join) mapped_trans[out_trans] = gateway_join elif len(in_trans.out_arcs) == 1 and len(out_trans.in_arcs) == 1: # sequential place between two activities, convert it into direct arc :) flow = None if in_trans.label is not None and out_trans.label is not None: seq_flow_id, flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, bpmn_transitions_map[in_trans], bpmn_transitions_map[out_trans]) if in_trans not in mapped_trans: mapped_trans[in_trans] = bpmn_transitions_map[in_trans] if out_trans not in mapped_trans: mapped_trans[out_trans] = bpmn_transitions_map[ out_trans] if flow is not None: mapped_places[place] = flow mapped_arcs[in_arc] = flow mapped_arcs[out_arc] = flow elements_correspondence[in_arc] = flow elements_correspondence[out_arc] = flow # add remaining elements of the Petri net as happen in a Petri net for trans in net.transitions: if len(trans.in_arcs) == 1 and len(trans.out_arcs) == 1 and trans.label is None and not \ [arc.source for arc in trans.in_arcs][0] in initial_marking and not \ [arc.target for arc in trans.out_arcs][ 0] in final_marking: pass else: if trans not in mapped_trans: if trans.label is None: gateway_name = trans.name gateway_id_principal = trans.name if (len(trans.in_arcs) == 1 and len(trans.out_arcs) > 1 ) or (len(trans.out_arcs) == 1 and len(trans.in_arcs) > 1): [gateway_princ, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name=gateway_name, node_id=gateway_id_principal) else: [gateway_princ, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=gateway_name, node_id=gateway_id_principal) mapped_trans[trans] = gateway_princ else: mapped_trans[trans] = bpmn_transitions_map[trans] for trans in net.transitions: if len(trans.in_arcs) == 1 and len(trans.out_arcs) == 1 and trans.label is None and not \ [arc.source for arc in trans.in_arcs][0] in initial_marking and not \ [arc.target for arc in trans.out_arcs][0] in final_marking: pass else: if trans in mapped_trans: for arc in trans.in_arcs: if arc not in mapped_arcs: place = arc.source if place not in mapped_places and len(place.in_arcs) == 1 and len(place.out_arcs) == 1 and \ list(place.in_arcs)[0].source in mapped_trans: in_arc_0 = list(place.in_arcs)[0] in_trans = in_arc_0.source if not mapped_trans[in_trans] == mapped_trans[ trans]: seq_flow_id, inplace_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_trans[in_trans], mapped_trans[trans]) mapped_arcs[arc] = inplace_flow elements_correspondence[arc] = inplace_flow elements_correspondence[ in_arc_0] = inplace_flow mapped_places[place] = mapped_trans[in_trans] else: if place not in mapped_places: gateway_name_inplace = place.name gateway_id_inplace = place.name [ i, _ ] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=gateway_name_inplace, node_id=gateway_id_inplace) mapped_places[place] = i if not mapped_places[place] == mapped_trans[trans]: seq_flow_id, inplace_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_places[place], mapped_trans[trans]) mapped_arcs[arc] = inplace_flow elements_correspondence[arc] = inplace_flow for arc in trans.out_arcs: if arc not in mapped_arcs: place = arc.target if place not in mapped_places and len(place.in_arcs) == 1 and len(place.out_arcs) == 1 and \ list(place.out_arcs)[0].target in mapped_trans: out_arc_0 = list(place.out_arcs)[0] out_trans = out_arc_0.target if not mapped_trans[trans] == mapped_trans[ out_trans]: seq_flow_id, outp_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_trans[trans], mapped_trans[out_trans]) mapped_arcs[out_arc_0] = outp_flow elements_correspondence[out_arc_0] = outp_flow elements_correspondence[arc] = outp_flow mapped_places[place] = mapped_trans[out_trans] else: if place not in mapped_places: gateway_name_out = place.name gateway_id_outplace = place.name [ go, _ ] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=gateway_name_out, node_id=gateway_id_outplace) mapped_places[place] = go if not mapped_trans[trans] == mapped_places[place]: seq_flow_id, outp_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_trans[trans], mapped_places[place]) mapped_arcs[arc] = outp_flow elements_correspondence[arc] = outp_flow for trans in net.transitions: if len(trans.in_arcs) == 1 and len(trans.out_arcs) == 1 and trans.label is None and not \ [arc.source for arc in trans.in_arcs][0] in initial_marking and not \ [arc.target for arc in trans.out_arcs][ 0] in final_marking: arc_source = [arc for arc in trans.in_arcs][0] arc_target = [arc for arc in trans.out_arcs][0] place_source = arc_source.source place_target = arc_target.target if place_source in mapped_places and place_target in mapped_places: seq_flow_id, place_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_places[place_source], mapped_places[place_target]) mapped_arcs[arc_source] = place_flow # elements_correspondence[arc_source] = place_flow # elements_correspondence[arc_target] = place_flow for arc in net.arcs: if not arc in mapped_arcs: if type(arc.source) is PetriNet.Place: if not arc.source in mapped_places: [gateway_princ, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=arc.source.name, node_id=arc.source.name) mapped_places[arc.source] = gateway_princ elements_correspondence[arc.source] = gateway_princ if not arc.target in mapped_trans: [gateway_princ, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=arc.target.name, node_id=arc.target.name) mapped_trans[arc.target] = gateway_princ elements_correspondence[arc.target] = gateway_princ if not mapped_places[arc.source] == mapped_trans[arc.target]: seq_flow_id, place_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_places[arc.source], mapped_trans[arc.target]) mapped_arcs[arc] = place_flow elements_correspondence[arc] = place_flow else: if not arc.source in mapped_trans: [gateway_princ, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=arc.source.name, node_id=arc.source.name) mapped_trans[arc.source] = gateway_princ elements_correspondence[arc.source] = gateway_princ if not arc.target in mapped_places: [gateway_princ, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name=arc.target.name, node_id=arc.target.name) mapped_places[arc.target] = gateway_princ elements_correspondence[arc.target] = gateway_princ if not mapped_trans[arc.source] == mapped_places[arc.target]: seq_flow_id, place_flow = bpmn_graph.add_sequence_flow_to_diagram( process_id, mapped_trans[arc.source], mapped_places[arc.target]) mapped_arcs[arc] = place_flow elements_correspondence[arc] = place_flow inv_elements_correspondence = {} for el in elements_correspondence.keys(): petri_el_type = get_petri_el_type(el) el_type = get_bpmn_el_type(elements_correspondence[el]) if (petri_el_type == "transition" and el_type == "task") or (petri_el_type == "arc" and el_type == "arc"): corresp_el = str(elements_correspondence[el]) if corresp_el not in inv_elements_correspondence: inv_elements_correspondence[corresp_el] = [] if el not in inv_elements_correspondence[corresp_el]: inv_elements_correspondence[corresp_el].append(el) el_corr_keys_map = {} for el in elements_correspondence: el_corr_keys_map[str(el)] = el removed = True while removed: removed = False nodes = bpmn_graph.diagram_graph.nodes nodes_keys = list(nodes.keys()) i = 0 while i < len(nodes_keys): node_key = nodes_keys[i] node = nodes[nodes_keys[i]] if node['type'] != 'startEvent' and node['type'] != 'endEvent' and ( len(node['incoming']) == 0 or len(node['outgoing']) == 0): bpmn_graph.diagram_graph.remove_node(node_key) del nodes_keys[i] removed = True continue i = i + 1 return bpmn_graph, elements_correspondence, inv_elements_correspondence, el_corr_keys_map
def test_odt_export_nested_gates_example(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(self.example_directory + "nested-gates.bpmn")) bpmn_graph.export_odt_file(self.output_directory, "nested-gates.odt")
def test_odt_export_bank_account_example(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(self.example_directory + "bank-account-process.bpmn")) bpmn_graph.export_odt_file(self.output_directory, "bank-account-process.odt")
def test_create_diagram_manually(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="start_event") [task1_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="First task") [subprocess1_id, _ ] = bpmn_graph.add_subprocess_to_diagram(process_id, subprocess_name="Subprocess") bpmn_graph.add_sequence_flow_to_diagram(process_id, start_id, task1_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_id, subprocess1_id) [parallel_gate_fork_id, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name="parallel_gate_fork") [task1_par_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1_par") [task2_par_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2_par") [parallel_gate_join_id, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name="parallel_gate_join") bpmn_graph.add_sequence_flow_to_diagram(process_id, subprocess1_id, parallel_gate_fork_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, parallel_gate_fork_id, task1_par_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, parallel_gate_fork_id, task2_par_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_par_id, parallel_gate_join_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_par_id, parallel_gate_join_id) [exclusive_gate_fork_id, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name="exclusive_gate_fork") [task1_ex_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1_ex") [task2_ex_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2_ex") [exclusive_gate_join_id, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name="exclusive_gate_join") bpmn_graph.add_sequence_flow_to_diagram(process_id, parallel_gate_join_id, exclusive_gate_fork_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_fork_id, task1_ex_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_fork_id, task2_ex_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_ex_id, exclusive_gate_join_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_ex_id, exclusive_gate_join_id) [inclusive_gate_fork_id, _] = bpmn_graph.add_inclusive_gateway_to_diagram( process_id, gateway_name="inclusive_gate_fork") [task1_in_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1_in") [task2_in_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2_in") [inclusive_gate_join_id, _] = bpmn_graph.add_inclusive_gateway_to_diagram( process_id, gateway_name="inclusive_gate_join") bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_join_id, inclusive_gate_fork_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, inclusive_gate_fork_id, task1_in_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, inclusive_gate_fork_id, task2_in_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_in_id, inclusive_gate_join_id) bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_in_id, inclusive_gate_join_id) [end_id, _] = bpmn_graph.add_end_event_to_diagram(process_id, end_event_name="end_event") bpmn_graph.add_sequence_flow_to_diagram(process_id, inclusive_gate_join_id, end_id) layouter.generate_layout(bpmn_graph) bpmn_graph.export_xml_file(self.output_directory, self.output_file_with_di) bpmn_graph.export_xml_file_no_di(self.output_directory, self.output_file_no_di) # Uncomment line below to get a simple view of created diagram # visualizer.visualize_diagram(bpmn_graph) visualizer.bpmn_diagram_to_dot_file( bpmn_graph, self.output_directory + self.output_dot_file) visualizer.bpmn_diagram_to_png( bpmn_graph, self.output_directory + self.output_png_file)
def load_example_diagram(filepath): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file(os.path.abspath(filepath)) return bpmn_graph
def test_create_diagram_manually(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="start_event", start_event_definition="timer") [task1_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1") bpmn_graph.add_sequence_flow_to_diagram(process_id, start_id, task1_id, "start_to_one") [exclusive_gate_fork_id, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name="exclusive_gate_fork") [task1_ex_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task1_ex") [task2_ex_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2_ex") [exclusive_gate_join_id, _] = bpmn_graph.add_exclusive_gateway_to_diagram( process_id, gateway_name="exclusive_gate_join") bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_id, exclusive_gate_fork_id, "one_to_ex_fork") bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_fork_id, task1_ex_id, "ex_fork_to_ex_one") bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_fork_id, task2_ex_id, "ex_fork_to_ex_two") bpmn_graph.add_sequence_flow_to_diagram(process_id, task1_ex_id, exclusive_gate_join_id, "ex_one_to_ex_join") bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_ex_id, exclusive_gate_join_id, "ex_two_to_ex_join") [task2_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="task2") [end_id, _] = bpmn_graph.add_end_event_to_diagram( process_id, end_event_name="end_event", end_event_definition="message") bpmn_graph.add_sequence_flow_to_diagram(process_id, exclusive_gate_join_id, task2_id, "ex_join_to_two") bpmn_graph.add_sequence_flow_to_diagram(process_id, task2_id, end_id, "two_to_end") layouter.generate_layout(bpmn_graph) bpmn_graph.export_xml_file(self.output_directory, self.output_file_with_di) bpmn_graph.export_xml_file_no_di(self.output_directory, self.output_file_no_di) # Uncomment line below to get a simple view of created diagram # visualizer.visualize_diagram(bpmn_graph) visualizer.bpmn_diagram_to_dot_file( bpmn_graph, self.output_directory + self.output_dot_file) visualizer.bpmn_diagram_to_png( bpmn_graph, self.output_directory + self.output_png_file)
def test_csv_export_credit_process_example(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file( os.path.abspath(self.example_directory + "credit-process.bpmn")) bpmn_graph.export_csv_file(self.output_directory, "credit-process.csv")
import os import bpmn_python.bpmn_diagram_rep as diagram # Import algorithms import metrics import triple_s import knoma_proc import match_sss import refmod_mine_nlm import opbot # Source dir for models dirpath = ".\\resources\\diagrams2\\" # Load example diagram from file example_diagram = diagram.BpmnDiagramGraph() example_diagram.load_diagram_from_xml_file("./resources/dataset1/models/Cologne.bpmn") print(example_diagram) modelFiles = os.listdir(dirpath) models = [] name_model = {} # OPBOT implementation requires dictionary {model_name:loaded_model} # Load diagrams from files and convert them to format used by library for f in modelFiles: diag = diagram.BpmnDiagramGraph() diag.load_diagram_from_xml_file(dirpath + f) models.append(diag) name_model[f.split('.')[0]] = diag for i in range(0, (len(models) - 1)): metrics.check_diagrams_metics(models[i], models[i + 1], True) # To get matches from two diagrams simply pass them to algorithm function triple_s_results = triple_s.get_triple_s_matches(models[i], models[i + 1], syntactic_weight=0.5,
import bpmn_python.bpmn_diagram_rep as diagram bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file("C:\\Users\\spetr\\Desktop\\BPMN-Usati_nel_paper\\GC_BPMN_CON_ATTRIBUTE.bpmn") lista = bpmn_graph.get_nodes() for tuple in lista: for dizionario in tuple: if type(dizionario) is dict: if dizionario['type'].endswith("Task"): #print(dizionario['type']) print(dizionario)
matchSSS_scores = [] refmod_mine_scores = [] opbot_scores = [] knomaproc_scores = [] #chosen_one = 'matchSSS' chosen_one='tripleS' # chosen_one='refmodmine' # chosen_one = 'opbot' # chosen_one='knomaproc' # load models from dataset1 models = {} name_model = {} for file_name in os.listdir(models_path): diag = diagram.BpmnDiagramGraph() diag.load_diagram_from_xml_file(models_path + "/" + file_name) models[file_name.split('.')[0]] = diag name_model[file_name.split('.')[0]] = diag chosen_results = dict() # load pair names from gold standard i = 0 if chosen_one == 'opbot': models_pairs = opbot.get_model_pairs(name_model) for k in range(0, 36, 3): print('iteration:' + str(k)) part_of_pairs = list(models_pairs)[k:(k + 3)]
def test_csv_export_pizza_order_example(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file( os.path.abspath(self.example_directory + "pizza-order.bpmn")) bpmn_graph.export_csv_file(self.output_directory, "pizza-order.csv")
def recognize_patterns_to_graph(self, threshold): Xl_a = [] Xl_b = [] Xl_c = [] P_d = [] P_e = [] L_1 = [] L_2 = [] #TODO: cleanup T_0 = list(self.norm_relation_frequency_df.columns) # list(logs.task.unique()) relations = np.array(self.get_relation_frequency_matrix()) loops = np.array(self.get_2loop_frequency_matrix()) for task in range(len(T_0)): x = task # that's L_1 if relations[x, x] > threshold: aa = self.negative_in_row(relations[x], x) # a->bb (minus w rzędzie b) cc = self.positive_in_row(relations[x], x) # bb->c (plus w b) if not aa + 1: print('todo_a') # L_1.append(()) elif not cc + 1: print('todo_c') # L_1.append(()) else: L_1.append((T_0[aa], T_0[x], T_0[cc])) # y = 1 y = self.next_no_nan_index(relations[x], 0) if not y: continue # print(y) for i in range(len(T_0) - x): a = x + i # print(x,a) # that's L_2 if loops[x, a] > 0: # print('got it') aba = self.negative_in_row(relations[x], x) # a->bcb (minus w rzędzie b) cbc = self.positive_in_row(relations[x], x) # bcb->d (plus w b) L_2.append((T_0[aba], (T_0[x], T_0[a], T_0[x]), T_0[cbc])) # that's A if relations[x, a] > threshold and relations[a, x] < -threshold: Xl_a.append((T_0[x], T_0[a])) # A is ok for i in range(len(T_0) - y): a = y + i z = self.next_no_nan_index(relations[x], a) # print(x,a,z) if not (a and z): continue # that's B,C if np.all(relations[x, a] > threshold and relations[x, z] > threshold and np.isnan(relations[a, z])): Xl_b.append((T_0[x], (T_0[a], T_0[z]))) if np.all(relations[x, a] < -threshold and relations[x, z] < -threshold and np.isnan(relations[a, z])): Xl_c.append(((T_0[a], T_0[z]), T_0[x])) # C is ok # that's D,E if np.all( relations[x, a] > -threshold and relations[x, z] > -threshold and relations[a, z] < threshold): P_d.append((T_0[x], (T_0[a], T_0[z]))) # k if np.all(relations[x, a] < threshold and relations[x, z] < threshold and relations[a, z] < threshold): P_e.append(((T_0[a], T_0[z]), T_0[x])) Yl = copy.deepcopy(Xl_a) # print(Yl) for bit in Xl_b: if ((bit[0], bit[1][0])) in Yl: Yl.remove((bit[0], bit[1][0])) if ((bit[0], bit[1][1])) in Yl: Yl.remove((bit[0], bit[1][1])) # Yl.append(bit) for bit in Xl_c: if ((bit[0][0], bit[1])) in Yl: Yl.remove((bit[0][0], bit[1])) if ((bit[0][1], bit[1])) in Yl: Yl.remove((bit[0][1], bit[1])) # Yl.append(bit) for bit in P_d: if ((bit[0], bit[1][0])) in Yl: Yl.remove((bit[0], bit[1][0])) if ((bit[0], bit[1][1])) in Yl: Yl.remove((bit[0], bit[1][1])) # Yl.append(bit) for bit in P_e: if ((bit[0][0], bit[1])) in Yl: Yl.remove((bit[0][0], bit[1])) if ((bit[0][1], bit[1])) in Yl: Yl.remove((bit[0][1], bit[1])) # Yl.append(bit) # TODO: if bit in L1/L2 remove from b/c/d/e ? for bit in L_1: if ((bit[0], bit[1])) in Yl: Yl.remove((bit[0], bit[1])) if ((bit[1], bit[2])) in Yl: Yl.remove((bit[1], bit[2])) # Yl.append(bit) for bit in L_2: if ((bit[0], bit[1][0])) in Yl: Yl.remove((bit[0], bit[1][0])) if ((bit[0], bit[1][1])) in Yl: Yl.remove((bit[0], bit[1][1])) if ((bit[1][0], bit[2])) in Yl: Yl.remove((bit[1][0], bit[2])) # Yl.append(bit) # print(Yl) # print(Xl_b) # print(Xl_c) # print(P_d) # print(P_e) # print(L_1) # print(L_2) self.bpmn_graph = diagram.BpmnDiagramGraph() self.bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = self.bpmn_graph.add_process_to_diagram() [start_id, _] = self.bpmn_graph.add_start_event_to_diagram(process_id, start_event_name="start_event", ) xors_fork = [] for n in Xl_b: xors_fork.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_fork"))[0]) xors_fork_l1 = [] for n in L_1: xors_fork_l1.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_fork"))[0]) xors_fork_l2 = [] for n in L_2: xors_fork_l2.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_fork"))[0]) ands_fork = [] for t in P_d: ands_fork.append((self.bpmn_graph.add_parallel_gateway_to_diagram(process_id, gateway_name="and_fork"))[0]) all_tasks = [] for task in T_0: all_tasks.append((self.bpmn_graph.add_task_to_diagram(process_id, task_name=str(task)))[0]) # print(all_tasks) xors_join = [] for i in Xl_c: xors_join.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_join"))[0]) xors_join_l1 = [] for n in L_1: xors_join_l1.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_join"))[0]) xors_join_l2 = [] for n in L_2: xors_join_l2.append((self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_join"))[0]) ands_join = [] for k in P_e: ands_join.append((self.bpmn_graph.add_parallel_gateway_to_diagram(process_id, gateway_name="and_join"))[0]) [end_id, _] = self.bpmn_graph.add_end_event_to_diagram(process_id, end_event_name="end_event", ) if len(self.TI) > 1: [first_xor, _] = self.bpmn_graph.add_exclusive_gateway_to_diagram(process_id, gateway_name="xor_fork") # start_id -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=start_id, target_ref_id=first_xor) for elem in self.TI: self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=first_xor, target_ref_id=all_tasks[T_0.index(elem)]) # XOR -> bit else: self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=start_id, target_ref_id=all_tasks[T_0.index(list(self.TI)[0])]) # start_event -> self.TI[0] for bits in self.TO: self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(bits)], target_ref_id=end_id) # bit -> end_event for num, B in enumerate(Xl_b): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(B[0])], target_ref_id=xors_fork[num]) # B[0] -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork[num], target_ref_id=all_tasks[T_0.index(B[1][0])]) # XOR -> B[1][0] self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork[num], target_ref_id=all_tasks[T_0.index(B[1][1])]) # XOR -> B[1][1] for num, C in enumerate(Xl_c): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(C[0][0])], target_ref_id=xors_join[num]) # C[0][0] -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(C[0][1])], target_ref_id=xors_join[num]) # C[0][1] -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_join[num], target_ref_id=all_tasks[T_0.index(C[1])]) # XOR -> C[1] for num, D in enumerate(P_d): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(D[0])], target_ref_id=ands_fork[num]) # D[0] -> AND self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=ands_fork[num], target_ref_id=all_tasks[T_0.index(D[1][0])]) # AND -> D[1][0] self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=ands_fork[num], target_ref_id=all_tasks[T_0.index(D[1][1])]) # AND -> D[1][1] for num, E in enumerate(P_e): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(E[0][0])], target_ref_id=ands_join[num]) # E[0][0] -> AND self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(E[0][1])], target_ref_id=ands_join[num]) # E[0][1] -> AND self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=ands_join[num], target_ref_id=all_tasks[T_0.index(E[1])]) # AND -> E[1] for A in Yl: self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(A[0])], target_ref_id=all_tasks[T_0.index(A[1])]) # A[0] -> A[1] for num, L in enumerate(L_1): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(L[0])], target_ref_id=xors_join_l1[num]) # A -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(L[1])], target_ref_id=xors_fork_l1[num]) # L -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_join_l1[num], target_ref_id=all_tasks[T_0.index(L[1])]) # XOR -> L self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork_l1[num], target_ref_id=xors_join_l1[num]) # XOR -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork_l1[num], target_ref_id=all_tasks[T_0.index(L[2])]) # XOR -> C for num, L in enumerate(L_2): self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(L[0])], target_ref_id=xors_join_l2[num]) # A -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(L[1][0])], target_ref_id=xors_fork_l2[num]) # B -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_join_l2[num], target_ref_id=all_tasks[T_0.index(L[1][0])]) # XOR -> B self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork_l2[num], target_ref_id=all_tasks[T_0.index(L[1][1])]) # XOR -> C self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=all_tasks[T_0.index(L[1][1])], target_ref_id=xors_join_l2[num]) # C -> XOR self.bpmn_graph.add_sequence_flow_to_diagram(process_id, source_ref_id=xors_fork_l2[num], target_ref_id=all_tasks[T_0.index(L[2])]) # XOR -> D
def test_csv_export_tram_process_example(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.load_diagram_from_xml_file( os.path.abspath(self.example_directory + "tram-process.bpmn"))
def test_csv_export_diagram_with_inclusive_parallel_gateway(self): bpmn_graph = diagram.BpmnDiagramGraph() bpmn_graph.create_new_diagram_graph(diagram_name="diagram1") process_id = bpmn_graph.add_process_to_diagram() [start_id, _] = bpmn_graph.add_start_event_to_diagram( process_id, start_event_name="Start event", start_event_definition="timer") [task1_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 1") [exclusive_gate_fork_id, _] = bpmn_graph.add_inclusive_gateway_to_diagram( process_id, gateway_name="Inclusive gate fork") [task2_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 2") [task3_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 3") [task6_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 6") [exclusive_gate_join_id, _] = bpmn_graph.add_inclusive_gateway_to_diagram( process_id, gateway_name="Inclusive gate join") [parallel_gate_fork_id, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name="Parallel gateway fork") [task4_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 4") [task5_id, _] = bpmn_graph.add_task_to_diagram(process_id, task_name="Task 5") [parallel_gate_join_id, _] = bpmn_graph.add_parallel_gateway_to_diagram( process_id, gateway_name="Parallel gateway join") [end_id, _] = bpmn_graph.add_end_event_to_diagram( process_id, end_event_name="End event", end_event_definition="message") bpmn_graph.add_sequence_flow_to_diagram( process_id, start_id, task1_id, sequence_flow_name="Start to one") bpmn_graph.add_sequence_flow_to_diagram( process_id, task1_id, exclusive_gate_fork_id, sequence_flow_name="Task one to exclusive fork") bpmn_graph.add_sequence_flow_to_diagram( process_id, exclusive_gate_fork_id, task2_id, sequence_flow_name="Condition: approved") bpmn_graph.add_sequence_flow_to_diagram( process_id, task2_id, task3_id, sequence_flow_name="Task two to task three") bpmn_graph.add_sequence_flow_to_diagram( process_id, exclusive_gate_fork_id, parallel_gate_fork_id, sequence_flow_name="Condition: rejected") bpmn_graph.add_sequence_flow_to_diagram( process_id, parallel_gate_fork_id, task4_id, sequence_flow_name="Parallel fork to task four") bpmn_graph.add_sequence_flow_to_diagram( process_id, parallel_gate_fork_id, task5_id, sequence_flow_name="Parallel fork to task five") bpmn_graph.add_sequence_flow_to_diagram( process_id, task4_id, parallel_gate_join_id, sequence_flow_name="Task four to parallel join") bpmn_graph.add_sequence_flow_to_diagram( process_id, task5_id, parallel_gate_join_id, sequence_flow_name="Task five to parallel join") bpmn_graph.add_sequence_flow_to_diagram( process_id, parallel_gate_join_id, task6_id, sequence_flow_name="Parallel join to task six") bpmn_graph.add_sequence_flow_to_diagram( process_id, task3_id, exclusive_gate_join_id, sequence_flow_name="Task three to exclusive join") bpmn_graph.add_sequence_flow_to_diagram( process_id, task6_id, exclusive_gate_join_id, sequence_flow_name="Task six to exclusive join") bpmn_graph.add_sequence_flow_to_diagram( process_id, exclusive_gate_join_id, end_id, sequence_flow_name="Exclusive join to end event") bpmn_graph.export_csv_file(self.output_directory, "inclusive_parallel_gateways_diagram.csv") bpmn_graph.export_xml_file(self.output_directory, "inclusive_parallel_gateways_diagram.bpmn")
def test_thesis_models(self): format_three_dec = "{0:.3f}" format_two_dec = "{0:.2f}" names = [ "model1", "model2", "model3", "model4", "model5", "model6", "model7", "model8", "model9", "model10", "model11", "model12", "model13", "model14", "model15", "model16", "model17", "model18", "model19", "model20", "model21", "model22", "model23", "model24", "model25", "model26", "model27", "model28", "model29", "model30", "model31", "model32" ] with open("./output/metrics_part1.csv", "w") as file_one: with open("./output/metrics_part2.csv", "w") as file_two: with open("./output/metrics_min_max.csv", "w") as file_three: # write header file_one.write("Model name,NOA-H,NOA-G,NOA-diff,NOA-prop,NOC-H,NOC-G,NOC-diff,NOC-prop\n") file_two.write("Model name,CNC-H,CNC-G,CNC-diff,Avg-H,Avg-G,Avg-diff,Heter-H,Heter-G,Heter-diff\n") counter = 1 noa_max_diff = None noa_max_diff_index = 0 noa_max_prop = None noa_max_prop_index = 0 noa_min_diff = None noa_min_diff_index = 0 noa_min_prop = None noa_min_prop_index = 0 noa_sum = 0 noc_max_diff = None noc_max_diff_index = 0 noc_max_prop = None noc_max_prop_index = 0 noc_min_diff = None noc_min_diff_index = 0 noc_min_prop = None noc_min_prop_index = 0 noc_sum = 0 cnc_max = None cnc_max_diff = None cnc_max_index = 0 cnc_min = None cnc_min_diff = None cnc_min_index = 0 cnc_diff_sum = 0 avg_max_diff = None avg_max_index = 0 avg_min_diff = None avg_min_index = 0 avg_diff_sum = 0 heter_max_diff = None heter_max_index = 0 heter_min_diff = None heter_min_index = 0 for model_name in names: print(model_name) hand_made_bpmn = diagram.BpmnDiagramGraph() hand_made_bpmn.load_diagram_from_xml_file(self.hand_made_models + model_name + ".bpmn") hand_made_noa = metrics.NOA_metric(hand_made_bpmn) hand_made_noc = metrics.NOAC_metric(hand_made_bpmn) - hand_made_noa hand_made_cnc = metrics.CoefficientOfNetworkComplexity_metric(hand_made_bpmn) if metrics.all_gateways_count(hand_made_bpmn) > 0: hand_made_avg = metrics.AverageGatewayDegree_metric(hand_made_bpmn) else: hand_made_avg = 0 hand_made_heter = int(metrics.GatewayHeterogenity_metric(hand_made_bpmn)) gen_bpmn = diagram.BpmnDiagramGraph() gen_bpmn.load_diagram_from_xml_file(self.generated_models + model_name + ".bpmn") gen_noa = metrics.NOA_metric(gen_bpmn) gen_noc = metrics.NOAC_metric(gen_bpmn) - gen_noa gen_cnc = metrics.CoefficientOfNetworkComplexity_metric(gen_bpmn) if cnc_max is None: cnc_max = gen_cnc elif cnc_max < gen_cnc: cnc_max = gen_cnc if cnc_min is None: cnc_min = gen_cnc elif cnc_min > gen_cnc: cnc_min = gen_cnc if metrics.all_gateways_count(gen_bpmn) > 0: gen_avg = metrics.AverageGatewayDegree_metric(gen_bpmn) else: gen_avg = 0 gen_heter = int(metrics.GatewayHeterogenity_metric(gen_bpmn)) noa_diff = hand_made_noa - gen_noa noa_prop = (noa_diff * 100.0) / hand_made_noa noa_sum += noa_prop if noa_max_diff is None: noa_max_diff = noa_diff noa_max_diff_index = counter elif noa_diff > noa_max_diff: noa_max_diff = noa_diff noa_max_diff_index = counter if noa_max_prop is None: noa_max_prop = noa_diff noa_max_prop_index = counter elif noa_prop > noa_max_prop: noa_max_prop = noa_prop noa_max_prop_index = counter if noa_min_diff is None: noa_min_diff = noa_diff noa_min_diff_index = counter elif noa_diff < noa_min_diff: noa_min_diff = noa_diff noa_min_diff_index = counter if noa_min_prop is None: noa_min_prop = noa_diff noa_min_prop_index = counter elif noa_prop < noa_min_prop: noa_min_prop = noa_prop noa_min_prop_index = counter noc_diff = hand_made_noc - gen_noc noc_prop = (noc_diff * 100.0) / hand_made_noc noc_sum += noc_prop if noc_max_diff is None: noc_max_diff = noc_diff noc_max_diff_index = counter elif noc_diff > noc_max_diff: noc_max_diff = noc_diff noc_max_diff_index = counter if noc_max_prop is None: noc_max_prop = noc_prop noc_max_prop_index = counter elif noc_prop > noc_max_prop: noc_max_prop = noc_prop noc_max_prop_index = counter if noc_min_diff is None: noc_min_diff = noc_diff noc_min_diff_index = counter elif noc_diff < noc_min_diff: noc_min_diff = noc_diff noc_min_diff_index = counter if noc_min_prop is None: noc_min_prop = noc_prop noc_min_prop_index = counter elif noc_prop < noc_min_prop: noc_min_prop = noc_prop noc_min_prop_index = counter cnc_diff = hand_made_cnc - gen_cnc cnc_diff_sum += cnc_diff if cnc_max_diff is None: cnc_max_diff = cnc_diff elif cnc_diff > cnc_max_diff: cnc_max_diff = cnc_diff cnc_max_index = counter if cnc_min_diff is None: cnc_min_diff = cnc_diff elif cnc_diff < cnc_min_diff: cnc_min_diff = cnc_diff cnc_min_index = counter avg_diff = hand_made_avg - gen_avg avg_diff_sum += avg_diff if avg_max_diff is None: avg_max_diff = avg_diff elif avg_diff > avg_max_diff: avg_max_diff = avg_diff avg_max_index = counter if avg_min_diff is None: avg_min_diff = avg_diff elif avg_diff < avg_min_diff: avg_min_diff = avg_diff avg_min_index = counter heter_diff = hand_made_heter - gen_heter if heter_max_diff is None: heter_max_diff = heter_diff elif heter_diff > heter_max_diff: heter_max_diff = heter_diff heter_max_index = counter if heter_min_diff is None: heter_min_diff = heter_diff elif heter_diff < heter_min_diff: heter_min_diff = heter_diff heter_min_index = counter file_one.write("Model " + str(counter) + "," + str(hand_made_noa) + "," + str(gen_noa) + "," + str(noa_diff) + "," + format_two_dec.format(noa_prop) + "\%," + str(hand_made_noc) + "," + str(gen_noc) + "," + str(noc_diff) + "," + format_two_dec.format(noc_prop) + "\%\n") file_two.write("Model " + str(counter) + "," + format_three_dec.format(hand_made_cnc) + "," + format_three_dec.format(gen_cnc) + "," + format_three_dec.format(cnc_diff) + "," + format_three_dec.format(hand_made_avg) + "," + format_three_dec.format(gen_avg) + "," + format_three_dec.format(avg_diff) + "," + str(hand_made_heter) + "," + str(gen_heter) + "," + str(heter_diff) + "\n") counter += 1 file_three.write( "CNC metric: avg=" + format_three_dec.format(cnc_diff_sum / counter) + ", min=" + format_three_dec.format(cnc_min_diff) + ", model: " + str(cnc_min_index) + ", max=" + format_three_dec.format(cnc_max_diff) + ", model: " + str(cnc_max_index) + ", global min: " + format_three_dec.format(cnc_min) + ", global max: " + format_three_dec.format(cnc_max) + "\n") file_three.write( "Average Gateway Degree metric: avg=" + format_three_dec.format(avg_diff_sum / counter) + ", min=" + format_three_dec.format(avg_min_diff) + ", model: " + str(avg_min_index) + ", max=" + format_three_dec.format(avg_max_diff) + ", model: " + str(avg_max_index) + "\n") file_three.write( "Gateway Heterogenity metric: " + "min=" + str(heter_min_diff) + ", model: " + str(heter_min_index) + ", max=" + str(heter_max_diff) + ", model: " + str(heter_max_index) + "\n") file_three.write( "NOA metric (diff): " + "min=" + str(noa_min_diff) + ", model: " + str(noa_min_diff_index) + ", max=" + str(noa_max_diff) + ", model: " + str(noa_max_diff_index) + "\n") file_three.write( "NOA metric (prop): " + "min=" + format_two_dec.format(noa_min_prop) + ", model: " + str(noa_min_prop_index) + ", max=" + format_two_dec.format(noa_max_prop) + ", model: " + str(noa_max_prop_index) + ", average: " + format_two_dec.format(noa_sum / counter) + "\n") file_three.write( "NOC metric (diff): " + "min=" + str(noc_min_diff) + ", model: " + str(noc_min_diff_index) + ", max=" + str(noc_max_diff) + ", model: " + str(noc_max_diff_index) + "\n") file_three.write( "NOC metric (prop): " + "min=" + format_two_dec.format(noc_min_prop) + ", model: " + str(noc_min_prop_index) + ", max=" + format_two_dec.format(noc_max_prop) + ", model: " + str(noc_max_prop_index) + ", average: " + format_two_dec.format(noc_sum / counter) + "\n")