PhylogeneticsApplicationTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_APP_PHYLOGENETICSAPPLICATIONTOOLS_H
#define BPP_PHYL_APP_PHYLOGENETICSAPPLICATIONTOOLS_H
 
#include "../Likelihood/ModelScenario.h"
#include "../Likelihood/PhyloLikelihoods/PhyloLikelihoodContainer.h"
#include "../Likelihood/PhyloLikelihoods/AlignedPhyloLikelihoodSet.h"
#include "../Likelihood/PhyloLikelihoods/SingleDataPhyloLikelihood.h"
#include "../Likelihood/SequenceEvolution.h"
#include "../Likelihood/AutonomousSubstitutionProcess.h"
#include "../Likelihood/SubstitutionProcessCollection.h"
#include "../Likelihood/SubstitutionProcessCollectionMember.h"
#include "../Mapping/SubstitutionCount.h"
#include "../Model/MarkovModulatedSubstitutionModel.h"
#include "../Model/SubstitutionModel.h"
#include "../Tree/PhyloTree.h"
#include "../Likelihood/DataFlow/DataFlow.h"
 
// From bpp-core:
#include <Bpp/Io/OutputStream.h>
#include <Bpp/Numeric/Function/Optimizer.h>
#include <Bpp/Numeric/Prob/DiscreteDistribution.h>
#include <Bpp/Numeric/Prob/MultipleDiscreteDistribution.h>
#include <Bpp/Text/TextTools.h>
 
// From bpp-seq:
#include <Bpp/Seq/Container/SiteContainer.h>
#include <Bpp/Seq/Container/VectorSiteContainer.h>
#include <Bpp/Seq/AlphabetIndex/AlphabetIndex2.h>
#include <Bpp/Seq/Io/BppOAlphabetIndex2Format.h>
 
// From the STL:
#include <string>
#include <map>
#include <memory>
#include <vector>
 
