Examples with ProcessNodeTransitionType de.hpi.bpt.scylla.logger.ProcessNodeTransitionType used on opensource projects

Example 1 with ProcessNodeTransitionType

use of de.hpi.bpt.scylla.logger.ProcessNodeTransitionType in project scylla by bptlab.

the class TaskBeginEvent method addToLog.

@Override
protected void addToLog(ProcessInstance processInstance) {
    long timestamp = Math.round(getModel().presentTime().getTimeRounded(DateTimeUtils.getReferenceTimeUnit()));
    String taskName = displayName;
    Set<String> resources = new HashSet<String>();
    Set<ResourceObject> resourceObjects = processInstance.getAssignedResources().get(source).getResourceObjects();
    for (ResourceObject res : resourceObjects) {
        String resourceName = res.getResourceType() + "_" + res.getId();
        resources.add(resourceName);
    }
    ProcessNodeTransitionType transition = ProcessNodeTransitionType.BEGIN;
    SimulationModel model = (SimulationModel) getModel();
    ProcessModel processModel = processInstance.getProcessModel();
    String processScopeNodeId = SimulationUtils.getProcessScopeNodeId(processModel, nodeId);
    ProcessNodeInfo info = new ProcessNodeInfo(nodeId, processScopeNodeId, source, timestamp, taskName, resources, transition);
    model.addNodeInfo(processModel, processInstance, info);
}

Example 2 with ProcessNodeTransitionType

use of de.hpi.bpt.scylla.logger.ProcessNodeTransitionType in project scylla by bptlab.

the class XESLogger method writeToLog.

