MixtureOfATransitionModel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_MIXTUREOFATRANSITIONMODEL_H
#define BPP_PHYL_MODEL_MIXTUREOFATRANSITIONMODEL_H
 
#include <Bpp/Numeric/Prob/DiscreteDistribution.h>
#include <Bpp/Numeric/VectorTools.h>
#include <cstring> // C lib for string copy
#include <map>
#include <string>
#include <vector>
 
#include "AbstractMixedTransitionModel.h"
 
namespace bpp
{
class MixtureOfATransitionModel :
  public AbstractMixedTransitionModel
{
private:
  std::map<std::string, std::unique_ptr<DiscreteDistributionInterface>> distributionMap_;
 
protected:
  int from_, to_;
 
public:
  MixtureOfATransitionModel(
      std::shared_ptr<const Alphabet> alpha,
      std::unique_ptr<TransitionModelInterface> model,
      std::map<std::string, std::unique_ptr<DiscreteDistributionInterface>>& parametersDistributionsList,
      int ffrom = -1, int tto = -1);
 
  MixtureOfATransitionModel(const MixtureOfATransitionModel&);
 
  MixtureOfATransitionModel& operator=(const MixtureOfATransitionModel&);
 
  virtual ~MixtureOfATransitionModel();
 
  MixtureOfATransitionModel* clone() const override { return new MixtureOfATransitionModel(*this); }
 
public:
  std::string getName() const override { return "MixedModel"; }
 
  const TransitionModelInterface& model(const std::string& name) const override
  {
    size_t nbmod = getNumberOfModels();
 
    for (size_t i = 0; i < nbmod; ++i)
    {
      auto& model = nModel(i);
      if (model.getName() == name)
        return model;
    }
 
    throw NullPointerException("MixtureOfATransitionModel::model(). No model with the specified name.");
  }
 
  const TransitionModelInterface& model(size_t i) const
  {
    return AbstractMixedTransitionModel::nModel(i);
  }
 
  Vuint getSubmodelNumbers(const std::string& desc) const override;
 
  void setFreq(std::map<int, double>&) override;
 
  bool hasDistribution(std::string& parName) const
  {
    return distributionMap_.find(parName) != distributionMap_.end();
  }
 
  const DiscreteDistributionInterface& distribution(std::string& parName) const
  {
    if (distributionMap_.find(parName) != distributionMap_.end())
      return *distributionMap_.find(parName)->second;
    else
      throw Exception("MixtureOfATransitionModel::distribution(). No distribution with name: '" + parName + "'.");
  }
 
 
  int from() const { return from_; }
 
  int to() const { return to_; }
 
protected:
  void updateMatrices_() override;
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_MIXTUREOFATRANSITIONMODEL_H