Search in sources :

Example 1 with BPMNIntermediateEvent

use of de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent in project scylla by bptlab.

the class BoundaryEventPluginUtils method createTimerBoundaryEvents.

// I did not touch this for now. Hopefully could be deleted in future.
private void createTimerBoundaryEvents(SimulationModel model, BoundaryObject bo, double startOfInterval, double endOfInterval) throws ScyllaRuntimeException {
    double beginTimeOfTask = bo.getBeginTimeOfTask();
    ProcessSimulationComponents desmojObjects = bo.getDesmojObjects();
    ProcessModel processModel = desmojObjects.getProcessModel();
    Map<Integer, EventType> eventTypes = processModel.getEventTypes();
    Map<Integer, Boolean> cancelActivities = processModel.getCancelActivities();
    List<Integer> referenceToBoundaryEvents = bo.getReferenceToBoundaryEvents();
    for (Integer nId : referenceToBoundaryEvents) {
        boolean timerEventIsInterrupting = false;
        EventType eventType = eventTypes.get(nId);
        if (eventType == EventType.BOUNDARY) {
            Map<EventDefinitionType, Map<String, String>> eventDefinitions = processModel.getEventDefinitions().get(nId);
            Map<String, String> definitionAttributes = eventDefinitions.get(EventDefinitionType.TIMER);
            if (definitionAttributes != null) {
                // if boundary event is timer event
                double timeUntilWhenTimerEventsAreCreated = bo.getTimeUntilWhenTimerEventsAreCreated();
                if (definitionAttributes.get("timeDuration") != null) {
                    // ISO 8601 duration
                    String timeDuration = definitionAttributes.get("timeDuration");
                    if (beginTimeOfTask != timeUntilWhenTimerEventsAreCreated) {
                        // timer event has already been created once, skip
                        continue;
                    }
                    Duration javaDuration = Duration.parse(timeDuration);
                    double duration = javaDuration.get(ChronoUnit.SECONDS);
                    if (duration == 0) {
                        continue;
                    }
                    double timeToSchedule = beginTimeOfTask + duration;
                    if (timeToSchedule < endOfInterval) {
                        String displayName = processModel.getDisplayNames().get(nId);
                        if (displayName == null) {
                            displayName = processModel.getIdentifiers().get(nId);
                        }
                        String source = bo.getSource();
                        ProcessInstance processInstance = bo.getProcessInstance();
                        TimeInstant timeInstant = new TimeInstant(startOfInterval, TimeUnit.SECONDS);
                        BPMNIntermediateEvent event = new BPMNIntermediateEvent(model, source, timeInstant, desmojObjects, processInstance, nId);
                        bo.getBoundaryEventsToSchedule().computeIfAbsent(timeToSchedule, k -> new ArrayList<BPMNIntermediateEvent>());
                        bo.getBoundaryEventsToSchedule().get(timeToSchedule).add(event);
                        String message = "Schedule boundary timer event: " + displayName;
                        bo.getMessagesOfBoundaryEventsToSchedule().computeIfAbsent(timeToSchedule, k -> new ArrayList<String>());
                        bo.getMessagesOfBoundaryEventsToSchedule().get(timeToSchedule).add(message);
                    // timeUntilWhenTimerEventsAreCreated = timeToSchedule;
                    }
                    // TODO fix boundary
                    timeUntilWhenTimerEventsAreCreated = timeToSchedule;
                } else if (definitionAttributes.get("timeCycle") != null) {
                    // ISO 8601 repeating time interval:
                    String timeCycle = definitionAttributes.get("timeCycle");
                    // Rn/[ISO 8601 duration] where n
                    // (optional) for number of
                    // recurrences
                    // ["Rn"], "[ISO 8601 duration]"]
                    String[] recurrencesAndDuration = timeCycle.split("/");
                    String recurrencesString = recurrencesAndDuration[0];
                    String timeDurationString = recurrencesAndDuration[1];
                    Integer recurrencesMax = null;
                    if (recurrencesString.length() > 1) {
                        recurrencesMax = Integer.parseInt(recurrencesString.substring(1, recurrencesString.length()));
                        timerEventIsInterrupting = cancelActivities.get(nId);
                        if (timerEventIsInterrupting) {
                            recurrencesMax = 1;
                        }
                    }
                    Duration javaDuration = Duration.parse(timeDurationString);
                    double duration = javaDuration.get(ChronoUnit.SECONDS);
                    if (duration == 0 || recurrencesMax != null && recurrencesMax == 0) {
                        continue;
                    }
                    double timeToSchedule = beginTimeOfTask;
                    int actualNumberOfOccurrences = 0;
                    boolean recurrencesMaxExceeded = false;
                    while (timeToSchedule <= timeUntilWhenTimerEventsAreCreated) {
                        timeToSchedule += duration;
                        actualNumberOfOccurrences++;
                        if (recurrencesMax != null && actualNumberOfOccurrences > recurrencesMax) {
                            recurrencesMaxExceeded = true;
                            break;
                        }
                    }
                    if (recurrencesMaxExceeded) {
                        continue;
                    }
                    while (timeToSchedule <= endOfInterval) {
                        // add as many timer events for scheduling as possible (lots of them if timer event is
                        // non-interrupting,
                        // only one if it is interrupting
                        String displayName = processModel.getDisplayNames().get(nId);
                        if (displayName == null) {
                            displayName = processModel.getIdentifiers().get(nId);
                        }
                        String source = bo.getSource();
                        ProcessInstance processInstance = bo.getProcessInstance();
                        TimeInstant timeInstant = new TimeInstant(startOfInterval, TimeUnit.SECONDS);
                        BPMNIntermediateEvent event = new BPMNIntermediateEvent(model, source, timeInstant, desmojObjects, processInstance, nId);
                        bo.getBoundaryEventsToSchedule().computeIfAbsent(timeToSchedule, k -> new ArrayList<BPMNIntermediateEvent>());
                        bo.getBoundaryEventsToSchedule().get(timeToSchedule).add(event);
                        String message = "Schedule boundary timer event: " + displayName;
                        bo.getMessagesOfBoundaryEventsToSchedule().computeIfAbsent(timeToSchedule, k -> new ArrayList<String>());
                        bo.getMessagesOfBoundaryEventsToSchedule().get(timeToSchedule).add(message);
                        actualNumberOfOccurrences++;
                        if (recurrencesMax != null && actualNumberOfOccurrences == recurrencesMax) {
                            // recurrencesMaxExceeded = true;
                            break;
                        }
                        timeToSchedule += duration;
                    }
                    timeUntilWhenTimerEventsAreCreated = timeToSchedule;
                } else {
                    // TODO support timeDate attributes?
                    String identifier = processModel.getIdentifiers().get(nId);
                    DebugLogger.log("Timer event " + identifier + " has no timer definition, skip.");
                    continue;
                }
                bo.setTimeUntilWhenTimerEventsAreCreated(timeUntilWhenTimerEventsAreCreated);
            }
        }
    }
}
Also used : SimulationUtils(de.hpi.bpt.scylla.simulation.utils.SimulationUtils) Entity(desmoj.core.simulator.Entity) HashMap(java.util.HashMap) DiscreteDistEmpirical(desmoj.core.dist.DiscreteDistEmpirical) ArrayList(java.util.ArrayList) HashSet(java.util.HashSet) BPMNIntermediateEvent(de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent) EventType(de.hpi.bpt.scylla.model.process.node.EventType) Duration(java.time.Duration) Map(java.util.Map) DebugLogger(de.hpi.bpt.scylla.logger.DebugLogger) EventDefinitionType(de.hpi.bpt.scylla.model.process.node.EventDefinitionType) TimeSpan(desmoj.core.simulator.TimeSpan) ScyllaEvent(de.hpi.bpt.scylla.simulation.event.ScyllaEvent) ProcessModel(de.hpi.bpt.scylla.model.process.ProcessModel) TimeInstant(desmoj.core.simulator.TimeInstant) SimulationModel(de.hpi.bpt.scylla.simulation.SimulationModel) Iterator(java.util.Iterator) ProcessSimulationComponents(de.hpi.bpt.scylla.simulation.ProcessSimulationComponents) Set(java.util.Set) TimeUnit(java.util.concurrent.TimeUnit) List(java.util.List) ScyllaRuntimeException(de.hpi.bpt.scylla.exception.ScyllaRuntimeException) ChronoUnit(java.time.temporal.ChronoUnit) TreeMap(java.util.TreeMap) ProcessInstance(de.hpi.bpt.scylla.simulation.ProcessInstance) ProcessModel(de.hpi.bpt.scylla.model.process.ProcessModel) EventType(de.hpi.bpt.scylla.model.process.node.EventType) EventDefinitionType(de.hpi.bpt.scylla.model.process.node.EventDefinitionType) ArrayList(java.util.ArrayList) Duration(java.time.Duration) BPMNIntermediateEvent(de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent) ProcessSimulationComponents(de.hpi.bpt.scylla.simulation.ProcessSimulationComponents) ProcessInstance(de.hpi.bpt.scylla.simulation.ProcessInstance) HashMap(java.util.HashMap) Map(java.util.Map) TreeMap(java.util.TreeMap) TimeInstant(desmoj.core.simulator.TimeInstant)