public void writeToLog(SimulationModel model, String outputPathWithoutExtension) throws IOException {
    Map<String, ProcessSimulationComponents> desmojObjectsMap = model.getDesmojObjectsMap();
    for (String processId : desmojObjectsMap.keySet()) {
        String fileNameWithoutExtension = model.getDesmojObjectsMap().get(processId).getCommonProcessElements().getBpmnFileNameWithoutExtension();
        ZonedDateTime baseDateTime = model.getStartDateTime();
        Map<Integer, List<ProcessNodeInfo>> nodeInfos = model.getProcessNodeInfos().get(processId);
        XFactory factory = XFactoryRegistry.instance().currentDefault();
        XLog log = factory.createLog();
        List<XExtension> extensions = new ArrayList<XExtension>();
        XLifecycleExtension lifecycleExt = XLifecycleExtension.instance();
        extensions.add(lifecycleExt);
        XOrganizationalExtension organizationalExt = XOrganizationalExtension.instance();
        extensions.add(organizationalExt);
        XTimeExtension timeExt = XTimeExtension.instance();
        extensions.add(timeExt);
        XConceptExtension conceptExt = XConceptExtension.instance();
        extensions.add(conceptExt);
        log.getExtensions().addAll(extensions);
        List<XAttribute> globalTraceAttributes = new ArrayList<XAttribute>();
        globalTraceAttributes.add(XConceptExtension.ATTR_NAME);
        log.getGlobalTraceAttributes().addAll(globalTraceAttributes);
        List<XAttribute> globalEventAttributes = new ArrayList<XAttribute>();
        globalEventAttributes.add(XConceptExtension.ATTR_NAME);
        globalEventAttributes.add(XLifecycleExtension.ATTR_TRANSITION);
        log.getGlobalEventAttributes().addAll(globalEventAttributes);
        List<XEventClassifier> classifiers = new ArrayList<XEventClassifier>();
        classifiers.add(new XEventAttributeClassifier("MXML Legacy Classifier", XConceptExtension.KEY_NAME, XLifecycleExtension.KEY_TRANSITION));
        classifiers.add(new XEventAttributeClassifier("Event Name", XConceptExtension.KEY_NAME));
        classifiers.add(new XEventAttributeClassifier("Resource", XOrganizationalExtension.KEY_RESOURCE));
        classifiers.add(new XEventAttributeClassifier("Event Name AND Resource", XConceptExtension.KEY_NAME, XOrganizationalExtension.KEY_RESOURCE));
        log.getClassifiers().addAll(classifiers);
        log.getAttributes().put("source", factory.createAttributeLiteral("source", "Scylla", null));
        log.getAttributes().put(XConceptExtension.KEY_NAME, factory.createAttributeLiteral(XConceptExtension.KEY_NAME, processId, conceptExt));
        log.getAttributes().put("description", factory.createAttributeLiteral("description", "Log file created in Scylla", null));
        log.getAttributes().put(XLifecycleExtension.KEY_MODEL, XLifecycleExtension.ATTR_MODEL);
        for (Integer processInstanceId : nodeInfos.keySet()) {
            XTrace trace = factory.createTrace();
            trace.getAttributes().put(XConceptExtension.KEY_NAME, factory.createAttributeLiteral(XConceptExtension.KEY_NAME, processInstanceId.toString(), conceptExt));
            List<ProcessNodeInfo> nodeInfoList = nodeInfos.get(processInstanceId);
            for (ProcessNodeInfo info : nodeInfoList) {
                XAttributeMap attributeMap = factory.createAttributeMap();
                Set<String> resources = info.getResources();
                for (String res : resources) {
                    attributeMap.put(res, factory.createAttributeLiteral(XOrganizationalExtension.KEY_RESOURCE, res, organizationalExt));
                }
                /* Set<String> dataObjects = info.getDataObejcts();
                    for (String dO : dataObjects) {
                        attributeMap.put(dO, factory.createAttributeLiteral(XOrganizationalExtension.KEY_RESOURCE, dO,
                                organizationalExt));
                    }*/
                ZonedDateTime zonedDateTime = baseDateTime.plus(info.getTimestamp(), DateTimeUtils.getReferenceChronoUnit());
                Date timestamp = new Date(zonedDateTime.toInstant().toEpochMilli());
                attributeMap.put(XTimeExtension.KEY_TIMESTAMP, factory.createAttributeTimestamp(XTimeExtension.KEY_TIMESTAMP, timestamp, timeExt));
                String taskName = info.getTaskName();
                attributeMap.put(XConceptExtension.KEY_NAME, factory.createAttributeLiteral(XConceptExtension.KEY_NAME, taskName, conceptExt));
                ProcessNodeTransitionType transition = info.getTransition();
                if (transition == ProcessNodeTransitionType.BEGIN || transition == ProcessNodeTransitionType.EVENT_BEGIN) {
                    attributeMap.put(XLifecycleExtension.KEY_TRANSITION, factory.createAttributeLiteral(XLifecycleExtension.KEY_TRANSITION, "start", lifecycleExt));
                } else if (transition == ProcessNodeTransitionType.TERMINATE || transition == ProcessNodeTransitionType.EVENT_TERMINATE) {
                    attributeMap.put(XLifecycleExtension.KEY_TRANSITION, factory.createAttributeLiteral(XLifecycleExtension.KEY_TRANSITION, "complete", lifecycleExt));
                    if (!info.getDataObjectField().isEmpty()) {
                        Integer size = info.getDataObjectField().size();
                        Object[] test = info.getDataObjectField().keySet().toArray();
                        Object[] test2 = info.getDataObjectField().values().toArray();
                        for (int i = 0; i < size; i++) {
                            attributeMap.put(Integer.toString(i), factory.createAttributeLiteral(Objects.toString(test[i]), Objects.toString(test2[i], null), lifecycleExt));
                        }
                    }
                } else if (transition == ProcessNodeTransitionType.CANCEL) {
                    attributeMap.put(XLifecycleExtension.KEY_TRANSITION, factory.createAttributeLiteral(XLifecycleExtension.KEY_TRANSITION, "ate_abort", lifecycleExt));
                } else if (transition == ProcessNodeTransitionType.ENABLE || transition == ProcessNodeTransitionType.PAUSE || transition == ProcessNodeTransitionType.RESUME) {
                    continue;
                } else {
                    System.out.println("Transition type " + transition + " not supported in XESLogger.");
                }
                XEvent event = factory.createEvent(attributeMap);
                trace.add(event);
            }
            log.add(trace);
        }
        XesXmlSerializer serializer;
        FileOutputStream fos;
        if (gzipOn) {
            serializer = new XesXmlGZIPSerializer();
            fos = new FileOutputStream(outputPathWithoutExtension + fileNameWithoutExtension + ".tar");
        } else {
            serializer = new XesXmlSerializer();
            fos = new FileOutputStream(outputPathWithoutExtension + fileNameWithoutExtension + ".xes");
        }
        ;
        serializer.serialize(log, fos);
        fos.close();
    }
}

Example 3 with ProcessNodeTransitionType

use of de.hpi.bpt.scylla.logger.ProcessNodeTransitionType in project scylla by bptlab.

the class ParallelBatchCluster method logTaskEventForNonResponsiblePI.

