SubstitutionMappingTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef _LEGACY_SUBSTITUTION_MAPPING_TOOLS_H_
#define _LEGACY_SUBSTITUTION_MAPPING_TOOLS_H_
 
#include "ProbabilisticSubstitutionMapping.h"
#include "../Likelihood/DRTreeLikelihood.h"
#include "../../Mapping/SubstitutionCount.h" // We use the new implementation here.
#include "../../Mapping/OneJumpSubstitutionCount.h"
 
#include <memory>
 
namespace bpp
{
class LegacySubstitutionMappingTools
{
public:
  LegacySubstitutionMappingTools() {}
  virtual ~LegacySubstitutionMappingTools() {}
 
public:
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectors(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true)
  {
    std::vector<int> nodeIds;
    return computeSubstitutionVectors(drtl, nodeIds, substitutionCount, verbose);
  }
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectors(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& nodeIds,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true);
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectors(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      const SubstitutionModelSet& modelSet,
      const std::vector<int>& nodeIds,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true);
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectorsNoAveraging(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true);
 
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectorsNoAveragingMarginal(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true);
 
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeSubstitutionVectorsMarginal(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      std::shared_ptr<SubstitutionCountInterface> substitutionCount,
      bool verbose = true);
 
 
  static std::unique_ptr<LegacyProbabilisticSubstitutionMapping> computeOneJumpProbabilityVectors(
      std::shared_ptr<const DRTreeLikelihoodInterface> drtl,
      bool verbose = true)
  {
    std::shared_ptr<SubstitutionModelInterface> ptr = nullptr;
    auto ojsm = std::make_shared<OneJumpSubstitutionCount>(ptr);
    return computeSubstitutionVectors(drtl, drtl->tree().getNodesId(), ojsm, 0);
  }
 
 
  static void writeToStream(
      const LegacyProbabilisticSubstitutionMapping& substitutions,
      const SiteContainerInterface& sites,
      size_t type,
      std::ostream& out);
 
 
  static void readFromStream(std::istream& in, LegacyProbabilisticSubstitutionMapping& substitutions, size_t type);
 
 
  static std::vector<double> computeTotalSubstitutionVectorForSitePerBranch(const LegacySubstitutionMappingInterface& smap, size_t siteIndex);
 
  static std::vector<double> computeTotalSubstitutionVectorForSitePerType(const LegacySubstitutionMappingInterface& smap, size_t siteIndex);
 
  static double computeNormForSite(const LegacySubstitutionMappingInterface& smap, size_t siteIndex);
 
  static std::vector<double> computeSumForBranch(const LegacySubstitutionMappingInterface& smap, size_t branchIndex);
 
 
  static std::vector<double> computeSumForSite(const LegacySubstitutionMappingInterface& smap, size_t siteIndex);
 
 
  static std::vector<std::vector<double>> getCountsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      double threshold = -1,
      bool verbose = true);
 
  static std::vector<std::vector<double>> getCountsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      const SubstitutionModelSet& modelSet,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      double threshold = -1,
      bool verbose = true);
 
 
  static std::vector<std::vector<double>> getNormalizationsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<const SubstitutionModelInterface> nullModel,
      const SubstitutionRegisterInterface& reg,
      bool verbose = true);
 
 
  static std::vector<std::vector<double>> getNormalizationsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<const SubstitutionModelSet> nullModelSet,
      const SubstitutionRegisterInterface& reg,
      bool verbose = true);
 
 
  static std::vector<std::vector<double>> getRelativeCountsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      double threshold = -1,
      bool verbose = true)
  {
    std::vector<std::vector<double>> result;
    computeCountsPerTypePerBranch(drtl, ids, model, reg, result, threshold, verbose);
    return result;
  }
 
  static std::vector<std::vector<double>> getNormalizedCountsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<SubstitutionModelInterface> nullModel,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      bool perTime,
      bool perWord,
      bool verbose = true)
  {
    std::vector< std::vector<double>> result;
    computeCountsPerTypePerBranch(drtl, ids, model, nullModel, reg, result, perTime, perWord, verbose);
    return result;
  }
 
  static std::vector<std::vector<double>> getNormalizedCountsPerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelSet> modelSet,
      std::shared_ptr<SubstitutionModelSet> nullModelSet,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      bool perTime,
      bool perWord,
      bool verbose = true)
  {
    std::vector<std::vector<double>> result;
    computeCountsPerTypePerBranch(drtl, ids, modelSet, nullModelSet, reg, result, perTime, perWord, verbose);
    return result;
  }
 
  static void computeCountsPerSitePerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& array);
 
 
  static void computeCountsPerTypePerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result,
      double threshold = -1,
      bool verbose = true);
 
  static void computeCountsPerTypePerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<SubstitutionModelInterface> nullModel,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result,
      bool perTime,
      bool perWord,
      bool verbose = true);
 
  static void computeCountsPerTypePerBranch(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelSet> modelSet,
      std::shared_ptr<SubstitutionModelSet> nullModelSet,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result,
      bool perTime,
      bool perWord,
      bool verbose = true);
 
  static void computeCountsPerSitePerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result);
 
  static void computeCountsPerSitePerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<SubstitutionModelInterface> nullModel,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result,
      bool perTime,
      bool perWord);
 
  static void computeCountsPerSitePerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelSet> modelSet,
      std::shared_ptr<SubstitutionModelSet> nullModelSet,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVdouble& result,
      bool perTime,
      bool perWord);
 
  static void computeCountsPerSitePerBranchPerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVVdouble& result);
 
  static void computeCountsPerSitePerBranchPerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelInterface> model,
      std::shared_ptr<SubstitutionModelInterface> nullModel,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVVdouble& result,
      bool perTime,
      bool perWord);
 
  static void computeCountsPerSitePerBranchPerType(
      std::shared_ptr<DRTreeLikelihoodInterface> drtl,
      const std::vector<int>& ids,
      std::shared_ptr<SubstitutionModelSet> modelSet,
      std::shared_ptr<SubstitutionModelSet> nullModelSet,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      VVVdouble& result,
      bool perTime,
      bool perWord);
 
  static void outputPerSitePerBranch(const std::string& filename,
      const std::vector<int>& ids,
      const VVdouble& counts);
 
  static void outputPerSitePerType(const std::string& filename,
      const SubstitutionRegisterInterface& reg,
      const VVdouble& counts);
 
  static void outputPerSitePerBranchPerType(const std::string& filenamePrefix,
      const std::vector<int>& ids,
      const SubstitutionRegisterInterface& reg,
      const VVVdouble& counts);
 
 
};
} // end of namespace bpp.
 
#endif // _LEGACY_SUBSTITUTION_MAPPING_TOOLS_H_