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")
