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

Timestamp:

06/29/14 11:11:30 (10 years ago)

Author:

rkrimmel

Message:

Multiple Alignment first version

File:

• branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/pal/tree/UPGMAAligningTree.java (modified) (8 diffs)

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.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.ObjectDistanceSubstitionMatrix;
 import de.ugoe.cs.autoquest.tasktrees.alignment.matrix.UPGMAMatrix;
 import de.ugoe.cs.autoquest.tasktrees.alignment.pal.misc.Identifier;
+import de.ugoe.cs.util.console.Console;
 
 
@@ -42 +47 @@
          * @param m distance matrix
          */
-        public UPGMAAligningTree(ArrayList<NumberSequence> numberseqs, BinaryAlignmentStorage alignments)
+        public UPGMAAligningTree(ArrayList<NumberSequence> numberseqs, BinaryAlignmentStorage alignments, ObjectDistanceSubstitionMatrix submat)
         {
                 if (alignments.getDistanceMatrix().size() < 2)
@@ -51 +56 @@
                 this.numberseqs = numberseqs;
                 this.alignments = alignments;
+                this.submat = submat;
                 init(alignments.getDistanceMatrix());
 
@@ -76 +82 @@
         private ArrayList<NumberSequence> numberseqs;
         private BinaryAlignmentStorage alignments;
+        private ObjectDistanceSubstitionMatrix submat;
         private int numClusters;
         private int besti, abi;
@@ -107 +114 @@
                         Node tmp = NodeFactory.createNode();
                         tmp.setIdentifier(new Identifier(Integer.toString(i)));
+                        tmp.setNumber(i);
                         tmp.addSequence(numberseqs.get(i));
                         getRoot().addChild(tmp);
@@ -181 +189 @@
                 
                 // Index besti now represent the new cluster
-                getRoot().joinChildren(besti, bestj);
+                Node newNode = getRoot().joinChildren(besti, bestj);
+                
+                if(newNode instanceof FengDoolittleNode) {
+                        newNode.setSequences(alignSequences(newNode));
+                }
                 
                 // Update alias
@@ -190 +202 @@
                 
                 numClusters--;
+        }
+        
+        
+        public ArrayList<NumberSequence> alignSequences(Node parent) {
+                ArrayList<NumberSequence> alignment = new ArrayList<NumberSequence>();
+                if(parent.getChildCount()<3) {
+                        
+                        Node node1 = parent.getChild(0);
+                        Node node2 = parent.getChild(1);
+                        
+                        int seqCount1 = node1.getSequences().size();
+                        int seqCount2 = node2.getSequences().size();
+                        Console.traceln(Level.INFO,"Merging node " + node1.getIdentifier() + " with " + node2.getIdentifier());
+                        //Console.println("SeqCount1: " + seqCount1 + " seqCount2 " + seqCount2);
+                        //Align 2 sequences
+                        if(seqCount1 == 1 && seqCount2 == 1) {
+                                alignment = (alignments.get(node1.getNumber(), node2.getNumber())).getAlignment();
+                        }
+                        //Align a sequence to a group
+                        else if( seqCount1 > 1 && seqCount2 == 1) {
+                                alignment.addAll(node1.getSequences());
+                                
+                                BinaryAlignmentStorage tempStorage = new BinaryAlignmentStorage(seqCount1,seqCount2);
+                                double maxScore = 0.0;
+                                int maxIndex = 0;
+                                for(int i=0;i<seqCount1;i++) {
+                                        tempStorage.set(i, 1, new SmithWatermanRepeated(node1.getSequence(i).getSequence(), node2.getSequence(0).getSequence() , submat, 5));
+                                        if(maxScore < tempStorage.get(i, 1).getAlignmentScore()) {
+                                                maxScore = tempStorage.get(i, 1).getAlignmentScore();
+                                                maxIndex = i;
+                                        }
+                                }
+                                alignment.add(tempStorage.get(maxIndex, 1).getAlignment().get(1));
+                        }
+                        //Align a sequence to a group
+                        else if(seqCount1 == 1 && seqCount2 > 1) {
+                                alignment.addAll(node2.getSequences());
+                                BinaryAlignmentStorage tempStorage = new BinaryAlignmentStorage(seqCount1,seqCount2);
+                                double maxScore = 0.0;
+                                int maxIndex = 0;
+                                for(int i=0;i<seqCount2;i++) {
+                                        tempStorage.set(1, i, new SmithWatermanRepeated(node2.getSequence(i).getSequence(), node1.getSequence(0).getSequence() , submat, 5));
+                                        if(maxScore < tempStorage.get(1, i).getAlignmentScore()) {
+                                                maxScore = tempStorage.get(1, i).getAlignmentScore();
+                                                maxIndex = i;
+                                        }
+                                }
+                                alignment.add(tempStorage.get(1,maxIndex).getAlignment().get(1));
+                        }
+                        //Align 2 groups
+                        else if((seqCount1 > 1) && (seqCount2 > 1)){
+                                        BinaryAlignmentStorage tempStorage1 = new BinaryAlignmentStorage(seqCount2,1);
+                                        BinaryAlignmentStorage tempStorage2 = new BinaryAlignmentStorage(seqCount1,1);
+                                        double maxScore1 = 0.0;
+                                        double maxScore2 = 0.0;
+                                        int maxIndex1 = 0;
+                                        int maxIndex2 = 0;
+                                        for(int i=0;i<seqCount1;i++) {
+                                                for(int j=0;j<seqCount2;j++) {
+                                                        tempStorage1.set(j, 0, new SmithWatermanRepeated(node1.getSequence(i).getSequence(), node2.getSequence(j).getSequence() , submat, 5));
+                                                        if(maxScore1 < tempStorage1.get(j, 0).getAlignmentScore()) {
+                                                                maxScore1 = tempStorage1.get(j, 0).getAlignmentScore();
+                                                                maxIndex1 = j;
+                                                        }
+                                                }
+                                                alignment.add(tempStorage1.get(maxIndex1,0).getAlignment().get(0));
+                                        }
+                                        for(int i=0; i<seqCount2;i++) {
+                                                for (int j=0;j<seqCount1;j++) {
+                                                        tempStorage2.set(j, 0, new SmithWatermanRepeated(node2.getSequence(i).getSequence(),node1.getSequence(j).getSequence(),submat,5));
+                                                        if(maxScore2 < tempStorage2.get(j, 0).getAlignmentScore()) {
+                                                                maxScore2 = tempStorage2.get(j, 0).getAlignmentScore();
+                                                                maxIndex2 = j;
+                                                        }
+                                                }
+                                                alignment.add(tempStorage2.get(maxIndex2,0).getAlignment().get(0));
+                                        }
+                                        
+                        }
+                        else {
+                                Console.traceln(Level.WARNING,"No sequences to align while merging " + node1.getIdentifier() + " with " + node2.getIdentifier());
+                        }
+                }
+                else {
+                        Console.traceln(Level.WARNING,"More than 2 children! This should never happen, it's a binary tree.");
+                }
+                return alignment;
         }
 
@@ -217 +316 @@
         }
 }
+
+