Example 2 with BPMNIntermediateEvent

use of de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent in project scylla by bptlab.

the class BoundaryEventPluginUtils method createNonTimerBoundaryEvents.

private void createNonTimerBoundaryEvents(SimulationModel model, BoundaryObject bo, double startOfInterval, double endOfInterval) throws ScyllaRuntimeException {
    double timeUntilWhenNonTimerEventsAreCreated = bo.getTimeUntilWhenNonTimerEventsAreCreated();
    if (!bo.isGenerateMoreNonTimerBoundaryEvents() || timeUntilWhenNonTimerEventsAreCreated >= endOfInterval) {
        return;
    }
    ProcessSimulationComponents desmojObjects = bo.getDesmojObjects();
    ProcessModel processModel = desmojObjects.getProcessModel();
    Map<Integer, EventType> eventTypes = processModel.getEventTypes();
    Map<Integer, Boolean> cancelActivities = processModel.getCancelActivities();
    int nodeId = bo.getNodeId();
    while (timeUntilWhenNonTimerEventsAreCreated < endOfInterval) {
        // If the parent task has not already ended...
        // simulation configuration defines probability of firing boundary events
        Map<Integer, Object> branchingDistributions = desmojObjects.getExtensionDistributions().get(PLUGIN_NAME);
        @SuppressWarnings("unchecked") DiscreteDistEmpirical<Integer> distribution = (DiscreteDistEmpirical<Integer>) branchingDistributions.get(nodeId);
        if (distribution == null) {
            // There are no non-timer boundary events at this task...
            bo.setGenerateMoreNonTimerBoundaryEvents(false);
            return;
        }
        // decide on next node
        model.skipTraceNote();
        Integer nodeIdOfElementToSchedule = distribution.sample();
        // System.out.println("Choosed: "+processModel.getIdentifiers().get(nodeIdOfElementToSchedule)+" "+processModel.getIdentifiers().get(nodeId));
        if (nodeIdOfElementToSchedule == nodeId) {
            // No next boundary non-timer event, finish
            bo.setGenerateMoreNonTimerBoundaryEvents(false);
            return;
        } else {
            // There are boundary events
            EventType eventType = eventTypes.get(nodeIdOfElementToSchedule);
            if (eventType == EventType.BOUNDARY) {
                // Determine whether the boundary event to schedule is an interrupting one.
                boolean eventIsInterrupting = cancelActivities.get(nodeIdOfElementToSchedule);
                // Get time relative to the start of the task when this boundary event will trigger.
                double relativeTimeToTrigger = desmojObjects.getDistributionSample(nodeIdOfElementToSchedule);
                if (relativeTimeToTrigger == 0) {
                    // If this happens something is wrong anyways...
                    continue;
                }
                // Add the relative time of this boundary event, to determine when no more events are scheduled.
                TimeUnit unit = desmojObjects.getDistributionTimeUnit(nodeIdOfElementToSchedule);
                TimeSpan durationAsTimeSpan = new TimeSpan(relativeTimeToTrigger, unit);
                timeUntilWhenNonTimerEventsAreCreated += durationAsTimeSpan.getTimeAsDouble(TimeUnit.SECONDS);
                // Took this message sending part out. It was just to complicated for boundary events, fixed to their parent task.
                // Furthermore it is not needed anymore.
                /*String message = null;
                    boolean showInTrace = model.traceIsOn();
                    Map<EventDefinitionType, Map<String, String>> definitions = processModel.getEventDefinitions().get(nodeIdOfElementToSchedule);

                    String displayName = processModel.getDisplayNames().get(nodeIdOfElementToSchedule);

                    if (displayName == null) {
                        displayName = processModel.getIdentifiers().get(nodeIdOfElementToSchedule);
                    }
                    for (EventDefinitionType definition : definitions.keySet()) {
                        if (definition == EventDefinitionType.MESSAGE) {
                            message = "Schedule boundary message event: " + displayName;
                        }
                        else if (definition == EventDefinitionType.CONDITIONAL) {
                            message = "Schedule boundary conditional event: " + displayName;
                        }
                        else if (definition == EventDefinitionType.SIGNAL) {
                            message = "Schedule boundary signal event: " + displayName;
                        }
                        else if (definition == EventDefinitionType.ESCALATION) {
                            message = "Schedule boundary escalation event: " + displayName;
                        }
                        else {
                            if (eventIsInterrupting) {
                                if (definition == EventDefinitionType.ERROR) {
                                    message = "Schedule boundary error event: " + displayName;
                                }
                                else if (definition == EventDefinitionType.COMPENSATION) {
                                    message = "Schedule boundary compensation event: " + displayName;
                                }
                                else if (definition == EventDefinitionType.CANCEL) {
                                    message = "Schedule boundary cancel event: " + displayName;
                                }
                            }
                            else {
                                SimulationUtils.sendElementNotSupportedTraceNote(model, processModel, displayName,
                                        nodeIdOfElementToSchedule);
                                SimulationUtils.abort(model, processInstance, nodeId, showInTrace);
                                String identifier = processModel.getIdentifiers().get(nodeIdOfElementToSchedule);
                                throw new ScyllaRuntimeException("BPMNEvent " + identifier + " not supported.");
                            }
                        }*

                        bo.getMessagesOfBoundaryEventsToSchedule().computeIfAbsent(timeUntilWhenNonTimerEventsAreCreated,
                                k -> new ArrayList<String>());
                        bo.getMessagesOfBoundaryEventsToSchedule().get(timeUntilWhenNonTimerEventsAreCreated)
                                .add(message);
                    }
                    */
                String source = bo.getSource();
                ProcessInstance processInstance = bo.getProcessInstance();
                TimeInstant timeInstant = new TimeInstant(startOfInterval, TimeUnit.SECONDS);
                // And create the event with the time it should trigger.
                BPMNIntermediateEvent event = new BPMNIntermediateEvent(model, source, timeInstant, desmojObjects, processInstance, nodeIdOfElementToSchedule);
                bo.getBoundaryEventsToSchedule().computeIfAbsent(timeUntilWhenNonTimerEventsAreCreated, k -> new ArrayList<BPMNIntermediateEvent>());
                bo.getBoundaryEventsToSchedule().get(timeUntilWhenNonTimerEventsAreCreated).add(event);
                if (eventIsInterrupting) {
                    // If the element is interrupting, finish and clean up
                    // boundaryObjects.values().remove(bo);
                    bo.setGenerateMoreNonTimerBoundaryEvents(false);
                    break;
                }
            }
        }
    }
    bo.setTimeUntilWhenNonTimerEventsAreCreated(timeUntilWhenNonTimerEventsAreCreated);
}
Also used : ProcessModel(de.hpi.bpt.scylla.model.process.ProcessModel) DiscreteDistEmpirical(desmoj.core.dist.DiscreteDistEmpirical) EventType(de.hpi.bpt.scylla.model.process.node.EventType) BPMNIntermediateEvent(de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent) TimeSpan(desmoj.core.simulator.TimeSpan) ProcessSimulationComponents(de.hpi.bpt.scylla.simulation.ProcessSimulationComponents) TimeUnit(java.util.concurrent.TimeUnit) ProcessInstance(de.hpi.bpt.scylla.simulation.ProcessInstance) TimeInstant(desmoj.core.simulator.TimeInstant)

