CurlingTrackCandSplitterModule.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 <tracking/spacePointCreation/SpacePointTrackCand.h>
#include <tracking/spacePointCreation/SpacePoint.h>
 
#include <array>
 
#include <framework/geometry/B2Vector3.h> // gradually moving to B2Vector3 instead of TVector3
 
#include <TFile.h>
#include <TTree.h>
 
namespace Belle2 {
  class CurlingTrackCandSplitterModule : public Module {
 
  public:
 
    CurlingTrackCandSplitterModule(); 
    void initialize() override;
 
    void event() override; 
    void terminate() override; 
    enum {
      c_nSVDPlanes = 4,
      c_nPXDPlanes = 2,
 
      c_nPlanes = c_nSVDPlanes + c_nPXDPlanes,
    };
 
    struct RootVariables {
      std::array<std::vector<double>, c_nPlanes> SpacePointXGlobal; 
      std::array<std::vector<double>, c_nPlanes> SpacePointYGlobal; 
      std::array<std::vector<double>, c_nPlanes> SpacePointZGlobal; 
      std::array<std::vector<double>, c_nPlanes> SpacePointULocal; 
      std::array<std::vector<double>, c_nPlanes> SpacePointVLocal; 
//       std::array<std::vector<double>, c_nPlanes> SpacePointZLocal; /**< local z-positions of SpacePoints (layerwise)*/
 
      std::array<std::vector<double>, c_nPlanes> TrueHitXGlobal; 
      std::array<std::vector<double>, c_nPlanes> TrueHitYGlobal; 
      std::array<std::vector<double>, c_nPlanes> TrueHitZGlobal; 
      std::array<std::vector<double>, c_nPlanes> PosResidueXGlobal;
      std::array<std::vector<double>, c_nPlanes> PosResidueYGlobal;
      std::array<std::vector<double>, c_nPlanes> PosResidueZGlobal;
 
      std::array<std::vector<double>, c_nPlanes> PosResidueULocal;
      std::array<std::vector<double>, c_nPlanes> PosResidueVLocal;
 
      std::array<std::vector<double>, c_nPlanes> TrueHitULocal; 
      std::array<std::vector<double>, c_nPlanes> TrueHitVLocal; 
//       std::array<std::vector<double>, c_nPlanes> TrueHitZLocal; /**< local z-positions of TrueHits (layerwise) */
 
      std::array<std::vector<double>, c_nPlanes> PosResiduesLocal; 
      std::array<std::vector<double>, c_nPlanes> PosResiduesGlobal; 
      std::array<std::vector<double>, c_nPlanes> MisMatchPosResiduals;
      std::array<std::vector<double>, c_nPlanes> MisMatchPosX;
      std::array<std::vector<double>, c_nPlanes> MisMatchPosY;
      std::array<std::vector<double>, c_nPlanes> MisMatchPosZ;
 
      std::array<std::vector<double>, c_nPlanes> MisMatchPosU;
      std::array<std::vector<double>, c_nPlanes> MisMatchPosV;
 
      std::array<std::vector<double>, c_nPlanes> MisMatchMomX;
      std::array<std::vector<double>, c_nPlanes> MisMatchMomY;
      std::array<std::vector<double>, c_nPlanes> MisMatchMomZ;
    };
 
    struct TaggedUVPos {
      bool m_setU; 
      bool m_setV; 
      double m_U; 
      double m_V; 
      TaggedUVPos() : m_setU(false), m_setV(false), m_U(0.), m_V(0.) {}
    };
 
  protected:
 
    bool m_PARAMsplitCurlers; 
    std::string m_PARAMsptcName; 
    std::string m_PARAMcurlingOutFirstName;
 
    std::string m_PARAMcurlingAllInName; 
    std::string m_PARAMcurlingOutRestName; 
    std::string m_PARAMcompleteCurlerName; 
    std::vector<double> m_PARAMsetOrigin;
 
