def petrinetcreator(self, places, transitions, arcs):
net = PetriNet("new_petri_net")
source = PetriNet.Place("source")
sink = PetriNet.Place("sink")
for i in range(1, places + 1):
p = PetriNet.Place("p_" + str(i))
net.places.add(p)
net.places.add(source)
net.places.add(sink)
for i in range(1, transitions + 1):
t = PetriNet.Transition("name_" + str(i), "label_" + str(i))
net.transitions.add(t)
for i in range(1, len(arcs + 1)):
arc = arcs[i].split()
utils.add_arc_from_to(arc[0], arc[1], net)
initial_marking = Marking()
initial_marking[source] = 1
final_marking = Marking()
final_marking[sink] = 1
return net
def apply(log, net, initial_marking, final_marking, parameters=None):
"""
Method to apply token-based replay
Parameters
-----------
log
Log
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
parameters
Parameters of the algorithm
"""
if parameters is None:
parameters = {}
for t in net.transitions:
ma = Marking()
for a in t.out_arcs:
p = a.target
ma[p] = a.weight
t.out_marking = ma
for t in net.transitions:
ma = Marking()
for a in t.in_arcs:
p = a.source
ma[p] = a.weight
t.in_marking = ma
variants_idxs = variants_filter.get_variants_from_log_trace_idx(log, parameters=parameters)
results = []
tmap = {}
bmap = {}
for t in net.transitions:
if t.label is not None:
if t.label not in tmap:
tmap[t.label] = []
tmap[t.label].append(t)
for variant in variants_idxs:
vlist = variant.split(",")
result = tr_vlist(vlist, net, initial_marking, final_marking, tmap, bmap, parameters=parameters)
results.append(result)
al_idx = {}
for index_variant, variant in enumerate(variants_idxs):
for trace_idx in variants_idxs[variant]:
al_idx[trace_idx] = results[index_variant]
ret = []
for i in range(len(log)):
ret.append(al_idx[i])
return ret
def to(net0, im0, fm0):
net = PetriNet("")
im = Marking()
fm = Marking()
dp = {}
dt = {}
i = 0
while i < len(net0[0]):
p = PetriNet.Place(str(net0[0][i]))
net.places.add(p)
dp[i] = p
i = i + 1
i = 0
while i < len(net0[1]):
t = PetriNet.Transition("t%d" % (i), net0[1][i][0])
net.transitions.add(t)
dt[i] = t
i = i + 1
i = 0
while i < len(net0[1]):
for p in net0[1][i][1]:
petri_utils.utils.add_arc_from_to(dp[p], dt[i], net)
for p in net0[1][i][2]:
petri_utils.utils.add_arc_from_to(dt[i], dp[p], net)
i = i + 1
for p in im0:
im[dp[p]] = im0[p]
for p in fm0:
fm[dp[p]] = fm0[p]
return net, im, fm
def construct_trace_net(trace,
trace_name_key=xes_util.DEFAULT_NAME_KEY,
activity_key=xes_util.DEFAULT_NAME_KEY):
"""
Creates a trace net, i.e. a trace in Petri net form.
Parameters
----------
trace: :class:`list` input trace, assumed to be a list of events
trace_name_key: :class:`str` key of the attribute that defines the name of the trace
activity_key: :class:`str` key of the attribute of the events that defines the activity name
Returns
-------
tuple: :class:`tuple` of the net, initial marking and the final marking
"""
net = PetriNet('trace net of %s' %
trace.attributes[trace_name_key] if trace_name_key in
trace.attributes else ' ')
place_map = {0: PetriNet.Place('p_0')}
net.places.add(place_map[0])
for i in range(0, len(trace)):
t = PetriNet.Transition('t_' + trace[i][activity_key] + '_' + str(i),
trace[i][activity_key])
net.transitions.add(t)
place_map[i + 1] = PetriNet.Place('p_' + str(i + 1))
net.places.add(place_map[i + 1])
add_arc_from_to(place_map[i], t, net)
add_arc_from_to(t, place_map[i + 1], net)
return net, Marking({place_map[0]: 1}), Marking({place_map[len(trace)]: 1})
def merge_comp(comp1, comp2):
net = PetriNet("")
im = Marking()
fm = Marking()
places = {}
trans = {}
for pl in comp1[0].places:
places[pl.name] = PetriNet.Place(pl.name)
net.places.add(places[pl.name])
if pl in comp1[1]:
im[places[pl.name]] = comp1[1][pl]
if pl in comp1[2]:
fm[places[pl.name]] = comp1[2][pl]
for pl in comp2[0].places:
places[pl.name] = PetriNet.Place(pl.name)
net.places.add(places[pl.name])
if pl in comp2[1]:
im[places[pl.name]] = comp2[1][pl]
if pl in comp2[2]:
fm[places[pl.name]] = comp2[2][pl]
for tr in comp1[0].transitions:
trans[tr.name] = PetriNet.Transition(tr.name, tr.label)
net.transitions.add(trans[tr.name])
for tr in comp2[0].transitions:
if not tr.name in trans:
trans[tr.name] = PetriNet.Transition(tr.name, tr.label)
net.transitions.add(trans[tr.name])
for arc in comp1[0].arcs:
if type(arc.source) is PetriNet.Place:
add_arc_from_to(places[arc.source.name], trans[arc.target.name],
net)
else:
add_arc_from_to(trans[arc.source.name], places[arc.target.name],
net)
for arc in comp2[0].arcs:
if type(arc.source) is PetriNet.Place:
add_arc_from_to(places[arc.source.name], trans[arc.target.name],
net)
else:
add_arc_from_to(trans[arc.source.name], places[arc.target.name],
net)
lvis_labels = sorted(
[t.label for t in net.transitions if t.label is not None])
t_tuple = tuple(
sorted(
list(
int(hashlib.md5(t.name.encode('utf-8')).hexdigest(), 16)
for t in net.transitions)))
net.lvis_labels = lvis_labels
net.t_tuple = t_tuple
return (net, im, fm)
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 test_marking_equality():
net = PetriNet()
p0 = PetriNet.Place('p0')
p1 = PetriNet.Place('p1')
net.places.update([p0, p1])
m0 = Marking([p0])
m1 = Marking([p0])
assert m0 == m1
def construct(pn1, im1, fm1, pn2, im2, fm2, skip):
"""
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
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)
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)
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
def test_52(self):
# creating an empty Petri net
from pm4py.objects.petri.petrinet import PetriNet, Marking
net = PetriNet("new_petri_net")
# creating source, p_1 and sink place
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 exporter as pnml_exporter
pnml_exporter.apply(net, initial_marking, "createdPetriNet1.pnml", final_marking=final_marking)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
gviz = pn_visualizer.apply(net, initial_marking, final_marking)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters)
pn_visualizer.save(gviz, "alpha.svg")
os.remove("createdPetriNet1.pnml")
os.remove("alpha.svg")
def project_net_on_place(place):
"""
Project a Petri net on a place
Parameters
-------------
place
Place
Returns
-------------
net
(Place) net
im
Empty initial marking
fm
Empty final marking
"""
place_net = PetriNet()
place_net_im = Marking()
place_net_fm = Marking()
input_trans = [arc.source for arc in place.in_arcs]
output_trans = [arc.target for arc in place.out_arcs]
if len(input_trans) == 0 or len(output_trans) == 0:
raise Exception("place projection not available on source/sink places")
input_trans_visible = [trans for trans in input_trans if trans.label]
output_trans_visible = [trans for trans in output_trans if trans.label]
if not len(input_trans) == len(input_trans_visible) or not len(
output_trans) == len(output_trans_visible):
raise Exception(
"place projection not available on places that have invisible transitions as preset/postset"
)
new_place = PetriNet.Place(place.name)
place_net.places.add(new_place)
for trans in input_trans:
new_trans = PetriNet.Transition(trans.name, trans.label)
place_net.transitions.add(new_trans)
add_arc_from_to(new_trans, new_place, place_net)
for trans in output_trans:
new_trans = PetriNet.Transition(trans.name, trans.label)
place_net.transitions.add(new_trans)
add_arc_from_to(new_place, new_trans, place_net)
return place_net, place_net_im, place_net_fm
def __init__(self,
current_time: datetime,
decay_values: dict,
token_counts: dict,
marking: Marking,
place_list: list,
resource_count: dict = None,
resource_indices: dict = None,
loadExisting: bool = False):
self.__data__ = {"ct": current_time}
#ct = current time
if not loadExisting:
decay_vector = []
token_count_vector = []
marking_vector = []
for place in place_list:
decay_vector.append(decay_values[str(place)])
token_count_vector.append(token_counts[str(place)])
if str(place) in [str(key) for key in marking.keys()]:
for key, val in marking.items():
if str(key) == str(place):
marking_vector.append(val)
break
else:
marking_vector.append(0)
if resource_count is None:
self.__data__["tss"] = [
decay_vector, token_count_vector, marking_vector
]
else:
resource_vector = [
0 for _ in range(len(resource_indices.keys()))
]
for key in resource_count.keys():
resource_vector[
resource_indices[key]] = resource_count[key]
self.__data__["tss"] = [
decay_vector, token_count_vector, marking_vector,
resource_vector
]
else:
""" Load from File """
self.__data__ = {
"ct": current_time,
"tss": [decay_values, token_counts, marking]
}
def __copy_net(self, pn, m0, mf):
self.__pn = deepcopy(pn)
self.__transitions = list(self.__pn.transitions)
self.__places = list(self.__pn.places)
self.__arcs = list(self.__pn.arcs)
self.__m0 = Marking()
self.__mf = Marking()
for p in self.__pn.places:
for n in m0.keys():
if n.name == p.name:
self.__m0[p] = 1
for n in mf.keys():
if n.name == p.name:
self.__mf[p] = 1
def remove_initial_hidden_if_possible(net, im):
"""
Remove initial hidden transition if possible
Parameters
------------
net
Petri net
im
Initial marking
Returns
------------
net
Petri net
im
Possibly different initial marking
"""
source = list(im.keys())[0]
first_hidden = list(source.out_arcs)[0].target
target_places_first_hidden = [x.target for x in first_hidden.out_arcs]
if len(target_places_first_hidden) == 1:
target_place_first_hidden = target_places_first_hidden[0]
if len(target_place_first_hidden.in_arcs) == 1:
new_im = Marking()
new_im[target_place_first_hidden] = 1
petri.utils.remove_place(net, source)
petri.utils.remove_transition(net, first_hidden)
return net, new_im
return net, im
def log_to_Pn(traces_xes,size_of_run):
traces = project_traces(traces_xes)
petri_of_traces=PetriNet()
init, end=PetriNet.Place("init"),PetriNet.Place("end")
[petri_of_traces.places.add(place) for place in [init, end]]
prec=init
for t in traces:
prec=init
for a in range (0,min(size_of_run,len(t))):
transition=PetriNet.Transition(t[a]+str(a), t[a])
petri_of_traces.transitions.add(transition)
place_suiv=end if a in [size_of_run-1,len(t)-1] else PetriNet.Place(t[a]+str(a))
add_arc_from_to(transition, place_suiv, petri_of_traces)
add_arc_from_to(prec, transition, petri_of_traces)
prec=place_suiv
m0=Marking().__add__({init:1})
mf=Marking().__add__({end:1})
return petri_of_traces,m0,mf
def add_markings(curr, add):
m = Marking()
for p in curr.items():
m[p[0]] = p[1]
for p in add.items():
m[p[0]] += p[1]
if m[p[0]] == 0:
del m[p[0]]
return m
def get_marking(net):
"""
Helper functions that creates a pm4py Marking object from a pm4py PetriNet
where the marking is encoded in the properties.
"""
marking = Marking()
for place in net.places:
marking[place] = place.properties['tokens']
return marking
def get_strongly_connected_subnets(net):
"""
Get the strongly connected components subnets in the Petri net
Parameters
-------------
net
Petri net
Returns
-------------
strongly_connected_transitions
List of strongly connected transitions of the Petri net
"""
import networkx as nx
graph, inv_dictionary = create_networkx_directed_graph(net)
sccg = list(nx.strongly_connected_components(graph))
strongly_connected_subnets = []
for sg in list(sccg):
if len(sg) > 1:
subnet = PetriNet()
imarking = Marking()
fmarking = Marking()
corr = {}
for node in sg:
if node in inv_dictionary:
if type(inv_dictionary[node]) is PetriNet.Transition:
prev_trans = inv_dictionary[node]
new_trans = PetriNet.Transition(
prev_trans.name, prev_trans.label)
corr[node] = new_trans
subnet.transitions.add(new_trans)
if type(inv_dictionary[node]) is PetriNet.Place:
prev_place = inv_dictionary[node]
new_place = PetriNet.Place(prev_place.name)
corr[node] = new_place
subnet.places.add(new_place)
for edge in graph.edges:
if edge[0] in sg and edge[1] in sg:
add_arc_from_to(corr[edge[0]], corr[edge[1]], subnet)
strongly_connected_subnets.append([subnet, imarking, fmarking])
return strongly_connected_subnets
def align_fake_log_stop_marking(fake_log, net, marking, final_marking, parameters=None):
"""
Align the 'fake' log_skeleton with all the prefixes in order to get the markings in which
the alignment stops
Parameters
-------------
fake_log
Fake log_skeleton
net
Petri net
marking
Marking
final_marking
Final marking
parameters
Parameters of the algorithm
Returns
-------------
alignment
For each trace in the log_skeleton, return the marking in which the alignment stops (expressed as place name with count)
"""
if parameters is None:
parameters = {}
align_result = []
for i in range(len(fake_log)):
trace = fake_log[i]
sync_net, sync_initial_marking, sync_final_marking = build_sync_net(trace, net, marking, final_marking,
parameters=parameters)
stop_marking = Marking()
for pl, count in sync_final_marking.items():
if pl.name[1] == utils.SKIP:
stop_marking[pl] = count
cost_function = utils.construct_standard_cost_function(sync_net, utils.SKIP)
# perform the alignment of the prefix
res = precision_utils.__search(sync_net, sync_initial_marking, sync_final_marking, stop_marking, cost_function,
utils.SKIP)
if res is not None:
align_result.append([])
for mark in res:
res2 = {}
for pl in mark:
# transforms the markings for easier correspondence at the end
# (distributed engine friendly!)
res2[(pl.name[0], pl.name[1])] = mark[pl]
align_result[-1].append(res2)
else:
# if there is no path from the initial marking
# replaying the given prefix, then add None
align_result.append(None)
return align_result
def strongly_test():
net = preprocess(example_graph)
print(net)
initial_marking = Marking()
final_marking = Marking()
for place in net.places:
if place.name != "p2":
initial_marking[place] = 1
else:
final_marking[place] = 1
parameters = {
pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"
}
gviz = pn_visualizer.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_visualizer.save(gviz, "alpha.svg")
def decode_marking(self, ems):
"""
Decodes a marking from a generic dictionary
to a Marking object
"""
em = eval(ems)
mark = Marking()
for p in em:
mark[self.places_inv_dict[p]] = em[p]
return mark
def create_PetriNet(n):
# label_set[0] = 'a',...,label_set[26]=z
label_set = dict(enumerate(string.ascii_lowercase))
if n >= 26:
print("N is >= 26 but there are only 26 unique letters.")
# create new petrinet
net = PetriNet("PN")
place_list = []
# create start and end place
start = PetriNet.Place("start")
end = PetriNet.Place("end")
net.places.add(start)
net.places.add(end)
place_list.insert(0, start)
place_list.insert(n + 1, end)
# create the rest of n-2 places (n+1 places are needed for a length n trace)
for i in range(n - 1):
p = PetriNet.Place(f"p{i}")
net.places.add(p)
place_list.insert(i + 1, p)
transitions_list = []
# create n transitions
for i in range(n):
t = PetriNet.Transition(f"t{i}", label_set[i])
net.transitions.add(t)
transitions_list.insert(i, t)
for i, t in enumerate(transitions_list):
utils.add_arc_from_to(place_list[i], t, net)
utils.add_arc_from_to(t, place_list[i + 1], net)
# defining initial and final marking
im = Marking()
im[start] = 1
fm = Marking()
fm[end] = 1
return net, im
def get_corresp_marking_and_trans(m, index, corresp, t):
marking = Marking()
marking[corresp[0][-index]] = 1
for pl in m:
if not corresp[1][pl] in marking:
marking[corresp[1][pl]] = 0
marking[corresp[1][pl]] = marking[corresp[1][pl]] + 1
trans = None
if t in corresp[2]:
trans = corresp[2][t]
return marking, trans
def construct_trace_net_cost_aware(trace,
costs,
trace_name_key=xes_util.DEFAULT_NAME_KEY,
activity_key=xes_util.DEFAULT_NAME_KEY):
"""
Creates a trace net, i.e. a trace in Petri net form mapping specific costs to transitions.
Parameters
----------
trace: :class:`list` input trace, assumed to be a list of events
costs: :class:`list` list of costs, length should be equal to the length of the input trace
trace_name_key: :class:`str` key of the attribute that defines the name of the trace
activity_key: :class:`str` key of the attribute of the events that defines the activity name
Returns
-------
tuple: :class:`tuple` of the net, initial marking, final marking and map of costs
"""
net = PetriNet('trace net of %s' %
trace.attributes[trace_name_key] if trace_name_key in
trace.attributes else ' ')
place_map = {0: PetriNet.Place('p_0')}
net.places.add(place_map[0])
cost_map = dict()
for i in range(0, len(trace)):
t = PetriNet.Transition('t_' + trace[i][activity_key] + '_' + str(i),
trace[i][activity_key])
# 16/02/2021: set the trace index as property of the transition of the trace net
t.properties[properties.TRACE_NET_TRANS_INDEX] = i
cost_map[t] = costs[i]
net.transitions.add(t)
place_map[i + 1] = PetriNet.Place('p_' + str(i + 1))
# 16/02/2021: set the place index as property of the place of the trace net
place_map[i + 1].properties[properties.TRACE_NET_PLACE_INDEX] = i + 1
net.places.add(place_map[i + 1])
add_arc_from_to(place_map[i], t, net)
add_arc_from_to(t, place_map[i + 1], net)
return net, Marking({place_map[0]: 1}), Marking({place_map[len(trace)]:
1}), cost_map
def __get_model_marking_and_index(marking):
"""
Transforms a marking on the synchronous product net
to a marking in the model and an index in the trace
"""
mm = Marking()
index = -1
for p in marking:
if properties.TRACE_NET_PLACE_INDEX in p.properties:
index = p.properties[properties.TRACE_NET_PLACE_INDEX]
else:
mm[p] = marking[p]
return mm, index
def execute(t, yn, m):
mm = Marking()
mmm = Marking()
m_out = copy.copy(m)
if not is_enabled(t, yn, m):
#if it should not be executed, just execute it and return original marking + executed marking
for arcs in t.out_arcs:
m[arcs.target] += 1
return m
for a in t.in_arcs:
p = a.source
if not p.is_hidden or m[p] >= a.weight:
m_out = petri_execute(t, yn, m)
else:
for c in p.in_arcs:
for d in c.source.in_arcs:
for e in d.source.in_arcs:
if e.source.is_hidden:
mmm = petri_execute(e.source, yn, m)
if mmm is not None and len(mmm) > 0:
break
if mmm is not None and len(mmm) > 0:
break
if mmm is not None and len(mmm) > 0:
break
for b in p.in_arcs:
if mmm is not None and len(mmm) > 0:
mm = petri_execute(b.source, yn, mmm)
if mm is not None:
break
else:
mm = petri_execute(b.source, yn, m)
if mm is not None:
break
m_out = petri_execute(t, yn, mm)
return m_out
def transform_markings_from_sync_to_original_net(markings0,
net,
parameters=None):
"""
Transform the markings of the sync net (in which alignment stops) into markings of the original net
(in order to measure the precision)
Parameters
-------------
markings0
Markings on the sync net (expressed as place name with count)
net
Petri net
parameters
Parameters of the algorithm
Returns
-------------
markings
Markings of the original model (expressed as place with count)
"""
if parameters is None:
parameters = {}
places_corr = {p.name: p for p in net.places}
markings = []
for i in range(len(markings0)):
res_list = markings0[i]
# res_list shall be a list of markings.
# If it is None, then there is no correspondence markings
# in the original Petri net
if res_list is not None:
# saves all the markings reached by the optimal alignment
# as markings of the original net
markings.append([])
for j in range(len(res_list)):
res = res_list[j]
atm = Marking()
for pl, count in res.items():
if pl[0] == utils.SKIP:
atm[places_corr[pl[1]]] = count
markings[-1].append(atm)
else:
markings.append(None)
return markings
def decorate_transitions_prepostset(net):
"""
Decorate transitions with sub and addition markings
Parameters
-------------
net
Petri net
"""
from pm4py.objects.petri.petrinet import Marking
for trans in net.transitions:
sub_marking = Marking()
add_marking = Marking()
for arc in trans.in_arcs:
sub_marking[arc.source] = arc.weight
add_marking[arc.source] = -arc.weight
for arc in trans.out_arcs:
if arc.target in add_marking:
add_marking[arc.target] = arc.weight + add_marking[arc.target]
else:
add_marking[arc.target] = arc.weight
trans.sub_marking = sub_marking
trans.add_marking = add_marking
def apply(tree, parameters=None):
"""
Conversion Process Tree to PetriNet.
Parameters
-----------
tree
Process tree
parameters
PARAM_CHILD_LOCK
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
counts = Counts()
net = petri.petrinet.PetriNet('imdf_net_' + str(time.time()))
initial_marking = Marking()
final_marking = Marking()
source = get_new_place(counts)
source.name = SOURCE_NAME
sink = get_new_place(counts)
sink.name = SINK_NAME
net.places.add(source)
net.places.add(sink)
initial_marking[source] = 1
final_marking[sink] = 1
generate_pn(tree, net, source, sink, counts, parameters)
return net, initial_marking, final_marking
def get_initial_marking(net, max_no_comb=4):
"""
Get the initial marking from a Petri net
(observing which nodes are without input connection,
if several nodes exist, then a source place is created artificially)
Parameters
-------------
net
Petri net
Returns
-------------
net
Petri net
initial_marking
Initial marking of the Petri net
"""
places = set(net.places)
places_wo_input = []
for place in places:
if len(place.in_arcs) == 0:
places_wo_input.append(place)
places_wo_input = list(places_wo_input)
initial_marking = Marking()
if len(places_wo_input) > 1:
source = PetriNet.Place('petri_source')
net.places.add(source)
for i in range(len(places_wo_input)):
htrans = PetriNet.Transition("itrans_" + str(i), None)
net.transitions.add(htrans)
utils.add_arc_from_to(source, htrans, net)
utils.add_arc_from_to(htrans, places_wo_input[i], net)
initial_marking[source] = 1
elif len(places_wo_input) == 1:
places_wo_input = list(places_wo_input)
initial_marking[places_wo_input[0]] = 1
return net, initial_marking
def discover_initial_marking(petri):
"""
Discovers initial marking from a Petri net
Parameters
------------
petri
Petri net
Returns
------------
initial_marking
Initial marking of the Petri net
"""
initial_marking = Marking()
for place in petri.places:
if len(place.in_arcs) == 0:
initial_marking[place] = 1
return initial_marking
