DRTreeParsimonyScore.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_PARSIMONY_DRTREEPARSIMONYSCORE_H
#define BPP_PHYL_PARSIMONY_DRTREEPARSIMONYSCORE_H
 
 
#include "../Tree/NNISearchable.h"
#include "../Tree/TreeTools.h"
#include "AbstractTreeParsimonyScore.h"
#include "DRTreeParsimonyData.h"
 
namespace bpp
{
class DRTreeParsimonyScore :
  public AbstractTreeParsimonyScore,
  public virtual NNISearchable
{
private:
  std::unique_ptr<DRTreeParsimonyData> parsimonyData_;
  size_t nbDistinctSites_;
 
public:
  DRTreeParsimonyScore(
      std::shared_ptr<TreeTemplate<Node>> tree,
      std::shared_ptr<const SiteContainerInterface> data,
      bool verbose = true,
      bool includeGaps = false);
 
  DRTreeParsimonyScore(
      std::shared_ptr<TreeTemplate<Node>> tree,
      std::shared_ptr<const SiteContainerInterface> data,
      std::shared_ptr<const StateMapInterface> statesMap,
      bool verbose = true);
 
  DRTreeParsimonyScore(const DRTreeParsimonyScore& tp);
 
  DRTreeParsimonyScore& operator=(const DRTreeParsimonyScore& tp);
 
  virtual ~DRTreeParsimonyScore();
 
  DRTreeParsimonyScore* clone() const override { return new DRTreeParsimonyScore(*this); }
 
private:
  void init_(std::shared_ptr<const SiteContainerInterface> data, bool verbose);
 
protected:
  virtual void computeScores();
  virtual void computeScoresPreorder(const Node*);
  virtual void computeScoresPostorder(const Node*);
 
public:
  unsigned int getScore() const override;
  unsigned int getScoreForSite(size_t site) const override;
 
  static void computeScoresPostorderForNode(
      const DRTreeParsimonyNodeData& pData,
      std::vector<Bitset>& rBitsets,
      std::vector<unsigned int>& rScores);
 
  static void computeScoresPreorderForNode(
      const DRTreeParsimonyNodeData& pData,
      const Node* source,
      std::vector<Bitset>& rBitsets,
      std::vector<unsigned int>& rScores);
 
  static void computeScoresForNode(
      const DRTreeParsimonyNodeData& pData, std::vector<Bitset>& rBitsets,
      std::vector<unsigned int>& rScores);
 
  static void computeScoresFromArrays(
      const std::vector<const std::vector<Bitset>*>& iBitsets,
      const std::vector<const std::vector<unsigned int>*>& iScores,
      std::vector<Bitset>& oBitsets,
      std::vector<unsigned int>& oScores);
 
  double getTopologyValue() const override { return getScore(); }
 
  double testNNI(int nodeId) const override;
 
  void doNNI(int nodeId) override;
 
  const Tree& topology() const override { return tree(); }
 
  void topologyChangeTested(const TopologyChangeEvent& event) override
  {
    parsimonyData_->reInit();
    computeScores();
  }
 
  void topologyChangeSuccessful(const TopologyChangeEvent& event) override {}
  static std::string PARSIMONY_SOLUTION_STATE;
 
  void setNodeState(Node* node, size_t state);
 
  size_t getNodeState(const Node* node);
 
  void computeSolution();
};
} // end of namespace bpp.
#endif // BPP_PHYL_PARSIMONY_DRTREEPARSIMONYSCORE_H