def apply_playout(net, initial_marking, no_traces=100, max_trace_length=100,
case_id_key=xes_constants.DEFAULT_TRACEID_KEY,
activity_key=xes_constants.DEFAULT_NAME_KEY, timestamp_key=xes_constants.DEFAULT_TIMESTAMP_KEY,
final_marking=None, smap=None, log=None, return_visited_elements=False):
"""
Do the playout of a Petrinet generating a log
Parameters
----------
net
Petri net to play-out
initial_marking
Initial marking of the Petri net
no_traces
Number of traces to generate
max_trace_length
Maximum number of events per trace (do break)
case_id_key
Trace attribute that is the case ID
activity_key
Event attribute that corresponds to the activity
timestamp_key
Event attribute that corresponds to the timestamp
final_marking
If provided, the final marking of the Petri net
smap
Stochastic map
log
Log
"""
if final_marking is None:
# infer the final marking from the net
final_marking = final_marking_discovery.discover_final_marking(net)
if smap is None:
if log is None:
raise Exception("please provide at least one between stochastic map and log")
smap = replay.get_map_from_log_and_net(log, net, initial_marking, final_marking,
parameters={Parameters.ACTIVITY_KEY: activity_key,
Parameters.TIMESTAMP_KEY: timestamp_key})
# assigns to each event an increased timestamp from 1970
curr_timestamp = 10000000
all_visited_elements = []
for i in range(no_traces):
visited_elements = []
visible_transitions_visited = []
marking = copy(initial_marking)
while len(visible_transitions_visited) < max_trace_length:
visited_elements.append(marking)
if not semantics.enabled_transitions(net, marking): # supports nets with possible deadlocks
break
all_enabled_trans = semantics.enabled_transitions(net, marking)
if final_marking is not None and marking == final_marking:
en_t_list = list(all_enabled_trans.union({None}))
else:
en_t_list = list(all_enabled_trans)
trans = stochastic_utils.pick_transition(en_t_list, smap)
if trans is None:
break
visited_elements.append(trans)
if trans.label is not None:
visible_transitions_visited.append(trans)
marking = semantics.execute(trans, net, marking)
all_visited_elements.append(tuple(visited_elements))
if return_visited_elements:
return all_visited_elements
log = log_instance.EventLog()
for index, visited_elements in enumerate(all_visited_elements):
trace = log_instance.Trace()
trace.attributes[case_id_key] = str(index)
for element in visited_elements:
if type(element) is PetriNet.Transition and element.label is not None:
event = log_instance.Event()
event[activity_key] = element.label
event[timestamp_key] = datetime.datetime.fromtimestamp(curr_timestamp)
trace.append(event)
# increases by 1 second
curr_timestamp += 1
log.append(trace)
return log
def run(self):
"""
Runs the thread
"""
if self.enable_diagnostics:
diagnostics = SimulationDiagnostics(self)
diagnostics.start()
from intervaltree import IntervalTree, Interval
logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
net, im, fm, smap, source, sink, start_time = self.net, self.im, self.fm, self.map, self.source, self.sink, self.start_time
places_interval_trees = self.places_interval_trees
transitions_interval_trees = self.transitions_interval_trees
cases_ex_time = self.cases_ex_time
current_time = start_time
self.internal_thread_start_time = time()
rem_time = self.get_rem_time()
acquired_places = set()
acquired = source.semaphore.acquire(timeout=rem_time)
if acquired:
acquired_places.add(source)
source.assigned_time.append(current_time)
current_marking = im
et = enabled_transitions(net, current_marking)
first_event = None
last_event = None
while not fm <= current_marking or len(et) == 0:
et = list(enabled_transitions(net, current_marking))
ct = stochastic_utils.pick_transition(et, smap)
simulated_execution_plus_waiting_time = -1
while simulated_execution_plus_waiting_time < 0:
simulated_execution_plus_waiting_time = smap[ct].get_value(
) if ct in smap else 0.0
# establish how much time we need to wait before firing the transition
# (it depends on the input places tokens)
waiting_time = 0
for arc in ct.out_arcs:
place = arc.target
sem_value = int(place.semaphore._value)
rem_time = self.get_rem_time()
acquired = place.semaphore.acquire(timeout=rem_time)
if acquired:
acquired_places.add(place)
rem_time = self.get_rem_time()
if rem_time == 0:
break
if sem_value == 0:
waiting_time = max(
waiting_time,
place.assigned_time.pop(0) -
current_time) if place.assigned_time else waiting_time
if rem_time == 0:
for place in acquired_places:
place.semaphore.release()
break
# if the waiting time is greater than 0, add an interval to the interval tree denoting
# the waiting times for the given transition
if waiting_time > 0:
transitions_interval_trees[ct].add(
Interval(current_time, current_time + waiting_time))
# get the actual execution time of the transition as a difference between simulated_execution_plus_waiting_time
# and the waiting time
execution_time = max(
simulated_execution_plus_waiting_time - waiting_time, 0)
# increase the timing based on the waiting time and the execution time of the transition
current_time = current_time + waiting_time + execution_time
for arc in ct.out_arcs:
place = arc.target
place.assigned_time.append(current_time)
place.assigned_time = sorted(place.assigned_time)
current_marking = weak_execute(ct, current_marking)
if ct.label is not None:
eve = Event({
xes_constants.DEFAULT_NAME_KEY:
ct.label,
xes_constants.DEFAULT_TIMESTAMP_KEY:
datetime.datetime.fromtimestamp(current_time)
})
last_event = eve
if first_event is None:
first_event = last_event
self.list_cases[self.id].append(eve)
for arc in ct.in_arcs:
place = arc.source
p_ex_time = place.assigned_time.pop(0)
if current_time - p_ex_time > 0:
places_interval_trees[place].add(
Interval(p_ex_time, current_time))
place.assigned_time.append(current_time)
place.assigned_time = sorted(place.assigned_time)
place.semaphore.release()
# sleep before starting next iteration
sleep((waiting_time + execution_time) / self.small_scale_factor)
if first_event is not None and last_event is not None:
cases_ex_time.append(
last_event[xes_constants.DEFAULT_TIMESTAMP_KEY].timestamp() -
first_event[xes_constants.DEFAULT_TIMESTAMP_KEY].timestamp())
else:
cases_ex_time.append(0)
places_to_free = set(current_marking).union(acquired_places)
for place in places_to_free:
place.semaphore.release()
rem_time = self.get_rem_time()
if rem_time > 0:
self.terminated_correctly = True
if self.enable_diagnostics:
logger.info(
str(time()) + " terminated successfully thread ID " +
str(self.id))
if self.enable_diagnostics:
if rem_time == 0:
if self.enable_diagnostics:
logger.info(
str(time()) + " terminated for timeout thread ID " +
str(self.id))
if self.enable_diagnostics:
diagnostics.diagn_open = False