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() override;

      void initialize() override;

 
      void event() 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);

      static int getICLayer(int slayer, int ilayer)
      {
        if (slayer == 0) {return ilayer;}
        else {return 8 + (slayer - 1) * 6 + ilayer;}
      }
 
      const Belle2::TrackFitResult* fitresult = nullptr;

      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 = nullptr;                          
      TH1* m_hNTracks = nullptr;                        
      TH1* m_hNTracksPerEvent = nullptr;                
      TH1* m_hNTracksPerEventFitted = nullptr;          
      TH1* m_hNDF = nullptr;                            
      TH1* m_hNHits = nullptr;                          
      TH1* m_hNHits_trackcand = nullptr;                
      TH1* m_hChi2 = nullptr;                           
      TH1* m_hPval = nullptr;                           
      TH2* m_hNDFChi2 = nullptr;                        
      TH2* m_hNDFPval = nullptr;                        
      TH1* m_hAlpha = nullptr;                          
      TH1* m_hPhi0 = nullptr;                           
      TH1* m_hTheta = nullptr;                          
      TH1* m_hHitDistInCDCHit[56] = {};            
      TH1* m_hHitDistInTrCand[56] = {};            
      TH1* m_hHitDistInTrack[56] = {};             
      TH1* m_hResidualU[56] = {};                  
      TH1* m_hEvtT0 = nullptr;                               
      TH2* m_hNDFResidualU[56] = {};               
      TH1* m_hNormalizedResidualU[56] = {};        
      TH2* m_hNDFNormalizedResidualU[56] = {};     
      TH2* m_hDxDt[56] = {};                       
      TProfile* m_hHitEff_soft[56] = {};           
      TH2* m_h2DHitDistInCDCHit = nullptr;              
      TH2* m_h2DHitDistInTrCand = nullptr;              
      TH2* m_h2DHitDistInTrack = nullptr;               
      TH2* m_hTriggerHitZX = nullptr;                   
 
 
      double res_b = 0.0;             
      double res_u = 0.0;             
      double res_b_err = 0.0;         
      double res_u_err = 0.0;         
      double weight = 0.0;            
      double absRes_b = 0.0;          
      double absRes_u = 0.0;          
      double alpha = 0.0;             
      double theta = 0.0;             
      unsigned short adc = 0;       
      short tdc = 0;                
      double t = 0.0;                 
      double t_fit = 0.0;             
      double dt_flight = 0.0;         
      double dt_flight_sim = 0.0;     
      double dt_prop = 0.0;           
      double evtT0 = 0.0;             
      double Pt = 0.0;                
 
      double x_mea = 0.0;             
      double x_u = 0.0;               
      double x_b = 0.0;               
      double x_sim = 0.0;             
      double z = 0.0;                 
      double z_sim = 0.0;             
      double z_prop = 0.0;            
      int lay = 0;                  
      int IWire = 0;                
      int lr = 0;                   
      int numhits = 0;              
      int boardID = 0;              
      double Pval = 0.0;              
      double TrPval = 0.0;            
      double ndf = 0.0;               
      double d0 = 0.0;                
      double z0 = 0.0;                
      double phi0 = 0.0;              
      double tanL = 0.0;              
      double omega = 0.0;             
      double m_MinimumPt = 0.0;       
 
      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 = 0.0;                              
      double trigHitPos_z = 0.0;                              
      int trighit = 0;                                      
 
      bool m_fillExpertHistos = false;                 
      bool m_plotResidual = false;                     
      bool m_hitEfficiency = false;                    
      bool m_calExpectedDriftTime = false;             
      bool m_noBFit = false;                           
      bool m_ToP = false;                              
      bool m_ToF = false;                              
      bool m_StoreCDCSimHitInfo = false;               
      bool m_EstimateResultForUnFittedLayer = false;   
      bool m_SmallerOutput = false;                    
      bool m_StoreTrackParams = false;                 
      bool m_MakeHitDist = false;                      
      bool m_EventT0Extraction = false;                
    };
  }
}