Belle II Software  release-06-02-00
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 
29 using namespace std;
30 using boost::format;
31 using namespace Belle2;
32 
33 //-----------------------------------------------------------------
34 // Register the Module
35 //-----------------------------------------------------------------
36 REG_MODULE(vxdDigitMasking)
37 
38 
39 //-----------------------------------------------------------------
40 // Implementation
41 //-----------------------------------------------------------------
42 
43 vxdDigitMaskingModule::vxdDigitMaskingModule() : HistoModule()
44 {
45  //Set module properties
46  setDescription("vxdDigitMasking of pixels and strips in PXD and SVD base on their fireing");
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 
75 vxdDigitMaskingModule::~vxdDigitMaskingModule()
76 {
77 }
78 
79 //------------------------------------------------------------------
80 // Function to define histograms
81 //-----------------------------------------------------------------
82 
83 void 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 skiped.");
92  }
93  if (gTools->getNumberOfSVDLayers() == 0) {
94  B2WARNING("Missing geometry for SVD, SVD-masking is skiped.");
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::get(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::get(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 
215 void 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 
235 void 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 
247 void vxdDigitMaskingModule::event()
248 {
249  m_nRealEventsProcess++;
250  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
251  int nPXDSensors = gTools->getNumberOfPXDSensors();
252  if (gTools->getNumberOfPXDLayers() != 0) {
253  const StoreArray<PXDDigit> storePXDDigits(m_storePXDDigitsName);
254  // If there are no digits, leave
255  if (storePXDDigits && storePXDDigits.getEntries()) {
256  int firstPXDLayer = gTools->getFirstPXDLayer();
257  int lastPXDLayer = gTools->getLastPXDLayer();
258 
259  for (const PXDDigit& digit : storePXDDigits) {
260  if (digit.getCharge() < m_PXDChargeCut) continue;
261  int iLayer = digit.getSensorID().getLayerNumber();
262  if ((iLayer < firstPXDLayer) || (iLayer > lastPXDLayer)) continue;
263  int iLadder = digit.getSensorID().getLadderNumber();
264  int iSensor = digit.getSensorID().getSensorNumber();
265  VxdID sensorID(iLayer, iLadder, iSensor);
266  int index = gTools->getPXDSensorIndex(sensorID);
267  if (m_PXDHitMapUV[index] != NULL) m_PXDHitMapUV[index]->Fill(digit.getUCellID(), digit.getVCellID());
268  m_nEventsPlane[index]++;
269  }
270  }
271  }
272  if (gTools->getNumberOfSVDLayers() != 0) {
273  const StoreArray<SVDShaperDigit> storeSVDDigits(m_storeSVDShaperDigitsName);
274  // If there are no digits, leave
275  if (storeSVDDigits && storeSVDDigits.getEntries()) {
276  int firstSVDLayer = gTools->getFirstSVDLayer();
277  int lastSVDLayer = gTools->getLastSVDLayer();
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 
320 void 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 proces 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  int nSVDSensors = gTools->getNumberOfSVDSensors();
347  if (gTools->getNumberOfPXDLayers() != 0) {
348  TString message = Form("Start to create masking from %i events (fraction: %6.3f)", (int)m_nRealEventsProcess,
349  m_nEventsProcessFraction);
350  B2INFO(message.Data());
351 
352  std::string FileName = str(format("%1%") % m_PXDMaskFileBasicName);
353  std::string ignoredPixelsListName = str(format("%1%") % FileName);
354  std::unique_ptr<PXDIgnoredPixelsMap> m_ignoredPixelsBasicList = unique_ptr<PXDIgnoredPixelsMap>(new PXDIgnoredPixelsMap(
355  ignoredPixelsListName));
356  FileName = str(format("%1%") % m_PXDMaskFileRunName);
357  ignoredPixelsListName = str(format("%1%") % FileName);
358  std::unique_ptr<PXDIgnoredPixelsMap> m_ignoredPixelsList = unique_ptr<PXDIgnoredPixelsMap>(new PXDIgnoredPixelsMap(
359  ignoredPixelsListName));
360  MaskList = fopen(FileName.data(), "w");
361  fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
362  fprintf(MaskList, "<Meta>\n");
363  fprintf(MaskList, " <Date>19.02.2018</Date>\n");
364  fprintf(MaskList, " <Description short=\"Ignore strip list for PXD planes in 2018 VXD phase2 and phase3\">\n");
365  fprintf(MaskList, " Crude initial list of bad pixels\n");
366  fprintf(MaskList, " </Description>\n");
367  fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
368  fprintf(MaskList, "</Meta>\n");
369  fprintf(MaskList, "<PXD>\n");
370  for (int i = 0; i < nPXDSensors; i++) {
371  if (m_nEventsPlane[i] == 0) continue;
372  VxdID id = gTools->getSensorIDFromPXDIndex(i);
373  int iLayer = id.getLayerNumber();
374  int iLadder = id.getLadderNumber();
375  int iSensor = id.getSensorNumber();
376  fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
377  fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
378  fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
379  fprintf(MaskList, " <!-- vxdDigitMasking rectangular parts of the sensor -->\n");
380  fprintf(MaskList, " <!--pixels uStart = \"070\" uEnd = \"110\" vStart = \"0\" vEnd = \"500\"></pixels-->\n");
381  fprintf(MaskList, "\n");
382  fprintf(MaskList, " <!-- Individual pixels can be masked, too -->\n");
383  fprintf(MaskList, " <!--pixels uStart = \"130\" vStart = \"500\"></pixels-->\n");
384  fprintf(MaskList, "\n");
385  fprintf(MaskList, " <!-- ROW is V / COLUMN is U -->\n");
386  fprintf(MaskList, "\n");
387  fprintf(MaskList, " <!-- Individual rows and columns can be masked, too -->\n");
388  fprintf(MaskList, " <!--pixels vStart = \"500\"></pixels-->\n");
389  fprintf(MaskList, " <!--pixels uStart = \"120\"></pixels-->\n");
390  fprintf(MaskList, "\n");
391  fprintf(MaskList, " <!-- Ranges of rows and columns can be masked, too -->\n");
392  fprintf(MaskList, " <!--pixels vStart = \"100\" vEnd = \"120\"></pixels-->\n");
393  fprintf(MaskList, " <!--pixels uStart = \"120\" uEnd = \"202\"></pixels-->\n");
394  fprintf(MaskList, "\n");
395  int nMasked = 0;
396  for (int i1 = 0; i1 < m_PXDMaskUV[i]->GetNbinsX(); ++i1) {
397  for (int i2 = 0; i2 < m_PXDMaskUV[i]->GetNbinsY(); ++i2) {
398  int ExistMask = 0;
399  if (m_AppendMaskFile) {
400  if (!m_ignoredPixelsBasicList->pixelOK(VxdID(iLayer, iLadder, iSensor), PXDIgnoredPixelsMap::map_pixel(i1, i2))) {
401  ExistMask += 1;
402  }
403  if (!m_ignoredPixelsList->pixelOK(VxdID(iLayer, iLadder, iSensor), PXDIgnoredPixelsMap::map_pixel(i1, i2))) {
404  ExistMask += 1;
405  }
406  }
407  if (ExistMask || (m_PXDHitMapUV[i]->GetBinContent(i1 + 1, i2 + 1) > PXDCut)) {
408  fprintf(MaskList, " <pixels uStart = \"%04i\" vStart = \"%04i\"></pixels>\n", i1, i2);
409  m_PXDMaskUV[i]->SetBinContent(i1 + 1, i2 + 1, 1 + ExistMask);
410  nMasked++;
411  }
412  }
413  }
414  fprintf(MaskList, "\n");
415  fprintf(MaskList, " </sensor>\n");
416  fprintf(MaskList, " </ladder>\n");
417  fprintf(MaskList, " </layer>\n");
418  }
419  fprintf(MaskList, "</PXD>\n");
420  fclose(MaskList);
421  }
422 
423  if (gTools->getNumberOfSVDLayers() != 0) {
424  std::string FileName = str(format("%1%") % m_SVDMaskFileBasicName);
425  std::string ignoredPixelsListName = str(format("%1%") % FileName);
426  std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsBasicList = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
427  ignoredPixelsListName));
428  string FileName2 = str(format("%1%") % m_SVDMaskFileRunName);
429  string ignoredPixelsListName2 = str(format("%1%") % FileName2);
430  std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsList = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
431  ignoredPixelsListName2));
432  MaskList = fopen(FileName2.data(), "w");
433  fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
434  fprintf(MaskList, "<Meta>\n");
435  fprintf(MaskList, " <Date>19.02.2018</Date>\n");
436  fprintf(MaskList, " <Description short=\"Ignore strip list for SVD planes in 2018 VXD phase2 and phase3\">\n");
437  fprintf(MaskList, " Crude initial list of bad strips\n");
438  fprintf(MaskList, " </Description>\n");
439  fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
440  fprintf(MaskList, "</Meta>\n");
441  fprintf(MaskList, "<SVD>\n");
442  for (int i = 0; i < nSVDSensors; i++) {
443  if (m_nEventsPlane[nPXDSensors + i] == 0) continue;
444  VxdID id = gTools->getSensorIDFromSVDIndex(i);
445  int iLayer = id.getLayerNumber();
446  int iLadder = id.getLadderNumber();
447  int iSensor = id.getSensorNumber();
448  fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
449  fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
450  fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
451  fprintf(MaskList, " <side side=\"u\">\n");
452  fprintf(MaskList, " <!-- stripsFromTo fromStrip = \"620\" toStrip = \"767\"></stripsFromTo-->\n");
453  fprintf(MaskList, " <!-- Individual strips can be masked, too -->\n");
454  int nMaskedU = 0;
455  int nMaskedV = 0;
456  for (int i1 = 0; i1 < m_SVDMaskU[i]->GetNbinsX(); ++i1) {
457  int ExistMask = 0;
458  if (m_AppendMaskFile) {
459  if (!m_ignoredStripsBasicList->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
460  ExistMask += 1;
461  }
462  if (!m_ignoredStripsList->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
463  ExistMask += 1;
464  }
465  }
466  int sTS = 0;
467  if (m_SVDHitMapU[i]->GetBinContent(i1 + 1) > SVDUCut)
468  sTS = 1;
469 
470  if (ExistMask || (sTS)) {
471  fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i1);
472  m_SVDMaskU[i]->SetBinContent(i1 + 1, 1 + ExistMask);
473  nMaskedU++;
474  }
475  }
476  fprintf(MaskList, " </side>\n");
477  fprintf(MaskList, " <side side=\"v\">\n");
478  for (int i2 = 0; i2 < m_SVDMaskV[i]->GetNbinsX(); ++i2) {
479  int ExistMask = 0;
480  if (m_AppendMaskFile) {
481  if (!m_ignoredStripsBasicList->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
482  ExistMask += 1;
483  }
484  if (!m_ignoredStripsList->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
485  ExistMask += 1;
486  }
487  }
488  int sTS = 0;
489  if (m_SVDHitMapV[i]->GetBinContent(i2 + 1) > SVDVCut)
490  sTS = 1;
491 
492  if (ExistMask || (sTS)) {
493  fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i2);
494  m_SVDMaskV[i]->SetBinContent(i2 + 1, 1 + ExistMask);
495  nMaskedV++;
496  }
497  }
498  fprintf(MaskList, " </side>\n");
499  fprintf(MaskList, " </sensor>\n");
500  TString message = Form("SVD(%i,%i,%i) masked %i U strips in: %s", iLayer, iLadder, iSensor, nMaskedU, ignoredPixelsListName.data());
501  B2INFO(message.Data());
502  message = Form("SVD(%i,%i,%i) masked %i V strips in: %s", iLayer, iLadder, iSensor, nMaskedV, ignoredPixelsListName.data());
503  B2INFO(message.Data());
504  fprintf(MaskList, " </ladder>\n");
505  fprintf(MaskList, " </layer>\n");
506  }
507  fprintf(MaskList, "</SVD>\n");
508  fclose(MaskList);
509 
510 //------------------------------------------------------------------
511 // the same for 2 and more fired samples in strip
512 //-----------------------------------------------------------------
513  FileName = str(format("%1%.2samples") % m_SVDMaskFileBasicName);
514  ignoredPixelsListName = str(format("%1%") % FileName);
515  std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsBasicList2 = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
516  ignoredPixelsListName));
517  FileName2 = str(format("%1%.2samples") % m_SVDMaskFileRunName);
518  ignoredPixelsListName2 = str(format("%1%") % FileName2);
519  std::unique_ptr<SVDIgnoredStripsMap> m_ignoredStripsList2 = unique_ptr<SVDIgnoredStripsMap>(new SVDIgnoredStripsMap(
520  ignoredPixelsListName2));
521  MaskList = fopen(FileName2.data(), "w");
522  fprintf(MaskList, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
523  fprintf(MaskList, "<Meta>\n");
524  fprintf(MaskList, " <Date>19.02.2018</Date>\n");
525  fprintf(MaskList,
526  " <Description short=\"Ignore strip list for SVD planes for 2-samples and more over charge cut in 2018 VXD phase2 and phase3\">\n");
527  fprintf(MaskList, " Crude initial list of bad strips\n");
528  fprintf(MaskList, " </Description>\n");
529  fprintf(MaskList, " <Author>Peter Kodys</Author>\n");
530  fprintf(MaskList, "</Meta>\n");
531  fprintf(MaskList, "<SVD>\n");
532  for (int i = 0; i < nSVDSensors; i++) {
533  if (m_nEventsPlane[nPXDSensors + i] == 0) continue;
534  VxdID id = gTools->getSensorIDFromSVDIndex(i);
535  int iLayer = id.getLayerNumber();
536  int iLadder = id.getLadderNumber();
537  int iSensor = id.getSensorNumber();
538  fprintf(MaskList, " <layer n=\"%i\">\n", iLayer);
539  fprintf(MaskList, " <ladder n=\"%i\">\n", iLadder);
540  fprintf(MaskList, " <sensor n=\"%i\">\n", iSensor);
541  fprintf(MaskList, " <side side=\"u\">\n");
542  fprintf(MaskList, " <!-- stripsFromTo fromStrip = \"620\" toStrip = \"767\"></stripsFromTo-->\n");
543  fprintf(MaskList, " <!-- Individual strips can be masked, too -->\n");
544  int nMaskedU = 0;
545  int nMaskedV = 0;
546  for (int i1 = 0; i1 < m_SVDMaskU2[i]->GetNbinsX(); ++i1) {
547  int ExistMask = 0;
548  if (m_AppendMaskFile) {
549  if (!m_ignoredStripsBasicList2->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
550  ExistMask += 1;
551  }
552  if (!m_ignoredStripsList2->stripOK(VxdID(iLayer, iLadder, iSensor, 1), (unsigned short) i1)) {
553  ExistMask += 1;
554  }
555  }
556  int sTS = 0;
557  if (m_SVDHitMapU2[i]->GetBinContent(i1 + 1) > SVDUCut)
558  sTS = 1;
559 
560  if (ExistMask || (sTS)) {
561  fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i1);
562  m_SVDMaskU2[i]->SetBinContent(i1 + 1, 1 + ExistMask);
563  nMaskedU++;
564  }
565  }
566  fprintf(MaskList, " </side>\n");
567  fprintf(MaskList, " <side side=\"v\">\n");
568  for (int i2 = 0; i2 < m_SVDMaskV2[i]->GetNbinsX(); ++i2) {
569  int ExistMask = 0;
570  if (m_AppendMaskFile) {
571  if (!m_ignoredStripsBasicList2->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
572  ExistMask += 1;
573  }
574  if (!m_ignoredStripsList2->stripOK(VxdID(iLayer, iLadder, iSensor, 0), (unsigned short) i2)) {
575  ExistMask += 1;
576  }
577  }
578  int sTS = 0;
579  if (m_SVDHitMapV2[i]->GetBinContent(i2 + 1) > SVDVCut)
580  sTS = 1;
581 
582  if (ExistMask || (sTS)) {
583  fprintf(MaskList, " <strip stripNo = \"%i\"></strip>\n", i2);
584  m_SVDMaskV2[i]->SetBinContent(i2 + 1, 1 + ExistMask);
585  nMaskedV++;
586  }
587  }
588  fprintf(MaskList, " </side>\n");
589  fprintf(MaskList, " </sensor>\n");
590  TString message = Form("SVD(%i,%i,%i) masked %i U strips in: %s", iLayer, iLadder, iSensor, nMaskedU, ignoredPixelsListName.data());
591  B2INFO(message.Data());
592  message = Form("SVD(%i,%i,%i) masked %i V strips in: %s", iLayer, iLadder, iSensor, nMaskedV, ignoredPixelsListName.data());
593  B2INFO(message.Data());
594  fprintf(MaskList, " </ladder>\n");
595  fprintf(MaskList, " </layer>\n");
596  }
597  fprintf(MaskList, "</SVD>\n");
598  fclose(MaskList);
599  }
600 
601 }
602 
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
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::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::SensorInfoBase::getVCells
int getVCells() const
Return number of pixel/strips in v direction.
Definition: SensorInfoBase.h:217
Belle2::VXD::SensorInfoBase::getUCells
int getUCells() const
Return number of pixel/strips in u direction.
Definition: SensorInfoBase.h:215
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:96
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17