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