CDCCRTestModule.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/HistoModule.h>
 
#include <cdc/dataobjects/WireID.h>
 
#include <string>
 
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/TrackFitResult.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <framework/dataobjects/EventT0.h>
#include <framework/datastore/StoreArray.h>
#include <framework/geometry/B2Vector3.h>
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TTree.h"
 
namespace Belle2 {
  namespace CDC {
 
    class CDCCRTestModule : public HistoModule {
 
    public:
 
      CDCCRTestModule();
 
      virtual ~CDCCRTestModule();
 
      void initialize() override;
 
      void beginRun() override;
 
      void event() override;
      void endRun() override;
 
      void terminate() override;
 
      void defineHisto() override;
 
    private:
 
      TH1* getHist(const char* name, const char* title,
                   int nBins, double x0, double x1)
      {
        TH1* h = new TH1D(name, title, nBins, x0, x1);
        m_allHistos.push_back(h);
        return h;
      }
 
      TProfile* getHistProfile(const char* name, const char* title,
                               int nBins, double x0, double x1)
      {
        TProfile* h = new TProfile(name, title, nBins, x0, x1);
        m_allHistos.push_back(h);
        return h;
      }
 
      TH2* getHist(const char* name, const char* title,
                   int nBinsX, double x0, double x1,
                   int nBinsY, double y0, double y1)
      {
        TH2* h = new TH2D(name, title, nBinsX, x0, x1, nBinsY, y0, y1);
        m_allHistos.push_back(h);
        return h;
      }
 
      TH1* getHist(const std::string& name, const std::string& title,
                   int nBins, double x0, double x1)
      {
        return getHist(name.c_str(), title.c_str(), nBins, x0, x1);
      }
 
      TProfile* getHistProfile(const std::string& name, const std::string& title,
                               int nBins, double x0, double x1)
      {
        return getHistProfile(name.c_str(), title.c_str(), nBins, x0, x1);
      }
 
      TH2* getHist(const std::string& name, const std::string& title,
                   int nBinsX, double x0, double x1,
                   int nBinsY, double y0, double y1)
      {
        return getHist(name.c_str(), title.c_str(), nBinsX, x0, x1, nBinsY, y0, y1);
      }
 
 
      const genfit::SharedPlanePtr constructPlane(const genfit::MeasuredStateOnPlane& state, WireID m_wireID);
 
      void getResidualOfUnFittedLayer(Belle2::RecoTrack* track);
 
      void plotResults(Belle2::RecoTrack* track);
 
      void getHitDistInTrackCand(const RecoTrack* track);//Draw hit distribution from track candidate
 
      B2Vector3D getTriggerHitPosition(Belle2::RecoTrack* track);
 
      void HitEfficiency(const Belle2::RecoTrack* track);
 
      int getICLayer(int slayer, int ilayer)
      {
        if (slayer == 0) {return ilayer;}
        else {return 8 + (slayer - 1) * 6 + ilayer;}
      }
 
      const Belle2::TrackFitResult* fitresult;
      StoreObjPtr<EventT0> m_eventTimeStoreObject;
 
      StoreArray<Track> m_Tracks;
 
      StoreArray<RecoTrack> m_RecoTracks;
 
      StoreArray<TrackFitResult> m_TrackFitResults;
 
      StoreArray<CDCHit> m_CDCHits;
 
      std::string m_trackArrayName;           
      std::string m_cdcHitArrayName ;         
      std::string m_recoTrackArrayName ;      
      std::string m_trackFitResultArrayName;  
      std::string m_relRecoTrackTrackName;    
      std::string m_histogramDirectoryName;   
      std::vector<TH1*> m_allHistos;          
      std::string m_treeName;                 
      TTree* m_tree;                          
      TH1* m_hNTracks;                        
      TH1* m_hNTracksPerEvent;                
      TH1* m_hNTracksPerEventFitted;          
      TH1* m_hNDF;                            
      TH1* m_hNHits;                          
      TH1* m_hNHits_trackcand;                
      TH1* m_hChi2;                           
      TH1* m_hPval;                           
      TH2* m_hNDFChi2;                        
      TH2* m_hNDFPval;                        
      TH1* m_hAlpha;                          
      TH1* m_hPhi0;                           
      TH1* m_hTheta;                          
      TH1* m_hHitDistInCDCHit[56];            
      TH1* m_hHitDistInTrCand[56];            
      TH1* m_hHitDistInTrack[56];             
      TH1* m_hResidualU[56];                  
      TH1* m_hEvtT0;                               
      TH2* m_hNDFResidualU[56];               
      TH1* m_hNormalizedResidualU[56];        
      TH2* m_hNDFNormalizedResidualU[56];     
      TH2* m_hDxDt[56];                       
      TProfile* m_hHitEff_soft[56];           
      TH2* m_h2DHitDistInCDCHit;              
      TH2* m_h2DHitDistInTrCand;              
      TH2* m_h2DHitDistInTrack;               
      TH2* m_hTriggerHitZX;                   
      double res_b;             
      double res_u;             
      double res_b_err;         
      double res_u_err;         
      double weight;            
      double absRes_b;          
      double absRes_u;          
      double alpha;             
      double theta;             
      unsigned short adc;       
      short tdc;                
      double t;                 
      double t_fit;             
      double dt_flight;         
      double dt_flight_sim;     
      double dt_prop;           
      double evtT0;             
      double Pt;                
      double x_mea;             
      double x_u;               
      double x_b;               
      double x_sim;             
      double z;                 
      double z_sim;             
      double z_prop;            
      int lay;                  
      int IWire;                
      int lr;                   
      int numhits;              
      int boardID;              
      double Pval;              
      double TrPval;            
      double ndf;               
      double d0;                
      double z0;                
      double phi0;              
      double tanL;              
      double omega;             
      double m_MinimumPt;       
      B2Vector3D m_trigHitPos;                          
      std::vector<double> m_TriggerPos;                 
      std::vector<double> m_TriggerPlaneDirection;      
      std::vector<double> m_TriggerSize;                
      std::vector<int> m_up;                            
      std::vector<int> m_low;                           
      double trigHitPos_x;                              
      double trigHitPos_z;                              
      int trighit;                                      
      bool m_fillExpertHistos;                 
      bool m_plotResidual;                     
      bool m_hitEfficiency;                    
      bool m_calExpectedDriftTime;             
      bool m_noBFit;                           
      bool m_ToP;                              
      bool m_ToF;                              
      bool m_StoreCDCSimHitInfo;               
      bool m_EstimateResultForUnFittedLayer;   
      bool m_SmallerOutput;                    
      bool m_StoreTrackParams;                 
      bool m_MakeHitDist;                      
      bool m_EventT0Extraction;                
    };
  }
}