Changeset 1589 for branches/ralph

Timestamp:

07/09/14 12:13:13 (10 years ago)

Author:

rkrimmel

Message:

Refactoring and code cleanup

Location:

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees

Files:

• alignment/algorithms/AlignmentAlgorithmFactory.java (modified) (1 diff)
• alignment/algorithms/SmithWatermanRepeated.java (modified) (2 diffs)
• alignment/matrix/PairwiseAlignmentGenerator.java (added)
• alignment/matrix/PairwiseAlignmentStorage.java (moved) (moved from branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/BinaryAlignmentStorage.java) (1 diff)
• alignment/pal/tree/UPGMAAligningTree.java (modified) (8 diffs)
• temporalrelation/SequenceForTaskDetectionRuleAlignment.java (modified) (2 diffs)

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/algorithms/AlignmentAlgorithmFactory.java

@@ -9 +9 @@
                 
                 //return new SmithWaterman(input1,input2,submat,threshold);
-                return new NeedlemanWunsch(input1,input2,submat,threshold);
-                //return new SmithWatermanRepeated(input1,input2,submat,threshold);
+                //return new NeedlemanWunsch(input1,input2,submat,threshold);
+                return new SmithWatermanRepeated(input1,input2,submat,threshold);
         }
 }

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/algorithms/SmithWatermanRepeated.java

@@ -2 +2 @@
 
 import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.logging.Level;
 
@@ -216 +218 @@
         }
 
-        
-        
         public void traceback() {
                 MatrixEntry tmp = matrix[length1+1][0];
-                int aligned1[] = new int[length1+1+length2+2];
-                int aligned2[] = new int[length1+1+length2+2];
+                LinkedList<Integer> aligned1 = new LinkedList<Integer>();
+                LinkedList<Integer> aligned2 = new LinkedList<Integer>();
+                do {
+                        
+                        aligned1.add(new Integer(tmp.getXvalue()));
+                        aligned2.add(new Integer(tmp.getYvalue()));
+
+                        tmp = tmp.getPrevious();
+
+                } while (tmp != null);
+                
+                // reverse order of the alignment
+                int reversed1[] = new int[aligned1.size()];
+                int reversed2[] = new int[aligned2.size()];
+
                 int count = 0;
-                do
-                {       
-                        if(count != 0)
-                        {
-                                if (length1+1+length2+2 == count) {     
-                                        Console.traceln(Level.WARNING, "Traceback longer than both sequences summed up!");
-                                        break;
-                                }
-                                aligned1[count] = tmp.getXvalue();
-                                aligned2[count] = tmp.getYvalue();
-                        }
-                        
-                        tmp = tmp.getPrevious();
+                for (Iterator<Integer> it = aligned1.descendingIterator(); it.hasNext();) {
                         count++;
-                
-                } while(tmp != null);
-                count--;
-                //reverse order of the alignment
-                int reversed1[] = new int[count];
-                int reversed2[] = new int[count];
-                
-                
-                for(int i = count-1; i > 0; i--) {
-                        reversed1[reversed1.length-i]= aligned1[i];
-                        reversed2[reversed2.length-i]= aligned2[i];
-                }
-                
+                        reversed1[reversed1.length - count] = it.next();
+                        
+                }
+                count = 0;
+                for (Iterator<Integer> it = aligned2.descendingIterator(); it.hasNext();) {
+                        count++;
+                        reversed2[reversed2.length - count] = it.next();
+                }
+
                 NumberSequence ns1 = new NumberSequence(reversed1.length);
                 NumberSequence ns2 = new NumberSequence(reversed2.length);
                 ns1.setSequence(reversed1);
                 ns2.setSequence(reversed2);
-                
+
                 alignment.add(ns1);
                 alignment.add(ns2);
         }
