ProcessComputationTree.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LIKELIHOOD_PROCESSCOMPUTATIONTREE_H
#define BPP_PHYL_LIKELIHOOD_PROCESSCOMPUTATIONTREE_H
 
 
#include "../Tree/PhyloBranchParam.h"
#include "../Tree/PhyloTree.h"
#include "ParametrizablePhyloTree.h"
#include "SubstitutionProcess.h"
 
namespace bpp
{
// Node specific DataFlow objects
class ProcessComputationNode :
  public PhyloNode
{
  const uint speciesIndex_;
 
public:
  ProcessComputationNode(const PhyloNode& node, uint speciesIndex) :
    PhyloNode(node),
    speciesIndex_(speciesIndex) {}
 
  ProcessComputationNode(const ProcessComputationNode& node) :
    PhyloNode(node),
    speciesIndex_(node.speciesIndex_) {}
 
  uint getSpeciesIndex() const
  {
    return speciesIndex_;
  }
 
  bool isSpeciation() const
  {
    auto prop = dynamic_cast<const NodeEvent*>(getProperty("event"));
    if (!prop)
      throw Exception("ProcessNode::isSpeciation : Node has no event associated: Node id " + TextTools::toString(getSpeciesIndex()));
    return prop->isSpeciation();
  }
 
  bool isMixture() const
  {
    auto prop = dynamic_cast<const NodeEvent*>(getProperty("event"));
    if (!prop)
      throw Exception("ProcessNode::isMixture : Node has no event associated: Node id " + TextTools::toString(getSpeciesIndex()));
    return prop->isMixture();
  }
};
 
using ProcessComputationNodeRef = std::shared_ptr<ProcessComputationNode>;
 
// Class for the edges: In case of mixture nodes, the probability is
// set through submodel probability
class ProcessComputationEdge
{
private:
  std::shared_ptr<const BranchModelInterface> model_;
 
  uint nmodel_;
 
  std::vector<uint> vSubNb_;
 
  bool useProb_;
 
  const uint speciesIndex_;
 
public:
  ProcessComputationEdge(
      std::shared_ptr<const BranchModelInterface> model,
      uint nmodel,
      uint speciesIndex,
      bool useProb = false,
      const std::vector<uint>& vNb = Vuint(0)) :
    model_(model),
    nmodel_(nmodel),
    vSubNb_(vNb),
    useProb_(useProb),
    speciesIndex_(speciesIndex)
  {}
 
  ProcessComputationEdge(const ProcessComputationEdge& edge) :
    model_(edge.model_),
    nmodel_(edge.nmodel_),
    vSubNb_(edge.vSubNb_),
    useProb_(edge.useProb_),
    speciesIndex_(edge.speciesIndex_)
  {}
 
  std::shared_ptr<const BranchModelInterface> getModel() const
  {
    return model_;
  }
 
  uint getModelNumber() const
  {
    return nmodel_;
  }
 
  uint getSpeciesIndex() const
  {
    return speciesIndex_;
  }
 
  const std::vector<uint>& subModelNumbers() const
  {
    return vSubNb_;
  }
 
  bool useProb() const
  {
    return useProb_;
  }
};
 
using BaseTree = AssociationTreeGlobalGraphObserver<ProcessComputationNode, ProcessComputationEdge>;
 
class ProcessComputationTree :
  public BaseTree
{
private:
  std::shared_ptr<const SubstitutionProcessInterface> process_;
 
  void buildFollowingPath_(
      std::shared_ptr<ProcessComputationNode> father,
      const ModelPath& path);
 
  void buildFollowingScenario_(
      std::shared_ptr<ProcessComputationNode> father,
      const ModelScenario& scenario,
      std::map<std::shared_ptr<MixedTransitionModelInterface>,
      uint>& mMrca);
 
public:
  ProcessComputationTree(std::shared_ptr<const SubstitutionProcessInterface> process);
};
} // end of namespace bpp.
#endif // BPP_PHYL_LIKELIHOOD_PROCESSCOMPUTATIONTREE_H