namespace bpp
{
class PhylogeneticsApplicationTools
{
public:
  PhylogeneticsApplicationTools();
  virtual ~PhylogeneticsApplicationTools();
 
 
  static std::unique_ptr<Tree> getTree(
      const std::map<std::string, std::string>& params,
      const std::string& prefix = "input.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::vector<std::unique_ptr<Tree>> getTrees(
      const std::map<std::string, std::string>& params,
      const std::string& prefix = "input.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::map<size_t, std::shared_ptr<PhyloTree>> getPhyloTrees(
      const std::map<std::string, std::string>& params,
      const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mSeq,
      std::map<std::string, std::string>& unparsedParams,
      const std::string& prefix = "input.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<BranchModelInterface> getBranchModel(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      std::shared_ptr<const AlignmentDataInterface> data,
      const std::map<std::string, std::string>& params,
      std::map<std::string, std::string>& unparsedparams,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<SubstitutionModelInterface> getSubstitutionModel(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      std::shared_ptr<const AlignmentDataInterface> data,
      const std::map<std::string, std::string>& params,
      std::map<std::string, std::string>& unparsedparams,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
 
  static std::map<size_t, std::unique_ptr<BranchModelInterface>> getBranchModels(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mData,
      const std::map<std::string, std::string>& params,
      std::map<std::string, std::string>& unparsedparams,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<FrequencySetInterface> getRootFrequencySet(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mData,
      size_t nData, 
      const std::map<std::string, std::string>& params,
      std::map<std::string, std::string>& sharedparams,
      const std::vector<double>& rateFreqs,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<FrequencySetInterface> getRootFrequencySet(
    std::shared_ptr<const Alphabet> alphabet,
    std::shared_ptr<const GeneticCode> gCode,
    std::shared_ptr<const AlignmentDataInterface> data,
    const std::map<std::string, std::string>& params,
    std::map<std::string, std::string>& sharedparams,
    const std::vector<double>& rateFreqs,
    const std::string& suffix = "",
    bool suffixIsOptional = true,
    bool verbose = true,
    int warn = 1)
  {
    std::map<size_t, std::shared_ptr<const AlignmentDataInterface>> mData;
    mData[1]=data;
    
    return getRootFrequencySet(alphabet, gCode, mData, 1, params, sharedparams, rateFreqs, suffix, suffixIsOptional, verbose, warn);
  }
 
  static std::map<size_t, std::unique_ptr<FrequencySetInterface>> getRootFrequencySets(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mData,
      const std::map<std::string, std::string>& params,
      std::map<std::string, std::string>& sharedparams,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<FrequencySetInterface> getFrequencySet(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      const std::string& freqDescription,
      std::shared_ptr<const AlignmentDataInterface> data,
      std::map<std::string, std::string>& sharedParams,
      const std::vector<double>& rateFreqs,
      bool verbose = true,
      int warn = 1)
  {
    std::map<size_t, std::shared_ptr<const AlignmentDataInterface>> mData;
    mData[1]=data;
 
    return getFrequencySet(alphabet, gCode, freqDescription, mData, 1, sharedParams, rateFreqs, verbose, warn);
  }
 
  static std::unique_ptr<FrequencySetInterface> getFrequencySet(
    std::shared_ptr<const Alphabet> alphabet,
    std::shared_ptr<const GeneticCode> gCode,
    const std::string& freqDescription,
    const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mData,
    size_t nData,
    std::map<std::string, std::string>& sharedParams,
    const std::vector<double>& rateFreqs,
    bool verbose = true,
    int warn = 1);
 
  static map<size_t, std::unique_ptr<ModelPath>> getModelPaths(
      const std::map<std::string, std::string>& params,
      const map<size_t, std::shared_ptr<BranchModelInterface>>& mModel,
      const string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static map<size_t, std::unique_ptr<ModelScenario>> getModelScenarios(
      const std::map<std::string, std::string>& params,
      const map<size_t, std::shared_ptr<ModelPath>>& mModelPath,
      const map<size_t, std::shared_ptr<BranchModelInterface>>& mModel,
      const string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<SubstitutionRegisterInterface> getSubstitutionRegister(
      const std::string& regTypeDesc,
      std::shared_ptr<const StateMapInterface> stateMap,
      std::shared_ptr<const GeneticCode> genCode,
      std::shared_ptr<AlphabetIndex2>& weights,
      std::shared_ptr<AlphabetIndex2>& distances,
      bool verbose = true);
 
  static std::unique_ptr<AutonomousSubstitutionProcessInterface> getSubstitutionProcess(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      std::shared_ptr<const AlignmentDataInterface> data,
      const vector<std::shared_ptr<PhyloTree>>& vTree,
      const std::map<std::string, std::string>& params,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static std::unique_ptr<SubstitutionProcessCollection> getSubstitutionProcessCollection(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const GeneticCode> gCode,
      const map<size_t, std::shared_ptr<PhyloTree>>& mTree,
      const map<size_t, std::shared_ptr<BranchModelInterface>>& mMod,
      const map<size_t, std::shared_ptr<FrequencySetInterface>>& mRootFreq,
      const map<size_t, std::shared_ptr<DiscreteDistributionInterface>>& mDist,
      const map<size_t, std::shared_ptr<ModelScenario>>& mScen,
      const std::map<std::string, std::string>& params,
      map<string, string>& unparsedparams,
      const string& suffix = "",
      bool suffixIsOptional  = true,
      bool verbose = true,
      int warn = 1);
 
 
  static bool addSubstitutionProcessCollectionMember(
      SubstitutionProcessCollection& SubProColl,
      size_t procNum,
      const std::map<std::string, std::string>& params,
      bool verbose = true,
      int warn = 1);
 
 
  static std::map<size_t, std::unique_ptr<SequenceEvolution>> getSequenceEvolutions(
      std::shared_ptr<SubstitutionProcessCollection> SPC,
      const std::map<std::string, std::string>& params,
      map<string, string>& unparsedParams,
      const string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
 
  static std::shared_ptr<PhyloLikelihoodContainer> getPhyloLikelihoodContainer(
      Context& context,
      std::shared_ptr<SubstitutionProcessCollection> SPC,
      std::map<size_t, std::shared_ptr<SequenceEvolution>>& mSeqEvol,
      const std::map<size_t, std::shared_ptr<const AlignmentDataInterface>>& mData,
      const std::map<std::string, std::string>& params,
      const string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static MultipleDiscreteDistribution* getMultipleDistributionDefaultInstance(
      const std::string& distDescription,
      std::map<std::string, std::string>& unparsedParameterValues,
      bool verbose = true);
 
  static std::unique_ptr<DiscreteDistributionInterface> getRateDistribution(
      const std::map<std::string, std::string>& params,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true);
 
  static std::map<size_t, std::shared_ptr<DiscreteDistributionInterface>> getRateDistributions(
      const std::map<std::string, std::string>& params,
      const string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true);
 
  static std::shared_ptr<PhyloLikelihoodInterface> optimizeParameters(
      std::shared_ptr<PhyloLikelihoodInterface> lik,
      const std::map<std::string, std::string>& params,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      int warn = 1);
 
  static void checkEstimatedParameters(const ParameterList& pl);
 
  static std::unique_ptr<SubstitutionCountInterface> getSubstitutionCount(
      std::shared_ptr<const Alphabet> alphabet,
      std::shared_ptr<const SubstitutionModelInterface> model,
      const std::map<std::string, std::string>& params,
      string suffix = "",
      bool verbose = true,
      int warn = 1);
 
  static void writeTree(
      const TreeTemplate<Node>& tree,
      const std::map<std::string, std::string>& params,
      const std::string& prefix = "output.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      bool checkOnly = false,
      int warn = 1);
 
  static void writePhyloTrees(
      const std::vector<const PhyloTree*>& trees,
      const std::map<std::string, std::string>& params,
      const std::string& prefix = "output.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      bool checkOnly = false,
      int warn = 1);
 
  static void writePhyloTrees(
      const SubstitutionProcessCollection& spc,
      const std::map<std::string, std::string>& params,
      const std::string& prefix = "output.",
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verbose = true,
      bool checkOnly = false,
      bool withIds = false,
      int warn = 1);
 
 
  static void printParameters(const BranchModelInterface& model, OutputStream& out, int warn = 1);
 
  static void printParameters(const SubstitutionProcessInterface& process, OutputStream& out, int warn = 1);
 
  static void printParameters(const SubstitutionProcessCollection& collection, OutputStream& out, int warn = 1, bool withAlias = true);
 
  static void printParameters(const PhyloLikelihoodContainer& phylocont, OutputStream& out, int warn = 1);
 
 
  static void printParameters(const SingleDataPhyloLikelihoodInterface& phylolike, OutputStream& out, size_t nPhylo = 1, int warn = 1);
 
  static void printParameters(const SequenceEvolution& evol, OutputStream& out, size_t nEvol = 1, int warn = 1);
 
  static void printParameters(const DiscreteDistributionInterface& rDist, OutputStream& out, bool withAlias = true);
 
  static void printAnalysisInformation(const PhyloLikelihoodContainer& phylocont, const std::string& infosFile, int warn = 1);
 
  static void printAnalysisInformation(const SingleDataPhyloLikelihoodInterface& phylolike, const std::string& infosFile, int warn = 1);
 
  static void printAnalysisInformation(const AlignedPhyloLikelihoodSetInterface& sOAP, const std::string& infosFile, int warn = 1);
 
  template<class T>
  static std::map<size_t, std::shared_ptr<T>> uniqueToSharedMap(std::map<size_t, std::unique_ptr<T>>& mu)
  {
    std::map<size_t, std::shared_ptr<T>> ms;
    for (auto& it : mu)
    {
      std::shared_ptr<T> pt = std::move(it.second);
      ms.emplace(it.first, pt);
    }
    return ms;
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_APP_PHYLOGENETICSAPPLICATIONTOOLS_H