MCTrackCandClassifierModule.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 <string>
#include <TFile.h>
#include <TList.h>
#include <TH1F.h>
#include <TH3F.h>
#include <time.h>
 
#include <tracking/dataobjects/MCParticleInfo.h>
#include <vxd/dataobjects/VXDTrueHit.h>
 
namespace Belle2 {
  class MCTrackCandClassifierModule : public Module {
 
  public:
 
    MCTrackCandClassifierModule();
 
    void initialize() override;
 
    void beginRun() override;
 
    void event() override;
 
    void endRun() override;
 
    void terminate() override;
 
  protected:
    std::string m_mcTrackCandsColName;
    std::string m_mcParticlesName;
    std::string m_rootFileName;
    int m_nSigma;
    bool m_usePXD;
    bool m_applyAnnulus;
    bool m_applySemiplane;
    bool m_applyLap;
    bool m_applyWedge;
    bool m_removeBadHits;
    int m_minHit;
    double m_fraction;
 
    int nWedge = 0;
    int nBarrel = 0;
 
    TFile* m_rootFilePtr = nullptr;
 
    TList* m_histoList = nullptr; 
    TH3F* m_h3_MCParticle = nullptr; 
    TH3F* m_h3_idealMCTrackCand = nullptr; 
    TH3F* m_h3_MCTrackCand = nullptr; 
    TH1F* m_h1_thetaMS_SVD = nullptr; 
    TH1F* m_h1_thetaMS_PXD = nullptr; 
    TH1F* m_h1_dR = nullptr; 
    TH1F* m_h1_dRoverR = nullptr; 
    TH1F* m_h1_distOVERdR = nullptr; 
    TH1F* m_h1_hitRadius_accepted = nullptr; 
    TH1F* m_h1_hitRadius_rejected = nullptr; 
    TH1F* m_h1_hitDistance_accepted = nullptr; 
    TH1F* m_h1_hitDistance_rejected = nullptr; 
    TH1F* m_h1_MCTrackCandNhits = nullptr; 
    TH1F* m_h1_firstRejectedHit = nullptr; 
    TH1F* m_h1_firstRejectedOVERMCHit = nullptr; 
    TH1F* m_h1_lapTime = nullptr; 
    TH1F* m_h1_timeDifference = nullptr; 
    TH1F* m_h1_diffOVERlap = nullptr; 
    TH1F* m_h1_nGoodTrueHits = nullptr; 
    TH1F* m_h1_nBadTrueHits = nullptr; 
    TH1F* m_h1_nGood1dInfo = nullptr; 
    TH1F* m_h1_nBad1dInfo = nullptr; 
  private:
 
    double semiPlane(TVector3 vertex, TVector3 center, TVector3 hit);
 
    bool isInSemiPlane(double semiPlane, double omega);
 
    double theDistance(TVector3 center, TVector3 hit);
 
    bool isInAnnulus(double hitDistance, double R, double dR);
 
    bool isFirstLap(double FirstHitTime, double HitTime, double LapTime);
 
    TH3F* createHistogram3D(const char* name, const char* title,
                            Int_t nbinsX, Double_t minX, Double_t maxX, const char* titleX,
                            Int_t nbinsY, Double_t minY, Double_t maxY, const char* titleY,
                            Int_t nbinsZ, Double_t minZ, Double_t maxZ, const char* titleZ,
                            TList* histoList = nullptr);
 
    TH3F* createHistogram3D(const char* name, const char* title,
                            Int_t nbinsX, Double_t* binsX, const char* titleX,
                            Int_t nbinsY, Double_t* binsY, const char* titleY,
                            Int_t nbinsZ, Double_t* binsZ, const char* titleZ,
                            TList* histoList = nullptr);
 
    TH1* duplicateHistogram(const char* newname, const char* newtitle,
                            TH1* h, TList* histoList = nullptr);
 
    TH1F* createHistogramsRatio(const char* name, const char* title,
                                TH1* hNum, TH1* hDen, bool isEffPlot,
                                int axisRef);
 
    void addEfficiencyPlots(TList* graphList = nullptr);
 
    void addInefficiencyPlots(TList* graphList = nullptr);
 
    float compute_dR(double thetaMS, double omega);
 
    float compute_thetaMS(MCParticleInfo& mcParticleInfo, VXDTrueHit* aTrueHit);
  };
}