MixedSubstitutionModelSet.h

Go to the documentation of this file.

//
// File: MixedSubstitutionModelSet.h
// Created by: Laurent Guéguen
// Created on: mercredi 25 mai 2011, à 22h 04
//

/*
   Copyright or (c) or Copr. Bio++ Development Team, (November 16, 2004)

   This software is a computer program whose purpose is to provide classes
   for phylogenetic data analysis.

   This software is governed by the CeCILL  license under French law and
   abiding by the rules of distribution of free software.  You can  use,
   modify and/ or redistribute the software under the terms of the CeCILL
   license as circulated by CEA, CNRS and INRIA at the following URL
   "http://www.cecill.info".

   As a counterpart to the access to the source code and  rights to copy,
   modify and redistribute granted by the license, users are provided only
   with a limited warranty  and the software's author,  the holder of the
   economic rights,  and the successive licensors  have only  limited
   liability.

   In this respect, the user's attention is drawn to the risks associated
   with loading,  using,  modifying and/or developing or reproducing the
   software by the user in light of its specific status of free software,
   that may mean  that it is complicated to manipulate,  and  that  also
   therefore means  that it is reserved for developers  and  experienced
   professionals having in-depth computer knowledge. Users are therefore
   encouraged to load and test the software's suitability as regards their
   requirements in conditions enabling the security of their systems and/or
   data to be ensured and,  more generally, to use and operate it in the
   same conditions as regards security.

   The fact that you are presently reading this means that you have had
   knowledge of the CeCILL license and that you accept its terms.
 */

#ifndef _MIXEDSUBSTITUTIONMODELSET_H_
#define _MIXEDSUBSTITUTIONMODELSET_H_


#include "SubstitutionModelSet.h"
#include "AbstractSubstitutionModel.h"

#include <Bpp/Exceptions.h>
#include <Bpp/Numeric/VectorTools.h>

namespace bpp
{
class MixedSubstitutionModelSet :
  public SubstitutionModelSet
{
public:
  class HyperNode
  {
public:
    class Node
    {
      Vint vNumb_;

public:
      Node() : vNumb_() {}
      Node(const Node& n) : vNumb_(n.vNumb_){}
      Node& operator=(const Node& n)
      {
        vNumb_ = n.vNumb_;
        return *this;
      }

      ~Node(){}

      Node& operator=(const Vint& n)
      {
        vNumb_ = n;
        return *this;
      }

      void insertN(const Vint& 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;

      int operator[](size_t i) const { return vNumb_[i]; }
    };

private:
    std::vector<Node> vNumbers_;

    Vint vUnused_;

    double proba_;

public:
    HyperNode(const MixedSubstitutionModelSet*);
    HyperNode(const HyperNode&);
    HyperNode& operator=(const HyperNode&);
    ~HyperNode(){}

    void setModel(size_t nM, const Vint& vnS);

    void addToModel(size_t nM, const Vint& 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(const Alphabet* alpha) :
    SubstitutionModelSet(alpha),
    vpHyperNodes_() {}

  ~MixedSubstitutionModelSet();

  MixedSubstitutionModelSet(const MixedSubstitutionModelSet& set);

  MixedSubstitutionModelSet(const SubstitutionModelSet& set);

  MixedSubstitutionModelSet& operator=(const MixedSubstitutionModelSet& set);

#ifndef NO_VIRTUAL_COV
  MixedSubstitutionModelSet*
#else
  Clonable*
#endif
  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 Vint& 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 // _MIXEDSUBSTITUTIONMODELSET_H_