Belle II Software  release-05-02-19
VXDSimpleClusterizerModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Jakob Lettenbichler, Moritz Nadler *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <tracking/modules/VXDTFHelperTools/VXDSimpleClusterizerModule.h>
12 #include <vxd/geometry/SensorInfoBase.h>
13 #include <vxd/geometry/GeoCache.h>
14 
15 #include <framework/datastore/StoreObjPtr.h>
16 #include <framework/dataobjects/EventMetaData.h>
17 #include <framework/logging/Logger.h>
18 
19 //C++ std lib
20 #include <vector>
21 using std::vector;
22 
23 #include <string>
24 using std::string;
25 
26 #include <cmath>
27 using std::sin;
28 using std::cos;
29 using std::sqrt;
30 
31 //root stuff
32 #include <TRandom.h>
33 
34 using namespace Belle2;
35 
36 REG_MODULE(VXDSimpleClusterizer)
37 
39 {
40  InitializeVariables();
41 
42 
43  setDescription("The VXDSimpleClusterizerModule generates PXD/SVD Clusters using TrueHits. Energy-deposit threshold and gaussian smearing can be chosen, non-primary-particles can be filtered as well. Its purpose is fast clusterizing for tracking test procedures, using standardized PXD/SVD-Cluster");
44  setPropertyFlags(c_ParallelProcessingCertified);
45 
46  addParam("energyThresholdU", m_energyThresholdU,
47  "particles with energy deposit in U lower than this will not create a cluster in SVD (GeV)", double(17.4E-6));
48  addParam("energyThresholdV", m_energyThresholdV,
49  "particles with energy deposit in V lower than this will not create a cluster in SVD (GeV)", double(28.6E-6));
50  addParam("energyThreshold", m_energyThreshold,
51  "particles with energy deposit lower than this will not create a cluster in PXD (GeV)", double(7E-6));
52  addParam("onlyPrimaries", m_onlyPrimaries, "if true use only primary particles from the generator no particles created by Geant4",
53  false);
54  addParam("uniSigma", m_uniSigma,
55  "you can define the sigma of the smearing. Standard value is the sigma of the unifom distribution for 0-1: 1/sqrt(12)",
56  double(1. / sqrt(12.)));
57  addParam("setMeasSigma", m_setMeasSigma,
58  "if positive value (in cm) is given it will be used as the sigma to smear the Clusters otherwise pitch/uniSigma will be used",
59  -1.0);
60  addParam("PXDTrueHits", m_pxdTrueHitsName,
61  "PXDTrueHit collection name", string(""));
62  addParam("SVDTrueHits", m_svdTrueHitsName,
63  "SVDTrueHit collection name", string(""));
64  addParam("MCParticles", m_mcParticlesName,
65  "MCParticle collection name", string(""));
66  addParam("PXDClusters", m_pxdClustersName,
67  "PXDCluster collection name", string(""));
68  addParam("SVDClusters", m_svdClustersName,
69  "SVDCluster collection name", string(""));
70 }
71 
72 
74 {
75  //input containers:
76  m_mcParticles.isOptional(m_mcParticlesName);
77  m_pxdTrueHits.isOptional(m_pxdTrueHitsName);
78  m_svdTrueHits.isOptional(m_svdTrueHitsName);
79 
80  // initializing StoreArrays for clusters. needed to give them the names set by parameters
83 
84  if (m_pxdTrueHits.isOptional() == true) {
85 
86  //Relations to cluster objects only if the ancestor relations exist:
88  m_pxdClustersName = m_pxdClusters.getName();
89  m_pxdTrueHitsName = m_pxdTrueHits.getName();
90 
91  if (m_mcParticles.isOptional() == true) {
93  m_mcParticlesName = m_mcParticles.getName();
94  }
95  }
96 
97  if (m_svdTrueHits.isOptional() == true) {
98 
99  //Relations to cluster objects only if the ancestor relations exist:
101  m_svdClustersName = m_svdClusters.getName();
102  m_svdTrueHitsName = m_svdTrueHits.getName();
103 
104  if (m_mcParticles.isOptional() == true) {
106  m_mcParticlesName = m_mcParticles.getName();
107  }
108  }
109 }
110 
111 
112 
114 {
115  string paramValue;
116  if (m_onlyPrimaries == true) {
117  paramValue = "true, means that there are no secondary hits (for 1-track events this means no ghost hits guaranteed)";
118  } else {
119  paramValue = "false, means that secondary hits can occur and increase the rate of ghost hits";
120  }
121  B2INFO("VXDSimpleClusterizer: parameter onlyPrimaries is set to " << paramValue);
122 
124 }
125 
126 
127 
129 {
130  // counter for cases when a trueHit god discarded:
131  int discardedPXDEdeposit = 0, discardedSVDEdeposit = 0, discardedPXDFake = 0, discardedSVDFake = 0;
132 
133  const StoreObjPtr<EventMetaData> eventMetaDataPtr("EventMetaData", DataStore::c_Event);
134 
135  B2DEBUG(5, "******* VXDSimpleClusterizerModule processing event number: " << eventMetaDataPtr->getEvent() << " *******");
136 
137 
138  //check all the input containers. First: MCParticles
139  int nMcParticles = m_mcParticles.getEntries();
140  if (nMcParticles == 0) {B2DEBUG(100, "MCTrackFinder: MCParticlesCollection is empty!");}
141  //PXD
142  int nPxdTrueHits = m_pxdTrueHits.getEntries();
143  if (nPxdTrueHits == 0) {B2DEBUG(100, "MCTrackFinder: PXDHitsCollection is empty!");}
144  //SVD
145  int nSvdTrueHits = m_svdTrueHits.getEntries();
146  if (nSvdTrueHits == 0) {B2DEBUG(100, "MCTrackFinder: SVDHitsCollection is empty!");}
147  B2DEBUG(175, "found " << nMcParticles << "/" << nPxdTrueHits << "/" << nSvdTrueHits << " mcParticles, pxdTrueHits, svdTrueHits");
148 
149 
150  double sigmaU = m_setMeasSigma;
151  double sigmaV = m_setMeasSigma;
152 
153 
155  for (unsigned int currentTrueHit = 0; int (currentTrueHit) not_eq nPxdTrueHits; ++currentTrueHit) {
156  B2DEBUG(175, "begin PXD current TrueHit: " << currentTrueHit << " of nPxdTrueHits total: " << nPxdTrueHits);
157 
158  const PXDTrueHit* aPxdTrueHit = m_pxdTrueHits[currentTrueHit];
159  const MCParticle* aMcParticle = aPxdTrueHit->getRelatedFrom<MCParticle>();
160  unsigned int particleID = std::numeric_limits<unsigned int>::max();
161 
162  if (aMcParticle != NULL) { particleID = aMcParticle->getArrayIndex(); }
163 
164  double energy = aPxdTrueHit->getEnergyDep();
165 
166 
167  if (m_onlyPrimaries == true) { // ingore hits not comming from primary particles (e.g material effects particles)
168  if (aMcParticle == NULL or aMcParticle->hasStatus(MCParticle::c_PrimaryParticle) == false) {
169  m_fakePXDHitCtr++;
170  discardedPXDFake++;
171  continue; // jump to next pxdTrueHit
172  }
173  }
174 
175  B2DEBUG(100, " PXD, current TrueHit " << currentTrueHit << " connected to " << particleID << " has an energy deposit of " <<
176  energy * 1000.0 << "MeV ");
177  if (energy < m_energyThreshold) { //ignore hit if energy deposit is too small
178  B2DEBUG(100, " PXD, TrueHit discarded because of energy deposit too small");
179  m_weakPXDHitCtr++;
180  discardedPXDEdeposit++;
181  continue;
182  }
183 
184  //smear the pxdTrueHit and get needed variables for storing
185  VxdID aVXDId = aPxdTrueHit->getSensorID();
186  double uTrue = aPxdTrueHit->getU();
187  double vTrue = aPxdTrueHit->getV();
188  double u = -20;
189  double v = -20;
190  if (m_setMeasSigma < 0.0) {
191  const VXD::SensorInfoBase* sensorInfo = &VXD::GeoCache::getInstance().getSensorInfo(aVXDId);
192  sigmaU = sensorInfo->getUPitch(uTrue) * m_uniSigma;
193  sigmaV = sensorInfo->getVPitch(vTrue) * m_uniSigma;
194  }
195  B2DEBUG(175, "sigU sigV: " << sigmaU << " " << sigmaV);
196 
197  if (m_setMeasSigma != 0) {
198  u = gRandom->Gaus(uTrue, sigmaU);
199  v = gRandom->Gaus(vTrue, sigmaV);
200  } else {
201  u = uTrue;
202  v = vTrue;
203  }
204 
205  if (m_setMeasSigma == 0 and m_uniSigma == 0) {
206  // in this case, the hits will not be smeared, but still we need some measurement error-values to be able to do some fitting... WARNING currently arbritary values here, better solution recommended!
207  sigmaU = 0.000001;
208  sigmaV = 0.000001;
209  }
210 
226  // Save as new 2D-PXD-cluster
227  PXDCluster* newCluster = m_pxdClusters.appendNew(aVXDId, u, v, sigmaU, sigmaV, 0, 1, 1, 1, 1, 1, 1, 1);
228  // add relations
229  newCluster->addRelationTo(m_pxdTrueHits[currentTrueHit]);
230 
231  if (particleID != std::numeric_limits<unsigned int>::max()) {
232  newCluster->addRelationTo(m_mcParticles[particleID]);
233  B2DEBUG(20, "mcParticle " << particleID << " has " << aMcParticle->getRelationsTo<PXDCluster>().size() <<
234  " relations to PXD clusters");
235  }
236  }
237 
238 
239 
241  for (unsigned int currentTrueHit = 0; int (currentTrueHit) not_eq nSvdTrueHits; ++currentTrueHit) {
242  B2DEBUG(175, "begin SVD current TrueHit: " << currentTrueHit << " of nSvdTrueHits total: " << nSvdTrueHits);
243 
244  const SVDTrueHit* aSvdTrueHit = m_svdTrueHits[currentTrueHit];
245  const MCParticle* aMcParticle = aSvdTrueHit->getRelatedFrom<MCParticle>();
246  unsigned int particleID = std::numeric_limits<unsigned int>::max();
247 
248  if (m_onlyPrimaries == true) { // ingore hits not comming from primary particles (e.g material effects particles)
249  if (aMcParticle == NULL or aMcParticle->hasStatus(MCParticle::c_PrimaryParticle) == false) {
250  m_fakeSVDHitCtr++;
251  discardedSVDFake++;
252  continue; // jump to next svdTrueHit
253  }
254  }
255 
256  if (aMcParticle != NULL) { particleID = aMcParticle->getArrayIndex(); }
257  double energy = aSvdTrueHit->getEnergyDep();
258 
259  B2DEBUG(100, " SVD, current TrueHit " << currentTrueHit << " connected to " << particleID << " has an energy deposit of " <<
260  energy * 1000.0 << "MeV ");
261  if (energy < (m_energyThresholdU + m_energyThresholdV)) { //ignore hit if energy deposity is too snall
262  m_weakSVDHitCtr++;
263  discardedSVDEdeposit++;
264  B2DEBUG(100, " SVD, TrueHit discarded because of energy deposit too small");
265  continue;
266  }
267 
268 
269  // smear the SvdTrueHit and get needed variables for storing
270  VxdID aVXDId = aSvdTrueHit->getSensorID();
271  double uTrue = aSvdTrueHit->getU();
272  double vTrue = aSvdTrueHit->getV();
273  double u = -20;
274  double v = -20;
275  if (m_setMeasSigma < 0.0) {
276  const VXD::SensorInfoBase* sensorInfo = &VXD::GeoCache::getInstance().getSensorInfo(aVXDId);
277  sigmaU = sensorInfo->getUPitch(uTrue) * m_uniSigma;
278  sigmaV = sensorInfo->getVPitch(vTrue) * m_uniSigma;
279  }
280  B2DEBUG(150, "sigU sigV: " << sigmaU << " " << sigmaV);
281 
282  if (m_setMeasSigma != 0) {
283  u = gRandom->Gaus(uTrue, sigmaU);
284  v = gRandom->Gaus(vTrue, sigmaV);
285  } else {
286  u = uTrue;
287  v = vTrue;
288  }
289 
290  if (m_setMeasSigma == 0) {
291  // in this case, the hits will not be smeared, but still we need some measurement error-values to be able to do some fitting... WARNING currently arbritary values here, better solution recommended!
292  sigmaU = 0.000001;
293  sigmaV = 0.000001;
294  }
295 
296  // Save as two new 1D-SVD-clusters
297  double timeStamp = m_svdTrueHits[currentTrueHit]->getGlobalTime();
298 
312  SVDCluster* newClusterU = m_svdClusters.appendNew(aVXDId, true, u, sigmaU, timeStamp, 0, 1, 1,
313  3, 1); // in a typical situation 3-5 Strips are excited per Hit -> set to 3
314  // add relations to u-cluster
315  newClusterU->addRelationTo(m_svdTrueHits[currentTrueHit]);
316 
317  SVDCluster* newClusterV = m_svdClusters.appendNew(aVXDId, false, v, sigmaV, timeStamp, 0, 1, 1, 3, 1);
318  // add relations to v-cluster
319  newClusterV->addRelationTo(m_svdTrueHits[currentTrueHit]);
320 
321  if (particleID != std::numeric_limits<unsigned int>::max()) {
322  newClusterU->addRelationTo(m_mcParticles[particleID]);
323  newClusterV->addRelationTo(m_mcParticles[particleID]);
324  B2DEBUG(20, "mcParticle " << particleID << " has " << aMcParticle->getRelationsTo<SVDCluster>().size() <<
325  " relations to SVD clusters");
326  }
327 
328  }
329 
330  B2DEBUG(10, "------------------------------------------------------");
331 
332  B2DEBUG(10, "VXDSimpleClusterizerModule: Number of PXDHits: " << nPxdTrueHits);
333  B2DEBUG(10, "VXDSimpleClusterizerModule: Number of SVDDHits: " << nSvdTrueHits);
334  B2DEBUG(10, "VXDSimpleClusterizerModule: total Number of MCParticles: " << nMcParticles);
335  B2DEBUG(10, "pxdClusters.getEntries()" << m_pxdClusters.getEntries());
336  B2DEBUG(10, "svdClusters.getEntries()" << m_svdClusters.getEntries());
337  B2DEBUG(10, "------------------------------------------------------");
338 
339  B2DEBUG(1, "VXDSimpleClusterizer - event " << eventMetaDataPtr->getEvent() << ":\n" << "of " << nPxdTrueHits << "/" << nSvdTrueHits
340  << " PXD-/SVDTrueHits, " << discardedPXDEdeposit << "/" << discardedSVDEdeposit << " hits were discarded bec. of low E-deposit & "
341  << discardedPXDFake << "/" << discardedSVDFake << " hits were discarded bec. of being a fake. " << m_pxdClusters.getEntries() << "/"
342  << m_svdClusters.getEntries() << " Clusters were stored.\n");
343 }
344 
345 
346 
348 {
349  B2INFO("VXDSimpleClusterizerModule::EndRun:\nSimpleClusterizerModule discarded " << m_weakPXDHitCtr << " PXDTrueHits and " <<
350  m_weakSVDHitCtr << " SVDTrueHits because of low E-deposit-threshold and discarded " << m_fakePXDHitCtr << " PXDTrueHits and " <<
351  m_fakeSVDHitCtr << " SVDTrueHits because they were fake");
352 }
Belle2::VXDSimpleClusterizerModule::m_weakSVDHitCtr
int m_weakSVDHitCtr
counts SVDHits whose energy deposit is lower than energyThreshold
Definition: VXDSimpleClusterizerModule.h:106
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::VXDSimpleClusterizerModule::m_svdClustersName
std::string m_svdClustersName
SVDCluster collection name.
Definition: VXDSimpleClusterizerModule.h:96
Belle2::VXDSimpleClusterizerModule::m_energyThreshold
double m_energyThreshold
set energy threshold for PXDClusters in GeV (standard is 7E-6)
Definition: VXDSimpleClusterizerModule.h:102
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::StoreArray::registerRelationTo
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:150
Belle2::VXDSimpleClusterizerModule::m_uniSigma
double m_uniSigma
you can define the sigma of the smearing.
Definition: VXDSimpleClusterizerModule.h:104
Belle2::PXDTrueHit
Class PXDTrueHit - Records of tracks that either enter or leave the sensitive volume.
Definition: PXDTrueHit.h:35
Belle2::VXDSimpleClusterizerModule
Module to convert TrueHits into Clusters using a simplified process.
Definition: VXDSimpleClusterizerModule.h:45
Belle2::VXDSimpleClusterizerModule::m_svdClusters
StoreArray< SVDCluster > m_svdClusters
the storeArray for svdClusters as member, is faster than recreating link for each event
Definition: VXDSimpleClusterizerModule.h:98
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::VXDSimpleClusterizerModule::m_pxdClustersName
std::string m_pxdClustersName
PXDCluster collection name.
Definition: VXDSimpleClusterizerModule.h:93
Belle2::VXDTrueHit::getSensorID
VxdID getSensorID() const
Return the Sensor ID.
Definition: VXDTrueHit.h:72
Belle2::VXDSimpleClusterizerModule::InitializeVariables
void InitializeVariables()
initialize variables to avoid nondeterministic behavior
Definition: VXDSimpleClusterizerModule.h:75
Belle2::VXDSimpleClusterizerModule::initialize
void initialize() override
Initialize the Module.
Definition: VXDSimpleClusterizerModule.cc:73
Belle2::SVDTrueHit
Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume.
Definition: SVDTrueHit.h:35
Belle2::VXDSimpleClusterizerModule::m_setMeasSigma
double m_setMeasSigma
if positive value (in cm) is given it will be used as the sigma to smear the Clusters otherwise pitch...
Definition: VXDSimpleClusterizerModule.h:105
Belle2::RelationsInterface::addRelationTo
void addRelationTo(const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
Add a relation from this object to another object (with caching).
Definition: RelationsObject.h:144
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
Belle2::VXDSimpleClusterizerModule::m_fakePXDHitCtr
int m_fakePXDHitCtr
counts PXDHits which were not caused by a primary partice
Definition: VXDSimpleClusterizerModule.h:109
Belle2::VXDSimpleClusterizerModule::m_fakeSVDHitCtr
int m_fakeSVDHitCtr
counts SVDHits which were not caused by a primary partice
Definition: VXDSimpleClusterizerModule.h:108
Belle2::VXDSimpleClusterizerModule::m_pxdTrueHitsName
std::string m_pxdTrueHitsName
PXDTrueHit collection name.
Definition: VXDSimpleClusterizerModule.h:84
Belle2::MCParticle::getArrayIndex
int getArrayIndex() const
Get 0-based index of the particle in the corresponding MCParticle list.
Definition: MCParticle.h:255
Belle2::RelationsInterface::getRelationsTo
RelationVector< TO > getRelationsTo(const std::string &name="", const std::string &namedRelation="") const
Get the relations that point from this object to another store array.
Definition: RelationsObject.h:199
Belle2::VXD::SensorInfoBase::getVPitch
double getVPitch(double v=0) const
Return the pitch of the sensor.
Definition: SensorInfoBase.h:150
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2::MCParticle::hasStatus
bool hasStatus(unsigned short int bitmask) const
Return if specific status bit is set.
Definition: MCParticle.h:140
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:215
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::VXDSimpleClusterizerModule::endRun
void endRun() override
This method is called if the current run ends.
Definition: VXDSimpleClusterizerModule.cc:347
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::VXDTrueHit::getV
float getV() const
Return local v coordinate of hit.
Definition: VXDTrueHit.h:78
Belle2::VXDSimpleClusterizerModule::m_onlyPrimaries
bool m_onlyPrimaries
set True if you do not want to have hits by secondary particles
Definition: VXDSimpleClusterizerModule.h:103
Belle2::VXDSimpleClusterizerModule::m_svdTrueHitsName
std::string m_svdTrueHitsName
SVDTrueHit collection name.
Definition: VXDSimpleClusterizerModule.h:87
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:41
Belle2::VXDSimpleClusterizerModule::m_weakPXDHitCtr
int m_weakPXDHitCtr
counts PXDHits whose energy deposit is lower than energyThreshold
Definition: VXDSimpleClusterizerModule.h:107
Belle2::VXDSimpleClusterizerModule::m_energyThresholdU
double m_energyThresholdU
set energy threshold for SVDClusters in u-direction in GeV (standard is 17.4E-6)
Definition: VXDSimpleClusterizerModule.h:100
Belle2::VXDTrueHit::getEnergyDep
float getEnergyDep() const
Return energy deposited during traversal of sensor.
Definition: VXDTrueHit.h:94
Belle2::VXD::SensorInfoBase::getUPitch
double getUPitch(double v=0) const
Return the pitch of the sensor.
Definition: SensorInfoBase.h:143
Belle2::DataStore::c_ErrorIfAlreadyRegistered
@ c_ErrorIfAlreadyRegistered
If the object/array was already registered, produce an error (aborting initialisation).
Definition: DataStore.h:74
Belle2::SVDCluster
The SVD Cluster class This class stores all information about reconstructed SVD clusters.
Definition: SVDCluster.h:38
Belle2::VXDSimpleClusterizerModule::event
void event() override
This method is the core of the module.
Definition: VXDSimpleClusterizerModule.cc:128
Belle2::VXDSimpleClusterizerModule::m_mcParticlesName
std::string m_mcParticlesName
MCParticle collection name.
Definition: VXDSimpleClusterizerModule.h:90
Belle2::VXDSimpleClusterizerModule::m_mcParticles
StoreArray< MCParticle > m_mcParticles
the storeArray for mcParticles as member, is faster than recreating link for each event
Definition: VXDSimpleClusterizerModule.h:92
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a referecne to the SensorInfo of a given SensorID.
Definition: GeoCache.cc:68
Belle2::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:43
Belle2::VXDTrueHit::getU
float getU() const
Return local u coordinate of hit.
Definition: VXDTrueHit.h:76
Belle2::VXDSimpleClusterizerModule::m_energyThresholdV
double m_energyThresholdV
set energy threshold for SVDClusters in v-direction in GeV (standard is 28.6E-6)
Definition: VXDSimpleClusterizerModule.h:101
Belle2::DataStore::c_Event
@ c_Event
Different object in each event, all objects/arrays are invalidated after event() function has been ca...
Definition: DataStore.h:61
Belle2::VXDSimpleClusterizerModule::beginRun
void beginRun() override
Called when entering a new run.
Definition: VXDSimpleClusterizerModule.cc:113
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226
Belle2::MCParticle::c_PrimaryParticle
@ c_PrimaryParticle
bit 0: Particle is primary particle.
Definition: MCParticle.h:58
Belle2::RelationsInterface::getRelatedFrom
FROM * getRelatedFrom(const std::string &name="", const std::string &namedRelation="") const
Get the object from which this object has a relation.
Definition: RelationsObject.h:265
Belle2::VXDSimpleClusterizerModule::m_pxdClusters
StoreArray< PXDCluster > m_pxdClusters
the storeArray for pxdClusters as member, is faster than recreating link for each event
Definition: VXDSimpleClusterizerModule.h:95
Belle2::VXDSimpleClusterizerModule::m_svdTrueHits
StoreArray< SVDTrueHit > m_svdTrueHits
the storeArray for svdTrueHits as member, is faster than recreating link for each event
Definition: VXDSimpleClusterizerModule.h:89
Belle2::VXDSimpleClusterizerModule::m_pxdTrueHits
StoreArray< PXDTrueHit > m_pxdTrueHits
the storeArray for pxdTrueHits as member, is faster than recreating link for each event
Definition: VXDSimpleClusterizerModule.h:86