AnalyzingAlgorithmBase.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler                                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
// fw:
#include <framework/logging/Logger.h>
#include <framework/core/FrameworkExceptions.h>
 
// tracking:
#include<tracking/trackFindingVXD/analyzingTools/TCType.h>
#include<tracking/trackFindingVXD/analyzingTools/AlgoritmType.h>
 
// stl:
#include <string>
 
 
namespace Belle2 {
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmBase {
  protected:
 
    struct TcPair {
      TcPair() : refTC(nullptr), testTC(nullptr) {}
 
      TcPair(const TCInfoType& aRefTC, const TCInfoType& aTestTC) : refTC(&aRefTC), testTC(&aTestTC) {}
 
      const TCInfoType* refTC;
 
      const TCInfoType* testTC;
    };
 
 
    AlgoritmType::Type m_iD;
 
 
    static VectorType s_origin;
 
 
    static bool m_storeRefTCDataForTestTC;
 
 
    explicit AnalyzingAlgorithmBase(const AlgoritmType::Type& newID) : m_iD(newID) {}
 
    explicit AnalyzingAlgorithmBase(const std::string& newID) : m_iD(AlgoritmType::getTypeEnum(newID)) {}
 
    AnalyzingAlgorithmBase(const AnalyzingAlgorithmBase& algo) = delete;
    AnalyzingAlgorithmBase& operator = (const AnalyzingAlgorithmBase& algo) = delete;
 
 
    virtual const TCInfoType& chooseCorrectTC(const TCInfoType& aTC) const
    {
      // capture cases of aTC == referenceTC first:
      if (TCType::isReference(aTC.tcType)) { return aTC; }
 
      // is no reference TC and own data usage is allowed:
      if (m_storeRefTCDataForTestTC == false) { return aTC; }
 
      // handle cases when attached reference TC has to be used instead of own data:
      if (aTC.assignedTC != NULL) { return *aTC.assignedTC; }
 
      throw AnalyzingAlgorithmBase::No_refTC_Attached();
    }
 
 
    virtual const TcPair chooseCorrectPairOfTCs(const TCInfoType& aTC) const
    {
      // capture bad case, where second TC is missing:
      if (aTC.assignedTC == NULL) { throw AnalyzingAlgorithmBase::No_refTC_Attached(); }
 
      if (aTC.tcType == TCType::Reference or aTC.tcType == TCType::Lost) {
        return TcPair(aTC, *aTC.assignedTC);
      }
      return TcPair(*aTC.assignedTC, aTC);
    }
 
  public:
 
    BELLE2_DEFINE_EXCEPTION(No_refTC_Attached,
                            "To given testTC no refTC was attached, could not provide valid data for algorithm - no value returned!");
 
 
    AnalyzingAlgorithmBase() : m_iD(AlgoritmType::AnalyzingAlgorithmBase) {}
 
 
    virtual ~AnalyzingAlgorithmBase() {}
 
 
    inline bool operator == (const AnalyzingAlgorithmBase& b) const { return m_iD == b.getID(); }
 
 
    AlgoritmType::Type getID() const { return m_iD; }
 
    std::string getIDName() const { return AlgoritmType::getTypeName(m_iD); }
 
    static VectorType& getOrigin() { return s_origin; }
 
 
    static void setOrigin(VectorType newOrigin) { s_origin = newOrigin; }
 
 
    static bool willRefTCdataBeUsed4TestTCs() { return m_storeRefTCDataForTestTC; }
 
 
    static void setWillRefTCdataBeUsed4TestTCs(bool newBehavior) { m_storeRefTCDataForTestTC = newBehavior; }
 
 
    virtual DataType calcData(const TCInfoType&)
    {
      B2ERROR(" AnalyzingAlgorithmBase::calcData: if you can see this, the code tried to return the actual baseClass instead of the inherited ones - this is unintended behavior!");
      return DataType();
    }
  };
 
 
  template<class DataType, class TCInfoType, class VectorType>
  VectorType AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::s_origin = VectorType(0, 0, 0);
 
 
  template<class DataType, class TCInfoType, class VectorType>
  bool AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::m_storeRefTCDataForTestTC = false;
 
 
  template <class DataType, class TCInfoType, class VectorType>
  inline bool operator == (const AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>& a, const std::string& b)
  { return (a.getIDName() == b); }
 
 
  template <class DataType, class TCInfoType, class VectorType>
  inline bool operator == (const std::string& a, const AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>& b)
  { return (a == b.getIDName()); }
 
 
  template <class DataType, class TCInfoType, class VectorType>
  inline bool operator == (const AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>& a, const AlgoritmType::Type& b)
  { return (a.getID() == b); }
 
 
  template <class DataType, class TCInfoType, class VectorType>
  inline bool operator == (const AlgoritmType::Type& a, const AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>& b)
  { return (a == b.getID()); }
 
}