Belle II Software development
vxdDigitMaskingModule.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 "vxd/modules/vxdMask/vxdDigitMaskingModule.h"
10
11#include <framework/datastore/StoreArray.h>
12
13#include <svd/dataobjects/SVDShaperDigit.h>
14#include <pxd/dataobjects/PXDDigit.h>
15
16#include <pxd/online/PXDIgnoredPixelsMap.h>
17#include <svd/online/SVDIgnoredStripsMap.h>
18
19#include <pxd/geometry/SensorInfo.h>
20#include <svd/geometry/SensorInfo.h>
21
22#include <vxd/geometry/GeoCache.h>
23#include <vxd/geometry/SensorInfoBase.h>
24
25#include <boost/format.hpp>
26
27#include <TDirectory.h>
28
29using namespace std;
30using boost::format;
31using namespace Belle2;
32
33//-----------------------------------------------------------------
34// Register the Module
35//-----------------------------------------------------------------
36REG_MODULE(vxdDigitMasking);
37
38
39//-----------------------------------------------------------------
40// Implementation
41//-----------------------------------------------------------------
42
43vxdDigitMaskingModule::vxdDigitMaskingModule() : HistoModule()
44{
45 //Set module properties
46 setDescription("vxdDigitMasking of pixels and strips in PXD and SVD base on their firing");
47 setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
48
49 addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms will be placed",
50 std::string("maskVXD"));
51 m_nEventsProcess = -1;
52 addParam("nEventsProcess", m_nEventsProcess, "Number of events to process", m_nEventsProcess);
53 m_AppendMaskFile = 1;
54 addParam("AppendMaskFile", m_AppendMaskFile, "Set option for append of existing file or recreate new list", m_AppendMaskFile);
55
56 addParam("PXDChargeCut", m_PXDChargeCut, "Cut for Charge of PXD pixel", m_PXDChargeCut);
57 addParam("SVDuChargeCut", m_SVDuChargeCut, "Cut for Charge of SVD U strip", m_SVDuChargeCut);
58 addParam("SVDvChargeCut", m_SVDvChargeCut, "Cut for Charge of SVD V strip", m_SVDvChargeCut);
59
60 addParam("PXDCut", m_PXDCut, "Cut for masking of PXD pixel - preset for 1 kEvent", m_PXDCut);
61 addParam("SVDuCut", m_SVDuCut, "Cut for masking of SVD U strip - preset for 1 kEvent", m_SVDuCut);
62 addParam("SVDvCut", m_SVDvCut, "Cut for masking of SVD V strip - preset for 1 kEvent", m_SVDvCut);
63
64 addParam("PXDMaskFileBasicName", m_PXDMaskFileBasicName, "Name of file with list of masked channels",
65 std::string("PXD_MaskFiredBasic.xml"));
66 addParam("SVDMaskFileBasicName", m_SVDMaskFileBasicName, "Name of file with list of masked channels",
67 std::string("SVD_MaskFiredBasic.xml"));
68 addParam("PXDMaskFileRunName", m_PXDMaskFileRunName, "Name of file with list of masked channels",
69 std::string("PXD_MaskFired_RunXXX.xml"));
70 addParam("SVDMaskFileRunName", m_SVDMaskFileRunName, "Name of file with list of masked channels",
71 std::string("SVD_MaskFired_RunXXX.xml"));
72}
73
74
75vxdDigitMaskingModule::~vxdDigitMaskingModule()
76{
77}
78
79//------------------------------------------------------------------
80// Function to define histograms
81//-----------------------------------------------------------------
82
83void vxdDigitMaskingModule::defineHisto()
84{
85 auto gTools = VXD::GeoCache::getInstance().getGeoTools();
86 if (gTools->getNumberOfLayers() == 0) {
87 B2WARNING("Missing geometry for VXD, check steering file.");
88 return;
89 }
90 if (gTools->getNumberOfPXDLayers() == 0) {
91 B2WARNING("Missing geometry for PXD, PXD-masking is skipped.");
92 }
93 if (gTools->getNumberOfSVDLayers() == 0) {
94 B2WARNING("Missing geometry for SVD, SVD-masking is skipped.");
95 }
96
97 // Create a separate histogram directories and cd into it.
98 TDirectory* oldDir = gDirectory;
99 if (m_histogramDirectoryName != "") {
100 oldDir->mkdir(m_histogramDirectoryName.c_str());// do not use return value with ->cd(), its ZERO if dir already exists
101 oldDir->cd(m_histogramDirectoryName.c_str());
102 }
103
104 int nPXDSensors = gTools->getNumberOfPXDSensors();
105 if (gTools->getNumberOfPXDLayers() != 0) {
106 m_PXDHitMapUV = new TH2F*[nPXDSensors];
107 m_PXDMaskUV = new TH2F*[nPXDSensors];
108
109 for (int i = 0; i < nPXDSensors; i++) {
110 VxdID id = gTools->getSensorIDFromPXDIndex(i);
111 int iLayer = id.getLayerNumber();
112 int iLadder = id.getLadderNumber();
113 int iSensor = id.getSensorNumber();
114 VxdID sensorID(iLayer, iLadder, iSensor);
115 PXD::SensorInfo SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
116 string sensorDescr = str(format("%1%_%2%_%3%") % iLayer % iLadder % iSensor);
117
118 int nPixelsU = SensorInfo.getUCells();
119 int nPixelsV = SensorInfo.getVCells();
120 //----------------------------------------------------------------
121 // Hitmaps: Number of pixels by coordinate
122 //----------------------------------------------------------------
123 string name = str(format("PXD_%1%_PixelHitmap") % sensorDescr);
124 string title = str(format("PXD Sensor %1% Pixel Hitmap") % sensorDescr);
125 m_PXDHitMapUV[i] = new TH2F(name.c_str(), title.c_str(), nPixelsU, 0, nPixelsU, nPixelsV, 0, nPixelsV);
126 m_PXDHitMapUV[i]->GetXaxis()->SetTitle("u position [pitch units]");
127 m_PXDHitMapUV[i]->GetYaxis()->SetTitle("v position [pitch units]");
128 m_PXDHitMapUV[i]->GetZaxis()->SetTitle("hits");
129
130 name = str(format("PXD_%1%_PixelMaskmap") % sensorDescr);
131 title = str(format("PXD Sensor %1% Pixel Maskmap") % sensorDescr);
132 m_PXDMaskUV[i] = new TH2F(name.c_str(), title.c_str(), nPixelsU, 0, nPixelsU, nPixelsV, 0, nPixelsV);
133 m_PXDMaskUV[i]->GetXaxis()->SetTitle("u position [pitch units]");
134 m_PXDMaskUV[i]->GetYaxis()->SetTitle("v position [pitch units]");
135 m_PXDMaskUV[i]->GetZaxis()->SetTitle("mask");
136 }
137 }
138 int nSVDSensors = gTools->getNumberOfSVDSensors();
139 if (gTools->getNumberOfPXDLayers() != 0) {
140 m_SVDHitMapU = new TH1F*[nSVDSensors];
141 m_SVDHitMapV = new TH1F*[nSVDSensors];
142 m_SVDHitMapU2 = new TH1F*[nSVDSensors];
143 m_SVDHitMapV2 = new TH1F*[nSVDSensors];
144 m_SVDMaskU = new TH1F*[nSVDSensors];
145 m_SVDMaskV = new TH1F*[nSVDSensors];
146 m_SVDMaskU2 = new TH1F*[nSVDSensors];
147 m_SVDMaskV2 = new TH1F*[nSVDSensors];
148
149 for (int i = 0; i < nSVDSensors; i++) {
150 VxdID id = gTools->getSensorIDFromSVDIndex(i);
151 int iLayer = id.getLayerNumber();
152 int iLadder = id.getLadderNumber();
153 int iSensor = id.getSensorNumber();
154 VxdID sensorID(iLayer, iLadder, iSensor);
155 SVD::SensorInfo SensorInfo = dynamic_cast<const SVD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
156 string sensorDescr = str(format("%1%_%2%_%3%") % iLayer % iLadder % iSensor);
157
158 int nStripsU = SensorInfo.getUCells();
159 int nStripsV = SensorInfo.getVCells();
160 //----------------------------------------------------------------
161 // Hitmaps: Number of strips by coordinate
162 //----------------------------------------------------------------
163 string name = str(format("SVD_%1%_StripHitmapU") % sensorDescr);
164 string title = str(format("SVD Sensor %1% Strip Hitmap in U") % sensorDescr);
165 m_SVDHitMapU[i] = new TH1F(name.c_str(), title.c_str(), nStripsU, 0, nStripsU);
166 m_SVDHitMapU[i]->GetXaxis()->SetTitle("u position [pitch units]");
167 m_SVDHitMapU[i]->GetYaxis()->SetTitle("hits");
168 name = str(format("SVD_%1%_StripHitmapV") % sensorDescr);
169 title = str(format("SVD Sensor %1% Strip Hitmap in V") % sensorDescr);
170 m_SVDHitMapV[i] = new TH1F(name.c_str(), title.c_str(), nStripsV, 0, nStripsV);
171 m_SVDHitMapV[i]->GetXaxis()->SetTitle("v position [pitch units]");
172 m_SVDHitMapV[i]->GetYaxis()->SetTitle("hits");
173
174 name = str(format("SVD_%1%_StripMaskmapU") % sensorDescr);
175 title = str(format("SVD Sensor %1% Strip Maskmap in U") % sensorDescr);
176 m_SVDMaskU[i] = new TH1F(name.c_str(), title.c_str(), nStripsU, 0, nStripsU);
177 m_SVDMaskU[i]->GetXaxis()->SetTitle("u position [pitch units]");
178 m_SVDMaskU[i]->GetYaxis()->SetTitle("mask");
179 name = str(format("SVD_%1%_StripMaskmapV") % sensorDescr);
180 title = str(format("SVD Sensor %1% Strip Maskmap in V") % sensorDescr);
181 m_SVDMaskV[i] = new TH1F(name.c_str(), title.c_str(), nStripsV, 0, nStripsV);
182 m_SVDMaskV[i]->GetXaxis()->SetTitle("v position [pitch units]");
183 m_SVDMaskV[i]->GetYaxis()->SetTitle("mask");
184
185 name = str(format("SVD_%1%_StripHitmapU2") % sensorDescr);
186 title = str(format("SVD Sensor %1% Strip Hitmap 2 samples in U") % sensorDescr);
187 m_SVDHitMapU2[i] = new TH1F(name.c_str(), title.c_str(), nStripsU, 0, nStripsU);
188 m_SVDHitMapU2[i]->GetXaxis()->SetTitle("u position [pitch units]");
189 m_SVDHitMapU2[i]->GetYaxis()->SetTitle("hits");
190 name = str(format("SVD_%1%_StripHitmapV2") % sensorDescr);
191 title = str(format("SVD Sensor %1% Strip Hitmap 2 samples in V") % sensorDescr);
192 m_SVDHitMapV2[i] = new TH1F(name.c_str(), title.c_str(), nStripsV, 0, nStripsV);
193 m_SVDHitMapV2[i]->GetXaxis()->SetTitle("v position [pitch units]");
194 m_SVDHitMapV2[i]->GetYaxis()->SetTitle("hits");
195
196 name = str(format("SVD_%1%_StripMaskmapU2") % sensorDescr);
197 title = str(format("SVD Sensor %1% Strip Maskmap 2 samples in U") % sensorDescr);
198 m_SVDMaskU2[i] = new TH1F(name.c_str(), title.c_str(), nStripsU, 0, nStripsU);
199 m_SVDMaskU2[i]->GetXaxis()->SetTitle("u position [pitch units]");
200 m_SVDMaskU2[i]->GetYaxis()->SetTitle("mask");
201 name = str(format("SVD_%1%_StripMaskmapV2") % sensorDescr);
202 title = str(format("SVD Sensor %1% Strip Maskmap 2 samples in V") % sensorDescr);
203 m_SVDMaskV2[i] = new TH1F(name.c_str(), title.c_str(), nStripsV, 0, nStripsV);
204 m_SVDMaskV2[i]->GetXaxis()->SetTitle("v position [pitch units]");
205 m_SVDMaskV2[i]->GetYaxis()->SetTitle("mask");
206
207 }
208 }
209 m_nEventsPlane = new long[nPXDSensors + nSVDSensors];
210 // cd back to root directory
211 oldDir->cd();
212}
213
214
215void vxdDigitMaskingModule::initialize()
216{
217 //Register histograms (calls back defineHisto)
218 REG_HISTOGRAM
219
220 auto gTools = VXD::GeoCache::getInstance().getGeoTools();
221 if (gTools->getNumberOfPXDLayers() != 0) {
222 //Register collections
223 StoreArray<PXDDigit> storePXDDigits(m_storePXDDigitsName);
224 //Store names to speed up creation later
225 m_storePXDDigitsName = storePXDDigits.getName();
226 }
227 if (gTools->getNumberOfSVDLayers() != 0) {
228 //Register collections
229 StoreArray<SVDShaperDigit> storeSVDDigits(m_storeSVDShaperDigitsName);
230 //Store names to speed up creation later
231 m_storeSVDShaperDigitsName = storeSVDDigits.getName();
232 }
233}
234
235void vxdDigitMaskingModule::beginRun()
236{
237 auto gTools = VXD::GeoCache::getInstance().getGeoTools();
238 int nPXDSensors = gTools->getNumberOfPXDSensors();
239 int nSVDSensors = gTools->getNumberOfSVDSensors();
240 m_nRealEventsProcess = 0;
241 for (int i = 0; i < (nPXDSensors + nSVDSensors); i++) {
242 m_nEventsPlane[i] = 0;
243 }
244}
245
246
247void vxdDigitMaskingModule::event()
248{
249 m_nRealEventsProcess++;
250 auto gTools = VXD::GeoCache::getInstance().getGeoTools();
251 if (gTools->getNumberOfPXDLayers() != 0) {
252 const StoreArray<PXDDigit> storePXDDigits(m_storePXDDigitsName);
253 // If there are no digits, leave
254 if (storePXDDigits && storePXDDigits.getEntries()) {
255 int firstPXDLayer = gTools->getFirstPXDLayer();
256 int lastPXDLayer = gTools->getLastPXDLayer();
257
258 for (const PXDDigit& digit : storePXDDigits) {
259 if (digit.getCharge() < m_PXDChargeCut) continue;
260 int iLayer = digit.getSensorID().getLayerNumber();
261 if ((iLayer < firstPXDLayer) || (iLayer > lastPXDLayer)) continue;
262 int iLadder = digit.getSensorID().getLadderNumber();
263 int iSensor = digit.getSensorID().getSensorNumber();
264 VxdID sensorID(iLayer, iLadder, iSensor);
265 int index = gTools->getPXDSensorIndex(sensorID);
266 if (m_PXDHitMapUV[index] != NULL) m_PXDHitMapUV[index]->Fill(digit.getUCellID(), digit.getVCellID());
267 m_nEventsPlane[index]++;
268 }
269 }
270 }
271 if (gTools->getNumberOfSVDLayers() != 0) {
272 const StoreArray<SVDShaperDigit> storeSVDDigits(m_storeSVDShaperDigitsName);
273 // If there are no digits, leave
274 if (storeSVDDigits && storeSVDDigits.getEntries()) {
275 int firstSVDLayer = gTools->getFirstSVDLayer();
276 int lastSVDLayer = gTools->getLastSVDLayer();
277 int nPXDSensors = gTools->getNumberOfPXDSensors();
278
279 for (const SVDShaperDigit& digit : storeSVDDigits) {
280 int iLayer = digit.getSensorID().getLayerNumber();
281 if ((iLayer < firstSVDLayer) || (iLayer > lastSVDLayer)) continue;
282 int iLadder = digit.getSensorID().getLadderNumber();
283 int iSensor = digit.getSensorID().getSensorNumber();
284 VxdID sensorID(iLayer, iLadder, iSensor);
285 int index = gTools->getSVDSensorIndex(sensorID);
286 SVDShaperDigit::APVFloatSamples samples = digit.getSamples();
287
288 if (digit.isUStrip()) {
289 int iCont = 0;
290 for (size_t i = 0; i < SVDShaperDigit::c_nAPVSamples; ++i) {
291 float fCharge1 = samples[i];
292 if (fCharge1 > m_SVDuChargeCut)
293 iCont++;
294 }
295 if (iCont == 1) {
296 if (m_SVDHitMapU[index] != NULL) m_SVDHitMapU[index]->Fill(digit.getCellID());
297 m_nEventsPlane[nPXDSensors + index]++;
298 }
299 if (iCont > 1)
300 if (m_SVDHitMapU2[index] != NULL) m_SVDHitMapU2[index]->Fill(digit.getCellID());
301 } else {
302 int iCont = 0;
303 for (size_t i = 0; i < SVDShaperDigit::c_nAPVSamples; ++i) {
304 float fCharge1 = samples[i];
305 if (fCharge1 > m_SVDvChargeCut)
306 iCont++;
307 }
308 if (iCont == 1) {
309 if (m_SVDHitMapV[index] != NULL) m_SVDHitMapV[index]->Fill(digit.getCellID());
310 m_nEventsPlane[nPXDSensors + index]++;
311 }
312 if (iCont > 1)
313 if (m_SVDHitMapV2[index] != NULL) m_SVDHitMapV2[index]->Fill(digit.getCellID());
314 }
315 }
316 }
317 }
318}
319
320void vxdDigitMaskingModule::endRun()
321{
322
323 auto gTools = VXD::GeoCache::getInstance().getGeoTools();
324
325 if (m_nRealEventsProcess < 500) {
326 TString message = Form("Not enough data: %li < 500, terminate without masking file create.", m_nRealEventsProcess);
327 B2WARNING(message.Data());
328 return;
329 }
330 m_nEventsProcessFraction = (double)m_nRealEventsProcess / m_nEventsProcess;
331
332 // Maskin border for all sensors at 1000 events!:
333 float PXDCut = m_PXDCut;
334
335 float SVDUCut = m_SVDuCut;
336 float SVDVCut = m_SVDvCut;
337
338 // correction for unmerged events and different No. of process events:
339 PXDCut *= m_nEventsProcessFraction * m_nEventsProcess / 1000.0;
340 SVDUCut *= m_nEventsProcessFraction * m_nEventsProcess / 1000.0;
341 SVDVCut *= m_nEventsProcessFraction * m_nEventsProcess / 1000.0;
342
343 FILE* MaskList;
344
345 int nPXDSensors = gTools->getNumberOfPXDSensors();
346 if (gTools->getNumberOfPXDLayers() != 0) {
347 TString message = Form("Start to create masking from %i events (fraction: %6.3f)", (int)m_nRealEventsProcess,
348 m_nEventsProcessFraction);
349 B2INFO(message.Data());
350
351 std::string FileName = str(format("%1%") % m_PXDMaskFileBasicName);
352 std::string ignoredPixelsListName = str(format("%1%") % FileName);
353 std::unique_ptr<PXDIgnoredPixelsMap> m_ignoredPixelsBasicList = unique_ptr<PXDIgnoredPixelsMap>(new PXDIgnoredPixelsMap(
354 ignoredPixelsListName));
355 FileName = str(format("%1%") % m_PXDMaskFileRunName);
356 ignoredPixelsListName = str(format("%1%") % FileName);
357 std::unique_ptr<PXDIgnoredPixelsMap> m_ignoredPixelsList = unique_ptr<PXDIgnoredPixelsMap>(new PXDIgnoredPixelsMap(
358 ignoredPixelsListName));
359 MaskList = fopen(FileName.data(), "w");
360 if (MaskList == nullptr) {
361 B2ERROR("Cannot open the mask file for writing: " << FileName);
362 return;
363 }
364 fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
365 fprintf(MaskList, "<Meta>\n");
366 fprintf(MaskList, " <Date>19.02.2018</Date>\n");
367 fprintf(MaskList, " <Description short=\"Ignore strip list for PXD planes in 2018 VXD phase2 and phase3\">\n");
368 fprintf(MaskList, " Crude initial list of bad pixels\n");
369 fprintf(MaskList, " </Description>\n");
370 fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
371 fprintf(MaskList, "</Meta>\n");
372 fprintf(MaskList, "<PXD>\n");
373 for (int i = 0; i < nPXDSensors; i++) {
374 if (m_nEventsPlane[i] == 0) continue;
375 VxdID id = gTools->getSensorIDFromPXDIndex(i);
376 int iLayer = id.getLayerNumber();
377 int iLadder = id.getLadderNumber();
378 int iSensor = id.getSensorNumber();
379 fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
380 fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
381 fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
382 fprintf(MaskList, " <!-- vxdDigitMasking rectangular parts of the sensor -->\n");
383 fprintf(MaskList, " <!--pixels uStart = \"070\" uEnd = \"110\" vStart = \"0\" vEnd = \"500\"></pixels-->\n");
384 fprintf(MaskList, "\n");
385 fprintf(MaskList, " <!-- Individual pixels can be masked, too -->\n");
386 fprintf(MaskList, " <!--pixels uStart = \"130\" vStart = \"500\"></pixels-->\n");
387 fprintf(MaskList, "\n");
388 fprintf(MaskList, " <!-- ROW is V / COLUMN is U -->\n");
389 fprintf(MaskList, "\n");
390 fprintf(MaskList, " <!-- Individual rows and columns can be masked, too -->\n");
391 fprintf(MaskList, " <!--pixels vStart = \"500\"></pixels-->\n");
392 fprintf(MaskList, " <!--pixels uStart = \"120\"></pixels-->\n");
393 fprintf(MaskList, "\n");
394 fprintf(MaskList, " <!-- Ranges of rows and columns can be masked, too -->\n");
395 fprintf(MaskList, " <!--pixels vStart = \"100\" vEnd = \"120\"></pixels-->\n");
396 fprintf(MaskList, " <!--pixels uStart = \"120\" uEnd = \"202\"></pixels-->\n");
397 fprintf(MaskList, "\n");
398 for (int i1 = 0; i1 < m_PXDMaskUV[i]->GetNbinsX(); ++i1) {
399 for (int i2 = 0; i2 < m_PXDMaskUV[i]->GetNbinsY(); ++i2) {
400 int ExistMask = 0;
401 if (m_AppendMaskFile) {
402 if (!m_ignoredPixelsBasicList->pixelOK(VxdID(iLayer, iLadder, iSensor), PXDIgnoredPixelsMap::map_pixel(i1, i2))) {
403 ExistMask += 1;
404 }
405 if (!m_ignoredPixelsList->pixelOK(VxdID(iLayer, iLadder, iSensor), PXDIgnoredPixelsMap::map_pixel(i1, i2))) {
406 ExistMask += 1;
407 }
408 }
409 if (ExistMask || (m_PXDHitMapUV[i]->GetBinContent(i1 + 1, i2 + 1) > PXDCut)) {
410 fprintf(MaskList, " <pixels uStart = \"%04i\" vStart = \"%04i\"></pixels>\n", i1, i2);
411 m_PXDMaskUV[i]->SetBinContent(i1 + 1, i2 + 1, 1 + ExistMask);
412 }
413 }
414 }
415 fprintf(MaskList, "\n");
416 fprintf(MaskList, " </sensor>\n");
417 fprintf(MaskList, " </ladder>\n");
418 fprintf(MaskList, " </layer>\n");
419 }
420 fprintf(MaskList, "</PXD>\n");
421 fclose(MaskList);
422 }
423
424 if (gTools->getNumberOfSVDLayers() != 0) {
425 std::string FileName = str(format("%1%") % m_SVDMaskFileBasicName);
426 std::string ignoredPixelsListName = str(format("%1%") % FileName);
427 std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsBasicList = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
428 ignoredPixelsListName));
429 string FileName2 = str(format("%1%") % m_SVDMaskFileRunName);
430 string ignoredPixelsListName2 = str(format("%1%") % FileName2);
431 std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsList = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
432 ignoredPixelsListName2));
433 MaskList = fopen(FileName2.data(), "w");
434 if (MaskList == nullptr) {
435 B2ERROR("Cannot open the mask file for writing: " << FileName2);
436 return;
437 }
438 fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
439 fprintf(MaskList, "<Meta>\n");
440 fprintf(MaskList, " <Date>19.02.2018</Date>\n");
441 fprintf(MaskList, " <Description short=\"Ignore strip list for SVD planes in 2018 VXD phase2 and phase3\">\n");
442 fprintf(MaskList, " Crude initial list of bad strips\n");
443 fprintf(MaskList, " </Description>\n");
444 fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
445 fprintf(MaskList, "</Meta>\n");
446 fprintf(MaskList, "<SVD>\n");
447 int nSVDSensors = gTools->getNumberOfSVDSensors();
448 for (int i = 0; i < nSVDSensors; i++) {
449 if (m_nEventsPlane[nPXDSensors + i] == 0) continue;
450 VxdID id = gTools->getSensorIDFromSVDIndex(i);
451 int iLayer = id.getLayerNumber();
452 int iLadder = id.getLadderNumber();
453 int iSensor = id.getSensorNumber();
454 fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
455 fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
456 fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
457 fprintf(MaskList, " <side side=\"u\">\n");
458 fprintf(MaskList, " <!-- stripsFromTo fromStrip = \"620\" toStrip = \"767\"></stripsFromTo-->\n");
459 fprintf(MaskList, " <!-- Individual strips can be masked, too -->\n");
460 int nMaskedU = 0;
461 int nMaskedV = 0;
462 for (int i1 = 0; i1 < m_SVDMaskU[i]->GetNbinsX(); ++i1) {
463 int ExistMask = 0;
464 if (m_AppendMaskFile) {
465 if (!m_ignoredStripsBasicList->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
466 ExistMask += 1;
467 }
468 if (!m_ignoredStripsList->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
469 ExistMask += 1;
470 }
471 }
472 int sTS = 0;
473 if (m_SVDHitMapU[i]->GetBinContent(i1 + 1) > SVDUCut)
474 sTS = 1;
475
476 if (ExistMask || (sTS)) {
477 fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i1);
478 m_SVDMaskU[i]->SetBinContent(i1 + 1, 1 + ExistMask);
479 nMaskedU++;
480 }
481 }
482 fprintf(MaskList, " </side>\n");
483 fprintf(MaskList, " <side side=\"v\">\n");
484 for (int i2 = 0; i2 < m_SVDMaskV[i]->GetNbinsX(); ++i2) {
485 int ExistMask = 0;
486 if (m_AppendMaskFile) {
487 if (!m_ignoredStripsBasicList->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
488 ExistMask += 1;
489 }
490 if (!m_ignoredStripsList->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
491 ExistMask += 1;
492 }
493 }
494 int sTS = 0;
495 if (m_SVDHitMapV[i]->GetBinContent(i2 + 1) > SVDVCut)
496 sTS = 1;
497
498 if (ExistMask || (sTS)) {
499 fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i2);
500 m_SVDMaskV[i]->SetBinContent(i2 + 1, 1 + ExistMask);
501 nMaskedV++;
502 }
503 }
504 fprintf(MaskList, " </side>\n");
505 fprintf(MaskList, " </sensor>\n");
506 TString message = Form("SVD(%i,%i,%i) masked %i U strips in: %s", iLayer, iLadder, iSensor, nMaskedU, ignoredPixelsListName.data());
507 B2INFO(message.Data());
508 message = Form("SVD(%i,%i,%i) masked %i V strips in: %s", iLayer, iLadder, iSensor, nMaskedV, ignoredPixelsListName.data());
509 B2INFO(message.Data());
510 fprintf(MaskList, " </ladder>\n");
511 fprintf(MaskList, " </layer>\n");
512 }
513 fprintf(MaskList, "</SVD>\n");
514 fclose(MaskList);
515
516//------------------------------------------------------------------
517// the same for 2 and more fired samples in strip
518//-----------------------------------------------------------------
519 FileName = str(format("%1%.2samples") % m_SVDMaskFileBasicName);
520 ignoredPixelsListName = str(format("%1%") % FileName);
521 std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsBasicList2 = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
522 ignoredPixelsListName));
523 FileName2 = str(format("%1%.2samples") % m_SVDMaskFileRunName);
524 ignoredPixelsListName2 = str(format("%1%") % FileName2);
525 std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsList2 = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
526 ignoredPixelsListName2));
527 MaskList = fopen(FileName2.data(), "w");
528 if (MaskList == nullptr) {
529 B2ERROR("Cannot open the mask file for writing: " << FileName2);
530 return;
531 }
532 fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
533 fprintf(MaskList, "<Meta>\n");
534 fprintf(MaskList, " <Date>19.02.2018</Date>\n");
535 fprintf(MaskList,
536 " <Description short=\"Ignore strip list for SVD planes for 2-samples and more over charge cut in 2018 VXD phase2 and phase3\">\n");
537 fprintf(MaskList, " Crude initial list of bad strips\n");
538 fprintf(MaskList, " </Description>\n");
539 fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
540 fprintf(MaskList, "</Meta>\n");
541 fprintf(MaskList, "<SVD>\n");
542 for (int i = 0; i < nSVDSensors; i++) {
543 if (m_nEventsPlane[nPXDSensors + i] == 0) continue;
544 VxdID id = gTools->getSensorIDFromSVDIndex(i);
545 int iLayer = id.getLayerNumber();
546 int iLadder = id.getLadderNumber();
547 int iSensor = id.getSensorNumber();
548 fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
549 fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
550 fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
551 fprintf(MaskList, " <side side=\"u\">\n");
552 fprintf(MaskList, " <!-- stripsFromTo fromStrip = \"620\" toStrip = \"767\"></stripsFromTo-->\n");
553 fprintf(MaskList, " <!-- Individual strips can be masked, too -->\n");
554 int nMaskedU = 0;
555 int nMaskedV = 0;
556 for (int i1 = 0; i1 < m_SVDMaskU2[i]->GetNbinsX(); ++i1) {
557 int ExistMask = 0;
558 if (m_AppendMaskFile) {
559 if (!m_ignoredStripsBasicList2->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
560 ExistMask += 1;
561 }
562 if (!m_ignoredStripsList2->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
563 ExistMask += 1;
564 }
565 }
566 int sTS = 0;
567 if (m_SVDHitMapU2[i]->GetBinContent(i1 + 1) > SVDUCut)
568 sTS = 1;
569
570 if (ExistMask || (sTS)) {
571 fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i1);
572 m_SVDMaskU2[i]->SetBinContent(i1 + 1, 1 + ExistMask);
573 nMaskedU++;
574 }
575 }
576 fprintf(MaskList, " </side>\n");
577 fprintf(MaskList, " <side side=\"v\">\n");
578 for (int i2 = 0; i2 < m_SVDMaskV2[i]->GetNbinsX(); ++i2) {
579 int ExistMask = 0;
580 if (m_AppendMaskFile) {
581 if (!m_ignoredStripsBasicList2->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
582 ExistMask += 1;
583 }
584 if (!m_ignoredStripsList2->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
585 ExistMask += 1;
586 }
587 }
588 int sTS = 0;
589 if (m_SVDHitMapV2[i]->GetBinContent(i2 + 1) > SVDVCut)
590 sTS = 1;
591
592 if (ExistMask || (sTS)) {
593 fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i2);
594 m_SVDMaskV2[i]->SetBinContent(i2 + 1, 1 + ExistMask);
595 nMaskedV++;
596 }
597 }
598 fprintf(MaskList, " </side>\n");
599 fprintf(MaskList, " </sensor>\n");
600 TString message = Form("SVD(%i,%i,%i) masked %i U strips in: %s", iLayer, iLadder, iSensor, nMaskedU, ignoredPixelsListName.data());
601 B2INFO(message.Data());
602 message = Form("SVD(%i,%i,%i) masked %i V strips in: %s", iLayer, iLadder, iSensor, nMaskedV, ignoredPixelsListName.data());
603 B2INFO(message.Data());
604 fprintf(MaskList, " </ladder>\n");
605 fprintf(MaskList, " </layer>\n");
606 }
607 fprintf(MaskList, "</SVD>\n");
608 fclose(MaskList);
609 }
610
611}
612
Belle2::HistoModule::HistoModule
HistoModule()
Constructor.
Definition HistoModule.h:32
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
Belle2::Module::c_ParallelProcessingCertified
@ 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
Belle2::PXDDigit
The PXD digit class.
Definition PXDDigit.h:27
Belle2::PXDIgnoredPixelsMap
This class provides a check for ignored (=cold, hot or otherwise deffective) pixels for the use in PX...
Definition PXDIgnoredPixelsMap.h:39
Belle2::PXDIgnoredPixelsMap::map_pixel
std::pair< unsigned short, unsigned short > map_pixel
Simple structure for a pixel, u = map_pixel.first, v = map_pixel.second.
Definition PXDIgnoredPixelsMap.h:42
Belle2::PXD::SensorInfo
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
Definition SensorInfo.h:23
Belle2::SVDIgnoredStripsMap
This class provides a list of ignored (=cold, hot or otherwise deffective) strips for the use in SVD ...
Definition SVDIgnoredStripsMap.h:28
Belle2::SVDShaperDigit
The SVD ShaperDigit class.
Definition SVDShaperDigit.h:32
Belle2::SVDShaperDigit::c_nAPVSamples
static const std::size_t c_nAPVSamples
Number of APV samples stored.
Definition SVDShaperDigit.h:37
Belle2::SVDShaperDigit::APVFloatSamples
std::array< APVFloatSampleType, c_nAPVSamples > APVFloatSamples
array of APVFloatSampleType objects
Definition SVDShaperDigit.h:49
Belle2::SVD::SensorInfo
Specific implementation of SensorInfo for SVD Sensors which provides additional sensor specific infor...
Definition SensorInfo.h:25
Belle2::StoreAccessorBase::getName
const std::string & getName() const
Return name under which the object is saved in the DataStore.
Definition StoreAccessorBase.h:128
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition StoreArray.h:113
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition StoreArray.h:216
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a reference to the SensorInfo of a given SensorID.
Definition GeoCache.cc:67
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition GeoCache.cc:214
Belle2::VXD::GeoCache::getGeoTools
const GeoTools * getGeoTools()
Return a raw pointer to a GeoTools object.
Definition GeoCache.h:141
Belle2::VXD::GeoTools::getNumberOfPXDSensors
unsigned short getNumberOfPXDSensors() const
Get number of PXD sensors.
Definition GeoTools.h:133
Belle2::VXD::SensorInfoBase::getVCells
int getVCells() const
Return number of pixel/strips in v direction.
Definition SensorInfoBase.h:216
Belle2::VXD::SensorInfoBase::getUCells
int getUCells() const
Return number of pixel/strips in u direction.
Definition SensorInfoBase.h:214
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:32
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition VxdID.h:95
Belle2::vxdDigitMaskingModule::initialize
void initialize() override final
Initialize.
Definition vxdDigitMaskingModule.cc:215
Belle2::vxdDigitMaskingModule::m_SVDvChargeCut
float m_SVDvChargeCut
Cut for charge of SVD v strip - in ADU.
Definition vxdDigitMaskingModule.h:81
Belle2::vxdDigitMaskingModule::m_nEventsProcess
long m_nEventsProcess
Number of events to process.
Definition vxdDigitMaskingModule.h:66
Belle2::vxdDigitMaskingModule::m_SVDHitMapV
TH1F ** m_SVDHitMapV
SVD hitmaps for v strips and timestamp by plane.
Definition vxdDigitMaskingModule.h:98
Belle2::vxdDigitMaskingModule::m_PXDMaskFileRunName
std::string m_PXDMaskFileRunName
Name of file with list of PXD masked channels.
Definition vxdDigitMaskingModule.h:61
Belle2::vxdDigitMaskingModule::m_SVDHitMapU2
TH1F ** m_SVDHitMapU2
SVD hitmaps for u strips and timestamp by plane.
Definition vxdDigitMaskingModule.h:104
Belle2::vxdDigitMaskingModule::m_nEventsPlane
long * m_nEventsPlane
How many events in plane.
Definition vxdDigitMaskingModule.h:72
Belle2::vxdDigitMaskingModule::defineHisto
void defineHisto() override final
Histogram definitions such as TH1(), TH2(), TNtuple(), TTree()....
Definition vxdDigitMaskingModule.cc:83
Belle2::vxdDigitMaskingModule::m_PXDCut
float m_PXDCut
Cut for masking of PXD pixel - preset for 1 kEvent.
Definition vxdDigitMaskingModule.h:84
Belle2::vxdDigitMaskingModule::m_PXDMaskUV
TH2F ** m_PXDMaskUV
mask for pixels by PXD plane
Definition vxdDigitMaskingModule.h:93
Belle2::vxdDigitMaskingModule::m_SVDMaskFileBasicName
std::string m_SVDMaskFileBasicName
Name of file with list of SVD basic masked channels.
Definition vxdDigitMaskingModule.h:59
Belle2::vxdDigitMaskingModule::event
void event() override final
Event.
Definition vxdDigitMaskingModule.cc:247
Belle2::vxdDigitMaskingModule::m_AppendMaskFile
int m_AppendMaskFile
Set option for append of existing file or recreate new list.
Definition vxdDigitMaskingModule.h:74
Belle2::vxdDigitMaskingModule::m_storeSVDShaperDigitsName
std::string m_storeSVDShaperDigitsName
SVDShaperDigits StoreArray name.
Definition vxdDigitMaskingModule.h:53
Belle2::vxdDigitMaskingModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
directory of histograms name
Definition vxdDigitMaskingModule.h:49
Belle2::vxdDigitMaskingModule::m_SVDMaskFileRunName
std::string m_SVDMaskFileRunName
Name of file with list of SVD masked channels.
Definition vxdDigitMaskingModule.h:63
Belle2::vxdDigitMaskingModule::m_SVDuChargeCut
float m_SVDuChargeCut
Cut for charge of SVD u strip - in ADU.
Definition vxdDigitMaskingModule.h:79
Belle2::vxdDigitMaskingModule::m_PXDMaskFileBasicName
std::string m_PXDMaskFileBasicName
Name of file with list of PXD basic masked channels.
Definition vxdDigitMaskingModule.h:57
Belle2::vxdDigitMaskingModule::m_SVDMaskV
TH1F ** m_SVDMaskV
SVD mask for v strips by plane.
Definition vxdDigitMaskingModule.h:102
Belle2::vxdDigitMaskingModule::m_nRealEventsProcess
long m_nRealEventsProcess
Real Number of events to process.
Definition vxdDigitMaskingModule.h:68
Belle2::vxdDigitMaskingModule::m_SVDMaskU2
TH1F ** m_SVDMaskU2
SVD mask for u strips by plane.
Definition vxdDigitMaskingModule.h:108
Belle2::vxdDigitMaskingModule::endRun
void endRun() override final
End run.
Definition vxdDigitMaskingModule.cc:320
Belle2::vxdDigitMaskingModule::m_PXDHitMapUV
TH2F ** m_PXDHitMapUV
Hitmaps for pixels by PXD plane.
Definition vxdDigitMaskingModule.h:91
Belle2::vxdDigitMaskingModule::m_SVDHitMapU
TH1F ** m_SVDHitMapU
SVD hitmaps for u strips and timestamp by plane.
Definition vxdDigitMaskingModule.h:96
Belle2::vxdDigitMaskingModule::beginRun
void beginRun() override final
Begin run.
Definition vxdDigitMaskingModule.cc:235
Belle2::vxdDigitMaskingModule::m_SVDHitMapV2
TH1F ** m_SVDHitMapV2
SVD hitmaps for v strips and timestamp by plane.
Definition vxdDigitMaskingModule.h:106
Belle2::vxdDigitMaskingModule::m_SVDvCut
float m_SVDvCut
Cut for masking of SVD v strip - preset for 1 kEvent.
Definition vxdDigitMaskingModule.h:88
Belle2::vxdDigitMaskingModule::m_PXDChargeCut
float m_PXDChargeCut
Cut for charge of PXD pixel - in ADU.
Definition vxdDigitMaskingModule.h:77
Belle2::vxdDigitMaskingModule::m_SVDMaskV2
TH1F ** m_SVDMaskV2
SVD mask for v strips by plane.
Definition vxdDigitMaskingModule.h:110
Belle2::vxdDigitMaskingModule::m_SVDuCut
float m_SVDuCut
Cut for masking of SVD u strip - preset for 1 kEvent.
Definition vxdDigitMaskingModule.h:86
Belle2::vxdDigitMaskingModule::m_nEventsProcessFraction
float m_nEventsProcessFraction
Fraction of events to process to expected No.
Definition vxdDigitMaskingModule.h:70
Belle2::vxdDigitMaskingModule::m_SVDMaskU
TH1F ** m_SVDMaskU
SVD mask for u strips by plane.
Definition vxdDigitMaskingModule.h:100
Belle2::vxdDigitMaskingModule::m_storePXDDigitsName
std::string m_storePXDDigitsName
PXDDigits StoreArray name.
Definition vxdDigitMaskingModule.h:51
Belle2::Module::addParam
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
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.