AbstractWordSubstitutionModel.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_ABSTRACTWORDSUBSTITUTIONMODEL_H
#define BPP_PHYL_MODEL_ABSTRACTWORDSUBSTITUTIONMODEL_H
 
 
#include "AbstractSubstitutionModel.h"
 
// From bpp-seq:
#include <Bpp/Seq/Alphabet/WordAlphabet.h>
 
// From the STL:
#include <vector>
 
namespace bpp
{
class ModelList
{
protected:
  std::vector<std::shared_ptr<SubstitutionModelInterface>> models_;
  std::shared_ptr<WordAlphabet> wordAlphabet_;
 
public:
  ModelList(std::vector<std::unique_ptr<SubstitutionModelInterface>>& models) :
    models_(models.size()), wordAlphabet_(nullptr)
  {
    std::vector<std::shared_ptr<const Alphabet>> alphabets(models.size());
    for (size_t i = 0; i < models.size(); ++i)
    {
      alphabets[i] = models[i]->getAlphabet();
      models_[i] = std::move(models[i]);
    }
    wordAlphabet_ = std::make_shared<WordAlphabet>(alphabets);
  }
 
private:
  ModelList(const ModelList& ml) {}
 
  ModelList& operator=(const ModelList& ml) { return *this; }
 
public:
  size_t size() const { return models_.size(); }
 
  std::shared_ptr<SubstitutionModelInterface> getModel(size_t i)
  {
    return models_[i];
  }
 
  std::shared_ptr<const WordAlphabet> getWordAlphabet()
  {
    return wordAlphabet_;
  }
};
 
 
class AbstractWordSubstitutionModel :
  public AbstractSubstitutionModel
{
private:
  bool newAlphabet_;
 
protected:
  std::vector<std::shared_ptr<SubstitutionModelInterface>> VSubMod_;
 
  std::vector<std::string> VnestedPrefix_;
 
  std::vector<double> Vrate_;
 
protected:
  void updateMatrices_();
 
  virtual void completeMatrices_() = 0;
 
  virtual void fillBasicGenerator_();
 
public:
  AbstractWordSubstitutionModel(
      ModelList& modelList,
      const std::string& prefix);
 
  AbstractWordSubstitutionModel(
      std::unique_ptr<SubstitutionModelInterface> model,
      unsigned int num,
      const std::string& prefix);
 
  AbstractWordSubstitutionModel(const AbstractWordSubstitutionModel&);
 
  AbstractWordSubstitutionModel& operator=(const AbstractWordSubstitutionModel&);
 
  virtual ~AbstractWordSubstitutionModel() {}
 
  void setNamespace(const std::string& prefix);
 
protected:
  AbstractWordSubstitutionModel(
      std::shared_ptr<const Alphabet> alph,
      std::shared_ptr<const StateMapInterface> stateMap,
      const std::string& prefix);
 
public:
  const SubstitutionModelInterface& nModel(size_t i) const
  {
    if (i < VSubMod_.size())
      return *VSubMod_[i];
    else
      throw NullPointerException("AbstractWordSubstitutionModel::nModel. Invalid model requested.");
  }
 
  size_t getNumberOfModels() const
  {
    return VSubMod_.size();
  }
 
  virtual void setFreq(std::map<int, double>& freqs);
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_ABSTRACTWORDSUBSTITUTIONMODEL_H