Java XTrace.get方法代码示例

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
private void checkIfOutlier(Map<Outlier<String>, Integer> removed, XTrace t, int i, int lookAHead, boolean directOrReverse) {
    XEvent current = directOrReverse?t.get((i - lookAHead)):t.get((i + lookAHead));
    XEvent next = t.get(i);
    String nameCurrent = getEventName(current);
    String nameNext = getEventName(next);

    OutlierIdentifier outlierIdentifier = outlierIdentifierGenerator.generate(nameCurrent);
    Set<Outlier<String>> set = mapOutliers.getOutliers(outlierIdentifier);
    Outlier<String> outlier = new Outlier<String>(nameNext, outlierIdentifier, false);

    if (set != null && set.contains(outlier)) {
        Integer val;
        if ((val = removed.get(outlier)) == null) {
            val = 0;
        }
        val++;
        removed.put(outlier, val);
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public Date fixDate(XTrace trace, int eventPos, int prePos, int postPos) {
    XEvent event = trace.get(eventPos);
    Date date1;
    if(prePos >= 0) {
        date1 = xte.extractTimestamp(trace.get(prePos));
        if (date1 == null) {
            date1 = fixDate(trace, prePos, prePos - 1, postPos);
        }
    }else {
        date1 = new Date(0);
    }

    Date date2;
    if(postPos < trace.size()) {
        date2 = xte.extractTimestamp(trace.get(postPos));
        if (date2 == null) {
            date2 = fixDate(trace, postPos, prePos, postPos + 1);
        }
    }else {
        date2 = new Date(Long.MAX_VALUE);
    }
    Date date3 = new Date((date2.getTime() + date1.getTime())/ 2);
    xte.assignTimestamp(event, date3);
    return date3;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
private void removeOutlierSelect(XTrace t, XTrace newT, int i) {
    XEvent before = t.get(i - 1);
    XEvent guilty = t.get(i);
    XEvent after = t.get(i + 1);

    String nameBefore = getEventName(before);
    String nameGuilty = getEventName(guilty);
    String nameAfter = getEventName(after);

    OutlierIdentifier outlierIdentifier = outlierIdentifierGenerator.generate(nameBefore, nameAfter);
    Set<Outlier<String>> set = mapOutliers.getOutliers(outlierIdentifier);
    Outlier<String> outlier = new Outlier<String>(nameGuilty, outlierIdentifier, false);

    if (set == null || !set.contains(outlier)) {
        newT.add((XEvent) t.get(i).clone());
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public double computeLikelihood(XTrace trace) {
    double likelihood = 1;
    XEvent last = null;
    String lastName;
    Double res;
    if((res = likelihoodCache.get(trace)) == null) {
        for (int i = 0; i < trace.size(); i++) {
            XEvent event = trace.get(i);
            if (last != null) {
                lastName = getEventName(last);
                String eventName = getEventName(event);
                likelihood *= computeLikelihood(lastName, eventName);
            }
            last = event;
        }
        likelihoodCache.put(trace, likelihood);
    }
    if(res != null) {
        likelihood = res;
    }

    return likelihood;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public double computeLikelihoodWithoutZero(XTrace trace) {
    double likelihood = 1;
    XEvent last = null;
    String lastName;
    double scaleFactor = 1 / trace.size();
    for(int i = 0; i < trace.size(); i++) {
        XEvent event = trace.get(i);
        if(last != null) {
            lastName = getEventName(last);
            String eventName = getEventName(event);
            likelihood += computeLikelihood(lastName, eventName) * scaleFactor;
        }
        last = event;
    }

    return likelihood;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public static StringBuilder getStringOfXTraces(HashMap<String,XTrace> traces){

		Iterator<Entry<String, XTrace>> trit = traces.entrySet().iterator();
		StringBuilder info = new StringBuilder("");
		
		while(trit.hasNext()){
			Entry<String, XTrace> xte = trit.next();
			XTrace xt = xte.getValue();
			
			info.append(LEConstants.LOGGER_LINE+"\n");
			info.append("XTrace URI: \t"+xte.getKey()+"\n");

			//handling trace's attributes
			XAttributeMap xattmap = xt.getAttributes();
			info.append(getStringOfXAttributeMap("\t", xattmap));
			//END OF handling trace's attributes
			
			//iterate over trace's events
			for(int ii = 0; ii < xt.size(); ii++){
				XEvent xe = xt.get(ii);
				info.append("\t"+LEConstants.LOGGER_LINE+"\n");
				info.append("\tXEvent: "+xe.toString()+"\n");

				//handling event's attributes
				info.append(getStringOfXAttributeMap("\t\t",xe.getAttributes()));
			}
			//END OF iterate over trace's events
		}
		
		return info;
	}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
private void removeOutlierSelectOnlyOne(XTrace t, XTrace newT, int i) {
    XEvent before = t.get(i - 1);
    XEvent guilty = t.get(i);
    XEvent after = t.get(i + 1);

    String nameBefore = getEventName(before);
    String nameGuilty = getEventName(guilty);
    String nameAfter = getEventName(after);

    if (!nameBefore.equals(((DoubleOutlierIdentifier) outlier.getIdentifier()).getIdentifier1())
            || !nameAfter.equals(((DoubleOutlierIdentifier) outlier.getIdentifier()).getIdentifier2())
            || !nameGuilty.equals(outlier.getElementToRemove())) {
        newT.add((XEvent) t.get(i).clone());
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public void assignTimestamps() {
    for(XTrace trace : log) {
        if(duplicatedTraces.contains(getTraceName(trace))) {
            Set<int[]> sameTimeStamps = findEventsSameTimeStamp(trace);
            for(int[] couple : sameTimeStamps) {
                XEvent first = trace.get(couple[0]);

                long diff;
                long[] distribution;
                if (couple[1] < trace.size()) {
                    XEvent last = trace.get(couple[1]);
                    diff = xte.extractTimestamp(last).getTime() - xte.extractTimestamp(first).getTime();
                    distribution = eventDurationDistributionCalculator.estimateDuration(diff, trace.subList(couple[0], couple[1] + 1));
                }else {
                    diff = Long.MAX_VALUE;
                    List<XEvent> list = new ArrayList<XEvent>(trace.subList(couple[0], couple[1]));
                    list.add(null);
                    distribution = eventDurationDistributionCalculator.estimateDuration(diff, list);
                }

                Date date = xte.extractTimestamp(first);
                if(distribution.length == 1) {
                    date = new Date(date.getTime() + distribution[0]);
                    if(debug_mode && xte.extractTimestamp(trace.get(couple[0] + 1)).equals(date)) System.out.println("Unable to fix timestamp for trace " + getTraceName(trace));

                    xte.assignTimestamp(trace.get(couple[0] + 1), date);
                }else {
                    for (int i = 1; i < distribution.length; i++) {
                        date = new Date(date.getTime() + distribution[i]);
                        if(debug_mode && xte.extractTimestamp(trace.get(couple[0] + i)).equals(date)) System.out.println("Unable to fix timestamp for trace " + getTraceName(trace));

                        xte.assignTimestamp(trace.get(couple[0] + i), date);
                    }
                }
            }
        }
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public void assignTimestampsDummy() {
    for(XTrace trace : log) {
        if(duplicatedTraces.contains(getTraceName(trace))) {
            Set<int[]> sameTimeStamps = findEventsSameTimeStamp(trace);
            for(int[] couple : sameTimeStamps) {
                XEvent first = trace.get(couple[0]);

                long diff;
                if (couple[1] < trace.size()) {
                    XEvent last = trace.get(couple[1]);
                    diff = xte.extractTimestamp(last).getTime() - xte.extractTimestamp(first).getTime();
                }else {
                    diff = Long.MAX_VALUE;
                }

                Date date = xte.extractTimestamp(first);
                long increment = diff / (couple[1] - couple[0]);
                for (int i = 1; i < couple[1] - couple[0]; i++) {
                    date = new Date(date.getTime() + increment);
                    if(debug_mode && xte.extractTimestamp(trace.get(couple[0] + i)).equals(date)) System.out.println("Unable to fix timestamp for trace " + getTraceName(trace));

                    xte.assignTimestamp(trace.get(couple[0] + i), date);
                }
            }
        }
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
@Override
public OutlierMap<String> buildOutliers(XLog log, int lookAHead, boolean smart) {
    for (XTrace trace : log) {
        for (int i = 0; i < trace.size() - 2; i++) {
            XEvent event1 = trace.get(i);
            XEvent event2 = trace.get(i + 1);
            XEvent event3 = trace.get(i + 2);

            build(event1, event2, event3, smart);
        }
    }
    return map;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
@Override
public OutlierMap<String> buildOutliersReverse(XLog log, int lookAHead, boolean smart) {
    for (XTrace trace : log) {
        for (int i = trace.size() - 1; i >= 0 + lookAHead; i--) {
            XEvent event1 = trace.get(i);
            XEvent event2 = trace.get(i - lookAHead);

            build(event1, event2, smart);
        }
    }
    return map;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
@Override
public void selectOulierToRemove(XLog log, int lookAHead, boolean selectOnlyOneOutlier, boolean smallestOrLargest) {
    if(selectOnlyOneOutlier) {
        boolean outlearsFound = false;
        if(mapOutliers.size() > 0) {
            outlearsFound = true;
        }

        Map<Outlier<String>, Integer> removed = new UnifiedMap<Outlier<String>, Integer>();
        if (outlearsFound) {
            for (XTrace t : log) {
                if(t.size() > 0) {
                    for (int i = 1; i < t.size() - 1; i++) {
                        XEvent before = t.get(i - 1);
                        XEvent guilty = t.get(i);
                        XEvent after = t.get(i + 1);

                        String nameBefore = getEventName(before);
                        String nameGuilty = getEventName(guilty);
                        String nameAfter = getEventName(after);

                        OutlierIdentifier outlierIdentifier = outlierIdentifierGenerator.generate(nameBefore, nameAfter);
                        Set<Outlier<String>> set = mapOutliers.getOutliers(outlierIdentifier);
                        Outlier<String> outlier1 = new Outlier<String>(nameGuilty, outlierIdentifier, false);

                        if (set != null && set.contains(outlier1)) {
                            Integer val;
                            if ((val = removed.get(outlier1)) == null) {
                                val = 0;
                            }
                            val++;
                            removed.put(outlier1, val);
                        }
                    }
                }
            }
            select(removed, smallestOrLargest);
        }
    }
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
public boolean isMultiInstanceActivity(Activity activity, XLog log) {

        for (XTrace trace : log) {

            int pos = -1;
            XEvent firstEvent = null;
            XEvent secondEvent;

            int newPos = 0;
            while (newPos >= 0) {
                newPos = bpmnAnalizer.findPositionOfEventOfActivity(activity, trace, newPos);

                if (newPos == -1) break;
                if (pos == -1) {
                    pos = newPos;
                    firstEvent = trace.get(pos);
                } else if (newPos > -1 && pos != newPos) {
                    secondEvent = trace.get(newPos);

                    long t1 = xte.extractTimestamp(firstEvent).getTime();
                    long t2 = xte.extractTimestamp(secondEvent).getTime();
                    if (t1 == t2) {
                        return true;
                    }
                } else if (newPos <= -1) {
                    break;
                }

                newPos++;
            }
        }

        return false;

    }
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
@Override
public OutlierMap<String> buildOutliers(XLog log, int lookAHead, boolean smart) {
    for (XTrace trace : log) {
        for (int i = 0; i < trace.size() - lookAHead; i++) {
            XEvent event1 = trace.get(i);
            XEvent event2 = trace.get(i + lookAHead);

            build(event1, event2, smart);
        }
    }
    return map;
}
 

import org.deckfour.xes.model.XTrace; //导入方法依赖的package包/类
private boolean insertNoise(XTrace trace, final Random r, double[] changedEvents, double[] changedTraces) {
    int number = r.nextInt(trace.size() - 1);
    int start = r.nextInt((trace.size() - 1) - number);

    if (number > 0) {
        trace.getAttributes().put("change", new XAttributeBooleanImpl("change", true));
        Date date = null;

        if(number == 1) {
            if(nameExtractor.getEventName(trace.get(start)).equals(nameExtractor.getEventName(trace.get(start + 1)))) {
                return false;
            }
        }

        for (int i = 0; i < trace.size(); i++) {
            XEvent event = trace.get(i);
            if (i == start) {
                if(event.getAttributes().get("originalTimeStamp") == null) {
                    event.getAttributes().put("originalTimeStamp", new XAttributeTimestampImpl("originalTimeStamp", xte.extractTimestamp(event)));
                }

                date = xte.extractTimestamp(event);
                event.getAttributes().put("change", new XAttributeBooleanImpl("change", true));
                changedEvents[0]++;
            } else if (i > start && i <= start + number) {
                if(event.getAttributes().get("originalTimeStamp") == null) {
                    event.getAttributes().put("originalTimeStamp", new XAttributeTimestampImpl("originalTimeStamp", xte.extractTimestamp(event)));
                }

                xte.assignTimestamp(event, date);
                event.getAttributes().put("change", new XAttributeBooleanImpl("change", true));
                changedEvents[0]++;
            }
        }

        String oldTrace = TraceToString.convertXTraceToString(trace, nameExtractor);

        while(oldTrace.equals(TraceToString.convertXTraceToString(trace, nameExtractor))) {
            Collections.sort(trace, new Comparator<XEvent>() {
                Random random = r;

                @Override
                public int compare(XEvent o1, XEvent o2) {
                    Date date1 = xte.extractTimestamp(o1);
                    Date date2 = xte.extractTimestamp(o2);
                    if (!date1.equals(date2)) return date1.compareTo(date2);
                    else return random.nextInt(2) > 0 ? 1 : -1;
                }
            });
        }

        changedTraces[0]++;
        return true;
    }

    return false;
}