CodonFrequencySet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MODEL_FREQUENCYSET_CODONFREQUENCYSET_H
#define BPP_PHYL_MODEL_FREQUENCYSET_CODONFREQUENCYSET_H
 
#include <Bpp/Numeric/Prob/Simplex.h>
#include <Bpp/Seq/Alphabet/CodonAlphabet.h>
#include <Bpp/Seq/GeneticCode/GeneticCode.h>
 
#include "FrequencySet.h"
#include "ProteinFrequencySet.h"
#include "WordFrequencySet.h"
 
namespace bpp
{
class CodonFrequencySetInterface :
  public virtual FrequencySetInterface
{
public:
  CodonFrequencySetInterface* clone() const override = 0;
 
  virtual std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const = 0;
 
public:
  virtual std::shared_ptr<const GeneticCode> getGeneticCode() const = 0;
 
  static std::unique_ptr<CodonFrequencySetInterface> getFrequencySetForCodons(
      short option,
      std::shared_ptr<const GeneticCode> gCode,
      const std::string& mgmtStopCodon = "quadratic",
      unsigned short method = 1);
 
  static const short F0;
  static const short F1X4;
  static const short F3X4;
  static const short F61;
};
 
 
class FullCodonFrequencySet :
  public virtual CodonFrequencySetInterface,
  public AbstractFrequencySet
{
protected:
  std::shared_ptr<const GeneticCode> pgc_;
 
private:
  Simplex sFreq_;
 
public:
  FullCodonFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      bool allowNullFreqs = false,
      unsigned short method = 1,
      const std::string& name = "Full");
 
  FullCodonFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      const std::vector<double>& initFreqs,
      bool allowNullFreqs = false,
      unsigned short method = 1,
      const std::string& name = "Full");
 
  FullCodonFrequencySet(const FullCodonFrequencySet& fcfs);
  FullCodonFrequencySet& operator=(const FullCodonFrequencySet& fcfs);
 
  FullCodonFrequencySet* clone() const override { return new FullCodonFrequencySet(*this); }
 
public:
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  void setFrequencies(const std::vector<double>& frequencies) override;
 
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override
  {
    return std::dynamic_pointer_cast<const CodonAlphabet>(getAlphabet());
  }
 
  void setNamespace(const std::string& nameSpace) override;
 
  unsigned short getMethod() const
  {
    return sFreq_.getMethod();
  }
 
protected:
  void fireParameterChanged(const ParameterList& parameters) override;
 
  void updateFreq_();
};
 
 
class FixedCodonFrequencySet :
  public virtual CodonFrequencySetInterface,
  public AbstractFrequencySet
{
protected:
  std::shared_ptr<const GeneticCode> pgc_;
 
public:
  FixedCodonFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      const std::vector<double>& initFreqs,
      const std::string& name = "Fixed");
 
  FixedCodonFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      const std::string& name = "Fixed");
 
  FixedCodonFrequencySet(const FixedCodonFrequencySet& fcfs) :
    AbstractFrequencySet(fcfs),
    pgc_(fcfs.pgc_)
  {}
 
  FixedCodonFrequencySet& operator=(const FixedCodonFrequencySet& fcfs)
  {
    AbstractFrequencySet::operator=(fcfs);
    pgc_ = fcfs.pgc_;
    return *this;
  }
 
  FixedCodonFrequencySet* clone() const override { return new FixedCodonFrequencySet(*this); }
 
public:
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override
  {
    return std::dynamic_pointer_cast<const CodonAlphabet>(getAlphabet());
  }
 
  void setFrequencies(const std::vector<double>& frequencies) override;
 
protected:
  void fireParameterChanged(const ParameterList& parameters) override {}
};
 
class UserCodonFrequencySet :
  public virtual CodonFrequencySetInterface,
  public UserFrequencySet
{
protected:
  std::shared_ptr<const GeneticCode> pgc_;
 
public:
  UserCodonFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      const std::string& path,
      size_t nCol = 1);
 
  UserCodonFrequencySet(const UserCodonFrequencySet& fcfs) :
    UserFrequencySet(fcfs),
    pgc_(fcfs.pgc_)
  {}
 
  UserCodonFrequencySet& operator=(const UserCodonFrequencySet& fcfs)
  {
    UserFrequencySet::operator=(fcfs);
    pgc_ = fcfs.pgc_;
    return *this;
  }
 
  UserCodonFrequencySet* clone() const override { return new UserCodonFrequencySet(*this); }
 
public:
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override
  {
    return std::dynamic_pointer_cast<const CodonAlphabet>(getAlphabet());
  }
 
  void setFrequencies(const std::vector<double>& frequencies) override;
 
protected:
  void fireParameterChanged(const ParameterList& parameters) override {}
};
 
