RE08.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_RE08_H
#define BPP_PHYL_MODEL_RE08_H
 
 
#include "AbstractSubstitutionModel.h"
#include "Codon/CodonSubstitutionModel.h"
#include "Nucleotide/NucleotideSubstitutionModel.h"
#include "Protein/ProteinSubstitutionModel.h"
#include "SubstitutionModel.h"
 
namespace bpp
{
class RE08 :
  public AbstractReversibleSubstitutionModel
{
private:
  std::unique_ptr<ReversibleSubstitutionModelInterface> simpleModel_;
  RowMatrix<double> simpleGenerator_;
  RowMatrix<double> simpleExchangeabilities_;
  mutable double exp_;
  mutable RowMatrix<double> p_;
  double lambda_;
  double mu_;
  std::string nestedPrefix_;
 
public:
  RE08(
      std::unique_ptr<ReversibleSubstitutionModelInterface> simpleModel,
      double lambda = 0.1,
      double mu = 0.1);
 
  RE08(const RE08& model) :
    AbstractParameterAliasable(model),
    AbstractReversibleSubstitutionModel(model),
    simpleModel_(model.simpleModel_->clone()),
    simpleGenerator_(model.simpleGenerator_),
    simpleExchangeabilities_(model.simpleExchangeabilities_),
    exp_(model.exp_),
    p_(model.p_),
    lambda_(model.lambda_),
    mu_(model.mu_),
    nestedPrefix_(model.nestedPrefix_)
  {}
 
  RE08& operator=(const RE08& model)
  {
    AbstractParameterAliasable::operator=(model);
    AbstractReversibleSubstitutionModel::operator=(model);
    simpleModel_.reset(model.simpleModel_->clone());
    simpleGenerator_         = model.simpleGenerator_;
    simpleExchangeabilities_ = model.simpleExchangeabilities_;
    exp_                     = model.exp_;
    p_                       = model.p_;
    lambda_                  = model.lambda_;
    mu_                      = model.mu_;
    nestedPrefix_            = model.nestedPrefix_;
    return *this;
  }
 
  virtual ~RE08() {}
 
  RE08* clone() const override { return new RE08(*this); }
 
public:
  double Pij_t    (size_t i, size_t j, double d) const override;
  double dPij_dt  (size_t i, size_t j, double d) const override;
  double d2Pij_dt2(size_t i, size_t j, double d) const override;
  const Matrix<double>& getPij_t    (double d) const override;
  const Matrix<double>& getdPij_dt  (double d) const override;
  const Matrix<double>& getd2Pij_dt2(double d) const override;
 
  std::string getName() const override { return "RE08"; }
 
  void setFreqFromData(const SequenceDataInterface& data, double pseudoCount = 0) override
  {
    simpleModel_->setFreqFromData(data, pseudoCount);
  }
 
  void setFreq(std::map<int, double>& frequencies) override
  {
    simpleModel_->setFreq(frequencies);
  }
 
  void fireParameterChanged(const ParameterList& parameters) override
  {
    simpleModel_->matchParametersValues(parameters);
    lambda_ = getParameter_(0).getValue();
    mu_     = getParameter_(1).getValue();
    updateMatrices_();
  }
 
  double getInitValue(size_t i, int state) const override;
 
  void setNamespace(const std::string& prefix) override;
 
  const ReversibleSubstitutionModelInterface& nestedModel() const
  {
    return *simpleModel_;
  }
 
protected:
  void updateMatrices_() override;
 
  ReversibleSubstitutionModelInterface& nestedModel_() { return *simpleModel_; }
};
 
 
class RE08Nucleotide :
  public RE08,
  public virtual NucleotideSubstitutionModelInterface
{
public:
  RE08Nucleotide(
      std::unique_ptr<NucleotideReversibleSubstitutionModelInterface> nucleotideModel,
      double lambda = 0.1,
      double mu = 0.1) :
    AbstractParameterAliasable("RE08."),
    RE08(std::move(nucleotideModel), lambda, mu) {}
 
  virtual ~RE08Nucleotide() {}
 
  RE08Nucleotide* clone() const override { return new RE08Nucleotide(*this); }
 
public:
  std::shared_ptr<const NucleicAlphabet> getNucleicAlphabet() const override
  {
    return std::dynamic_pointer_cast<const NucleicAlphabet>(alphabet_);
  }
 
  const NucleotideReversibleSubstitutionModelInterface& nestedModel() const
  {
    return dynamic_cast<const NucleotideReversibleSubstitutionModelInterface&>(RE08::nestedModel());
  }
 
  size_t getNumberOfStates() const override { return RE08::getNumberOfStates(); }
};
 
class RE08Protein :
  public RE08,
  public virtual ProteinSubstitutionModelInterface
{
public:
  RE08Protein(
      std::unique_ptr<ProteinReversibleSubstitutionModelInterface> proteinModel,
      double lambda = 0.1,
      double mu = 0.1) :
    AbstractParameterAliasable("RE08."),
    RE08(std::move(proteinModel), lambda, mu) {}
 
  virtual ~RE08Protein() {}
 
  RE08Protein* clone() const override { return new RE08Protein(*this); }
 
public:
  std::shared_ptr<const ProteicAlphabet> getProteicAlphabet() const override
  {
    return std::dynamic_pointer_cast<const ProteicAlphabet>(alphabet_);
  }
 
  const ProteinReversibleSubstitutionModelInterface& nestedModel() const
  {
    return dynamic_cast<const ProteinReversibleSubstitutionModelInterface&>(RE08::nestedModel());
  }
 
  size_t getNumberOfStates() const override { return RE08::getNumberOfStates(); }
};
 
 
class RE08Codon :
  public RE08,
  public virtual CodonSubstitutionModelInterface
{
public:
  RE08Codon(
      std::unique_ptr<CodonReversibleSubstitutionModelInterface> codonModel,
      double lambda = 0.1,
      double mu = 0.1) :
    AbstractParameterAliasable("RE08."),
    RE08(std::move(codonModel), lambda, mu) {}
 
  virtual ~RE08Codon() {}
 
  RE08Codon* clone() const override { return new RE08Codon(*this); }
 
public:
  const CodonReversibleSubstitutionModelInterface& nestedModel() const
  {
    return dynamic_cast<const CodonReversibleSubstitutionModelInterface&>(RE08::nestedModel());
  }
 
  std::shared_ptr<const GeneticCode> getGeneticCode () const override
  {
    return nestedModel().getGeneticCode();
  }
 
  double getCodonsMulRate(size_t i, size_t j) const override
  {
    return nestedModel().getCodonsMulRate(i, j);
  }
 
  size_t getNumberOfStates() const override { return RE08::getNumberOfStates(); }
 
  const CodonFrequencySetInterface& codonFrequencySet() const override
  {
    return dynamic_cast<const CodonFrequencySetInterface&>(RE08::nestedModel().frequencySet());
  }
 
  bool hasCodonFrequencySet() const override
  {
    return true;
  }
 
  void setFreq(std::map<int, double>& frequencies) override
  {
    RE08::nestedModel_().setFreq(frequencies);
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_RE08_H