Example 3 with BPMNIntermediateEvent

use of de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent in project scylla by bptlab.

the class SimulationUtils method createEventsForNextNode.

/**
 * Gets type of next node and prepare respective event.
 *
 * @param model
 *            the simulation model
 * @param processModel
 *            the process model
 * @param processInstanceId
 *            the identifier of the process instance
 * @param nextNodeId
 *            the identifier of the next node
 * @return the DesmoJ representing the next node plus DesmoJ events from plug-ins
 * @throws ScyllaRuntimeException
 * @throws NodeNotFoundException
 * @throws ScyllaValidationException
 */
public static List<ScyllaEvent> createEventsForNextNode(ScyllaEvent currentEvent, ProcessSimulationComponents desmojObjects, ProcessInstance processInstance, int nextNodeId) throws ScyllaRuntimeException, NodeNotFoundException, ScyllaValidationException {
    SimulationModel model = (SimulationModel) processInstance.getModel();
    TimeInstant currentSimulationTime = model.presentTime();
    ProcessModel processModel = processInstance.getProcessModel();
    String source = currentEvent.getSource();
    List<ScyllaEvent> events = new ArrayList<ScyllaEvent>();
    if (processModel.getTasks().containsKey(nextNodeId) || processModel.getSubProcesses().containsKey(nextNodeId)) {
        // TaskType tType = processModel.getTasks().get(nextNodeId);
        ScyllaEvent event = new TaskEnableEvent(model, source, currentSimulationTime, desmojObjects, processInstance, nextNodeId);
        events.add(event);
    } else if (processModel.getGateways().containsKey(nextNodeId)) {
        GatewayType gType = processModel.getGateways().get(nextNodeId);
        Set<Integer> idsOfNodesBeforeGateway = processModel.getIdsOfPreviousNodes(nextNodeId);
        if (gType == GatewayType.PARALLEL && idsOfNodesBeforeGateway.size() > 1) {
            Map<Integer, Set<Integer>> referenceToEventsOnHold = processInstance.getNodesAndTriggers();
            if (!referenceToEventsOnHold.containsKey(nextNodeId)) {
                referenceToEventsOnHold.put(nextNodeId, new HashSet<Integer>());
            }
            Set<Integer> nodesTriggeredFrom = referenceToEventsOnHold.get(nextNodeId);
            int currentNodeId = currentEvent.getNodeId();
            nodesTriggeredFrom.add(currentNodeId);
            if (idsOfNodesBeforeGateway.equals(nodesTriggeredFrom)) {
                ScyllaEvent event = new GatewayEvent(model, source, currentSimulationTime, desmojObjects, processInstance, nextNodeId);
                events.add(event);
                // clear list of fired incoming flows
                referenceToEventsOnHold.remove(nextNodeId);
            }
        } else {
            ScyllaEvent event = new GatewayEvent(model, source, currentSimulationTime, desmojObjects, processInstance, nextNodeId);
            events.add(event);
        }
    } else if (processModel.getEventTypes().containsKey(nextNodeId)) {
        EventType eType = processModel.getEventTypes().get(nextNodeId);
        if (eType == EventType.START) {
            throw new ScyllaRuntimeException("Start event " + nextNodeId + " must be at the beginning of the process.");
        } else if (eType == EventType.END) {
            ScyllaEvent event = new BPMNEndEvent(model, source, currentSimulationTime, desmojObjects, processInstance, nextNodeId);
            events.add(event);
        } else {
            ScyllaEvent event = new BPMNIntermediateEvent(model, source, currentSimulationTime, desmojObjects, processInstance, nextNodeId);
            events.add(event);
        }
    } else {
        throw new ScyllaRuntimeException("Next node " + nextNodeId + " not found or not supported.");
    }
    List<ScyllaEvent> eventsFromPlugins = EventCreationPluggable.runPlugins(currentEvent, desmojObjects, processInstance, nextNodeId);
    events.addAll(eventsFromPlugins);
    return events;
}
Also used : ScyllaRuntimeException(de.hpi.bpt.scylla.exception.ScyllaRuntimeException) ProcessModel(de.hpi.bpt.scylla.model.process.ProcessModel) Set(java.util.Set) HashSet(java.util.HashSet) TaskEnableEvent(de.hpi.bpt.scylla.simulation.event.TaskEnableEvent) EventType(de.hpi.bpt.scylla.model.process.node.EventType) ArrayList(java.util.ArrayList) GatewayType(de.hpi.bpt.scylla.model.process.node.GatewayType) BPMNIntermediateEvent(de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent) ScyllaEvent(de.hpi.bpt.scylla.simulation.event.ScyllaEvent) GatewayEvent(de.hpi.bpt.scylla.simulation.event.GatewayEvent) BPMNEndEvent(de.hpi.bpt.scylla.simulation.event.BPMNEndEvent) Map(java.util.Map) SimulationModel(de.hpi.bpt.scylla.simulation.SimulationModel) TimeInstant(desmoj.core.simulator.TimeInstant) HashSet(java.util.HashSet)

