13 #include <ecl/modules/eclBhabhaTCollector/ECLBhabhaTCollectorModule.h>
14 #include <framework/dataobjects/EventMetaData.h>
15 #include <framework/gearbox/Const.h>
16 #include <ecl/dbobjects/ECLCrystalCalib.h>
17 #include <ecl/dataobjects/ECLDigit.h>
18 #include <ecl/dataobjects/ECLCalDigit.h>
19 #include <mdst/dataobjects/ECLCluster.h>
20 #include <mdst/dataobjects/Track.h>
21 #include <mdst/dataobjects/HitPatternCDC.h>
22 #include <tracking/dataobjects/RecoTrack.h>
23 #include <ecl/digitization/EclConfiguration.h>
24 #include <analysis/utility/PCmsLabTransform.h>
25 #include <analysis/ClusterUtility/ClusterUtils.h>
26 #include <boost/optional.hpp>
27 #include <ecl/geometry/ECLGeometryPar.h>
47 m_ElectronicsDB("ECLCrystalElectronics"),
48 m_ElectronicsTimeDB("ECLCrystalElectronicsTime"),
49 m_FlightTimeDB("ECLCrystalFlightTime"),
50 m_PreviousCrystalTimeDB("ECLCrystalTimeOffset"),
51 m_CrateTimeDB("ECLCrateTimeOffset"),
52 m_dbgTree_electrons(0),
55 setDescription(
"This module generates sum of all event times per crystal");
57 addParam(
"timeAbsMax", m_timeAbsMax,
58 "Events with abs(getTimeFit) > m_timeAbsMax "
59 "are excluded", (
short)80);
61 addParam(
"minCrystal", m_minCrystal,
62 "First CellId to handle.", 1);
63 addParam(
"maxCrystal", m_maxCrystal,
64 "Last CellId to handle.", 8736);
66 addParam(
"saveTree", m_saveTree,
67 "If true, TTree 'tree' with more detailed event info is saved in "
68 "the output file specified by HistoManager",
71 addParam(
"looseTrkZ0", m_looseTrkZ0,
"max Z0 for loose tracks (cm)", 10.);
72 addParam(
"tightTrkZ0", m_tightTrkZ0,
"max Z0 for tight tracks (cm)", 2.);
73 addParam(
"looseTrkD0", m_looseTrkD0,
"max D0 for loose tracks (cm)", 2.);
74 addParam(
"tightTrkD0", m_tightTrkD0,
"max D0 for tight tracks (cm)", 0.5);
78 setPropertyFlags(c_ParallelProcessingCertified);
90 m_dbgTree_electrons =
new TTree(
"tree_electrons",
"Debug data for bhabha time calibration - one entry per electron");
91 m_dbgTree_electrons->Branch(
"EventNum", &m_tree_evtNum)->SetTitle(
"Event number");
92 m_dbgTree_electrons->Branch(
"CrystalCellID", &m_tree_cid)->SetTitle(
"Cell ID, 1..8736");
93 m_dbgTree_electrons->Branch(
"ADCamplitude", &m_tree_amp)->SetTitle(
"Amplitude, ADC units");
94 m_dbgTree_electrons->Branch(
"maxEcrystalEnergy", &m_tree_en)->SetTitle(
"Max Energy Crystal Energy, GeV");
95 m_dbgTree_electrons->Branch(
"maxEcrystalEnergyDIVclusterE",
96 &m_tree_E1Etot)->SetTitle(
"Max Energy Crystal Fraction Energy of Cluster");
97 m_dbgTree_electrons->Branch(
"E1divE2crystal",
98 &m_tree_E1E2)->SetTitle(
"Max Energy Crystal DIV second max energy crystal in cluster");
99 m_dbgTree_electrons->Branch(
"E1crystal_DIV_p", &m_tree_E1p)->SetTitle(
"Max Energy Crystal in cluster DIV track p");
100 m_dbgTree_electrons->Branch(
"timetsPreviousTimeCalibs",
101 &m_tree_timetsPreviousTimeCalibs)->SetTitle(
"Time t_psi after application of previous Ts, ns");
102 m_dbgTree_electrons->Branch(
"E_DIV_p", &m_E_DIV_p)->SetTitle(
"E DIV p");
103 m_dbgTree_electrons->Branch(
"timeF", &m_tree_timeF)->SetTitle(
"Time F, ns");
104 m_dbgTree_electrons->Branch(
"time_t_psi", &m_tree_time)->SetTitle(
"Time t_psi for Ts, ns");
105 m_dbgTree_electrons->Branch(
"quality", &m_tree_quality)->SetTitle(
"ECL FPGA fit quality, see Confluence article");
106 m_dbgTree_electrons->Branch(
"t0", &m_tree_t0)->SetTitle(
"T0, ns");
107 m_dbgTree_electrons->Branch(
"t0_unc", &m_tree_t0_unc)->SetTitle(
"T0 uncertainty, ns");
108 m_dbgTree_electrons->Branch(
"CrateID", &m_crystalCrate)->SetTitle(
"Crate id for crystal");
109 m_dbgTree_electrons->Branch(
"runNum", &m_runNum)->SetTitle(
"Run number");
111 m_dbgTree_electrons->SetAutoSave(10);
115 m_dbgTree_tracks =
new TTree(
"tree_tracks",
"Debug data for bhabha time calibration - one entry per track");
116 m_dbgTree_tracks->Branch(
"d0", &m_tree_d0)->SetTitle(
"d0, cm");
117 m_dbgTree_tracks->Branch(
"z0", &m_tree_z0)->SetTitle(
"z0, cm");
118 m_dbgTree_tracks->Branch(
"p", &m_tree_p)->SetTitle(
"track momentum, GeV");
119 m_dbgTree_tracks->Branch(
"charge", &m_charge)->SetTitle(
"track electric charge");
120 m_dbgTree_tracks->Branch(
"Num_CDC_hits", &m_tree_nCDChits)->SetTitle(
"Num CDC hits");
122 m_dbgTree_tracks->SetAutoSave(10);
125 m_dbgTree_crystals =
new TTree(
"tree_crystals",
126 "Debug data for bhabha time calibration - one entry per electron - one entry per crystal");
127 m_dbgTree_crystals->Branch(
"clustCrysE_DIV_maxEcrys",
128 &m_tree_clustCrysE_DIV_maxEcrys)->SetTitle(
"E of crystal i from cluster / E of max E crystal");
129 m_dbgTree_crystals->Branch(
"Crystal_E", &m_tree_clustCrysE) ->SetTitle(
"E of crystal i from cluster");
130 m_dbgTree_crystals->Branch(
"time_t_psi", &m_tree_time)->SetTitle(
"Time for Ts, ns");
131 m_dbgTree_crystals->Branch(
"Crystal_cell_ID", &m_tree_cid)->SetTitle(
"Cell ID, 1..8736");
132 m_dbgTree_crystals->Branch(
"quality", &m_tree_quality)->SetTitle(
"ECL FPGA fit quality, see Confluence article");
134 m_dbgTree_crystals->SetAutoSave(10);
138 m_dbgTree_event =
new TTree(
"tree_event",
"Debug data for bhabha time calibration - one entry per event");
139 m_dbgTree_event->Branch(
"massInvTracks", &m_massInvTracks)->SetTitle(
"Invariant mass of the two tracks");
141 m_dbgTree_event->SetAutoSave(10);
144 m_dbgTree_evt_allCuts =
new TTree(
"tree_evt_allCuts",
145 "Debug data for bhabha time calibration - one entry per event after all the cuts");
146 m_dbgTree_evt_allCuts->Branch(
"EclustPlus", &m_tree_enPlus)->SetTitle(
"Energy of cluster with +ve charge, GeV");
147 m_dbgTree_evt_allCuts->Branch(
"EclustNeg", &m_tree_enNeg)->SetTitle(
"Energy of cluster with -ve charge, GeV");
148 m_dbgTree_evt_allCuts->Branch(
"clustTimePos", &m_tree_tClustPos)->SetTitle(
"Cluster time of cluster with +ve charge, GeV");
149 m_dbgTree_evt_allCuts->Branch(
"clustTimeNeg", &m_tree_tClustNeg)->SetTitle(
"Cluster time of cluster with -ve charge, GeV");
150 m_dbgTree_evt_allCuts->Branch(
"maxEcrysTimePosClust",
151 &m_tree_maxEcrystPosClust)->SetTitle(
"Time of maximum energy crystal in cluster with +ve charge, GeV");
152 m_dbgTree_evt_allCuts->Branch(
"maxEcrysTimeNegClust",
153 &m_tree_maxEcrystNegClust)->SetTitle(
"Time of maximum energy crystal in cluster with -ve charge, GeV");
154 m_dbgTree_evt_allCuts->Branch(
"t0", &m_tree_t0)->SetTitle(
"T0, ns");
155 m_dbgTree_evt_allCuts->Branch(
"t0_ECL_closestCDC", &m_tree_t0_ECLclosestCDC)->SetTitle(
"T0 ECL closest to CDC t0, ns");
156 m_dbgTree_evt_allCuts->Branch(
"t0_ECL_minChi2", &m_tree_t0_ECL_minChi2)->SetTitle(
"T0 ECL with smallest chi squared, ns");
158 m_dbgTree_evt_allCuts->SetAutoSave(10);
162 m_dbgTree_crys_allCuts =
new TTree(
"m_dbgTree_crys_allCuts",
163 "Debug data for bhabha time calibration - one entry per crystal per cluster entry after all cuts");
165 m_dbgTree_crys_allCuts->Branch(
"runNum", &m_runNum)->SetTitle(
"Run number");
166 m_dbgTree_crys_allCuts->Branch(
"EventNum", &m_tree_evtNum)->SetTitle(
"Event number");
167 m_dbgTree_crys_allCuts->Branch(
"m_tree_ECLCalDigitTime",
168 &m_tree_ECLCalDigitTime)
169 ->SetTitle(
"Time of a crystal within the cluster after application of previous calibrations except t0, ns");
170 m_dbgTree_crys_allCuts->Branch(
"m_tree_ECLCalDigitE", &m_tree_ECLCalDigitE)->SetTitle(
"Energy of crystal, GeV");
171 m_dbgTree_crys_allCuts->Branch(
"m_tree_ECLDigitAmplitude",
172 &m_tree_ECLDigitAmplitude)->SetTitle(
"Amplitude of crystal signal pulse");
173 m_dbgTree_crys_allCuts->Branch(
"timetsPreviousTimeCalibs",
174 &m_tree_timetsPreviousTimeCalibs)->SetTitle(
"Time t_psi after application of previous Ts, ns");
175 m_dbgTree_crys_allCuts->Branch(
"t0", &m_tree_t0)->SetTitle(
"T0, ns");
176 m_dbgTree_crys_allCuts->Branch(
"t0_ECL_closestCDC", &m_tree_t0_ECLclosestCDC)->SetTitle(
"T0 ECL closest to CDC t0, ns");
177 m_dbgTree_crys_allCuts->Branch(
"t0_ECL_minChi2", &m_tree_t0_ECL_minChi2)->SetTitle(
"T0 ECL with smallest chi squared, ns");
178 m_dbgTree_crys_allCuts->Branch(
"CrystalCellID", &m_tree_cid)->SetTitle(
"Cell ID, 1..8736");
180 m_dbgTree_crys_allCuts->SetAutoSave(10);
188 m_dbgTree_allCuts =
new TTree(
"tree_allCuts",
189 "Debug data for bhabha time calibration - one entry per max E crystal entry after cuts");
191 m_dbgTree_allCuts->Branch(
"time_t_psi", &m_tree_time)->SetTitle(
"Time t_psi for Ts, ns");
192 m_dbgTree_allCuts->Branch(
"crateID", &m_crystalCrate)->SetTitle(
"Crate id for crystal");
193 m_dbgTree_allCuts->Branch(
"EventNum", &m_tree_evtNum)->SetTitle(
"Event number");
194 m_dbgTree_allCuts->Branch(
"runNum", &m_runNum)->SetTitle(
"Run number");
195 m_dbgTree_allCuts->Branch(
"CrystalCellID", &m_tree_cid)->SetTitle(
"Cell ID, 1..8736");
196 m_dbgTree_allCuts->Branch(
"maxEcrystalEnergy", &m_tree_en)->SetTitle(
"Max Energy Crystal Energy, GeV");
197 m_dbgTree_allCuts->Branch(
"maxEcrystalEnergyDIVclusterE",
198 &m_tree_E1Etot)->SetTitle(
"Max Energy Crystal Fraction Energy of Cluster");
199 m_dbgTree_allCuts->Branch(
"E1divE2crystal",
200 &m_tree_E1E2)->SetTitle(
"Max Energy Crystal DIV second max energy crystal in cluster");
201 m_dbgTree_allCuts->Branch(
"E1crystalDIVp", &m_tree_E1p)->SetTitle(
"Max Energy Crystal in cluster DIV track p");
202 m_dbgTree_allCuts->Branch(
"timetsPreviousTimeCalibs",
203 &m_tree_timetsPreviousTimeCalibs)->SetTitle(
"Time t_psi after application of previous Ts, ns");
204 m_dbgTree_allCuts->Branch(
"massInvTracks", &m_massInvTracks)->SetTitle(
"Invariant mass of the two tracks");
205 m_dbgTree_allCuts->Branch(
"t0", &m_tree_t0)->SetTitle(
"T0, ns");
206 m_dbgTree_allCuts->Branch(
"t0_ECL_closestCDC", &m_tree_t0_ECLclosestCDC)->SetTitle(
"T0 ECL closest to CDC t0, ns");
207 m_dbgTree_allCuts->Branch(
"t0_ECL_minChi2", &m_tree_t0_ECL_minChi2)->SetTitle(
"T0 ECL with smallest chi squared, ns");
209 m_dbgTree_allCuts->Branch(
"clusterTime", &m_tree_tClust)->SetTitle(
"Cluster time of cluster with +ve charge, GeV");
211 m_dbgTree_allCuts->SetAutoSave(10);
220 B2INFO(
"ECLBhabhaTCollector: Experiment = " << evtMetaData->getExperiment() <<
221 " run = " << evtMetaData->getRun());
226 int nbins = m_timeAbsMax * 8;
227 int max_t = m_timeAbsMax;
228 int min_t = -m_timeAbsMax;
231 auto TimevsCrysPrevCrateCalibPrevCrystCalib =
new TH2F(
"TimevsCrysPrevCrateCalibPrevCrystCalib",
232 "Time t psi - ts - tcrate (previous calibs) vs crystal ID;crystal ID;Time t_psi with previous calib (ns)",
233 8736, 0, 8736, nbins, min_t, max_t);
234 registerObject<TH2F>(
"TimevsCrysPrevCrateCalibPrevCrystCalib", TimevsCrysPrevCrateCalibPrevCrystCalib);
236 auto TimevsCratePrevCrateCalibPrevCrystCalib =
new TH2F(
"TimevsCratePrevCrateCalibPrevCrystCalib",
237 "Time t psi - ts - tcrate (previous calibs) vs crate ID;crate ID;Time t_psi previous calib (ns)",
238 52, 1, 53, nbins, min_t, max_t);
239 registerObject<TH2F>(
"TimevsCratePrevCrateCalibPrevCrystCalib", TimevsCratePrevCrateCalibPrevCrystCalib);
241 auto TimevsCrysNoCalibrations =
new TH2F(
"TimevsCrysNoCalibrations",
242 "Time tpsi vs crystal ID;crystal ID;Time t_psi (ns)", 8736, 0, 8736, nbins, min_t, max_t);
243 registerObject<TH2F>(
"TimevsCrysNoCalibrations", TimevsCrysNoCalibrations);
245 auto TimevsCrateNoCalibrations =
new TH2F(
"TimevsCrateNoCalibrations",
246 "Time tpsi vs crate ID;crate ID;Time t_psi (ns)", 52, 1, 53, nbins, min_t, max_t);
247 registerObject<TH2F>(
"TimevsCrateNoCalibrations", TimevsCrateNoCalibrations);
249 auto TimevsCrysPrevCrateCalibNoCrystCalib =
new TH2F(
"TimevsCrysPrevCrateCalibNoCrystCalib",
250 "Time tpsi - tcrate (previous calib) vs crystal ID;crystal ID;Time t_psi including previous crate calib (ns)",
251 8736, 0, 8736, nbins, min_t, max_t);
252 registerObject<TH2F>(
"TimevsCrysPrevCrateCalibNoCrystCalib", TimevsCrysPrevCrateCalibNoCrystCalib);
254 auto TimevsCrateNoCrateCalibPrevCrystCalib =
new TH2F(
"TimevsCrateNoCrateCalibPrevCrystCalib",
255 "Time tpsi - ts (previous calib) vs crate ID;crate ID;Time t_psi including previous crystal calib (ns)",
256 52, 1, 53, nbins, min_t, max_t);
257 registerObject<TH2F>(
"TimevsCrateNoCrateCalibPrevCrystCalib", TimevsCrateNoCrateCalibPrevCrystCalib);
260 auto TsDatabase =
new TH1F(
"TsDatabase",
";cell id;Ts from database", 8736, 0, 8736);
261 registerObject<TH1F>(
"TsDatabase", TsDatabase);
263 auto TsDatabaseUnc =
new TH1F(
"TsDatabaseUnc",
";cell id;Ts uncertainty from database", 8736, 0, 8736);
264 registerObject<TH1F>(
"TsDatabaseUnc", TsDatabaseUnc);
266 auto TcrateDatabase =
new TH1F(
"TcrateDatabase",
";cell id;Tcrate from database", 8736, 0, 8736);
267 registerObject<TH1F>(
"TcrateDatabase", TcrateDatabase);
269 auto TcrateUncDatabase =
new TH1F(
"TcrateUncDatabase",
";cell id;Tcrate uncertainty from database", 8736, 0, 8736);
270 registerObject<TH1F>(
"TcrateUncDatabase", TcrateUncDatabase);
273 auto tcrateDatabase_ns =
new TH1F(
"tcrateDatabase_ns",
";crate id;tcrate derived from database", 52, 0, 52);
274 registerObject<TH1F>(
"tcrateDatabase_ns", tcrateDatabase_ns);
277 auto databaseCounter =
new TH1F(
"databaseCounter",
278 ";A database was read in;Number of times database was saved to histogram", 1, 1, 2);
279 registerObject<TH1F>(
"databaseCounter", databaseCounter);
282 auto numCrystalEntriesPerEvent =
new TH1F(
"numCrystalEntriesPerEvent",
283 ";Number crystal entries;Number of events", 15, 0, 15);
284 registerObject<TH1F>(
"numCrystalEntriesPerEvent", numCrystalEntriesPerEvent);
286 auto cutflow =
new TH1F(
"cutflow",
";Cut label number;Number of events passing cut", 20, 0, 20);
287 registerObject<TH1F>(
"cutflow", cutflow);
289 auto numPhotonClustersPerTrack =
new TH1F(
"numPhotonClustersPerTrack",
290 ";Number of photon clusters per track;Number", 20, 0, 20);
291 registerObject<TH1F>(
"numPhotonClustersPerTrack", numPhotonClustersPerTrack);
293 auto maxEcrsytalEnergyFraction =
new TH1F(
"maxEcrsytalEnergyFraction",
294 ";Maximum energy crystal energy / (sum) cluster energy;Number", 22, 0, 1.1);
295 registerObject<TH1F>(
"maxEcrsytalEnergyFraction", maxEcrsytalEnergyFraction);
298 auto numEntriesPerCrystal =
new TH1F(
"numEntriesPerCrystal",
";cell id;Number", 8736, 0, 8736);
299 registerObject<TH1F>(
"numEntriesPerCrystal", numEntriesPerCrystal);
302 auto TimevsRunPrevCrateCalibPrevCrystCalibCID1338 =
new TH2F(
"TimevsRunPrevCrateCalibPrevCrystCalibCID1338",
303 "Time t psi - ts - tcrate (previous calibs) vs run number cid 1338;Run number;Time t_psi with previous calib (ns)",
304 7000, 1, 7000, nbins, min_t, max_t);
305 registerObject<TH2F>(
"TimevsRunPrevCrateCalibPrevCrystCalibCID1338", TimevsRunPrevCrateCalibPrevCrystCalibCID1338);
307 auto TimevsRunPrevCrateCalibPrevCrystCalibCrate8 =
new TH2F(
"TimevsRunPrevCrateCalibPrevCrystCalibCrate8",
308 "Time t psi - ts - tcrate (previous calibs) vs run number crate 8;Run number;Time t_psi with previous calib (ns)",
309 7000, 1, 7000, nbins, min_t, max_t);
310 registerObject<TH2F>(
"TimevsRunPrevCrateCalibPrevCrystCalibCrate8", TimevsRunPrevCrateCalibPrevCrystCalibCrate8);
316 m_eventT0.isRequired();
318 m_eclClusterArray.isRequired();
319 m_eclCalDigitArray.isRequired();
320 m_eclDigitArray.isRequired();
326 int cutIndexPassed = 0;
327 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
328 B2DEBUG(10,
"Cutflow: no cuts: index = " << cutIndexPassed);
340 if (m_ElectronicsDB.hasChanged()) {
341 m_Electronics = m_ElectronicsDB->getCalibVector();
343 if (m_ElectronicsTimeDB.hasChanged()) {
344 m_ElectronicsTime = m_ElectronicsTimeDB->getCalibVector();
346 if (m_FlightTimeDB.hasChanged()) {
347 m_FlightTime = m_FlightTimeDB->getCalibVector();
352 if (m_PreviousCrystalTimeDB.hasChanged()) {
353 m_PreviousCrystalTime = m_PreviousCrystalTimeDB->getCalibVector();
354 m_PreviousCrystalTimeUnc = m_PreviousCrystalTimeDB->getCalibUncVector();
357 B2DEBUG(35,
"Finished checking if previous crystal time payload has changed");
358 if (m_CrateTimeDB.hasChanged()) {
359 m_CrateTime = m_CrateTimeDB->getCalibVector();
360 m_CrateTimeUnc = m_CrateTimeDB->getCalibUncVector();
362 B2DEBUG(35,
"Finished checking if previous crate time payload has changed");
363 B2DEBUG(35,
"m_CrateTime size = " << m_CrateTime.size());
364 B2DEBUG(29,
"Crate time +- uncertainty [0]= " << m_CrateTime[0] <<
" +- " << m_CrateTimeUnc[0]);
365 B2DEBUG(29,
"Crate time +- uncertainty [8735]= " << m_CrateTime[8735] <<
" +- " << m_CrateTimeUnc[8735]);
374 vector<float> Crate_time_ns(52, 0.0);
377 for (
int crysID = 1; crysID <= 8736; crysID++) {
378 int crateID_temp = crystalMapper->
getCrateID(crysID);
379 Crate_time_ns[crateID_temp - 1] = m_CrateTime[crysID] * TICKS_TO_NS;
385 for (
int crysID = 0; crysID < 8736; crysID++) {
386 getObjectPtr<TH1F>(
"TsDatabase")->Fill(crysID + 0.001, m_PreviousCrystalTime[crysID]);
387 getObjectPtr<TH1F>(
"TsDatabaseUnc")->Fill(crysID + 0.001, m_PreviousCrystalTimeUnc[crysID]);
388 getObjectPtr<TH1F>(
"TcrateDatabase")->Fill(crysID + 0.001, m_CrateTime[crysID]);
389 getObjectPtr<TH1F>(
"TcrateUncDatabase")->Fill(crysID + 0.001, m_CrateTimeUnc[crysID]);
391 B2INFO(
"cid = " << crysID + 1 <<
", Ts previous = " << m_PreviousCrystalTime[crysID]);
394 for (
int crateID_temp = 1; crateID_temp <= 52; crateID_temp++) {
395 getObjectPtr<TH1F>(
"tcrateDatabase_ns")->Fill(crateID_temp + 0.001, Crate_time_ns[crateID_temp - 1]);
400 getObjectPtr<TH1F>(
"databaseCounter")->Fill(1.001, 1);
402 m_storeCalib =
false;
408 double evt_t0_unc = -1;
409 double evt_t0_ECL_closestCDC = -1;
410 double evt_t0_ECL_minChi2 = -1;
413 if (!m_eventT0.isValid()) {
416 }
else if (!m_eventT0->hasTemporaryEventT0(Const::EDetector::CDC)) {
422 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
423 B2DEBUG(10,
"Cutflow: Event t0 exists: index = " << cutIndexPassed);
428 vector<EventT0::EventT0Component> evt_t0_list = m_eventT0->getTemporaryEventT0s(Const::EDetector::CDC);
429 evt_t0 = evt_t0_list.back().eventT0;
430 evt_t0_unc = evt_t0_list.back().eventT0Uncertainty;
434 if (m_eventT0->hasTemporaryEventT0(Const::EDetector::ECL)) {
435 vector<EventT0::EventT0Component> evt_t0_list_ECL = m_eventT0->getTemporaryEventT0s(Const::EDetector::ECL);
438 double smallest_CDC_ECL_t0_diff = fabs(evt_t0_list_ECL[0].eventT0 - evt_t0);
439 int smallest_CDC_ECL_t0_diff_idx = 0;
440 for (
long unsigned int ECLi = 0; ECLi < evt_t0_list_ECL.size(); ECLi++) {
441 double tempt_ECL_t0 = evt_t0_list_ECL[ECLi].eventT0;
442 if (fabs(tempt_ECL_t0 - evt_t0) < smallest_CDC_ECL_t0_diff) {
443 smallest_CDC_ECL_t0_diff = fabs(tempt_ECL_t0 - evt_t0);
444 smallest_CDC_ECL_t0_diff_idx = ECLi;
448 evt_t0_ECL_closestCDC = evt_t0_list_ECL[smallest_CDC_ECL_t0_diff_idx].eventT0;
449 B2DEBUG(30,
"evt_t0_ECL_closestCDC = " << evt_t0_ECL_closestCDC);
453 double smallest_ECL_t0_minChi2 = evt_t0_list_ECL[0].quality;
454 int smallest_ECL_t0_minChi2_idx = 0;
456 B2DEBUG(30,
"evt_t0_list_ECL[0].quality = " << evt_t0_list_ECL[0].quality
457 <<
", with ECL event t0 = " << evt_t0_list_ECL[0].eventT0);
459 for (
long unsigned int ECLi = 0; ECLi < evt_t0_list_ECL.size(); ECLi++) {
460 B2DEBUG(30,
"evt_t0_list_ECL[" << ECLi <<
"].quality = " << evt_t0_list_ECL[ECLi].quality
461 <<
", with ECL event t0 = " <<
462 evt_t0_list_ECL[ECLi].eventT0);
463 if (evt_t0_list_ECL[ECLi].quality < smallest_ECL_t0_minChi2) {
464 smallest_ECL_t0_minChi2 = evt_t0_list_ECL[ECLi].quality;
465 smallest_ECL_t0_minChi2_idx = ECLi;
469 evt_t0_ECL_minChi2 = evt_t0_list_ECL[smallest_ECL_t0_minChi2_idx].eventT0;
471 B2DEBUG(30,
"evt_t0_ECL_minChi2 = " << evt_t0_ECL_minChi2);
472 B2DEBUG(30,
"smallest_ECL_t0_minChi2_idx = " << smallest_ECL_t0_minChi2_idx);
483 m_EperCrys.resize(8736);
484 m_eclCalDigitID.resize(8736);
485 m_eclDigitID.resize(8736);
489 for (
auto& eclCalDigit : m_eclCalDigitArray) {
490 int tempCrysID = eclCalDigit.getCellId() - 1;
491 m_EperCrys[tempCrysID] = eclCalDigit.getEnergy();
492 m_eclCalDigitID[tempCrysID] = idx;
497 for (
auto& eclDigit : m_eclDigitArray) {
498 int tempCrysID = eclDigit.getCellId() - 1;
499 m_eclDigitID[tempCrysID] = idx;
515 double maxp[2] = {0., 0.};
516 int maxiTrk[2] = { -1, -1};
517 int nTrkAll = tracks.getEntries();
525 for (
int iTrk = 0; iTrk < nTrkAll; iTrk++) {
528 if (not tempTrackFit) {
continue;}
531 short charge = tempTrackFit->getChargeSign();
532 double z0 = tempTrackFit->getZ0();
533 double d0 = tempTrackFit->getD0();
534 int nCDChits = tempTrackFit->getHitPatternCDC().getNHits();
535 double p = tempTrackFit->getMomentum().Mag();
543 m_tree_nCDChits = nCDChits;
546 m_dbgTree_tracks->Fill();
554 if (abs(d0) > m_looseTrkD0) {
557 if (abs(z0) > m_looseTrkZ0) {
577 if (abs(d0) > m_tightTrkD0) {
580 if (abs(z0) > m_tightTrkZ0) {
588 if (charge > 0) {icharge = 1;}
589 if (p > maxp[icharge]) {
591 maxiTrk[icharge] = iTrk;
600 if (nTrkTight != 2) {
605 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
606 B2DEBUG(10,
"Cutflow: Two tight tracks: index = " << cutIndexPassed);
609 if (nTrkLoose != 2) {
614 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
615 B2DEBUG(10,
"Cutflow: No additional loose tracks: index = " << cutIndexPassed);
621 bool oppositelyChargedTracksPassed = maxiTrk[0] != -1 && maxiTrk[1] != -1;
622 if (!oppositelyChargedTracksPassed) {
627 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
628 B2DEBUG(10,
"Cutflow: Oppositely charged tracks: index = " << cutIndexPassed);
637 double trkEClustLab[2] = {0., 0.};
638 double trkEClustCOM[2] = {0., 0.};
642 TLorentzVector trkp4Lab[2];
643 TLorentzVector trkp4COM[2];
646 int crysIDMax[2] = { -1, -1 };
647 double crysEMax[2] = { -1, -1 };
648 double crysE2Max[2] = { -1, -1 };
649 int numClustersPerTrack[2] = { 0, 0 };
651 double clusterTime[2] = {0, 0};
655 vector<double> time_ECLCaldigits_bothClusters;
656 vector<int> cid_ECLCaldigits_bothClusters;
657 vector<double> E_ECLCaldigits_bothClusters;
658 vector<double> amp_ECLDigits_bothClusters;
659 vector<int> chargeID_ECLCaldigits_bothClusters;
661 for (
int icharge = 0; icharge < 2; icharge++) {
662 if (maxiTrk[icharge] > -1) {
663 B2DEBUG(10,
"looping over the 2 max pt tracks");
667 trkp4COM[icharge] = boostrotate.
rotateLabToCms() * trkp4Lab[icharge];
668 trkpLab[icharge] = trkp4Lab[icharge].Rho();
669 trkpCOM[icharge] = trkp4COM[icharge].Rho();
675 auto eclClusterRelationsFromTracks = tracks[maxiTrk[icharge]]->getRelationsTo<
ECLCluster>();
676 for (
unsigned int clusterIdx = 0; clusterIdx < eclClusterRelationsFromTracks.size(); clusterIdx++) {
678 B2DEBUG(10,
"Looking at clusters. index = " << clusterIdx);
679 auto cluster = eclClusterRelationsFromTracks[clusterIdx];
680 bool goodClusterType =
false;
684 goodClusterType =
true;
685 numClustersPerTrack[icharge]++;
688 if (goodClusterType) {
690 clusterTime[icharge] = cluster->getTime();
692 auto eclClusterRelations = cluster->getRelationsTo<
ECLCalDigit>(
"ECLCalDigits");
695 for (
unsigned int ir = 0; ir < eclClusterRelations.size(); ir++) {
696 const auto calDigit = eclClusterRelations.object(ir);
697 int tempCrysID = calDigit->
getCellId() - 1;
698 double tempE = m_EperCrys[tempCrysID];
700 int eclDigitIndex = m_eclDigitID[tempCrysID];
701 ECLDigit* ecl_dig = m_eclDigitArray[eclDigitIndex];
704 if (tempE > crysEMax[icharge]) {
706 crysE2Max[icharge] = crysEMax[icharge];
708 crysEMax[icharge] = tempE;
709 crysIDMax[icharge] = tempCrysID;
712 if (tempE > crysE2Max[icharge] && tempCrysID != crysIDMax[icharge]) {
713 crysE2Max[icharge] = tempE;
717 B2DEBUG(30,
"calDigit(ir" << ir <<
") time = " << calDigit->getTime() <<
"ns , with E = " << tempE <<
" GeV");
718 time_ECLCaldigits_bothClusters.push_back(calDigit->getTime());
719 cid_ECLCaldigits_bothClusters.push_back(tempCrysID);
720 E_ECLCaldigits_bothClusters.push_back(tempE);
721 amp_ECLDigits_bothClusters.push_back(ecl_dig->
getAmp());
722 chargeID_ECLCaldigits_bothClusters.push_back(icharge);
727 trkEClustCOM[icharge] = trkEClustLab[icharge] * trkpCOM[icharge] / trkpLab[icharge];
730 getObjectPtr<TH1F>(
"numPhotonClustersPerTrack")->Fill(numClustersPerTrack[icharge]);
736 E_DIV_p[icharge] = trkEClustCOM[icharge] / trkpCOM[icharge];
750 int numCrystalsPassingCuts = 0;
752 int crystalIDs[2] = { -1, -1};
753 int crateIDs[2] = { -1, -1};
754 double ts_prevCalib[2] = { -1, -1};
755 double tcrate_prevCalib[2] = { -1, -1};
756 double times_noPreviousCalibrations[2] = { -1, -1};
757 bool crystalCutsPassed[2] = {
false,
false};
758 double crystalEnergies[2] = { -1, -1};
759 double crystalEnergies2[2] = { -1, -1};
761 for (
int iCharge = 0; iCharge < 2; iCharge++) {
762 int crystal_idx = crysIDMax[iCharge];
763 int eclCalDigitIndex = m_eclCalDigitID[crystal_idx];
764 int eclDigitIndex = m_eclDigitID[crystal_idx];
766 ECLDigit* ecl_dig = m_eclDigitArray[eclDigitIndex];
767 ECLCalDigit* ecl_cal = m_eclCalDigitArray[eclCalDigitIndex];
772 auto amplitude = ecl_dig->
getAmp();
773 crystalEnergies[iCharge] = en;
776 time = ecl_dig->
getTimeFit() * TICKS_TO_NS - evt_t0;
779 time -= m_ElectronicsTime[cid - 1] * TICKS_TO_NS;
780 time -= m_FlightTime[cid - 1];
785 double energyTimeShift = m_ECLTimeUtil->energyDependentTimeOffsetElectronic(amplitude * m_Electronics[cid - 1]) * TICKS_TO_NS;
787 B2DEBUG(35,
"cellid = " << cid <<
", amplitude = " << amplitude <<
", time before t(E) shift = " << time <<
788 ", t(E) shift = " << energyTimeShift <<
" ns");
789 time -= energyTimeShift;
793 if (cid < m_minCrystal || cid > m_maxCrystal)
continue;
796 if (fabs(time) > m_timeAbsMax)
continue;
802 crystalIDs[iCharge] = cid;
806 ts_prevCalib[iCharge] = m_PreviousCrystalTime[cid - 1] * TICKS_TO_NS;
807 tcrate_prevCalib[iCharge] = m_CrateTime[cid - 1] * TICKS_TO_NS;
808 times_noPreviousCalibrations[iCharge] = time;
811 B2DEBUG(30,
"iCharge = " << iCharge);
812 B2DEBUG(30,
"crateIDs[iCharge] = " << crateIDs[iCharge]);
813 B2DEBUG(30,
"times_noPreviousCalibrations[iCharge] = " << times_noPreviousCalibrations[iCharge]);
814 B2DEBUG(30,
"tcrate_prevCalib[iCharge] = " << tcrate_prevCalib[iCharge]);
815 B2DEBUG(30,
"ts_prevCalib[iCharge] = " << ts_prevCalib[iCharge]);
818 crystalCutsPassed[iCharge] =
true;
822 crystalEnergies2[iCharge] = crysE2Max[iCharge];
830 m_tree_amp = ecl_dig->
getAmp();
832 m_tree_E1Etot = en / trkEClustLab[iCharge];
833 m_tree_E1E2 = en / crystalEnergies2[iCharge];
834 m_tree_E1p = en / trkpLab[iCharge];
835 m_tree_timetsPreviousTimeCalibs = time - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge];
836 m_tree_timeF = ecl_dig->
getTimeFit() * TICKS_TO_NS;
840 m_tree_t0_unc = evt_t0_unc;
841 m_E_DIV_p = E_DIV_p[iCharge];
842 m_tree_evtNum = evtMetaData->getEvent();
844 m_runNum = evtMetaData->getRun();
847 m_dbgTree_electrons->Fill();
852 getObjectPtr<TH1F>(
"maxEcrsytalEnergyFraction")->Fill(en / trkEClustLab[iCharge]);
862 bool E_DIV_p_instance_passed[2] = {
false,
false};
863 double E_DIV_p_CUT = 0.7;
864 for (
int icharge = 0; icharge < 2; icharge++) {
865 E_DIV_p_instance_passed[icharge] = E_DIV_p[icharge] > E_DIV_p_CUT;
867 if (!E_DIV_p_instance_passed[0] || !E_DIV_p_instance_passed[1]) {
872 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
873 B2DEBUG(10,
"Cutflow: E_i/p_i > " << E_DIV_p_CUT <<
": index = " << cutIndexPassed);
883 vector<double> goodClusters_E;
888 double clusterE_minCut = 0.06;
889 int nclust = m_eclClusterArray.getEntries();
891 vector<int> goodPhotonClusterIdxs;
892 vector<int> goodECLClusterIds;
893 for (
int ic = 0; ic < nclust; ic++) {
896 if (eClust > clusterE_minCut) {
897 goodPhotonClusterIdxs.push_back(ic);
898 goodECLClusterIds.push_back(m_eclClusterArray[ic]->getClusterId());
904 int numTrackless = 0;
905 for (
int clustId = 0; clustId < 2; clustId++) {
906 B2DEBUG(30,
"m_eclClusterArray[goodPhotonClusterIdxs[clustId]]->isTrack() = " <<
907 m_eclClusterArray[goodPhotonClusterIdxs[clustId]]->isTrack());
908 if (!m_eclClusterArray[goodPhotonClusterIdxs[clustId]]->isTrack()) {
912 if (numTrackless != 0) {
913 B2DEBUG(20,
"Number of trackless ECL clusters != 0");
918 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
919 B2DEBUG(10,
"Cutflow: ECL cluster associated to photon does not have a track associated to it: index = " << cutIndexPassed);
920 B2DEBUG(10,
"Cutflow: NEW CUT TO BHABHA CODE FROM eegamma code");
928 double invMassTrk = (trkp4Lab[0] + trkp4Lab[1]).M();
929 double invMass_CUT = 0.9;
930 m_massInvTracks = invMassTrk;
934 m_dbgTree_event->Fill();
938 bool invMassCutsPassed = invMassTrk > (invMass_CUT * boostrotate.
getCMSEnergy());
939 if (!invMassCutsPassed) {
944 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
945 B2DEBUG(10,
"Cutflow: m(track 1+2) > " << invMass_CUT <<
"*E_COM = " << invMass_CUT <<
" * " << boostrotate.
getCMSEnergy() <<
946 " : index = " << cutIndexPassed);
951 for (
int iCharge = 0; iCharge < 2; iCharge++) {
952 if (crystalCutsPassed[iCharge]) {
953 getObjectPtr<TH2F>(
"TimevsCrysPrevCrateCalibPrevCrystCalib")->Fill((crystalIDs[iCharge] - 1) + 0.001,
954 times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge] , 1);
955 getObjectPtr<TH2F>(
"TimevsCratePrevCrateCalibPrevCrystCalib")->Fill((crateIDs[iCharge]) + 0.001,
956 times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge], 1);
957 getObjectPtr<TH2F>(
"TimevsCrysNoCalibrations")->Fill((crystalIDs[iCharge] - 1) + 0.001, times_noPreviousCalibrations[iCharge], 1);
958 getObjectPtr<TH2F>(
"TimevsCrateNoCalibrations")->Fill((crateIDs[iCharge]) + 0.001, times_noPreviousCalibrations[iCharge], 1);
959 getObjectPtr<TH2F>(
"TimevsCrysPrevCrateCalibNoCrystCalib")->Fill((crystalIDs[iCharge] - 1) + 0.001,
960 times_noPreviousCalibrations[iCharge] - tcrate_prevCalib[iCharge], 1);
961 getObjectPtr<TH2F>(
"TimevsCrateNoCrateCalibPrevCrystCalib")->Fill((crateIDs[iCharge]) + 0.001,
962 times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] , 1);
964 getObjectPtr<TH1F>(
"numEntriesPerCrystal")->Fill((crystalIDs[iCharge] - 1) + 0.001);
967 numCrystalsPassingCuts++;
972 if (crystalIDs[iCharge] == 1338) {
973 getObjectPtr<TH2F>(
"TimevsRunPrevCrateCalibPrevCrystCalibCID1338")->Fill(m_runNum + 0.001,
974 times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge] , 1);
976 if (crateIDs[iCharge] == 8) {
977 getObjectPtr<TH2F>(
"TimevsRunPrevCrateCalibPrevCrystCalibCrate8")->Fill(m_runNum + 0.001,
978 times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge] , 1);
987 if (crystalCutsPassed[0] || crystalCutsPassed[1]) {
990 getObjectPtr<TH1F>(
"cutflow")->Fill(cutIndexPassed);
991 B2DEBUG(10,
"Cutflow: At least one crystal time and quality cuts passed: index = " << cutIndexPassed);
993 getObjectPtr<TH1F>(
"numCrystalEntriesPerEvent")->Fill(numCrystalsPassingCuts);
998 for (
int iCharge = 0; iCharge < 2; iCharge++) {
999 if (crystalCutsPassed[iCharge]) {
1002 m_tree_evtNum = evtMetaData->getEvent();
1003 m_tree_cid = crystalIDs[iCharge];
1005 m_tree_time = times_noPreviousCalibrations[iCharge];
1006 m_crystalCrate = crateIDs[iCharge];
1007 m_runNum = evtMetaData->getRun();
1008 m_tree_en = crystalEnergies[iCharge];
1009 m_tree_E1Etot = crystalEnergies[iCharge] / trkEClustLab[iCharge];
1010 m_tree_E1E2 = crystalEnergies[iCharge] / crystalEnergies2[iCharge];
1011 m_tree_E1p = crystalEnergies[iCharge] / trkpLab[iCharge];
1012 m_tree_timetsPreviousTimeCalibs = times_noPreviousCalibrations[iCharge] - ts_prevCalib[iCharge] - tcrate_prevCalib[iCharge];
1014 m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1015 m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1016 m_tree_tClust = clusterTime[iCharge];
1018 m_massInvTracks = invMassTrk;
1021 m_dbgTree_allCuts->Fill();
1030 if (crystalCutsPassed[0] && crystalCutsPassed[1] &&
1031 numClustersPerTrack[0] == 1 && numClustersPerTrack[1] == 1) {
1032 m_tree_enNeg = trkEClustLab[0];
1033 m_tree_enPlus = trkEClustLab[1];
1034 m_tree_tClustNeg = clusterTime[0];
1035 m_tree_tClustPos = clusterTime[1];
1036 m_tree_maxEcrystPosClust = times_noPreviousCalibrations[0] - ts_prevCalib[0] - tcrate_prevCalib[0];
1037 m_tree_maxEcrystNegClust = times_noPreviousCalibrations[1] - ts_prevCalib[1] - tcrate_prevCalib[1];
1039 m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1040 m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1044 m_dbgTree_evt_allCuts->Fill();
1050 B2DEBUG(30,
"m_tree_maxEcrystPosClust + evt_t0 = " << m_tree_maxEcrystPosClust + evt_t0);
1051 B2DEBUG(30,
"m_tree_maxEcrystNegClust + evt_t0 = " << m_tree_maxEcrystNegClust + evt_t0);
1052 B2DEBUG(30,
"CDC evt_t0 = " << evt_t0);
1053 B2DEBUG(30,
"ECL min chi2 even t0, m_tree_t0_ECL_minChi2 = " << m_tree_t0_ECL_minChi2);
1057 for (
long unsigned int digit_i = 0; digit_i < time_ECLCaldigits_bothClusters.size(); digit_i++) {
1059 m_runNum = evtMetaData->getRun();
1060 m_tree_evtNum = evtMetaData->getEvent();
1061 m_tree_ECLCalDigitTime = time_ECLCaldigits_bothClusters[digit_i];
1062 m_tree_ECLCalDigitE = E_ECLCaldigits_bothClusters[digit_i];
1063 m_tree_ECLDigitAmplitude = amp_ECLDigits_bothClusters[digit_i];
1065 m_tree_t0_ECLclosestCDC = evt_t0_ECL_closestCDC;
1066 m_tree_t0_ECL_minChi2 = evt_t0_ECL_minChi2;
1067 m_tree_timetsPreviousTimeCalibs = times_noPreviousCalibrations[chargeID_ECLCaldigits_bothClusters[digit_i]] -
1068 ts_prevCalib[chargeID_ECLCaldigits_bothClusters[digit_i]] -
1069 tcrate_prevCalib[chargeID_ECLCaldigits_bothClusters[digit_i]];
1070 m_tree_cid = cid_ECLCaldigits_bothClusters[digit_i];
1074 m_dbgTree_crys_allCuts->Fill();
1081 B2DEBUG(30,
"This was for event number = " << m_tree_evtNum);