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 <framework/datastore/StoreArray.h>
#include <tracking/spacePointCreation/SpacePointTrackCand.h>
#include <tracking/spacePointCreation/SpacePoint.h>
 
#include <array>
 
#include <framework/geometry/B2Vector3.h>
 
#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;
 
    StoreArray<SpacePointTrackCand> m_spacePointTCs;  
    StoreArray<SpacePointTrackCand> m_curlingFirstOuts;  
    StoreArray<SpacePointTrackCand> m_curlingAllIns;  
    StoreArray<SpacePointTrackCand> m_curlingRestOuts;  
    StoreArray<SpacePointTrackCand> m_curlingCompletes;  
 
    int m_PARAMnTrackStubs; 
 
    bool m_saveCompleteCurler; 
 
    B2Vector3D 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 B2Vector3D, const B2Vector3D >
    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 B2Vector3D, const B2Vector3D > const& hitPosAndMom,
                              const B2Vector3D& 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); 
  };

}