Belle II Software  release-05-01-25
BeamBkgMixerModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Marko Staric *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 // Own include
12 #include <background/modules/BeamBkgMixer/BeamBkgMixerModule.h>
13 
14 
15 
16 // framework - DataStore
17 #include <framework/datastore/DataStore.h>
18 #include <framework/datastore/StoreArray.h>
19 #include <framework/datastore/StoreObjPtr.h>
20 #include <framework/datastore/RelationArray.h>
21 
22 // framework aux
23 #include <framework/core/ModuleParam.templateDetails.h>
24 #include <framework/logging/Logger.h>
25 
26 // SimHits
27 #include <pxd/dataobjects/PXDSimHit.h>
28 #include <svd/dataobjects/SVDSimHit.h>
29 #include <cdc/dataobjects/CDCSimHit.h>
30 #include <top/dataobjects/TOPSimHit.h>
31 #include <arich/dataobjects/ARICHSimHit.h>
32 #include <ecl/dataobjects/ECLHit.h>
33 #include <klm/dataobjects/bklm/BKLMSimHit.h>
34 #include <klm/dataobjects/eklm/EKLMSimHit.h>
35 #include <simulation/dataobjects/BeamBackHit.h>
36 
37 // MetaData
38 #include <framework/dataobjects/EventMetaData.h>
39 #include <framework/dataobjects/BackgroundInfo.h>
40 
41 // Root
42 #include <TFile.h>
43 #include <TRandom3.h>
44 
45 //std::find
46 #include <algorithm>
47 
48 using namespace std;
49 
50 namespace Belle2 {
56  //-----------------------------------------------------------------
57  // Register module
58  //-----------------------------------------------------------------
59 
60  REG_MODULE(BeamBkgMixer)
61 
62  //-----------------------------------------------------------------
63  // Implementation
64  //-----------------------------------------------------------------
65 
66  BeamBkgMixerModule::BeamBkgMixerModule() : Module()
67  {
68  // set module description (e.g. insert text)
69  setDescription("Beam background mixer at SimHit level that uses beam background"
70  " simulation output directly (collision files) and not ROF files. "
71  "Each background event is shifted in time randomly within "
72  "a time window specified with minTime and maxTime.");
73 
74  // Add parameters
75  addParam("backgroundFiles", m_backgroundFiles,
76  "List of background (collision) files (wildcards not allowed - "
77  "use python glob.glob() to expand to list of files)");
78  addParam("minTime", m_minTime,
79  "Time window lower edge in nano seconds", -1000.0);
80  addParam("maxTime", m_maxTime,
81  "Time window upper edge in nano seconds", 800.0);
82  addParam("overallScaleFactor", m_overallScaleFactor,
83  "Overall factor to scale rates of backgrounds", 1.0);
84  addParam("scaleFactors", m_scaleFactors,
85  "Factors to scale rates of backgrounds. "
86  "Possible tag names: " + m_bgTypes.getBGTypes(),
87  m_scaleFactors);
88  addParam("components", m_components,
89  "Detector components to be included, empty list means all components",
90  m_components);
91  addParam("wrapAround", m_wrapAround,
92  "if true wrap around events passing time window upper edge", true);
93  addParam("minTimeECL", m_minTimeECL,
94  "Time window lower edge for ECL in nano seconds", -17600.0);
95  addParam("maxTimeECL", m_maxTimeECL,
96  "Time window upper edge for ECL in nano seconds", 8500.0);
97  addParam("minTimePXD", m_minTimePXD,
98  "Time window lower edge for PXD in nano seconds", -10000.0);
99  addParam("maxTimePXD", m_maxTimePXD,
100  "Time window upper edge for PXD in nano seconds", 10000.0);
101 
102  addParam("beambackhits", m_BeamBackHits,
103  "If true also add the BeamBackHits collection for the selected "
104  "subdetectors to the output file", false);
105 
106  addParam("maxEdepECL", m_maxEdepECL,
107  "maximal deposited energy of ECLHit to accept BG event for mixing"
108  "(0 means accept all events)", 1.0);
109 
110  addParam("cacheSize", m_cacheSize,
111  "file cache size in Mbytes. If negative, use root default", 0);
112  }
113 
114  BeamBkgMixerModule::~BeamBkgMixerModule()
115  {
116  }
117 
118  void BeamBkgMixerModule::initialize()
119  {
120 
121  // included components
122 
123  std::vector<std::string> components = m_components;
124  m_PXD = isComponentIncluded(components, "PXD");
125  m_SVD = isComponentIncluded(components, "SVD");
126  m_CDC = isComponentIncluded(components, "CDC");
127  m_TOP = isComponentIncluded(components, "TOP");
128  m_ARICH = isComponentIncluded(components, "ARICH");
129  m_ECL = isComponentIncluded(components, "ECL");
130  m_KLM = isComponentIncluded(components, "KLM");
131 
132  // ignore these ones
133 
134  isComponentIncluded(components, "MagneticField2d");
135  isComponentIncluded(components, "MagneticField3d");
136  isComponentIncluded(components, "MagneticField");
137  isComponentIncluded(components, "MagneticFieldConstant4LimitedRCDC");
138  isComponentIncluded(components, "MagneticFieldConstant4LimitedRSVD");
139  isComponentIncluded(components, "BeamPipe");
140  isComponentIncluded(components, "Cryostat");
141  isComponentIncluded(components, "FarBeamLine");
142  isComponentIncluded(components, "HeavyMetalShield");
143  isComponentIncluded(components, "COIL");
144  isComponentIncluded(components, "STR");
145  isComponentIncluded(components, "VXDService");
146 
147  if (!components.empty()) {
148  std::string str;
149  for (unsigned i = 0; i < components.size(); ++i) str = str + " " + components[i];
150  B2WARNING("Unknown components:" << str);
151  }
152 
153  // check files and append them to sample container
154 
155  for (auto file : m_backgroundFiles) {
156 
157  // wildcarding is not allowed anymore
158  if (TString(file.c_str()).Contains("*")) {
159  B2ERROR(file << ": wildcards are not allowed");
160  continue;
161  }
162 
163  // check the file existance
164  TFile* f = TFile::Open(file.c_str(), "READ");
165  if (!f) {
166  B2ERROR(file << ": file not found");
167  continue;
168  }
169  if (!f->IsOpen()) {
170  B2ERROR(file << ": can't open file");
171  continue;
172  }
173  f->Close();
174 
175  TChain persistent("persistent");
176  int nFiles = persistent.Add(file.c_str());
177  if (nFiles == 0) {
178  B2ERROR(file << ": no such files");
179  continue;
180  }
181  if (persistent.GetEntries() == 0) {
182  B2ERROR(file << ": tree 'persistent' has no entries");
183  continue;
184  }
185 
186  TObject* bkgMetaData = 0; // Note: allocation left to root
187  TBranch* branchBMD = persistent.GetBranch("BackgroundMetaData");
188  if (!branchBMD) {
189  B2ERROR(file << ": branch 'BackgroundMetaData' not found");
190  continue;
191  }
192  branchBMD->SetAddress(&bkgMetaData);
193 
194  std::vector<BackgroundMetaData::BG_TAG> tags;
195  std::vector<std::string> types;
196  std::vector<BackgroundMetaData::EFileType> fileTypes;
197  double realTime = 0;
198  for (unsigned k = 0; k < persistent.GetEntries(); k++) {
199  persistent.GetEntry(k);
200  BackgroundMetaData* bgMD = static_cast<BackgroundMetaData*>(bkgMetaData);
201  tags.push_back(bgMD->getBackgroundTag());
202  types.push_back(bgMD->getBackgroundType());
203  fileTypes.push_back(bgMD->getFileType());
204  realTime += bgMD->getRealTime();
205  }
206  if (realTime <= 0) {
207  B2ERROR(file << ": invalid realTime: " << realTime);
208  continue;
209  }
210  for (unsigned i = 1; i < tags.size(); ++i) {
211  if (tags[i] != tags[0]) {
212  B2ERROR(file << ": files with mixed background types not supported");
213  continue;
214  }
215  }
216  for (unsigned i = 1; i < fileTypes.size(); ++i) {
217  if (fileTypes[i] != fileTypes[0]) {
218  B2ERROR(file << ": files with mixed file types not supported");
219  continue;
220  }
221  }
222 
223  appendSample(tags[0], types[0], file, realTime, fileTypes[0]);
224 
225  }
226 
227 
228  // set scale factors
229 
230  for (auto scaleFactor : m_scaleFactors) {
231  std::string type = std::get<0>(scaleFactor);
232  if (m_bgTypes.getTag(type) == 0)
233  B2ERROR("Unknown beam background type found in 'scaleFactors': " << type << "\n"
234  "Possible are: " + m_bgTypes.getBGTypes());
235  for (auto& bkg : m_backgrounds) {
236  if (bkg.type.find(type) != std::string::npos)
237  bkg.scaleFactor *= std::get<1>(scaleFactor);
238  }
239  }
240 
241  // open files for reading SimHits
242 
243  for (auto& bkg : m_backgrounds) {
244 
245  // define TChain for reading SimHits
246  bkg.tree.reset(new TChain("tree"));
247  for (unsigned i = 0; i < bkg.fileNames.size(); ++i) {
248  bkg.numFiles += bkg.tree->Add(bkg.fileNames[i].c_str());
249  }
250 
251  bkg.numEvents = bkg.tree->GetEntries();
252  bkg.rate = bkg.numEvents / bkg.realTime * bkg.scaleFactor;
253 
254  if (m_cacheSize >= 0) bkg.tree->SetCacheSize(m_cacheSize * 1024 * 1024);
255 
256  if (m_PXD and bkg.tree->GetBranch("PXDSimHits"))
257  bkg.tree->SetBranchAddress("PXDSimHits", &m_simHits.PXD);
258  if (m_SVD and bkg.tree->GetBranch("SVDSimHits"))
259  bkg.tree->SetBranchAddress("SVDSimHits", &m_simHits.SVD);
260  if (m_CDC and bkg.tree->GetBranch("CDCSimHits"))
261  bkg.tree->SetBranchAddress("CDCSimHits", &m_simHits.CDC);
262  if (m_TOP and bkg.tree->GetBranch("TOPSimHits"))
263  bkg.tree->SetBranchAddress("TOPSimHits", &m_simHits.TOP);
264  if (m_ARICH and bkg.tree->GetBranch("ARICHSimHits"))
265  bkg.tree->SetBranchAddress("ARICHSimHits", &m_simHits.ARICH);
266  if (m_ECL and bkg.tree->GetBranch("ECLHits"))
267  bkg.tree->SetBranchAddress("ECLHits", &m_simHits.ECL);
268  if (m_KLM and bkg.tree->GetBranch("BKLMSimHits"))
269  bkg.tree->SetBranchAddress("BKLMSimHits", &m_simHits.BKLM);
270  if (m_KLM and bkg.tree->GetBranch("EKLMSimHits"))
271  bkg.tree->SetBranchAddress("EKLMSimHits", &m_simHits.EKLM);
272 
273  if (m_BeamBackHits and bkg.tree->GetBranch("BeamBackHits"))
274  bkg.tree->SetBranchAddress("BeamBackHits", &m_simHits.BeamBackHits);
275 
276  // print INFO
277  std::string unit(" ns");
278  double realTime = bkg.realTime;
279  if (realTime >= 1000.0) {realTime /= 1000.0; unit = " us";}
280  if (realTime >= 1000.0) {realTime /= 1000.0; unit = " ms";}
281  if (realTime >= 1000.0) {realTime /= 1000.0; unit = " s";}
282 
283  B2INFO("BeamBkgMixer: " << bkg.type <<
284  " files=" << bkg.numFiles <<
285  " events=" << bkg.numEvents <<
286  " realTime=" << realTime << unit <<
287  " scaleFactor=" << bkg.scaleFactor <<
288  " rate=" << bkg.rate * 1000 << " MHz");
289  }
290 
291 
292  // SimHits registration
293 
294  StoreArray<PXDSimHit> pxdSimHits;
295  if (m_PXD) pxdSimHits.registerInDataStore();
296 
297  StoreArray<SVDSimHit> svdSimHits;
298  if (m_SVD) svdSimHits.registerInDataStore();
299 
300  StoreArray<CDCSimHit> cdcSimHits;
301  if (m_CDC) cdcSimHits.registerInDataStore();
302 
303  StoreArray<TOPSimHit> topSimHits;
304  if (m_TOP) topSimHits.registerInDataStore();
305 
306  StoreArray<ARICHSimHit> arichSimHits;
307  if (m_ARICH) arichSimHits.registerInDataStore();
308 
309  StoreArray<ECLHit> eclHits;
310  if (m_ECL) eclHits.registerInDataStore();
311 
312  StoreArray<BKLMSimHit> bklmSimHits;
313  if (m_KLM) bklmSimHits.registerInDataStore();
314 
315  StoreArray<EKLMSimHit> eklmSimHits;
316  if (m_KLM) eklmSimHits.registerInDataStore();
317 
318  StoreArray<BeamBackHit> beamBackHits;
319  if (m_BeamBackHits) beamBackHits.registerInDataStore();
320 
321 
322  // add BackgroundInfo to persistent tree
323 
324  StoreObjPtr<BackgroundInfo> bkgInfo("", DataStore::c_Persistent);
325  bkgInfo.registerInDataStore();
326  bkgInfo.create();
327  bkgInfo->setMethod(BackgroundInfo::c_Mixing);
328  bkgInfo->setComponents(m_components);
329  bkgInfo->setMinTime(m_minTime);
330  bkgInfo->setMaxTime(m_maxTime);
331  bkgInfo->setMinTimeECL(m_minTimeECL);
332  bkgInfo->setMaxTimeECL(m_maxTimeECL);
333  bkgInfo->setMinTimePXD(m_minTimePXD);
334  bkgInfo->setMaxTimePXD(m_maxTimePXD);
335  bkgInfo->setWrapAround(m_wrapAround);
336  bkgInfo->setMaxEdepECL(m_maxEdepECL);
337  for (auto& bkg : m_backgrounds) {
338  BackgroundInfo::BackgroundDescr descr;
339  descr.tag = bkg.tag;
340  descr.type = bkg.type;
341  descr.fileType = bkg.fileType;
342  descr.fileNames = bkg.fileNames;
343  descr.realTime = bkg.realTime;
344  descr.numEvents = bkg.numEvents;
345  descr.scaleFactor = bkg.scaleFactor;
346  descr.rate = bkg.rate;
347  descr.reused = 0;
348  bkgInfo->appendBackgroundDescr(descr);
349  }
350 
351  }
352 
353  void BeamBkgMixerModule::beginRun()
354  {
355  }
356 
357  void BeamBkgMixerModule::event()
358  {
359  StoreArray<PXDSimHit> pxdSimHits;
360  StoreArray<SVDSimHit> svdSimHits;
361  StoreArray<CDCSimHit> cdcSimHits;
362  StoreArray<TOPSimHit> topSimHits;
363  StoreArray<ARICHSimHit> arichSimHits;
364  StoreArray<ECLHit> eclHits;
365  StoreArray<BKLMSimHit> bklmSimHits;
366  StoreArray<EKLMSimHit> eklmSimHits;
367  StoreArray<BeamBackHit> beamBackHits;
368  StoreObjPtr<BackgroundInfo> bkgInfo("", DataStore::c_Persistent);
369 
370  for (auto& bkg : m_backgrounds) {
371 
372  if (bkg.fileType != BackgroundMetaData::c_Usual) continue;
373 
374  double mean = bkg.rate * (m_maxTime - m_minTime);
375  int nev = gRandom->Poisson(mean);
376 
377  for (int iev = 0; iev < nev; iev++) {
378  double timeShift = gRandom->Rndm() * (m_maxTime - m_minTime) + m_minTime;
379  bkg.tree->GetEntry(bkg.eventCount);
380 
381  if (acceptEvent(m_simHits.ECL)) {
382  addSimHits(pxdSimHits, m_simHits.PXD, timeShift, m_minTime, m_maxTime);
383  addSimHits(svdSimHits, m_simHits.SVD, timeShift, m_minTime, m_maxTime);
384  addSimHits(cdcSimHits, m_simHits.CDC, timeShift, m_minTime, m_maxTime);
385  addSimHits(topSimHits, m_simHits.TOP, timeShift, m_minTime, m_maxTime);
386  addSimHits(arichSimHits, m_simHits.ARICH, timeShift, m_minTime, m_maxTime);
387  addSimHits(eclHits, m_simHits.ECL, timeShift, m_minTime, m_maxTime);
388  addSimHits(bklmSimHits, m_simHits.BKLM, timeShift, m_minTime, m_maxTime);
389  addSimHits(eklmSimHits, m_simHits.EKLM, timeShift, m_minTime, m_maxTime);
390  addBeamBackHits(beamBackHits, m_simHits.BeamBackHits, timeShift,
391  m_minTime, m_maxTime);
392  } else {
393  iev--;
394  std::string message = "BeamBkgMixer: event " + to_string(bkg.eventCount)
395  + " of " + bkg.type + " rejected due to large energy deposit in ECL";
396  m_rejected[message] += 1;
397  m_rejectedCount++;
398  if (m_rejectedCount < 10) {
399  B2INFO("BeamBkgMixer: event rejected due to large energy deposit in ECL");
400  } else if (m_rejectedCount == 10) {
401  B2INFO("BeamBkgMixer: event rejected due to large energy deposit in ECL "
402  << "(message will be suppressed now)");
403  }
404  }
405 
406  bkg.eventCount++;
407  if (bkg.eventCount >= bkg.numEvents) {
408  bkg.eventCount = 0;
409  std::string message = "BeamBkgMixer: events of " + bkg.type + " will be re-used";
410  m_reused[message] += 1;
411  if (m_reused[message] == 1) B2INFO(message);
412  bkgInfo->incrementReusedCounter(bkg.index);
413  }
414  }
415  }
416 
417 
418  for (auto& bkg : m_backgrounds) {
419 
420  if (bkg.fileType != BackgroundMetaData::c_ECL) continue;
421 
422  double mean = bkg.rate * (m_maxTimeECL - m_minTimeECL);
423  int nev = gRandom->Poisson(mean);
424 
425  for (int iev = 0; iev < nev; iev++) {
426  double timeShift = gRandom->Rndm() * (m_maxTimeECL - m_minTimeECL) + m_minTimeECL;
427  if (timeShift > m_minTime and timeShift < m_maxTime) continue;
428  bkg.tree->GetEntry(bkg.eventCount);
429 
430  if (acceptEvent(m_simHits.ECL)) {
431  double minTime = m_minTimeECL;
432  double maxTime = m_maxTimeECL;
433  if (timeShift <= m_minTime) {
434  maxTime = m_minTime;
435  } else {
436  minTime = m_maxTime;
437  }
438  addSimHits(eclHits, m_simHits.ECL, timeShift, minTime, maxTime);
439  } else {
440  iev--;
441  std::string message = "BeamBkgMixer: event " + to_string(bkg.eventCount)
442  + " of " + bkg.type + " rejected due to large energy deposit in ECL";
443  m_rejected[message] += 1;
444  m_rejectedCount++;
445  if (m_rejectedCount < 10) {
446  B2INFO("BeamBkgMixer: event rejected due to large energy deposit in ECL");
447  } else if (m_rejectedCount == 10) {
448  B2INFO("BeamBkgMixer: event rejected due to large energy deposit in ECL "
449  << "(message will be suppressed now)");
450  }
451  }
452 
453  bkg.eventCount++;
454  if (bkg.eventCount >= bkg.numEvents) {
455  bkg.eventCount = 0;
456  std::string message = "BeamBkgMixer: events of " + bkg.type + " will be re-used";
457  m_reused[message] += 1;
458  if (m_reused[message] == 1) B2INFO(message);
459  bkgInfo->incrementReusedCounter(bkg.index);
460  }
461  }
462 
463  }
464 
465 
466  for (auto& bkg : m_backgrounds) {
467 
468  if (bkg.fileType != BackgroundMetaData::c_PXD) continue;
469 
470  double mean = bkg.rate * (m_maxTimePXD - m_minTimePXD);
471  int nev = gRandom->Poisson(mean);
472 
473  for (int iev = 0; iev < nev; iev++) {
474  double timeShift = gRandom->Rndm() * (m_maxTimePXD - m_minTimePXD) + m_minTimePXD;
475  if (timeShift > m_minTime and timeShift < m_maxTime) continue;
476  bkg.tree->GetEntry(bkg.eventCount);
477 
478  double minTime = m_minTimePXD;
479  double maxTime = m_maxTimePXD;
480  if (timeShift <= m_minTime) {
481  maxTime = m_minTime;
482  } else {
483  minTime = m_maxTime;
484  }
485  addSimHits(pxdSimHits, m_simHits.PXD, timeShift, minTime, maxTime);
486 
487  bkg.eventCount++;
488  if (bkg.eventCount >= bkg.numEvents) {
489  bkg.eventCount = 0;
490  std::string message = "BeamBkgMixer: events of " + bkg.type + " will be re-used";
491  m_reused[message] += 1;
492  if (m_reused[message] == 1) B2INFO(message);
493  bkgInfo->incrementReusedCounter(bkg.index);
494  }
495  }
496 
497  }
498 
499  }
500 
501 
502  void BeamBkgMixerModule::endRun()
503  {
504  }
505 
506  void BeamBkgMixerModule::terminate()
507  {
508 
509  B2INFO("BeamBkgMixer - reused samples:");
510  for (const auto& message : m_reused) {
511  B2INFO(message.first << "(occured " << message.second << " times)");
512  }
513  B2INFO("BeamBkgMixer - rejected events:");
514  for (const auto& message : m_rejected) {
515  B2INFO(message.first << "(occured " << message.second << " times)");
516  }
517 
518  for (auto& bkg : m_backgrounds) {
519  bkg.tree.reset();
520  }
521 
522  }
523 
524 
525  bool BeamBkgMixerModule::isComponentIncluded(std::vector<std::string>& components,
526  const std::string& component)
527  {
528  if (m_components.empty()) return true;
529  auto iterator = std::find(components.begin(), components.end(), component);
530  if (iterator != components.end()) {
531  components.erase(iterator);
532  return true;
533  }
534  return false;
535  }
536 
537 
538  void BeamBkgMixerModule::appendSample(BackgroundMetaData::BG_TAG tag,
539  const std::string& type,
540  const std::string& fileName,
541  double realTime,
542  BackgroundMetaData::EFileType fileType)
543  {
544  for (auto& bkg : m_backgrounds) {
545  if (tag == bkg.tag and fileType == bkg.fileType) {
546  bkg.fileNames.push_back(fileName);
547  bkg.realTime += realTime;
548  return;
549  }
550  }
551  std::string ftype = type;
552  if (fileType == BackgroundMetaData::c_ECL) ftype += "(ECL)";
553  if (fileType == BackgroundMetaData::c_PXD) ftype += "(PXD)";
554  unsigned index = m_backgrounds.size();
555  m_backgrounds.push_back(BkgFiles(tag, ftype, fileName, realTime,
556  m_overallScaleFactor, fileType, index));
557  }
558 
559 
560  bool BeamBkgMixerModule::acceptEvent(TClonesArray* cloneArrayECL)
561  {
562  if (!cloneArrayECL) return true;
563  if (m_maxEdepECL == 0) return true;
564 
565  int numEntries = cloneArrayECL->GetEntriesFast();
566  for (int i = 0; i < numEntries; i++) {
567  ECLHit* simHit = static_cast<ECLHit*>(cloneArrayECL->AddrAt(i));
568  if (simHit->getEnergyDep() > m_maxEdepECL) return false;
569  }
570  return true;
571  }
572 
573 
575 } // end Belle2 namespace
576 
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::ECLHit::getEnergyDep
double getEnergyDep() const
Get deposit energy.
Definition: ECLHit.h:81
Belle2::BackgroundMetaData::getBackgroundType
const std::string & getBackgroundType() const
Returns the type of background.
Definition: BackgroundMetaData.h:116
Belle2::BackgroundMetaData::EFileType
EFileType
Enum for BG file types.
Definition: BackgroundMetaData.h:77
Belle2::BackgroundInfo::BackgroundDescr
Structure for background description.
Definition: BackgroundInfo.h:57
Belle2::BackgroundMetaData::getRealTime
float getRealTime() const
Returns real time that corresponds to this background sample.
Definition: BackgroundMetaData.h:128
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::BeamBkgMixerModule::BkgFiles
structure to hold samples of a particular background type
Definition: BeamBkgMixerModule.h:115
Belle2::BackgroundMetaData
Metadata information about the beam background file.
Definition: BackgroundMetaData.h:34
Belle2::ECLHit
Class to store simulated hits which equate to average of ECLSImHit on crystals input for digitization...
Definition: ECLHit.h:36
Belle2::BeamBkgMixerModule
New beam background mixer; this one doesn't need ROF files.
Definition: BeamBkgMixerModule.h:44
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::BackgroundMetaData::getFileType
EFileType getFileType() const
Returns file type.
Definition: BackgroundMetaData.h:134
Belle2::BackgroundMetaData::getBackgroundTag
BG_TAG getBackgroundTag() const
Returns background tag value.
Definition: BackgroundMetaData.h:122
Belle2::BackgroundMetaData::BG_TAG
BG_TAG
Enum for background tags.
Definition: BackgroundMetaData.h:41