diff --git a/analysis/include/SvtTimingHistos.h b/analysis/include/SvtTimingHistos.h new file mode 100644 index 000000000..c65214d52 --- /dev/null +++ b/analysis/include/SvtTimingHistos.h @@ -0,0 +1,40 @@ +#ifndef SVTTIMING_ANAHISTOS_H +#define SVTTIMING_ANAHISTOS_H + +// HPSTR +#include "HistoManager.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "Track.h" +#include "CalHit.h" +#include "CalCluster.h" +#include "ModuleMapper.h" +#include +#include +#include + +class SvtTimingHistos : public HistoManager { + + public: + + SvtTimingHistos(const std::string& inputName,ModuleMapper* mmapper) ; + + virtual void Define3DHistos(){}; + virtual void Define2DHistos(){}; + virtual void Define1DHistos(); + void DefineHistos(); + + void FillRawHits(std::vector *trkrHits,float weight = 1.); + void FillTrackerHits(std::vector *trkrHits, float weight = 1.); + void FillTracks(std::vector *tracks, float weight = 1.); + void FillHitsOnTrack(Track* track, std::map *timingCalib, int phase, CalCluster *cluster, float weight =1. ); + void FillEcalHits(std::vector *ecalHits, float weight = 1.); + void FillEcalClusters(std::vector *ecalClusters, float weight = 1.); + + private: + + ModuleMapper* mmapper_; + bool debug_=false; +}; + +#endif //SVTTIMING_ANAHISTOS_H diff --git a/analysis/plotconfigs/reco/layersRecoHit.json b/analysis/plotconfigs/reco/layersRecoHit.json new file mode 100644 index 000000000..32baf695b --- /dev/null +++ b/analysis/plotconfigs/reco/layersRecoHit.json @@ -0,0 +1,158 @@ +{ + "numTrkrHits_h" : { + "bins" : 30, + "minX" : -0.5, + "maxX" : 29.5, + "xtitle" : "Number of Reco Tracker Hits", + "ytitle" : "Events" + }, + "trkrHit_Edep_h" : { + "bins" : 150, + "minX" : 0, + "maxX" : 25, + "xtitle" : "Tracker Hit Energy [arb. units]", + "ytitle" : "Tracker Hits / 2 arb. unit" + }, + "trkrHit_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit Time [ns]", + "ytitle" : "Tracker Hits " + }, + "svtHit_Edep_h" : { + "bins" : 150, + "minX" : 0, + "maxX" : 25, + "xtitle" : "Tracker Hit Energy [arb. units]", + "ytitle" : "Tracker Hits / 2 arb. unit" + }, + "svtHit_Time_h" : { + "bins" : 100, + "minX" : -25, + "maxX" : 25, + "xtitle" : "Tracker Hit Time [ns]", + "ytitle" : "Tracker Hits " + }, + "trkrHit_L5AxEle_Minus_LX_TimeWide_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit Time [ns]", + "ytitle" : "Tracker Hits " + }, + "trkSiCluster_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "trkSiCluster_L5AxEle_Minus_LX_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "trkSiCluster_L5AxEle_Versus_LX_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "L5AxEle Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + "trkSiCluster_L5AxEle_Minus_LX_Time_Versus_Chi2_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : 0, + "maxY" : 250, + "xtitle" : "L5AxEle - LX Track Hit Time [ns]", + "ytitle" : "Track Chi2 " + }, + "trkRawHit_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + "svtHit_TimeWide_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit Time [ns]", + "ytitle" : "Tracker Hits " + }, + "numTracks_h" : { + "bins" : 10, + "minX" : -0.5, + "maxX" : 9.5, + "xtitle" : "Number of KF Tracks", + "ytitle" : "Events" + }, + "trkChiSq_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 100.0, + "xtitle" : "Track ChiSq", + "ytitle" : "Tracks" + }, + "trkP_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 5.0, + "xtitle" : "Track Momentum (GeV)", + "ytitle" : "Tracks" + }, + + "trkNHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Hits on Track", + "ytitle" : "Tracks" + }, + + "trkTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "numEcalHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Reco ECal Hits", + "ytitle" : "Events" + }, + "ecalHitEnergy_h" : { + "bins" : 200, + "minX" : 0, + "maxX" : 2000, + "xtitle" : "Reco Ecal Hit Energy [MeV]", + "ytitle" : "Ecal Hits / 10 MeV" + }, + "numEcalClusters_h" : { + "bins" : 10, + "minX" : -0.5, + "maxX" : 9.5, + "xtitle" : "Number of Reco Ecal Clusters", + "ytitle" : "Events" + }, + "ecalClusterEnergy_h" : { + "bins" : 150, + "minX" : 0, + "maxX" : 3000, + "xtitle" : "Reco Ecal Cluster Energy [MeV]", + "ytitle" : "Clusters / 20 MeV" + } +} diff --git a/analysis/plotconfigs/reco/svtTiming.json b/analysis/plotconfigs/reco/svtTiming.json new file mode 100644 index 000000000..50be2e756 --- /dev/null +++ b/analysis/plotconfigs/reco/svtTiming.json @@ -0,0 +1,535 @@ +{ + "numTrkrHits_h" : { + "bins" : 30, + "minX" : -0.5, + "maxX" : 29.5, + "xtitle" : "Number of Reco Tracker Hits", + "ytitle" : "Events" + }, + "trkRawHit_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + "trkSiCluster_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "trkSiCluster_M3L0_Minus_LX_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "trkSiCluster_M3L0_Versus_LX_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + + + "trkRawHit_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + "trkSiCluster_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "trkSiCluster_M3L0_Minus_LX_2Fits_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "trkSiCluster_M3L0_Versus_LX_2Fits_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + + "trkSiCluster_M3L0_Minus_LX_Time_Versus_Chi2_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : 0, + "maxY" : 250, + "xtitle" : "M3L0 - LX Track Hit Time [ns]", + "ytitle" : "Track Chi2 " + }, + "electron_trkRawHit_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + + "electron_trkSiCluster_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "electron_trkSiCluster_M3L0_Minus_LX_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "electron_trkSiCluster_M3L0_Versus_LX_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + "electron_trkRawHit_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + + "electron_trkSiCluster_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "electron_trkSiCluster_M3L0_Minus_LX_2Fits_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "electron_trkSiCluster_M3L0_Versus_LX_2Fits_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + + "electron_trkSiCluster_M3L0_Minus_LX_Time_Versus_Chi2_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : 0, + "maxY" : 250, + "xtitle" : "M3L0 - LX Track Hit Time [ns]", + "ytitle" : "Track Chi2 " + }, + + "positron_trkRawHit_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + + "positron_trkSiCluster_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "positron_trkSiCluster_M3L0_Minus_LX_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "positron_trkSiCluster_M3L0_Versus_LX_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + "positron_trkRawHit_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Raw Hit On Track Time [ns]", + "ytitle" : "Raw Hits " + }, + + "positron_trkSiCluster_2Fits_Time_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + "positron_trkSiCluster_M3L0_Minus_LX_2Fits_Time_h" : { + "bins" : 160, + "minX" : -30, + "maxX" : 10, + "xtitle" : "Tracker Hit On Track Time [ns]", + "ytitle" : "Tracker Hits " + }, + + "positron_trkSiCluster_M3L0_Versus_LX_2Fits_Time_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : -50, + "maxY" : 50, + "xtitle" : "M3L0 Track Hit Time [ns]", + "ytitle" : "LX Track Time [ns] " + }, + + "positron_trkSiCluster_M3L0_Minus_LX_Time_Versus_Chi2_hh" : { + "binsX" : 100, + "minX" : -50, + "maxX" : 50, + "binsY" : 100, + "minY" : 0, + "maxY" : 250, + "xtitle" : "M3L0 - LX Track Hit Time [ns]", + "ytitle" : "Track Chi2 " + }, + + "numTracks_h" : { + "bins" : 10, + "minX" : -0.5, + "maxX" : 9.5, + "xtitle" : "Number of KF Tracks", + "ytitle" : "Events" + }, + "trkChiSq_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 100.0, + "xtitle" : "Track ChiSq", + "ytitle" : "Tracks" + }, + "trkP_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 5.0, + "xtitle" : "Track Momentum (GeV)", + "ytitle" : "Tracks" + }, + + "trkNHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Hits on Track", + "ytitle" : "Tracks" + }, + + "trkTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "trkTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "trkTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "electron_trkChiSq_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 100.0, + "xtitle" : "Track ChiSq", + "ytitle" : "Tracks" + }, + "electron_trkP_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 5.0, + "xtitle" : "Track Momentum (GeV)", + "ytitle" : "Tracks" + }, + + "electron_trkNHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Hits on Track", + "ytitle" : "Tracks" + }, + + "electron_trkTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "electron_trkTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "electron_trkTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "positron_trkChiSq_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 100.0, + "xtitle" : "Track ChiSq", + "ytitle" : "Tracks" + }, + "positron_trkP_h" : { + "bins" : 100, + "minX" : 0.0, + "maxX" : 5.0, + "xtitle" : "Track Momentum (GeV)", + "ytitle" : "Tracks" + }, + + "positron_trkNHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Hits on Track", + "ytitle" : "Tracks" + }, + + "positron_trkTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "positron_trkTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "positron_trkTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Track Time", + "ytitle" : "Tracks" + }, + "CalibratedTrackTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalibratedTrackTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalibratedTrackTime_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "CalTrackTime_Minus_M3L0_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalTrackTime_Minus_M3L0_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalTrackTime_Minus_M3L0_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "CalibratedTrackTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalibratedTrackTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalibratedTrackTime_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "CalibratedTrackTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalibratedTrackTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalibratedTrackTime_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "CalTrackTime_Minus_M3L0_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalTrackTime_Minus_M3L0_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalTrackTime_Minus_M3L0_Top_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "CalTrackTime_Minus_M3L0_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "electron_CalTrackTime_Minus_M3L0_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "positron_CalTrackTime_Minus_M3L0_Bot_h" : { + "bins" : 100, + "minX" : -50, + "maxX" : 50, + "xtitle" : "Calibrated Track Time", + "ytitle" : "Tracks" + }, + "numEcalHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Reco ECal Hits", + "ytitle" : "Events" + }, + "ecalHitEnergy_h" : { + "bins" : 200, + "minX" : 0, + "maxX" : 2000, + "xtitle" : "Reco Ecal Hit Energy [MeV]", + "ytitle" : "Ecal Hits / 10 MeV" + }, + "numEcalClusters_h" : { + "bins" : 10, + "minX" : -0.5, + "maxX" : 9.5, + "xtitle" : "Number of Reco Ecal Clusters", + "ytitle" : "Events" + }, + "ecalClusterEnergy_h" : { + "bins" : 150, + "minX" : 0, + "maxX" : 3000, + "xtitle" : "Reco Ecal Cluster Energy [MeV]", + "ytitle" : "Clusters / 20 MeV" + } +} diff --git a/analysis/selections/svtTiming/evtPhase0.json b/analysis/selections/svtTiming/evtPhase0.json new file mode 100644 index 000000000..6de0e3a2d --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase0.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 0, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase0FEE.json b/analysis/selections/svtTiming/evtPhase0FEE.json new file mode 100644 index 000000000..1e6cfbda9 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase0FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 0, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svtTiming/evtPhase1.json b/analysis/selections/svtTiming/evtPhase1.json new file mode 100644 index 000000000..e51a92a8e --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase1.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 1, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase1FEE.json b/analysis/selections/svtTiming/evtPhase1FEE.json new file mode 100644 index 000000000..faebb590e --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase1FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 1, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svtTiming/evtPhase2.json b/analysis/selections/svtTiming/evtPhase2.json new file mode 100644 index 000000000..ac1489653 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase2.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 2, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase2FEE.json b/analysis/selections/svtTiming/evtPhase2FEE.json new file mode 100644 index 000000000..71291919d --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase2FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 2, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svtTiming/evtPhase3.json b/analysis/selections/svtTiming/evtPhase3.json new file mode 100644 index 000000000..170cbbc50 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase3.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 3, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase3FEE.json b/analysis/selections/svtTiming/evtPhase3FEE.json new file mode 100644 index 000000000..632177553 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase3FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 3, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svtTiming/evtPhase4.json b/analysis/selections/svtTiming/evtPhase4.json new file mode 100644 index 000000000..8a5d535d5 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase4.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 4, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase4FEE.json b/analysis/selections/svtTiming/evtPhase4FEE.json new file mode 100644 index 000000000..b4deb420f --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase4FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 4, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svtTiming/evtPhase5.json b/analysis/selections/svtTiming/evtPhase5.json new file mode 100644 index 000000000..16f26ade7 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase5.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 5, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/svtTiming/evtPhase5FEE.json b/analysis/selections/svtTiming/evtPhase5FEE.json new file mode 100644 index 000000000..e53c777e4 --- /dev/null +++ b/analysis/selections/svtTiming/evtPhase5FEE.json @@ -0,0 +1,17 @@ +{ + "modTime_eq" : { + "cut" : 5, + "id" : 0, + "info" : "Phase 0" + }, + "trkP_gt": { + "cut" : 2.9, + "id" : 1, + "info" : "track P >2.9 GeV (FEE)" + }, + "trkP_lt": { + "cut" : 4.1, + "id" : 2, + "info" : "track P <4.1 GeV (FEE)" + } +} diff --git a/analysis/selections/svttiming_10hit.json b/analysis/selections/svttiming_10hit.json new file mode 100644 index 000000000..989d07c4a --- /dev/null +++ b/analysis/selections/svttiming_10hit.json @@ -0,0 +1,12 @@ +{ + "nHits_gt" : { + "cut" : 9, + "id" : 0, + "info" : "Number of hits on track > 9 " + }, + "trkP_gt" : { + "cut" : 1.0, + "id" : 1, + "info" : "Track Momentum >1.0 GeV " + } +} diff --git a/analysis/src/SvtTimingHistos.cxx b/analysis/src/SvtTimingHistos.cxx new file mode 100644 index 000000000..9d52a517d --- /dev/null +++ b/analysis/src/SvtTimingHistos.cxx @@ -0,0 +1,339 @@ +#include "SvtTimingHistos.h" +#include + +SvtTimingHistos::SvtTimingHistos(const std::string& inputName, ModuleMapper* mmapper) { + m_name = inputName; + mmapper_ = mmapper; +} + + +void SvtTimingHistos::Define1DHistos() { + +} + +void SvtTimingHistos::DefineHistos(){ + std::string makeMultiplesTag = "svtHit"; + std::vector sensorNames; + mmapper_->getStrings(sensorNames); + HistoManager::DefineHistos(sensorNames, makeMultiplesTag ); + HistoManager::DefineHistos(sensorNames, "trkrHit" ); + HistoManager::DefineHistos(sensorNames, "trkRawHit" ); + HistoManager::DefineHistos(sensorNames, "trkSiCluster" ); + + +} + +void SvtTimingHistos::FillRawHits(std::vector *rawHits, float weight ) { + int nHits = rawHits->size(); + Fill1DHisto("numTrkrHits_h", (float)nHits, weight); + std::string h_name = ""; + int fitNumber=0;//take the first fit even if there is pileup + + for (int i=0; i < nHits; i++) + { + RawSvtHit *hit = rawHits->at(i); + auto mod = std::to_string(hit->getModule()); + auto lay = std::to_string(hit->getLayer()); + + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + + // std::cout<getAmp(fitNumber), weight); // Scaled to MeV + Fill1DHisto(sensorName+"_svtHit_Time_h", hit->getT0(fitNumber), weight); + Fill1DHisto(sensorName+"_svtHit_TimeWide_h", hit->getT0(fitNumber), weight); + + // Fill1DHisto("svtHitEdep"+lname, hit->getAmp(fitNumber), weight); // Scaled to MeV + ///Fill1DHisto("svtHitTime"+lname, hit->getT0(fitNumber), weight); + } + + + +} + + +void SvtTimingHistos::FillTrackerHits(std::vector *trkrHits, float weight ) { + int nHits = trkrHits->size(); + Fill1DHisto("numTrkrHits_h", (float)nHits, weight); + std::string h_name = ""; + bool hasRefHit=false; + std::string refModString="ly11_m0"; //"L5T_axial_ele" + float refTime=-666.; + + for (int i=0; i < nHits; i++) + { + TrackerHit *hit = trkrHits->at(i); + RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits().At(0); + auto mod = std::to_string(rhit->getModule()); + auto lay = std::to_string(rhit->getLayer()); + std::string swName="ly"+lay+"_m"+mod; + if (swName==refModString){ + hasRefHit=true; + refTime=hit->getTime(); + } + + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + Fill1DHisto(sensorName+"_trkrHit_Edep_h", hit->getCharge()*1000000.0, weight); // Scaled to MeV + Fill1DHisto(sensorName+"_trkrHit_Time_h", hit->getTime(), weight); + } + + // if track doesn't have a hit in reference layer, just return + if(!hasRefHit) + return; + for (int i=0; i < nHits; i++) + { + TrackerHit *hit = trkrHits->at(i); + RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits().At(0); + auto mod = std::to_string(rhit->getModule()); + auto lay = std::to_string(rhit->getLayer()); + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + // std::cout<getTime(), weight); + } + +} + +void SvtTimingHistos::FillTracks(std::vector *tracks, float weight ) { + int nTracks = tracks->size(); + Fill1DHisto("numTracks_h", (float)nTracks, weight); + + for (int i=0;iat(i); + int nHitsOnTrack=trk->getTrackerHitCount(); + float trkP=(float)trk->getP(); + Fill1DHisto("trkChiSq_h",(float)trk->getChi2(),weight); + Fill1DHisto("trkTime_h",(float)trk->getTrackTime(),weight); + Fill1DHisto("trkP_h",trkP,weight); + Fill1DHisto("trkNHits_h",(float)trk->getTrackerHitCount(),weight); + } +} + +void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map *timingCalib, int phase, CalCluster *cluster, float weight){ + + int fitNumber=0; + int secondFit=1; + // std::string refModStringT="ly11_m0"; //"L5T_axial_ele" + // std::string refModStringB="ly11_m1"; //"L5B_stereo_ele" + std::string refModStringT="ly8_m0"; //"L3T_stereo" + std::string refModStringB="ly8_m1"; //"L3B_axial" + + bool useCalibration=true; + if(timingCalib->size()<1){ + if(debug_)std::cout<<"Calibration Map is not there...no calib"<getTrackerHitCount(); + int trkCh=trk->getCharge(); + std::string chStr="electron"; + if(trkCh>0){ + chStr="positron"; + //refModStringT="ly11_m2"; + // refModStringB="ly11_m3"; + } + + float clTimeOffset=37.5; //ns + float roughSVTHitTimeOffsetSlim=-7.0; //ns + float roughSVTHitTimeOffsetOld=-16.5; //ns + + + float clTime=(float)cluster->getTime()-clTimeOffset; + float trkTime=(float)trk->getTrackTime()-roughSVTHitTimeOffsetOld; + float trkP=(float)trk->getP(); + float refTime=-666.; + bool hasRefHit=false; + auto trkHits=trk->getSvtHits(); + Fill1DHisto("trkChiSq_h",(float)trk->getChi2(),weight); + Fill1DHisto("trkTime_h",trkTime,weight); + Fill1DHisto("trkTime_Minus_CluTime_h",trkTime-clTime,weight); + Fill1DHisto("ecalClusterTime_h",clTime,weight); + Fill1DHisto("ecalClusterEnergy_h",(float) cluster->getEnergy(),weight); + Fill2DHisto("cluTime_vs_trkTime_hh",clTime,trkTime,weight); + Fill1DHisto("ecalClusterTime_h",clTime,weight); + if(trk->isTopTrack()){ + Fill1DHisto("trkTime_Top_h",trkTime,weight); + Fill1DHisto("trkTime_Minus_CluTime_Top_h",trkTime-clTime,weight); + Fill1DHisto("ecalClusterTime_Top_h",clTime,weight); + Fill2DHisto("cluTime_vs_trkTime_Top_hh",clTime,trkTime,weight); + } else { + Fill1DHisto("trkTime_Bot_h",trkTime,weight); + Fill1DHisto("trkTime_Minus_CluTime_Bot_h",trkTime-clTime,weight); + Fill1DHisto("ecalClusterTime_Bot_h",clTime,weight); + Fill2DHisto("cluTime_vs_trkTime_Bot_hh",clTime,trkTime,weight); + } + + Fill1DHisto("trkP_h",trkP,weight); + Fill1DHisto("trkNHits_h",(float)trk->getTrackerHitCount(),weight); + + Fill1DHisto(chStr+"_trkChiSq_h",(float)trk->getChi2(),weight); + Fill1DHisto(chStr+"_trkTime_h",trkTime,weight); + Fill1DHisto(chStr+"_trkTime_Minus_CluTime_h",trkTime-clTime,weight); + Fill1DHisto(chStr+"_ecalClusterTime_h",clTime,weight); + Fill2DHisto(chStr+"_cluTime_vs_trkTime_hh",clTime,trkTime,weight); + if(trk->isTopTrack()){ + Fill1DHisto(chStr+"_trkTime_Top_h",trkTime,weight); + Fill1DHisto(chStr+"_trkTime_Minus_CluTime_Top_h",trkTime-clTime,weight); + Fill1DHisto(chStr+"_ecalClusterTime_Top_h",clTime,weight); + Fill2DHisto(chStr+"_cluTime_vs_trkTime_Top_hh",clTime,trkTime,weight); + } else { + Fill1DHisto(chStr+"_trkTime_Bot_h",trkTime,weight); + Fill1DHisto(chStr+"_trkTime_Minus_CluTime_Bot_h",trkTime-clTime,weight); + Fill1DHisto(chStr+"_ecalClusterTime_Bot_h",clTime,weight); + Fill2DHisto(chStr+"_cluTime_vs_trkTime_Bot_hh",clTime,trkTime,weight); + } + Fill1DHisto(chStr+"_trkP_h",trkP,weight); + Fill1DHisto(chStr+"_trkNHits_h",(float)trk->getTrackerHitCount(),weight); + double trkTimeCorr=0; + for (int i=0; i < nHitsOnTrack; i++) + { + double calibForLayer=0.0; + TrackerHit *hit =(TrackerHit*) trkHits.At(i); + RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits().At(0); + auto mod = std::to_string(rhit->getModule()); + auto lay = std::to_string(rhit->getLayer()); + std::string swName="ly"+lay+"_m"+mod; + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + std::string phSt=std::to_string(phase); + std::string calibName=sensorName+"_phase"+phSt; + if(useCalibration){ + if(debug_)std::cout<<"Getting calib for "<at(calibName); + if(debug_)std::cout<getT0(fitNumber)+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_Time_h",hitTime, weight); + //Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + + Fill2DHisto("HitMinCluTime_Versus_Layer_hh", rhit->getLayer()-1, hitTime-clTime,weight); + Fill2DHisto(chStr+"_HitMinCluTime_Versus_Layer_hh", rhit->getLayer()-1, hitTime-clTime,weight); + if(trk->isTopTrack()){ + Fill2DHisto("HitMinCluTime_Versus_Layer_Top_hh", rhit->getLayer()-1, hitTime-clTime,weight); + Fill2DHisto(chStr+"_HitMinCluTime_Versus_Layer_Top_hh", rhit->getLayer()-1, hitTime-clTime,weight); + }else{ + Fill2DHisto("HitMinCluTime_Versus_Layer_Bot_hh", rhit->getLayer()-1, hitTime-clTime,weight); + Fill2DHisto(chStr+"_HitMinCluTime_Versus_Layer_Bot_hh", rhit->getLayer()-1, hitTime-clTime,weight); + } + + Fill1DHisto(sensorName+"_trkSiCluster_Time_Minus_CluTime_h",hitTime-clTime, weight); + Fill2DHisto(sensorName+"_trkSiCluster_Time_Versus_CluTime_hh",hitTime, clTime, weight); + + Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_Time_Minus_CluTime_h",hitTime-clTime, weight); + Fill2DHisto(sensorName+"_"+chStr+"_trkSiCluster_Time_Versus_CluTime_hh",hitTime, clTime, weight); + + if(rhit->getFitN()==2){ + //Fill1DHisto(sensorName+"_trkSiCluster_2Fits_Time_h",hitTime, weight); + // Fill1DHisto(sensorName+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + //Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_2Fits_Time_h",hitTime, weight); + //Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + } + + } + trkTimeCorr=trkTimeCorr/nHitsOnTrack; + Fill1DHisto("CalibratedTrackTime_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_h", trkTimeCorr, weight); + Fill1DHisto("CalibratedTrackTime_Minus_CluTime_h", trkTimeCorr-clTime, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Minus_CluTime_h", trkTimeCorr-clTime, weight); + Fill2DHisto("CalibratedTrackTime_Versus_CluTime_hh",clTime,trkTimeCorr,weight); + Fill2DHisto(chStr+"_CalibratedTrackTime_Versus_CluTime_hh",clTime,trkTimeCorr,weight); + + if(trk->isTopTrack()){ + Fill1DHisto("CalibratedTrackTime_Top_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Top_h", trkTimeCorr, weight); + Fill1DHisto("CalibratedTrackTime_Minus_CluTime_Top_h", trkTimeCorr-clTime, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Minus_CluTime_Top_h", trkTimeCorr-clTime, weight); + Fill2DHisto("CalibratedTrackTime_Versus_CluTime_Top_hh",clTime,trkTimeCorr,weight); + Fill2DHisto(chStr+"_CalibratedTrackTime_Versus_CluTime_Top_hh",clTime,trkTimeCorr,weight); + }else { + Fill1DHisto("CalibratedTrackTime_Bot_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Bot_h", trkTimeCorr, weight); + Fill1DHisto("CalibratedTrackTime_Minus_CluTime_Bot_h", trkTimeCorr-clTime, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Minus_CluTime_Bot_h", trkTimeCorr-clTime, weight); + Fill2DHisto("CalibratedTrackTime_Versus_CluTime_Bot_hh",clTime,trkTimeCorr,weight); + Fill2DHisto(chStr+"_CalibratedTrackTime_Versus_CluTime_Bot_hh",clTime,trkTimeCorr,weight); + } + // if track doesn't have a hit in reference layer, just return + /* + if(!hasRefHit) + return; + Fill1DHisto("CalTrackTime_Minus_M3L0_h", trkTimeCorr-refTime, weight); + Fill1DHisto(chStr+"_CalTrackTime_Minus_M3L0_h", trkTimeCorr-refTime, weight); + + if(trk->isTopTrack()){ + Fill1DHisto("CalTrackTime_Minus_M3L0_Top_h", trkTimeCorr-refTime, weight); + Fill1DHisto(chStr+"_CalTrackTime_Minus_M3L0_Top_h", trkTimeCorr-refTime, weight); + }else { + Fill1DHisto("CalTrackTime_Minus_M3L0_Bot_h", trkTimeCorr-refTime, weight); + Fill1DHisto(chStr+"_CalTrackTime_Minus_M3L0_Bot_h", trkTimeCorr-refTime, weight); + } + + for (int i=0; i < nHitsOnTrack; i++) + { + double calibForLayer=0.0; + TrackerHit *hit =(TrackerHit*) trkHits.At(i); + RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits().At(0); + auto mod = std::to_string(rhit->getModule()); + auto lay = std::to_string(rhit->getLayer()); + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + std::string phSt=std::to_string(phase); + std::string calibName=sensorName+"_phase"+phSt; + if(useCalibration){ + calibForLayer=timingCalib->at(calibName); + //std::cout<getTime()-calibForLayer, (float)trk->getChi2(), weight); + Fill1DHisto(sensorName+"_trkSiCluster_M3L0_Minus_LX_Time_h", refTime-hit->getTime()-calibForLayer, weight); + Fill2DHisto(sensorName+"_trkSiCluster_M3L0_Versus_LX_Time_hh", refTime,hit->getTime()+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_M3L0_Minus_LX_Time_h", refTime-hit->getTime()-calibForLayer, weight); + // Fill2DHisto(sensorName+"_"+chStr+"_trkSiCluster_M3L0_Minus_LX_Time_Versus_Chi2_hh", refTime-hit->getTime()-calibForLayer, (float)trk->getChi2(), weight); + Fill2DHisto(sensorName+"_"+chStr+"_trkSiCluster_M3L0_Versus_LX_Time_hh", refTime,hit->getTime()+calibForLayer, weight); + if(rhit->getFitN()==2){ + //Fill1DHisto(sensorName+"_trkSiCluster_M3L0_Minus_LX_2Fits_Time_h", refTime-hit->getTime()-calibForLayer, weight); + //Fill2DHisto(sensorName+"_trkSiCluster_M3L0_Versus_LX_2Fits_Time_hh", refTime,hit->getTime()+calibForLayer, weight); + //Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_M3L0_Minus_LX_2Fits_Time_h", refTime-hit->getTime()-calibForLayer, weight); + //Fill2DHisto(sensorName+"_"+chStr+"_trkSiCluster_M3L0_Versus_LX_2Fits_Time_hh", refTime,hit->getTime()+calibForLayer, weight); + } + } + */ + +} + +void SvtTimingHistos::FillEcalHits(std::vector *ecalHits, float weight ) { + int nHits = ecalHits->size(); + Fill1DHisto("numEcalHits_h", (float)nHits, weight); + for (int i=0; i < nHits; i++) + { + CalHit *hit = ecalHits->at(i); + Fill1DHisto("ecalHitEnergy_h", hit->getEnergy()*1000.0, weight); // Scaled to MeV + } +} + +void SvtTimingHistos::FillEcalClusters(std::vector *ecalClusters, float weight ) { + int nClusters = ecalClusters->size(); + Fill1DHisto("numEcalClusters_h", (float)nClusters, weight); + for (int i=0; i < nClusters; i++) + { + CalCluster *cluster = ecalClusters->at(i); + Fill1DHisto("ecalClusterEnergy_h", cluster->getEnergy()*1000.0, weight); // Scaled to MeV + } +} diff --git a/processors/config/anaSvtTiming_cfg.py b/processors/config/anaSvtTiming_cfg.py new file mode 100644 index 000000000..65132c170 --- /dev/null +++ b/processors/config/anaSvtTiming_cfg.py @@ -0,0 +1,75 @@ +import HpstrConf +import sys +import os +import baseConfig as base + + +options = base.parser.parse_args() + + +# Use the input file to set the output file name +infile = options.inFilename +outfile = options.outFilename + +print('Input file: %s' % infile) +print('Output file: %s' % outfile) + +p = HpstrConf.Process() + +p.run_mode = 1 +#p.max_events = 1000 + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### + +recoana = HpstrConf.Processor('recoana', 'SvtTimingProcessor') + +############################### +# Processor Configuration # +############################### +#SvtTiming +recoana.parameters["debug"] = 0 +recoana.parameters["anaName"] = "svtHitTimingAna" +recoana.parameters["trkColl"] = "KalmanFullTracks" +#recoana.parameters["trkrHitColl"] = "RotatedHelicalTrackHits" +recoana.parameters["rawHitColl"] = "SVTRawHitsOnTrack_KF" +recoana.parameters["trkrHitColl"] = "SiClustersOnTrack" +recoana.parameters["fspColl"] = "FinalStateParticles_KF" +recoana.parameters["ecalHitColl"] = "RecoEcalHits" +recoana.parameters["ecalClusColl"] = "RecoEcalClusters" +recoana.parameters["histCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/reco/svtTiming-ecalRef.json' +recoana.parameters["mcHistoCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/mc/basicMC.json' +#recoana.parameters["timingCalibFile"]="/sdf/group/hps/users/mgraham/TimingCorrections/physrun2021/run14507_calib.txt" +#recoana.parameters["timingCalibFile"]="/sdf/group/hps/users/mgraham/TimingCorrections/physrun2021/svtTiming_ecalRef_run_14495_preCal_calib.txt" +recoana.parameters["timingCalibDir"]="/sdf/group/hps/users/mgraham/TimingCorrections/physrun2021/perRunTiming" +recoana.parameters["postfixTiming"]="_calib_constants_final.txt" +recoana.parameters["analysis"] = options.analysis +recoana.parameters["selectionjson"] = os.environ['HPSTR_BASE']+'/analysis/selections/svttiming_10hit.json' +print("anaSvtTiming_cfg.py::Setting runNumber to "+str(options.runNumber)) +recoana.parameters["runNumber"]=options.runNumber + +RegionPath=os.environ['HPSTR_BASE']+"/analysis/selections/svtTiming/" +recoana.parameters["regionDefinitions"] = [RegionPath+'evtPhase0.json', + RegionPath+'evtPhase1.json', + RegionPath+'evtPhase2.json', + RegionPath+'evtPhase3.json', + RegionPath+'evtPhase4.json', + RegionPath+'evtPhase5.json'] +# RegionPath+'evtPhase0FEE.json', +# RegionPath+'evtPhase1FEE.json', +# RegionPath+'evtPhase2FEE.json', +# RegionPath+'evtPhase3FEE.json', +# RegionPath+'evtPhase4FEE.json', +# RegionPath+'evtPhase5FEE.json'] + +# Sequence which the processors will run. +p.sequence = [recoana] + +p.input_files = infile +p.output_files = [outfile] + +p.printProcess() diff --git a/processors/config/baseConfig.py b/processors/config/baseConfig.py index 4fdaf9f0c..8bdfca7ca 100644 --- a/processors/config/baseConfig.py +++ b/processors/config/baseConfig.py @@ -22,7 +22,7 @@ help="Which analysis is being run ", metavar="analysis", default="vertex") parser.add_argument('--infile', '-i', type=str, dest="inFilename", metavar='infiles', nargs="+", help="Input files, specify on or more.") - +parser.add_argument('--runnumber', '-r', type=int, dest="runNumber",default=-666) #options = parser.parse_args() #if options.analysis != "simps" and options.analysis != "vertex": diff --git a/processors/include/SvtTimingProcessor.h b/processors/include/SvtTimingProcessor.h new file mode 100644 index 000000000..96cce9a7c --- /dev/null +++ b/processors/include/SvtTimingProcessor.h @@ -0,0 +1,93 @@ +#ifndef __SVTTIMING_PROCESSOR_H__ +#define __SVTTIMING_PROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "Collections.h" +#include "Track.h" +#include "TrackerHit.h" +#include "SvtTimingHistos.h" +#include "BaseSelector.h" +#include "EventHeader.h" +#include "AnaHelpers.h" +#include "ModuleMapper.h" +//ROOT +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" + +class TTree; + + +class SvtTimingProcessor : public Processor { + + public: + + SvtTimingProcessor(const std::string& name, Process& process); + + ~SvtTimingProcessor(); + + virtual bool process(IEvent* ievent); + + virtual void initialize(TTree* tree); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + ModuleMapper * mmapper_; + //Containers to hold histogrammer info + SvtTimingHistos* histos{nullptr}; + std::string histCfgFilename_; + int runNumber_; + //TODO Change this to be held from HPSEvent + TTree* tree_; + TBranch* brawHits_{nullptr}; + TBranch* btrkrHits_{nullptr}; + TBranch* btracks_{nullptr}; + TBranch* bfsps_{nullptr}; + TBranch* becalHits_{nullptr}; + TBranch* becalClusters_{nullptr}; + TBranch* bevth_{nullptr}; + + std::vector * rawHits_{}; + std::vector * trkrHits_{}; + std::vector * tracks_{}; + std::vector * fsps_{}; + std::vector * ecalHits_{}; + std::vector * ecalClusters_{}; + EventHeader* evth_{nullptr}; + + std::string anaName_{"recoHitAna"}; + std::string trkColl_{"GBLTracks"}; + std::string rawHitColl_{"SVTRawHitsOnTrack_KF"}; + std::string trkrHitColl_{"RotatedHelicalTrackHits"}; + std::string fspColl_{"FinalStateParticles_KF"}; + std::string ecalHitColl_{"EcalCalHits"}; + std::string ecalClusColl_{"EcalClustersCorr"}; + std::string timingCalibDir_{"timingCalibDir"}; + std::string postfixTiming_{"postfixTiming"}; + + std::shared_ptr evtSelector_; + std::string selectionCfg_; + + std::vector regionSelections_; + std::map > _reg_phase_selectors; + std::map > _reg_phase_histos; + std::vector _regions; + + typedef std::map >::iterator reg_it; + std::shared_ptr _ah; + std::map timingCalibConstants_; + //Debug Level + int debug_{0}; + + + +}; + + +#endif diff --git a/processors/src/SvtTimingProcessor.cxx b/processors/src/SvtTimingProcessor.cxx new file mode 100644 index 000000000..b89baebd5 --- /dev/null +++ b/processors/src/SvtTimingProcessor.cxx @@ -0,0 +1,201 @@ +/** + * @file SvtTimingProcessor.cxx + * @brief AnaProcessor used fill histograms for SVT Timing Calibrations + * @author Cameron Bravo, Matt Graham, SLAC National Accelerator Laboratory + */ +#include "SvtTimingProcessor.h" +#include +#include + +//TODO CHECK THIS DESTRUCTOR +SvtTimingProcessor::~SvtTimingProcessor(){} + +SvtTimingProcessor::SvtTimingProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(); +} + +void SvtTimingProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring SvtTimingProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + anaName_ = parameters.getString("anaName"); + rawHitColl_ = parameters.getString("rawHitColl"); + trkColl_ = parameters.getString("trkColl"); + trkrHitColl_ = parameters.getString("trkrHitColl"); + fspColl_ = parameters.getString("fspColl"); + // ecalHitColl_ = parameters.getString("ecalHitColl"); + //ecalClusColl_ = parameters.getString("ecalClusColl"); + histCfgFilename_ = parameters.getString("histCfg"); + selectionCfg_ = parameters.getString("selectionjson",selectionCfg_); + regionSelections_ = parameters.getVString("regionDefinitions",regionSelections_); + timingCalibDir_ = parameters.getString("timingCalibDir"); + postfixTiming_ = parameters.getString("postfixTiming"); + runNumber_=parameters.getInteger("runNumber"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + +void SvtTimingProcessor::initialize(TTree* tree) { + tree_= tree; + _ah = std::make_shared(); + // init histos + histos = new SvtTimingHistos(anaName_.c_str(),mmapper_); + histos->loadHistoConfig(histCfgFilename_); + histos->DefineHistos(); + if (!selectionCfg_.empty()) { + evtSelector_ = std::make_shared(name_+"_evtSelector",selectionCfg_); + evtSelector_->setDebug(debug_); + evtSelector_->LoadSelection(); + } + + for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { + std::string regname = AnaHelpers::getFileName(regionSelections_[i_reg],false); + std::cout<<"Setting up region:: " << regname <(anaName_+"_"+regname, regionSelections_[i_reg]); + _reg_phase_selectors[regname]->setDebug(debug_); + _reg_phase_selectors[regname]->LoadSelection(); + + _reg_phase_histos[regname] = std::make_shared(anaName_+"_"+regname,mmapper_); + _reg_phase_histos[regname]->loadHistoConfig(histCfgFilename_); + _reg_phase_histos[regname]->DefineHistos(); + _regions.push_back(regname); + } + + // init TTree + tree_->SetBranchAddress(rawHitColl_.c_str() , &rawHits_ , &brawHits_ ); + tree_->SetBranchAddress(trkrHitColl_.c_str() , &trkrHits_ , &btrkrHits_ ); + tree_->SetBranchAddress(trkColl_.c_str() , &tracks_ , &btracks_ ); + tree_->SetBranchAddress(fspColl_.c_str() , &fsps_ , &bfsps_ ); + tree_->SetBranchAddress("EventHeader" , &evth_ , &bevth_ ); + //tree_->SetBranchAddress(ecalHitColl_.c_str() , &ecalHits_ , &becalHits_ ); + //tree_->SetBranchAddress(ecalClusColl_.c_str() , &ecalClusters_, &becalClusters_); + + std::string timingCalibFile_=timingCalibDir_+"/run"+std::to_string(runNumber_)+"/run"+std::to_string(runNumber_)+postfixTiming_; + std::ifstream calibFile(timingCalibFile_); + std::string sensorName; + double calibMean; + + if(calibFile.is_open()){ + std::cout<<"SvtTimingProcessor::Loading Timing Calibration File: "<>sensorName>>calibMean; + std::cout<<"name = "<getEventTime()%24)/4.; + int phase=int(modTime); + if(debug_) + std::cout<<"event phase = "<FillRawHits(rawHits_); + // histos->FillTrackerHits(trkrHits_); + // int nTracks = tracks_->size(); + //for (int i=0;iat(i); + // int nHitsOnTrack=trk->getTrackerHitCount(); + // float trkP=(float)trk->getP(); + // if(!evtSelector_->passCutGt("nHits_gt",nHitsOnTrack,weight)) + // continue; + // if(!evtSelector_->passCutGt("trkP_gt",trkP,weight)) + // continue; + // histos->FillHitsOnTrack(trk,&timingCalibConstants_, phase,weight); + //} + + int nFSPs=fsps_->size(); + for(int i=0; iat(i); + Track trk=fsp->getTrack(); + CalCluster cluster=fsp->getCluster(); + + //require both a track and matched cluster + if(&trk==NULL) + continue; + if(&cluster==NULL) + continue; + + bool foundL1 = false; + bool foundL2 = false; + //_ah->InnermostLayerCheck(pos_trk_from_trkList, foundL1pos, foundL2pos); + _ah->InnermostLayerCheck(&trk, foundL1, foundL2); + + int nHitsOnTrack=trk.getTrackerHitCount(); + float trkP=(float)trk.getP(); + if(!evtSelector_->passCutGt("nHits_gt",nHitsOnTrack,weight)) + continue; + if(!evtSelector_->passCutGt("trkP_gt",trkP,weight)) + continue; + if(debug_) + std::cout<<"Filling Histo"<FillHitsOnTrack(&trk,&timingCalibConstants_, phase, &cluster, weight); + } + + for (auto region : _regions ) { + if (_reg_phase_selectors[region] && !_reg_phase_selectors[region]->passCutEq("modTime_eq",modTime,weight)) + continue; + + for (int i=0;iat(i); + Track trk=fsp->getTrack(); + CalCluster cluster=fsp->getCluster(); + + //require both a track and matched cluster + if(&trk==NULL) + continue; + if(&cluster==NULL) + continue; + int nHitsOnTrack=trk.getTrackerHitCount(); + float trkP=(float)trk.getP(); + if(!evtSelector_->passCutGt("nHits_gt",nHitsOnTrack,weight)) + continue; + if(!evtSelector_->passCutGt("trkP_gt",trkP,weight)) + continue; + /* + std::cout<<"region = "<passCutGt("trkP_gt",trkP,weight)<passCutLt("trkP_lt",trkP,weight)<passCutGt("trkP_gt",trkP,weight)) + continue; + if (_reg_phase_selectors[region] && !_reg_phase_selectors[region]->passCutLt("trkP_lt",trkP,weight)) + continue; + //std::cout<<"region = "<FillHitsOnTrack(trk,weight); + _reg_phase_histos[region]->FillHitsOnTrack(&trk, &timingCalibConstants_, phase, &cluster, weight); + } + + } + + //histos->FillEcalHits(ecalHits_); + //histos->FillEcalClusters(ecalClusters_); + + return true; +} + +void SvtTimingProcessor::finalize() { + + histos->saveHistos(outF_, anaName_.c_str()); + delete histos; + histos = nullptr; + + for (reg_it it = _reg_phase_histos.begin(); it!=_reg_phase_histos.end(); ++it) { + std::string dirName = anaName_+"_"+it->first; + (it->second)->saveHistos(outF_,dirName); + } + +} +DECLARE_PROCESSOR(SvtTimingProcessor);