Package org.processmining.plugins.stochasticpetrinet.simulator

Class PNSimulator

  • Direct Known Subclasses:
    PNTimeSeriesSimulator, PNUnfoldedSimulator
    public class PNSimulator
extends java.lang.Object
    Very plain simulator only used for evaluation of the evaluation of the mining of stochastic Petri nets and the repair-log plug-in. Works with simple stochastic Petri nets.

    ProM is no simulator!! By all means use CPNTools (http://cpntools.org) if you want to have a feature-rich stable simulation and analysis tool for all kinds of Petri nets.

    Author:
    Andreas Rogge-Solti

    • Constructor Summary

      Constructors 
      Constructor Description
      PNSimulator()  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      protected void addAllDifferentTracesToLog​(org.deckfour.xes.model.XLog log, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, java.util.LinkedList<VisitState> statesToVisit, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, java.util.Map<java.lang.String,​java.util.Set<java.lang.Integer>> numberOfDecisionTransitions, PNSimulatorConfig config, org.processmining.models.semantics.petrinet.Marking endPlaces)  
      protected org.deckfour.xes.model.XEvent createSimulatedEvent​(org.processmining.models.graphbased.directed.petrinet.elements.Transition transition, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph net, long firingTime, java.lang.String instance)  
      protected org.deckfour.xes.model.XTrace createTrace​(long i, PNSimulatorConfig config)  
      protected org.processmining.models.semantics.petrinet.Marking getEndPlaces​(org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet)  
      double getLogProbabilityOfLastTrace()  
      protected java.util.Date getNextArrivalDate​(java.util.Date lastTime, StochasticNet.TimeUnit unitFactor)  
      static boolean getOnlyImmediateTransitions​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions, boolean immediate)
      Checks whether all transitions in set are immediate (if flag onlyImmediate is true) or whether all transitions in set are timed (if flag onlyImmediate is false).
      protected java.lang.Object getReturnObject​(org.deckfour.xes.model.XTrace trace, long lastFiringTime, PNSimulatorConfig config)  
      long getTransitionRemainingTime​(org.processmining.models.graphbased.directed.petrinet.elements.Transition t, StochasticNet.TimeUnit unitFactor, java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long> transitionRemainingTimes, long startOfTransition, double positiveConstraint, LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurations, boolean useOnlyPastTrainingData)
      Checks if the transition has already a running task (depending on the memory policy, this can be true) and returns that value, or samples a new value freshly from the distribution.
      static org.processmining.models.graphbased.directed.petrinet.elements.Transition getTransitionWithIndex​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions, int index)  
      protected void insertEvent​(java.lang.String instanceId, org.deckfour.xes.model.XTrace trace, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph net, Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> transitionAndDuration, long firingTime, PNSimulatorConfig config)  
      protected boolean isFinal​(org.processmining.models.semantics.petrinet.Marking currentMarking, org.processmining.models.semantics.petrinet.Marking endPlaces)  
      protected boolean isOneBounded​(org.processmining.models.semantics.petrinet.Marking currentMarking)  
      Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> pickTransition​(org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions, java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long> transitionRemainingTimes, LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurationDistributions, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, PNSimulatorConfig config, long startOfTransition, long constraint, boolean usePositiveTimeContraint, boolean useOnlyPastTrainingData)  
      static org.processmining.framework.util.Pair<java.lang.Integer,​java.lang.Double> pickTransitionAccordingToWeights​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions, java.util.Date currentTime, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, boolean useOnlyPastTrainingData)  
      protected double sampleDurationForTransition​(double positiveConstraint, long startOfTransition, TimedTransition timedT, StochasticNet.TimeUnit unitFactor, LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurations, boolean useOnlyPastTrainingData)  
      void setUseOnlyPastTrainingData​(boolean useOnlyPastTrainingData)  
      org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics)
      Asks the user to specify configuration parameters for the simulation.
      org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, PNSimulatorConfig config, org.processmining.models.semantics.petrinet.Marking initialMarking)
      Performs a simulation according to a given configuration PNSimulatorConfig
      org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context, org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, PNSimulatorConfig config, org.processmining.models.semantics.petrinet.Marking initialMarking, org.processmining.models.semantics.petrinet.Marking finalMarking)
      Performs a simulation according to a given configuration PNSimulatorConfig
      java.lang.Object simulateOneTrace​(org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics, PNSimulatorConfig config, org.processmining.models.semantics.petrinet.Marking initialMarking, long traceStart, long constraint, long i, boolean useTimeConstraint, org.processmining.models.semantics.petrinet.Marking finalMarking)
      Performs a simple simulation of the Petri net (mostly used for StochasticNets, but can also simulate a PN without stochastic annotations)
      static boolean transitionsContainTimingInfo​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions)  
      void updateTransitionMemoriesAfterFiring​(PNSimulatorConfig config, java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitionsEnabledInMarking, Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> transitionAndDuration, long elapsedTimeInCurrentMarking, java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> afterwardsEnabledTransitions, org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics)  

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • TRANSITION_COMPLETE

        public static final java.lang.String TRANSITION_COMPLETE
        See Also:
        Constant Field Values

      • LIFECYCLE_TRANSITION

        public static final java.lang.String LIFECYCLE_TRANSITION
        See Also:
        Constant Field Values

      • CONCEPT_SIMULATED

        public static final java.lang.String CONCEPT_SIMULATED
        See Also:
        Constant Field Values

      • CONCEPT_INSTANCE

        public static final java.lang.String CONCEPT_INSTANCE
        See Also:
        Constant Field Values

      • SIMULATED_LOG_PROBABILITY

        public static final java.lang.String SIMULATED_LOG_PROBABILITY
        See Also:
        Constant Field Values

      • random

        protected static java.util.Random random

      • arrivalDistribution

        protected org.apache.commons.math3.distribution.RealDistribution arrivalDistribution

      • transitionRemainingTimes

        protected java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long> transitionRemainingTimes
        Each transition has it's remaining time stored, once it becomes active in a marking. These values are all lowered, by the time elapsed in a marking.

      • lastFiringTime

        protected long lastFiringTime
        Stores the time of the last step in the simulation.

      • oneMarking

        protected org.processmining.models.semantics.petrinet.Marking oneMarking

      • useOnlyPastTrainingData

        protected boolean useOnlyPastTrainingData
        Needs to be explicitly set by the caller. Switching this on, creates a significant overhead in filtering the training data to only being from the relative past. It is currently the only implemented option, and only used for a rolling cross-validation. In this case, we have one training pass to collect all the data and we filter later based on availability of information at prediction time. The reason for this procedure is that events can be scattered throughout the log, For example, the last observation at transition A could be in a trace that started later than the current one!

      • cachedDurations

        protected LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurations
        maps from the prediction time point (long since start of epoch) to a cache storing the predictions for each transition

      • logProbabilityOfCurrentTrace

        protected double logProbabilityOfCurrentTrace

    • Constructor Detail

      • PNSimulator

        public PNSimulator()

    • Method Detail

      • simulate

        public org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context,
                                            org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                            org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics)
        Asks the user to specify configuration parameters for the simulation. PNSimulatorConfig
        Parameters:
        context -
        petriNet -
        semantics -
        Returns:

      • simulate

        public org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context,
                                            org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                            org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                            PNSimulatorConfig config,
                                            org.processmining.models.semantics.petrinet.Marking initialMarking)
        Performs a simulation according to a given configuration PNSimulatorConfig
        Parameters:
        context - UIPluginContext ProM plugin context
        petriNet - a petri net (preferable with stochastic timing information
        semantics - a Semantics according to which simulation should be performed
        config - PNSimulatorConfig
        Returns:

      • simulate

        public org.deckfour.xes.model.XLog simulate​(org.processmining.contexts.uitopia.UIPluginContext context,
                                            org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                            org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                            PNSimulatorConfig config,
                                            org.processmining.models.semantics.petrinet.Marking initialMarking,
                                            org.processmining.models.semantics.petrinet.Marking finalMarking)
        Performs a simulation according to a given configuration PNSimulatorConfig
        Parameters:
        context - UIPluginContext ProM plugin context
        petriNet - a petri net (preferable with stochastic timing information
        semantics - a Semantics according to which simulation should be performed
        config - PNSimulatorConfig
        initialMarking -
        finalMarking -
        Returns:

      • getEndPlaces

        protected org.processmining.models.semantics.petrinet.Marking getEndPlaces​(org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet)

      • addAllDifferentTracesToLog

        protected void addAllDifferentTracesToLog​(org.deckfour.xes.model.XLog log,
                                          org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                          java.util.LinkedList<VisitState> statesToVisit,
                                          org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                          java.util.Map<java.lang.String,​java.util.Set<java.lang.Integer>> numberOfDecisionTransitions,
                                          PNSimulatorConfig config,
                                          org.processmining.models.semantics.petrinet.Marking endPlaces)

      • isOneBounded

        protected boolean isOneBounded​(org.processmining.models.semantics.petrinet.Marking currentMarking)

      • isFinal

        protected boolean isFinal​(org.processmining.models.semantics.petrinet.Marking currentMarking,
                          org.processmining.models.semantics.petrinet.Marking endPlaces)

      • simulateOneTrace

        public java.lang.Object simulateOneTrace​(org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                         org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                         PNSimulatorConfig config,
                                         org.processmining.models.semantics.petrinet.Marking initialMarking,
                                         long traceStart,
                                         long constraint,
                                         long i,
                                         boolean useTimeConstraint,
                                         org.processmining.models.semantics.petrinet.Marking finalMarking)
        Performs a simple simulation of the Petri net (mostly used for StochasticNets, but can also simulate a PN without stochastic annotations)
        Parameters:
        petriNet - PetrinetGraph the model
        semantics - Semantics the semantics
        config - PNSimulatorConfig the configuration PNSimulatorConfig
        initialMarking - Marking the initial Marking
        traceStart - long the date time to start the trace
        constraint - long the date time that all simulated events should be greater than
        i - int trace id
        useTimeConstraint - boolean stores whether created events are constrained to be later than traceStart
        finalMarking - Marking a final marking can be set to terminate the simulation, when it is reached... ignored, if null
        Returns:

      • getLogProbabilityOfLastTrace

        public double getLogProbabilityOfLastTrace()

      • getReturnObject

        protected java.lang.Object getReturnObject​(org.deckfour.xes.model.XTrace trace,
                                           long lastFiringTime,
                                           PNSimulatorConfig config)

      • createTrace

        protected org.deckfour.xes.model.XTrace createTrace​(long i,
                                                    PNSimulatorConfig config)

      • insertEvent

        protected void insertEvent​(java.lang.String instanceId,
                           org.deckfour.xes.model.XTrace trace,
                           org.processmining.models.graphbased.directed.petrinet.PetrinetGraph net,
                           Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> transitionAndDuration,
                           long firingTime,
                           PNSimulatorConfig config)

      • updateTransitionMemoriesAfterFiring

        public void updateTransitionMemoriesAfterFiring​(PNSimulatorConfig config,
                                                java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitionsEnabledInMarking,
                                                Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> transitionAndDuration,
                                                long elapsedTimeInCurrentMarking,
                                                java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> afterwardsEnabledTransitions,
                                                org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics)

      • createSimulatedEvent

        protected org.deckfour.xes.model.XEvent createSimulatedEvent​(org.processmining.models.graphbased.directed.petrinet.elements.Transition transition,
                                                             org.processmining.models.graphbased.directed.petrinet.PetrinetGraph net,
                                                             long firingTime,
                                                             java.lang.String instance)

      • getTransitionRemainingTime

        public long getTransitionRemainingTime​(org.processmining.models.graphbased.directed.petrinet.elements.Transition t,
                                       StochasticNet.TimeUnit unitFactor,
                                       java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long> transitionRemainingTimes,
                                       long startOfTransition,
                                       double positiveConstraint,
                                       LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurations,
                                       boolean useOnlyPastTrainingData)
        Checks if the transition has already a running task (depending on the memory policy, this can be true) and returns that value, or samples a new value freshly from the distribution.
        Parameters:
        t - the transition for which the remaining duration (in ms) will be determined
        unitFactor - the scaling factor to get from the distribution parameters to milliseconds
        transitionRemainingTimes -
        startOfTransition - long the entry time of the current marking (i.e., usually the last observed event's timestamp)
        positiveConstraint - a constraint that might restrict sample values (left-truncates the distribution)
        cachedDurations - LimitedTreeMap that caches distributions to avoid costly recomputation from the time series.
        useOnlyPastTrainingData - a flag that tells us whether only data from the past is allowed for the computation of the remaining time
        Returns:
        long milliseconds that the transition has to wait until it will fire.

      • sampleDurationForTransition

        protected double sampleDurationForTransition​(double positiveConstraint,
                                             long startOfTransition,
                                             TimedTransition timedT,
                                             StochasticNet.TimeUnit unitFactor,
                                             LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurations,
                                             boolean useOnlyPastTrainingData)
        Parameters:
        positiveConstraint - a possible constraint for sampling a value from the distribution of the transition
        startOfTransition - long the current time (or better: the last observed event's time)
        timedT - TimedTransition that captures information about the duration distribution from which the sample should be taken.
        Returns:

      • pickTransition

        public Triple<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long,​java.lang.Double> pickTransition​(org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                                                                                                                                    java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions,
                                                                                                                                                    java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​java.lang.Long> transitionRemainingTimes,
                                                                                                                                                    LimitedTreeMap<java.lang.Integer,​java.util.Map<org.processmining.models.graphbased.directed.petrinet.elements.Transition,​org.apache.commons.math3.distribution.RealDistribution>> cachedDurationDistributions,
                                                                                                                                                    org.processmining.models.graphbased.directed.petrinet.PetrinetGraph petriNet,
                                                                                                                                                    PNSimulatorConfig config,
                                                                                                                                                    long startOfTransition,
                                                                                                                                                    long constraint,
                                                                                                                                                    boolean usePositiveTimeContraint,
                                                                                                                                                    boolean useOnlyPastTrainingData)
        Parameters:
        semantics - the Semantics of the net
        transitions - all enabled transitions to pick from.
        transitionRemainingTimes - state of the simulation (transitions have associated remaining times/clocks)
        cachedDurationDistributions - (if transitions are only allowed to use training data up to a certain point in time, then this cache prevents us to recompute the estimated distribution over and over)
        petriNet - the underlying Petri net of the simulation.
        config - the configuration of the simulation. See PNSimulatorConfig. Contains the selection policy!
        startOfTransition - the absolute time of the current marking's last state.
        constraint - all sampled durations should be greater than the constraint
        usePositiveTimeContraint - the simulation might start in the middle of one trace, after some time has passed. In this case, we don't want to generate samples that are in the past. (the parameter traceStart sets the constraint's value)
        useOnlyPastTrainingData - flag that indicates whether only past training data is allowed to be used (rolling forecasts), or all training data is allowed to be used in distribution estimation (cross-validation)
        Returns:
        The transition that is picked as the next one to fire with its duration in the current marking

      • transitionsContainTimingInfo

        public static boolean transitionsContainTimingInfo​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions)

      • getOnlyImmediateTransitions

        public static boolean getOnlyImmediateTransitions​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions,
                                                  boolean immediate)
        Checks whether all transitions in set are immediate (if flag onlyImmediate is true) or whether all transitions in set are timed (if flag onlyImmediate is false). Example: To check, whether all transitions in the set trans are immediate, call: getOnlyImmediateTransitions(trans,true);
        Parameters:
        transitions - set of transitions to check, whether they belong to the same type (immediate, or not immediate)
        immediate - flag
        Returns:

      • pickTransitionAccordingToWeights

        public static org.processmining.framework.util.Pair<java.lang.Integer,​java.lang.Double> pickTransitionAccordingToWeights​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions,
                                                                                                                               java.util.Date currentTime,
                                                                                                                               org.processmining.models.semantics.Semantics<org.processmining.models.semantics.petrinet.Marking,​org.processmining.models.graphbased.directed.petrinet.elements.Transition> semantics,
                                                                                                                               boolean useOnlyPastTrainingData)
        Parameters:
        transitions - collections of enabled transitions
        currentTime - the current simulation time
        semantics - semantics of the net
        useOnlyPastTrainingData - flag that tells us wether we can use all training data, or only the ones in the past (e.g. for rolling forecasts)
        Returns:

      • getTransitionWithIndex

        public static org.processmining.models.graphbased.directed.petrinet.elements.Transition getTransitionWithIndex​(java.util.Collection<org.processmining.models.graphbased.directed.petrinet.elements.Transition> transitions,
                                                                                                               int index)

      • getNextArrivalDate

        protected java.util.Date getNextArrivalDate​(java.util.Date lastTime,
                                            StochasticNet.TimeUnit unitFactor)

      • setUseOnlyPastTrainingData

        public void setUseOnlyPastTrainingData​(boolean useOnlyPastTrainingData)