Example 4 with BPMNIntermediateEvent

use of de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent in project scylla by bptlab.

the class BoundaryEventPluginUtils method scheduleBoundaryEvents.

private void scheduleBoundaryEvents(SimulationModel model, double startOfInterval, double endOfInterval) {
    Set<String> boundaryObjectsToRemove = new HashSet<>();
    for (String taskEnableEventName : boundaryObjects.keySet()) {
        // boolean isInterruptingEvent = false;
        BoundaryObject bo = boundaryObjects.get(taskEnableEventName);
        TreeMap<Double, List<BPMNIntermediateEvent>> boundaryEventsToSchedule = bo.getBoundaryEventsToSchedule();
        Iterator<Double> iterator = boundaryEventsToSchedule.keySet().iterator();
        Set<Double> elementsToRemove = new HashSet<>();
        ProcessInstance processInstance = bo.getProcessInstance();
        while (iterator.hasNext()) {
            Double timeToSchedule = iterator.next();
            if (timeToSchedule > endOfInterval) {
                // We will not have prepared events for scheduling which are beyond endOfInterval.
                break;
            }
            List<BPMNIntermediateEvent> events = boundaryEventsToSchedule.get(timeToSchedule);
            // Now take all events and schedule them.
            for (BPMNIntermediateEvent event : events) {
                double durationRelativeToEventStart = timeToSchedule - startOfInterval;
                if (durationRelativeToEventStart < 0)
                    continue;
                TimeUnit unit = TimeUnit.SECONDS;
                TimeSpan timeSpan = new TimeSpan(durationRelativeToEventStart, unit);
                // Schedule the event.
                try {
                    SimulationUtils.scheduleEvent(event, timeSpan);
                } catch (ScyllaRuntimeException exception) {
                    exception.printStackTrace();
                }
            /*ProcessModel processModel = processInstance.getProcessModel();
                    int nodeId = event.getNodeId();
                    boolean cancelActivity = processModel.getCancelActivities().get(nodeId);
                    if (cancelActivity) {
                        isInterruptingEvent = true;
                    }*/
            }
            // TreeMap<Double, List<String>> messagesOfBoundaryEventsToSchedule = bo.getMessagesOfBoundaryEventsToSchedule();
            // Took this out, see rest in createNonTimerBoundaryEvents.
            /*List<String> messages = messagesOfBoundaryEventsToSchedule.get(timeToSchedule);
                for (String message : messages) {
                    model.sendTraceNote(message);
                }*/
            // clean up
            elementsToRemove.add(timeToSchedule);
        // Not needed anymore, alreday done in creation.
        /*if (isInterruptingEvent) {
                    boundaryObjectsToRemove.add(taskEnableEventName);
                    // if (bo.getSource().equals(desmojEvent.getSource())) {
                    // normalBehavior = false;
                    // }
                    // processInstance.cancel();
                    break;
                }*/
        }
        for (Double timeToSchedule : elementsToRemove) {
            boundaryEventsToSchedule.remove(timeToSchedule);
            // messagesOfBoundaryEventsToSchedule.remove(timeToSchedule);
            if (boundaryEventsToSchedule.isEmpty()) {
                boundaryObjectsToRemove.add(taskEnableEventName);
            }
        }
    }
    // Delete all boudnaryObjects, which are compeltetly scheduled.
    for (String taskEnableEventName : boundaryObjectsToRemove) {
        boundaryObjects.remove(taskEnableEventName);
    }
}
Also used : ScyllaRuntimeException(de.hpi.bpt.scylla.exception.ScyllaRuntimeException) BPMNIntermediateEvent(de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent) TimeSpan(desmoj.core.simulator.TimeSpan) TimeUnit(java.util.concurrent.TimeUnit) ArrayList(java.util.ArrayList) List(java.util.List) ProcessInstance(de.hpi.bpt.scylla.simulation.ProcessInstance) HashSet(java.util.HashSet)

