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

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

import java.util.ArrayList;
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.util.console.Console;

public class PairwiseAlignmentGenerator {

        public static PairwiseAlignmentStorage generate(
                        ArrayList<NumberSequence> numberseqs,
                        ObjectDistanceSubstitionMatrix submat, 
                        int threshold) {
                PairwiseAlignmentStorage alignments = new PairwiseAlignmentStorage(
                                numberseqs.size(), numberseqs.size());
                int smithWatermanThreshold = threshold;

                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) {
                                        Console.traceln(Level.FINEST,"Aligning sequence " + i + " with sequence " + j);
                                
                                        AlignmentAlgorithm aa = AlignmentAlgorithmFactory.create();
                                        aa.align(ns1, ns2, submat,
                                                        smithWatermanThreshold);
                                        alignments.set(i, j, aa);
                                        //TODO: This is old code used for generating pairwise distances between alignments (to build
                                        // a guide tree
                                        /*
                                        AlignmentAlgorithm sameSequence1 = AlignmentAlgorithmFactory
                                                        .create();
                                        sameSequence1.align(ns1, ns1,
                                                        submat, smithWatermanThreshold);
                                        AlignmentAlgorithm sameSequence2 = AlignmentAlgorithmFactory
                                                        .create();
                                        sameSequence2.align(ns2, ns2,
                                                        submat, smithWatermanThreshold);
                                        AlignmentAlgorithm randomSequence = AlignmentAlgorithmFactory
                                                        .create();
                                        randomSequence.align(ns1.shuffle(), ns2
                                                        .shuffle(), 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);
                                                }
                                        }
                                        */
                                }
                        }
                }
                return alignments;
        }
}