RegisterRatesSubstitutionModel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_REGISTERRATESSUBSTITUTIONMODEL_H
#define BPP_PHYL_MODEL_REGISTERRATESSUBSTITUTIONMODEL_H
 
#include <Bpp/Numeric/AbstractParameterAliasable.h>
 
#include "../Mapping/SubstitutionRegister.h"
#include "AbstractSubstitutionModel.h"
#include "AbstractWrappedModel.h"
#include "AnonymousSubstitutionModel.h"
 
namespace bpp
{
class RegisterRatesSubstitutionModel :
  public AbstractWrappedSubstitutionModel,
  public AbstractSubstitutionModel
{
private:
  std::unique_ptr<SubstitutionModelInterface> originalModel_;
 
  std::string registerName_;
 
  VVVuint vRegStates_;
  size_t nbTypes_;
 
  Vdouble vRates_;
 
public:
  RegisterRatesSubstitutionModel(
      std::unique_ptr<SubstitutionModelInterface> originalModel,
      const SubstitutionRegisterInterface& reg,
      bool isNormalized = false);
 
 
  RegisterRatesSubstitutionModel(const RegisterRatesSubstitutionModel& fmsm) :
    AbstractParameterAliasable(fmsm),
    AbstractWrappedModel(fmsm),
    AbstractWrappedTransitionModel(fmsm),
    AbstractWrappedSubstitutionModel(fmsm),
    AbstractSubstitutionModel(fmsm),
    originalModel_(fmsm.originalModel_->clone()),
    registerName_(fmsm.registerName_),
    vRegStates_(fmsm.vRegStates_),
    nbTypes_(fmsm.nbTypes_),
    vRates_(fmsm.vRates_)
  {}
 
 
  RegisterRatesSubstitutionModel& operator=(const RegisterRatesSubstitutionModel& fmsm)
  {
    AbstractWrappedSubstitutionModel::operator=(fmsm);
    AbstractSubstitutionModel::operator=(fmsm);
 
    originalModel_.reset(fmsm.originalModel_->clone());
    registerName_ = fmsm.registerName_;
    vRegStates_ = fmsm.vRegStates_;
    nbTypes_ = fmsm.nbTypes_;
    vRates_ = fmsm.vRates_;
 
    return *this;
  }
 
  virtual ~RegisterRatesSubstitutionModel() {}
 
  RegisterRatesSubstitutionModel* clone() const override
  {
    return new RegisterRatesSubstitutionModel(*this);
  }
 
public:
  const SubstitutionModelInterface& substitutionModel() const override
  {
    return *originalModel_;
  }
 
  const TransitionModelInterface& transitionModel() const override
  {
    return *originalModel_;
  }
 
protected:
  SubstitutionModelInterface& substitutionModel_() override
  {
    return *originalModel_;
  }
 
 
  TransitionModelInterface& transitionModel_() override
  {
    return *originalModel_;
  }
 
public:
  void fireParameterChanged(const ParameterList& parameters) override
  {
    substitutionModel_().matchParametersValues(parameters);
    AbstractParameterAliasable::fireParameterChanged(parameters);
    updateMatrices_();
  }
 
  size_t getNumberOfStates() const override
  {
    return stateMap().getNumberOfModelStates();
  }
 
public:
  std::string getName() const override
  {
    return "FromRegister";
  }
 
  const std::string& getRegisterName() const
  {
    return registerName_;
  }
 
  void addRateParameter() override
  {
    throw Exception("RegisterRatesSubstitutionModel::addRateParameter method should not be called, because rates are defined through registers.");
  }
 
  const std::vector<int>& getAlphabetStates() const override
  {
    return AbstractWrappedSubstitutionModel::getAlphabetStates();
  }
 
  std::vector<size_t> getModelStates(int i) const override
  {
    return AbstractWrappedSubstitutionModel::getModelStates(i);
  }
 
  std::vector<size_t> getModelStates(const std::string& s) const override
  {
    return AbstractWrappedSubstitutionModel::getModelStates(s);
  }
 
  int getAlphabetStateAsInt(size_t i) const override
  {
    return AbstractWrappedSubstitutionModel::getAlphabetStateAsInt(i);
  }
 
  std::string getAlphabetStateAsChar(size_t s) const override
  {
    return AbstractWrappedSubstitutionModel::getAlphabetStateAsChar(s);
  }
 
  const Alphabet& alphabet() const override
  {
    return AbstractWrappedSubstitutionModel::alphabet();
  }
 
  std::shared_ptr<const Alphabet> getAlphabet() const override
  {
    return AbstractWrappedSubstitutionModel::getAlphabet();
  }
 
  const StateMapInterface& stateMap() const override
  {
    return AbstractWrappedSubstitutionModel::stateMap();
  }
 
  std::shared_ptr<const StateMapInterface> getStateMap() const override
  {
    return AbstractWrappedSubstitutionModel::getStateMap();
  }
 
  const FrequencySetInterface& frequencySet() const override
  {
    return AbstractWrappedSubstitutionModel::frequencySet();
  }
 
  void setRate(double rate) override { model_().setRate(rate); }
 
  double getRate() const override { return model().getRate(); }
 
private:
  void setRegStates_();
 
protected:
  void updateMatrices_() override;
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_REGISTERRATESSUBSTITUTIONMODEL_H