From 6ad43cbcda4e771e80db680401373384bd5678c0 Mon Sep 17 00:00:00 2001 From: Graham Date: Thu, 2 Feb 2023 15:15:34 -0800 Subject: [PATCH 1/5] svt timing calibration analysis --- analysis/include/SvtTimingHistos.h | 37 ++ analysis/plotconfigs/reco/layersRecoHit.json | 137 +++++ analysis/plotconfigs/reco/svtTiming.json | 535 ++++++++++++++++++ analysis/selections/evtPhase0.json | 7 + analysis/selections/evtPhase1.json | 7 + analysis/selections/evtPhase2.json | 7 + analysis/selections/evtPhase3.json | 7 + analysis/selections/evtPhase4.json | 7 + analysis/selections/evtPhase5.json | 7 + analysis/selections/svtTiming/evtPhase0.json | 7 + .../selections/svtTiming/evtPhase0FEE.json | 17 + analysis/selections/svtTiming/evtPhase1.json | 7 + .../selections/svtTiming/evtPhase1FEE.json | 17 + analysis/selections/svtTiming/evtPhase2.json | 7 + .../selections/svtTiming/evtPhase2FEE.json | 17 + analysis/selections/svtTiming/evtPhase3.json | 7 + .../selections/svtTiming/evtPhase3FEE.json | 17 + analysis/selections/svtTiming/evtPhase4.json | 7 + .../selections/svtTiming/evtPhase4FEE.json | 17 + analysis/selections/svtTiming/evtPhase5.json | 7 + .../selections/svtTiming/evtPhase5FEE.json | 17 + analysis/selections/svttiming_10hit.json | 12 + analysis/src/SvtTimingHistos.cxx | 162 ++++++ processors/config/anaSvtTiming_cfg.py | 62 ++ processors/include/SvtTimingProcessor.h | 82 +++ processors/src/SvtTimingProcessor.cxx | 112 ++++ 26 files changed, 1325 insertions(+) create mode 100644 analysis/include/SvtTimingHistos.h create mode 100644 analysis/plotconfigs/reco/layersRecoHit.json create mode 100644 analysis/plotconfigs/reco/svtTiming.json create mode 100644 analysis/selections/evtPhase0.json create mode 100644 analysis/selections/evtPhase1.json create mode 100644 analysis/selections/evtPhase2.json create mode 100644 analysis/selections/evtPhase3.json create mode 100644 analysis/selections/evtPhase4.json create mode 100644 analysis/selections/evtPhase5.json create mode 100644 analysis/selections/svtTiming/evtPhase0.json create mode 100644 analysis/selections/svtTiming/evtPhase0FEE.json create mode 100644 analysis/selections/svtTiming/evtPhase1.json create mode 100644 analysis/selections/svtTiming/evtPhase1FEE.json create mode 100644 analysis/selections/svtTiming/evtPhase2.json create mode 100644 analysis/selections/svtTiming/evtPhase2FEE.json create mode 100644 analysis/selections/svtTiming/evtPhase3.json create mode 100644 analysis/selections/svtTiming/evtPhase3FEE.json create mode 100644 analysis/selections/svtTiming/evtPhase4.json create mode 100644 analysis/selections/svtTiming/evtPhase4FEE.json create mode 100644 analysis/selections/svtTiming/evtPhase5.json create mode 100644 analysis/selections/svtTiming/evtPhase5FEE.json create mode 100644 analysis/selections/svttiming_10hit.json create mode 100644 analysis/src/SvtTimingHistos.cxx create mode 100644 processors/config/anaSvtTiming_cfg.py create mode 100644 processors/include/SvtTimingProcessor.h create mode 100644 processors/src/SvtTimingProcessor.cxx diff --git a/analysis/include/SvtTimingHistos.h b/analysis/include/SvtTimingHistos.h new file mode 100644 index 000000000..30cea2756 --- /dev/null +++ b/analysis/include/SvtTimingHistos.h @@ -0,0 +1,37 @@ +#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 + +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 FillEcalHits(std::vector *ecalHits, float weight = 1.); + void FillEcalClusters(std::vector *ecalClusters, float weight = 1.); + + private: + + ModuleMapper* mmapper_; +}; + +#endif //SVTTIMING_ANAHISTOS_H diff --git a/analysis/plotconfigs/reco/layersRecoHit.json b/analysis/plotconfigs/reco/layersRecoHit.json new file mode 100644 index 000000000..c46af6164 --- /dev/null +++ b/analysis/plotconfigs/reco/layersRecoHit.json @@ -0,0 +1,137 @@ +{ + "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 " + }, + + "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" + }, + + "trkNHits_h" : { + "bins" : 20, + "minX" : -0.5, + "maxX" : 19.5, + "xtitle" : "Number of Hits on Track", + "ytitle" : "Tracks" + }, + "trkChiSq_h" : { + "bins" : 100, + "minX" : 0, + "maxX" : 100, + "xtitle" : "Track ChiSq", + "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/evtPhase0.json b/analysis/selections/evtPhase0.json new file mode 100644 index 000000000..6de0e3a2d --- /dev/null +++ b/analysis/selections/evtPhase0.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 0, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/evtPhase1.json b/analysis/selections/evtPhase1.json new file mode 100644 index 000000000..e51a92a8e --- /dev/null +++ b/analysis/selections/evtPhase1.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 1, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/evtPhase2.json b/analysis/selections/evtPhase2.json new file mode 100644 index 000000000..ac1489653 --- /dev/null +++ b/analysis/selections/evtPhase2.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 2, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/evtPhase3.json b/analysis/selections/evtPhase3.json new file mode 100644 index 000000000..170cbbc50 --- /dev/null +++ b/analysis/selections/evtPhase3.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 3, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/evtPhase4.json b/analysis/selections/evtPhase4.json new file mode 100644 index 000000000..8a5d535d5 --- /dev/null +++ b/analysis/selections/evtPhase4.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 4, + "id" : 0, + "info" : "Phase 0" + } +} diff --git a/analysis/selections/evtPhase5.json b/analysis/selections/evtPhase5.json new file mode 100644 index 000000000..16f26ade7 --- /dev/null +++ b/analysis/selections/evtPhase5.json @@ -0,0 +1,7 @@ +{ + "modTime_eq" : { + "cut" : 5, + "id" : 0, + "info" : "Phase 0" + } +} 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..268bc36d3 --- /dev/null +++ b/analysis/src/SvtTimingHistos.cxx @@ -0,0 +1,162 @@ +#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); + int fitNumber=0; + std::string refModString="ly11_m0"; //"L5T_axial_ele" + + for (int i=0;iat(i); + int nHitsOnTrack=trk->getTrackerHitCount(); + Fill1DHisto("trkChiSq_h",(float)trk->getChi2(),weight); + Fill1DHisto("trkTime_h",(float)trk->getTrackTime(),weight); + Fill1DHisto("trkNHits_h",(float)trk->getTrackerHitCount(),weight); + auto trkHits=trk->getSvtHits(); + float refTime=-666.; + bool hasRefHit=false; + for (int i=0; i < nHitsOnTrack; i++) + { + 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; + if (swName==refModString){ + hasRefHit=true; + refTime=hit->getTime(); + } + + std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); + Fill1DHisto(sensorName+"_trkSiCluster_Time_h", hit->getTime(), weight); + Fill1DHisto(sensorName+"_trkRawHit_Time_h", rhit->getT0(fitNumber), weight); + + } + + // if track doesn't have a hit in reference layer, just return + if(!hasRefHit) + continue; + for (int i=0; i < nHitsOnTrack; i++) + { + 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::cout<getTime(), 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..3baf92575 --- /dev/null +++ b/processors/config/anaSvtTiming_cfg.py @@ -0,0 +1,62 @@ +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["ecalHitColl"] = "RecoEcalHits" +recoana.parameters["ecalClusColl"] = "RecoEcalClusters" +recoana.parameters["histCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/reco/layersRecoHit.json' +recoana.parameters["mcHistoCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/mc/basicMC.json' +recoana.parameters["analysis"] = options.analysis +recoana.parameters["selectionjson"] = os.environ['HPSTR_BASE']+'/analysis/selections/empty.json' + +RegionPath=os.environ['HPSTR_BASE']+"/analysis/selections/" +recoana.parameters["regionDefinitions"] = [RegionPath+'evtPhase0.json', + RegionPath+'evtPhase1.json', + RegionPath+'evtPhase2.json', + RegionPath+'evtPhase3.json', + RegionPath+'evtPhase4.json', + RegionPath+'evtPhase5.json'] + +# Sequence which the processors will run. +p.sequence = [recoana] + +p.input_files = infile +p.output_files = [outfile] + +p.printProcess() diff --git a/processors/include/SvtTimingProcessor.h b/processors/include/SvtTimingProcessor.h new file mode 100644 index 000000000..933a2ffb2 --- /dev/null +++ b/processors/include/SvtTimingProcessor.h @@ -0,0 +1,82 @@ +#ifndef __SVTTIMING_ANAPROCESSOR_H__ +#define __SVTTIMING_ANAPROCESSOR_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_; + //TODO Change this to be held from HPSEvent + TTree* tree_; + TBranch* brawHits_{nullptr}; + TBranch* btrkrHits_{nullptr}; + TBranch* btracks_{nullptr}; + TBranch* becalHits_{nullptr}; + TBranch* becalClusters_{nullptr}; + TBranch* bevth_{nullptr}; + + std::vector * rawHits_{}; + std::vector * trkrHits_{}; + std::vector * tracks_{}; + 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 ecalHitColl_{"EcalCalHits"}; + std::string ecalClusColl_{"EcalClustersCorr"}; + 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; + //Debug Level + int debug_{0}; + +}; + + +#endif diff --git a/processors/src/SvtTimingProcessor.cxx b/processors/src/SvtTimingProcessor.cxx new file mode 100644 index 000000000..0a3d14e73 --- /dev/null +++ b/processors/src/SvtTimingProcessor.cxx @@ -0,0 +1,112 @@ +/** + * @file SvtTimingProcessor.cxx + * @brief AnaProcessor used fill histograms to compare simulations + * @author Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "SvtTimingProcessor.h" +#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"); + // ecalHitColl_ = parameters.getString("ecalHitColl"); + //ecalClusColl_ = parameters.getString("ecalClusColl"); + histCfgFilename_ = parameters.getString("histCfg"); + selectionCfg_ = parameters.getString("selectionjson",selectionCfg_); + regionSelections_ = parameters.getVString("regionDefinitions",regionSelections_); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + +void SvtTimingProcessor::initialize(TTree* tree) { + tree_= tree; + // 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("EventHeader" , &evth_ , &bevth_ ); + //tree_->SetBranchAddress(ecalHitColl_.c_str() , &ecalHits_ , &becalHits_ ); + //tree_->SetBranchAddress(ecalClusColl_.c_str() , &ecalClusters_, &becalClusters_); + +} + +bool SvtTimingProcessor::process(IEvent* ievent) { + double weight=1.0; + float modTime=(evth_->getEventTime()%24)/4.; + // std::cout<<"event phase = "<FillRawHits(rawHits_); + histos->FillTrackerHits(trkrHits_); + histos->FillTracks(tracks_); + + for (auto region : _regions ) { + // std::cout<<"pass cut? "<<_reg_phase_selectors[region]->passCutEq("modTime_eq",modTime,weight)<passCutEq("modTime_eq",modTime,weight)) + continue; + + _reg_phase_histos[region]->FillRawHits(rawHits_); + _reg_phase_histos[region]->FillTrackerHits(trkrHits_); + _reg_phase_histos[region]->FillTracks(tracks_); + + } + + //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); From d5cee9ba9f54715bd5f68aa040534ea8b054d7a4 Mon Sep 17 00:00:00 2001 From: Graham Date: Thu, 2 Feb 2023 15:17:40 -0800 Subject: [PATCH 2/5] a few last changes --- analysis/include/SvtTimingHistos.h | 2 + analysis/plotconfigs/reco/layersRecoHit.json | 35 +++- analysis/selections/evtPhase0.json | 7 - analysis/selections/evtPhase1.json | 7 - analysis/selections/evtPhase2.json | 7 - analysis/selections/evtPhase3.json | 7 - analysis/selections/evtPhase4.json | 7 - analysis/selections/evtPhase5.json | 7 - analysis/src/SvtTimingHistos.cxx | 178 +++++++++++++++---- processing/src/ConfigurePython.cxx | 1 + processing/src/Processor.cxx | 1 + processors/config/anaSvtTiming_cfg.py | 13 +- processors/include/SvtTimingProcessor.h | 9 +- processors/src/SvtTimingProcessor.cxx | 76 ++++++-- 14 files changed, 251 insertions(+), 106 deletions(-) delete mode 100644 analysis/selections/evtPhase0.json delete mode 100644 analysis/selections/evtPhase1.json delete mode 100644 analysis/selections/evtPhase2.json delete mode 100644 analysis/selections/evtPhase3.json delete mode 100644 analysis/selections/evtPhase4.json delete mode 100644 analysis/selections/evtPhase5.json diff --git a/analysis/include/SvtTimingHistos.h b/analysis/include/SvtTimingHistos.h index 30cea2756..0fa510da3 100644 --- a/analysis/include/SvtTimingHistos.h +++ b/analysis/include/SvtTimingHistos.h @@ -11,6 +11,7 @@ #include "ModuleMapper.h" #include #include +#include class SvtTimingHistos : public HistoManager { @@ -26,6 +27,7 @@ class SvtTimingHistos : public HistoManager { 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, float weight =1. ); void FillEcalHits(std::vector *ecalHits, float weight = 1.); void FillEcalClusters(std::vector *ecalClusters, float weight = 1.); diff --git a/analysis/plotconfigs/reco/layersRecoHit.json b/analysis/plotconfigs/reco/layersRecoHit.json index c46af6164..32baf695b 100644 --- a/analysis/plotconfigs/reco/layersRecoHit.json +++ b/analysis/plotconfigs/reco/layersRecoHit.json @@ -56,6 +56,26 @@ "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, @@ -84,6 +104,13 @@ "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, @@ -92,13 +119,7 @@ "xtitle" : "Number of Hits on Track", "ytitle" : "Tracks" }, - "trkChiSq_h" : { - "bins" : 100, - "minX" : 0, - "maxX" : 100, - "xtitle" : "Track ChiSq", - "ytitle" : "Tracks" - }, + "trkTime_h" : { "bins" : 100, "minX" : -50, diff --git a/analysis/selections/evtPhase0.json b/analysis/selections/evtPhase0.json deleted file mode 100644 index 6de0e3a2d..000000000 --- a/analysis/selections/evtPhase0.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 0, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/selections/evtPhase1.json b/analysis/selections/evtPhase1.json deleted file mode 100644 index e51a92a8e..000000000 --- a/analysis/selections/evtPhase1.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 1, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/selections/evtPhase2.json b/analysis/selections/evtPhase2.json deleted file mode 100644 index ac1489653..000000000 --- a/analysis/selections/evtPhase2.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 2, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/selections/evtPhase3.json b/analysis/selections/evtPhase3.json deleted file mode 100644 index 170cbbc50..000000000 --- a/analysis/selections/evtPhase3.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 3, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/selections/evtPhase4.json b/analysis/selections/evtPhase4.json deleted file mode 100644 index 8a5d535d5..000000000 --- a/analysis/selections/evtPhase4.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 4, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/selections/evtPhase5.json b/analysis/selections/evtPhase5.json deleted file mode 100644 index 16f26ade7..000000000 --- a/analysis/selections/evtPhase5.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "modTime_eq" : { - "cut" : 5, - "id" : 0, - "info" : "Phase 0" - } -} diff --git a/analysis/src/SvtTimingHistos.cxx b/analysis/src/SvtTimingHistos.cxx index 268bc36d3..8fd586cb9 100644 --- a/analysis/src/SvtTimingHistos.cxx +++ b/analysis/src/SvtTimingHistos.cxx @@ -62,7 +62,7 @@ void SvtTimingHistos::FillTrackerHits(std::vector *trkrHits, float for (int i=0; i < nHits; i++) { TrackerHit *hit = trkrHits->at(i); - RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits()->At(0); + 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; @@ -82,7 +82,7 @@ void SvtTimingHistos::FillTrackerHits(std::vector *trkrHits, float for (int i=0; i < nHits; i++) { TrackerHit *hit = trkrHits->at(i); - RawSvtHit *rhit = (RawSvtHit*)hit->getRawHits()->At(0); + 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); @@ -95,50 +95,152 @@ void SvtTimingHistos::FillTrackerHits(std::vector *trkrHits, float void SvtTimingHistos::FillTracks(std::vector *tracks, float weight ) { int nTracks = tracks->size(); Fill1DHisto("numTracks_h", (float)nTracks, weight); - int fitNumber=0; - std::string refModString="ly11_m0"; //"L5T_axial_ele" - + 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); - auto trkHits=trk->getSvtHits(); - float refTime=-666.; - bool hasRefHit=false; - for (int i=0; i < nHitsOnTrack; i++) - { - 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; - if (swName==refModString){ - hasRefHit=true; - refTime=hit->getTime(); - } - - std::string sensorName= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); - Fill1DHisto(sensorName+"_trkSiCluster_Time_h", hit->getTime(), weight); - Fill1DHisto(sensorName+"_trkRawHit_Time_h", rhit->getT0(fitNumber), weight); - - } + } +} + +void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map *timingCalib, int phase, 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){ + // 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 trkP=(float)trk->getP(); + float refTime=-666.; + bool hasRefHit=false; + auto trkHits=trk->getSvtHits(); + Fill1DHisto("trkChiSq_h",(float)trk->getChi2(),weight); + Fill1DHisto("trkTime_h",(float)trk->getTrackTime(),weight); + if(trk->isTopTrack()){ + Fill1DHisto("trkTime_Top_h",(float)trk->getTrackTime(),weight); + } else { + Fill1DHisto("trkTime_Bot_h",(float)trk->getTrackTime(),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",(float)trk->getTrackTime(),weight); + if(trk->isTopTrack()){ + Fill1DHisto(chStr+"_trkTime_Top_h",(float)trk->getTrackTime(),weight); + } else { + Fill1DHisto(chStr+"_trkTime_Bot_h",(float)trk->getTrackTime(),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){ + calibForLayer=timingCalib->at(calibName); + // std::cout<getTime()+calibForLayer, weight); + Fill1DHisto(sensorName+"_trkRawHit_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_Time_h", hit->getTime()+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + + if(rhit->getFitN()==2){ + Fill1DHisto(sensorName+"_trkSiCluster_2Fits_Time_h", hit->getTime()+calibForLayer, weight); + Fill1DHisto(sensorName+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_2Fits_Time_h", hit->getTime()+calibForLayer, weight); + Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + } - // if track doesn't have a hit in reference layer, just return - if(!hasRefHit) - continue; - for (int i=0; i < nHitsOnTrack; i++) - { - 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::cout<getTime(), weight); - } } + trkTimeCorr=trkTimeCorr/nHitsOnTrack; + Fill1DHisto("CalibratedTrackTime_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_h", trkTimeCorr, weight); + if(trk->isTopTrack()){ + Fill1DHisto("CalibratedTrackTime_Top_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Top_h", trkTimeCorr, weight); + }else { + Fill1DHisto("CalibratedTrackTime_Bot_h", trkTimeCorr, weight); + Fill1DHisto(chStr+"_CalibratedTrackTime_Bot_h", 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, weight); + Fill2DHisto(sensorName+"_trkSiCluster_M3L0_Minus_LX_Time_Versus_Chi2_hh", refTime-hit->getTime()-calibForLayer, (float)trk->getChi2(), 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 ) { diff --git a/processing/src/ConfigurePython.cxx b/processing/src/ConfigurePython.cxx index 67dd17a04..954572c2d 100644 --- a/processing/src/ConfigurePython.cxx +++ b/processing/src/ConfigurePython.cxx @@ -307,6 +307,7 @@ Process* ConfigurePython::makeProcess() { for (auto proc : sequence_) { Processor* ep = ProcessorFactory::instance().createProcessor(proc.classname_, proc.instancename_, *p); if (ep == 0) { + std::cout<<"classname = "<configure(proc.params_); diff --git a/processing/src/Processor.cxx b/processing/src/Processor.cxx index e48577374..63697cbf5 100644 --- a/processing/src/Processor.cxx +++ b/processing/src/Processor.cxx @@ -12,5 +12,6 @@ Processor::Processor(const std::string& name, Process& process) : } void Processor::declare(const std::string& classname, ProcessorMaker* maker) { + std::cout<<"Registering "< evtSelector_; std::string selectionCfg_; @@ -73,9 +74,13 @@ class SvtTimingProcessor : public Processor { std::vector _regions; typedef std::map >::iterator reg_it; + + std::map timingCalibConstants_; //Debug Level int debug_{0}; + + }; diff --git a/processors/src/SvtTimingProcessor.cxx b/processors/src/SvtTimingProcessor.cxx index 0a3d14e73..919ffa98b 100644 --- a/processors/src/SvtTimingProcessor.cxx +++ b/processors/src/SvtTimingProcessor.cxx @@ -1,10 +1,11 @@ /** * @file SvtTimingProcessor.cxx - * @brief AnaProcessor used fill histograms to compare simulations - * @author Cameron Bravo, SLAC National Accelerator Laboratory + * @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(){} @@ -14,7 +15,7 @@ SvtTimingProcessor::SvtTimingProcessor(const std::string& name, Process& process } void SvtTimingProcessor::configure(const ParameterSet& parameters) { - std::cout << "Configuring SvtTimingProcessor" << std::endl; + std::cout << "Configuring SvtTimingProcessor" << std::endl; try { debug_ = parameters.getInteger("debug"); @@ -27,6 +28,7 @@ void SvtTimingProcessor::configure(const ParameterSet& parameters) { histCfgFilename_ = parameters.getString("histCfg"); selectionCfg_ = parameters.getString("selectionjson",selectionCfg_); regionSelections_ = parameters.getVString("regionDefinitions",regionSelections_); + timingCalibFile_ = parameters.getString("timingCalibFile"); } catch (std::runtime_error& error) { @@ -44,7 +46,7 @@ void SvtTimingProcessor::initialize(TTree* tree) { if (!selectionCfg_.empty()) { evtSelector_ = std::make_shared(name_+"_evtSelector",selectionCfg_); evtSelector_->setDebug(debug_); - evtSelector_->LoadSelection(); + evtSelector_->LoadSelection(); } for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { @@ -67,26 +69,73 @@ void SvtTimingProcessor::initialize(TTree* tree) { tree_->SetBranchAddress("EventHeader" , &evth_ , &bevth_ ); //tree_->SetBranchAddress(ecalHitColl_.c_str() , &ecalHits_ , &becalHits_ ); //tree_->SetBranchAddress(ecalClusColl_.c_str() , &ecalClusters_, &becalClusters_); - + + std::ifstream calibFile(timingCalibFile_); + std::string sensorName; + double calibMean; + if(calibFile.is_open()){ + while(calibFile.good()){ + calibFile>>sensorName>>calibMean; + std::cout<<"name = "<getEventTime()%24)/4.; + int phase=int(modTime); // std::cout<<"event phase = "<FillRawHits(rawHits_); - histos->FillTrackerHits(trkrHits_); - histos->FillTracks(tracks_); + // histos->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); + } + for (auto region : _regions ) { - // std::cout<<"pass cut? "<<_reg_phase_selectors[region]->passCutEq("modTime_eq",modTime,weight)<passCutEq("modTime_eq",modTime,weight)) continue; - - _reg_phase_histos[region]->FillRawHits(rawHits_); - _reg_phase_histos[region]->FillTrackerHits(trkrHits_); - _reg_phase_histos[region]->FillTracks(tracks_); + + // _reg_phase_histos[region]->FillRawHits(rawHits_); + // _reg_phase_histos[region]->FillTrackerHits(trkrHits_); + + 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; + /* + 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, weight); + } } @@ -108,5 +157,4 @@ void SvtTimingProcessor::finalize() { } } - DECLARE_PROCESSOR(SvtTimingProcessor); From 02ac6a2e74c0ff209f4ca1d33fb255dd881d76bc Mon Sep 17 00:00:00 2001 From: mgraham Date: Wed, 21 Jun 2023 13:54:30 -0700 Subject: [PATCH 3/5] add run option to baseconfig and use run-by-run constants --- processors/config/anaSvtTiming_cfg.py | 10 ++- processors/config/baseConfig.py | 18 ++--- processors/include/SvtTimingProcessor.h | 10 ++- processors/src/SvtTimingProcessor.cxx | 87 ++++++++++++++++++------- 4 files changed, 89 insertions(+), 36 deletions(-) diff --git a/processors/config/anaSvtTiming_cfg.py b/processors/config/anaSvtTiming_cfg.py index f10fe1306..65132c170 100644 --- a/processors/config/anaSvtTiming_cfg.py +++ b/processors/config/anaSvtTiming_cfg.py @@ -38,13 +38,19 @@ #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.json' +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/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', diff --git a/processors/config/baseConfig.py b/processors/config/baseConfig.py index 92264b7f3..8bdfca7ca 100644 --- a/processors/config/baseConfig.py +++ b/processors/config/baseConfig.py @@ -7,22 +7,22 @@ #parser.add_option("-i", "--inFile", type="string", dest="inFilename", # help="Input filename.", metavar="inFilename", default="") parser.add_argument('--outDir', '-d', type=str, dest="outDir", action='store', - help="Specify the output directory.", metavar="outDir", default=".") + help="Specify the output directory.", metavar="outDir", default=".") parser.add_argument("-o", "--outFile", type=str, dest="outFilename", action='store', - help="Output filename.", metavar="outFilename", default="out.root") + help="Output filename.", metavar="outFilename", default="out.root") parser.add_argument("-t", "--isData", type=int, dest="isData", - help="Type of lcio ntuple: 1=data, 0=MC", metavar="isData", default=-1) + help="Type of lcio ntuple: 1=data, 0=MC", metavar="isData", default=-1) parser.add_argument("-y", "--year", type=int, dest="year", - help="Select year of the data", metavar="year", default=2019) + help="Select year of the data", metavar="year", default=2019) parser.add_argument("-n", "--nevents", type=int, dest="nevents", - help="Number of events to process", metavar="nevents",default=-1) + help="Number of events to process", metavar="nevents", default=-1) parser.add_argument("-sk", "--skip", type=int, dest="skip_events", - help="What event would you like to run on first", metavar="skip_events",default=0) + help="What event would you like to run on first", metavar="skip_events", default=0) parser.add_argument("-a", "--analysis", type=str, dest="analysis", - help="Which analysis is being run ", metavar="analysis",default="vertex") -parser.add_argument('--infile','-i', type=str, dest="inFilename", metavar='infiles', nargs="+", + 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 index 1adcc01b5..96cce9a7c 100644 --- a/processors/include/SvtTimingProcessor.h +++ b/processors/include/SvtTimingProcessor.h @@ -42,11 +42,13 @@ class SvtTimingProcessor : public Processor { //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}; @@ -54,6 +56,7 @@ class SvtTimingProcessor : public Processor { std::vector * rawHits_{}; std::vector * trkrHits_{}; std::vector * tracks_{}; + std::vector * fsps_{}; std::vector * ecalHits_{}; std::vector * ecalClusters_{}; EventHeader* evth_{nullptr}; @@ -62,9 +65,12 @@ class SvtTimingProcessor : public Processor { 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 timingCalibFile_{"timingCalibFile"}; + std::string timingCalibDir_{"timingCalibDir"}; + std::string postfixTiming_{"postfixTiming"}; + std::shared_ptr evtSelector_; std::string selectionCfg_; @@ -74,7 +80,7 @@ class SvtTimingProcessor : public Processor { std::vector _regions; typedef std::map >::iterator reg_it; - + std::shared_ptr _ah; std::map timingCalibConstants_; //Debug Level int debug_{0}; diff --git a/processors/src/SvtTimingProcessor.cxx b/processors/src/SvtTimingProcessor.cxx index 919ffa98b..b89baebd5 100644 --- a/processors/src/SvtTimingProcessor.cxx +++ b/processors/src/SvtTimingProcessor.cxx @@ -23,12 +23,15 @@ void SvtTimingProcessor::configure(const ParameterSet& parameters) { 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_); - timingCalibFile_ = parameters.getString("timingCalibFile"); + timingCalibDir_ = parameters.getString("timingCalibDir"); + postfixTiming_ = parameters.getString("postfixTiming"); + runNumber_=parameters.getInteger("runNumber"); } catch (std::runtime_error& error) { @@ -39,6 +42,7 @@ void SvtTimingProcessor::configure(const ParameterSet& parameters) { void SvtTimingProcessor::initialize(TTree* tree) { tree_= tree; + _ah = std::make_shared(); // init histos histos = new SvtTimingHistos(anaName_.c_str(),mmapper_); histos->loadHistoConfig(histCfgFilename_); @@ -66,14 +70,18 @@ void SvtTimingProcessor::initialize(TTree* tree) { 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); - // std::cout<<"event phase = "<passCutGt("trkP_gt",trkP,weight)) - continue; - histos->FillHitsOnTrack(trk,&timingCalibConstants_, phase,weight); - } + // 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; - // _reg_phase_histos[region]->FillRawHits(rawHits_); - // _reg_phase_histos[region]->FillTrackerHits(trkrHits_); - - for (int i=0;iat(i); - int nHitsOnTrack=trk->getTrackerHitCount(); - float trkP=(float)trk->getP(); + 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)) @@ -134,7 +175,7 @@ bool SvtTimingProcessor::process(IEvent* ievent) { continue; //std::cout<<"region = "<FillHitsOnTrack(trk,weight); - _reg_phase_histos[region]->FillHitsOnTrack(trk, &timingCalibConstants_, phase, weight); + _reg_phase_histos[region]->FillHitsOnTrack(&trk, &timingCalibConstants_, phase, &cluster, weight); } } From 0748bf001bfd3502b02fbc492c16f3c0cbef6dab Mon Sep 17 00:00:00 2001 From: Graham Date: Wed, 21 Jun 2023 14:08:43 -0700 Subject: [PATCH 4/5] add changes to histos --- analysis/include/SvtTimingHistos.h | 3 +- analysis/src/SvtTimingHistos.cxx | 125 +++++++++++++++++++++++------ 2 files changed, 102 insertions(+), 26 deletions(-) diff --git a/analysis/include/SvtTimingHistos.h b/analysis/include/SvtTimingHistos.h index 0fa510da3..c65214d52 100644 --- a/analysis/include/SvtTimingHistos.h +++ b/analysis/include/SvtTimingHistos.h @@ -27,13 +27,14 @@ class SvtTimingHistos : public HistoManager { 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, 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/src/SvtTimingHistos.cxx b/analysis/src/SvtTimingHistos.cxx index 8fd586cb9..9d52a517d 100644 --- a/analysis/src/SvtTimingHistos.cxx +++ b/analysis/src/SvtTimingHistos.cxx @@ -107,7 +107,7 @@ void SvtTimingHistos::FillTracks(std::vector *tracks, float weight ) { } } -void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map *timingCalib, int phase, float weight){ +void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map *timingCalib, int phase, CalCluster *cluster, float weight){ int fitNumber=0; int secondFit=1; @@ -118,9 +118,12 @@ void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map * bool useCalibration=true; if(timingCalib->size()<1){ - // std::cout<<"Calibration Map is not there...no calib"<getTrackerHitCount(); int trkCh=trk->getCharge(); std::string chStr="electron"; @@ -129,27 +132,55 @@ void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map * //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",(float)trk->getTrackTime(),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",(float)trk->getTrackTime(),weight); + 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",(float)trk->getTrackTime(),weight); + 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",(float)trk->getTrackTime(),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",(float)trk->getTrackTime(),weight); + 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",(float)trk->getTrackTime(),weight); + 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); @@ -166,40 +197,81 @@ void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map * std::string phSt=std::to_string(phase); std::string calibName=sensorName+"_phase"+phSt; if(useCalibration){ - calibForLayer=timingCalib->at(calibName); - // std::cout<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_h", hit->getTime()+calibForLayer, weight); - Fill1DHisto(sensorName+"_trkRawHit_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); - Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_Time_h", hit->getTime()+calibForLayer, weight); - Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_Time_h", rhit->getT0(fitNumber)+calibForLayer, 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", hit->getTime()+calibForLayer, weight); - Fill1DHisto(sensorName+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); - Fill1DHisto(sensorName+"_"+chStr+"_trkSiCluster_2Fits_Time_h", hit->getTime()+calibForLayer, weight); - Fill1DHisto(sensorName+"_"+chStr+"_trkRawHit_2Fits_Time_h", rhit->getT0(fitNumber)+calibForLayer, weight); + //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); @@ -212,6 +284,7 @@ void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map * 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; @@ -228,19 +301,21 @@ void SvtTimingHistos::FillHitsOnTrack(Track* trk, std::map * } else { //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_Minus_LX_Time_Versus_Chi2_hh", refTime-hit->getTime()-calibForLayer, (float)trk->getChi2(), 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_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); + //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 ) { From 129188cb33bfbc91447a2089e6c87cee75863a39 Mon Sep 17 00:00:00 2001 From: Graham Date: Wed, 21 Jun 2023 15:21:22 -0700 Subject: [PATCH 5/5] revert a couple of classes that I put print statements in --- processing/src/ConfigurePython.cxx | 1 - processing/src/Processor.cxx | 1 - 2 files changed, 2 deletions(-) diff --git a/processing/src/ConfigurePython.cxx b/processing/src/ConfigurePython.cxx index 954572c2d..67dd17a04 100644 --- a/processing/src/ConfigurePython.cxx +++ b/processing/src/ConfigurePython.cxx @@ -307,7 +307,6 @@ Process* ConfigurePython::makeProcess() { for (auto proc : sequence_) { Processor* ep = ProcessorFactory::instance().createProcessor(proc.classname_, proc.instancename_, *p); if (ep == 0) { - std::cout<<"classname = "<configure(proc.params_); diff --git a/processing/src/Processor.cxx b/processing/src/Processor.cxx index 63697cbf5..e48577374 100644 --- a/processing/src/Processor.cxx +++ b/processing/src/Processor.cxx @@ -12,6 +12,5 @@ Processor::Processor(const std::string& name, Process& process) : } void Processor::declare(const std::string& classname, ProcessorMaker* maker) { - std::cout<<"Registering "<