class FullPerAACodonFrequencySet :
  public virtual CodonFrequencySetInterface,
  public AbstractFrequencySet
{
private:
  std::shared_ptr<const GeneticCode> pgc_;
  std::unique_ptr<ProteinFrequencySetInterface> ppfs_;
 
  std::vector<Simplex> vS_;
 
  void updateFrequencies_();
 
public:
  FullPerAACodonFrequencySet(
      std::shared_ptr<const GeneticCode> gencode,
      std::unique_ptr<ProteinFrequencySetInterface> ppfs,
      unsigned short method = 1);
 
  FullPerAACodonFrequencySet(
      std::shared_ptr<const GeneticCode> gencode,
      unsigned short method = 1);
 
  FullPerAACodonFrequencySet(const FullPerAACodonFrequencySet& ffs);
 
  FullPerAACodonFrequencySet& operator=(const FullPerAACodonFrequencySet& ffs);
 
  virtual ~FullPerAACodonFrequencySet() {}
 
  FullPerAACodonFrequencySet* clone() const override { return new FullPerAACodonFrequencySet(*this); }
 
public:
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override
  {
    return std::dynamic_pointer_cast<const CodonAlphabet>(getAlphabet());
  }
 
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  void setFrequencies(const std::vector<double>& frequencies) override;
 
  void setNamespace(const std::string& prefix) override;
 
  bool hasProteinFrequencySet() const
  {
    return ppfs_ != nullptr;
  }
 
  const ProteinFrequencySetInterface& proteinFrequencySet() const
  {
    return *ppfs_;
  }
 
  unsigned short getMethod() const
  {
    return vS_.size() > 0 ? vS_[0].getMethod() : static_cast<unsigned short>(1);
  }
 
protected:
  void fireParameterChanged(const ParameterList& parameters) override;
};
 
 
class CodonFromIndependentFrequencySet :
  public virtual CodonFrequencySetInterface,
  public WordFromIndependentFrequencySet
{
private:
  // a map associating stop codons numbers with numbers of neighbour non-stop codons
  std::map<int, Vint> mStopNeigh_;
 
  unsigned short mgmtStopCodon_;
 
  std::shared_ptr<const GeneticCode> pgc_;
 
public:
  CodonFromIndependentFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      std::vector<std::unique_ptr<FrequencySetInterface>>& freqvector,
      const std::string& name = "Codon",
      const std::string& mgmtStopCodon = "quadratic");
 
  CodonFromIndependentFrequencySet(const CodonFromIndependentFrequencySet& iwfs);
 
  virtual ~CodonFromIndependentFrequencySet(){}
 
  CodonFromIndependentFrequencySet& operator=(const CodonFromIndependentFrequencySet& iwfs);
 
  CodonFromIndependentFrequencySet* clone() const override { return new CodonFromIndependentFrequencySet(*this); }
 
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override;
 
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  void updateFrequencies() override;
 
  std::string getMgmtStopCodon() const
  {
    switch (mgmtStopCodon_)
    {
    case 0:
      return "uniform";
    case 1:
      return "linear";
    case 2:
      return "quadratic";
    }
    return "";
  }
};
 
 
class CodonFromUniqueFrequencySet :
  public virtual CodonFrequencySetInterface,
  public WordFromUniqueFrequencySet
{
private:
  // a map associating stop codons numbers with numbers of neighbour non-stop codons
  std::map<int, Vint> mStopNeigh_;
 
  unsigned short mgmtStopCodon_;
 
  std::shared_ptr<const GeneticCode> pgc_;
 
public:
  CodonFromUniqueFrequencySet(
      std::shared_ptr<const GeneticCode> gCode,
      std::unique_ptr<FrequencySetInterface> pfreq,
      const std::string& name = "Codon",
      const std::string& mgmtStopCodon = "quadratic");
 
  CodonFromUniqueFrequencySet(const CodonFromUniqueFrequencySet& iwfs);
 
  virtual ~CodonFromUniqueFrequencySet() {}
 
  CodonFromUniqueFrequencySet& operator=(const CodonFromUniqueFrequencySet& iwfs);
 
  CodonFromUniqueFrequencySet* clone() const override { return new CodonFromUniqueFrequencySet(*this); }
 
  std::shared_ptr<const CodonAlphabet> getCodonAlphabet() const override;
 
  std::shared_ptr<const GeneticCode> getGeneticCode() const override { return pgc_; }
 
  void updateFrequencies() override;
 
  std::string getMgmtStopCodon() const
  {
    switch (mgmtStopCodon_)
    {
    case 0:
      return "uniform";
    case 1:
      return "linear";
    case 2:
      return "quadratic";
    }
    return "";
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_MODEL_FREQUENCYSET_CODONFREQUENCYSET_H