private void logTaskEventForNonResponsiblePI(TaskEvent event) throws ScyllaRuntimeException {
    ProcessInstance processInstance = event.getProcessInstance();
    ProcessModel processModel = processInstance.getProcessModel();
    SimulationModel model = (SimulationModel) event.getModel();
    long timestamp = Math.round(model.presentTime().getTimeRounded(DateTimeUtils.getReferenceTimeUnit()));
    String taskName = event.getDisplayName();
    int nodeId = event.getNodeId();
    String processScopeNodeId = SimulationUtils.getProcessScopeNodeId(processModel, nodeId);
    String source = event.getSource();
    ProcessNodeTransitionType transition;
    if (event instanceof TaskEnableEvent) {
        transition = ProcessNodeTransitionType.ENABLE;
    } else if (event instanceof TaskBeginEvent) {
        transition = ProcessNodeTransitionType.BEGIN;
        ResourceObjectTuple commonResources = event.getProcessInstance().getAssignedResources().get(source);
        getParentalStartEvents().stream().forEach(each -> each.getProcessInstance().getAssignedResources().put(each.getSource(), commonResources));
    } else if (event instanceof TaskCancelEvent) {
        transition = ProcessNodeTransitionType.CANCEL;
    } else if (event instanceof TaskTerminateEvent) {
        transition = ProcessNodeTransitionType.TERMINATE;
    } else {
        throw new ScyllaRuntimeException("Task event type not supported.");
    }
    for (TaskBeginEvent beginEvent : getParentalStartEvents()) {
        if (!getResponsibleProcessInstance().equals(beginEvent.getProcessInstance())) {
            ResourceObjectTuple commonResources = beginEvent.getProcessInstance().getAssignedResources().get(beginEvent.getSource());
            Set<String> resourceStrings = commonResources.getResourceObjects().stream().map(res -> res.getResourceType() + "_" + res.getId()).collect(Collectors.toSet());
            ProcessNodeInfo info;
            info = new ProcessNodeInfo(nodeId, processScopeNodeId, beginEvent.getSource(), timestamp, taskName, resourceStrings, transition);
            model.addNodeInfo(processModel, beginEvent.getProcessInstance(), info);
        }
    }
}

Example 4 with ProcessNodeTransitionType

use of de.hpi.bpt.scylla.logger.ProcessNodeTransitionType in project scylla by bptlab.

the class StatisticsLogger method writeToLog.

