SubstitutionMappingTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MAPPING_SUBSTITUTIONMAPPINGTOOLS_H
#define BPP_PHYL_MAPPING_SUBSTITUTIONMAPPINGTOOLS_H
 
#include <Bpp/Seq/AlphabetIndex/AlphabetIndex2.h>
 
#include "../Likelihood/DataFlow/LikelihoodCalculationSingleProcess.h"
#include "BranchedModelSet.h"
#include "OneJumpSubstitutionCount.h"
#include "ProbabilisticSubstitutionMapping.h"
#include "SubstitutionCount.h"
 
namespace bpp
{
class SubstitutionMappingTools
{
public:
  static const short UNRESOLVED_ZERO = 0;
  static const short UNRESOLVED_AVERAGE = 2;
  static const short UNRESOLVED_ONE = 1;
 
public:
  SubstitutionMappingTools() {}
 
  virtual ~SubstitutionMappingTools() {}
 
public:
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeCounts(
      LikelihoodCalculationSingleProcess& rltc,
      SubstitutionCountInterface& substitutionCount,
      short unresolvedOption = UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true)
  {
    std::vector<uint> edgeIds = rltc.substitutionProcess().parametrizablePhyloTree().getAllEdgesIndexes();
    return computeCounts(rltc, edgeIds, substitutionCount, unresolvedOption, threshold, verbose);
  }
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeCounts(
      LikelihoodCalculationSingleProcess& rltc,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> weights = 0,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      short unresolvedOption = UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true)
  {
    std::vector<uint> edgeIds = rltc.substitutionProcess().parametrizablePhyloTree().getAllEdgesIndexes();
    return computeCounts(rltc, edgeIds, reg, weights, distances, unresolvedOption, threshold, verbose);
  }
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeCounts(
      LikelihoodCalculationSingleProcess& rltc,
      const std::vector<uint>& speciesIds,
      SubstitutionCountInterface& substitutionCount,
      short unresolvedOption = UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true);
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeCounts(
      LikelihoodCalculationSingleProcess& rltc,
      const std::vector<uint>& edgeIds,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> weights = 0,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      short unresolvedOption = UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true);
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizations(
      LikelihoodCalculationSingleProcess& rltc,
      const std::vector<uint>& edgeIds,
      std::shared_ptr<const BranchedModelSet> nullModels,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      short unresolvedOption = UNRESOLVED_ZERO,
      bool verbose = true);
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizations(
      LikelihoodCalculationSingleProcess& rltc,
      std::shared_ptr<const BranchedModelSet> nullModels,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      short unresolvedOption = UNRESOLVED_ZERO,
      bool verbose = true)
  {
    std::vector<uint> edgeIds = rltc.substitutionProcess().parametrizablePhyloTree().getAllEdgesIndexes();
    return computeNormalizations(rltc, edgeIds, nullModels, reg, distances, unresolvedOption, verbose);
  }
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizedCounts(
      LikelihoodCalculationSingleProcess& rltc,
      const std::vector<uint>& edgeIds,
      std::shared_ptr<const BranchedModelSet> nullModels,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> weights = 0,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      bool perTimeUnit = false,
      uint siteSize = 1,
      short unresolvedOption = SubstitutionMappingTools::UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true);
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizedCounts(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      const std::vector<uint>& edgeIds,
      bool perTimeUnit = false,
      uint siteSize = 1);
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizedCounts(
      LikelihoodCalculationSingleProcess& rltc,
      std::shared_ptr<const BranchedModelSet> nullModels,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> weights = 0,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      bool perTimeUnit = false,
      uint siteSize = 1,
      short unresolvedOption = SubstitutionMappingTools::UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true)
  {
    std::vector<uint> edgeIds = rltc.substitutionProcess().parametrizablePhyloTree().getAllEdgesIndexes();
    return computeNormalizedCounts(rltc, edgeIds, nullModels, reg, weights, distances, perTimeUnit, siteSize, unresolvedOption, threshold, verbose);
  }
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeNormalizedCounts(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      bool perTimeUnit,
      uint siteSize = 1)
  {
    std::vector<uint> edgeIds = factors.getAllEdgesIndexes();
    return computeNormalizedCounts(counts, factors, edgeIds, perTimeUnit, siteSize);
  }
 
