Belle II Software  release-05-02-19
SVDBackgroundModule.cc
1 #include <svd/modules/svdBackground/SVDBackgroundModule.h>
2 
3 #include <framework/datastore/DataStore.h>
4 #include <framework/datastore/StoreObjPtr.h>
5 #include <framework/datastore/StoreArray.h>
6 #include <framework/datastore/RelationArray.h>
7 
8 #include <framework/dataobjects/FileMetaData.h>
9 #include <framework/dataobjects/BackgroundMetaData.h>
10 #include <mdst/dataobjects/MCParticle.h>
11 #include <svd/dataobjects/SVDSimHit.h>
12 #include <svd/dataobjects/SVDTrueHit.h>
13 #include <svd/dataobjects/SVDShaperDigit.h>
14 #include <svd/dataobjects/SVDCluster.h>
15 #include <svd/dataobjects/SVDEnergyDepositionEvent.h>
16 #include <svd/dataobjects/SVDNeutronFluxEvent.h>
17 #include <svd/dataobjects/SVDOccupancyEvent.h>
18 #include <cmath>
19 #include <fstream>
20 #include <set>
21 #include <algorithm>
22 #include <boost/format.hpp>
23 
24 #include "TVector3.h"
25 
26 using namespace std;
27 using boost::format;
28 using namespace Belle2;
29 using namespace Belle2::SVD;
30 
31 //-----------------------------------------------------------------
32 // A small helper function to convert between electons and ADU
33 // ----------------------------------------------------------------
34 double eToADU(double charge)
35 {
36  double minADC = -96000;
37  double maxADC = 288000;
38  double unitADC = (maxADC - minADC) / 1024.0;
39  return round(std::min(maxADC, std::max(minADC, charge)) / unitADC);
40 }
41 
42 //-----------------------------------------------------------------
43 // Register the Module
44 //-----------------------------------------------------------------
45 REG_MODULE(SVDBackground)
46 
47 
48 //-----------------------------------------------------------------
49 // Implementation
50 //-----------------------------------------------------------------
51 
53  Module(), m_outputDirectoryName(""),
54  m_doseReportingLevel(c_reportNTuple),
55  m_nfluxReportingLevel(c_reportNTuple),
56  m_occupancyReportingLevel(c_reportNTuple),
57  m_componentName(""), m_componentTime(0),
58  m_triggerWidth(5), m_acceptanceWidth(2.5), // keeps 99%
59  m_nielNeutrons(new TNiel(c_niel_neutronFile)),
60  m_nielProtons(new TNiel(c_niel_protonFile)),
61  m_nielPions(new TNiel(c_niel_pionFile)),
62  m_nielElectrons(new TNiel(c_niel_electronFile))
63 {
64  //Set module properties
65  setDescription("SVD background module");
66  setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
67  // FIXME: This information can in principle be extracted from bg files, though not trivially.
68  addParam("componentName", m_componentName, "Background component name to process", m_componentName);
69  addParam("componentTime", m_componentTime, "Background component time", m_componentTime);
70  addParam("triggerWidth", m_triggerWidth, "RMS of trigger time estimate in ns", m_triggerWidth);
71  addParam("acceptanceWidth", m_acceptanceWidth,
72  "A hit is accepted if arrived within +/- accpetanceWidth * RMS(hit time - trigger time) of trigger; in ns", m_acceptanceWidth);
73  addParam("doseReportingLevel", m_doseReportingLevel, "0 - no data, 1 - summary only, 2 - summary + ntuple", m_doseReportingLevel);
74  addParam("nfluxReportingLevel", m_nfluxReportingLevel, "0 - no data, 1 - summary only, 2 - summary + ntuple",
75  m_nfluxReportingLevel);
76  addParam("occupancyReportingLevel", m_occupancyReportingLevel, "0 - no data, 1 - summary only, 2 - summary + ntuple",
77  m_occupancyReportingLevel);
78  addParam("outputDirectory", m_outputDirectoryName, "Name of output directory", m_outputDirectoryName);
79 }
80 
81 const TVector3& SVDBackgroundModule::pointToGlobal(VxdID sensorID, const TVector3& local)
82 {
83  static TVector3 result(0, 0, 0);
84 
85  const SVD::SensorInfo& info = getInfo(sensorID);
86  result = info.pointToGlobal(local);
87  return result;
88 }
89 
90 const TVector3& SVDBackgroundModule::vectorToGlobal(VxdID sensorID, const TVector3& local)
91 {
92  static TVector3 result(0, 0, 0);
93 
94  const SVD::SensorInfo& info = getInfo(sensorID);
95  result = info.vectorToGlobal(local);
96  return result;
97 }
98 
99 SVDBackgroundModule::~SVDBackgroundModule()
100 {
101 }
102 
103 void SVDBackgroundModule::initialize()
104 {
105  //Register collections
106  StoreObjPtr<FileMetaData> storeFileMetaData(m_storeFileMetaDataName, DataStore::c_Persistent);
107  StoreObjPtr<BackgroundMetaData> storeBgMetaData(m_storeBgMetaDataName, DataStore::c_Persistent);
108  StoreArray<MCParticle> storeMCParticles(m_storeMCParticlesName);
109  StoreArray<SVDSimHit> storeSimHits(m_storeSimHitsName);
110  StoreArray<SVDTrueHit> storeTrueHits(m_storeTrueHitsName);
111  StoreArray<SVDShaperDigit> storeDigits(m_storeDigitsName);
112  StoreArray<SVDCluster> storeClusters(m_storeClustersName);
113 
114  RelationArray relDigitsMCParticles(storeDigits, storeMCParticles);
115  RelationArray relDigitsTrueHits(storeDigits, storeTrueHits);
116  RelationArray relMCParticlesTrueHits(storeMCParticles, storeTrueHits);
117  RelationArray relTrueHitsSimHits(storeTrueHits, storeSimHits);
118 
119  // Add two new StoreArrays
120  StoreArray<SVDEnergyDepositionEvent> storeEnergyDeposits(m_storeEnergyDepositsName);
121  storeEnergyDeposits.registerInDataStore();
122  StoreArray<SVDNeutronFluxEvent> storeNeutronFluxes(m_storeNeutronFluxesName);
123  storeNeutronFluxes.registerInDataStore();
124  StoreArray<SVDOccupancyEvent> storeOccupancyEvents(m_storeOccupancyEventsName);
125  storeOccupancyEvents.registerInDataStore();
126 
127  //Store names to speed up creation later
128  m_storeFileMetaDataName = storeFileMetaData.getName();
129  m_storeBgMetaDataName = storeBgMetaData.getName();
130  m_storeMCParticlesName = storeMCParticles.getName();
131  m_storeSimHitsName = storeSimHits.getName();
132  m_storeTrueHitsName = storeTrueHits.getName();
133  m_storeDigitsName = storeDigits.getName();
134  m_relDigitsMCParticlesName = relDigitsMCParticles.getName();
135  m_relDigitsTrueHitsName = relDigitsTrueHits.getName();
136  m_relParticlesTrueHitsName = relMCParticlesTrueHits.getName();
137  m_relTrueHitsSimHitsName = relTrueHitsSimHits.getName();
138  m_storeEnergyDepositsName = storeEnergyDeposits.getName();
139  m_storeNeutronFluxesName = storeNeutronFluxes.getName();
140 
141  m_componentTime *= Unit::us;
142  m_acceptanceWidth *= Unit::ns;
143  m_triggerWidth *= Unit::ns;
144 }
145 
146 void SVDBackgroundModule::beginRun()
147 {
148 }
149 
150 void SVDBackgroundModule::event()
151 {
152  //Register collections
153  const StoreObjPtr<FileMetaData> storeFileMetaData(m_storeFileMetaDataName, DataStore::c_Persistent);
154  const StoreObjPtr<BackgroundMetaData> storeBgMetaData(m_storeBgMetaDataName, DataStore::c_Persistent);
155  const StoreArray<MCParticle> storeMCParticles(m_storeMCParticlesName);
156  const StoreArray<SVDSimHit> storeSimHits(m_storeSimHitsName);
157  const StoreArray<SVDTrueHit> storeTrueHits(m_storeTrueHitsName);
158  const StoreArray<SVDShaperDigit> storeDigits(m_storeDigitsName);
159  const StoreArray<SVDCluster> storeClsuters(m_storeClustersName);
160 
161  // Add two new StoreArrays
162  StoreArray<SVDEnergyDepositionEvent> storeEnergyDeposits(m_storeEnergyDepositsName);
163  StoreArray<SVDNeutronFluxEvent> storeNeutronFluxes(m_storeNeutronFluxesName);
164  StoreArray<SVDOccupancyEvent> storeOccupancyEvents(m_storeOccupancyEventsName);
165 
166  // Relations
167  RelationArray relDigitsMCParticles(storeDigits, storeMCParticles, m_relDigitsMCParticlesName);
168  RelationArray relDigitsTrueHits(storeDigits, storeTrueHits, m_relDigitsTrueHitsName);
169  RelationArray relTrueHitsSimHits(storeTrueHits, storeSimHits, m_relTrueHitsSimHitsName);
170  RelationArray relTrueHitsMCParticles(storeMCParticles, storeTrueHits, m_relParticlesTrueHitsName);
171 
172  // unsigned long numberOfEvents = storeFileMetaData->getNEvents();
173  double currentComponentTime = storeBgMetaData->getRealTime();
174  if (currentComponentTime != m_componentTime)
175  B2FATAL("Mismatch in component times:\n"
176  << "Steering file: " << m_componentTime << "\n"
177  << "Background file: " << currentComponentTime);
178 
179  VxdID currentSensorID(0);
180  double currentSensorThickness(0);
181  double currentSensorMass(0);
182  double currentSensorArea(0);
183 
184  // Exposition and dose
185  if (m_doseReportingLevel > c_reportNone) {
186  B2DEBUG(100, "Expo and dose");
187  currentSensorID.setID(0);
188  for (const SVDSimHit& hit : storeSimHits) {
189  // Update if we have a new sensor
190  VxdID sensorID = hit.getSensorID();
191  if (sensorID != currentSensorID) {
192  currentSensorID = sensorID;
193  currentSensorThickness = getSensorThickness(currentSensorID);
194  currentSensorMass = getSensorMass(currentSensorID);
195  currentSensorArea = getSensorArea(currentSensorID);
196  }
197  double hitEnergy = hit.getElectrons() * Const::ehEnergy;
198  // Dose in Gy/smy, normalize by sensor mass
199  m_sensorData[currentSensorID].m_dose +=
200  (hitEnergy / Unit::J) / (currentSensorMass / 1000) * (c_smy / currentComponentTime);
201  // Exposition in GeV/cm2/s
202  m_sensorData[currentSensorID].m_expo += hitEnergy / currentSensorArea / (currentComponentTime / Unit::s);
203  if (m_doseReportingLevel == c_reportNTuple) {
204  const TVector3 localPos = hit.getPosIn();
205  const TVector3 globalPos = pointToGlobal(currentSensorID, localPos);
206  float globalPosXYZ[3];
207  globalPos.GetXYZ(globalPosXYZ);
208  storeEnergyDeposits.appendNew(
209  sensorID.getLayerNumber(), sensorID.getLadderNumber(), sensorID.getSensorNumber(),
210  hit.getPDGcode(), hit.getGlobalTime(),
211  localPos.X(), localPos.Y(), globalPosXYZ, hitEnergy,
212  (hitEnergy / Unit::J) / (currentSensorMass / 1000) / (currentComponentTime / Unit::s),
213  (hitEnergy / Unit::J) / currentSensorArea / (currentComponentTime / Unit::s)
214  );
215  }
216  }
217  }
218 
219  // Neutron flux
220  if (m_nfluxReportingLevel > c_reportNone) {
221  B2DEBUG(100, "Neutron flux");
222  currentSensorID.setID(0);
223  for (const SVDTrueHit& hit : storeTrueHits) {
224  VxdID sensorID = hit.getSensorID();
225  // Update if we are on a new sensor
226  if (sensorID != currentSensorID) {
227  currentSensorID = sensorID;
228  currentSensorThickness = getSensorThickness(currentSensorID);
229  currentSensorMass = getSensorMass(currentSensorID);
230  currentSensorArea = getSensorArea(currentSensorID);
231  }
232  // J(TrueHit) = abs(step)/thickness * correctionFactor;
233  TVector3 entryPos(hit.getEntryU(), hit.getEntryV(), hit.getEntryW());
234  TVector3 exitPos(hit.getExitU(), hit.getExitV(), hit.getExitW());
235  double stepLength = (exitPos - entryPos).Mag();
236  // Identify what particle we've got. We need type and kinetic energy.
237  // TODO: TrueHit must carry pdg or SimHit must carry energy.
238  // NOTE: MCParticles may get remapped, then SimHits still carry correct pdg.
239  const SVDSimHit* simhit = hit.getRelatedTo<SVDSimHit>();
240  if (!simhit) { //either something is very wrong, or we just don't have the relation. Try to find an appropriate SimHit manually.
241  double minDistance = 1.0e10;
242  for (const SVDSimHit& related : storeSimHits) {
243  double distance = (entryPos - related.getPosIn()).Mag();
244  if (distance < minDistance) {
245  minDistance = distance;
246  simhit = &related;
247  }
248  }
249  }
250  // FIXME: Is there a difference between positrons and electrons wrt. NIEL?
251  // We fill neutronFluxBars with summary NIEL deposit for all kinds of particles by layer and component.
252  // Fluency plots are by component and are deposition histograms for a particular type of particle and compoonent.
253  // Special treatment of corrupt p's in TrueHits:
254  TVector3 hitMomentum(hit.getMomentum());
255  hitMomentum.SetX(std::isfinite(hitMomentum.X()) ? hitMomentum.X() : 0.0);
256  hitMomentum.SetY(std::isfinite(hitMomentum.Y()) ? hitMomentum.Y() : 0.0);
257  hitMomentum.SetZ(std::isfinite(hitMomentum.Z()) ? hitMomentum.Z() : 0.0);
258  int pdg = abs(simhit->getPDGcode());
259  double kineticEnergy(0.0);
260  double nielWeight(0.0);
261  if (pdg == 2112) {
262  double m0 = 0.940;
263  kineticEnergy = sqrt(hitMomentum.Mag2() + m0 * m0) - m0;
264  nielWeight = m_nielNeutrons->getNielFactor(kineticEnergy / Unit::MeV);
265  }
266  if (pdg == 2212) {
267  double m0 = 0.938;
268  kineticEnergy = sqrt(hitMomentum.Mag2() + m0 * m0) - m0;
269  nielWeight = m_nielProtons->getNielFactor(kineticEnergy / Unit::MeV);
270  }
271  if (pdg == 111 || pdg == 211) {
272  double m0 = 0.135;
273  kineticEnergy = sqrt(hitMomentum.Mag2() + m0 * m0) - m0;
274  nielWeight = m_nielPions->getNielFactor(kineticEnergy / Unit::MeV);
275  }
276  if (pdg == 11) {
277  double m0 = 0.511e-3;
278  kineticEnergy = sqrt(hitMomentum.Mag2() + m0 * m0) - m0;
279  nielWeight = m_nielElectrons->getNielFactor(kineticEnergy / Unit::MeV);
280  }
281  if (pdg == 22) {
282  double m0 = 0.0;
283  kineticEnergy = sqrt(hitMomentum.Mag2() + m0 * m0) - m0;
284  }
285 
286  // Only set weight for supported particles
287  nielWeight = std::isfinite(nielWeight) ? nielWeight : 0.0;
288  m_sensorData[currentSensorID].m_neutronFlux += nielWeight * stepLength / currentSensorThickness / currentSensorArea /
289  currentComponentTime * c_smy;
290 
291  // Store data in a SVDNeutronFluxEvent object
292  if (m_nfluxReportingLevel == c_reportNTuple) {
293  TVector3 localPos(hit.getU(), hit.getV(), hit.getW());
294  const TVector3 globalPos = pointToGlobal(currentSensorID, localPos);
295  float globalPosXYZ[3];
296  globalPos.GetXYZ(globalPosXYZ);
297  TVector3 localMom = hit.getMomentum();
298  const TVector3 globalMom = vectorToGlobal(currentSensorID, localMom);
299  float globalMomXYZ[3];
300  globalMom.GetXYZ(globalMomXYZ);
301  storeNeutronFluxes.appendNew(
302  sensorID.getLayerNumber(), sensorID.getLadderNumber(), sensorID.getSensorNumber(),
303  simhit->getPDGcode(), simhit->getGlobalTime(),
304  hit.getU(), hit.getV(), globalPosXYZ, globalMomXYZ, kineticEnergy,
305  stepLength, nielWeight,
306  stepLength / currentSensorThickness / currentSensorArea / (currentComponentTime / Unit::s),
307  nielWeight * stepLength / currentSensorThickness / currentSensorArea / (currentComponentTime / Unit::s)
308  );
309  }
310  }
311  }
312 
313  // Fired strips
314  if (m_occupancyReportingLevel > c_reportNone) {
315  B2DEBUG(100, "Fired strips");
316  currentSensorID.setID(0);
317  double currentSensorUCut = 0;
318  double currentSensorVCut = 0;
319  // Store fired strips: count number of digits over threshold
320  std::map<VxdID, std::multiset<unsigned short> > firedStrips;
321  for (const SVDShaperDigit& digit : storeDigits) {
322  // Filter out digits with signals below zero-suppression threshold
323  // ARE THRE SUCH DIGITS?
324  VxdID sensorID = digit.getSensorID();
325  if (sensorID != currentSensorID) {
326  currentSensorID = sensorID;
327  auto info = getInfo(sensorID);
328  currentSensorUCut = eToADU(3.0 * info.getElectronicNoiseU());
329  currentSensorVCut = eToADU(3.0 * info.getElectronicNoiseV());
330  }
331  B2DEBUG(30, "MaxCharge: " << digit.getMaxADCCounts() << " threshold: " << (digit.isUStrip() ? currentSensorUCut :
332  currentSensorVCut));
333  if (digit.getMaxADCCounts() < (digit.isUStrip() ? currentSensorUCut : currentSensorVCut)) continue;
334  B2DEBUG(30, "Passed.");
335  // Economize writing u- and v- strips by re-using the Segment field of VxdID
336  VxdID writeID(sensorID);
337  if (digit.isUStrip())
338  writeID.setSegmentNumber(0);
339  else
340  writeID.setSegmentNumber(1);
341  firedStrips[writeID].insert(digit.getCellID());
342  }
343  // Process the map
344  for (auto idAndSet : firedStrips) {
345  bool isUStrip = (idAndSet.first.getSegmentNumber() == 0);
346  VxdID sensorID = idAndSet.first;
347  sensorID.setSegmentNumber(0);
348  double sensorArea = getSensorArea(sensorID);
349  int nFired_APV = idAndSet.second.size();
350  int nFired = 0; // count unique keys
351  for (auto it = idAndSet.second.begin();
352  it != idAndSet.second.end();
353  it = idAndSet.second.upper_bound(*it)) nFired++;
354  double fired = nFired / (currentComponentTime / Unit::s) / sensorArea;
355  double fired_t = nFired_APV * c_APVCycleTime / (currentComponentTime / Unit::s) / sensorArea;
356  if (isUStrip) {
357  m_sensorData[sensorID].m_firedU += fired;
358  m_sensorData[sensorID].m_firedU_t += fired_t;
359  } else {
360  m_sensorData[sensorID].m_firedV += fired;
361  m_sensorData[sensorID].m_firedV_t += fired_t;
362  }
363  }
364 
365  // Occupancy
366  //
367  // We assume a S/N dependent acceptance window of size
368  // W = 2 * acceptanceWidth * RMS(hit_time - trigger_time)
369  // that is used to keep most of signal hits.
370  // occupancy for a cluster with S/N = sn and size sz on sensor id =
371  // cluster_rate(sn,sz,id) * W * sz / #strips(id)
372  // Cluster rate is number of clusters / sample time, and as we expect
373  // clusters to be justly represented in the sample as to S/N, size, and
374  // sensor they appear on, we calculate occupancy on sensor id as
375  //
376  // occupancy(id) = Sum_over_clusters_in_id (
377  // W(sn) / t_simulation * sz / #strips(id)
378  // )
379  //
380  B2DEBUG(100, "Occupancy");
381  currentSensorID.setID(0);
382  double currentNoiseU = 0;
383  double currentNoiseV = 0;
384  int nStripsU = 0;
385  int nStripsV = 0;
386  for (auto cluster : storeClsuters) {
387  VxdID sensorID = cluster.getSensorID();
388  if (currentSensorID != sensorID) {
389  currentSensorID = sensorID;
390  auto info = getInfo(sensorID);
391  currentNoiseU = eToADU(info.getElectronicNoiseU());
392  currentNoiseV = eToADU(info.getElectronicNoiseV());
393  nStripsU = info.getUCells();
394  nStripsV = info.getVCells();
395  }
396  bool isU = cluster.isUCluster();
397  double snr = (isU) ? cluster.getCharge() / currentNoiseU : cluster.getCharge() / currentNoiseV;
398  int nStrips = (isU) ? nStripsU : nStripsV;
399  double tau_error = 45 / snr * Unit::ns;
400  tau_error = sqrt(m_triggerWidth * m_triggerWidth + tau_error * tau_error);
401  double tau_acceptance = 2 * m_acceptanceWidth * tau_error;
402  double w_acceptance = tau_acceptance / currentComponentTime;
403  double w_acceptance_APV = c_APVCycleTime / currentComponentTime;
404  double occupancy = 1.0 / nStrips * cluster.getSize();
405  if (isU) {
406  m_sensorData[sensorID].m_occupancyU += w_acceptance * occupancy;
407  m_sensorData[sensorID].m_occupancyU_APV += w_acceptance_APV * occupancy;
408  } else {
409  m_sensorData[sensorID].m_occupancyV += w_acceptance * occupancy;
410  m_sensorData[sensorID].m_occupancyV_APV += w_acceptance_APV * occupancy;
411  }
412  if (m_occupancyReportingLevel == c_reportNTuple) {
413  storeOccupancyEvents.appendNew(
414  sensorID.getLayerNumber(), sensorID.getLadderNumber(),
415  sensorID.getSensorNumber(), cluster.getClsTime(),
416  cluster.isUCluster(), cluster.getPosition(), cluster.getSize(),
417  cluster.getCharge(), snr, w_acceptance, w_acceptance * occupancy,
418  w_acceptance_APV * occupancy
419  );
420  }
421  }
422  }
423 }
424 
425 void SVDBackgroundModule::endRun()
426 {
427 }
428 
429 
430 void SVDBackgroundModule::terminate()
431 {
432  // Write out m_data
433  ofstream outfile;
434  string outfileName(m_outputDirectoryName + m_componentName + "_summary.txt");
435  outfile.open(outfileName.c_str(), ios::out | ios::trunc);
436  outfile << "component_name\t"
437  << "component_time\t"
438  << "layer\t"
439  << "ladder\t"
440  << "sensor\t"
441  << "dose\t"
442  << "expo\t"
443  << "neutronFlux\t"
444  << "fired_u\t"
445  << "fired_v\t"
446  << "fired_u_t\t"
447  << "fired_v_t\t"
448  << "occupancy_u\t"
449  << "occupancy_v\t"
450  << "occupancy_u_APV\t"
451  << "occupancy_v_APV"
452  << endl;
453  double componentTime = m_componentTime / Unit::us;
454  for (auto vxdSensor : m_sensorData) {
455  outfile << m_componentName.c_str() << "\t"
456  << componentTime << "\t"
457  << vxdSensor.first.getLayerNumber() << "\t"
458  << vxdSensor.first.getLadderNumber() << "\t"
459  << vxdSensor.first.getSensorNumber() << "\t"
460  << vxdSensor.second.m_dose << "\t"
461  << vxdSensor.second.m_expo << "\t"
462  << vxdSensor.second.m_neutronFlux << "\t"
463  << vxdSensor.second.m_firedU << "\t"
464  << vxdSensor.second.m_firedV << "\t"
465  << vxdSensor.second.m_firedU_t << "\t"
466  << vxdSensor.second.m_firedV_t << "\t"
467  << vxdSensor.second.m_occupancyU << "\t"
468  << vxdSensor.second.m_occupancyV << "\t"
469  << vxdSensor.second.m_occupancyU_APV << "\t"
470  << vxdSensor.second.m_occupancyV_APV
471  << endl;
472  }
473  outfile << endl;
474 }
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::RelationArray
Low-level class to create/modify relations between StoreArrays.
Definition: RelationArray.h:72
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::SVDSimHit
Class SVDSimHit - Geant4 simulated hit for the SVD.
Definition: SVDSimHit.h:28
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::VxdID::getLadderNumber
baseType getLadderNumber() const
Get the ladder id.
Definition: VxdID.h:108
Belle2::SVDTrueHit
Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume.
Definition: SVDTrueHit.h:35
Belle2::StoreAccessorBase::getName
const std::string & getName() const
Return name under which the object is saved in the DataStore.
Definition: StoreAccessorBase.h:130
Belle2::SVD::SensorInfo
Specific implementation of SensorInfo for SVD Sensors which provides additional sensor specific infor...
Definition: SensorInfo.h:35
TNiel
TNiel - the class providing values for NIEL factors.
Definition: niel_fun.h:10
Belle2::SVDShaperDigit
The SVD ShaperDigit class.
Definition: SVDShaperDigit.h:46
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::VxdID::setSegmentNumber
void setSegmentNumber(baseType segment)
Set the sensor segment.
Definition: VxdID.h:123
Belle2::SVD
Namespace to encapsulate code needed for simulation and reconstrucion of the SVD.
Definition: GeoSVDCreator.h:35
Belle2::VXDSimHit::getGlobalTime
float getGlobalTime() const override
Return the time of the electron deposition.
Definition: VXDSimHit.h:80
Belle2::SVD::SVDBackgroundModule
SVD Background module.
Definition: SVDBackgroundModule.h:66
Belle2::VxdID::getSensorNumber
baseType getSensorNumber() const
Get the sensor id.
Definition: VxdID.h:110
Belle2::StoreArray< MCParticle >
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:106
Belle2::VXDSimHit::getPDGcode
int getPDGcode() const
Return the PDG code of the particle causing the electron deposition.
Definition: VXDSimHit.h:70
Belle2::VxdID::setID
void setID(baseType id)
Set the unique id.
Definition: VxdID.h:115