DistanceEstimation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_DISTANCE_DISTANCEESTIMATION_H
#define BPP_PHYL_DISTANCE_DISTANCEESTIMATION_H
 
#include <Bpp/Clonable.h>
#include <Bpp/Numeric/Function/MetaOptimizer.h>
#include <Bpp/Numeric/Function/Optimizer.h>
#include <Bpp/Numeric/Function/SimpleMultiDimensions.h>
#include <Bpp/Numeric/ParameterList.h>
#include <Bpp/Numeric/Prob/DiscreteDistribution.h>
 
#include "../Likelihood/SubstitutionProcess.h"
#include "../PseudoNewtonOptimizer.h"
#include "../Likelihood/PhyloLikelihoods/SingleProcessPhyloLikelihood.h"
#include "../Likelihood/RateAcrossSitesSubstitutionProcess.h"
 
// From bpp-seq:
#include <Bpp/Seq/Container/AlignmentData.h>
 
// From the STL:
#include <memory>
 
namespace bpp
{
class DistanceEstimation :
  public virtual Clonable
{
private:
  std::shared_ptr<SubstitutionProcessInterface> process_;
  size_t numProc_; // needed if in Collection Process
  std::shared_ptr<const AlignmentDataInterface> sites_;
  std::shared_ptr<DistanceMatrix> dist_;
  std::shared_ptr<OptimizerInterface> optimizer_;
  std::shared_ptr<MetaOptimizer> defaultOptimizer_;
  size_t verbose_;
  ParameterList parameters_;
 
public:
  DistanceEstimation(
      std::shared_ptr<SubstitutionProcessInterface> process,
      size_t verbose = 1) :
    process_(process),
    numProc_(0),
    sites_(0),
    dist_(0),
    optimizer_(0),
    defaultOptimizer_(0),
    verbose_(verbose),
    parameters_()
  {
    init_();
  }
 
  DistanceEstimation(
      std::shared_ptr<BranchModelInterface> model,
      std::shared_ptr<DiscreteDistributionInterface> rateDist,
      size_t verbose = 1) :
    process_(),
    numProc_(0),
    sites_(0),
    dist_(0),
    optimizer_(0),
    defaultOptimizer_(0),
    verbose_(verbose),
    parameters_()
  {
    process_ = std::make_shared<RateAcrossSitesSubstitutionProcess>(model, rateDist);
    init_();
  }
 
  DistanceEstimation(
      std::shared_ptr<SubstitutionProcessInterface> process,
      std::shared_ptr<const AlignmentDataInterface> sites,
      size_t verbose = 1,
      bool computeMat = true) :
    process_(process),
    numProc_(0),
    sites_(sites),
    dist_(0),
    optimizer_(0),
    defaultOptimizer_(0),
    verbose_(verbose),
    parameters_()
  {
    init_();
    if (computeMat) computeMatrix();
  }
 
  DistanceEstimation(
      std::shared_ptr<BranchModelInterface> model,
      std::shared_ptr<DiscreteDistributionInterface> rateDist,
      std::shared_ptr<const AlignmentDataInterface> sites,
      size_t verbose = 1,
      bool computeMat = true) :
    process_(),
    numProc_(0),
    sites_(sites),
    dist_(0),
    optimizer_(0),
    defaultOptimizer_(0),
    verbose_(verbose),
    parameters_()
  {
    process_ = std::make_shared<RateAcrossSitesSubstitutionProcess>(model, rateDist);
    init_();
    if (computeMat) computeMatrix();
  }
 
  DistanceEstimation(const DistanceEstimation& distanceEstimation) :
    process_(distanceEstimation.process_),
    numProc_(distanceEstimation.numProc_),
    sites_(distanceEstimation.sites_),
    dist_(0),
    optimizer_(distanceEstimation.optimizer_),
    defaultOptimizer_(distanceEstimation.defaultOptimizer_),
    verbose_(distanceEstimation.verbose_),
    parameters_(distanceEstimation.parameters_)
  {
    if (distanceEstimation.dist_ != 0)
      dist_ = std::make_shared<DistanceMatrix>(*distanceEstimation.dist_);
    else
      dist_ = 0;
  }
 
  DistanceEstimation& operator=(const DistanceEstimation& distanceEstimation)
  {
    process_    = distanceEstimation.process_;
    numProc_    = distanceEstimation.numProc_;
    sites_      = distanceEstimation.sites_;
    if (distanceEstimation.dist_)
      dist_     = std::make_shared<DistanceMatrix>(*distanceEstimation.dist_);
    else
      dist_     = 0;
    optimizer_  = distanceEstimation.optimizer_;
    // _defaultOptimizer has already been initialized since the default constructor has been called.
    verbose_    = distanceEstimation.verbose_;
    parameters_ = distanceEstimation.parameters_;
    return *this;
  }
 
  virtual ~DistanceEstimation() {}
 
  DistanceEstimation* clone() const override { return new DistanceEstimation(*this); }
 
private:
  void init_();
 
public:
  void computeMatrix();
 
  std::unique_ptr<DistanceMatrix> getMatrix() const
  {
    return dist_ == nullptr ? nullptr : std::make_unique<DistanceMatrix>(*dist_);
  }
 
  bool hasProcess() const { return process_.get(); }
 
  const SubstitutionProcessInterface& process() const
  {
    if (hasProcess())
      return *process_;
    else
      throw Exception("DistanceEstimation::getSubstitutionModel(). No process associated to this instance.");
  }
 
  std::shared_ptr<const SubstitutionProcessInterface> getProcess() const
  {
    return process_;
  }
 
  void setProcess(std::shared_ptr<SubstitutionProcessInterface> process = nullptr) { process_ = process; }
 
  void setData(std::shared_ptr<const AlignmentDataInterface> sites = nullptr) { sites_ = sites; }
 
  std::shared_ptr<const AlignmentDataInterface> getData() const { return sites_; }
 
  const AlignmentDataInterface& data() const { return *sites_; }
 
  void setOptimizer(std::shared_ptr<OptimizerInterface> optimizer)
  {
    optimizer_ = optimizer;
  }
 
  std::shared_ptr<const OptimizerInterface> getOptimizer() const { return optimizer_; }
 
  std::shared_ptr<OptimizerInterface> getOptimizer() { return optimizer_; }
 
  const OptimizerInterface& optimizer() const { return *optimizer_; }
 
  OptimizerInterface& optimizer() { return *optimizer_; }
 
  void resetOptimizer() { optimizer_ = dynamic_pointer_cast<OptimizerInterface>(defaultOptimizer_); }
 
  bool matchParametersValues(const ParameterList& parameters)
  {
    if (hasProcess())
      return process_->matchParametersValues(parameters);
    return false;
  }
 
  void setAdditionalParameters(const ParameterList& parameters)
  {
    parameters_ = parameters;
  }
 
  void resetAdditionalParameters()
  {
    parameters_.reset();
  }
 
  void setVerbose(size_t verbose) { verbose_ = verbose; }
  size_t getVerbose() const { return verbose_; }
};
} // end of namespace bpp.
#endif // BPP_PHYL_DISTANCE_DISTANCEESTIMATION_H