void copyFromTopAlignment(AlignmentConstPtr topAlignment,
AlignmentPtr mainAlignment, const string &genomeName)
{
Genome *mainReplacedGenome = mainAlignment->openGenome(genomeName);
const Genome *topReplacedGenome = topAlignment->openGenome(genomeName);
topReplacedGenome->copyTopDimensions(mainReplacedGenome);
topReplacedGenome->copyTopSegments(mainReplacedGenome);
mainReplacedGenome->fixParseInfo();
// Copy bot segments for the parent and top segments for the
// siblings of the genome that's being replaced
Genome *mainParent = mainReplacedGenome->getParent();
const Genome *topParent = topReplacedGenome->getParent();
topParent->copyBottomDimensions(mainParent);
topParent->copyBottomSegments(mainParent);
mainParent->fixParseInfo();
vector<string> siblings = mainAlignment->getChildNames(mainParent->getName());
for (size_t i = 0; i < siblings.size(); i++)
{
if (siblings[i] != genomeName)
{
Genome *mainChild = mainAlignment->openGenome(siblings[i]);
const Genome *topChild = topAlignment->openGenome(siblings[i]);
topChild->copyTopDimensions(mainChild);
topChild->copyTopSegments(mainChild);
mainChild->fixParseInfo();
}
}
}
void MappedSegmentMapAcrossTest::testTopSegment(AlignmentConstPtr alignment,
TopSegmentIteratorConstPtr top)
{
const Genome* parent = top->getGenome()->getParent();
const Genome* other = top->getGenome()->getName() == "child1" ?
alignment->openGenome("child2") : alignment->openGenome("child1");
set<MappedSegmentConstPtr> results;
top->getMappedSegments(results, other, NULL, false);
CuAssertTrue(_testCase, results.size() == 1);
MappedSegmentConstPtr mseg = *results.begin();
CuAssertTrue(_testCase, mseg->getSource()->getGenome() == top->getGenome());
CuAssertTrue(_testCase, mseg->getSource()->getStartPosition() ==
top->getStartPosition());
CuAssertTrue(_testCase,
mseg->getSource()->getLength() == top->getLength());
CuAssertTrue(_testCase,
mseg->getSource()->getReversed() == top->getReversed());
BottomSegmentIteratorConstPtr bottom = parent->getBottomSegmentIterator();
bottom->toParent(top);
TopSegmentIteratorConstPtr sister = other->getTopSegmentIterator();
sister->toChildG(bottom, other);
CuAssertTrue(_testCase, mseg->getGenome() == sister->getGenome());
CuAssertTrue(_testCase,
mseg->getStartPosition() == sister->getStartPosition());
CuAssertTrue(_testCase,
mseg->getLength() == sister->getLength());
CuAssertTrue(_testCase,
mseg->getReversed() == sister->getReversed());
}
void TopSegmentIteratorReverseTest::checkCallBack(AlignmentConstPtr alignment)
{
BottomSegmentIteratorConstPtr bi;
TopSegmentIteratorConstPtr ti, ti2;
const Genome* parent1 = alignment->openGenome("parent1");
const Genome* child1 = alignment->openGenome("child1");
ti = child1->getTopSegmentIterator();
bi = parent1->getBottomSegmentIterator();
ti2 = child1->getTopSegmentIterator();
ti2->toChild(bi, 0);
CuAssertTrue(_testCase, ti->getStartPosition() == 0);
CuAssertTrue(_testCase, ti->getLength() == 10);
CuAssertTrue(_testCase, ti->getReversed() == false);
CuAssertTrue(_testCase, ti2->getStartPosition() == 9);
CuAssertTrue(_testCase, ti2->getLength() == 10);
CuAssertTrue(_testCase, ti2->getReversed() == true);
bi->slice(1, 3);
ti2->toChild(bi, 0);
CuAssertTrue(_testCase, bi->getStartPosition() == 1);
CuAssertTrue(_testCase, bi->getLength() == 6);
CuAssertTrue(_testCase, ti2->getStartPosition() == 8);
CuAssertTrue(_testCase, ti2->getLength() == 6);
string buffer;
bi->getString(buffer);
CuAssertTrue(_testCase, buffer == "CCTACG");
ti2->getString(buffer);
CuAssertTrue(_testCase, buffer == "CACGTA");
bi = child1->getBottomSegmentIterator();
CuAssertTrue(_testCase, bi->getReversed() == false);
ti->toParseUp(bi);
CuAssertTrue(_testCase, ti->getStartPosition() == 0);
CuAssertTrue(_testCase, ti->getLength() == 5);
bi->toReverse();
ti->toParseUp(bi);
CuAssertTrue(_testCase, ti->getStartPosition() == 4);
CuAssertTrue(_testCase, ti->getLength() == 5);
bi->toReverse();
CuAssertTrue(_testCase, bi->getReversed() == false);
bi->toRight();
ti->toParseUp(bi);
CuAssertTrue(_testCase, ti->getStartPosition() == 5);
CuAssertTrue(_testCase, ti->getLength() == 5);
bi->toReverse();
ti->toParseUp(bi);
CuAssertTrue(_testCase, ti->getStartPosition() == 9);
CuAssertTrue(_testCase, ti->getLength() == 5);
}
void GenomeCreateTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* dudGenome = alignment->openGenome("Zebra");
CuAssertTrue(_testCase, dudGenome == NULL);
const Genome* ancGenome = alignment->openGenome("AncGenome");
const MetaData* ancMeta = ancGenome->getMetaData();
CuAssertTrue(_testCase, ancMeta->get("Young") == "Jeezy");
const Genome* leaf1Genome = alignment->openGenome("Leaf1");
const Genome* leaf2Genome = alignment->openGenome("Leaf2");
const Genome* leaf3Genome = alignment->openGenome("Leaf3");
CuAssertTrue(_testCase, ancGenome->getName() == "AncGenome");
CuAssertTrue(_testCase, leaf1Genome->getName() == "Leaf1");
CuAssertTrue(_testCase, leaf2Genome->getName() == "Leaf2");
CuAssertTrue(_testCase, leaf3Genome->getName() == "Leaf3");
CuAssertTrue(_testCase, ancGenome->getSequenceLength() == 1000000);
CuAssertTrue(_testCase, ancGenome->getNumTopSegments() == 5000);
CuAssertTrue(_testCase, ancGenome->getNumBottomSegments() == 700000);
CuAssertTrue(_testCase, leaf1Genome->getSequenceLength() == 1000000);
CuAssertTrue(_testCase, leaf1Genome->getNumTopSegments() == 700000);
CuAssertTrue(_testCase, leaf1Genome->getNumBottomSegments() == 0);
CuAssertTrue(_testCase, leaf2Genome->getSequenceLength() == 2000000);
CuAssertTrue(_testCase, leaf2Genome->getNumTopSegments() == 700000);
CuAssertTrue(_testCase, leaf2Genome->getNumBottomSegments() == 0);
CuAssertTrue(_testCase, leaf3Genome->getSequenceLength() == 3000000);
CuAssertTrue(_testCase, leaf3Genome->getNumTopSegments() == 700000);
CuAssertTrue(_testCase, leaf3Genome->getNumBottomSegments() == 0);
}
static void printBranches(ostream& os, AlignmentConstPtr alignment)
{
const Genome* root = alignment->openGenome(alignment->getRootName());
set<const Genome*> genomes;
getGenomesInSubTree(root, genomes);
genomes.insert(root);
bool first = true;
for (set<const Genome*>::iterator i = genomes.begin(); i != genomes.end();
++i)
{
if ((*i)->getParent() != NULL)
{
if (!first)
{
os << " ";
}
else
{
first = false;
}
os << (*i)->getName();
}
}
os << endl;
}
void MappedSegmentColCompareTest::checkCallBack(AlignmentConstPtr alignment)
{
if (alignment->getNumGenomes() == 0)
{
return;
}
validateAlignment(alignment);
set<const Genome*> genomeSet;
hal::getGenomesInSubTree(alignment->openGenome(alignment->getRootName()),
genomeSet);
for (set<const Genome*>::iterator i = genomeSet.begin(); i != genomeSet.end();
++i)
{
const Genome* srcGenome = *i;
for (set<const Genome*>::iterator j = genomeSet.begin();
j != genomeSet.end(); ++j)
{
const Genome* tgtGenome = *j;
if (srcGenome->getSequenceLength() > 0 &&
tgtGenome->getSequenceLength() > 0)
{
_ref = srcGenome;
_tgt = tgtGenome;
createColArray();
createBlockArray();
compareArrays();
}
}
}
}
void MappedSegmentMapUpTest::checkCallBack(AlignmentConstPtr alignment)
{
validateAlignment(alignment);
const Genome* child1 = alignment->openGenome("child1");
const Genome* child2 = alignment->openGenome("child2");
TopSegmentIteratorConstPtr top = child2->getTopSegmentIterator();
testTopSegment(alignment, top, "parent");
top->slice(1,2);
testTopSegment(alignment, top, "parent");
top->toReverse();
testTopSegment(alignment, top, "parent");
top = child1->getTopSegmentIterator();
testTopSegment(alignment, top, "parent");
top->slice(1,2);
testTopSegment(alignment, top, "parent");
top->toReverse();
testTopSegment(alignment, top, "parent");
const Genome* g1 = alignment->openGenome("g1");
for (hal_size_t i = 0; i < g1->getNumTopSegments(); ++i)
{
top = g1->getTopSegmentIterator(i);
testTopSegment(alignment, top, "parent");
top->slice(1,0);
testTopSegment(alignment, top, "parent");
top->toReverse();
testTopSegment(alignment, top, "parent");
top->slice(0,1);
testTopSegment(alignment, top, "parent");
top->toReverse();
testTopSegment(alignment, top, "parent");
}
}
void printParent(ostream& os, AlignmentConstPtr alignment,
const string& genomeName)
{
if (genomeName != alignment->getRootName())
{
os << alignment->getParentName(genomeName) << endl;
}
}
void printBranchLength(ostream& os, AlignmentConstPtr alignment,
const string& genomeName)
{
if (genomeName != alignment->getRootName())
{
string parentName = alignment->getParentName(genomeName);
os << alignment->getBranchLength(parentName, genomeName) << endl;
}
}
void TopSegmentIteratorToSiteTest::checkCallBack(AlignmentConstPtr alignment)
{
TopSegmentIteratorConstPtr bi;
// case 1
const Genome* case1 = alignment->openGenome("case1");
checkGenome(case1);
// case 2
const Genome* case2 = alignment->openGenome("case2");
checkGenome(case2);
}
void TopSegmentIteratorParseTest::checkCallBack(AlignmentConstPtr alignment)
{
BottomSegmentIteratorConstPtr bi;
TopSegmentIteratorConstPtr ti;
// case 1
const Genome* case1 = alignment->openGenome("case1");
ti = case1->getTopSegmentIterator();
bi = case1->getBottomSegmentIterator();
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
CuAssertTrue(_testCase, bi->getLength() == ti->getLength());
bi->slice(3, 1);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getLength() ==
bi->getBottomSegment()->getLength() - 4);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
CuAssertTrue(_testCase, bi->getLength() == ti->getLength());
// case 2
const Genome* case2 = alignment->openGenome("case2");
ti = case2->getTopSegmentIterator();
bi = case2->getBottomSegmentIterator(1);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
bi->slice(1, 1);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
// case 3
const Genome* case3 = alignment->openGenome("case3");
ti = case3->getTopSegmentIterator();
bi = case3->getBottomSegmentIterator();
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
bi->slice(2, 1);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
// case 4
const Genome* case4 = alignment->openGenome("case4");
ti = case4->getTopSegmentIterator();
bi = case4->getBottomSegmentIterator(1);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
bi->slice(2, 2);
ti->toParseUp(bi);
CuAssertTrue(_testCase, bi->getStartPosition() == ti->getStartPosition());
}
void MappedSegmentMapUpTest::testTopSegment(AlignmentConstPtr alignment,
TopSegmentIteratorConstPtr top,
const string& ancName)
{
const Genome* parent = alignment->openGenome(ancName);
set<MappedSegmentConstPtr> results;
top->getMappedSegments(results, parent, NULL, false);
CuAssertTrue(_testCase, results.size() == 1);
MappedSegmentConstPtr mseg = *results.begin();
CuAssertTrue(_testCase, mseg->getSource()->getGenome() == top->getGenome());
CuAssertTrue(_testCase, mseg->getSource()->getStartPosition() ==
top->getStartPosition());
CuAssertTrue(_testCase,
mseg->getSource()->getLength() == top->getLength());
CuAssertTrue(_testCase,
mseg->getSource()->getReversed() == top->getReversed());
BottomSegmentIteratorConstPtr bottom = parent->getBottomSegmentIterator();
bottom->toParent(top);
// extra hop for when top is in grand child
if (bottom->getGenome() != parent)
{
TopSegmentIteratorConstPtr temp =
bottom->getGenome()->getTopSegmentIterator();
temp->toParseUp(bottom);
bottom->toParent(temp);
}
CuAssertTrue(_testCase, mseg->getGenome() == bottom->getGenome());
CuAssertTrue(_testCase,
mseg->getStartPosition() == bottom->getStartPosition());
CuAssertTrue(_testCase,
mseg->getLength() == bottom->getLength());
CuAssertTrue(_testCase,
mseg->getReversed() == bottom->getReversed());
}
void GenomeUpdateTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* ancGenome = alignment->openGenome("AncGenome");
CuAssertTrue(_testCase, ancGenome->getName() == "AncGenome");
CuAssertTrue(_testCase, ancGenome->getSequenceLength() == 10000005);
CuAssertTrue(_testCase, ancGenome->getNumTopSegments() == 14000);
CuAssertTrue(_testCase, ancGenome->getNumBottomSegments() == 2000001);
}
void printGenomes(ostream& os, AlignmentConstPtr alignment)
{
const Genome* root = alignment->openGenome(alignment->getRootName());
set<const Genome*> genomes;
getGenomesInSubTree(root, genomes);
genomes.insert(root);
for (set<const Genome*>::iterator i = genomes.begin(); i != genomes.end();
++i)
{
if (i != genomes.begin())
{
os << ",";
}
os << (*i)->getName();
}
os << endl;
}
void GenomeStringTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* ancGenome = alignment->openGenome("AncGenome");
CuAssertTrue(_testCase, ancGenome->getName() == "AncGenome");
string genomeString;
ancGenome->getString(genomeString);
CuAssertTrue(_testCase, genomeString == _string);
}
void GenomeMetaTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* ancGenome = alignment->openGenome("AncGenome");
const MetaData* ancMeta = ancGenome->getMetaData();
CuAssertTrue(_testCase, ancMeta->get("Young") == "Jeezy");
CuAssertTrue(_testCase, ancGenome->getSequenceLength() == 0);
CuAssertTrue(_testCase, ancGenome->getNumTopSegments() == 0);
CuAssertTrue(_testCase, ancGenome->getNumBottomSegments() == 0);
CuAssertTrue(_testCase, ancGenome->getName() == "AncGenome");
}
void MappedSegmentParseTest::checkCallBack(AlignmentConstPtr alignment)
{
validateAlignment(alignment);
const Genome* g1 = alignment->openGenome("g1");
const Genome* g2 = alignment->openGenome("g2");
const Genome* g3 = alignment->openGenome("g3");
const Genome* g4 = alignment->openGenome("g4");
const Genome* g5 = alignment->openGenome("g5");
const Genome* gs[] = {g1, g2, g3, g4, g5};
for (size_t i = 0; i < 5; ++i)
{
const Genome* g = gs[i];
for (size_t j = 0; j < g->getNumTopSegments(); ++j)
{
TopSegmentIteratorConstPtr top = g->getTopSegmentIterator(j);
testTopSegment(alignment, top);
}
}
}
void printNumSegments(ostream& os, AlignmentConstPtr alignment,
const string& genomeName)
{
const Genome* genome = alignment->openGenome(genomeName);
if (genome == NULL)
{
throw hal_exception(string("Genome ") + genomeName + " not found.");
}
os << genome->getNumTopSegments() << " " << genome->getNumBottomSegments()
<< endl;
}
void LodManager::checkAlignment(hal_size_t minQuery,
const string& path,
AlignmentConstPtr alignment)
{
if (alignment->getNumGenomes() == 0)
{
stringstream ss;
ss << "No genomes found in base alignment specified in " << path;
throw hal_exception(ss.str());
}
#ifndef NDEBUG
if (minQuery == 0)
{
vector<string> leafNames = alignment->getLeafNamesBelow(
alignment->getRootName());
string name = !leafNames.empty() ? leafNames[0] : alignment->getRootName();
const Genome* genome = alignment->openGenome(name);
bool seqFound = genome->containsDNAArray();
alignment->closeGenome(genome);
if (seqFound == false)
{
stringstream ss;
ss << "HAL file for highest level of detail (0) in " << path
<< "must contain DNA sequence information.";
throw hal_exception(ss.str());
}
}
#endif
}
void TopSegmentSequenceTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* ancGenome = alignment->openGenome("Anc0");
TopSegmentIteratorConstPtr tsIt = ancGenome->getTopSegmentIterator(100);
CuAssertTrue(_testCase, tsIt->getTopSegment()->getStartPosition() == 500);
CuAssertTrue(_testCase, tsIt->getTopSegment()->getLength() == 9);
string seq;
tsIt->getString(seq);
CuAssertTrue(_testCase, seq == "CACACATTC");
tsIt->toReverse();
tsIt->getString(seq);
CuAssertTrue(_testCase, seq == "GAATGTGTG");
}
void printChildren(ostream& os, AlignmentConstPtr alignment,
const string& genomeName)
{
vector<string> children = alignment->getChildNames(genomeName);
for (size_t i = 0; i < children.size(); ++i)
{
os << children[i];
if (i != children.size() - 1)
{
os << " ";
}
}
os << endl;
}
void hal::validateAlignment(AlignmentConstPtr alignment)
{
deque<string> bfQueue;
bfQueue.push_back(alignment->getRootName());
while (bfQueue.empty() == false)
{
string name = bfQueue.back();
bfQueue.pop_back();
if (name.empty() == false)
{
const Genome* genome = alignment->openGenome(name);
if (genome == NULL)
{
throw hal_exception("Failure to open genome " + name);
}
validateGenome(genome);
vector<string> childNames = alignment->getChildNames(name);
for (size_t i = 0; i < childNames.size(); ++i)
{
bfQueue.push_front(childNames[i]);
}
}
}
}
void copyFromBottomAlignment(AlignmentConstPtr bottomAlignment,
AlignmentPtr mainAlignment,
const string &genomeName)
{
// Copy genome & bottom segments for the genome that's being replaced
Genome *mainReplacedGenome = mainAlignment->openGenome(genomeName);
const Genome *botReplacedGenome = bottomAlignment->openGenome(genomeName);
botReplacedGenome->copyDimensions(mainReplacedGenome);
botReplacedGenome->copySequence(mainReplacedGenome);
botReplacedGenome->copyBottomDimensions(mainReplacedGenome);
botReplacedGenome->copyBottomSegments(mainReplacedGenome);
mainReplacedGenome->fixParseInfo();
// Copy top segments for the children
vector<string> children = mainAlignment->getChildNames(genomeName);
for (size_t i = 0; i < children.size(); i++)
{
Genome *mainChild = mainAlignment->openGenome(children[i]);
const Genome *botChild = bottomAlignment->openGenome(children[i]);
botChild->copyTopDimensions(mainChild);
botChild->copyTopSegments(mainChild);
mainChild->fixParseInfo();
}
}
void MappedSegmentMapDownTest::checkCallBack(AlignmentConstPtr alignment)
{
validateAlignment(alignment);
const Genome* parent = alignment->openGenome("parent");
BottomSegmentIteratorConstPtr bottom = parent->getBottomSegmentIterator();
testBottomSegment(alignment, bottom, 0);
testBottomSegment(alignment, bottom, 1);
bottom->slice(1,2);
testBottomSegment(alignment, bottom, 0);
testBottomSegment(alignment, bottom, 1);
bottom->toReverse();
testBottomSegment(alignment, bottom, 0);
testBottomSegment(alignment, bottom, 1);
}
void MappedSegmentParseTest::testTopSegment(AlignmentConstPtr alignment,
TopSegmentIteratorConstPtr top)
{
const Genome* parent = alignment->openGenome("parent");
set<MappedSegmentConstPtr> results;
top->getMappedSegments(results, parent, NULL, false);
vector<bool> covered(top->getLength(), false);
CuAssertTrue(_testCase, results.size() >= 1);
set<MappedSegmentConstPtr>::iterator i = results.begin();
for (; i != results.end(); ++i)
{
MappedSegmentConstPtr mseg = *i;
CuAssertTrue(_testCase, mseg->getSource()->getGenome() == top->getGenome());
CuAssertTrue(_testCase, mseg->getGenome() == parent);
for (hal_index_t j = mseg->getStartPosition(); j <= mseg->getEndPosition();
++j)
{
CuAssertTrue(_testCase, covered[j] == false);
covered[j] = true;
}
CuAssertTrue(_testCase, mseg->getStartPosition() ==
mseg->getSource()->getStartPosition());
CuAssertTrue(_testCase, mseg->getEndPosition() ==
mseg->getSource()->getEndPosition());
set<MappedSegmentConstPtr> tResults;
mseg->getMappedSegments(tResults, top->getGenome(), NULL, false);
CuAssertTrue(_testCase, tResults.size() == 1);
MappedSegmentConstPtr tmseg = *tResults.begin();
CuAssertTrue(_testCase, tmseg->getGenome() == top->getGenome());
CuAssertTrue(_testCase, tmseg->getSource()->getGenome() ==
mseg->getGenome());
CuAssertTrue(_testCase, tmseg->getStartPosition() ==
mseg->getStartPosition());
CuAssertTrue(_testCase, tmseg->getEndPosition() ==
mseg->getEndPosition());
CuAssertTrue(_testCase, tmseg->getSource()->getStartPosition() ==
mseg->getStartPosition());
CuAssertTrue(_testCase, tmseg->getSource()->getEndPosition() ==
mseg->getEndPosition());
}
}
void MappedSegmentMapAcrossTest::checkCallBack(AlignmentConstPtr alignment)
{
validateAlignment(alignment);
const Genome* child1 = alignment->openGenome("child1");
const Genome* child2 = alignment->openGenome("child2");
TopSegmentIteratorConstPtr top = child2->getTopSegmentIterator();
testTopSegment(alignment, top);
top->slice(1,2);
testTopSegment(alignment, top);
top->toReverse();
testTopSegment(alignment, top);
top = child1->getTopSegmentIterator();
testTopSegment(alignment, top);
top->slice(1,2);
testTopSegment(alignment, top);
top->toReverse();
testTopSegment(alignment, top);
}
void TopSegmentIsGapTest::checkCallBack(AlignmentConstPtr alignment)
{
BottomSegmentIteratorConstPtr bi;
TopSegmentIteratorConstPtr ti;
const Genome* child1 = alignment->openGenome("child1");
for (hal_size_t i = 0; i < child1->getNumTopSegments(); ++i)
{
ti = child1->getTopSegmentIterator(i);
if (i == 8 || i == 10)
{
// CuAssertTrue(_testCase, ti->getTopSegment()->isGapInsertion());
}
else
{
// CuAssertTrue(_testCase, !ti->getTopSegment()->isGapInsertion());
}
}
}
void printBedSequenceStats(ostream& os, AlignmentConstPtr alignment,
const string& genomeName)
{
const Genome* genome = alignment->openGenome(genomeName);
if (genome == NULL)
{
throw hal_exception(string("Genome ") + genomeName + " not found.");
}
if (genome->getNumSequences() > 0)
{
SequenceIteratorConstPtr seqIt = genome->getSequenceIterator();
SequenceIteratorConstPtr seqEnd = genome->getSequenceEndIterator();
for (; !seqIt->equals(seqEnd); seqIt->toNext())
{
os << seqIt->getSequence()->getName() << "\t"
<< 0 << "\t"
<< seqIt->getSequence()->getSequenceLength() << "\n";
}
}
os << endl;
}
void LodExtract::createInterpolatedAlignment(AlignmentConstPtr inAlignment,
AlignmentPtr outAlignment,
double scale,
const string& tree,
const string& rootName,
bool keepSequences,
bool allSequences,
double probeFrac,
double minSeqFrac)
{
_inAlignment = inAlignment;
_outAlignment = outAlignment;
_keepSequences = keepSequences;
_allSequences = allSequences;
_probeFrac = probeFrac;
_minSeqFrac = minSeqFrac;
string newTree = tree.empty() ? inAlignment->getNewickTree() : tree;
createTree(newTree, rootName);
cout << "tree = " << _outAlignment->getNewickTree() << endl;
deque<string> bfQueue;
bfQueue.push_front(_outAlignment->getRootName());
while (!bfQueue.empty())
{
string genomeName = bfQueue.back();
bfQueue.pop_back();
vector<string> childNames = _outAlignment->getChildNames(genomeName);
if (!childNames.empty())
{
convertInternalNode(genomeName, scale);
for (size_t childIdx = 0; childIdx < childNames.size(); childIdx++)
{
bfQueue.push_back(childNames[childIdx]);
}
}
}
}
int main(int argc, char *argv[])
{
CLParserPtr optParser = initParser();
string inPath, botAlignmentPath, topAlignmentPath, parentName, insertName,
childName, leafName;
double upperBranchLength, leafBranchLength;
bool noMarkAncestors;
try {
optParser->parseOptions(argc, argv);
inPath = optParser->getArgument<string>("inFile");
botAlignmentPath = optParser->getArgument<string>("botAlignmentFile");
topAlignmentPath = optParser->getArgument<string>("topAlignmentFile");
parentName = optParser->getArgument<string>("parentName");
insertName = optParser->getArgument<string>("insertName");
childName = optParser->getArgument<string>("childName");
leafName = optParser->getArgument<string>("leafName");
upperBranchLength = optParser->getArgument<double>("upperBranchLength");
leafBranchLength = optParser->getArgument<double>("leafBranchLength");
noMarkAncestors = optParser->getFlag("noMarkAncestors");
} catch (exception &e) {
optParser->printUsage(cerr);
return 1;
}
AlignmentPtr mainAlignment = openHalAlignment(inPath, optParser);
AlignmentConstPtr botAlignment = openHalAlignment(botAlignmentPath,
optParser);
AlignmentConstPtr topAlignment = openHalAlignment(topAlignmentPath,
optParser);
mainAlignment->insertGenome(insertName, parentName, childName,
upperBranchLength);
mainAlignment->addLeafGenome(leafName, insertName, leafBranchLength);
// Insert the new intermediate node.
Genome *insertGenome = mainAlignment->openGenome(insertName);
const Genome *topInsertGenome = topAlignment->openGenome(insertName);
const Genome *botInsertGenome = botAlignment->openGenome(insertName);
topInsertGenome->copyDimensions(insertGenome);
topInsertGenome->copyTopDimensions(insertGenome);
botInsertGenome->copyBottomDimensions(insertGenome);
topInsertGenome->copySequence(insertGenome);
topInsertGenome->copyTopSegments(insertGenome);
topInsertGenome->copyMetadata(insertGenome);
botInsertGenome->copyBottomSegments(insertGenome);
insertGenome->fixParseInfo();
// Copy the bottom segments for the parent genome from the top alignment.
Genome *parentGenome = mainAlignment->openGenome(parentName);
const Genome *botParentGenome = topAlignment->openGenome(parentName);
botParentGenome->copyBottomDimensions(parentGenome);
botParentGenome->copyBottomSegments(parentGenome);
parentGenome->fixParseInfo();
// Fix the parent's other children as well.
vector<string> allChildren = mainAlignment->getChildNames(parentName);
for (size_t i = 0; i < allChildren.size(); i++)
{
if (allChildren[i] != insertName)
{
Genome *outGenome = mainAlignment->openGenome(allChildren[i]);
const Genome *topSegmentsGenome = topAlignment->openGenome(allChildren[i]);
topSegmentsGenome->copyTopDimensions(outGenome);
topSegmentsGenome->copyTopSegments(outGenome);
outGenome->fixParseInfo();
}
}
// Copy the top segments for the child genome from the bottom alignment.
Genome *childGenome = mainAlignment->openGenome(childName);
const Genome *topChildGenome = botAlignment->openGenome(childName);
topChildGenome->copyTopDimensions(childGenome);
topChildGenome->copyTopSegments(childGenome);
childGenome->fixParseInfo();
// Copy the entire genome for the leaf from the bottom alignment.
Genome *outLeafGenome = mainAlignment->openGenome(leafName);
const Genome *inLeafGenome = botAlignment->openGenome(leafName);
inLeafGenome->copy(outLeafGenome);
if (!noMarkAncestors) {
markAncestorsForUpdate(mainAlignment, insertName);
}
mainAlignment->close();
botAlignment->close();
topAlignment->close();
}
