Belle II Software development
PXDGatedModeDQMModule.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <pxd/modules/pxdDQM/PXDGatedModeDQMModule.h>
10#include "TDirectory.h"
11
12using namespace std;
13using namespace Belle2;
14using namespace Belle2::PXD;
15using namespace Belle2::VXD;
16
17//-----------------------------------------------------------------
18// Register the Module
19//-----------------------------------------------------------------
20REG_MODULE(PXDGatedModeDQM);
21
22//-----------------------------------------------------------------
23// Implementation
24//-----------------------------------------------------------------
25
27{
28 //Set module properties
29 setDescription("Monitor GatedMode");
31 addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms will be placed",
32 std::string("PXDINJ"));
33 addParam("PXDRawHitsName", m_PXDRawHitsName, "Name of PXD raw hits", std::string(""));
34 addParam("perGate", m_perGate, "Make plots per GM Start Gate", true);
35 addParam("minTimeCutLER", m_minTimeCutLER, "minimum time cut in us after LER kick", 20);
36 addParam("maxTimeCutLER", m_maxTimeCutLER, "maximum time cut in us after LER kick", 4980);
37 addParam("minTimeCutHER", m_minTimeCutHER, "minimum time cut in us after HER kick", 20);
38 addParam("maxTimeCutHER", m_maxTimeCutHER, "maximum time cut in us after HER kick", 4980);
39 addParam("outsideTimeCut", m_outsideTimeCut, "outside GM time cut in us after kick", 20000);
40 addParam("chargeCut", m_chargeCut, "minimum pixel ADU charge cut", 5);
41 addParam("chargeCutHigh", m_chargeCutHigh, "minimum pixel ADU charge cut for second set of histograms", 20);
42}
43
45{
46 TDirectory* oldDir = gDirectory;
47 oldDir->mkdir(m_histogramDirectoryName.c_str());// do not rely on return value, might be ZERO
48 oldDir->cd(m_histogramDirectoryName.c_str());//changing to the right directory
49
50 hBunchInjHER = new TH1F("hBunchInjHER", "Last Inj Bunch HER;Counts;BunchNr/4", 1280, 0, 1280);
51 hBunchInjLER = new TH1F("hBunchInjLER", "Last Inj Bunch LER;Counts;BunchNr/4", 1280, 0, 1280);
52 hBunchTrg = new TH1F("hBunchTrg", "Triggered Bunch;Counts;BunchNr/4", 1280, 0, 1280);
53
54
55 std::vector<VxdID> sensors = m_vxdGeometry.getListOfSensors();
56 for (VxdID& avxdid : sensors) {
57 VXD::SensorInfoBase info = m_vxdGeometry.getSensorInfo(avxdid);
58 if (info.getType() != VXD::SensorInfoBase::PXD) continue;
59 // Only interested in PXD sensors
60
61 TString buff = (std::string)avxdid;
62 TString buffus = buff;
63 buffus.ReplaceAll(".", "_");
64
65 for (int rgate = m_perGate ? 0 : 96; rgate <= 96; rgate++) { // 96 is no gating
66 hGatedModeMapLER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapLER_%d_", rgate) + buffus,
67 Form("PXDGatedModeMapLER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
68 hGatedModeMapHER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapHER_%d_", rgate) + buffus,
69 Form("PXDGatedModeMapHER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
70 hGatedModeMapCutLER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapCutLER_%d_", rgate) + buffus,
71 Form("PXDGatedModeMapCutLER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
72 hGatedModeMapCutHER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapCutHER_%d_", rgate) + buffus,
73 Form("PXDGatedModeMapCutHER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
74
75 hGatedModeMapADCLER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapADCLER_%d_", rgate) + buffus,
76 Form("PXDGatedModeMapADCLER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
77 hGatedModeMapADCHER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapADCHER_%d_", rgate) + buffus,
78 Form("PXDGatedModeMapADCHER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
79 hGatedModeMapCutADCLER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapCutADCLER_%d_", rgate) + buffus,
80 Form("PXDGatedModeMapCutADCLER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
81 hGatedModeMapCutADCHER[std::make_pair(avxdid, rgate)] = new TH2F(Form("PXDGatedModeMapCutADCHER_%d_", rgate) + buffus,
82 Form("PXDGatedModeMapCutADCHER %d ", rgate) + buff + ";U;V", 25, 0, 250, 192, 0, 768);
83 }
84 hGatedModeProjLER[avxdid] = new TH2F("PXDGatedModeProjLER_" + buffus,
85 "PXDGatedModeProjLER " + buff + ";Gate;V", 96, 0, 96, 192, 0, 768);
86 hGatedModeProjHER[avxdid] = new TH2F("PXDGatedModeProjHER_" + buffus,
87 "PXDGatedModeProjHER " + buff + ";Gate;V", 96, 0, 96, 192, 0, 768);
88
89 hGatedModeMapSubLER[avxdid] = new TH2F("PXDGatedModeMapSubLER_" + buffus,
90 "PXDGatedModeMapSubLER " + buff + ";U;V-G", 25, 0, 250, 192, 0, 768);
91 hGatedModeMapSubHER[avxdid] = new TH2F("PXDGatedModeMapSubHER_" + buffus,
92 "PXDGatedModeMapSubHER " + buff + ";U;V-G", 25, 0, 250, 192, 0, 768);
93 hGatedModeMapAddLER[avxdid] = new TH2F("PXDGatedModeMapAddLER_" + buffus,
94 "PXDGatedModeMapAddLER " + buff + ";U;V+G", 25, 0, 250, 192, 0, 768);
95 hGatedModeMapAddHER[avxdid] = new TH2F("PXDGatedModeMapAddHER_" + buffus,
96 "PXDGatedModeMapAddHER " + buff + ";U;V+G", 25, 0, 250, 192, 0, 768);
97
98 hGatedModeProjADCLER[avxdid] = new TH2F("PXDGatedModeProjADCLER_" + buffus,
99 "PXDGatedModeProjADCLER " + buff + ";Gate;V", 96, 0, 96, 192, 0, 768);
100 hGatedModeProjADCHER[avxdid] = new TH2F("PXDGatedModeProjADCHER_" + buffus,
101 "PXDGatedModeProjADCHER " + buff + ";Gate;V", 96, 0, 96, 192, 0, 768);
102
103 hGatedModeMapSubADCLER[avxdid] = new TH2F("PXDGatedModeMapSubADCLER_" + buffus,
104 "PXDGatedModeMapSubADCLER " + buff + ";U;V-G", 25, 0, 250, 192, 0, 768);
105 hGatedModeMapSubADCHER[avxdid] = new TH2F("PXDGatedModeMapSubADCHER_" + buffus,
106 "PXDGatedModeMapSubADCHER " + buff + ";U;V-G", 25, 0, 250, 192, 0, 768);
107 hGatedModeMapAddADCLER[avxdid] = new TH2F("PXDGatedModeMapAddADCLER_" + buffus,
108 "PXDGatedModeMapAddADCLER " + buff + ";U;V+G", 25, 0, 250, 192, 0, 768);
109 hGatedModeMapAddADCHER[avxdid] = new TH2F("PXDGatedModeMapAddADCHER_" + buffus,
110 "PXDGatedModeMapAddADCHER " + buff + ";U;V+G", 25, 0, 250, 192, 0, 768);
111
112 }
113 // cd back to root directory
114 oldDir->cd();
115}
116
118{
119 REG_HISTOGRAM
121 m_EventLevelTriggerTimeInfo.isRequired();
122
123}
124
126{
127 // reset all histograms
128 hBunchInjHER->Reset();
129 hBunchInjLER->Reset();
130 hBunchTrg->Reset();
131
132 for (auto& it : hGatedModeMapLER) if (it.second) it.second->Reset();
133 for (auto& it : hGatedModeMapHER) if (it.second) it.second->Reset();
134 for (auto& it : hGatedModeMapCutLER) if (it.second) it.second->Reset();
135 for (auto& it : hGatedModeMapCutHER) if (it.second) it.second->Reset();
136 for (auto& it : hGatedModeMapADCLER) if (it.second) it.second->Reset();
137 for (auto& it : hGatedModeMapADCHER) if (it.second) it.second->Reset();
138 for (auto& it : hGatedModeMapCutADCLER) if (it.second) it.second->Reset();
139 for (auto& it : hGatedModeMapCutADCHER) if (it.second) it.second->Reset();
140
141 for (auto& it : hGatedModeProjLER) if (it.second) it.second->Reset();
142 for (auto& it : hGatedModeProjHER) if (it.second) it.second->Reset();
143 for (auto& it : hGatedModeMapSubLER) if (it.second) it.second->Reset();
144 for (auto& it : hGatedModeMapSubHER) if (it.second) it.second->Reset();
145 for (auto& it : hGatedModeMapAddLER) if (it.second) it.second->Reset();
146 for (auto& it : hGatedModeMapAddHER) if (it.second) it.second->Reset();
147 for (auto& it : hGatedModeProjADCLER) if (it.second) it.second->Reset();
148 for (auto& it : hGatedModeProjADCHER) if (it.second) it.second->Reset();
149 for (auto& it : hGatedModeMapSubADCLER) if (it.second) it.second->Reset();
150 for (auto& it : hGatedModeMapSubADCHER) if (it.second) it.second->Reset();
151 for (auto& it : hGatedModeMapAddADCLER) if (it.second) it.second->Reset();
152 for (auto& it : hGatedModeMapAddADCHER) if (it.second) it.second->Reset();
153}
154
156{
157 // And check if the stored data is valid
158 if (m_EventLevelTriggerTimeInfo.isValid() and m_EventLevelTriggerTimeInfo->isValid()) {
159 // check time overflow, too long ago
160 if (m_EventLevelTriggerTimeInfo->hasInjection()) {
161 // get last injection time
162 auto isher = m_EventLevelTriggerTimeInfo->isHER();
163 float difference = m_EventLevelTriggerTimeInfo->getTimeSinceLastInjection() / 127. ; // 127MHz clock ticks to us, inexact rounding
164 int bunch_trg = m_EventLevelTriggerTimeInfo->getBunchNumber();
165 int time_inj = m_EventLevelTriggerTimeInfo->getTimeSinceLastInjection();
166 int bunch_inj = (bunch_trg - time_inj) % 1280;
167 if (bunch_inj < 0) bunch_inj += 1280;
168 int rgate = bunch_inj / (1280. / 96.); // 0-96 ?
169 if ((isher && difference >= m_minTimeCutHER && difference <= m_maxTimeCutHER) ||
170 (!isher && difference >= m_minTimeCutLER && difference <= m_maxTimeCutLER)
171 ) { // be sure that we fill only in gating region
172 hBunchTrg->Fill(m_EventLevelTriggerTimeInfo->getBunchNumber() & 0x7FF);
173 if (isher) hBunchInjHER->Fill(bunch_inj);
174 else hBunchInjLER->Fill(bunch_inj);
175 for (auto& p : m_storeRawHits) {
176 auto charge = p.getCharge();
177 if (charge > m_chargeCut) {
178 int v = int(p.getVCellID()) - rgate * 4;
179 if (v < 0) v += 768;
180 int v2 = int(p.getVCellID()) + rgate * 4;
181 if (v2 >= 768) v2 -= 768;
182 if (isher) {
183 auto h = hGatedModeMapHER[std::make_pair(p.getSensorID(), rgate)];
184 if (h) {
185 h->Fill(p.getUCellID(), p.getVCellID());
186 }
187 auto h2 = hGatedModeProjHER[p.getSensorID()];
188 if (h2) {
189 h2->Fill(rgate, p.getVCellID());
190 }
191 auto h3 = hGatedModeMapSubHER[p.getSensorID()];
192 if (h3) {
193 h3->Fill(p.getUCellID(), v);
194 }
195 auto h4 = hGatedModeMapAddHER[p.getSensorID()];
196 if (h4) {
197 h4->Fill(p.getUCellID(), v2);
198 }
199 auto h5 = hGatedModeMapADCHER[std::make_pair(p.getSensorID(), rgate)];
200 if (h5) {
201 h5->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
202 }
203 auto h6 = hGatedModeProjADCHER[p.getSensorID()];
204 if (h6) {
205 h6->Fill(rgate, p.getVCellID(), p.getCharge());
206 }
207 auto h7 = hGatedModeMapSubADCHER[p.getSensorID()];
208 if (h7) {
209 h7->Fill(p.getUCellID(), v, p.getCharge());
210 }
211 auto h8 = hGatedModeMapAddADCHER[p.getSensorID()];
212 if (h8) {
213 h8->Fill(p.getUCellID(), v2, p.getCharge());
214 }
215 } else {
216 auto h = hGatedModeMapLER[std::make_pair(p.getSensorID(), rgate)];
217 if (h) {
218 h->Fill(p.getUCellID(), p.getVCellID());
219 }
220 auto h2 = hGatedModeProjLER[p.getSensorID()];
221 if (h2) {
222 h2->Fill(rgate, p.getVCellID());
223 }
224 auto h3 = hGatedModeMapSubLER[p.getSensorID()];
225 if (h3) {
226 h3->Fill(p.getUCellID(), v);
227 }
228 auto h4 = hGatedModeMapAddLER[p.getSensorID()];
229 if (h4) {
230 h4->Fill(p.getUCellID(), v2);
231 }
232 auto h5 = hGatedModeMapADCLER[std::make_pair(p.getSensorID(), rgate)];
233 if (h5) {
234 h5->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
235 }
236 auto h6 = hGatedModeProjADCLER[p.getSensorID()];
237 if (h6) {
238 h6->Fill(rgate, p.getVCellID(), p.getCharge());
239 }
240 auto h7 = hGatedModeMapSubADCLER[p.getSensorID()];
241 if (h7) {
242 h7->Fill(p.getUCellID(), v, p.getCharge());
243 }
244 auto h8 = hGatedModeMapAddADCLER[p.getSensorID()];
245 if (h8) {
246 h8->Fill(p.getUCellID(), v2, p.getCharge());
247 }
248 }
249 }
250 if (m_chargeCutHigh > 30) {
251
252 if (isher) {
253 auto h = hGatedModeMapCutHER[std::make_pair(p.getSensorID(), rgate)];
254 if (h) {
255 h->Fill(p.getUCellID(), p.getVCellID());
256 }
257 auto h2 = hGatedModeMapCutADCHER[std::make_pair(p.getSensorID(), rgate)];
258 if (h2) {
259 h2->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
260 }
261 } else {
262 auto h = hGatedModeMapCutLER[std::make_pair(p.getSensorID(), rgate)];
263 if (h) {
264 h->Fill(p.getUCellID(), p.getVCellID());
265 }
266 auto h2 = hGatedModeMapCutADCLER[std::make_pair(p.getSensorID(), rgate)];
267 if (h2) {
268 h2->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
269 }
270 }
271 }
272 }
273 } else if (difference > m_outsideTimeCut) {
274 rgate = 96;
275 for (auto& p : m_storeRawHits) {
276 if (isher) {
277 auto h = hGatedModeMapHER[std::make_pair(p.getSensorID(), rgate)];
278 if (h) {
279 h->Fill(p.getUCellID(), p.getVCellID());
280 }
281 auto h2 = hGatedModeMapADCHER[std::make_pair(p.getSensorID(), rgate)];
282 if (h2) {
283 h2->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
284 }
285 } else {
286 auto h = hGatedModeMapLER[std::make_pair(p.getSensorID(), rgate)];
287 if (h) {
288 h->Fill(p.getUCellID(), p.getVCellID());
289 }
290 auto h2 = hGatedModeMapADCLER[std::make_pair(p.getSensorID(), rgate)];
291 if (h2) {
292 h2->Fill(p.getUCellID(), p.getVCellID(), p.getCharge());
293 }
294 }
295 }
296 }
297 }
298 }
299}
HistoModule()
Constructor.
Definition HistoModule.h:32
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition Module.h:80
std::map< VxdID, TH2F * > hGatedModeProjLER
Histogram Occupancy after LER injection.
std::string m_PXDRawHitsName
The name of the StoreArray of PXDRawHits to be generated.
std::map< VxdID, TH2F * > hGatedModeProjHER
Histogram Occupancy after HER injection.
void initialize() override final
initialize function
bool m_perGate
make one plot per possible gate
PXDGatedModeDQMModule()
Constructor defining the parameters.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapHER
Histogram Occupancy after HER injection.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapADCLER
Histogram Occupancy after LER injection.
int m_minTimeCutLER
minimum time cut in us after LER kick
std::map< VxdID, TH2F * > hGatedModeMapSubHER
Histogram Occupancy after HER injection.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapLER
Histogram Occupancy after LER injection.
std::map< VxdID, TH2F * > hGatedModeMapAddADCHER
Histogram Occupancy after HER injection.
int m_outsideTimeCut
outside GM time cut in us after kick
void defineHisto() override final
defineHisto function
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapADCHER
Histogram Occupancy after HER injection.
std::map< VxdID, TH2F * > hGatedModeMapSubADCLER
Histogram Occupancy after LER injection.
std::map< VxdID, TH2F * > hGatedModeMapAddLER
Histogram Occupancy after LER injection.
int m_maxTimeCutLER
maximum time cut in us after LER kick
int m_maxTimeCutHER
maximum time cut in us after HER kick
int m_chargeCut
minimum charge cut in ADU
void event() override final
event function
int m_minTimeCutHER
minimum time cut in us after HER kick
std::map< VxdID, TH2F * > hGatedModeProjADCLER
Histogram Occupancy after LER injection.
std::string m_histogramDirectoryName
Name of the histogram directory in ROOT file.
TH1F * hBunchInjLER
Histo for last LER injected bunches.
int m_chargeCutHigh
minimum charge cut for second set of histograms in ADU
std::map< VxdID, TH2F * > hGatedModeMapSubLER
Histogram Occupancy after LER injection.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapCutLER
Histogram Occupancy after LER injection.
std::map< VxdID, TH2F * > hGatedModeMapSubADCHER
Histogram Occupancy after HER injection.
void beginRun() override final
beginRun function
std::map< VxdID, TH2F * > hGatedModeMapAddADCLER
Histogram Occupancy after LER injection.
VXD::GeoCache & m_vxdGeometry
the VXD geometry
std::map< VxdID, TH2F * > hGatedModeMapAddHER
Histogram Occupancy after HER injection.
TH1F * hBunchTrg
Histo for triggered bunches.
std::map< VxdID, TH2F * > hGatedModeProjADCHER
Histogram Occupancy after HER injection.
StoreObjPtr< EventLevelTriggerTimeInfo > m_EventLevelTriggerTimeInfo
Object for TTD mdst object.
StoreArray< PXDRawHit > m_storeRawHits
Input array for PXD Raw Hits.
TH1F * hBunchInjHER
Histo for last HER injected bunches.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapCutHER
Histogram Occupancy after HER injection.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapCutADCLER
Histogram Occupancy after LER injection.
std::map< std::pair< VxdID, int >, TH2F * > hGatedModeMapCutADCHER
Histogram Occupancy after HER injection.
Class to facilitate easy access to sensor information of the VXD like coordinate transformations or p...
Definition GeoCache.h:39
Base class to provide Sensor Information for PXD and SVD.
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:33
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition Module.h:559
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Namespace to encapsulate code needed for simulation and reconstrucion of the PXD.
Namespace to provide code needed by both Vertex Detectors, PXD and SVD, and also testbeam telescopes.
Definition GeoCache.h:34
Abstract base class for different kinds of events.
STL namespace.