source = PetriNet.Place("source") sink = PetriNet.Place("sink") p_1 = PetriNet.Place("p_1") # add the places to the Petri Net net.places.add(source) net.places.add(sink) net.places.add(p_1) # Create transitions t_1 = PetriNet.Transition("name_1", "label_1") t_2 = PetriNet.Transition("name_2", "label_2") # Add the transitions to the Petri Net net.transitions.add(t_1) net.transitions.add(t_2) # Add arcs from pm4py.objects.petri import utils utils.add_arc_from_to(source, t_1, net) utils.add_arc_from_to(t_1, p_1, net) utils.add_arc_from_to(p_1, t_2, net) utils.add_arc_from_to(t_2, sink, net) # Adding tokens initial_marking = Marking() initial_marking[source] = 1 final_marking = Marking() final_marking[sink] = 1 from pm4py.objects.petri.exporter import pnml as pnml_exporter pnml_exporter.export_net(net, initial_marking, "createdPetriNet1.pnml", final_marking=final_marking) from pm4py.visualization.petrinet import factory as pn_vis_factory
def construct_cost_aware(pn1, im1, fm1, pn2, im2, fm2, skip, pn1_costs, pn2_costs, sync_costs): """ Constructs the synchronous product net of two given Petri nets. :param pn1: Petri net 1 :param im1: Initial marking of Petri net 1 :param fm1: Final marking of Petri net 1 :param pn2: Petri net 2 :param im2: Initial marking of Petri net 2 :param fm2: Final marking of Petri net 2 :param skip: Symbol to be used as skip :param pn1_costs: dictionary mapping transitions of pn1 to corresponding costs :param pn2_costs: dictionary mapping transitions of pn2 to corresponding costs :param pn1_costs: dictionary mapping pairs of transitions in pn1 and pn2 to costs :param sync_costs: Costs of sync moves Returns ------- :return: Synchronous product net and associated marking labels are of the form (a,>>) """ sync_net = PetriNet('synchronous_product_net of %s and %s' % (pn1.name, pn2.name)) t1_map, p1_map = __copy_into(pn1, sync_net, True, skip) t2_map, p2_map = __copy_into(pn2, sync_net, False, skip) costs = dict() for t1 in pn1.transitions: costs[t1_map[t1]] = pn1_costs[t1] for t2 in pn2.transitions: costs[t2_map[t2]] = pn2_costs[t2] for t1 in pn1.transitions: for t2 in pn2.transitions: if t1.label == t2.label: sync = PetriNet.Transition((t1.name, t2.name), (t1.label, t2.label)) sync_net.transitions.add(sync) costs[sync] = sync_costs[(t1, t2)] for a in t1.in_arcs: add_arc_from_to(p1_map[a.source], sync, sync_net) for a in t2.in_arcs: add_arc_from_to(p2_map[a.source], sync, sync_net) for a in t1.out_arcs: add_arc_from_to(sync, p1_map[a.target], sync_net) for a in t2.out_arcs: add_arc_from_to(sync, p2_map[a.target], sync_net) sync_im = Marking() sync_fm = Marking() for p in im1: sync_im[p1_map[p]] = im1[p] for p in im2: sync_im[p2_map[p]] = im2[p] for p in fm1: sync_fm[p1_map[p]] = fm1[p] for p in fm2: sync_fm[p2_map[p]] = fm2[p] # update 06/02/2021: to distinguish the sync nets that are output of this method, put a property in the sync net sync_net.properties[properties.IS_SYNC_NET] = True return sync_net, sync_im, sync_fm, costs
def apply(bpmn_graph, parameters=None): """ Apply conversion from a BPMN graph to a Petri net along with an initial and final marking Parameters ----------- bpmn_graph BPMN graph parameters Parameters of the algorithm Returns ----------- net Petri net initial_marking Initial marking of the Petri net final_marking Final marking of the Petri net 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 = {} enable_reduction = parameters[ "enable_reduction"] if "enable_reduction" in parameters else False del parameters net = PetriNet("converted_net") nodes = bpmn_graph.get_nodes() corresponding_in_nodes = {} corresponding_out_nodes = {} elements_correspondence = {} inv_elements_correspondence = {} el_corr_keys_map = {} start_event_subprocess = {} end_event_subprocess = {} sources = [] targets = [] # adds nodes for node in nodes: node_id = node[1]['id'] if 'id' in node[1] else node[0] node_name = node[1]['node_name'].replace("\r", " ").replace( "\n", " ").strip() if 'node_name' in node[1] else None node_type = node[1]['type'].lower() if 'type' in node[1] else "" node_process = node[1]['process'] if 'process' in node[1] else None if not "type" in node[1]: # some problem with the importing of inclusive gateways node_type = 'inclusivegateway' trans = None if "task" in node_type: trans = get_transition(node_id, node_name) net.transitions.add(trans) elements_correspondence[trans] = node[1] if not str(node[1]) in inv_elements_correspondence: inv_elements_correspondence[str(node[1])] = [] inv_elements_correspondence[str(node[1])].append(trans) input_place = PetriNet.Place('it_' + node_id) net.places.add(input_place) output_place = PetriNet.Place('ot_' + node_id) net.places.add(output_place) corresponding_in_nodes[node_id] = [input_place] corresponding_out_nodes[node_id] = [output_place] utils.add_arc_from_to(input_place, trans, net) utils.add_arc_from_to(trans, output_place, net) elif "gateway" in node_type: if "parallelgateway" in node_type: place = PetriNet.Place('pp_' + node_id) net.places.add(place) corresponding_in_nodes[node_id] = [] corresponding_out_nodes[node_id] = [] htrans = get_transition(str(uuid.uuid4()), None) net.transitions.add(htrans) utils.add_arc_from_to(htrans, place, net) for edge in node[1]['incoming']: str(edge) hplace = PetriNet.Place(str(uuid.uuid4())) net.places.add(hplace) utils.add_arc_from_to(hplace, htrans, net) corresponding_in_nodes[node_id].append(hplace) htrans = get_transition(str(uuid.uuid4()), None) net.transitions.add(htrans) utils.add_arc_from_to(place, htrans, net) for edge in node[1]['outgoing']: str(edge) hplace = PetriNet.Place(str(uuid.uuid4())) net.places.add(hplace) utils.add_arc_from_to(htrans, hplace, net) corresponding_out_nodes[node_id].append(hplace) elif "inclusivegateway" in node_type: input_place = PetriNet.Place('i_' + node_id) net.places.add(input_place) corresponding_in_nodes[node_id] = [] added_places_input = [] for edge in node[1]['incoming']: str(edge) hplace = PetriNet.Place(str(uuid.uuid4())) net.places.add(hplace) added_places_input.append(hplace) corresponding_in_nodes[node_id].append(hplace) for i in range(1, len(added_places_input) + 1): subsets = findsubsets(set(added_places_input), i) for subset in subsets: htrans = get_transition(str(uuid.uuid4()), None) net.transitions.add(htrans) utils.add_arc_from_to(htrans, input_place, net) for place in subset: utils.add_arc_from_to(place, htrans, net) corresponding_out_nodes[node_id] = [] added_places_output = [] for edge in node[1]['outgoing']: str(edge) hplace = PetriNet.Place(str(uuid.uuid4())) net.places.add(hplace) added_places_output.append(hplace) corresponding_out_nodes[node_id].append(hplace) for i in range(1, len(added_places_output) + 1): subsets = findsubsets(set(added_places_output), i) for subset in subsets: htrans = get_transition(str(uuid.uuid4()), None) net.transitions.add(htrans) utils.add_arc_from_to(input_place, htrans, net) for place in subset: utils.add_arc_from_to(htrans, place, net) else: input_place = PetriNet.Place('i_' + node_id) net.places.add(input_place) output_place = PetriNet.Place('o_' + node_id) net.places.add(output_place) trans = get_transition(node_id, None) net.transitions.add(trans) utils.add_arc_from_to(input_place, trans, net) utils.add_arc_from_to(trans, output_place, net) corresponding_in_nodes[node_id] = [input_place] * len( node[1]['incoming']) corresponding_out_nodes[node_id] = [output_place] * len( node[1]['outgoing']) elif node_type == "startevent": source_place_source = PetriNet.Place("sourceplacesource_" + str(node_id)) net.places.add(source_place_source) sources.append(source_place_source) corresponding_in_nodes[node_id] = [source_place_source] if node_process not in corresponding_in_nodes: corresponding_in_nodes[node_process] = [] corresponding_in_nodes[node_process].append(source_place_source) start_event_subprocess[node_process] = source_place_source if not node_name.lower().startswith("start"): trans = get_transition("stt_" + node_id, node_name) net.transitions.add(trans) source_place_target = PetriNet.Place("stp_" + node_id) net.places.add(source_place_target) utils.add_arc_from_to(source_place_source, trans, net) utils.add_arc_from_to(trans, source_place_target, net) corresponding_out_nodes[node_id] = [source_place_target] else: corresponding_out_nodes[node_id] = [source_place_source] elif node_type == "endevent": sink_place_target = PetriNet.Place("sinkplacetarget_" + str(node_id)) net.places.add(sink_place_target) targets.append(sink_place_target) corresponding_out_nodes[node_id] = [sink_place_target] if node_process not in corresponding_out_nodes: corresponding_out_nodes[node_process] = [] corresponding_out_nodes[node_process].append(sink_place_target) end_event_subprocess[node_process] = sink_place_target if not node_name.lower().startswith("end"): trans = get_transition("ett_" + node_id, node_name) net.transitions.add(trans) sink_place_source = PetriNet.Place("etp_" + node_id) net.places.add(sink_place_source) utils.add_arc_from_to(sink_place_source, trans, net) utils.add_arc_from_to(trans, sink_place_target, net) corresponding_in_nodes[node_id] = [sink_place_source] else: corresponding_in_nodes[node_id] = [sink_place_target] elif "event" in node_type: input_place = PetriNet.Place('i_' + node_id) net.places.add(input_place) output_place = PetriNet.Place('o_' + node_id) net.places.add(output_place) if not node_id == node_name: trans = get_transition(node_id, node_name) else: trans = get_transition(node_id, None) net.transitions.add(trans) corresponding_in_nodes[node_id] = [input_place] corresponding_out_nodes[node_id] = [output_place] utils.add_arc_from_to(input_place, trans, net) utils.add_arc_from_to(trans, output_place, net) flows = bpmn_graph.get_flows() for flow in flows: flow_id = flow[2]['id'] source_ref = flow[2]['sourceRef'] target_ref = flow[2]['targetRef'] if source_ref in corresponding_out_nodes and target_ref in corresponding_in_nodes and corresponding_out_nodes[ source_ref] and corresponding_in_nodes[target_ref]: trans = get_transition(flow_id, None) net.transitions.add(trans) source_arc = utils.add_arc_from_to( corresponding_out_nodes[source_ref][0], trans, net) target_arc = utils.add_arc_from_to( trans, corresponding_in_nodes[target_ref][0], net) if len(corresponding_out_nodes[source_ref]) > 1: del corresponding_out_nodes[source_ref][0] if len(corresponding_in_nodes[target_ref]) > 1: del corresponding_in_nodes[target_ref][0] elements_correspondence[target_arc] = flow if not str(flow) in inv_elements_correspondence: inv_elements_correspondence[str(flow[2])] = [] inv_elements_correspondence[str(flow[2])].append(target_arc) inv_elements_correspondence[str(flow[2])].append(source_arc) net = remove_unconnected_places(net, sources, targets) for el in elements_correspondence: el_corr_keys_map[str(el)] = el if enable_reduction: net = reduce(net) #net, initial_marking = remove_places_im_that_go_to_fm_through_hidden(net, initial_marking, final_marking) net, initial_marking = get_initial_marking(net) net, final_marking = get_final_marking(net) return net, initial_marking, final_marking, elements_correspondence, inv_elements_correspondence, el_corr_keys_map
def transform_net(self, net0, initial_marking0, final_marking0, s_map, avg_time_starts): """ Transform the source Petri net removing the initial and final marking, and connecting to each "initial" place a hidden timed transition mimicking the case start Parameters ------------- net0 Initial Petri net provided to the object initial_marking0 Initial marking of the Petri net provided to the object final_marking0 Final marking of the Petri net provided to the object s_map Stochastic map of transitions (EXPONENTIAL distribution since we assume a Markovian process) avg_time_starts Average time interlapsed between case starts Returns ------------- net Petri net that will be simulated initial_marking Initial marking of the Petri net that will be simulated (empty) final_marking Final marking of the Petri net that will be simulated (empty) s_map Stochastic map of transitions enriched by new hidden case-generator transitions """ # copy the Petri net object (assure that we do not change the original Petri net) [net1, initial_marking1, final_marking1] = copy([net0, initial_marking0, final_marking0]) # on the copied Petri net, add a sucking transition for the final marking for index, place in enumerate(final_marking1): suck_transition = PetriNet.Transition( "SUCK_TRANSITION" + str(index), None) net1.transitions.add(suck_transition) add_arc_from_to(place, suck_transition, net1) hidden_generator_distr = Exponential() hidden_generator_distr.scale = avg_time_starts s_map[suck_transition] = hidden_generator_distr # on the copied Petri net, remove both the place(s) in the initial marking and # the immediate transitions that are connected to it. target_places = [] for place in initial_marking1: out_arcs = list(place.out_arcs) for target_arc in out_arcs: target_trans = target_arc.target if len(target_trans.in_arcs) == 1: out_arcs_lev2 = list(target_trans.out_arcs) for arc in out_arcs_lev2: target_place = arc.target target_places.append(target_place) net1 = remove_transition(net1, target_trans) net1 = remove_place(net1, place) # add hidden case-generation transitions to the model. # all places that are left orphan by the previous operation are targeted. for index, place in enumerate(target_places): hidden_generator_trans = PetriNet.Transition( "HIDDEN_GENERATOR_TRANS" + str(index), None) net1.transitions.add(hidden_generator_trans) add_arc_from_to(hidden_generator_trans, place, net1) hidden_generator_distr = Exponential() hidden_generator_distr.scale = avg_time_starts s_map[hidden_generator_trans] = hidden_generator_distr # the simulated Petri net is assumed to start from an empty initial and final marking initial_marking = Marking() final_marking = Marking() return net1, initial_marking, final_marking, s_map
def setUp(self): self.trace_net = PetriNet('trace net of %s' % str(1)) activities = ['a', 'b', 'c', 'd'] transitions = [] artificial_start_transition = PetriNet.Transition('start', 'start') artificial_end_transition = PetriNet.Transition('end', 'end') place = PetriNet.Place('p_0') self.trace_net.places.add(place) utils.add_arc_from_to(place, artificial_start_transition, self.trace_net) self.trace_net.transitions.add(artificial_start_transition) self.trace_net.transitions.add(artificial_end_transition) i = 0 for index, activity in enumerate(activities): place = PetriNet.Place('p_' + str(i)) self.trace_net.places.add(place) utils.add_arc_from_to(artificial_start_transition, place, self.trace_net) transition = PetriNet.Transition( 't_' + activities[index] + '_' + str(index), activities[index]) self.trace_net.transitions.add(transition) utils.add_arc_from_to(place, transition, self.trace_net) place = PetriNet.Place('p_' + str(i + 1)) self.trace_net.places.add(place) utils.add_arc_from_to(transition, place, self.trace_net) utils.add_arc_from_to(place, artificial_end_transition, self.trace_net) i = i + 1 place = PetriNet.Place('p_' + str(i)) self.trace_net.places.add(place) utils.add_arc_from_to(artificial_end_transition, place, self.trace_net) transition_a = [ transition for transition in self.trace_net.transitions if transition.label == 'a' ][0] transition_b = [ transition for transition in self.trace_net.transitions if transition.label == 'b' ][0] transition_c = [ transition for transition in self.trace_net.transitions if transition.label == 'c' ][0] transition_d = [ transition for transition in self.trace_net.transitions if transition.label == 'd' ][0] place = PetriNet.Place('p_' + str(i + 1)) self.trace_net.places.add(place) utils.add_arc_from_to(transition_a, place, self.trace_net) utils.add_arc_from_to(place, transition_b, self.trace_net) place = PetriNet.Place('p_' + str(i + 2)) self.trace_net.places.add(place) utils.add_arc_from_to(transition_a, place, self.trace_net) utils.add_arc_from_to(place, transition_c, self.trace_net) place = PetriNet.Place('p_' + str(i + 3)) self.trace_net.places.add(place) utils.add_arc_from_to(transition_a, place, self.trace_net) utils.add_arc_from_to(place, transition_d, self.trace_net) place = PetriNet.Place('p_' + str(i + 4)) self.trace_net.places.add(place) utils.add_arc_from_to(transition_b, place, self.trace_net) utils.add_arc_from_to(place, transition_d, self.trace_net) place = PetriNet.Place('p_' + str(i + 5)) self.trace_net.places.add(place) utils.add_arc_from_to(transition_c, place, self.trace_net) utils.add_arc_from_to(place, transition_d, self.trace_net) filename = "partially_ordered_test_log.xes" path = os.path.join("/GitHub/pm4py-source/tests/input_data", filename) self.log = importer.import_log(path)
def test_figure415(self): net = PetriNet("figure_4_15") p_1 = PetriNet.Place("p_1") p_2 = PetriNet.Place("p_2") p_3 = PetriNet.Place("p_3") p_4 = PetriNet.Place("p_4") p_5 = PetriNet.Place("p_5") p_6 = PetriNet.Place("p_6") p_7 = PetriNet.Place("p_7") net.places.add(p_1) net.places.add(p_2) net.places.add(p_3) net.places.add(p_4) net.places.add(p_5) net.places.add(p_6) net.places.add(p_7) t_1 = PetriNet.Transition("t_1", "t_1") t_2 = PetriNet.Transition("t_2", "t_2") t_3 = PetriNet.Transition("t_3", "t_3") t_4 = PetriNet.Transition("t_4", "t_4") t_5 = PetriNet.Transition("t_5", "t_5") t_6 = PetriNet.Transition("t_6", "t_6") net.transitions.add(t_1) net.transitions.add(t_2) net.transitions.add(t_3) net.transitions.add(t_4) net.transitions.add(t_5) net.transitions.add(t_6) utils.add_arc_from_to(p_1, t_1, net) utils.add_arc_from_to(t_1, p_3, net) utils.add_arc_from_to(t_1, p_2, net) utils.add_arc_from_to(t_1, p_5, net) utils.add_arc_from_to(p_5, t_2, net) utils.add_arc_from_to(p_5, t_5, net) utils.add_arc_from_to(p_3, t_2, net) utils.add_arc_from_to(p_3, t_4, net) utils.add_arc_from_to(t_2, p_6, net) utils.add_arc_from_to(t_2, p_4, net) utils.add_arc_from_to(t_5, p_5, net) utils.add_arc_from_to(t_5, p_3, net) utils.add_arc_from_to(p_2, t_2, net) utils.add_arc_from_to(t_3, p_2, net) utils.add_arc_from_to(t_3, p_3, net) utils.add_arc_from_to(t_3, p_4, net) utils.add_arc_from_to(p_6, t_5, net) utils.add_arc_from_to(p_6, t_6, net) utils.add_arc_from_to(p_6, t_3, net) utils.add_arc_from_to(t_4, p_6, net) utils.add_arc_from_to(t_4, p_5, net) utils.add_arc_from_to(p_4, t_3, net) utils.add_arc_from_to(p_4, t_6, net) utils.add_arc_from_to(p_4, t_4, net) utils.add_arc_from_to(t_6, p_7, net) initial_marking = Marking() initial_marking[p_1] = 1 final_marking = Marking() final_marking[p_7] = 1 self.assertTrue(woflan.apply(net, initial_marking, final_marking))
def __add_sink(net, end_activities, label_transition_dict): end = PetriNet.Place('end') net.places.add(end) for e in end_activities: add_arc_from_to(label_transition_dict[e], end, net) return end
def test_figure42(self): net = PetriNet("figure_4_2") p_1 = PetriNet.Place("p_1") p_2 = PetriNet.Place("p_2") p_3 = PetriNet.Place("p_3") p_4 = PetriNet.Place("p_4") p_5 = PetriNet.Place("p_5") p_6 = PetriNet.Place("p_6") p_7 = PetriNet.Place("p_7") p_8 = PetriNet.Place("p_8") net.places.add(p_1) net.places.add(p_2) net.places.add(p_3) net.places.add(p_4) net.places.add(p_5) net.places.add(p_6) net.places.add(p_7) net.places.add(p_8) t_1 = PetriNet.Transition("t_1", "t_1") t_2 = PetriNet.Transition("t_2", "t_2") t_3 = PetriNet.Transition("t_3", "t_3") t_4 = PetriNet.Transition("t_4", "t_4") t_5 = PetriNet.Transition("t_5", "t_5") t_6 = PetriNet.Transition("t_6", "t_6") t_7 = PetriNet.Transition("t_7", "t_7") t_8 = PetriNet.Transition("t_8", "t_8") net.transitions.add(t_1) net.transitions.add(t_2) net.transitions.add(t_3) net.transitions.add(t_4) net.transitions.add(t_5) net.transitions.add(t_6) net.transitions.add(t_7) net.transitions.add(t_8) utils.add_arc_from_to(p_1, t_1, net) utils.add_arc_from_to(t_1, p_6, net) utils.add_arc_from_to(t_1, p_4, net) utils.add_arc_from_to(p_4, t_4, net) utils.add_arc_from_to(p_4, t_5, net) utils.add_arc_from_to(t_2, p_6, net) utils.add_arc_from_to(t_2, p_4, net) utils.add_arc_from_to(t_4, p_3, net) utils.add_arc_from_to(t_4, p_5, net) utils.add_arc_from_to(t_5, p_7, net) utils.add_arc_from_to(t_7, p_4, net) utils.add_arc_from_to(p_3, t_2, net) utils.add_arc_from_to(p_3, t_3, net) utils.add_arc_from_to(p_5, t_2, net) utils.add_arc_from_to(p_5, t_3, net) utils.add_arc_from_to(p_5, t_4, net) utils.add_arc_from_to(p_7, t_6, net) utils.add_arc_from_to(p_8, t_7, net) utils.add_arc_from_to(p_8, t_8, net) utils.add_arc_from_to(t_3, p_2, net) utils.add_arc_from_to(p_6, t_6, net) utils.add_arc_from_to(t_6, p_5, net) utils.add_arc_from_to(t_8, p_8, net) initial_marking = Marking() initial_marking[p_1] = 1 final_marking = Marking() final_marking[p_2] = 1 self.assertFalse( woflan.apply(net, initial_marking, final_marking, parameters={"print_diagnostics": False}))
def apply_dfg_sa_ea(dfg, start_activities, end_activities, parameters=None): """ Applying Alpha Miner starting from the knowledge of the Directly Follows graph, and of the start activities and end activities in the log (possibly inferred from the DFG) Parameters ------------ dfg Directly-Follows graph start_activities Start activities end_activities End activities parameters Parameters of the algorithm including: activity key -> name of the attribute that contains the activity Returns ------- net : :class:`pm4py.entities.petri.petrinet.PetriNet` A Petri net describing the event log that is provided as an input initial marking : :class:`pm4py.models.net.Marking` marking object representing the initial marking final marking : :class:`pm4py.models.net.Marking` marking object representing the final marking, not guaranteed that it is actually reachable! """ if parameters is None: parameters = {} activity_key = exec_utils.get_param_value( Parameters.ACTIVITY_KEY, parameters, pm_util.xes_constants.DEFAULT_NAME_KEY) if start_activities is None: start_activities = dfg_utils.infer_start_activities(dfg) if end_activities is None: end_activities = dfg_utils.infer_end_activities(dfg) labels = set() for el in dfg: labels.add(el[0]) labels.add(el[1]) for a in start_activities: labels.add(a) for a in end_activities: labels.add(a) labels = list(labels) alpha_abstraction = alpha_classic_abstraction.ClassicAlphaAbstraction( start_activities, end_activities, dfg, activity_key=activity_key) pairs = list( map( lambda p: ({p[0]}, {p[1]}), filter( lambda p: __initial_filter(alpha_abstraction.parallel_relation, p), alpha_abstraction.causal_relation))) for i in range(0, len(pairs)): t1 = pairs[i] for j in range(i, len(pairs)): t2 = pairs[j] if t1 != t2: if t1[0].issubset(t2[0]) or t1[1].issubset(t2[1]): if not (__check_is_unrelated( alpha_abstraction.parallel_relation, alpha_abstraction.causal_relation, t1[0], t2[0]) or __check_is_unrelated( alpha_abstraction.parallel_relation, alpha_abstraction.causal_relation, t1[1], t2[1])): new_alpha_pair = (t1[0] | t2[0], t1[1] | t2[1]) if new_alpha_pair not in pairs: pairs.append((t1[0] | t2[0], t1[1] | t2[1])) internal_places = filter(lambda p: __pair_maximizer(pairs, p), pairs) net = PetriNet('alpha_classic_net_' + str(time.time())) label_transition_dict = {} for i in range(0, len(labels)): label_transition_dict[labels[i]] = PetriNet.Transition( labels[i], labels[i]) net.transitions.add(label_transition_dict[labels[i]]) src = __add_source(net, alpha_abstraction.start_activities, label_transition_dict) sink = __add_sink(net, alpha_abstraction.end_activities, label_transition_dict) for pair in internal_places: place = PetriNet.Place(str(pair)) net.places.add(place) for in_arc in pair[0]: add_arc_from_to(label_transition_dict[in_arc], place, net) for out_arc in pair[1]: add_arc_from_to(place, label_transition_dict[out_arc], net) return net, Marking({src: 1}), Marking({sink: 1})
def __add_source(net, start_activities, label_transition_dict): source = PetriNet.Place('start') net.places.add(source) for s in start_activities: add_arc_from_to(source, label_transition_dict[s], net) return source
def _add_src_sink_transitions(net, p_s, p_t): src = pn_util.add_transition(net) pn_util.add_arc_from_to(src, p_s, net) sink = pn_util.add_transition(net) pn_util.add_arc_from_to(p_t, sink, net) return net, petrinet.Marking(), petrinet.Marking()
net.places.add(p_2) net.places.add(p_3) net.places.add(p_4) t_1 = PetriNet.Transition("Activity A", "Activity A") t_2 = PetriNet.Transition("Activity B", "Activity B") t_3 = PetriNet.Transition("Activity C", "Activity C") t_4 = PetriNet.Transition("Activity D", "Activity D") # Add the transitions to the Petri Net net.transitions.add(t_1) net.transitions.add(t_2) net.transitions.add(t_3) net.transitions.add(t_4) from pm4py.objects.petri import utils utils.add_arc_from_to(start, t_1, net) utils.add_arc_from_to(t_4, end, net) utils.add_arc_from_to(t_1, p_1, net) utils.add_arc_from_to(t_1, p_2, net) utils.add_arc_from_to(p_1, t_2, net) utils.add_arc_from_to(p_2, t_3, net) utils.add_arc_from_to(t_2, p_3, net) utils.add_arc_from_to(t_3, p_4, net) utils.add_arc_from_to(p_3, t_4, net) utils.add_arc_from_to(p_4, t_4, net) initial_marking = Marking() initial_marking[start] = 1 final_marking = Marking() final_marking[end] = 1 from pm4py.objects.petri.exporter import exporter as pnml_exporter
def processing(log, causal, follows): """ Applying the Alpha Miner with the new relations Parameters ------------- log Filtered log causal Pairs that have a causal relation (->) follows Pairs that have a follow relation (>) Returns ------------- net Petri net im Initial marking fm Final marking """ # create list of all events labels = set() start_activities = set() end_activities = set() for trace in log: start_activities.add(trace.__getitem__(0)) end_activities.add(trace.__getitem__(len(trace) - 1)) for events in trace: labels.add(events) labels = list(labels) pairs = [] for key, element in causal.items(): for item in element: if get_sharp_relation(follows, key, key): if get_sharp_relation(follows, item, item): pairs.append(({key}, {item})) # combining pairs for i in range(0, len(pairs)): t1 = pairs[i] for j in range(i, len(pairs)): t2 = pairs[j] if t1 != t2: if t1[0].issubset(t2[0]) or t1[1].issubset(t2[1]): if get_sharp_relations_for_sets( follows, t1[0], t2[0]) and get_sharp_relations_for_sets( follows, t1[1], t2[1]): new_alpha_pair = (t1[0] | t2[0], t1[1] | t2[1]) if new_alpha_pair not in pairs: pairs.append((t1[0] | t2[0], t1[1] | t2[1])) # maximize pairs cleaned_pairs = list(filter(lambda p: __pair_maximizer(pairs, p), pairs)) # create transitions net = PetriNet('alpha_plus_net_' + str(time.time())) label_transition_dict = {} for label in labels: if label != 'artificial_start' and label != 'artificial_end': label_transition_dict[label] = PetriNet.Transition(label, label) net.transitions.add(label_transition_dict[label]) else: label_transition_dict[label] = PetriNet.Transition(label, None) net.transitions.add(label_transition_dict[label]) # and source and sink src = add_source(net, start_activities, label_transition_dict) sink = add_sink(net, end_activities, label_transition_dict) # create places for pair in cleaned_pairs: place = PetriNet.Place(str(pair)) net.places.add(place) for in_arc in pair[0]: add_arc_from_to(label_transition_dict[in_arc], place, net) for out_arc in pair[1]: add_arc_from_to(place, label_transition_dict[out_arc], net) return net, Marking({src: 1}), Marking({sink: 1}), cleaned_pairs
def apply(heu_net, parameters=None): """ Converts an Heuristics Net to a Petri net Parameters -------------- heu_net Heuristics net parameters Possible parameters of the algorithm Returns -------------- net Petri net im Initial marking fm Final marking """ if parameters is None: parameters = {} net = PetriNet("") im = Marking() fm = Marking() source_places = [] sink_places = [] hid_trans_count = 0 for index, sa_list in enumerate(heu_net.start_activities): source = PetriNet.Place("source" + str(index)) source_places.append(source) net.places.add(source) im[source] = 1 for index, ea_list in enumerate(heu_net.end_activities): sink = PetriNet.Place("sink" + str(index)) sink_places.append(sink) net.places.add(sink) fm[sink] = 1 act_trans = {} who_is_entering = {} who_is_exiting = {} for act1_name in heu_net.nodes: act1 = heu_net.nodes[act1_name] if act1_name not in act_trans: act_trans[act1_name] = PetriNet.Transition(act1_name, act1_name) net.transitions.add(act_trans[act1_name]) who_is_entering[act1_name] = set() who_is_exiting[act1_name] = set() for index, sa_list in enumerate(heu_net.start_activities): if act1_name in sa_list: who_is_entering[act1_name].add((None, index)) for index, ea_list in enumerate(heu_net.end_activities): if act1_name in ea_list: who_is_exiting[act1_name].add((None, index)) for act2 in act1.output_connections: act2_name = act2.node_name if act2_name not in act_trans: act_trans[act2_name] = PetriNet.Transition( act2_name, act2_name) net.transitions.add(act_trans[act2_name]) who_is_entering[act2_name] = set() who_is_exiting[act2_name] = set() for index, sa_list in enumerate(heu_net.start_activities): if act2_name in sa_list: who_is_entering[act2_name].add((None, index)) for index, ea_list in enumerate(heu_net.end_activities): if act2_name in ea_list: who_is_exiting[act2_name].add((None, index)) who_is_entering[act2_name].add((act1_name, None)) who_is_exiting[act1_name].add((act2_name, None)) places_entering = {} for act1 in who_is_entering: cliques = find_bindings(heu_net.nodes[act1].and_measures_in) places_entering[act1] = {} entering_activities = list(who_is_entering[act1]) entering_activities_wo_source = sorted( [x for x in entering_activities if x[0] is not None], key=lambda x: x[0]) entering_activities_only_source = [ x for x in entering_activities if x[0] is None ] if entering_activities_wo_source: master_place = PetriNet.Place("pre_" + act1) net.places.add(master_place) add_arc_from_to(master_place, act_trans[act1], net) if len(entering_activities) == 1: places_entering[act1][entering_activities[0]] = master_place else: for index, act in enumerate(entering_activities_wo_source): if act[0] in heu_net.nodes[act1].and_measures_in: z = 0 while z < len(cliques): if act[0] in cliques[z]: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition( "hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(hid_trans, master_place, net) for act2 in cliques[z]: if (act2, None) not in places_entering[act1]: s_place = PetriNet.Place("splace_in_" + act1 + "_" + act2 + "_" + str(index)) net.places.add(s_place) places_entering[act1][(act2, None)] = s_place add_arc_from_to( places_entering[act1][(act2, None)], hid_trans, net) del cliques[z] continue z = z + 1 pass elif act not in places_entering[act1]: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition( "hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(hid_trans, master_place, net) if act not in places_entering[act1]: s_place = PetriNet.Place("splace_in_" + act1 + "_" + str(index)) net.places.add(s_place) places_entering[act1][act] = s_place add_arc_from_to(places_entering[act1][act], hid_trans, net) for el in entering_activities_only_source: if len(entering_activities) == 1: add_arc_from_to(source_places[el[1]], act_trans[act1], net) else: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition("hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(source_places[el[1]], hid_trans, net) add_arc_from_to(hid_trans, master_place, net) for act1 in who_is_exiting: cliques = find_bindings(heu_net.nodes[act1].and_measures_out) exiting_activities = list(who_is_exiting[act1]) exiting_activities_wo_sink = sorted( [x for x in exiting_activities if x[0] is not None], key=lambda x: x[0]) exiting_activities_only_sink = [ x for x in exiting_activities if x[0] is None ] if exiting_activities_wo_sink: if len(exiting_activities) == 1 and len( exiting_activities_wo_sink) == 1: ex_act = exiting_activities_wo_sink[0] if (act1, None) in places_entering[ex_act[0]]: add_arc_from_to(act_trans[act1], places_entering[ex_act[0]][(act1, None)], net) else: int_place = PetriNet.Place("intplace_" + str(act1)) net.places.add(int_place) add_arc_from_to(act_trans[act1], int_place, net) for ex_act in exiting_activities_wo_sink: if (act1, None) in places_entering[ex_act[0]]: if ex_act[0] in heu_net.nodes[act1].and_measures_out: z = 0 while z < len(cliques): if ex_act[0] in cliques[z]: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition( "hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(int_place, hid_trans, net) for act in cliques[z]: add_arc_from_to( hid_trans, places_entering[act][(act1, None)], net) del cliques[z] continue z = z + 1 else: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition( "hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(int_place, hid_trans, net) add_arc_from_to( hid_trans, places_entering[ex_act[0]][(act1, None)], net) for el in exiting_activities_only_sink: if len(exiting_activities) == 1: add_arc_from_to(act_trans[act1], sink_places[el[1]], net) else: hid_trans_count = hid_trans_count + 1 hid_trans = PetriNet.Transition("hid_" + str(hid_trans_count), None) net.transitions.add(hid_trans) add_arc_from_to(int_place, hid_trans, net) add_arc_from_to(hid_trans, sink_places[el[1]], net) net = remove_rendundant_invisible_transitions(net) return net, im, fm
def import_net_from_xml_object(root, parameters=None): """ Import a Petri net from an etree XML object Parameters ---------- root Root object of the XML parameters Other parameters of the algorithm """ if parameters is None: parameters = {} net = PetriNet('imported_' + str(time.time())) marking = Marking() fmarking = Marking() nett = None page = None finalmarkings = None stochastic_information = {} for child in root: nett = child places_dict = {} trans_dict = {} if nett is not None: for child in nett: if "page" in child.tag: page = child if "finalmarkings" in child.tag: finalmarkings = child if page is None: page = nett if page is not None: for child in page: if "place" in child.tag: position_X = None position_Y = None dimension_X = None dimension_Y = None place_id = child.get("id") place_name = place_id number = 0 for child2 in child: if child2.tag.endswith('name'): for child3 in child2: if child3.text: place_name = child3.text if child2.tag.endswith('initialMarking'): for child3 in child2: if child3.tag.endswith("text"): number = int(child3.text) if child2.tag.endswith('graphics'): for child3 in child2: if child3.tag.endswith('position'): position_X = float(child3.get("x")) position_Y = float(child3.get("y")) elif child3.tag.endswith("dimension"): dimension_X = float(child3.get("x")) dimension_Y = float(child3.get("y")) places_dict[place_id] = PetriNet.Place(place_id) places_dict[place_id].properties[ constants.PLACE_NAME_TAG] = place_name net.places.add(places_dict[place_id]) if position_X is not None and position_Y is not None and dimension_X is not None and dimension_Y is not None: places_dict[place_id].properties[ constants.LAYOUT_INFORMATION_PETRI] = ((position_X, position_Y), (dimension_X, dimension_Y)) if number > 0: marking[places_dict[place_id]] = number del place_name if page is not None: for child in page: if child.tag.endswith("transition"): position_X = None position_Y = None dimension_X = None dimension_Y = None trans_name = child.get("id") trans_label = trans_name trans_visible = True random_variable = None for child2 in child: if child2.tag.endswith("name"): for child3 in child2: if child3.text: if trans_label == trans_name: trans_label = child3.text if child2.tag.endswith("graphics"): for child3 in child2: if child3.tag.endswith("position"): position_X = float(child3.get("x")) position_Y = float(child3.get("y")) elif child3.tag.endswith("dimension"): dimension_X = float(child3.get("x")) dimension_Y = float(child3.get("y")) if child2.tag.endswith("toolspecific"): tool = child2.get("tool") if "ProM" in tool: activity = child2.get("activity") if "invisible" in activity: trans_visible = False elif "StochasticPetriNet" in tool: distribution_type = None distribution_parameters = None priority = None weight = None for child3 in child2: key = child3.get("key") value = child3.text if key == "distributionType": distribution_type = value elif key == "distributionParameters": distribution_parameters = value elif key == "priority": priority = int(value) elif key == "weight": weight = float(value) random_variable = RandomVariable() random_variable.read_from_string( distribution_type, distribution_parameters) random_variable.set_priority(priority) random_variable.set_weight(weight) if not trans_visible: trans_label = None # if "INVISIBLE" in trans_label: # trans_label = None trans_dict[trans_name] = PetriNet.Transition( trans_name, trans_label) net.transitions.add(trans_dict[trans_name]) if random_variable is not None: trans_dict[trans_name].properties[ constants.STOCHASTIC_DISTRIBUTION] = random_variable if position_X is not None and position_Y is not None and dimension_X is not None and dimension_Y is not None: trans_dict[trans_name].properties[ constants.LAYOUT_INFORMATION_PETRI] = ((position_X, position_Y), (dimension_X, dimension_Y)) if page is not None: for child in page: if child.tag.endswith("arc"): arc_source = child.get("source") arc_target = child.get("target") arc_weight = 1 for arc_child in child: if arc_child.tag.endswith("inscription"): for text_arcweight in arc_child: if text_arcweight.tag.endswith("text"): arc_weight = int(text_arcweight.text) if arc_source in places_dict and arc_target in trans_dict: add_arc_from_to(places_dict[arc_source], trans_dict[arc_target], net, weight=arc_weight) elif arc_target in places_dict and arc_source in trans_dict: add_arc_from_to(trans_dict[arc_source], places_dict[arc_target], net, weight=arc_weight) if finalmarkings is not None: for child in finalmarkings: for child2 in child: place_id = child2.get("idref") for child3 in child2: if child3.tag.endswith("text"): number = int(child3.text) if number > 0: fmarking[places_dict[place_id]] = number # generate the final marking in the case has not been found if len(fmarking) == 0: fmarking = final_marking.discover_final_marking(net) return net, marking, fmarking
def test_mcg(self): net = PetriNet("mcg") p_1 = PetriNet.Place("p_1") p_2 = PetriNet.Place("p_2") p_3 = PetriNet.Place("p_3") p_4 = PetriNet.Place("p_4") p_5 = PetriNet.Place("p_5") net.places.add(p_1) net.places.add(p_2) net.places.add(p_3) net.places.add(p_4) net.places.add(p_5) t_1 = PetriNet.Transition("t_1", "t_1") t_2 = PetriNet.Transition("t_2", "t_2") t_3 = PetriNet.Transition("t_3", "t_3") t_4 = PetriNet.Transition("t_4", "t_4") t_5 = PetriNet.Transition("t_5", "t_5") t_6 = PetriNet.Transition("t_6", "t_6") net.transitions.add(t_1) net.transitions.add(t_2) net.transitions.add(t_3) net.transitions.add(t_4) net.transitions.add(t_5) net.transitions.add(t_6) utils.add_arc_from_to(p_1, t_1, net) utils.add_arc_from_to(t_1, p_2, net) utils.add_arc_from_to(p_2, t_3, net) utils.add_arc_from_to(t_3, p_3, net, weight=2) utils.add_arc_from_to(p_3, t_4, net) utils.add_arc_from_to(t_4, p_2, net) utils.add_arc_from_to(p_1, t_2, net) utils.add_arc_from_to(t_2, p_4, net) utils.add_arc_from_to(p_4, t_5, net) utils.add_arc_from_to(t_5, p_5, net, weight=2) utils.add_arc_from_to(p_5, t_6, net) utils.add_arc_from_to(t_6, p_4, net) initial_marking = Marking() initial_marking[p_1] = 1 mcg = minimal_coverability_graph.apply(net, initial_marking)
def apply(dfg, parameters=None): """ Applies the DFG mining on a given object (if it is a Pandas dataframe or a log, the DFG is calculated) Parameters ------------- dfg Object (DFG) (if it is a Pandas dataframe or a log, the DFG is calculated) parameters Parameters """ if parameters is None: parameters = {} dfg = dfg start_activities = parameters[ PARAM_KEY_START_ACTIVITIES] if PARAM_KEY_START_ACTIVITIES in parameters else dfg_utils.infer_start_activities( dfg) end_activities = parameters[ PARAM_KEY_END_ACTIVITIES] if PARAM_KEY_END_ACTIVITIES in parameters else dfg_utils.infer_end_activities( dfg) activities = dfg_utils.get_activities_from_dfg(dfg) net = PetriNet("") im = Marking() fm = Marking() source = PetriNet.Place("source") net.places.add(source) im[source] = 1 sink = PetriNet.Place("sink") net.places.add(sink) fm[sink] = 1 places_corr = {} index = 0 for act in activities: places_corr[act] = PetriNet.Place(act) net.places.add(places_corr[act]) for act in start_activities: if act in places_corr: index = index + 1 trans = PetriNet.Transition(act + "_" + str(index), act) net.transitions.add(trans) add_arc_from_to(source, trans, net) add_arc_from_to(trans, places_corr[act], net) for act in end_activities: if act in places_corr: index = index + 1 inv_trans = PetriNet.Transition(act + "_" + str(index), None) net.transitions.add(inv_trans) add_arc_from_to(places_corr[act], inv_trans, net) add_arc_from_to(inv_trans, sink, net) for el in dfg.keys(): act1 = el[0] act2 = el[1] index = index + 1 trans = PetriNet.Transition(act2 + "_" + str(index), act2) net.transitions.add(trans) add_arc_from_to(places_corr[act1], trans, net) add_arc_from_to(trans, places_corr[act2], net) return net, im, fm
def recursively_add_tree(parent_tree, tree, net, initial_entity_subtree, final_entity_subtree, counts, rec_depth, force_add_skip=False): """ Recursively add the subtrees to the Petri net Parameters ----------- parent_tree Parent tree tree Current subtree net Petri net initial_entity_subtree Initial entity (place/transition) that should be attached from the subtree final_entity_subtree Final entity (place/transition) that should be attached from the subtree counts Counts object (keeps the number of places, transitions and hidden transitions) rec_depth Recursion depth of the current iteration force_add_skip Boolean value that tells if the addition of a skip is mandatory Returns ---------- net Updated Petri net counts Updated counts object (keeps the number of places, transitions and hidden transitions) final_place Last place added in this recursion """ if type(initial_entity_subtree) is PetriNet.Transition: initial_place = get_new_place(counts) net.places.add(initial_place) add_arc_from_to(initial_entity_subtree, initial_place, net) else: initial_place = initial_entity_subtree if final_entity_subtree is not None and type( final_entity_subtree) is PetriNet.Place: final_place = final_entity_subtree else: final_place = get_new_place(counts) net.places.add(final_place) if final_entity_subtree is not None and type( final_entity_subtree) is PetriNet.Transition: add_arc_from_to(final_place, final_entity_subtree, net) tree_childs = [child for child in tree.children] if force_add_skip: invisible = get_new_hidden_trans(counts, type_trans="skip") add_arc_from_to(initial_place, invisible, net) add_arc_from_to(invisible, final_place, net) if tree.operator is None: trans = tree if trans.label is None: petri_trans = get_new_hidden_trans(counts, type_trans="skip") else: petri_trans = get_transition(counts, trans.label) net.transitions.add(petri_trans) add_arc_from_to(initial_place, petri_trans, net) add_arc_from_to(petri_trans, final_place, net) if tree.operator == Operator.XOR: for subtree in tree_childs: net, counts, intermediate_place = recursively_add_tree( tree, subtree, net, initial_place, final_place, counts, rec_depth + 1) elif tree.operator == Operator.OR: new_initial_trans = get_new_hidden_trans(counts, type_trans="tauSplit") net.transitions.add(new_initial_trans) add_arc_from_to(initial_place, new_initial_trans, net) new_final_trans = get_new_hidden_trans(counts, type_trans="tauJoin") net.transitions.add(new_final_trans) add_arc_from_to(new_final_trans, final_place, net) terminal_place = get_new_place(counts) net.places.add(terminal_place) add_arc_from_to(terminal_place, new_final_trans, net) first_place = get_new_place(counts) net.places.add(first_place) add_arc_from_to(new_initial_trans, first_place, net) for subtree in tree_childs: subtree_init_place = get_new_place(counts) net.places.add(subtree_init_place) add_arc_from_to(new_initial_trans, subtree_init_place, net) subtree_start_place = get_new_place(counts) net.places.add(subtree_start_place) subtree_end_place = get_new_place(counts) net.places.add(subtree_end_place) trans_start = get_new_hidden_trans(counts, type_trans="inclusiveStart") trans_later = get_new_hidden_trans(counts, type_trans="inclusiveLater") trans_skip = get_new_hidden_trans(counts, type_trans="inclusiveSkip") net.transitions.add(trans_start) net.transitions.add(trans_later) net.transitions.add(trans_skip) add_arc_from_to(first_place, trans_start, net) add_arc_from_to(subtree_init_place, trans_start, net) add_arc_from_to(trans_start, subtree_start_place, net) add_arc_from_to(trans_start, terminal_place, net) add_arc_from_to(terminal_place, trans_later, net) add_arc_from_to(subtree_init_place, trans_later, net) add_arc_from_to(trans_later, subtree_start_place, net) add_arc_from_to(trans_later, terminal_place, net) add_arc_from_to(terminal_place, trans_skip, net) add_arc_from_to(subtree_init_place, trans_skip, net) add_arc_from_to(trans_skip, terminal_place, net) add_arc_from_to(trans_skip, subtree_end_place, net) add_arc_from_to(subtree_end_place, new_final_trans, net) net, counts, intermediate_place = recursively_add_tree( tree, subtree, net, subtree_start_place, subtree_end_place, counts, rec_depth + 1) elif tree.operator == Operator.PARALLEL: new_initial_trans = get_new_hidden_trans(counts, type_trans="tauSplit") net.transitions.add(new_initial_trans) add_arc_from_to(initial_place, new_initial_trans, net) new_final_trans = get_new_hidden_trans(counts, type_trans="tauJoin") net.transitions.add(new_final_trans) add_arc_from_to(new_final_trans, final_place, net) for subtree in tree_childs: net, counts, intermediate_place = recursively_add_tree( tree, subtree, net, new_initial_trans, new_final_trans, counts, rec_depth + 1) elif tree.operator == Operator.SEQUENCE: intermediate_place = initial_place for i in range(len(tree_childs)): final_connection_place = None if i == len(tree_childs) - 1: final_connection_place = final_place net, counts, intermediate_place = recursively_add_tree( tree, tree_childs[i], net, intermediate_place, final_connection_place, counts, rec_depth + 1) elif tree.operator == Operator.LOOP: # if not parent_tree.operator == Operator.SEQUENCE: new_initial_place = get_new_place(counts) net.places.add(new_initial_place) init_loop_trans = get_new_hidden_trans(counts, type_trans="init_loop") net.transitions.add(init_loop_trans) add_arc_from_to(initial_place, init_loop_trans, net) add_arc_from_to(init_loop_trans, new_initial_place, net) initial_place = new_initial_place loop_trans = get_new_hidden_trans(counts, type_trans="loop") net.transitions.add(loop_trans) if len(tree_childs) == 1: net, counts, intermediate_place = recursively_add_tree( tree, tree_childs[0], net, initial_place, final_place, counts, rec_depth + 1) add_arc_from_to(final_place, loop_trans, net) add_arc_from_to(loop_trans, initial_place, net) else: dummy = ProcessTree() do = tree_childs[0] redo = tree_childs[1] exit = tree_childs[2] if len(tree_childs) > 2 and ( tree_childs[2].label is not None or tree_childs[2].children) else dummy net, counts, int1 = recursively_add_tree(tree, do, net, initial_place, None, counts, rec_depth + 1) net, counts, int2 = recursively_add_tree(tree, redo, net, int1, None, counts, rec_depth + 1) net, counts, int3 = recursively_add_tree(tree, exit, net, int1, final_place, counts, rec_depth + 1) looping_place = int2 add_arc_from_to(looping_place, loop_trans, net) add_arc_from_to(loop_trans, initial_place, net) return net, counts, final_place
def execute_script(): net = PetriNet("") start = PetriNet.Place("start") end = PetriNet.Place("end") c1 = PetriNet.Place("c1") c2 = PetriNet.Place("c2") c3 = PetriNet.Place("c3") c4 = PetriNet.Place("c4") c5 = PetriNet.Place("c5") c6 = PetriNet.Place("c6") c7 = PetriNet.Place("c7") c8 = PetriNet.Place("c8") c9 = PetriNet.Place("c9") net.places.add(c1) net.places.add(c2) net.places.add(c3) net.places.add(c4) net.places.add(c5) net.places.add(c6) net.places.add(c7) net.places.add(c8) net.places.add(c9) net.places.add(start) net.places.add(end) t1 = PetriNet.Transition("t1", "a") t2 = PetriNet.Transition("t2", None) t3 = PetriNet.Transition("t3", "b") t4 = PetriNet.Transition("t4", "c") t5 = PetriNet.Transition("t5", "d") t6 = PetriNet.Transition("t6", "e") t7 = PetriNet.Transition("t7", None) t8 = PetriNet.Transition("t8", "f") t9 = PetriNet.Transition("t9", "g") t10 = PetriNet.Transition("t10", "h") t11 = PetriNet.Transition("t11", None) net.transitions.add(t1) net.transitions.add(t2) net.transitions.add(t3) net.transitions.add(t4) net.transitions.add(t5) net.transitions.add(t6) net.transitions.add(t7) net.transitions.add(t8) net.transitions.add(t9) net.transitions.add(t10) net.transitions.add(t11) add_arc_from_to(start, t1, net) add_arc_from_to(t1, c1, net) add_arc_from_to(t1, c2, net) add_arc_from_to(c1, t2, net) add_arc_from_to(c1, t3, net) add_arc_from_to(c2, t4, net) add_arc_from_to(t2, c3, net) add_arc_from_to(t3, c3, net) add_arc_from_to(t4, c4, net) add_arc_from_to(c3, t5, net) add_arc_from_to(c4, t5, net) add_arc_from_to(t5, c5, net) add_arc_from_to(c5, t6, net) add_arc_from_to(t6, c1, net) add_arc_from_to(t6, c2, net) add_arc_from_to(c5, t7, net) add_arc_from_to(t7, c7, net) add_arc_from_to(t7, c6, net) add_arc_from_to(c7, t8, net) add_arc_from_to(c6, t9, net) add_arc_from_to(t8, c8, net) add_arc_from_to(t9, c9, net) add_arc_from_to(c8, t11, net) add_arc_from_to(c9, t11, net) add_arc_from_to(t11, end, net) add_arc_from_to(c5, t10, net) add_arc_from_to(t10, end, net) im = Marking() im[start] = 1 fm = Marking() fm[end] = 1 gvizs = [] gvizs.append( visualizer.apply(net, im, final_marking=fm, parameters={"format": "svg"})) visualizer.view(gvizs[len(gvizs) - 1]) decomposed_net = decomposition.decompose(net, im, fm) for snet, sim, sfm in decomposed_net: gvizs.append( visualizer.apply(snet, sim, final_marking=sfm, parameters={"format": "svg"})) visualizer.view(gvizs[len(gvizs) - 1])