def test_multiple_optimal_alignments(self):
net = PetriNet()
for i in range(1, 5):
net.add_place(i)
transitions = ['A', 'B', 'C', 'D']
for t in transitions:
net.add_transition(t)
edges = [(1, -1), (1, -2), (-1, 2), (-2, 2), (2, -3), (-3, 3), (3, -4),
(-4, 4)]
for e in edges:
net.add_edge(e[0], e[1])
trace = ['C']
trace_net = TraceNet(trace)
sync_prod = SynchronousProduct(net, trace_net)
ilp_searcher = A_Star(sync_prod,
trace,
heuristic='ilp',
n_alignments=2)
ilp_searcher.search()
# ----------------------------------
self.assertTrue(len(ilp_searcher.alignments) == 2)
self.assertTrue(
[('B', '>>'), ('C', 'C'), ('D',
'>>')] in ilp_searcher.alignment_moves)
self.assertTrue(
[('A', '>>'), ('C', 'C'), ('D',
'>>')] in ilp_searcher.alignment_moves)
def test_add_edge_df_pn(self):
dpn = PetriNet()
dpn.add_transition('A')
dpn.add_place(1)
dpn.add_place(2)
# ----------------------------------
dpn.add_edge(1, -1, True)
self.assertEqual(dpn.edges, [(1, -1), (-1, 1)])
def test_all_enabled_transitions(self):
net = PetriNet()
net.add_transition('A').add_transition('B')
net.add_place(1).add_place(2).add_place(3).add_place(4)
net.add_edge(1, -1).add_edge(-1, 3).add_edge(2, -1) \
.add_edge(3, -2).add_edge(-2, 4)
# ----------------------------------
net.add_marking(1).add_marking(2)
transitions = net.all_enabled_transitions()
self.assertListEqual(transitions, [-1])
def test_is_enabled(self):
net = PetriNet()
net.add_transition('A')
net.add_place(1).add_place(2).add_place(3)
net.add_edge(1, -1).add_edge(-1, 3).add_edge(2, -1)
# ----------------------------------
self.assertFalse(net.is_enabled(-1))
net.add_marking(1)
self.assertFalse(net.is_enabled(-1))
net.add_marking(2)
self.assertTrue(net.is_enabled(-1))
def test_replay_df_pn(self):
dpn = PetriNet()
dpn.add_transition('A')
dpn.add_transition('B')
dpn.add_transition('C')
dpn.add_place(1)
dpn.add_place(2)
dpn.add_place(3)
dpn.add_edge(1, -1)
dpn.add_edge(-1, 2)
dpn.add_edge(1, -3)
dpn.add_edge(-3, 3)
# dpn.add_edge(1, -2) # deadlock
dpn.add_edge(2, -2)
# dpn.add_edge(3, -2)
dpn.add_edge(-2, 3)
dpn.add_marking(1)
# dpn.add_marking(2, 2)
# dpn.add_marking(3, 2)
# start replay
dpn.replay(5)
self.assertListEqual(dpn.marking, [0, 0, 1])
def test_remove_all_edges_of_df_pn(self):
dpn = PetriNet()
dpn.add_transition('A')
dpn.add_transition('B')
dpn.add_place(1)
dpn.add_place(2)
dpn.add_edge(1, -1, True)
dpn.add_edge(-1, 2)
dpn.add_edge(1, -2)
# ----------------------------------
dpn.remove_all_edges_of(-1)
self.assertEqual(dpn.edges, [(1, -2)])
def test_place_capacity(self):
net = PetriNet()
for i in range(1, 4):
net.add_place(i)
net.add_transition('A')
net.add_transition('B')
net.add_edge(1, -1)
net.add_edge(-1, 2)
net.add_edge(-1, 3)
net.add_edge(2, -2)
net.add_marking(1, 1)
net.add_marking(2, 4)
net.fire_transition(-1)
print(net.get_exceeded_places())
net.fire_transition(-2)
net.fire_transition(-2)
net.fire_transition(-2)
net.fire_transition(-2)
print(net.get_exceeded_places())
from pmlab_lite.alignments import a_star
from pmlab_lite.helper.viz.dot import draw_petri_net, draw_synchronous_product, draw_a_star_search_space
from numpy.linalg import lstsq, matrix_rank
#create running example from conformance checking, p. 126
running_example = PetriNet()
transitions = ['As', 'Aa', 'Da1', 'Fa', 'Sso', 'Ro', 'Co', 'tau', 'Ao', 'Do', 'Aaa', 'Da2', 'Af']
edges = [(1,-1), (-1,2), (2,-3), (2,-2), (-3,11), (-2,3), (-2,5), (3,-4), (-4,4), (4,-8), (5,-5), (-5,6), (6,-6), (-6,7), (7,-7), (-7,5), (7,-8),
(-8,8), (8,-9), (-9,9), (9,-11), (-11,11), (8,-10), (-10,10), (10,-12), (-12,11), (11,-13), (-13,12)]
for p in range(1,13):
running_example.add_place(p)
for t in transitions:
running_example.add_transition(t)
for e in edges:
running_example.add_edge(e[0], e[1])
#create trace net
trace1 = ['As', 'Aa', 'Sso', 'Ro', 'Ao', 'Aaa', 'Aaa']
trace_net1 = TraceNet(trace1)
#create synchronous product
sp1 = SynchronousProduct(running_example, trace_net1)
# draw nets for first example
#draw_petri_net(running_example, filename='running_example')
#draw_petri_net(trace_net1, filename='trace_net1')
#draw_synchronous_product(sp1, filename='synchronous_product1')
a = a_star.A_Star(sp1, trace1, heuristic='lp')
a.search()
from pmlab_lite.pn import PetriNet, TraceNet, SynchronousProduct
from pmlab_lite.alignments import a_star
from pmlab_lite.helper.viz.dot import draw_petri_net, draw_synchronous_product, draw_a_star_search_space
import numpy as np
from numpy.linalg import lstsq, matrix_rank
from cvxopt import matrix, solvers
net = PetriNet()
transitions = ['A', 'B']
edges = [(1, -1), (-1, 2), (2, -2), (-2, 3)]
for p in range(1, 4):
net.add_place(p)
for t in transitions:
net.add_transition(t)
for e in edges:
net.add_edge(e[0], e[1])
trace = ['A', 'B']
trace_net = TraceNet(trace)
sp = SynchronousProduct(net, trace_net)
im = sp.incidence_matrix()
imv = sp.get_init_marking()
fmv = sp.get_final_marking()
b = fmv - imv
x = np.linalg.lstsq(im, b, rcond=None)[0]
#print(x)
#x[x > 0] = 1
#x[x <= 0] = 0
trans_to_idx = sp.transitions_by_index()