GFTC2SPTCConverterModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
# pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <tracking/spacePointCreation/SpacePoint.h>
 
#include <tracking/spacePointCreation/SpacePointTrackCand.h>
 
#include <pxd/dataobjects/PXDTrueHit.h>
#include <svd/dataobjects/SVDTrueHit.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, 
    };

    static 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);

    std::pair<Belle2::SpacePoint*, conversionStatus>
    processTrackCandHit(genfit::TrackCandHit* hit, 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);

    static 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);

    static int getNDF(const 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.");
  private:
    StoreArray<PXDCluster> m_PXDClusters; 
    StoreArray<SVDCluster> m_SVDClusters; 
    StoreArray<SpacePoint> m_SingleClusterSpacePoints; 
    StoreArray<SpacePoint> m_NoSingleClusterSpacePoints; 
    StoreArray<SpacePoint> m_PXDSpacePoints; 
    StoreArray<genfit::TrackCand> m_GenfitTrackCands; 
    StoreArray<SpacePointTrackCand> m_SpacePointTrackCands; 
    StoreArray<PXDTrueHit> m_PXDTrueHits; 
    StoreArray<SVDTrueHit> m_SVDTrueHits; 
  };

}