PatternTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_PATTERNTOOLS_H
#define BPP_PHYL_PATTERNTOOLS_H
 
#include <Bpp/Numeric/VectorTools.h>
 
#include "Tree/PhyloTree.h"
#include "Tree/TreeTemplateTools.h"
 
// From SeqLib:
#include <Bpp/Seq/SymbolListTools.h>
#include <Bpp/Seq/Site.h>
#include <Bpp/Seq/Container/SiteContainer.h>
#include <Bpp/Seq/Container/AlignmentData.h>
#include <Bpp/Seq/Container/VectorSiteContainer.h>
 
// From the STL:
#include <map>
 
namespace bpp
{
class PatternTools
{
public:
  template<class N, class E, class I>
  static std::unique_ptr<AlignmentDataInterface> getSequenceSubset(
      const AlignmentDataInterface& sequenceSet,
      const std::shared_ptr<N> node,
      const AssociationTreeGraphImplObserver<N, E, I>& tree)
  {
    try
    {
      const auto& siteContainer = dynamic_cast<const SiteContainerInterface&>(sequenceSet);
      return getSequenceSubset(siteContainer, node, tree);
    }
    catch (std::bad_cast& e) {}
 
    try
    {
      const auto& siteContainer = dynamic_cast<const ProbabilisticSiteContainerInterface&>(sequenceSet);
      return getSequenceSubset(siteContainer, node, tree);
    }
    catch (std::bad_cast& e) {}
 
    throw Exception("PatternTools::getSequenceSubset : unsupported sequence type.");
  }
 
  template<class N, class E, class I>
  static std::unique_ptr<SiteContainerInterface> getSequenceSubset(
      const SiteContainerInterface& sequenceSet,
      const std::shared_ptr<N> node,
      const AssociationTreeGraphImplObserver<N, E, I>& tree)
  {
    size_t nbSites = sequenceSet.getNumberOfSites();
    auto alphabet = sequenceSet.getAlphabet();
    auto sequenceSubset = std::make_unique<VectorSiteContainer>(alphabet);
 
    std::vector<std::shared_ptr<N>> leaves = tree.getLeavesUnderNode(node);
 
    for (auto i : leaves)
    {
      if (i->hasName())
      {
        // Use sequence name as key.
        try
        {
          auto newSeq = std::make_unique<Sequence>(sequenceSet.sequence(i->getName()));
          sequenceSubset->addSequence(i->getName(), newSeq);
        }
        catch (std::exception& e)
        {
          ApplicationTools::displayWarning("PatternTools::getSequenceSubset : Leaf name not found in sequence file: " + i->getName() + " : Replaced with unknown sequence");
 
          auto seq = std::make_unique<Sequence>(i->getName(), "", alphabet);
          seq->setToSizeR(nbSites);
          SymbolListTools::changeGapsToUnknownCharacters(*seq);
          sequenceSubset->addSequence(i->getName(), seq);
        }
      }
    }
    sequenceSubset->setSiteCoordinates(sequenceSet.getSiteCoordinates());
    return sequenceSubset;
  }
 
  template<class N, class E, class I>
  static std::unique_ptr<ProbabilisticSiteContainerInterface> getSequenceSubset(
      const ProbabilisticSiteContainerInterface& sequenceSet,
      const std::shared_ptr<N> node,
      const AssociationTreeGraphImplObserver<N, E, I>& tree)
  {
    size_t nbSites = sequenceSet.getNumberOfSites();
    auto alphabet = sequenceSet.getAlphabet();
    auto sequenceSubset = std::make_unique<ProbabilisticVectorSiteContainer>(alphabet);
 
    std::vector<std::shared_ptr<N>> leaves = tree.getLeavesUnderNode(node);
 
    for (auto i : leaves)
    {
      if (i->hasName())
      {
        // Use sequence name as key.
        try
        {
          auto newSeq = std::make_unique<ProbabilisticSequence>(sequenceSet.sequence(i->getName()));
          sequenceSubset->addSequence(newSeq->getName(), newSeq);
        }
        catch (std::exception const& e)
        {
          ApplicationTools::displayWarning("PatternTools::getSequenceSubset : Leaf name not found in sequence file: " + i->getName() + " : Replaced with unknown sequence");
 
          auto newSeq = std::make_unique<ProbabilisticSequence>(i->getName(), Table<double>(alphabet->getSize(), 0), alphabet);
          newSeq->setToSizeR(nbSites);
          SymbolListTools::changeGapsToUnknownCharacters(*newSeq);
          sequenceSubset->addSequence(i->getName(), newSeq);
        }
      }
    }
    sequenceSubset->setSiteCoordinates(sequenceSet.getSiteCoordinates());
    return sequenceSubset;
  }
 
  static std::unique_ptr<AlignmentDataInterface> getSequenceSubset(
      const AlignmentDataInterface& sequenceSet,
      const Node& node);
 
  static std::unique_ptr<SiteContainerInterface> getSequenceSubset(
      const SiteContainerInterface& sequenceSet,
      const Node& node);
 
  static std::unique_ptr<ProbabilisticSiteContainerInterface> getSequenceSubset(
      const ProbabilisticSiteContainerInterface& sequenceSet,
      const Node& node);
 
  static std::unique_ptr<AlignmentDataInterface> getSequenceSubset(
      const AlignmentDataInterface& sequenceSet,
      const std::vector<std::string>& names);
 
  static std::unique_ptr<SiteContainerInterface> getSequenceSubset(
      const SiteContainerInterface& sequenceSet,
      const std::vector<std::string>& names);
 
  static std::unique_ptr<ProbabilisticSiteContainerInterface> getSequenceSubset(
      const ProbabilisticSiteContainerInterface& sequenceSet,
      const std::vector<std::string>& names);
 
  static std::unique_ptr<AlignmentDataInterface> shrinkSiteSet(
      const AlignmentDataInterface& siteSet);
 
  static std::unique_ptr<SiteContainerInterface> shrinkSiteSet(
      const SiteContainerInterface& siteSet);
 
  static std::unique_ptr<ProbabilisticSiteContainerInterface> shrinkSiteSet(
      const ProbabilisticSiteContainerInterface& siteSet);
 
  static Vint getIndexes(
      const AlignmentDataInterface& sequences1,
      const AlignmentDataInterface& sequences2);
};
} // end of namespace bpp.
#endif // BPP_PHYL_PATTERNTOOLS_H