MixedSubstitutionModelSet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LEGACY_MODEL_MIXEDSUBSTITUTIONMODELSET_H
#define BPP_PHYL_LEGACY_MODEL_MIXEDSUBSTITUTIONMODELSET_H
 
#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/VectorTools.h>
 
#include "../../Model/AbstractSubstitutionModel.h"
#include "SubstitutionModelSet.h"
 
// From the STL:
#include <memory>
 
namespace bpp
{
class MixedSubstitutionModelSet :
  public SubstitutionModelSet,
  public std::enable_shared_from_this<MixedSubstitutionModelSet>
{
public:
  class HyperNode
  {
public:
    class Node
    {
      Vuint vNumb_;
 
public:
      Node() : vNumb_() {}
      Node(const Node& n) : vNumb_(n.vNumb_){}
      Node& operator=(const Node& n)
      {
        vNumb_ = n.vNumb_;
        return *this;
      }
 
      virtual ~Node(){}
 
      Node& operator=(const Vuint& n)
      {
        vNumb_ = n;
        return *this;
      }
 
      void insertN(const Vuint& vn);
 
      size_t size() const
      {
        return vNumb_.size();
      }
 
      Node& operator+=(const Node&);
 
      bool operator<=(const Node&) const;
 
      bool operator>=(const Node&) const;
 
      bool intersects(const Node&) const;
 
      uint operator[](size_t i) const { return vNumb_[i]; }
    };
 
private:
    std::vector<Node> vNumbers_;
 
    Vuint vUnused_;
 
    double proba_;
 
public:
    HyperNode(std::shared_ptr<const MixedSubstitutionModelSet> );
    HyperNode(const HyperNode&);
    HyperNode& operator=(const HyperNode&);
    ~HyperNode(){}
 
    void setModel(size_t nM, const Vuint& vnS);
 
    void addToModel(size_t nM, const Vuint& vnS);
    HyperNode& operator+=(const HyperNode&);
 
    bool operator<=(const HyperNode&) const;
 
    bool isComplete() const;
    bool operator>=(const HyperNode&) const;
 
    bool intersects(const HyperNode&) const;
 
    double getProbability() const {return proba_; }
 
    void setProbability(double x) { proba_ = x; }
 
    const Node& getNode(size_t i) const { return vNumbers_[i]; }
  };
 
private:
  std::vector<HyperNode*> vpHyperNodes_;
 
public:
  MixedSubstitutionModelSet(std::shared_ptr<const Alphabet> alpha) :
    SubstitutionModelSet(alpha),
    vpHyperNodes_() {}
 
  ~MixedSubstitutionModelSet();
 
  MixedSubstitutionModelSet(const MixedSubstitutionModelSet& set);
 
  MixedSubstitutionModelSet(const SubstitutionModelSet& set);
 
  MixedSubstitutionModelSet& operator=(const MixedSubstitutionModelSet& set);
 
  MixedSubstitutionModelSet* clone() const { return new MixedSubstitutionModelSet(*this); }
 
  void clear();
 
  /*
   *@brief adds a new empty HyperNode to the end of the HyperNodes
   * list.
   */
 
  void addEmptyHyperNode();
 
  /*
   *@brief adds the copy of an HyperNode to the end of the
   * HyperNodes list.
   */
 
  void addHyperNode(const HyperNode& hn);
 
  /*
   *@brief If necessary, adds a new HyperNode such that all
   *       submodels of the mixture models are at least in an
   *       HyperNode.
   *
   * Returns true iff a new path has been built.
   *
   */
 
  bool complete();
 
  /*
   *@brief adds a submodel number to the nMth mixed model of the
   *  nHth HyperNode of the list (default nH=0). Checks if all the
   *  numbers are valid.
   *
   *@param nM number of the mixed model
   *@param vnS number of the submodel
   *@param nH number of the concerned HyperNode (default the last element of
   *     the list)
   */
 
  void addToHyperNode(size_t nM, const Vuint& vnS, int nH = -1);
 
  size_t getNumberOfHyperNodes() const { return vpHyperNodes_.size(); }
 
  HyperNode& getHyperNode(size_t i) {return *vpHyperNodes_[i]; }
 
  const HyperNode& getHyperNode(size_t i) const {return *vpHyperNodes_[i]; }
 
  /*
   *@brief Checks if all the path (ie hypernodes) are exclusive.
   *
   */
 
  bool hasExclusivePaths() const;
 
  void fireParameterChanged(const ParameterList& parameters);
 
  /*
   *@brief compute the probabilities in all the HyperNodes
   *
   */
 
  void computeHyperNodesProbabilities();
 
  /*
   *@brief computes the probability of an HyperNode, given the
   *     conditional probabilities of the submodels computed from the
   *     hypernodes of this MixedSubstitutionModelSet object. If the
   *     HyperNode does not match the structure of allowed by this
   *     MixedSubstitutionModelSet, an Exception is thrown.
   *
   *     The probability of an HyperNode is the product -- on the set
   *     of the mixed models -- of the sums of the conditional
   *     probabilities of the submodels that belon to this hypernode
   *     for each mixed model.
   *
   *@param hn the HyperNode which conditional probability is computed.
   */
 
  double getHyperNodeProbability(const HyperNode& hn) const;
};
} // end of namespace bpp.
#endif // BPP_PHYL_LEGACY_MODEL_MIXEDSUBSTITUTIONMODELSET_H