SubstitutionProcessCollectionMember.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LIKELIHOOD_SUBSTITUTIONPROCESSCOLLECTIONMEMBER_H
#define BPP_PHYL_LIKELIHOOD_SUBSTITUTIONPROCESSCOLLECTIONMEMBER_H
 
 
#include "AbstractSubstitutionProcess.h"
 
namespace bpp
{
class SubstitutionProcessCollection;
 
class SubstitutionProcessCollectionMember :
  public AbstractSubstitutionProcess
{
private:
  SubstitutionProcessCollection* pSubProColl_;
 
  size_t nProc_;
 
private:
  void updateParameters();
 
private:
  std::map<unsigned int, size_t> nodeToModel_;
  std::map<size_t, std::vector<unsigned int>> modelToNodes_;
 
  size_t nTree_;
 
  size_t nDist_;
 
  size_t nRoot_;
 
  size_t nPath_;
 
private:
  /*
   * @brief Constructors are only accessible through a SubstitutionProcessCollection.
   */
 
  SubstitutionProcessCollectionMember(
      SubstitutionProcessCollection* pSubProColl,
      size_t nProc,
      size_t nTree,
      size_t nDist) :
    AbstractParameterAliasable(""),
    pSubProColl_(pSubProColl),
    nProc_(nProc),
    nodeToModel_(),
    modelToNodes_(),
    nTree_(nTree),
    nDist_(nDist),
    nRoot_(0),
    nPath_(0)
  {
    updateParameters();
  }
 
  SubstitutionProcessCollectionMember(const SubstitutionProcessCollectionMember& set) :
    AbstractParameterAliasable(set),
    pSubProColl_(set.pSubProColl_),
    nProc_(set.nProc_),
    nodeToModel_(set.nodeToModel_),
    modelToNodes_(set.modelToNodes_),
    nTree_(set.nTree_),
    nDist_(set.nDist_),
    nRoot_(set.nRoot_),
    nPath_(set.nPath_)
  {}
 
  SubstitutionProcessCollectionMember& operator=(const SubstitutionProcessCollectionMember& set)
  {
    AbstractParameterAliasable::operator=(set);
    pSubProColl_ = set.pSubProColl_;
    nProc_ = set.nProc_;
 
    nodeToModel_ = set.nodeToModel_;
    modelToNodes_ = set.modelToNodes_;
    nTree_ = set.nTree_;
    nDist_ = set.nDist_;
    nRoot_ = set.nRoot_;
    nPath_ = set.nPath_;
 
    return *this;
  }
 
  virtual ~SubstitutionProcessCollectionMember() {}
 
  struct Deleter
  {
    void operator()(SubstitutionProcessCollectionMember* sm) const
    {
      delete sm;
    }
  };
 
  SubstitutionProcessCollectionMember* clone() const override { return new SubstitutionProcessCollectionMember(*this); }
 
public:
  const SubstitutionProcessCollection& collection() const
  {
    if (!pSubProColl_)
      throw NullPointerException("SubstitutionProcessCollectionMember::collection(). Member is not associated to any collection.");
    return *pSubProColl_;
  }
 
  SubstitutionProcessCollection& collection()
  {
    if (!pSubProColl_)
      throw NullPointerException("SubstitutionProcessCollectionMember::collection(). Member is not associated to any collection.");
    return *pSubProColl_;
  }
 
  void clear()
  {
    nodeToModel_.clear();
    modelToNodes_.clear();
    nRoot_ = 0;
  }
 
  const SubstitutionProcessCollection* getCollection() const
  {
    return pSubProColl_;
  }
 
  SubstitutionProcessCollection* getCollection()
  {
    return pSubProColl_;
  }
 
  const StateMapInterface& stateMap() const override
  {
    return model(modelToNodes_.begin()->first).stateMap();
  }
 
  std::shared_ptr<const StateMapInterface> getStateMap() const override
  {
    return model(modelToNodes_.begin()->first).getStateMap();
  }
 
  size_t getNumberOfProcesses() const
  {
    return nProc_;
  }
 
  size_t getNumberOfModels() const override { return modelToNodes_.size(); }
 
  bool hasMixedTransitionModel() const;
 
  bool isStationary() const
  {
    return nRoot_ == 0;
  }
 
  const BranchModelInterface& model(size_t n) const override;
 
  std::shared_ptr<const BranchModelInterface> getModel(size_t n) const override;
 
  std::shared_ptr<BranchModelInterface> getModel(size_t n);
 
  std::vector<size_t> getModelNumbers() const override;
 
  size_t getModelNumberForNode(unsigned int nodeId) const override
  {
    auto i = nodeToModel_.find(nodeId);
    if (i == nodeToModel_.end())
      throw Exception("SubstitutionProcessCollectionMember::getModelNumberForNode(). No model associated to node with id " + TextTools::toString(nodeId));
    return i->second;
  }
 
  std::shared_ptr<const BranchModelInterface> getModelForNode(unsigned int nodeId) const override
  {
    std::map<unsigned int, size_t>::const_iterator i = nodeToModel_.find(nodeId);
    if (i == nodeToModel_.end())
      throw Exception("SubstitutionProcessCollectionMember::getModelForNode(). No model associated to node with id " + TextTools::toString(nodeId));
    return getModel(i->second);
  }
 
  const std::vector<unsigned int> getNodesWithModel(size_t i) const override
  {
    const auto it = modelToNodes_.find(i);
    if (it == modelToNodes_.end())
      throw Exception("SubstitutionProcessCollectionMember::getNodesWithModel(). No nodes associated with model " + TextTools::toString(i));
 
    return it->second;
  }
 
  void addModel(size_t numModel, const std::vector<unsigned int>& nodesId);
 
  const DiscreteDistributionInterface& rateDistribution() const override;
 
  DiscreteDistributionInterface& rateDistribution() override;
 
  std::shared_ptr<const DiscreteDistributionInterface> getRateDistribution() const override;
 
  std::shared_ptr<DiscreteDistributionInterface> getRateDistribution() override;
 
  const size_t getRateDistributionNumber() const { return nDist_; }
 
  void setRootFrequencies(size_t numFreq);
 
  const size_t getRootFrequenciesNumber() const { return nRoot_; }
 
  bool hasRootFrequencySet() const override { return !isStationary(); }
 
  const FrequencySetInterface& rootFrequencySet() const override;
 
  FrequencySetInterface& rootFrequencySet() override;
 
  std::shared_ptr<const FrequencySetInterface> getRootFrequencySet() const override;
 
  std::shared_ptr<FrequencySetInterface> getRootFrequencySet() override;
 
  /*
   * @brief Set the Set of Model Path
   * @param numPath the index of the frequencies in the collection.
   *
   * This method checks that the models defined in the process match
   * those of the model paths.
   */
  void setModelScenario(size_t numPath);
 
  const size_t getModelScenarioNumber() const { return nPath_; }
 
  std::shared_ptr<const ModelScenario> getModelScenario() const override;
 
  std::shared_ptr<ModelScenario> getModelScenario();
 
  bool matchParametersValues(const ParameterList& parameters) override;
 
  bool isFullySetUp(bool throwEx = true) const
  {
    return checkOrphanNodes(throwEx)
           && checkUnknownNodes(throwEx);
  }
 
protected:
  bool checkOrphanNodes(bool throwEx) const;
 
  bool checkUnknownNodes(bool throwEx) const;
public:
  const std::vector<double>& getRootFrequencies() const override;
 
  const ParametrizablePhyloTree& parametrizablePhyloTree() const override;
 
  std::shared_ptr<const ParametrizablePhyloTree> getParametrizablePhyloTree() const override;
 
  ParametrizablePhyloTree& parametrizablePhyloTree();
 
  std::shared_ptr<ParametrizablePhyloTree> getParametrizablePhyloTree();
 
public:
  /*
   * @brief set a new tree number from the collection
   *
   * @param nTree  number of the tree
   * @param check if models assignment on branches is correct
   *
   */
  
  void setTreeNumber(size_t nTree, bool check = true);
  
  size_t getTreeNumber() const { return nTree_; }
 
  const BranchModelInterface& model(unsigned int nodeId, size_t classIndex) const override
  {
    return model(nodeToModel_.at(nodeId));
  }
 
  std::shared_ptr<const BranchModelInterface> getModel(unsigned int nodeId, size_t classIndex) const override
  {
    return getModel(nodeToModel_.at(nodeId));
  }
 
 
  ParameterList getSubstitutionModelParameters(bool independent) const override;
 
  ParameterList getRateDistributionParameters(bool independent) const override;
 
  ParameterList getBranchLengthParameters(bool independent) const override;
 
  ParameterList getRootFrequenciesParameters(bool independent) const override;
 
  ParameterList getNonDerivableParameters() const override;
 
  double getProbabilityForModel(size_t classIndex) const override;
 
  Vdouble getClassProbabilities() const override;
 
  double getRateForModel(size_t classIndex) const override;
 
  friend class SubstitutionProcessCollection;
};
} // end of namespace bpp.
#endif // BPP_PHYL_LIKELIHOOD_SUBSTITUTIONPROCESSCOLLECTIONMEMBER_H