DRHomogeneousTreeLikelihood.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LEGACY_LIKELIHOOD_DRHOMOGENEOUSTREELIKELIHOOD_H
#define BPP_PHYL_LEGACY_LIKELIHOOD_DRHOMOGENEOUSTREELIKELIHOOD_H
 
#include <Bpp/Numeric/Prob/DiscreteDistribution.h>
#include <Bpp/Numeric/VectorTools.h>
 
#include "AbstractHomogeneousTreeLikelihood.h"
#include "DRASDRTreeLikelihoodData.h"
#include "DRTreeLikelihood.h"
 
namespace bpp
{
class DRHomogeneousTreeLikelihood :
  public AbstractHomogeneousTreeLikelihood,
  public virtual DRTreeLikelihoodInterface
{
private:
  mutable std::unique_ptr<DRASDRTreeLikelihoodData> likelihoodData_;
 
protected:
  double minusLogLik_;
 
public:
  DRHomogeneousTreeLikelihood(
      const Tree& tree,
      std::shared_ptr<TransitionModelInterface> model,
      std::shared_ptr<DiscreteDistributionInterface> rDist,
      bool checkRooted = true,
      bool verbose = true);
 
  DRHomogeneousTreeLikelihood(
      const Tree& tree,
      const AlignmentDataInterface& data,
      std::shared_ptr<TransitionModelInterface> model,
      std::shared_ptr<DiscreteDistributionInterface> rDist,
      bool checkRooted = true,
      bool verbose = true);
 
  DRHomogeneousTreeLikelihood(const DRHomogeneousTreeLikelihood& lik);
 
  DRHomogeneousTreeLikelihood& operator=(const DRHomogeneousTreeLikelihood& lik);
 
  virtual ~DRHomogeneousTreeLikelihood() {}
 
  DRHomogeneousTreeLikelihood* clone() const override { return new DRHomogeneousTreeLikelihood(*this); }
 
private:
  void init_();
 
public:
  void setData(const AlignmentDataInterface& sites) override;
  double getLikelihood() const override;
  double getLogLikelihood() const override;
  double getLikelihoodForASite (size_t site) const override;
  double getLogLikelihoodForASite(size_t site) const override;
  size_t getSiteIndex(size_t site) const override { return likelihoodData_->getRootArrayPosition(site); }
  void computeTreeLikelihood();
 
 
  double getLikelihoodForASiteForARateClass(size_t site, size_t rateClass) const override;
  double getLogLikelihoodForASiteForARateClass(size_t site, size_t rateClass) const override;
  double getLikelihoodForASiteForARateClassForAState(size_t site, size_t rateClass, int state) const override;
  double getLogLikelihoodForASiteForARateClassForAState(size_t site, size_t rateClass, int state) const override;
  void setParameters(const ParameterList& parameters) override;
 
  double getValue() const override;
 
  double getFirstOrderDerivative(const std::string& variable) const override;
  double getSecondOrderDerivative(const std::string& variable) const override;
  double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const override { return 0; } // Not implemented for now.
public:
  // Specific methods:
 
  DRASDRTreeLikelihoodData& likelihoodData() override { return *likelihoodData_; }
  const DRASDRTreeLikelihoodData& likelihoodData() const override { return *likelihoodData_; }
 
  virtual void computeLikelihoodAtNode(int nodeId, VVVdouble& likelihoodArray) const override
  {
    computeLikelihoodAtNode_(tree_->getNode(nodeId), likelihoodArray);
  }
 
protected:
  virtual void computeLikelihoodAtNode_(const Node* node, VVVdouble& likelihoodArray, const Node* sonNode = 0) const;
 
  virtual void computeSubtreeLikelihoodPostfix(const Node* node); // Recursive method.
  virtual void computeSubtreeLikelihoodPrefix(const Node* node); // Recursive method.
 
  virtual void computeRootLikelihood();
 
  virtual void computeTreeDLikelihoodAtNode(const Node* node);
  virtual void computeTreeDLikelihoods();
 
  virtual void computeTreeD2LikelihoodAtNode(const Node* node);
  virtual void computeTreeD2Likelihoods();
 
  virtual void fireParameterChanged(const ParameterList& params) override;
 
  virtual void resetLikelihoodArrays(const Node* node);
 
  virtual void displayLikelihood(const Node* node);
 
  static void computeLikelihoodFromArrays(
      const std::vector<const VVVdouble*>& iLik,
      const std::vector<const VVVdouble*>& tProb,
      VVVdouble& oLik, size_t nbNodes,
      size_t nbDistinctSites,
      size_t nbClasses,
      size_t nbStates,
      bool reset = true);
 
  static void computeLikelihoodFromArrays(
      const std::vector<const VVVdouble*>& iLik,
      const std::vector<const VVVdouble*>& tProb,
      const VVVdouble* iLikR,
      const VVVdouble* tProbR,
      VVVdouble& oLik,
      size_t nbNodes,
      size_t nbDistinctSites,
      size_t nbClasses,
      size_t nbStates,
      bool reset = true);
 
  friend class DRHomogeneousMixedTreeLikelihood;
};
} // end of namespace bpp.
#endif // BPP_PHYL_LEGACY_LIKELIHOOD_DRHOMOGENEOUSTREELIKELIHOOD_H