public void writeToLog(SimulationModel model, String outputPathWithoutExtension) throws IOException {
    TimeUnit timeUnit = DateTimeUtils.getReferenceTimeUnit();
    double totalEndTime = model.presentTime().getTimeAsDouble(timeUnit);
    Map<String, Map<Integer, List<ProcessNodeInfo>>> processNodeInfos = model.getProcessNodeInfos();
    Map<String, Map<String, List<ResourceInfo>>> resourceInfos = model.getResourceInfos();
    Set<ResourceObject> resourceObjectsSet = QueueManager.getAllResourceObjects(model);
    Map<String, Double> costPerResourceInstance = new HashMap<String, Double>();
    Map<String, Map<String, ResourceObject>> resourceObjects = new HashMap<String, Map<String, ResourceObject>>();
    for (ResourceObject res : resourceObjectsSet) {
        String resourceName = res.getResourceType() + "_" + res.getId();
        TimeUnit timeUnitOfResource = res.getTimeUnit();
        TimeUnit referenceUnit = DateTimeUtils.getReferenceTimeUnit();
        double cost = res.getCost();
        double costInReferenceUnit = DateTimeUtils.convertCost(timeUnitOfResource, referenceUnit, cost);
        costPerResourceInstance.put(resourceName, costInReferenceUnit);
        String resourceType = res.getResourceType();
        if (!resourceObjects.containsKey(resourceType)) {
            resourceObjects.put(resourceType, new HashMap<String, ResourceObject>());
        }
        String resourceId = res.getId();
        resourceObjects.get(resourceType).put(resourceId, res);
    }
    // resource utilization
    Map<String, Map<String, StatisticsResourceObject>> statsPerResource = new HashMap<String, Map<String, StatisticsResourceObject>>();
    // double totalEndTime = 0;
    for (String resourceType : resourceInfos.keySet()) {
        Map<String, StatisticsResourceObject> statsPerResourceInstance = new HashMap<String, StatisticsResourceObject>();
        Map<String, List<ResourceInfo>> resourceInfosOfType = resourceInfos.get(resourceType);
        for (String resourceId : resourceInfosOfType.keySet()) {
            long durationInUse = 0;
            long durationInUseIdle = 0;
            long currentTime = 0;
            List<ResourceInfo> infosOfResource = resourceInfosOfType.get(resourceId);
            ResourceStatus previousStatus = null;
            for (ResourceInfo info : infosOfResource) {
                ResourceStatus status = info.getTransition();
                long timestamp = info.getTimestamp();
                // FREE <-> IN_USE <-> IN_USE_IDLE
                if (status == ResourceStatus.IN_USE) {
                    if (previousStatus == ResourceStatus.IN_USE_IDLE) {
                        durationInUseIdle += timestamp - currentTime;
                    }
                } else if (status == ResourceStatus.FREE || status == ResourceStatus.IN_USE_IDLE) {
                    durationInUse += timestamp - currentTime;
                } else {
                    DebugLogger.log("Resource transition type not supported: " + status);
                }
                currentTime = timestamp;
            // if (currentTime > totalEndTime) {
            // totalEndTime = currentTime;
            // }
            }
            long durationAvailable = DateTimeUtils.getAvailabilityTime(resourceObjects.get(resourceType).get(resourceId).getTimetable(), new TimeInstant(totalEndTime));
            String resourceName = resourceType + "_" + resourceId;
            Double costPerUnit = costPerResourceInstance.get(resourceName);
            double costs = durationAvailable * costPerUnit;
            StatisticsResourceObject sro = new StatisticsResourceObject();
            sro.setDurationAvailable(durationAvailable);
            sro.setDurationInUse(durationInUse);
            // for total available time
            sro.setCosts(costs);
            sro.setDurationInUseIdle(durationInUseIdle);
            statsPerResourceInstance.put(resourceId, sro);
        }
        statsPerResource.put(resourceType, statsPerResourceInstance);
    }
    // process time with and without off-timetable hours (= idle time)
    // process waiting time
    // process costs
    // task duration
    // task waiting time
    Map<String, Map<Integer, StatisticsProcessInstanceObject>> statsPerProcess = new HashMap<String, Map<Integer, StatisticsProcessInstanceObject>>();
    Map<String, Map<String, Map<String, StatisticsTaskInstanceObject>>> statsPerTask = new HashMap<String, Map<String, Map<String, StatisticsTaskInstanceObject>>>();
    for (String processId : processNodeInfos.keySet()) {
        Map<Integer, StatisticsProcessInstanceObject> statsPerProcessInstance = new HashMap<Integer, StatisticsProcessInstanceObject>();
        Map<String, Map<String, StatisticsTaskInstanceObject>> statsPerTaskOfProcess = new HashMap<String, Map<String, StatisticsTaskInstanceObject>>();
        Map<Integer, List<ProcessNodeInfo>> nodeInfoOfProcessInstances = processNodeInfos.get(processId);
        for (int processInstanceId : nodeInfoOfProcessInstances.keySet()) {
            List<ProcessNodeInfo> nodeInfoList = nodeInfoOfProcessInstances.get(processInstanceId);
            long durationTotal = 0;
            long durationInactive = 0;
            long durationResourcesIdle = 0;
            long durationWaiting = 0;
            double costs = 0;
            Long previousTimestamp = null;
            long timeProcessStart = 0;
            Map<TaskInstanceIdentifier, Long> taskDurations = new HashMap<TaskInstanceIdentifier, Long>();
            Map<TaskInstanceIdentifier, Long> begunOrResumedTasks = new HashMap<TaskInstanceIdentifier, Long>();
            Map<TaskInstanceIdentifier, Long> enabledTasks = new HashMap<TaskInstanceIdentifier, Long>();
            Map<TaskInstanceIdentifier, Long> pausedTasks = new HashMap<TaskInstanceIdentifier, Long>();
            for (int i = 0; i < nodeInfoList.size(); i++) {
                String taskInstanceId = String.valueOf(i);
                long taskDurationEffective = 0;
                long taskDurationResourcesIdle = 0;
                long taskDurationWaiting = 0;
                double taskCosts = 0;
                ProcessNodeInfo ni = nodeInfoList.get(i);
                long timestamp = ni.getTimestamp();
                String processScopeNodeId = ni.getProcessScopeNodeId();
                String source = ni.getSource();
                TaskInstanceIdentifier taskInstanceIdentifier = new TaskInstanceIdentifier(processScopeNodeId, source);
                Set<String> resources = ni.getResources();
                String taskName = ni.getTaskName();
                StatisticsTaskInstanceObject stio = new StatisticsTaskInstanceObject(taskName);
                if (i == 0) {
                    previousTimestamp = timestamp;
                    timeProcessStart = timestamp;
                } else if (i == nodeInfoList.size() - 1) {
                    durationTotal = timestamp - timeProcessStart;
                }
                ProcessNodeTransitionType transition = ni.getTransition();
                if (begunOrResumedTasks.isEmpty()) {
                    durationInactive += timestamp - previousTimestamp;
                }
                if (transition == ProcessNodeTransitionType.ENABLE) {
                    enabledTasks.put(taskInstanceIdentifier, timestamp);
                } else if (transition == ProcessNodeTransitionType.BEGIN) {
                    Long enableTimestamp = enabledTasks.get(taskInstanceIdentifier);
                    if (enableTimestamp != null) {
                        long duration = timestamp - enableTimestamp;
                        durationWaiting += duration;
                        taskDurationWaiting += duration;
                        enabledTasks.remove(taskInstanceIdentifier);
                    }
                    taskDurations.put(taskInstanceIdentifier, 0L);
                    begunOrResumedTasks.put(taskInstanceIdentifier, timestamp);
                } else if (transition == ProcessNodeTransitionType.PAUSE) {
                    pausedTasks.put(taskInstanceIdentifier, timestamp);
                    Long beginOrResumeTimestamp = begunOrResumedTasks.get(taskInstanceIdentifier);
                    long duration = timestamp - beginOrResumeTimestamp;
                    for (String resourceName : resources) {
                        Double costPerUnit = costPerResourceInstance.get(resourceName);
                        costs += duration * costPerUnit;
                        taskCosts += duration * costPerUnit;
                    }
                    taskDurations.put(taskInstanceIdentifier, taskDurations.get(taskInstanceIdentifier) + duration);
                    begunOrResumedTasks.remove(taskInstanceIdentifier);
                } else if (transition == ProcessNodeTransitionType.RESUME) {
                    Long pauseTimestamp = pausedTasks.get(taskInstanceIdentifier);
                    long duration = timestamp - pauseTimestamp;
                    durationResourcesIdle += duration;
                    taskDurationResourcesIdle += duration;
                    pausedTasks.remove(taskInstanceIdentifier);
                    begunOrResumedTasks.put(taskInstanceIdentifier, timestamp);
                } else if (transition == ProcessNodeTransitionType.TERMINATE || transition == ProcessNodeTransitionType.CANCEL) {
                    Long beginOrResumeTimestamp = begunOrResumedTasks.get(taskInstanceIdentifier);
                    long duration = timestamp - beginOrResumeTimestamp;
                    for (String resourceName : resources) {
                        Double costPerUnit = costPerResourceInstance.get(resourceName);
                        costs += duration * costPerUnit;
                        taskCosts += duration * costPerUnit;
                    }
                    taskDurationEffective = taskDurations.get(taskInstanceIdentifier) + duration;
                    taskDurations.remove(taskInstanceIdentifier);
                    begunOrResumedTasks.remove(taskInstanceIdentifier);
                } else if (transition == ProcessNodeTransitionType.EVENT_BEGIN || transition == ProcessNodeTransitionType.EVENT_TERMINATE) {
                // not supported
                }
                stio.setDurationEffective(taskDurationEffective);
                stio.setDurationResourcesIdle(taskDurationResourcesIdle);
                stio.setDurationWaiting(taskDurationWaiting);
                stio.setCost(taskCosts);
                if (!statsPerTaskOfProcess.containsKey(processScopeNodeId)) {
                    statsPerTaskOfProcess.put(processScopeNodeId, new HashMap<String, StatisticsTaskInstanceObject>());
                }
                statsPerTaskOfProcess.get(processScopeNodeId).put(taskInstanceId, stio);
                previousTimestamp = ni.getTimestamp();
            }
            StatisticsProcessInstanceObject spio = new StatisticsProcessInstanceObject();
            spio.setDurationTotal(durationTotal);
            spio.setDurationInactive(durationInactive);
            spio.setDurationResourcesIdle(durationResourcesIdle);
            spio.setDurationWaiting(durationWaiting);
            spio.setCosts(costs);
            statsPerProcessInstance.put(processInstanceId, spio);
        }
        statsPerProcess.put(processId, statsPerProcessInstance);
        statsPerTask.put(processId, statsPerTaskOfProcess);
    }
    // build xml document
    Element resourceUtilization = new Element("resourceUtilization");
    Document doc = new Document(resourceUtilization);
    Element configuration = new Element("configuration");
    Element processes = new Element("processes");
    Element resources = new Element("resources");
    doc.getRootElement().addContent(configuration);
    doc.getRootElement().addContent(processes);
    doc.getRootElement().addContent(resources);
    configuration.addContent(new Element("time_unit").setText(String.valueOf(DateTimeUtils.getReferenceTimeUnit())));
    // add processes
    for (String processId : statsPerProcess.keySet()) {
        Map<Integer, StatisticsProcessInstanceObject> statsPerProcessInstance = statsPerProcess.get(processId);
        Element process = new Element("process");
        processes.addContent(process);
        process.addContent(new Element("id").setText(processId));
        Element processCost = new Element("cost");
        Element processTime = new Element("time");
        Element processInstances = new Element("instances");
        Element processActivities = new Element("activities");
        process.addContent(processCost);
        process.addContent(processTime);
        process.addContent(processInstances);
        process.addContent(processActivities);
        Element processFlowTime = new Element("flow_time");
        Element processEffectiveTime = new Element("effective");
        Element processWaitingTime = new Element("waiting");
        Element processOffTime = new Element("off_timetable");
        processTime.addContent(processFlowTime);
        processTime.addContent(processEffectiveTime);
        processTime.addContent(processWaitingTime);
        processTime.addContent(processOffTime);
        StatisticsCalculationObject costStats = new StatisticsCalculationObject();
        StatisticsCalculationObject flowTimeStats = new StatisticsCalculationObject();
        StatisticsCalculationObject effectiveStats = new StatisticsCalculationObject();
        StatisticsCalculationObject offTimeStats = new StatisticsCalculationObject();
        StatisticsCalculationObject waitingStats = new StatisticsCalculationObject();
        // add process instances
        for (Integer processInstanceId : statsPerProcessInstance.keySet()) {
            StatisticsProcessInstanceObject stats = statsPerProcessInstance.get(processInstanceId);
            long durationTotal = stats.getDurationTotal();
            long durationEffective = durationTotal - stats.getDurationInactive();
            long durationResourcesIdle = stats.getDurationResourcesIdle();
            long durationWaiting = stats.getDurationWaiting();
            double cost = stats.getCosts();
            Element instance = new Element("instance");
            processInstances.addContent(instance);
            instance.addContent(new Element("costs").setText(String.valueOf(cost)));
            Element instanceTime = new Element("time");
            instanceTime.addContent(new Element("duration").setText(String.valueOf(durationTotal)));
            instanceTime.addContent(new Element("effective").setText(String.valueOf(durationEffective)));
            instanceTime.addContent(new Element("waiting").setText(String.valueOf(durationWaiting)));
            instanceTime.addContent(new Element("offTime").setText(String.valueOf(durationResourcesIdle)));
            instance.addContent(instanceTime);
            costStats.addValue(cost);
            flowTimeStats.addValue(durationTotal);
            effectiveStats.addValue(durationEffective);
            offTimeStats.addValue(durationResourcesIdle);
            waitingStats.addValue(durationWaiting);
        }
        costStats.calculateStatistics();
        flowTimeStats.calculateStatistics();
        effectiveStats.calculateStatistics();
        waitingStats.calculateStatistics();
        offTimeStats.calculateStatistics();
        processCost.addContent(costStats.getStatsAsElements());
        processFlowTime.addContent(flowTimeStats.getStatsAsElements());
        processEffectiveTime.addContent(effectiveStats.getStatsAsElements());
        processWaitingTime.addContent(waitingStats.getStatsAsElements());
        processOffTime.addContent(offTimeStats.getStatsAsElements());
        Map<String, Map<String, StatisticsTaskInstanceObject>> statsPerTaskOfProcess = statsPerTask.get(processId);
        // add activities
        for (String processScopeNodeId : statsPerTaskOfProcess.keySet()) {
            long taskDuration = 0;
            for (StatisticsTaskInstanceObject instance : statsPerTaskOfProcess.get(processScopeNodeId).values()) {
                taskDuration += instance.getDurationEffective();
            }
            // skip tasks with zero duration (which are most likely events)
            if (taskDuration == 0)
                continue;
            StatisticsCalculationObject taskCostStats = new StatisticsCalculationObject();
            StatisticsCalculationObject taskDurationStats = new StatisticsCalculationObject();
            StatisticsCalculationObject taskWaitingStats = new StatisticsCalculationObject();
            StatisticsCalculationObject taskResourcesIdleStats = new StatisticsCalculationObject();
            Map<String, StatisticsTaskInstanceObject> statsPerTaskInstance = statsPerTaskOfProcess.get(processScopeNodeId);
            String taskName = "";
            Element activity = new Element("activity");
            processActivities.addContent(activity);
            activity.addContent(new Element("id").setText(processScopeNodeId));
            Element activityName = new Element("name");
            Element activityCost = new Element("cost");
            Element activityTime = new Element("time");
            Element activityInstances = new Element("instances");
            activity.addContent(activityName);
            activity.addContent(activityCost);
            activity.addContent(activityTime);
            activity.addContent(activityInstances);
            Element activityDurationTime = new Element("duration");
            Element activityWaitingTime = new Element("waiting");
            Element activityResourcesIdleTime = new Element("resources_idle");
            activityTime.addContent(activityDurationTime);
            activityTime.addContent(activityWaitingTime);
            activityTime.addContent(activityResourcesIdleTime);
            // add activity instances
            for (String taskInstanceId : statsPerTaskInstance.keySet()) {
                StatisticsTaskInstanceObject stats = statsPerTaskInstance.get(taskInstanceId);
                if (taskName.isEmpty()) {
                    taskName = stats.getTaskName();
                }
                long durationEffective = stats.getDurationEffective();
                long durationResourcesIdle = stats.getDurationResourcesIdle();
                long durationWaiting = stats.getDurationWaiting();
                double cost = stats.getCost();
                Element activityInstance = new Element("instance");
                activityInstances.addContent(activityInstance);
                activityInstance.addContent(new Element("cost").setText(String.valueOf(cost)));
                Element activityInstanceTime = new Element("time");
                activityInstanceTime.addContent(new Element("effective").setText(String.valueOf(durationEffective)));
                activityInstanceTime.addContent(new Element("waiting").setText(String.valueOf(durationWaiting)));
                activityInstanceTime.addContent(new Element("resources_idle").setText(String.valueOf(durationResourcesIdle)));
                activityInstance.addContent(activityInstanceTime);
                taskCostStats.addValue(cost);
                taskDurationStats.addValue(durationEffective);
                taskWaitingStats.addValue(durationWaiting);
                taskResourcesIdleStats.addValue(durationResourcesIdle);
            }
            activityName.setText(taskName);
            taskCostStats.calculateStatistics();
            taskDurationStats.calculateStatistics();
            taskWaitingStats.calculateStatistics();
            taskResourcesIdleStats.calculateStatistics();
            activityCost.addContent(taskCostStats.getStatsAsElements());
            activityDurationTime.addContent(taskDurationStats.getStatsAsElements());
            activityWaitingTime.addContent(taskWaitingStats.getStatsAsElements());
            activityResourcesIdleTime.addContent(taskResourcesIdleStats.getStatsAsElements());
        }
        // add resources
        for (String resourceType : statsPerResource.keySet()) {
            Map<String, StatisticsResourceObject> statsPerResourceInstance = statsPerResource.get(resourceType);
            Element resource = new Element("resource");
            resources.addContent(resource);
            resource.addContent(new Element("type").setText(resourceType));
            Element resourceCost = new Element("cost");
            Element resourceTime = new Element("time");
            Element resourceInstances = new Element("instances");
            resource.addContent(resourceCost);
            resource.addContent(resourceTime);
            resource.addContent(resourceInstances);
            Element resourceInUse = new Element("in_use");
            Element resourceAvailable = new Element("available");
            Element resourceWorkload = new Element("workload");
            resourceTime.addContent(resourceInUse);
            resourceTime.addContent(resourceAvailable);
            resourceTime.addContent(resourceWorkload);
            StatisticsCalculationObject resourceCostStats = new StatisticsCalculationObject();
            StatisticsCalculationObject resourceInUseStats = new StatisticsCalculationObject();
            StatisticsCalculationObject resourceAvailableStats = new StatisticsCalculationObject();
            StatisticsCalculationObject resourceWorkloadStats = new StatisticsCalculationObject();
            // add resource instances
            for (String resourceId : statsPerResourceInstance.keySet()) {
                StatisticsResourceObject stats = statsPerResourceInstance.get(resourceId);
                long durationInUse = stats.getDurationInUse();
                long durationAvailable = stats.getDurationAvailable();
                double percentageInUse = durationInUse / (double) durationAvailable;
                double cost = stats.getCosts();
                Element resourceInstance = new Element("instance");
                resourceInstances.addContent(resourceInstance);
                resourceInstance.addContent(new Element("id").setText(resourceId));
                resourceInstance.addContent(new Element("cost").setText(String.valueOf(cost)));
                Element resourceInstanceTime = new Element("time");
                resourceInstanceTime.addContent(new Element("in_use").setText(String.valueOf(durationInUse)));
                resourceInstanceTime.addContent(new Element("available").setText(String.valueOf(durationAvailable)));
                resourceInstanceTime.addContent(new Element("workload").setText(String.valueOf(percentageInUse)));
                resourceInstance.addContent(resourceInstanceTime);
                resourceCostStats.addValue(cost);
                resourceInUseStats.addValue(durationInUse);
                resourceAvailableStats.addValue(durationAvailable);
                resourceWorkloadStats.addValue(percentageInUse);
            }
            resourceCostStats.calculateStatistics();
            resourceInUseStats.calculateStatistics();
            resourceAvailableStats.calculateStatistics();
            resourceWorkloadStats.calculateStatistics();
            resourceCost.addContent(resourceCostStats.getStatsAsElements());
            resourceInUse.addContent(resourceInUseStats.getStatsAsElements());
            resourceAvailable.addContent(resourceAvailableStats.getStatsAsElements());
            resourceWorkload.addContent(resourceWorkloadStats.getStatsAsElements());
        }
    }
    // print
    String resourceUtilizationFileName = outputPathWithoutExtension + model.getGlobalConfiguration().getFileNameWithoutExtension() + "_resourceutilization.xml";
    FileOutputStream fos = new FileOutputStream(resourceUtilizationFileName);
    XMLOutputter xmlOutput = new XMLOutputter();
    xmlOutput.output(doc, fos);
}