Aggregations

BPMNIntermediateEvent (de.hpi.bpt.scylla.simulation.event.BPMNIntermediateEvent)4 ScyllaRuntimeException (de.hpi.bpt.scylla.exception.ScyllaRuntimeException)3 ProcessModel (de.hpi.bpt.scylla.model.process.ProcessModel)3 EventType (de.hpi.bpt.scylla.model.process.node.EventType)3 ProcessInstance (de.hpi.bpt.scylla.simulation.ProcessInstance)3 TimeInstant (desmoj.core.simulator.TimeInstant)3 TimeSpan (desmoj.core.simulator.TimeSpan)3 ArrayList (java.util.ArrayList)3 HashSet (java.util.HashSet)3 TimeUnit (java.util.concurrent.TimeUnit)3 ProcessSimulationComponents (de.hpi.bpt.scylla.simulation.ProcessSimulationComponents)2 SimulationModel (de.hpi.bpt.scylla.simulation.SimulationModel)2 ScyllaEvent (de.hpi.bpt.scylla.simulation.event.ScyllaEvent)2 DiscreteDistEmpirical (desmoj.core.dist.DiscreteDistEmpirical)2 List (java.util.List)2 Map (java.util.Map)2 Set (java.util.Set)2 DebugLogger (de.hpi.bpt.scylla.logger.DebugLogger)1 EventDefinitionType (de.hpi.bpt.scylla.model.process.node.EventDefinitionType)1 GatewayType (de.hpi.bpt.scylla.model.process.node.GatewayType)1