ModelPath.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LIKELIHOOD_MODELPATH_H
#define BPP_PHYL_LIKELIHOOD_MODELPATH_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/VectorTools.h>
 
#include "../Model/MixedTransitionModel.h"
 
namespace bpp
{
class ModelPath
{
public:
  class PathNode : public Vuint
  {
public:
    PathNode() {}
    PathNode(const PathNode& n) : Vuint(n){}
 
    ~PathNode(){}
 
    void insertN(const Vuint& vn);
 
    void removeN(const Vuint& vn);
 
 
    PathNode& operator=(const Vuint& vn)
    {
      clear();
      insertN(vn);
      return *this;
    }
 
    PathNode& operator+=(const PathNode& n)
    {
      insertN(n);
      return *this;
    }
 
    PathNode& operator-=(const PathNode& n)
    {
      removeN(n);
      return *this;
    }
 
    bool operator<=(const PathNode&) const;
 
    bool operator>=(const PathNode&) const;
 
    bool intersects(const PathNode&) const;
 
    std::string to_string() const;
  };
 
private:
  std::map<std::shared_ptr<MixedTransitionModelInterface>, PathNode> mModPath_;
 
  std::shared_ptr<MixedTransitionModelInterface> leadMod_;
 
  double proba_;
 
public:
  ModelPath() : mModPath_(), leadMod_(0), proba_(0) {}
  ModelPath(const ModelPath&);
  ModelPath& operator=(const ModelPath&);
  ~ModelPath(){}
 
  size_t size() const
  {
    return mModPath_.size();
  }
 
  std::shared_ptr<MixedTransitionModelInterface> getLeadModel()
  {
    return leadMod_;
  }
 
  const std::shared_ptr<MixedTransitionModelInterface> getLeadModel() const
  {
    return leadMod_;
  }
 
  void setLeadModel(std::shared_ptr<MixedTransitionModelInterface> model)
  {
    if (mModPath_.find(model) == mModPath_.end())
      throw Exception("ModelPath::setLeadModel: Unknown model " + model->getName());
    leadMod_ = model;
  }
 
  void setModel(std::shared_ptr<MixedTransitionModelInterface> mMod, const Vuint& vnS);
 
  void changeModel(std::shared_ptr<MixedTransitionModelInterface> mMod1,
      std::shared_ptr<MixedTransitionModelInterface> mMod2);
 
  void removeModel(std::shared_ptr<MixedTransitionModelInterface> mMod)
  {
    if (mMod == leadMod_)
      leadMod_ = 0;
 
    if (mModPath_.find(mMod) != mModPath_.end())
      mModPath_.erase(mMod);
  }
 
  void addToModel(std::shared_ptr<MixedTransitionModelInterface> mMod, const Vuint& vnS);
 
  ModelPath& operator+=(const ModelPath&);
 
  ModelPath& operator-=(const ModelPath&);
 
  bool operator<=(const ModelPath&) const;
 
  bool operator>=(const ModelPath&) const;
 
  bool intersects(const ModelPath&) const;
 
  double getProbability() const {return proba_; }
 
  void setProbability(double x) { proba_ = x; }
 
  bool hasModel(std::shared_ptr<MixedTransitionModelInterface> mMod) const
  { return mModPath_.find(mMod) != mModPath_.end(); }
 
  bool hasModel(std::shared_ptr<const MixedTransitionModelInterface> mMod) const
  {
    for (const auto& mn:mModPath_)
    {
      if (mn.first == mMod)
        return true;
    }
    return false;
  }
 
  const PathNode& getPathNode(std::shared_ptr<MixedTransitionModelInterface> mMod) const
  { return mModPath_.at(mMod); }
 
  const PathNode& getPathNode(std::shared_ptr<const MixedTransitionModelInterface> mMod) const
  {
    for (const auto& mn:mModPath_)
    {
      if (mn.first == mMod)
        return mn.second;
    }
    throw Exception("ModelPath::getPathNode : unknown model " + mMod->getName());
  }
 
  std::vector<std::shared_ptr<MixedTransitionModelInterface>> getModels() const;
 
  std::string toString() const;
};
} // end of namespace bpp.
#endif // BPP_PHYL_LIKELIHOOD_MODELPATH_H