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

Last change on this file since 1707 was 1707, checked in by rkrimmel, 10 years ago

Possibility to save intermediate results
File size: 10.4 KB
Line 
1package de.ugoe.cs.autoquest.tasktrees.alignment.matrix;
2
3import java.io.Serializable;
4import java.util.HashMap;
5import java.util.concurrent.ExecutorService;
6import java.util.concurrent.Executors;
7import java.util.concurrent.TimeUnit;
8import java.util.HashSet;
9import java.util.Iterator;
10import java.util.LinkedList;
11import java.util.logging.Level;
12
13import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
14import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentHelpers;
15import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.Constants;
16import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
17import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
19import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
20import de.ugoe.cs.util.console.Console;
21
22
23
24public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix,Serializable {
25
26        /**
27         *
28         */
29        private static final long serialVersionUID = -4253258274617754083L;
30        private HashMap<Integer, Integer> idmapping;
31        private ITriangleMatrix matrix;
32        private HashSet<ITask> uniqueTasks;
33        private float gapPenalty;
34        private int index = 0;
35        private HashMap<Integer, LinkedList<IEventTaskInstance>> etisOfTasks;
36        private boolean calculateNonTaskInstances = true;
37        private int firstRoundMaxIndex = 0;
38
39        private double positiveThreshold;
40
41        public ObjectDistanceSubstitionMatrix(
42                float positiveThreshold, int gapPenalty,
43                boolean calculateNonTaskInstances) {
44                this.positiveThreshold = positiveThreshold;
45                idmapping = new HashMap<Integer, Integer>();
46                etisOfTasks = new HashMap<Integer, LinkedList<IEventTaskInstance>>();
47                this.gapPenalty = gapPenalty;
48                this.calculateNonTaskInstances = calculateNonTaskInstances;
49
50        }
51
52        public float getGapPenalty() {
53                return gapPenalty;
54        }
55
56        public void setGapPenalty(float gapPenalty) {
57                this.gapPenalty = gapPenalty;
58        }
59
60        //TODO: Merge this with updateEventTaskInstances
61        private void searchEventTaskInstances() {
62                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
63                        ITask task = it.next();
64                        if (!(task instanceof IEventTask)) {
65                                EventTaskInstancesListGenerator etlg = new EventTaskInstancesListGenerator();
66                                task.accept(etlg);
67                                LinkedList<IEventTaskInstance> eventTaskInstances = etlg
68                                                .getEventlist();
69                                etisOfTasks.put(task.getId(), eventTaskInstances);
70                        }
71                }
72        }
73       
74        public void updateEventTaskInstances(LinkedList<ITask> newTasks){
75                for (Iterator<ITask> it = newTasks.iterator();it.hasNext();) {
76                        ITask task = it.next();
77                        if (!(task instanceof IEventTask)) {
78                                EventTaskInstancesListGenerator etlg = new EventTaskInstancesListGenerator();
79                                task.accept(etlg);
80                                LinkedList<IEventTaskInstance> eventTaskInstances = etlg
81                                                .getEventlist();
82                                etisOfTasks.put(task.getId(), eventTaskInstances);
83                        }
84                }
85        }
86       
87        //Just Calculate the distance between the new tasks and the matrix.
88        public void update(LinkedList<ITask> newTasks) {
89
90                if (this.calculateNonTaskInstances) {
91                        try {
92                                matrix.increaseSize(newTasks.size());
93                                System.out.println("Subsitution matrix size is now " + matrix.size()*(matrix.size()+1)/2);
94                                Console.traceln(Level.INFO, "searching EventTasks in Tasks");
95                        } catch (Exception e) {
96                                Console.logException(e);
97                        }
98                        this.updateEventTaskInstances(newTasks);
99                       
100                        int nThreads = de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads;
101                        ExecutorService executor = Executors.newFixedThreadPool(nThreads);
102                       
103                             
104                        int count=0;
105                        int size=uniqueTasks.size();
106                       
107                        for(Iterator<ITask> it = newTasks.iterator();it.hasNext();) {
108                                ITask task1 = it.next();
109                                for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
110                                        ITask task2 = jt.next();
111                                        Runnable worker = new DistanceCalculator(task1,task2);
112                                    executor.execute(worker);
113                                }
114                        }
115                       
116                         executor.shutdown();
117                            // Wait until all threads are finish
118                         try {
119                                executor.awaitTermination(60, TimeUnit.MINUTES);
120                        } catch (InterruptedException e) {
121                                e.printStackTrace();
122                        }
123                         System.out.println("Finished all threads");
124                       
125                }
126        }
127
128        public void generate(HashSet<ITask> uniqueTasks) {
129                this.uniqueTasks = uniqueTasks;
130                if (this.calculateNonTaskInstances) {
131                        matrix = new DynamicTriangleMatrix(uniqueTasks.size() + 1);
132                        Console.traceln(Level.INFO, "searching EventTasks in Tasks");
133                        searchEventTaskInstances();
134                }
135                else{
136                        matrix = new StaticTriangleMatrix(uniqueTasks.size()+1);
137                }
138                matrix.initialize(0);
139               
140               
141                int nThreads = de.ugoe.cs.autoquest.tasktrees.temporalrelation.SequenceForTaskDetectionRuleAlignment.nThreads;
142                Console.traceln(Level.INFO, "calculating distances with " + nThreads + " threads");
143                ExecutorService executor = Executors.newFixedThreadPool(nThreads);
144               
145                     
146                int count=0;
147                int size=uniqueTasks.size();
148                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
149                        ITask task1 = it.next();
150                        count++;
151                        if((size%count*100)==0) {
152                                Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
153                        }
154                        for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
155                                ITask task2 = jt.next();
156                                Runnable worker = new DistanceCalculator(task1,task2);
157                            executor.execute(worker);
158                        }
159                }
160                 executor.shutdown();
161                    // Wait until all threads are finish
162                 try {
163                        executor.awaitTermination(60, TimeUnit.MINUTES);
164                } catch (InterruptedException e) {
165                        e.printStackTrace();
166                }
167                 System.out.println("Finished all threads");
168               
169                this.firstRoundMaxIndex=index;
170        }
171       
172               
173
174       
175       
176
177        private float distanceBetweenTaskAndInstance(ITask task1,
178                        IEventTaskInstance eti1) {
179                if (this.calculateNonTaskInstances) {
180                        float tmpDistance = 0;
181                        //System.out.println(etisOfTasks);
182                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
183                                        .get(task1.getId());
184                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
185                                        .iterator(); it.hasNext();) {
186                                IEventTaskInstance eti2 = it.next();
187                                //int taskId1 = eti1.getTask().getId();
188                                //int taskId2 = eti2.getTask().getId();
189                                //if (scoreExists(taskId1, taskId2)) {
190                                //      tmpDistance += getScore(taskId1, taskId2);
191                                //} else {
192                                        float dist = distanceBetweenInstances(eti1, eti2);
193                                        matrix.set(getIndex(eti1), getIndex(eti2), dist);
194                                        tmpDistance += dist;
195                                //}
196                        }
197                        return tmpDistance / eventTaskInstances.size();
198                } else {
199                        return 0;
200                }
201        }
202
203        //public boolean scoreExists(int id, int id2) {
204                //return idmapping.containsKey(id) && idmapping.containsKey(id2);
205        //      return false;
206        //}
207
208        private float distanceBetweenTasks(ITask task1, ITask task2) {
209                if (this.calculateNonTaskInstances) {
210                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
211                                        .get(task1.getId());
212                        float tmpDistance = 0;
213                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
214                                        .iterator(); it.hasNext();) {
215                                IEventTaskInstance eti1 = it.next();
216                                tmpDistance += distanceBetweenTaskAndInstance(task2, eti1);
217                        }
218
219                        return tmpDistance / eventTaskInstances.size();
220                } else {
221                        return 0;
222                }
223        }
224
225        synchronized private int getIndex(ITask task) {
226                int tempindex = -1;
227
228                if (!idmapping.containsKey(task.getId())) {
229                       
230                        idmapping.put(task.getId(), index);
231                        tempindex = index;
232                        index++;
233                } else {
234                        tempindex = idmapping.get(task.getId());
235                }
236
237                return tempindex;
238        }
239
240        synchronized private int getIndex(IEventTaskInstance eti) {
241                int tempindex = -1;
242                if (!idmapping.containsKey(eti.getTask().getId())) {
243                        idmapping.put(eti.getTask().getId(), index);
244                        tempindex = index;
245                        index++;
246                } else {
247                        tempindex = idmapping.get(eti.getTask().getId());
248                }
249                return tempindex;
250        };
251
252        private float distanceBetweenInstances(IEventTaskInstance eti1,
253                        IEventTaskInstance eti2) {
254                IGUIElement first = (IGUIElement) eti1.getEvent().getTarget();
255                IGUIElement second = (IGUIElement) eti2.getEvent().getTarget();
256                float distance = -1 * AlignmentHelpers.distanceBetween(first, second);
257                distance += positiveThreshold;
258                return distance;
259        }
260
261        public String toString() {
262                return matrix.toString();
263        }
264
265        public float getScore(int taskId1, int taskId2) {
266                if (taskId1 == Constants.GAP_SYMBOL
267                                || taskId1 == Constants.UNMATCHED_SYMBOL
268                                || taskId2 == Constants.GAP_SYMBOL
269                                || taskId2 == Constants.UNMATCHED_SYMBOL) {
270                        return 0;
271                } else if(this.calculateNonTaskInstances==false &&     
272                                (taskId1>this.firstRoundMaxIndex
273                                || taskId2>this.firstRoundMaxIndex)) {
274                        return 0;
275                } else {
276                        Integer first = idmapping.get(taskId1);
277                        Integer second = idmapping.get(taskId2);
278                        return matrix.get(first, second);
279                }
280
281        }
282       
283       
284        private class DistanceCalculator implements Runnable {
285
286                private ITask task1;
287                private ITask task2;
288               
289                public DistanceCalculator(ITask task1, ITask task2){
290                        this.task1 = task1;
291                        this.task2 = task2;
292                }
293               
294               
295                @Override
296                public void run() {
297                        computeDistance(task1,task2);
298                }
299                private void computeDistance(ITask task1, ITask task2) {
300                        int index1 = -1;
301                        int index2 = -1;
302                        float distance = 0;
303                        ITaskInstance ti1 = null;
304                        ITaskInstance ti2 = null;
305                        // We just need to the first instance here
306                        if (task1.getInstances().size() > 0) {
307                                ti1 = (ITaskInstance) task1.getInstances().iterator()
308                                                .next();
309                        }
310                        if (task2.getInstances().size() > 0) {
311                                ti2 = (ITaskInstance) task2.getInstances().iterator()
312                                                .next();
313                        }
314                        IEventTaskInstance eti1 = null;
315                        IEventTaskInstance eti2 = null;
316
317                        if (ti1 instanceof IEventTaskInstance
318                                        && ti2 instanceof IEventTaskInstance) {
319                                eti1 = (IEventTaskInstance) ti1;
320                                index1 = getIndex(eti1);
321                                eti2 = (IEventTaskInstance) ti2;
322                                index2 = getIndex(eti2);
323                                distance = distanceBetweenInstances(eti1, eti2);
324                        } else if (ti1 instanceof IEventTaskInstance
325                                        && !(ti2 instanceof IEventTaskInstance)) {
326                                task1 = ((ITaskInstance) ti1).getTask();
327                                index2 = getIndex(task2);
328                                eti1 = (IEventTaskInstance) ti1;
329                                index1 = getIndex(eti1);
330                                distance = distanceBetweenTaskAndInstance(task2, eti1);
331                        } else if (!(ti1 instanceof IEventTaskInstance)
332                                        && ti2 instanceof IEventTaskInstance) {
333                                index1 = getIndex(task1);
334                                eti2 = (IEventTaskInstance) ti2;
335                                index2 = getIndex(eti2);
336                                distance = distanceBetweenTaskAndInstance(task1, eti2);
337                        } else if (!(ti1 instanceof IEventTaskInstance)
338                                        && !(ti2 instanceof IEventTaskInstance)) {
339                                index1 = getIndex(task1);
340                                index2 = getIndex(task2);
341                                distance = distanceBetweenTasks(task1, task2);
342                        } else {
343                                System.out.println("Unknown error");
344                        }
345                        matrix.set(index1, index2, distance);
346                        //return distance;
347                       
348                }
349               
350               
351        }
352
353}
Note: See TracBrowser for help on using the repository browser.