Index: /branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java
===================================================================
--- /branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java	(revision 1720)
+++ /branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java	(revision 1721)
@@ -23,4 +23,5 @@
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
@@ -32,4 +33,8 @@
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 
@@ -77,6 +82,7 @@
 public class SequenceForTaskDetectionRuleAlignment implements ISessionScopeRule {
 	
-	
-
+	public static int nThreads = Runtime.getRuntime().availableProcessors()-1;
+
+	
 	private int iteration = 0;
 	/**
@@ -94,4 +100,5 @@
 	 */
 	private ITaskBuilder taskBuilder;
+	
 
 	/**
@@ -649,6 +656,6 @@
 		
 		// Generate pairwise alignments
-		int size = appData.getNumberSequences().size();
-		Console.traceln(Level.INFO, "generating pairwise alignments from " + size + " sessions");
+		int numberSeqSize = appData.getNumberSequences().size();
+		Console.traceln(Level.INFO, "generating pairwise alignments from " + numberSeqSize + " sessions");
 		int count = 0;
 		
@@ -657,18 +664,8 @@
 		if(!(aligned.exists() && !aligned.isDirectory())) {
 			appData.matchseqs = new LinkedList<Match>();
-			System.out.println(appData.matchseqs);
 			for (int i = 0; i < appData.getNumberSequences().size(); i++) {
 				NumberSequence ns1 = appData.getNumberSequences().get(i);
 				count++;
-				
-				//Print out the progress
-				if(size>100) {
-					if((count%(size/100)==0)) {	
-						Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-					}
-				}
-				else {
-					Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-				}
+				printProgressPercentage(count,numberSeqSize);
 				for (int j = 0; j < appData.getNumberSequences().size(); j++) {
 					NumberSequence ns2 = appData.getNumberSequences().get(j);
@@ -690,45 +687,34 @@
 
 
-		Console.traceln(Level.INFO, "searching for patterns occuring most");
-		
-		count = 0;
-		size=appData.getMatchseqs().size();
-		Console.traceln(Level.INFO, "Pattern count is " + size);
-		// search each match in every other sequence
-		for (Iterator<Match> it = appData.getMatchseqs().iterator(); it.hasNext();) {
-			Match pattern = it.next();
-			count++;
-			//Print out the progress
-			if(size>100) {
-				if((count%(size/100)==0)) {	
-					Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-				}
-			}
-			else {
-				Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
-			}
-			// Skip sequences with more 0 events (scrolls) than other events.
-			// Both of the pattern sequences are equally long, so the zero
-			// counts just need to be smaller than the length of one sequence
-			if (pattern.getFirstSequence().eventCount(0)
-					+ pattern.getSecondSequence().eventCount(0) + 1 > pattern
-					.getFirstSequence().size())
-				continue;
-
-			for (int j = 0; j < appData.getNumberSequences().size(); j++) {
-				LinkedList<Integer> startpositions = appData
-						.getNumberSequences().get(j).containsPattern(pattern);
-				if (startpositions.size() > 0) {
-					for (Iterator<Integer> jt = startpositions.iterator(); jt
-							.hasNext();) {
-						int start = jt.next();
-						pattern.addOccurence(new MatchOccurence(start, start
-								+ pattern.size(), j));
-					}
-
-				}
-			}
-		}
-
+		Console.traceln(Level.INFO, "searching for patterns occuring most with " + nThreads + " threads");
+		
+		//Prepare parallel search of matchseqs
+		ExecutorService executor = Executors.newFixedThreadPool(nThreads);
+		int matchSeqSize=appData.getMatchseqs().size();
+		int interval = Math.round(matchSeqSize/nThreads);
+		int rest = matchSeqSize % nThreads;
+		
+		for(int i =0;i<matchSeqSize-interval;i+=interval) {
+			int offset =0;
+			if(rest!=0) {
+				offset=1;
+				rest--;
+			}
+			int from = i;
+			int to = i+interval+offset;
+			System.out.println("Creating thread with matches from " + from + " to " + to);
+			// search each match in every other sequence
+			ParallelMatchOcurrencesFinder finder = new ParallelMatchOcurrencesFinder(appData,from,to);
+			executor.execute(finder);
+		}
+		executor.shutdown();
+		try {
+			executor.awaitTermination(2, TimeUnit.HOURS);
+		} catch (InterruptedException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+		
 		Console.traceln(Level.INFO, "sorting results");
 		// Sort results to get the most occurring results
@@ -839,4 +825,69 @@
 		appData.getStopWatch().stop("replacing tasks");
 	}
+	
+	
+	//Print out the progress
+	 private static void printProgressPercentage(int count, int size) {
+		
+		if(size>100) {
+			if((count%(size/100)==0)) {	
+				Console.traceln(Level.INFO,("Thread" + Thread.currentThread().getName() + ": " + Math.round((float) count/size*100))+ "%");
+			}
+		}
+		else {
+			Console.traceln(Level.INFO,("Thread" + Thread.currentThread().getName() + ": " +Math.round((float) count/size*100))+ "%");
+		}
+	}
+	
+	 
+	 
+	
+	private class ParallelMatchOcurrencesFinder implements Runnable {
+        private final RuleApplicationData appData;
+        private final int from;
+        private final int to;
+            ParallelMatchOcurrencesFinder(RuleApplicationData appData, int from, int to) {
+            this.appData = appData;
+            this.from = from;
+            this.to = to;
+        }
+        
+        @Override
+        public void run() {
+        	int count = 0;
+    		int size=to-from;
+    		Console.traceln(Level.INFO, "Pattern count is " + size);
+    		for (int i=from; i<to;i++) { {
+    			Match pattern = appData.getMatchseqs().get(i);
+    			count++;
+    			printProgressPercentage(count,size);
+    			// Skip sequences with more 0 events (scrolls) than other events.
+    			// Both of the pattern sequences are equally long, so the zero
+    			// counts just need to be smaller than the length of one sequence
+    			if (pattern.getFirstSequence().eventCount(0)
+    					+ pattern.getSecondSequence().eventCount(0) + 1 > pattern
+    					.getFirstSequence().size())
+    				continue;
+
+    			for (int j = 0; j < appData.getNumberSequences().size(); j++) {
+    				LinkedList<Integer> startpositions = appData
+    						.getNumberSequences().get(j).containsPattern(pattern);
+    				if (startpositions.size() > 0) {
+    					for (Iterator<Integer> jt = startpositions.iterator(); jt
+    							.hasNext();) {
+    						int start = jt.next();
+    						pattern.addOccurence(new MatchOccurence(start, start
+    								+ pattern.size(), j));
+    					}
+
+    				}
+    			}
+    		}  
+    	}
+        }
+	}
+	
+	
+
 
 	/**
@@ -895,5 +946,6 @@
 			submat= new ObjectDistanceSubstitionMatrix(6,-3,false);
 			newTasks = new LinkedList<ITask>();
-			this.detectedAndReplacedTasks = true;
+			
+			//this.detectedAndReplacedTasks = true;
 		}