GFTC2SPTCConverterModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014  Belle II Collaboration                              *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Madlener                                          *
 *                                                                        *
 **************************************************************************/
 
# pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <tracking/spacePointCreation/SpacePoint.h>
 
#include <tracking/spacePointCreation/SpacePointTrackCand.h>
 
#include <genfit/TrackCand.h>
#include <genfit/TrackCandHit.h>
 
#include <string>
#include <utility>
#include <boost/tuple/tuple.hpp>
 
namespace Belle2 {
  class GFTC2SPTCConverterModule : public Module {
 
  public:
 
    GFTC2SPTCConverterModule(); 
    void initialize()
    override; 
    void event() override; 
    void terminate() override; 
  protected:
 
    enum conversionStatus {
      c_singleClusterSP = 1, 
      c_noFail = 0, 
      c_foundNoSpacePoint = -1, 
      c_foundNoTrueHit = -2, 
      c_unsuitableGFTC = -3, 
      c_unusedHits = -4, 
      c_nonSingleSP = -5, 
      c_noValidSP = -6, 
      c_lowNDF = -7, 
    };
 
    conversionStatus getFailEnum(int intToConvert)
    {
      switch (intToConvert) {
        case 1: return c_singleClusterSP;
        case 0: return c_noFail;
        case -1: return c_foundNoSpacePoint;
        case -2: return c_foundNoTrueHit;
        case -3: return c_unsuitableGFTC;
        case -4: return c_unusedHits;
        case -5: return c_nonSingleSP;
        case -6: return c_noValidSP;
        case -7: return c_lowNDF;
        default: return c_foundNoSpacePoint;
      }
    }
 
    // ========================================================== PARAMETERS ============================================================================
    std::string m_PXDClusterName; 
    std::string m_SVDClusterName; 
    std::string m_SingleClusterSVDSPName; 
    std::string m_NoSingleClusterSVDSPName; 
    std::string m_PXDClusterSPName; 
    std::string m_genfitTCName; 
    std::string m_SPTCName; 
    bool m_PARAMcheckTrueHits; 
    bool m_PARAMuseSingleClusterSP; 
    bool m_PARAMcheckNoSingleSVDSP; 
    bool m_PARAMskipCluster; 
    int m_PARAMminNDF; 
    // ============================================================= COUNTER VARIABLES ====================================================================
    unsigned int
    m_SpacePointTCCtr; 
    unsigned int m_genfitTCCtr; 
    unsigned int m_abortedTrueHitCtr; 
    unsigned int m_abortedUnsuitableTCCtr; 
    unsigned int m_abortedNoSPCtr; 
    unsigned int
    m_noTwoClusterSPCtr; 
    unsigned int
    m_abortedLowNDFCtr; 
    unsigned int m_skippedPXDnoSPCtr; 
    unsigned int m_skippedPXDnoTHCtr; 
    unsigned int m_skippedSVDnoSPCtr; 
    unsigned int m_skippedSVDnoTHCtr; 
    unsigned int m_singleClusterSPCtr; 
    unsigned int
    m_abortedMiscCtr; 
    unsigned int m_skippedCluster; 
    unsigned int
    m_skippedPXDunsuitableCtr; 
    unsigned int m_skippedSVDunsuitableCtr; 
    unsigned int
    m_skippedPXDnoValidSPCtr; 
    unsigned int m_skippedSVDnoValidSPCtr; 
    unsigned int m_nonSingleSPCtr; 
    unsigned int
    m_abortedNoValidSPCtr; 
    void initializeCounters()
    {
      m_SpacePointTCCtr = 0;
      m_genfitTCCtr = 0;
      m_abortedTrueHitCtr = 0;
      m_abortedUnsuitableTCCtr = 0;
      m_abortedNoSPCtr = 0;
      m_abortedMiscCtr = 0;
      m_abortedLowNDFCtr = 0;
      m_abortedNoValidSPCtr = 0;
 
      m_noTwoClusterSPCtr = 0;
      m_nonSingleSPCtr = 0;
 
      m_skippedPXDnoSPCtr = 0;
      m_skippedPXDnoTHCtr = 0;
      m_skippedSVDnoSPCtr = 0;
      m_skippedSVDnoTHCtr = 0;
      m_singleClusterSPCtr = 0;
 
      m_skippedCluster = 0;
      m_skippedPXDunsuitableCtr = 0;
      m_skippedSVDunsuitableCtr = 0;
 
      m_skippedPXDnoValidSPCtr = 0;
      m_skippedSVDnoValidSPCtr = 0;
 
      m_NDF = 0; // (cppcheck complaining about not being initialized in constructor)
    }
 