    int m_PARAMnTrackStubs; 
    bool m_saveCompleteCurler; 
    B2Vector3<double> m_origin; 
    int m_spacePointTCCtr; 
    int m_curlingTCCtr; 
    int m_createdTrackStubsCtr; 
    int m_noDecisionPossibleCtr; 
    int m_NoSingleTrueHitCtr; 
    int m_NoCurlingTCsCtr; 
    bool m_PARAMuseNonSingleTHinPA; 
    void initializeCounters(); 
    const std::vector<int> checkTrackCandForCurling(const Belle2::SpacePointTrackCand&, RootVariables& rootVariables);
 
    template<class TrueHit>
    std::pair<const B2Vector3<double>, const B2Vector3<double> >
    getGlobalPositionAndMomentum(TrueHit* aTrueHit);
 
    const std::vector<Belle2::SpacePointTrackCand>
    splitCurlingTrackCand(const Belle2::SpacePointTrackCand& SPTrackCand, int NTracklets, const std::vector<int>& splitIndices);
 
    bool getDirectionOfFlight(std::pair<const B2Vector3<double>, const B2Vector3<double> > const& hitPosAndMom,
                              const B2Vector3<double>& origin);
 
    BELLE2_DEFINE_EXCEPTION(FoundNoTrueHit, "Found no TrueHit for one (or more) Cluster(s). "
                            "Without a TrueHit a decision if a TrackCand is curling is not possible");
 
    BELLE2_DEFINE_EXCEPTION(TrueHitsNotMatching, "The TrueHits related to the two SVDClusters of a SpacePoint are not the same!")
 
    
    BELLE2_DEFINE_EXCEPTION(FoundNoCluster, "No related Cluster to a SpacePoint was found.");
 
    bool m_PARAMpositionAnalysis; 
    std::vector<std::string> m_PARAMrootFileName;
    TFile* m_rootFilePtr; 
    TTree* m_treePtr; 
    std::array<std::vector<double>, c_nPlanes> m_rootSpacePointXGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootSpacePointYGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootSpacePointZGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootSpacePointULocals; 
    std::array<std::vector<double>, c_nPlanes> m_rootSpacePointVLocals; 
//     std::array<std::vector<double>, c_nPlanes> m_rootSpacePointZLocals; /**< Local Z-Positions of SpacePoints (layerwise) */
 
    std::array<std::vector<double>, c_nPlanes> m_rootTrueHitXGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootTrueHitYGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootTrueHitZGlobals; 
    std::array<std::vector<double>, c_nPlanes> m_rootTrueHitULocals; 
    std::array<std::vector<double>, c_nPlanes> m_rootTrueHitVLocals; 
//     std::vector<double> m_rootTrueHitZLocals; /**< Local Z-Positions of TrueHits (layerwise) */
 
    std::array<std::vector<double>, c_nPlanes> m_rootPosResidueXGlobal;
    std::array<std::vector<double>, c_nPlanes> m_rootPosResidueYGlobal;
    std::array<std::vector<double>, c_nPlanes> m_rootPosResidueZGlobal;
 
    std::array<std::vector<double>, c_nPlanes> m_rootPosResidueULocal;
    std::array<std::vector<double>, c_nPlanes> m_rootPosResidueVLocal;
 
    std::array<std::vector<double>, c_nPlanes> m_rootLocalPosResiduals;
    std::array<std::vector<double>, c_nPlanes> m_rootGlobalPosResiduals;
 
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosDistance;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosX;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosY;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosZ;
 
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosU;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchPosV;
 
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchMomX;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchMomY;
    std::array<std::vector<double>, c_nPlanes> m_rootMisMatchMomZ;
 
    TaggedUVPos getUV(const SpacePoint* spacePoint);
 
    template <class TrueHit>
    void getValuesForRoot(const SpacePoint* spacePoint, const TrueHit* trueHit, RootVariables& rootVariables);
 
    void writeToRoot(const RootVariables& rootVariables); 
  };
}