void NxsTaxaBlockSurrogate::AssureTaxaBlock(bool allocBlock, NxsToken &token, const char *cmd)
{
if (!allocBlock)
{
if (taxa != NULL)
return;
if (!nxsReader)
{
NxsString errormsg = "API Error: No nxsReader during parse in NxsTaxaBlockSurrogate::AssureTaxaBlock";
throw NxsNCLAPIException(errormsg, token);
}
unsigned nTb;
NxsTaxaBlockAPI * cb = nxsReader->GetTaxaBlockByTitle(NULL, &nTb);
if (cb == NULL)
{
NxsString errormsg = "TAXA Block has been not been read, but a ";
if (cmd)
errormsg += cmd;
errormsg += " command (which requires a TAXA block) has been encountered. Either add a TAXA block or (for blocks other than the TREES block) you may use a \"DIMENSIONS NEWTAXA NTAX= ...\" command to introduces taxa.";
throw NxsException(errormsg, token);
}
if (nTb > 1)
{
NxsString errormsg = "Multiple TAXA Blocks have been read (or implied using NEWTAXA in other blocks) and a";
if (cmd)
errormsg += cmd;
errormsg += " command (which requires a TAXA block) has been encountered.\nA \"LINK TAXA=<title here>;\" command must be used to specify which TAXA block is needed.";
cb->WarnDangerousContent(errormsg, token);
}
taxa = cb;
return;
}
if (nxsReader != NULL)
{
NxsTaxaBlockFactory * tbf = nxsReader->GetTaxaBlockFactory();
if (tbf)
{
std::string s("TAXA");
taxa = tbf->GetBlockReaderForID(s, nxsReader, &token);
ownsTaxaBlock = true;
passedRefOfOwnedBlock = false;
taxaLinkStatus = NxsBlock::BLOCK_LINK_TO_IMPLIED_BLOCK;
}
}
if (taxa == NULL)
{
taxa = new NxsTaxaBlock();
ownsTaxaBlock = true;
passedRefOfOwnedBlock = false;
taxaLinkStatus = NxsBlock::BLOCK_LINK_TO_IMPLIED_BLOCK;
}
}
////////////////////////////////////////////////////////////////////////////////
// Takes NxsReader that has successfully read a file, and processes the
// information stored in the reader.
//
// The caller is responsibel for calling DeleteBlocksFromFactories() to clean
// up (if the reader uses the factory API).
////////////////////////////////////////////////////////////////////////////////
void processContent(PublicNexusReader & nexusReader, ostream *out)
{
if (!out)
return;
BlockReaderList blocks = nexusReader.GetUsedBlocksInOrder();
*out << "#NEXUS\n";
for (BlockReaderList::const_iterator bIt = blocks.begin(); bIt != blocks.end(); ++bIt)
{
NxsBlock * b = *bIt;
if (b->GetID() == "TAXA")
b->WriteAsNexus(*out);
}
TreesToSplits::TaxaBlockToSplitsMap::const_iterator tbtsm = gTreesToSplitsB->taxaBlockToSplitsMap.begin();
for (; tbtsm != gTreesToSplitsB->taxaBlockToSplitsMap.end(); ++tbtsm) {
*out << "Begin Trees;\n";
NxsTaxaBlockAPI * tb = tbtsm->first;
if (tb && gTreesToSplitsB->taxaBlockToSplitsMap.size() > 1)
*out << "Link Taxa = " << NxsString::GetEscaped(tb->GetTitle()) << ";\n";
writeTranslateCommand(tb, *out);
const TreesToSplits::NTreesSplitsMap & ntsm = tbtsm->second;
const unsigned nt = ntsm.first;
const TreesToSplits::SplitsMap & sm = ntsm.second;
unsigned n = 1;
writeStarTreeCommand(tb, *out);
for (TreesToSplits::SplitsMap::const_iterator smIt = sm.begin(); smIt != sm.end(); ++smIt, ++n) {
const SplitInfo & si = smIt->second;
*out << "Tree split_" << n << " = " << " [&";
*out << (gTreesToSplitsB->treatAsRooted ? 'R' : 'U');
*out << "] [";
if (gTreesToSplitsB->trackFreq || gTreesToSplitsB->trackEdgeLenSummary || gTreesToSplitsB->trackEdgeLen)
*out << "&W " << ((double)si.nTimes)/((double)nt) << " ] [";
if (gTreesToSplitsB->trackHeightSummary) {
*out << "meanH =" << ((double)si.heightSum)/((double)si.nTimes);
}
*out << "] ";
if (gTreesToSplitsB->trackEdgeLenSummary)
smIt->first.writeNewick(*out, si.edgeLenSum/((double)si.nTimes), true);
else
smIt->first.writeNewick(*out, true);
*out << ";\n";
}
*out << "End;\n";
}
}
void WriteCharactersBlock(ostream & out, NxsCharactersBlock *ncb)
{
const unsigned nt = ncb->GetNTax();
const unsigned nc = ncb->GetNChar();
int status;
NxsTaxaBlockAPI* tb = ncb->GetTaxaBlockPtr(&status);
assert(tb);
out << "BEGIN DATA;\n";
out << " DIMENSIONS NTax="<< ncb->GetNTaxWithData() << " NChar=" << ncb->GetNumActiveChar() << ";\n";
out << " FORMAT Datatype = "<< ncb->GetDatatypeName() << " missing=" << ncb->GetMissingSymbol();
const char gap = ncb->GetGapSymbol();
if (gap != '\0')
out << " gap=" << gap;
out << ";\nMatrix\n";
for (unsigned i = 0; i < nt; ++i)
{
if (ncb->TaxonIndHasData(i))
{
out << NxsToken::EscapeString(tb->GetTaxonLabel(i)) << ' ';
for (unsigned j = 0; j < nc; ++j)
{
const unsigned ns = ncb->GetNumStates(i, j);
if (ns > 1)
{
out << '{';
for (unsigned k = 0; k < ns; ++k)
out << ncb->GetState(i, j, k);
out << '}';
}
else
out << ncb->GetState(i, j, 0);
}
out << '\n';
}
}
out << ";\nEND;\n";
}
/* This function is called by derived classes right before they start to parse a command
that requires a Taxa block.
If a taxa block has not been set at this point, and one cannot be created then
a NxsException will be generated.
This enables lazy initialization of the taxa field.
*/
void NxsTaxaBlockSurrogate::AssureTaxaBlock(bool allocBlock, NxsToken &token, const char *cmd)
{
if (!allocBlock)
{
if (taxa != NULL)
return;
if (!nxsReader)
{
NxsString errormsg = "API Error: No nxsReader during parse in NxsTaxaBlockSurrogate::AssureTaxaBlock";
throw NxsNCLAPIException(errormsg, token);
}
unsigned nTb;
NxsTaxaBlockAPI * cb = nxsReader->GetTaxaBlockByTitle(NULL, &nTb);
if (cb == NULL)
{
NxsString errormsg = "TAXA Block has been not been read, but a ";
if (cmd)
errormsg += cmd;
errormsg += " command (which requires a TAXA block) has been encountered. Either add a TAXA block or (for blocks other than the TREES block) you may use a \"DIMENSIONS NEWTAXA NTAX= ...\" command to introduces taxa.";
throw NxsException(errormsg, token);
}
if (nTb > 1)
{
NxsString errormsg = "Multiple TAXA Blocks have been read (or implied using NEWTAXA in other blocks) and a ";
if (cmd)
errormsg += cmd;
errormsg += " command (which requires a TAXA block) has been encountered";
std::string bn = token.GetBlockName();
if (!bn.empty())
{
errormsg += " in a ";
errormsg += bn;
errormsg += " block.";
}
errormsg += ".\nThis can be caused by reading multiple files. It is possible that\neach file is readable separately, but cannot be read unambiguously when read in sequence.\n";
errormsg += "One way to correct this is to use the\n TITLE some-unique-name-here ;\ncommand in the TAXA block and an accompanying\n LINK TAXA=the-unique-title-goes here;\n";
errormsg += "command to specify which TAXA block is needed.";
cb->WarnDangerousContent(errormsg, token);
}
taxa = cb;
return;
}
if (nxsReader != NULL)
{
NxsTaxaBlockFactory * tbf = nxsReader->GetTaxaBlockFactory();
if (tbf)
{
std::string s("TAXA");
taxa = tbf->GetBlockReaderForID(s, nxsReader, &token);
ownsTaxaBlock = true;
passedRefOfOwnedBlock = false;
taxaLinkStatus = NxsBlock::BLOCK_LINK_TO_IMPLIED_BLOCK;
}
}
if (taxa == NULL)
{
taxa = new NxsTaxaBlock();
ownsTaxaBlock = true;
passedRefOfOwnedBlock = false;
taxaLinkStatus = NxsBlock::BLOCK_LINK_TO_IMPLIED_BLOCK;
}
}
void writeCharactersAsGapped(ostream &out, NxsCharactersBlock * cb)
{
if (!cb )
return;
NxsTaxaBlockAPI *tb = cb->GetTaxaBlockPtr(NULL);
if (tb == NULL)
return;
NxsCharactersBlock::DataTypesEnum dt = cb->GetDataType();
const char g = cb->GetGapSymbol();
const std::string baseTitle = cb->GetTitle();
if (tb == NULL
|| dt == NxsCharactersBlock::standard
|| dt == NxsCharactersBlock::continuous
|| dt == NxsCharactersBlock::mixed
|| (g == '\0' && !gGapCodeAllPresentSites))
{
cb->WriteAsNexus(out);
writeCoreAssumptions(out, cb, baseTitle.c_str());
return;
}
bool isAutogen = cb->IsAutoGeneratedTitle();
std::string newTitle = baseTitle;
newTitle.append("GapsAsMissing");
cb->SetTitle(newTitle, isAutogen);
std::set<unsigned> gappedColumns;
std::set<unsigned> residueColumns;
out << "BEGIN CHARACTERS;\n";
cb->WriteBasicBlockCommands(out);
const unsigned ntaxTotal = tb->GetNTax();
out << " DIMENSIONS";
if (tb)
{
const unsigned wod = cb->GetNTaxWithData();
if (wod > 0 && wod != ntaxTotal)
out << " NTax=" << wod;
}
const unsigned nc = cb->GetNCharTotal();
out << " NChar=" << nc << ";\n";
cb->WriteEliminateCommand(out);
cb->SetGapSymbol('\0');
cb->WriteFormatCommand(out);
cb->SetGapSymbol(g);
cb->WriteCharStateLabelsCommand(out);
std::vector<int> intWts;
std::vector<double> dblWts;
NxsUnsignedSet activeExSet = cb->GetExcludedIndexSet();
const NxsTransformationManager &tm = cb->GetNxsTransformationManagerRef();
intWts = tm.GetDefaultIntWeights();
if (intWts.empty())
dblWts = tm.GetDefaultDoubleWeights();
unsigned width = tb->GetMaxTaxonLabelLength();
out << "Matrix\n";
unsigned begCharInd = 0;
unsigned endCharInd = nc;
for (unsigned i = 0; i < ntaxTotal; i++)
{
if (cb->TaxonIndHasData(i))
{
const std::string currTaxonLabel = NxsString::GetEscaped(tb->GetTaxonLabel(i));
out << currTaxonLabel;
unsigned currTaxonLabelLen = (unsigned)currTaxonLabel.size();
unsigned diff = width - currTaxonLabelLen;
for (unsigned k = 0; k < diff + 5; k++)
out << ' ';
const NxsDiscreteStateRow & row = cb->GetDiscreteMatrixRow(i);
if (!row.empty())
{
const NxsDiscreteDatatypeMapper * dm = cb->GetDatatypeMapperForChar(0);
if (dm == NULL)
throw NxsNCLAPIException("No DatatypeMapper in WriteStatesForTaxonAsNexus");
if (cb->IsMixedType())
throw NxsNCLAPIException("Mixed datatypes are not supported by the NEXUSgapcode program.");
if (cb->IsTokens())
{
for (unsigned charInd = begCharInd; charInd < endCharInd; ++charInd)
{
int sc = row[charInd];
out << ' ';
if (sc == NXS_GAP_STATE_CODE)
out << dm->GetMissingSymbol();
else
{
NxsString sl = cb->GetStateLabel(charInd, sc); /*v2.1to2.2 2 */
if (sl == " ")
{
NxsString errormsg = "Writing character state ";
errormsg << 1 + sc << " for character " << 1+charInd << ", but no appropriate chararcter label or symbol was found.";
throw NxsNCLAPIException(errormsg);
}
else
out << NxsString::GetEscaped(sl);
}
}
}
else
{
std::vector<NxsDiscreteStateCell>::const_iterator endIt = row.begin() + begCharInd;
std::vector<NxsDiscreteStateCell>::const_iterator begIt = endIt;
if (endCharInd == row.size())
endIt = row.end();
else
endIt += endCharInd - begCharInd;
unsigned j = begCharInd;
for (; begIt != endIt; ++begIt, ++j)
{
NxsDiscreteStateCell c;
if (*begIt == NXS_GAP_STATE_CODE)
{
c = NXS_MISSING_CODE;
gappedColumns.insert(j);
}
else
{
c = *begIt;
if (gGapCodeAllPresentSites)
gappedColumns.insert(j);
residueColumns.insert(j);
}
dm->WriteStateCodeAsNexusString(out, c, true);
}
}
}
out << '\n';
}
}
out << ";\n";
cb->WriteSkippedCommands(out);
out << "END;\n";
writeCoreAssumptions(out, cb, newTitle.c_str());
const unsigned nGappedCols = gappedColumns.size();
if (nGappedCols > 0)
{
newTitle = baseTitle;
newTitle.append("GapsAsBinary");
cb->SetTitle(newTitle, isAutogen);
out << "BEGIN CHARACTERS;\n";
cb->WriteBasicBlockCommands(out);
out << " DIMENSIONS";
if (tb)
{
const unsigned wod = cb->GetNTaxWithData();
if (wod > 0 && wod != ntaxTotal)
out << " NTax=" << wod;
}
out << " NChar=" << nGappedCols << ";\n";
out << " CharStateLabels " ;
unsigned currChNumber = 1;
std::set<unsigned>::iterator gcIt = gappedColumns.begin();
out << currChNumber++ << " col_" << (1 + *gcIt);
for (++gcIt ; gcIt != gappedColumns.end(); ++gcIt)
out << ",\n " << currChNumber++ << " col_" << (1 + *gcIt);
out << " ;\n" ;
out << "Format Datatype = Standard Symbols=\"01\" missing = '?' ;\n";
out << "Matrix\n";
for (unsigned i = 0; i < ntaxTotal; i++)
{
if (cb->TaxonIndHasData(i))
{
const std::string currTaxonLabel = NxsString::GetEscaped(tb->GetTaxonLabel(i));
out << currTaxonLabel;
unsigned currTaxonLabelLen = (unsigned)currTaxonLabel.size();
unsigned diff = width - currTaxonLabelLen;
for (unsigned k = 0; k < diff + 5; k++)
out << ' ';
const NxsDiscreteStateRow & row = cb->GetDiscreteMatrixRow(i);
for (std::set<unsigned>::iterator cIt = gappedColumns.begin(); cIt != gappedColumns.end(); ++cIt)
{
NxsDiscreteStateCell sc = row[*cIt];
if (sc == NXS_GAP_STATE_CODE)
{
if (gGapCodeAllAbsentSites || (residueColumns.find(*cIt) != residueColumns.end()))
out << '0';
else
out << '?';
}
else if (sc == NXS_MISSING_CODE)
{
out << '?';
}
else
{
out << '1';
}
}
out << '\n';
}
}
out << ";\n";
cb->WriteSkippedCommands(out);
out << "END;\n";
}
std::vector<int> gapintWts;
std::vector<double> gapdblWts;
std::set<unsigned> gapactiveExSet;
if (!activeExSet.empty())
{
unsigned gapind = 0;
for (std::set<unsigned>::iterator cIt = gappedColumns.begin(); cIt != gappedColumns.end(); ++cIt, ++gapind)
{
if (activeExSet.find(*cIt) != activeExSet.end())
gapactiveExSet.insert(gapind);
}
}
if (!intWts.empty())
{
for (std::set<unsigned>::iterator cIt = gappedColumns.begin(); cIt != gappedColumns.end(); ++cIt)
gapintWts.push_back(intWts[*cIt]);
}
if (!dblWts.empty())
{
for (std::set<unsigned>::iterator cIt = gappedColumns.begin(); cIt != gappedColumns.end(); ++cIt)
gapdblWts.push_back(dblWts[*cIt]);
}
if (!(gapactiveExSet.empty() && gapintWts.empty() && gapdblWts.empty()))
{
out << "BEGIN ASSUMPTIONS; \n LINK CHARACTERS = ";
out << NxsString::GetEscaped(newTitle) << " ;\n";
if (!gapactiveExSet.empty())
{
NxsString exsetName;
exsetName << newTitle;
exsetName.append("GapExSet");
NxsUnsignedSetMap m;
m[exsetName] = gapactiveExSet;
NxsWriteSetCommand("EXSET", m, out, exsetName.c_str());;
}
if (!(gapintWts.empty() && gapdblWts.empty()))
{
NxsTransformationManager &cbntm = cb->GetNxsTransformationManagerRef();
std::string wtSetName = cbntm.GetDefaultWeightSetName();
wtSetName.append("GapWtSet");
NxsTransformationManager ntm;
if (!gapintWts.empty())
{
NxsTransformationManager::ListOfIntWeights iw;
vecToListOfIntWeights(gapintWts, iw);
ntm.AddIntWeightSet(wtSetName, iw, true);
}
else
{
NxsTransformationManager::ListOfDblWeights dw;
vecToListOfDblWeights(gapdblWts, dw);
ntm.AddRealWeightSet(wtSetName, dw, true);
}
ntm.WriteWtSet(out);
}
out << "END;\n";
}
cb->SetTitle(baseTitle, isAutogen);
}
