org.processmining.plugins.petrinet.replay

Class Replayer<C extends ReplayCost & java.lang.Comparable<? super C>>

java.lang.Object

org.processmining.plugins.petrinet.replay.Replayer<C>

Type Parameters:

C - The class implementing the cost structure. To be able to detect which cost is better, it needs to implement Comparable.

public class Replayer<C extends ReplayCost & java.lang.Comparable<? super C>>
extends java.lang.Object

Cost-based Petri net trace replayer. This replayer returns the cheapest transition sequence that replays a given trace in a given Petri net with a given initial marking. The caller needs to specify a cost structure by implementing the ReplayCost and the ReaplyCostAddOperator interfaces. This cost structure determines which sequence will be the cheapest. The replayer assumes that there are six possible actions that can be used to replay the trace (see ReplayAction): 1. Execute an enabled transition that matches the head of trace. The transition will be inserted in the transition sequence, the head of the trace will be removed. 2. Execute an invisible transition. The transition will be inserted in the transition sequence. 3. Skip the head of the trace. The head of the trace will be removed. 4. Execute an enabled transition that does not match the head of the trace. The transition will be inserted in the transition sequence, but the head of the trace will not be removed. 5. Execute a disabled transition that matches the head of the trace. The transition will be inserted in the transition sequence and the head of the trace will be removed. 6. Execute a disabled transition that does not match the head of the trace. The transition will be inserted in the transition sequence, but the head of the trace will not be removed. In the cost structure, the caller needs to specify what the costs are for every action. To make this more flexible, the cost does not only depend on the action, but may also depend on the transition involved (if any) and the matched head of the trace (if any). Thus, it would be possible for the caller to punish the skipping of a certain head of the trace severely. Apart from the cost structure, the caller also needs to specify an initial cost, a maximal cost, whether some replay is final, and which of the 6 actions are allowed at all. To so so, s/he needs to implement the ReplaySettings interface. The replayer does a cost-based breadth-first search. At any point in time, it will have a set of states in the search space that it can expand. Of these states, it takes the one with the lowest cost, and expands it. If a state corresponds to a final replay, and if it is cheaper then the cheapest replay found so far, then we have a new cheapest replay. The replayer returns null if no replay was found. Some observations that need to be taken into account by the caller: A. To prevent endless cycles, every action should have a positive cost. B. If skipping the head of the trace is allowed, then the replayer will always find some replay (skipping all objects in the trace is a replay).

Author:

hverbeek

See Also:

ReplayCost, ReplayCostAddOperator, ReplaySettings

Constructor Summary

Constructors

Constructor and Description
Replayer(org.processmining.framework.plugin.PluginContext context, org.processmining.models.graphbased.directed.petrinet.Petrinet net, org.processmining.models.semantics.petrinet.PetrinetSemantics semantics, java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,? extends java.lang.Object> map, ReplayCostAddOperator<C> addOperator) Constructs a replayer.

Method Summary

Modifier and Type	Method and Description
java.util.List<org.processmining.models.graphbased.directed.petrinet.elements.Transition>	replayTrace(org.processmining.models.semantics.petrinet.Marking initialMarking, java.util.List<? extends java.lang.Object> trace, ReplaySettings<C> settings) Replays a given trace with the given settings, from the given initial marking.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Replayer

public Replayer(org.processmining.framework.plugin.PluginContext context,
                org.processmining.models.graphbased.directed.petrinet.Petrinet net,
                org.processmining.models.semantics.petrinet.PetrinetSemantics semantics,
                java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,? extends java.lang.Object> map,
                ReplayCostAddOperator<C> addOperator)

Constructs a replayer.

Parameters:

context - The context in which the replayer runs.

net - The net to replay the traces in.

semantics - The semantics to use while replaying traces.

map - The map from transitions to objects in the trace.

addOperator - The operator to use for adding to a cost.

Method Detail

replayTrace

public java.util.List<org.processmining.models.graphbased.directed.petrinet.elements.Transition> replayTrace(org.processmining.models.semantics.petrinet.Marking initialMarking,
                                                                                                             java.util.List<? extends java.lang.Object> trace,
                                                                                                             ReplaySettings<C> settings)
                                                                                                      throws java.lang.InterruptedException,
                                                                                                             java.util.concurrent.ExecutionException

Replays a given trace with the given settings, from the given initial marking. Uses the MultiThreadedSearcher.

Parameters:

initialMarking - The initial marking of the Petri net for this trace.

trace - The trace to replay.

settings - The settings to use.

Returns:

The cheapest transition sequence that replays the given trace, null if no such transition sequence exists.

Throws:

java.util.concurrent.ExecutionException

java.lang.InterruptedException