Changeset 1692 for branches/autoquest-core-tasktrees-alignment/src/main

Timestamp:

08/23/14 17:19:39 (10 years ago)

Author:

rkrimmel

Message:

HarmonizeIterationinstancemodel? DOES need to be called after iteration detection....

Location:

branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees

Files:

• alignment/matrix/ObjectDistanceSubstitionMatrix.java (modified) (6 diffs)
• temporalrelation/RuleUtils.java (modified) (2 diffs)
• temporalrelation/SequenceForTaskDetectionRuleAlignment.java (modified) (3 diffs)

branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/ObjectDistanceSubstitionMatrix.java

@@ -3 +3 @@
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 
@@ -11 +12 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
-import de.ugoe.cs.autoquest.usageprofiles.SymbolMap;
 
 
 public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix {
 
-        // private ArrayList<int[][]> matrix;
         HashMap<Integer, Integer> idmapping;
         private TriangleMatrix matrix;
-        private SymbolMap<ITaskInstance, ITask> uniqueTasks;
+        private HashSet<ITask> uniqueTasks;
         private double gapPenalty; 
         private int index = 0;
@@ -26 +25 @@
         
         public ObjectDistanceSubstitionMatrix(
-                        SymbolMap<ITaskInstance, ITask> uniqueTasks,float positiveThreshold, int gapPenalty) {
+                        HashSet<ITask> uniqueTasks,float positiveThreshold, int gapPenalty) {
                 this.uniqueTasks = uniqueTasks;
                 this.positiveThreshold = positiveThreshold;
@@ -49 +48 @@
                 int index2=-1;
                 float distance=0;
-                
-                //TODO: Nicht ueber Symbols sondern ueber values, wenn Eventtask -> getInstances()->get(0)
-                for (Iterator<ITaskInstance> it = uniqueTasks.getSymbols().iterator(); it
-                                .hasNext();) {
-                        Object obj1 = it.next();
-                        for (Iterator<ITaskInstance> jt = uniqueTasks.getSymbols()
-                                        .iterator(); jt.hasNext();) {
-                        
+                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
+                        ITask task1 = it.next();
+                        for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
+                                ITask task2 = jt.next();
+                                ITaskInstance ti1 = null;
+                                ITaskInstance ti2 = null;
+                                //TODO This seems ugly
+                                if(task1.getInstances().size() > 0) {
+                                        ti1 = (ITaskInstance) task1.getInstances().iterator().next();
+                                }
+                                if(task2.getInstances().size() > 0) {
+                                        ti2 = (ITaskInstance) task2.getInstances().iterator().next();
+                                }
                                 IEventTaskInstance eti1 = null;
-                                ITask task1 = null;
+                                IEventTaskInstance eti2 = null;
                                 
-                                IEventTaskInstance eti2 = null;
-                                ITask task2 = null;
                                 
-                                Object obj2 = jt.next();
-                                
-                                if (obj1 instanceof IEventTaskInstance && obj2 instanceof IEventTaskInstance) {
-                                        eti1 = (IEventTaskInstance) obj1;
+                                if (ti1 instanceof IEventTaskInstance && ti2 instanceof IEventTaskInstance) {
+                                        eti1 = (IEventTaskInstance) ti1;
                                         index1 = getIndex(eti1);
-                                        eti2 = (IEventTaskInstance) obj2;
+                                        eti2 = (IEventTaskInstance) ti2;
                                         index2 = getIndex(eti2);
                                         distance = distanceBetweenInstances(eti1,eti2);
                                 }
-                                else if(obj1 instanceof IEventTaskInstance &&  !(obj2 instanceof IEventTaskInstance)) {
-                                        task2 = ((ITaskInstance) obj2).getTask();
+                                else if(ti1 instanceof IEventTaskInstance &&  !(ti2 instanceof IEventTaskInstance)) {
+                                        task1 = ((ITaskInstance) ti1).getTask();
                                         index2 = getIndex(task2);
-                                        eti1 = (IEventTaskInstance) obj1;
+                                        eti1 = (IEventTaskInstance) ti1;
                                         index1 = getIndex(eti1);
                                         distance = distanceBetweenTaskAndInstance(task2,eti1);
                                 }
-                                else if(!(obj1 instanceof IEventTaskInstance) && obj2 instanceof IEventTaskInstance) {
-                                        task1 = ((ITaskInstance) obj1).getTask();
+                                else if(!(ti1 instanceof IEventTaskInstance) && ti2 instanceof IEventTaskInstance) {
                                         index1 = getIndex(task1);
-                                        eti2 = (IEventTaskInstance) obj2;
+                                        eti2 = (IEventTaskInstance) ti2;
                                         index2 = getIndex(eti2);
                                         distance = distanceBetweenTaskAndInstance(task1,eti2);
                                 }
-                                else if(!(obj2 instanceof IEventTaskInstance) && !(obj2 instanceof IEventTaskInstance)) {
-                                        task1 = ((ITaskInstance) obj1).getTask();
+                                else if(!(ti1 instanceof IEventTaskInstance) && !(ti2 instanceof IEventTaskInstance)) {
                                         index1 = getIndex(task1);
-                                        task2 = ((ITaskInstance) obj2).getTask();
                                         index2 = getIndex(task2);
                                         distance = distanceBetweenTasks(task1,task2);
@@ -103 +100 @@
         }
 
-        
+        //TODO: Calculate distance here
         private float distanceBetweenTaskAndInstance(ITask task1, IEventTaskInstance eti) {
                 return 0;
         }
         
+        //TODO: Calculate distance here
         private float distanceBetweenTasks(ITask task1, ITask task2) {
                 return 0;
@@ -158 +156 @@
                 } 
                 else {
-                        System.out.println("Firsttask: " +taskId1);
-                        System.out.println("Secondtask: " + taskId2);
-                        System.out.println(idmapping);
+                        
                         Integer first = idmapping.get(taskId1);
                         Integer second = idmapping.get(taskId2);
-                        System.out.println("First: " + first + " Second: " + second);
-                        System.out.println("Matrix: " + matrix.get(first, second));
                         return matrix.get(first,second);        
                 }

branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleUtils.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIterationInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional;
@@ -145 +147 @@
 
                         } else if (tempTask.getType() == "sequence") {
-                                //System.out.println("Adding SequenceInstance " + parent.get(startIndex) + " to " + tempTask.getType());
-                                taskBuilder.addChild(subsequence,parent.get(startIndex));
+                                //ISequenceInstance sequence = taskFactory.createNewTaskInstance((ISequence) tempTask);
+                                //taskBuilder.addChild(sequence, parent.get(i));
+                                //taskBuilder.addChild(subsequence,sequence);
+                                taskBuilder.addChild(subsequence, parent.get(startIndex));
                         } else if (tempTask.getType() == "iteration") {
+                                //IIterationInstance iteration = taskFactory.createNewTaskInstance((IIteration) tempTask);
+                                //taskBuilder.addChild(iteration, parent.get(startIndex));
+                                //taskBuilder.addChild(subsequence, iteration);
                                 taskBuilder.addChild(subsequence, parent.get(startIndex));
                                 //System.out.println("Adding IterationInstance " + parent.get(startIndex) + " to " + tempTask.getType());

branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java

@@ -38 +38 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelectionInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequenceInstance;
@@ -138 +139 @@
         public RuleApplicationResult apply(List<IUserSession> sessions) {
                 RuleApplicationData appData = new RuleApplicationData(sessions);
+                
                 harmonizeEventTaskInstancesModel(appData);
-                
                 do {
                         iteration++;
+                        
                         appData.detectedAndReplacedTasks = false;
                         appData.getStopWatch().start("whole loop"); 
@@ -364 +366 @@
                         }
                 }
-        }
+                  
+        for (Map.Entry<IIteration, List<IIterationInstance>> entry : iterationInstances.entrySet())
+        {
+            harmonizeIterationInstancesModel(entry.getKey(), entry.getValue());
+        }
+        }
+
+        
+        /**
+     * <p>
+     * TODO clarify why this is done
+     * </p>
+     */
+    private void harmonizeIterationInstancesModel(IIteration               iteration,
+                                                  List<IIterationInstance> iterationInstances)
+    {
+        List<ITask> iteratedTaskVariants = new LinkedList<ITask>();
+        TaskInstanceComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
+        
+        // merge the lexically different variants of iterated task to a unique list 
+        for (IIterationInstance iterationInstance : iterationInstances) {
+            for (ITaskInstance executionVariant : iterationInstance) {
+                ITask candidate = executionVariant.getTask();
+            
+                boolean found = false;
+                for (ITask taskVariant : iteratedTaskVariants) {
+                    if (comparator.areLexicallyEqual(taskVariant, candidate)) {
+                        taskBuilder.setTask(executionVariant, taskVariant);
+                        found = true;
+                        break;
+                    }
+                }
+                
+                if (!found) {
+                    iteratedTaskVariants.add(candidate);
+                }
+            }
+        }
+        
+        // if there are more than one lexically different variant of iterated tasks, adapt the
+        // iteration model to be a selection of different variants. In this case also adapt
+        // the generated iteration instances to correctly contain selection instances. If there
+        // is only one variant of an iterated task, simply set this as the marked task of the
+        // iteration. In this case, the instances can be preserved as is
+        if (iteratedTaskVariants.size() > 1) {
+            ISelection selection = taskFactory.createNewSelection();
+            
+            for (ITask variant : iteratedTaskVariants) {
+                taskBuilder.addChild(selection, variant);
+            }
+            
+            taskBuilder.setMarkedTask(iteration, selection);
+            
+            for (IIterationInstance instance : iterationInstances) {
+                for (int i = 0; i < instance.size(); i++) {
+                    ISelectionInstance selectionInstance =
+                        taskFactory.createNewTaskInstance(selection);
+                    taskBuilder.setChild(selectionInstance, instance.get(i));
+                    taskBuilder.setTaskInstance(instance, i, selectionInstance);
+                }
+            }
+        }
+        else {
+            taskBuilder.setMarkedTask(iteration, iteratedTaskVariants.get(0));
+        }
+    }
+
 
         ISequence matchAsSequence(RuleApplicationData appData, Match m) {