release-05-02-19/doxygen/CDCCRTestModule_8h_source.html

/**************************************************************************

 * BASF2 (Belle Analysis Framework 2)                                     *

 * Copyright(C) 2010 - Belle II Collaboration                             *

 *                                                                        *

 * Author: The Belle II Collaboration                                     *

 * Contributors: Dong Van Thanh                                           *

 *                                                                        *

 * This software is provided "as is" without any warranty.                *

 **************************************************************************/


#ifndef CDCCRTestModule_H_

#define CDCCRTestModule_H_


#include <framework/core/HistoModule.h>


#include <cdc/dataobjects/WireID.h>


#include <string>


#include <mdst/dataobjects/TrackFitResult.h>

#include <tracking/dataobjects/RecoTrack.h>

#include <framework/dataobjects/EventT0.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


      TVector3 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;

      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;

      TVector3 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;

    };

  }

}

#endif