source: branches/ralph/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/PairwiseAlignmentGenerator.java @ 1594

package de.ugoe.cs.autoquest.tasktrees.alignment.matrix;

import java.util.ArrayList;
import java.util.Iterator;

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;

public class PairwiseAlignmentGenerator {


        public static PairwiseAlignmentStorage generate(ArrayList<NumberSequence> numberseqs,ObjectDistanceSubstitionMatrix submat) {
                PairwiseAlignmentStorage alignments = new PairwiseAlignmentStorage(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();
                                        if(score > 0) {
                                                System.out.println();
                                                //alignments.get(i, j).printAlignment();
                                                ArrayList<ArrayList<NumberSequence>> matches = alignments.get(i, j).getMatches();
                                                int count = 0;
                                                for(Iterator<ArrayList<NumberSequence>> it = matches.iterator();it.hasNext();) {
                                                        System.out.println("Match number" + count); 
                                                        ArrayList<NumberSequence> tmp = it.next();
                                                        tmp.get(0).printSequence();
                                                        tmp.get(1).printSequence();
                                                        System.out.println();
                                                        count++;
                                                }
                                                System.out.println();
                                        }
                                        // 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 );
                                                }
                                        }
                                }
                        }
                }
                return alignments;      
    }
}