ProbabilisticRewardMapping.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_MAPPING_PROBABILISTICREWARDMAPPING_H
#define BPP_PHYL_MAPPING_PROBABILISTICREWARDMAPPING_H
 
#include <Bpp/Text/TextTools.h>
 
#include "../Likelihood/DataFlow/DataFlowCWise.h"
#include "../Tree/PhyloTreeExceptions.h"
#include "PhyloBranchReward.h"
#include "Reward.h"
#include "RewardMapping.h"
 
// From the STL:
#include <vector>
 
namespace bpp
{
class ProbabilisticRewardMapping :
  public AbstractRewardMapping,
  public AssociationTreeGlobalGraphObserver<PhyloNode, PhyloBranchReward>
{
public:
  typedef AssociationTreeGlobalGraphObserver<PhyloNode, PhyloBranchReward> mapTree;
 
private:
  PatternType rootPatternLinks_;
 
  bool usePatterns_;
 
  size_t numberOfDistinctSites_;
 
public:
  typedef mapTree::EdgeIterator EdgeIterator;
  typedef mapTree::NodeIterator NodeIterator;
 
public:
  ProbabilisticRewardMapping(const PhyloTree& tree, size_t numberOfSites) :
    AbstractRewardMapping(), mapTree(tree), rootPatternLinks_(), usePatterns_(false), numberOfDistinctSites_(numberOfSites)
  {
    std::unique_ptr<mapTree::EdgeIterator> nIT = allEdgesIterator();
    for ( ; !nIT->end(); nIT->next())
    {
      (**nIT)->setNumberOfSites(numberOfDistinctSites_);
    }
  }
 
  ProbabilisticRewardMapping(const PhyloTree& tree, const PatternType& rootpatterns, size_t nbDistinctSites) :
    AbstractRewardMapping(), mapTree(tree), rootPatternLinks_(rootpatterns), usePatterns_(true), numberOfDistinctSites_(nbDistinctSites)
  {
    std::unique_ptr<mapTree::EdgeIterator> nIT = allEdgesIterator();
    for ( ; !nIT->end(); nIT->next())
    {
      (**nIT)->setNumberOfSites(numberOfDistinctSites_);
    }
  }
 
  ProbabilisticRewardMapping(const PhyloTree& tree) :
    AbstractRewardMapping(), mapTree(tree), rootPatternLinks_(), usePatterns_(false), numberOfDistinctSites_(0)
  {}
 
 
  ProbabilisticRewardMapping* clone() const override { return new ProbabilisticRewardMapping(*this); }
 
  ProbabilisticRewardMapping(const ProbabilisticRewardMapping& prm) :
    AbstractRewardMapping(prm), mapTree(prm), rootPatternLinks_(prm.rootPatternLinks_), usePatterns_(prm.usePatterns_), numberOfDistinctSites_(prm.numberOfDistinctSites_)
  {}
 
  ProbabilisticRewardMapping& operator=(const ProbabilisticRewardMapping& prm)
  {
    AbstractMapping::operator=(prm);
    mapTree::operator=(prm);
 
    rootPatternLinks_ = prm.rootPatternLinks_;
    usePatterns_ = prm.usePatterns_;
    numberOfDistinctSites_ = prm.numberOfDistinctSites_;
    return *this;
  }
 
  virtual ~ProbabilisticRewardMapping() {}
 
public:
  /*
   * @brief From Mapping interface
   *
   * @{
   */
  const PhyloBranch& getBranch(unsigned int branchIndex) const override
  {
    return *getEdge(branchIndex);
  }
 
  PhyloBranch& getBranch(unsigned int branchIndex) override
  {
    return *getEdge(branchIndex);
  }
 
  size_t getNumberOfBranches() const override
  {
    return getNumberOfEdges();
  }
 
  size_t getNumberOfDistinctSites() const
  {
    return numberOfDistinctSites_;
  }
 
  /*
   * @}
   */
 
  virtual double getReward(int branchId, size_t site) const
  {
    return getEdge((uint)branchId)->getSiteReward(getSiteIndex(site));
  }
 
  virtual void setNumberOfSites(size_t numberOfSites) override;
 
  virtual double operator()(uint branchId, size_t siteIndex) const override
  {
    return (*getEdge(branchId))(siteIndex);
  }
 
  virtual double& operator()(uint branchId, size_t siteIndex) override
  {
    return (*getEdge(branchId))(siteIndex);
  }
 
  bool usePatterns() const
  {
    return usePatterns_;
  }
 
  const PatternType& getPatterns() const
  {
    return rootPatternLinks_;
  }
 
  const size_t getSiteIndex(size_t site) const
  {
    return rootPatternLinks_[Eigen::Index(site)];
  }
};
} // end of namespace bpp.
#endif // BPP_PHYL_MAPPING_PROBABILISTICREWARDMAPPING_H