  static std::unique_ptr<ProbabilisticSubstitutionMapping> computeOneJumpCounts(
      LikelihoodCalculationSingleProcess& rltc,
      bool verbose = true)
  {
    OneJumpSubstitutionCount ojsm(rltc.getStateMap());
    return computeCounts(rltc, ojsm, 0);
  }
 
 
  static std::unique_ptr<PhyloTree> getTreeForType(
      const ProbabilisticSubstitutionMapping& counts,
      size_t type);
 
  static std::unique_ptr<PhyloTree> getTreeForType(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      size_t type);
 
  static VVVdouble getCountsPerSitePerBranchPerType(
      const ProbabilisticSubstitutionMapping& counts,
      const std::vector<uint>& ids = Vuint(0));
 
 
  static Vdouble getCountsForSitePerBranch(
      const ProbabilisticSubstitutionMapping& counts,
      size_t site);
 
  static Vdouble getCountsForSitePerBranch(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      size_t site);
 
  static VVdouble getCountsPerSitePerBranch(
      const ProbabilisticSubstitutionMapping& counts,
      const std::vector<uint>& ids = Vuint(0));
 
  static VVdouble getCountsPerSitePerBranch(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      const std::vector<uint>& ids = Vuint(0));
 
  static Vdouble getCountsForBranchPerType(
      const ProbabilisticSubstitutionMapping& counts,
      uint branchId);
 
  static VVdouble getCountsPerBranchPerType(
      const ProbabilisticSubstitutionMapping& counts,
      const std::vector<uint>& ids = Vuint(0));
 
  static VVdouble getCountsPerTypePerBranch(
      const ProbabilisticSubstitutionMapping& counts,
      const std::vector<uint>& ids = Vuint(0));
 
  static VVdouble computeCountsPerTypePerBranch(
      LikelihoodCalculationSingleProcess& rltc,
      const std::vector<uint>& ids,
      std::shared_ptr<const SubstitutionRegisterInterface> reg,
      std::shared_ptr<const AlphabetIndex2> weights = 0,
      std::shared_ptr<const AlphabetIndex2> distances = 0,
      short unresolvedOption = UNRESOLVED_ZERO,
      double threshold = -1,
      bool verbose = true);
 
  static Vdouble getCountsForSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      size_t site,
      const std::vector<uint>& ids = Vuint(0));
 
  static Vdouble getCountsForSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      size_t site,
      bool perTimeUnit,
      uint siteSize = 1);
 
  static Vdouble getCountsForSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      size_t site,
      const std::vector<uint>& ids,
      bool perTimeUnit,
      uint siteSize = 1);
 
  static VVdouble getCountsPerSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      const std::vector<uint>& ids = Vuint(0));
 
  static VVdouble getCountsPerSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      bool perTimeUnit,
      uint siteSize = 1);
 
  static VVdouble getCountsPerSitePerType(
      const ProbabilisticSubstitutionMapping& counts,
      const ProbabilisticSubstitutionMapping& factors,
      const std::vector<uint>& ids,
      bool perTimeUnit,
      uint siteSize = 1);
 
  static double getNormForSite(
      const ProbabilisticSubstitutionMapping& counts,
      size_t site);
 
  static void outputPerSitePerBranch(const std::string& filename,
      const std::vector<uint>& ids,
      const AlignmentDataInterface& sites,
      const VVdouble& counts);
 
  static void outputPerSitePerType(const std::string& filename,
      const SubstitutionRegisterInterface& reg,
      const AlignmentDataInterface& sites,
      const VVdouble& counts);
 
  static void outputPerType(const std::string& filename,
      const SubstitutionRegisterInterface& reg,
      const AlignmentDataInterface& sites,
      const VVdouble& counts);
 
  static void outputPerSitePerBranchPerType(const std::string& filenamePrefix,
      const std::vector<uint>& ids,
      const SubstitutionRegisterInterface& reg,
      const AlignmentDataInterface& sites,
      const VVVdouble& counts);
 
 
  static void writeToStream(
      const ProbabilisticSubstitutionMapping& substitutions,
      const AlignmentDataInterface& sites,
      size_t type,
      std::ostream& out);
 
  static void readFromStream(
      std::istream& in,
      ProbabilisticSubstitutionMapping& substitutions,
      size_t type);
 
};
} // end of namespace bpp.
 
 
#endif // BPP_PHYL_MAPPING_SUBSTITUTIONMAPPINGTOOLS_H