Example 5 with ProcessNodeTransitionType

use of de.hpi.bpt.scylla.logger.ProcessNodeTransitionType in project scylla by bptlab.

the class BatchPluginUtils method logTaskEventForNonResponsiblePI.

// If the execution type is parallel this makes the entry for the not really simulated process instances for tasks
void logTaskEventForNonResponsiblePI(TaskEvent event, ProcessInstance processInstance) throws ScyllaRuntimeException {
    ProcessInstance parentProcessInstance = processInstance.getParent();
    if (parentProcessInstance != null) {
        ProcessModel processModel = processInstance.getProcessModel();
        int parentNodeId = processModel.getNodeIdInParent();
        BatchPluginUtils pluginInstance = BatchPluginUtils.getInstance();
        BatchCluster cluster = pluginInstance.getRunningCluster(parentProcessInstance, parentNodeId);
        if (cluster != null && cluster.getBatchActivity().getExecutionType().equals(BatchClusterExecutionType.PARALLEL)) {
            SimulationModel model = (SimulationModel) event.getModel();
            long timestamp = Math.round(model.presentTime().getTimeRounded(DateTimeUtils.getReferenceTimeUnit()));
            String taskName = event.getDisplayName();
            int nodeId = event.getNodeId();
            String processScopeNodeId = SimulationUtils.getProcessScopeNodeId(processModel, nodeId);
            String source = event.getSource();
            ProcessNodeTransitionType transition;
            Set<String> resources = new HashSet<String>();
            if (event instanceof TaskEnableEvent) {
                transition = ProcessNodeTransitionType.ENABLE;
            } else if (event instanceof TaskBeginEvent) {
                transition = ProcessNodeTransitionType.BEGIN;
                Set<ResourceObject> resourceObjects = processInstance.getAssignedResources().get(source).getResourceObjects();
                for (ResourceObject res : resourceObjects) {
                    String resourceName = res.getResourceType() + "_" + res.getId();
                    resources.add(resourceName);
                }
                tasksAndResources.put(source, resources);
            } else if (event instanceof TaskCancelEvent) {
                transition = ProcessNodeTransitionType.CANCEL;
                resources = tasksAndResources.get(source);
                tasksAndResources.remove(source);
            } else if (event instanceof TaskTerminateEvent) {
                transition = ProcessNodeTransitionType.TERMINATE;
                resources = tasksAndResources.get(source);
                tasksAndResources.remove(source);
            } else {
                throw new ScyllaRuntimeException("Task event type not supported.");
            }
            int sourceSuffix = 0;
            List<ProcessInstance> processInstances = cluster.getProcessInstances();
            for (ProcessInstance pi : processInstances) {
                if (!processInstance.getParent().equals(pi)) {
                    // the source attribute comes from an event, but we did not really simulate the events for the
                    // non-responsible process instances, so we mock a source attribute value
                    String mockSource = source + "##" + ++sourceSuffix;
                    ProcessNodeInfo info;
                    info = new ProcessNodeInfo(nodeId, processScopeNodeId, mockSource, timestamp, taskName, resources, transition);
                    model.addNodeInfo(processModel, pi, info);
                }
            }
        }
    }
}