    void increaseFailCounter(conversionStatus status)
    {
      switch (status) {
        case c_foundNoSpacePoint: m_abortedNoSPCtr++; break;
        case c_foundNoTrueHit: m_abortedTrueHitCtr++; break;
        case c_unsuitableGFTC: m_abortedUnsuitableTCCtr++; break;
        case c_lowNDF: m_abortedLowNDFCtr++; break;
        case c_noValidSP: m_abortedNoValidSPCtr++; break;
        default: m_abortedMiscCtr++; break;
      }
      return;
    }
 
    template<typename ClusterType>
    void increaseSkippedCounter(conversionStatus status, ClusterType* cluster)
    {
      short unsigned int layerNumber = cluster->getSensorID().getLayerNumber();
      if (layerNumber > 6) throw SpacePointTrackCand::UnsupportedDetType();
      switch (status) {
        case c_noFail:
          break;
        case c_singleClusterSP:
          break;
        case c_foundNoSpacePoint:
          if (layerNumber < 3) m_skippedPXDnoSPCtr++;
          else m_skippedSVDnoSPCtr++;
          break;
        case c_foundNoTrueHit:
          if (layerNumber < 3) m_skippedPXDnoTHCtr++;
          else m_skippedSVDnoTHCtr++;
          break;
        case c_unsuitableGFTC:
          if (layerNumber < 3) m_skippedPXDunsuitableCtr++;
          else m_skippedSVDunsuitableCtr++;
          break;
        case c_noValidSP:
          if (layerNumber < 3) m_skippedPXDnoValidSPCtr++;
          else m_skippedSVDnoValidSPCtr++;
          break;
        default:
          m_skippedCluster++; break;
      }
      return;
    }
    // ================================================================ INTERNALLY USED VARIABLES ===========================================================
    std::string svdMainArrayName; 
    int m_NDF; 
    // ================================================= TYPEDEFS ============================================================================================================
 
// #ifndef __CINT__ // was once needed, when it was defined in SpacePointTrackCand.h
    template<typename HitType> using HitInfo =
      std::pair<double, const HitType*>; 
// #endif
 
    template<typename T> using flaggedPair =
      boost::tuple<bool, T, T>; 
    // ============================================================================ MODULE METHODS ==============================================================================
 
 
    void markHitAsUsed(std::vector<flaggedPair<int> >& flaggedHitIDs,
                       int hitToMark); 
    std::pair<const Belle2::SpacePointTrackCand, conversionStatus>
    createSpacePointTC(const genfit::TrackCand* genfitTC, const StoreArray<PXDCluster>& pxdClusters,
                       const StoreArray<SVDCluster>& svdClusters);
 
    std::pair<Belle2::SpacePoint*, conversionStatus>
    processTrackCandHit(genfit::TrackCandHit* hit, const StoreArray<PXDCluster>& pxdClusters, const StoreArray<SVDCluster>& svdClusters,
                        std::vector<flaggedPair<int> >& flaggedHitIDs, int iHit);
 
    template<typename ClusterType, typename TrueHitType>
    std::pair<Belle2::SpacePoint*, conversionStatus>
    getSpacePoint(const ClusterType* cluster, std::vector<flaggedPair<int> >& flaggedHitIDs, int iHit, bool singleCluster,
                  std::string arrayName = ""); 
    template<typename ClusterType>
    std::pair<Belle2::SpacePoint*, conversionStatus>
    findAppropriateSpacePoint(const Belle2::RelationVector<Belle2::SpacePoint>& spacePoints,
                              std::vector<flaggedPair<int> >& flaggedHitIDs);
 
    std::pair<int, int> checkExistAndValid(int clusterInd, int detID, std::vector<flaggedPair<int> >& flaggedHitIDs);
 
    int getAppropriateSpacePointIndex(const std::vector<std::pair<bool, bool> >& existAndValidSPs,
                                      const std::vector<std::pair<int, int> >& clusterPositions);
 
    template<typename ClusterType>
    std::vector<int> getClusterIndices(const Belle2::SpacePoint* spacePoint, std::string storeArrayName);
 
    int getNDF(Belle2::SpacePoint* spacePoint);
 
    bool checkUsedAllHits(std::vector<flaggedPair<int> >& flaggedHitIDs);
 
    template <typename TrueHitType>
    bool foundRelatedTrueHit(const Belle2::SpacePoint* spacePoint, unsigned int allowedRelations = 1);
 
    BELLE2_DEFINE_EXCEPTION(UnusedHits,
                            "Not all hits of the genfit::TrackCand have been marked as used. This indicates that not all hits have been used to create a SpacePointTrackCand.");
  };
}