+        
+
         
         public void printAlignment() {

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/PairwiseAlignmentStorage.java

@@ -1 +1 @@
 package de.ugoe.cs.autoquest.tasktrees.alignment.matrix;
+
+
 
 
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm;
 
-public class BinaryAlignmentStorage {
+
+public class PairwiseAlignmentStorage {
 
     private AlignmentAlgorithm[][] alignments;
-    UPGMAMatrix sequenceDistances;
+    private UPGMAMatrix sequenceDistances;
    
-    public BinaryAlignmentStorage(int sizex, int sizey) {
+    public PairwiseAlignmentStorage(int sizex, int sizey) {
         alignments = new AlignmentAlgorithm[sizex+1][sizey+1];
         sequenceDistances = new UPGMAMatrix(Math.max(sizex,sizey));
         sequenceDistances.initialize(Double.POSITIVE_INFINITY);
     }
+ 
+    
     
     public void set(int i,int j,AlignmentAlgorithm sw) {

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/pal/tree/UPGMAAligningTree.java

@@ -15 +15 @@
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.logging.Level;
 
-import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithm;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithmFactory;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.NumberSequence;
-import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.SmithWatermanRepeated;
-import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.BinaryAlignmentStorage;
+import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.PairwiseAlignmentStorage;
 import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.ObjectDistanceSubstitionMatrix;
 import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.UPGMAMatrix;
@@ -48 +47 @@
          * @param m distance matrix
          */
-        public UPGMAAligningTree(ArrayList<NumberSequence> numberseqs, BinaryAlignmentStorage alignments, ObjectDistanceSubstitionMatrix submat)
+        public UPGMAAligningTree(ArrayList<NumberSequence> numberseqs, PairwiseAlignmentStorage alignments, ObjectDistanceSubstitionMatrix submat)
         {
                 if (alignments.getDistanceMatrix().size() < 2)
@@ -82 +81 @@
         //
         private ArrayList<NumberSequence> numberseqs;
-        private BinaryAlignmentStorage alignments;
+        private PairwiseAlignmentStorage alignments;
         private ObjectDistanceSubstitionMatrix submat;
         private int numClusters;
@@ -216 +215 @@
                         int seqCount1 = node1.getSequences().size();
                         int seqCount2 = node2.getSequences().size();
-                        
-                        /*
-                        for(int i = 0; i < seqCount1; i++) {
-                                for(int j = 0; j < seqCount2; j++) {
-                                        node1.getSequence(i).printSequence();
-                                        node2.getSequence(j).printSequence();
-                                }
-                        }
-                        */
+
                         
                         Console.traceln(Level.INFO,"Merging node " + node1.getIdentifier() + " with " + node2.getIdentifier());
@@ -237 +228 @@
                                 alignment.addAll(node1.getSequences());
                                 
-                                BinaryAlignmentStorage tempStorage = new BinaryAlignmentStorage(seqCount1,seqCount2);
+                                PairwiseAlignmentStorage tempStorage = new PairwiseAlignmentStorage(seqCount1,seqCount2);
                                 double maxScore = 0.0;
                                 int maxIndex = 0;
@@ -254 +245 @@
                         else if(seqCount1 == 1 && seqCount2 > 1) {
                                 alignment.addAll(node2.getSequences());
-                                BinaryAlignmentStorage tempStorage = new BinaryAlignmentStorage(seqCount1,seqCount2);
+                                PairwiseAlignmentStorage tempStorage = new PairwiseAlignmentStorage(seqCount1,seqCount2);
                                 double maxScore = 0.0;
                                 int maxIndex = 0;
@@ -270 +261 @@
                         //Align 2 groups
                         else if((seqCount1 > 1) && (seqCount2 > 1)){
-                                        BinaryAlignmentStorage tempStorage1 = new BinaryAlignmentStorage(seqCount2,1);
-                                        BinaryAlignmentStorage tempStorage2 = new BinaryAlignmentStorage(seqCount1,1);
+                                        PairwiseAlignmentStorage tempStorage1 = new PairwiseAlignmentStorage(seqCount2,1);
+                                        PairwiseAlignmentStorage tempStorage2 = new PairwiseAlignmentStorage(seqCount1,1);
                                         double maxScore1 = 0.0;
                                         double maxScore2 = 0.0;
@@ -334 +325 @@
                         (oc[aj]/ocsum)*jdist;
         }
+
+
+        public void printMultipleAlignment() {
+                for (Iterator<NumberSequence> it =  getRoot().getSequences().iterator(); it.hasNext();) {
+                        NumberSequence tmp  = it.next();
+                        tmp.printSequence();
+                }
+        }
 }
 

branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleAlignment.java

@@ -29 +29 @@
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentAlgorithmFactory;
 import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.NumberSequence;
-import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.BinaryAlignmentStorage;
+import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.PairwiseAlignmentGenerator;
+import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.PairwiseAlignmentStorage;
 import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.ObjectDistanceSubstitionMatrix;
 import de.ugoe.cs.autoquest.tasktrees.alignment.pal.tree.UPGMAAligningTree;
@@ -158 +159 @@
                 submat.generate();
 
+                
+                PairwiseAlignmentStorage alignments = PairwiseAlignmentGenerator.generate(numberseqs,submat);
         
-                BinaryAlignmentStorage alignments = new BinaryAlignmentStorage(numberseqs.size(),numberseqs.size());
-
-
-                for (int i = 0; i < numberseqs.size(); i++) {
-                        NumberSequence ns1 = numberseqs.get(i);
-                        for (int j = 0; j < numberseqs.size(); j++) {
-                                NumberSequence ns2 = numberseqs.get(j);
-
-                                if (i != j) {
-                                        int smithWatermanThreshold = 10;
-
-                                        alignments.set(i, j,AlignmentAlgorithmFactory.create(
-                                                        ns1.getSequence(), ns2.getSequence(), submat,
-                                                        smithWatermanThreshold));
-                                        AlignmentAlgorithm sameSequence1 = AlignmentAlgorithmFactory.create(
-                                                        ns1.getSequence(), ns1.getSequence(), submat,
-                                                        smithWatermanThreshold);
-                                        AlignmentAlgorithm sameSequence2 = AlignmentAlgorithmFactory.create(
-                                                        ns2.getSequence(), ns2.getSequence(), submat,
-                                                        smithWatermanThreshold);
-                                        AlignmentAlgorithm randomSequence = AlignmentAlgorithmFactory.create(
-                                                        ns1.shuffle().getSequence(),ns2.shuffle().getSequence(),submat,smithWatermanThreshold);
-                                        
-                                        // Score of the aligmnment
-                                        double score = alignments.get(i,j).getAlignmentScore();
-                                        // Scores of the sequence being aligned to itself (maximum score)
-                                        double sSelf1 = sameSequence1.getAlignmentScore();
-                                        double sSelf2 = sameSequence2.getAlignmentScore();
-                                        // Score of sequences shuffled before aligned  
-                                        double sRand = randomSequence.getAlignmentScore();
-
-                                        double sMax = (sSelf1 + sSelf2) / 2;
-                                        double sEff = (score - sRand)/ (sMax - sRand);
-                                        if(sEff < 0) {
-                                                sEff = 0;
-                                        }
-                                        double distance = -Math.log(sEff);
-                                        
-                                        
-                                        if(!Double.isInfinite(distance) && !Double.isNaN(distance)) {
-                                                if(distance < alignments.getDistance(i, j)) {   
-                                                        alignments.setDistance(i,j,distance );
-                                                }
-                                        }
-                                }
-                        }
-                }
-                //alignments.get(20, 47).printDPMatrix();
-                //alignments.get(20, 47).printAlignment();
                 
                 System.out.println(alignments.getDistanceMatrix());
-                UPGMAAligningTree guidetree = new UPGMAAligningTree(numberseqs, alignments,submat);
-                System.out.println("Number of sequences in root node: " + guidetree.getRoot().getSequences().size());
-                for (Iterator<NumberSequence> it =  guidetree.getRoot().getSequences().iterator(); it.hasNext();) {
-                        NumberSequence tmp  = it.next();
-                        tmp.printSequence();
-                }
+                //UPGMAAligningTree guidetree = new UPGMAAligningTree(numberseqs, alignments,submat);
+                
+