ProcessTree.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LIKELIHOOD_DATAFLOW_PROCESSTREE_H
#define BPP_PHYL_LIKELIHOOD_DATAFLOW_PROCESSTREE_H
 
#include <Bpp/Graph/AssociationTreeGraphImplObserver.h>
#include <Bpp/Numeric/ParametrizableCollection.h>
#include <Bpp/Phyl/Likelihood/DataFlow/Parametrizable.h>
#include <Bpp/Phyl/Likelihood/ParametrizablePhyloTree.h>
#include <Bpp/Phyl/Likelihood/ProcessComputationTree.h>
#include <Bpp/Phyl/Likelihood/SubstitutionProcess.h>
 
#include "Definitions.h"
#include "Model.h"
#include "Parameter.h"
 
// From the stl:
#include <string>
 
namespace bpp
{
class CollectionNodes;
 
using DAGindexes = std::vector<uint>;
using Speciesindex = uint;
 
 
// Branch specific DataFlow objects
class ProcessEdge
{
private:
  const Speciesindex speciesIndex_;
 
  std::shared_ptr<ConfiguredParameter> brlen_;
 
  std::shared_ptr<ConfiguredModel> model_;
 
  // Not just "size_t nMod_" because dataflow dependency is needed
  // for createMatrix for TransitionMatrixFromModel
 
  std::shared_ptr<NumericConstant<size_t>> nMod_;
 
  ValueRef<Eigen::MatrixXd> transitionMatrix_;
 
  ValueRef<double> brprob_;
 
public:
  ProcessEdge(uint speciesIndex,
      std::shared_ptr<ConfiguredParameter> brlen,
      std::shared_ptr<ConfiguredModel> model,
      std::shared_ptr<NumericConstant<size_t>> nMod = 0) : speciesIndex_(speciesIndex), brlen_(brlen), model_(model), nMod_(nMod), transitionMatrix_(0), brprob_(0){}
 
  ProcessEdge(uint speciesIndex,
      ValueRef<double> brprob) : speciesIndex_(speciesIndex), brlen_(0), model_(0), nMod_(0), transitionMatrix_(0), brprob_(brprob){}
 
  ProcessEdge(const ProcessEdge& edge) : speciesIndex_(edge.speciesIndex_), brlen_(edge.brlen_), model_(edge.model_), nMod_(edge.nMod_), transitionMatrix_(edge.transitionMatrix_), brprob_(edge.brprob_){}
 
  std::shared_ptr<ConfiguredModel> getModel()
  {
    return model_;
  }
 
  ConfiguredModel& model()
  {
    return *model_;
  }
 
  // void setModel(std::shared_ptr<ConfiguredModel> model)
  // {
  //   model_=model;
  // }
 
  std::shared_ptr<ConfiguredParameter> getBrLen()
  {
    return brlen_;
  }
 
  void setBrLen(std::shared_ptr<ConfiguredParameter> brlen)
  {
    brlen_ = brlen;
  }
 
  void setTransitionMatrix(ValueRef<Eigen::MatrixXd> transitionMatrix)
  {
    transitionMatrix_ = transitionMatrix;
  }
 
  ValueRef<Eigen::MatrixXd> getTransitionMatrix()
  {
    return transitionMatrix_;
  }
 
  ValueRef<double> getProba()
  {
    return brprob_;
  }
 
  // void setNMod(std::shared_ptr<NumericConstant<size_t>> nMod)
  // {
  //   nMod_=nMod;
  // }
 
  std::shared_ptr<NumericConstant<size_t>> getNMod()
  {
    return nMod_;
  }
 
  uint getSpeciesIndex() const
  {
    return speciesIndex_;
  }
};
 
typedef ProcessComputationNode ProcessNode;
 
using ProcessEdgePtr = std::shared_ptr<ProcessEdge>;
using ProcessNodePtr = std::shared_ptr<ProcessNode>;
 
class ProcessTree : public AssociationTreeGlobalGraphObserver<ProcessNode, ProcessEdge>
{
  Context context_;
 
  // CollectionNodes* nodes_;
 
public:
  ProcessTree(Context& context,
      const ParametrizablePhyloTree& tree);
 
  ProcessTree(const ProcessTree& tree,
      ValueRef<double> rate);
 
  ProcessTree(Context& context,
      const ParametrizablePhyloTree& tree,
      const ParameterList& parList,
      const std::string& suff);
 
  ProcessTree(const ProcessComputationTree& tree,
      ParametrizableCollection<ConfiguredModel>& modelColl,
      const ProcessTree& phyloTree);
 
 
  ProcessTree* clone() const override
  {
    throw Exception("ProcessTree::clone should not be called.");
  }
 
  ProcessTree(const ProcessTree& pTree) :
    AssociationTreeGlobalGraphObserver<ProcessNode, ProcessEdge>(pTree.getGraph())
  {
    throw Exception("ProcessTree::ProcessTree should not be called.");
  }
 
  ProcessTree& operator=(const ProcessTree& pTree)
  {
    throw Exception("ProcessTree::operator= should not be called.");
    // AssociationTreeGlobalGraphObserver<ProcessNode,Value<T>>::operator=(pTree);
    return *this;
  }
 
  /*
   * @brief Get the edges indexes of the DAG that correspond to
   * the species Index (of the Process tree).
   */
 
  DAGindexes getDAGEdgesIndexes(const Speciesindex speciesIndex) const;
 
  /*
   * For inclusion in ParametrizableCollection. Not used
   *
   */
  const ParameterList getParameters() {return ParameterList();}
 
  bool matchParametersValues(ParameterList&) {return true;}
 
  /*
   * Static construction methods.
   *
   */
 
  static std::shared_ptr<ProcessTree> makeProcessTree(
      Context& context,
      std::shared_ptr<const SubstitutionProcessInterface> process,
      ParameterList& parList,
      const std::string& suff = "");
 
  static std::shared_ptr<ProcessTree> makeProcessTree(CollectionNodes& collection, size_t pNum);
};
 
inline ParametrizableCollection<ConfiguredModel> makeConfiguredModelCollection(
    Context& context,
    const SubstitutionProcessInterface& process,
    ParameterList& parList)
{
  ParametrizableCollection<ConfiguredModel> modelColl;
 
  // Build the ConfiguredModels from the BranchModels
  auto vnMod = process.getModelNumbers();
 
  for (auto nMod:vnMod)
  {
    auto mod = process.getModel(nMod);
 
    modelColl.addObject(ConfiguredParametrizable::createConfigured<BranchModelInterface, ConfiguredModel>(context, *mod, parList, (nMod == 1 ? "" : "_" + TextTools::toString(nMod))), nMod); // suffix "_1" will be added if necessary
  }
 
  return modelColl;
}
} // end of namespace bpp
#endif // BPP_PHYL_LIKELIHOOD_DATAFLOW_PROCESSTREE_H