Belle II Software  release-05-02-19
MergerCosmicTracksModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015-2016 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Dong Van Thanh, Jakub Kandra *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <alignment/modules/MergerCosmicTracks/MergerCosmicTracksModule.h>
12 
13 #include <cdc/geometry/CDCGeometryPar.h>
14 #include <ecl/dataobjects/ECLConnectedRegion.h>
15 #include <ecl/dataobjects/ECLShower.h>
16 #include <framework/datastore/StoreArray.h>
17 #include <framework/geometry/B2Vector3.h>
18 #include <mdst/dataobjects/KLMCluster.h>
19 #include <mdst/dataobjects/Track.h>
20 #include <tracking/dataobjects/RecoTrack.h>
21 #include <vxd/geometry/GeoCache.h>
22 
23 using namespace Belle2;
24 
25 REG_MODULE(MergerCosmicTracks);
26 
27 MergerCosmicTracksModule::MergerCosmicTracksModule() : Module()
28 {
29  setDescription("Select cosmic events containing two tracks (up/down) and merge two tracks");
30  setPropertyFlags(c_ParallelProcessingCertified);
31 
32  addParam("recoTracksStoreArrayName", m_param_recoTracksStoreArrayName,
33  "StoreArray containing the RecoTracks to read from and delete afterwards.",
34  m_param_recoTracksStoreArrayName);
35  addParam("mergedRecoTracksStoreArrayName", m_param_mergedRecoTracksStoreArrayName,
36  "StoreArray to where to copy the merged RecoTrack.",
37  m_param_mergedRecoTracksStoreArrayName);
38  addParam("usingMagneticField", m_usingMagneticField,
39  "Flag to using magnetic field during reconstruction.",
40  m_usingMagneticField);
41  addParam("minimumNumHitCut", m_minimumNumHitCut, "Number of CDC hit per track required for cosmic track", m_minimumNumHitCut);
42  addParam("minimumClusterSize", m_minimumClusterSize, "Minimal cluster size for used PXD clusters for cosmic track",
43  m_minimumClusterSize);
44 }
45 
46 void MergerCosmicTracksModule::initialize()
47 {
48  StoreArray<Track> tracks;
49  tracks.isRequired();
50 
51  StoreArray<RecoTrack> recoTracks(m_param_recoTracksStoreArrayName);
52  recoTracks.isRequired();
53 
54  StoreArray<RecoTrack> mergedRecoTracks(m_param_mergedRecoTracksStoreArrayName);
55  mergedRecoTracks.registerInDataStore();
56 
57  RecoTrack::registerRequiredRelations(mergedRecoTracks);
58 
59  Belle2::VXD::GeoCache::getInstance();
60  Belle2::CDC::CDCGeometryPar::Instance();
61 }
62 
63 void MergerCosmicTracksModule::MergingTracks(RecoTrack* firstRecoTrack, RecoTrack* secondRecoTrack,
64  StoreArray<RecoTrack> mergedRecoTracks)
65 {
66 
67  // y = exp((-p0+x)/p1) + p2 ; where x ~ ADCCounts/NumberOfCDCHits, y ~ momentum
68  float fittedValuesOfFunctions[3] = {50.2380, 21.9203, 19.8463}; // {p0, p1, p2}
69 
70  // Definition of upper and lower part of CosmicRecoTrack
71  RecoTrack* upperTrack;
72  RecoTrack* lowerTrack;
73 
74  // The RecoTrack with smaller timeSeed is upper
75  if (firstRecoTrack->getTimeSeed() < secondRecoTrack->getTimeSeed()) {
76  upperTrack = firstRecoTrack;
77  lowerTrack = secondRecoTrack;
78  } else {
79  upperTrack = secondRecoTrack;
80  lowerTrack = firstRecoTrack;
81  }
82 
83  // estimation of momentum tracks
84  int numberOfCDCHits = upperTrack->getNumberOfCDCHits() + lowerTrack->getNumberOfCDCHits();
85  float totalADCCount = 0;
86  if (upperTrack->hasCDCHits()) {
87  int CDCHits = upperTrack->getNumberOfCDCHits();
88  for (int i = 0; i < CDCHits; i++) {
89  totalADCCount = totalADCCount + upperTrack->getSortedCDCHitList()[i]->getADCCount();
90  }
91  }
92  if (lowerTrack->hasCDCHits()) {
93  int CDCHits = lowerTrack->getNumberOfCDCHits();
94  for (int i = 0; i < CDCHits; i++) {
95  totalADCCount = totalADCCount + lowerTrack->getSortedCDCHitList()[i]->getADCCount();
96  }
97  }
98  if (totalADCCount / numberOfCDCHits < 115) {
99  // y = exp((-p0+x)/p1) + p2 ; where x ~ ADCCounts/NumberOfCDCHits, y ~ momentum
100  m_magnitudeOfMomentumWithoutMagneticField = exp((-fittedValuesOfFunctions[0] + totalADCCount / numberOfCDCHits) /
101  fittedValuesOfFunctions[1]);
102  } else {
103  m_magnitudeOfMomentumWithoutMagneticField = fittedValuesOfFunctions[2];
104  }
105 
106  // Creation of CosmicRecoTrack
107  RecoTrack* mergedRecoTrack;
108  if (m_usingMagneticField == true) {
109  mergedRecoTrack = mergedRecoTracks.appendNew(upperTrack->getPositionSeed(),
110  upperTrack->getMomentumSeed(),
111  upperTrack->getChargeSeed());
112  } else {
113  B2Vector3D momentum = upperTrack->getMomentumSeed();
114  float magnitudeMomentum = momentum.Mag();
115  float newMomentumX = (momentum.Px() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
116  float newMomentumY = (momentum.Py() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
117  float newMomentumZ = (momentum.Pz() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
118  B2Vector3D newMomentum(newMomentumX, newMomentumY, newMomentumZ);
119  // std::cout << "No Magnetic Field: " << newMomentum.Mag() << "\n";
120  mergedRecoTrack = mergedRecoTracks.appendNew(upperTrack->getPositionSeed(),
121  newMomentum,
122  upperTrack->getChargeSeed());
123  }
124  mergedRecoTrack->setTimeSeed(upperTrack->getTimeSeed());
125 
126  int sortingNumber = 0;
127 
128  if (upperTrack->hasPXDHits()) {
129  int PXDHits = upperTrack->getNumberOfPXDHits();
130  for (int i = 0; i < PXDHits; i++) {
131  if (upperTrack->getSortedPXDHitList()[i]->getSize() > m_minimumClusterSize) {mergedRecoTrack->addPXDHit(upperTrack->getSortedPXDHitList()[i], sortingNumber);}
132  // B2INFO("Cluster size of included PXD hit: " << upperTrack->getSortedPXDHitList()[i]->getSize());
133  sortingNumber++;
134  }
135 
136  }
137 
138  if (lowerTrack->hasPXDHits()) {
139  int PXDHits = lowerTrack->getNumberOfPXDHits();
140  for (int i = 0; i < PXDHits; i++) {
141  if (lowerTrack->getSortedPXDHitList()[i]->getSize() > m_minimumClusterSize) {mergedRecoTrack->addPXDHit(lowerTrack->getSortedPXDHitList()[i], sortingNumber);}
142  // B2INFO("Cluster size of included PXD hit: " << lowerTrack->getSortedPXDHitList()[i]->getSize());
143  sortingNumber++;
144  }
145  }
146 
147  if (upperTrack->hasSVDHits()) {
148  int SVDHits = upperTrack->getNumberOfSVDHits();
149  for (int i = 0; i < SVDHits; i++) {
150  mergedRecoTrack->addSVDHit(upperTrack->getSortedSVDHitList()[i], sortingNumber);
151  sortingNumber++;
152  }
153  }
154 
155  if (lowerTrack->hasSVDHits()) {
156  int SVDHits = lowerTrack->getNumberOfSVDHits();
157  for (int i = 0; i < SVDHits; i++) {
158  mergedRecoTrack->addSVDHit(lowerTrack->getSortedSVDHitList()[i], sortingNumber);
159  sortingNumber++;
160  }
161  }
162 
163 
164  if (upperTrack->hasCDCHits()) {
165  int CDCHits = upperTrack->getNumberOfCDCHits();
166  for (int i = 0; i < CDCHits; i++) {
167  mergedRecoTrack->addCDCHit(upperTrack->getSortedCDCHitList()[i], sortingNumber);
168  sortingNumber++;
169  }
170  }
171 
172  if (lowerTrack->hasCDCHits()) {
173  int CDCHits = lowerTrack->getNumberOfCDCHits();
174  for (int i = CDCHits - 1; i >= 0; i--) {
175  mergedRecoTrack->addCDCHit(lowerTrack->getSortedCDCHitList()[i], sortingNumber);
176  sortingNumber++;
177  }
178  }
179 
180  if (upperTrack->hasBKLMHits()) {
181  int BKLMHits = upperTrack->getNumberOfBKLMHits();
182  for (int i = 0; i < BKLMHits; i++) {
183  mergedRecoTrack->addBKLMHit(upperTrack->getSortedBKLMHitList()[i], sortingNumber);
184  sortingNumber++;
185  }
186  }
187 
188  if (upperTrack->hasEKLMHits()) {
189  int EKLMHits = upperTrack->getNumberOfEKLMHits();
190  for (int i = 0; i < EKLMHits; i++) {
191  mergedRecoTrack->addEKLMHit(upperTrack->getSortedEKLMHitList()[i], sortingNumber);
192  }
193  }
194 
195  if (lowerTrack->hasBKLMHits()) {
196  int BKLMHits = lowerTrack->getNumberOfBKLMHits();
197  for (int i = 0; i < BKLMHits; i++) {
198  mergedRecoTrack->addBKLMHit(lowerTrack->getSortedBKLMHitList()[i], sortingNumber);
199  sortingNumber++;
200  }
201  }
202 
203  if (lowerTrack->hasEKLMHits()) {
204  int EKLMHits = lowerTrack->getNumberOfEKLMHits();
205  for (int i = 0; i < EKLMHits; i++) {
206  mergedRecoTrack->addEKLMHit(lowerTrack->getSortedEKLMHitList()[i], sortingNumber);
207  sortingNumber++;
208  }
209  }
210 }
211 
212 void MergerCosmicTracksModule::event()
213 {
214  StoreArray<ECLConnectedRegion> eclConnectedRegionStoreArray;
215  StoreArray<ECLShower> eclShowerStoreArray;
216  StoreArray<KLMCluster> klmClusterStoreArray;
217  StoreArray<Track> trackStoreArray;
218  StoreArray<RecoTrack> recoTrackStoreArray(m_param_recoTracksStoreArrayName);
219  StoreArray<RecoTrack> mergedRecoTracks(m_param_mergedRecoTracksStoreArrayName);
220 
221  // VXD::GeoCache& geoCache = VXD::GeoCache::getInstance();
222  // CDC::CDCGeometryPar& geometryPar = CDC::CDCGeometryPar::Instance();
223 
224  // numberRecoTracks | numberKLMClusters | numberRecoTracksWithB(E)KLMHits => CosmicRecoTracks
225  // 1 1 1 Create
226  // 1 2 1 Create
227  // 2 1 1 Create
228  // 2 2 2 Create
229  // 2 More than 2 2 Create
230  // More than 2 2 2 Create
231 
232 
233  // Estimation of momentum from dE/dx, when magnetic field is off
234  // y = exp((-p0+x)/p1) + p2 ; where x ~ ADCCounts/NumberOfCDCHits, y ~ momentum
235  float fittedValuesOfFunctions[3] = {50.2380, 21.9203, 19.8463}; // {p0, p1, p2}
236 
237  // bool mergedTracks = false;
238 
239  if (recoTrackStoreArray.getEntries() == 1) {
240  int numberKLMClusterEnoughLayers = 0;
241  for (int i = 0; i < klmClusterStoreArray.getEntries(); i++) {
242  if (klmClusterStoreArray[i]->getLayers() > 4) {
243  numberKLMClusterEnoughLayers++;
244  }
245  }
246 
247  if (eclConnectedRegionStoreArray.getEntries() == 2 || eclConnectedRegionStoreArray.getEntries() == 1
248  || numberKLMClusterEnoughLayers == 2 || numberKLMClusterEnoughLayers == 1) {
249  if (recoTrackStoreArray[0]->getNumberOfCDCHits() > m_minimumNumHitCut) {
250  RelationVector<Track> track = recoTrackStoreArray[0]->getRelationsWith<Track>();
251  if (track.size() != 0) {
252  RelationVector<ECLShower> eclShower = track[0]->getRelationsTo<ECLShower>();
253  if (eclShower.size() != 0 || recoTrackStoreArray[0]->hasEKLMHits() || recoTrackStoreArray[0]->hasBKLMHits()) {
254 
255  int numberOfCDCHits = recoTrackStoreArray[0]->getNumberOfCDCHits();
256  float totalADCCount = 0;
257  if (recoTrackStoreArray[0]->hasCDCHits()) {
258  int CDCHits = recoTrackStoreArray[0]->getNumberOfCDCHits();
259  for (int i = 0; i < CDCHits; i++) {
260  totalADCCount = totalADCCount + recoTrackStoreArray[0]->getSortedCDCHitList()[i]->getADCCount();
261  }
262  }
263  if (totalADCCount / numberOfCDCHits < 115) {
264  // y = exp((-p0+x)/p1) + p2 ; where x ~ ADCCounts/NumberOfCDCHits, y ~ momentum
265  m_magnitudeOfMomentumWithoutMagneticField = exp((-fittedValuesOfFunctions[0] + totalADCCount / numberOfCDCHits) /
266  fittedValuesOfFunctions[1]);
267  } else {
268  m_magnitudeOfMomentumWithoutMagneticField = fittedValuesOfFunctions[2];
269  }
270  RecoTrack* mergedRecoTrack;
271  if (m_usingMagneticField == true) {
272  mergedRecoTrack = mergedRecoTracks.appendNew(recoTrackStoreArray[0]->getPositionSeed(),
273  recoTrackStoreArray[0]->getMomentumSeed(), recoTrackStoreArray[0]->getChargeSeed());
274  } else {
275  B2Vector3D momentum = recoTrackStoreArray[0]->getMomentumSeed();
276  float magnitudeMomentum = momentum.Mag();
277  float newMomentumX = (momentum.Px() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
278  float newMomentumY = (momentum.Py() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
279  float newMomentumZ = (momentum.Pz() * m_magnitudeOfMomentumWithoutMagneticField) / magnitudeMomentum;
280  B2Vector3D newMomentum(newMomentumX, newMomentumY, newMomentumZ);
281  mergedRecoTrack = mergedRecoTracks.appendNew(recoTrackStoreArray[0]->getPositionSeed(),
282  newMomentum, recoTrackStoreArray[0]->getChargeSeed());
283  }
284  mergedRecoTrack->setTimeSeed(recoTrackStoreArray[0]->getTimeSeed());
285 
286  int sortingNumber = 0;
287  if (recoTrackStoreArray[0]->hasPXDHits()) {
288  int PXDHits = recoTrackStoreArray[0]->getNumberOfPXDHits();
289  for (int i = 0; i < PXDHits; i++) {
290  if (recoTrackStoreArray[0]->getSortedPXDHitList()[i]->getSize() > 1) {mergedRecoTrack->addPXDHit(recoTrackStoreArray[0]->getSortedPXDHitList()[i], sortingNumber);}
291  // B2INFO("Cluster size of included PXD hit: " << recoTrackStoreArray[0]->getSortedPXDHitList()[i]->getSize());
292  sortingNumber++;
293  }
294  }
295  if (recoTrackStoreArray[0]->hasSVDHits()) {
296  int SVDHits = recoTrackStoreArray[0]->getNumberOfSVDHits();
297  for (int i = 0; i < SVDHits; i++) {
298  mergedRecoTrack->addSVDHit(recoTrackStoreArray[0]->getSortedSVDHitList()[i], sortingNumber);
299  sortingNumber++;
300  }
301  }
302  if (recoTrackStoreArray[0]->hasCDCHits()) {
303  int CDCHits = recoTrackStoreArray[0]->getNumberOfCDCHits();
304  for (int i = 0; i < CDCHits; i++) {
305  mergedRecoTrack->addCDCHit(recoTrackStoreArray[0]->getSortedCDCHitList()[i], sortingNumber);
306  sortingNumber++;
307  }
308  }
309  if (recoTrackStoreArray[0]->hasBKLMHits()) {
310  int BKLMHits = recoTrackStoreArray[0]->getNumberOfBKLMHits();
311  for (int i = 0; i < BKLMHits; i++) {
312  mergedRecoTrack->addBKLMHit(recoTrackStoreArray[0]->getSortedBKLMHitList()[i], sortingNumber);
313  sortingNumber++;
314  }
315  }
316  if (recoTrackStoreArray[0]->hasEKLMHits()) {
317  int EKLMHits = recoTrackStoreArray[0]->getNumberOfEKLMHits();
318  for (int i = 0; i < EKLMHits; i++) {
319  mergedRecoTrack->addEKLMHit(recoTrackStoreArray[0]->getSortedEKLMHitList()[i], sortingNumber);
320  }
321  }
322  // mergedTracks = true;
323  }
324  }
325  }
326  }
327  }
328 
329  else if (recoTrackStoreArray.getEntries() == 2) {
330  if (recoTrackStoreArray[0]->getNumberOfCDCHits() + recoTrackStoreArray[1]->getNumberOfCDCHits() > m_minimumNumHitCut) {
331  RelationVector<Track> trackFirst = recoTrackStoreArray[0]->getRelationsWith<Track>();
332  RelationVector<Track> trackSecond = recoTrackStoreArray[1]->getRelationsWith<Track>();
333  if (trackFirst.size() != 0 && trackSecond.size() != 0) {
334  RelationVector<ECLShower> eclShowerFirst = trackFirst[0]->getRelationsTo<ECLShower>();
335  RelationVector<ECLShower> eclShowerSecond = trackSecond[0]->getRelationsTo<ECLShower>();
336  if ((eclShowerFirst.size() != 0 && eclShowerSecond.size() != 0) || ((recoTrackStoreArray[0]->hasEKLMHits()
337  || recoTrackStoreArray[0]->hasBKLMHits()) && (recoTrackStoreArray[1]->hasEKLMHits() || recoTrackStoreArray[1]->hasBKLMHits()))) {
338  if (eclConnectedRegionStoreArray.getEntries() >= 2 || klmClusterStoreArray.getEntries() >= 2) {
339  MergingTracks(recoTrackStoreArray[0], recoTrackStoreArray[1], mergedRecoTracks);
340  // mergedTracks = true;
341  }
342  } else if (eclShowerFirst.size() != 0 || eclShowerSecond.size() != 0 || recoTrackStoreArray[0]->hasEKLMHits()
343  || recoTrackStoreArray[0]->hasBKLMHits() || recoTrackStoreArray[1]->hasEKLMHits() || recoTrackStoreArray[1]->hasBKLMHits()) {
344  if (eclConnectedRegionStoreArray.getEntries() == 2 || eclConnectedRegionStoreArray.getEntries() == 1
345  || klmClusterStoreArray.getEntries() == 2 || klmClusterStoreArray.getEntries() == 1) {
346  MergingTracks(recoTrackStoreArray[0], recoTrackStoreArray[1], mergedRecoTracks);
347  // mergedTracks = true;
348  }
349  }
350  }
351  }
352  }
353 
354  else {
355  for (int i = 0; i < recoTrackStoreArray.getEntries(); i++) {
356  RelationVector<Track> trackFirst = recoTrackStoreArray[i]->getRelationsWith<Track>();
357  if (trackFirst.size() != 0) {
358  for (int j = i + 1; j < recoTrackStoreArray.getEntries(); j++) {
359  RelationVector<Track> trackSecond = recoTrackStoreArray[j]->getRelationsWith<Track>();
360  if (trackSecond.size() != 0) {
361  if (recoTrackStoreArray[i]->getNumberOfCDCHits() + recoTrackStoreArray[j]->getNumberOfCDCHits() > m_minimumNumHitCut) {
362  RelationVector<ECLShower> eclShowerFirst = trackFirst[0]->getRelationsTo<ECLShower>();
363  RelationVector<ECLShower> eclShowerSecond = trackSecond[0]->getRelationsTo<ECLShower>();
364  if (eclShowerFirst.size() != 0 && eclShowerSecond.size() != 0) {
365  if (eclShowerFirst[0]->getRelationsWith<Track>().size() == 1 && eclShowerSecond[0]->getRelationsWith<Track>().size() == 1) {
366  MergingTracks(recoTrackStoreArray[i], recoTrackStoreArray[j], mergedRecoTracks);
367  // mergedTracks = true;
368  }
369  } else if ((recoTrackStoreArray[i]->hasEKLMHits() || recoTrackStoreArray[i]->hasBKLMHits())
370  && (recoTrackStoreArray[j]->hasEKLMHits() || recoTrackStoreArray[j]->hasBKLMHits())) {
371  if (recoTrackStoreArray[i]->getNumberOfBKLMHits() + recoTrackStoreArray[i]->getNumberOfEKLMHits() > 3
372  && recoTrackStoreArray[j]->getNumberOfBKLMHits() + recoTrackStoreArray[j]->getNumberOfEKLMHits() > 3) {
373  MergingTracks(recoTrackStoreArray[i], recoTrackStoreArray[j], mergedRecoTracks);
374  // mergedTracks = true;
375  }
376  }
377  }
378  }
379  }
380  }
381  }
382  }
383 }
Belle2::RecoTrack::getNumberOfPXDHits
unsigned int getNumberOfPXDHits() const
Return the number of pxd hits.
Definition: RecoTrack.h:423
Belle2::RelationVector::size
size_t size() const
Get number of relations.
Definition: RelationVector.h:98
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::RecoTrack::getSortedEKLMHitList
std::vector< Belle2::RecoTrack::UsedEKLMHit * > getSortedEKLMHitList() const
Return a sorted list of eklm hits. Sorted by the sortingParameter.
Definition: RecoTrack.h:473
Belle2::RecoTrack::registerRequiredRelations
static void registerRequiredRelations(StoreArray< RecoTrack > &recoTracks, std::string const &pxdHitsStoreArrayName="", std::string const &svdHitsStoreArrayName="", std::string const &cdcHitsStoreArrayName="", std::string const &bklmHitsStoreArrayName="", std::string const &eklmHitsStoreArrayName="", std::string const &recoHitInformationStoreArrayName="")
Convenience method which registers all relations required to fully use a RecoTrack.
Definition: RecoTrack.cc:42
Belle2::RecoTrack::getNumberOfBKLMHits
unsigned int getNumberOfBKLMHits() const
Return the number of bklm hits.
Definition: RecoTrack.h:426
Belle2::MergerCosmicTracksModule::m_usingMagneticField
bool m_usingMagneticField
Flag to using magnetic field during reconstruction.
Definition: MergerCosmicTracksModule.h:55
Belle2::RecoTrack::setTimeSeed
void setTimeSeed(const double timeSeed)
Set the time seed. ATTENTION: This is not the fitted time.
Definition: RecoTrack.h:520
Belle2::MergerCosmicTracksModule::m_magnitudeOfMomentumWithoutMagneticField
double m_magnitudeOfMomentumWithoutMagneticField
Magnitude of cosmic tracks if magnetic field is not used.
Definition: MergerCosmicTracksModule.h:61
Belle2::MergerCosmicTracksModule::MergingTracks
void MergingTracks(RecoTrack *, RecoTrack *, StoreArray< RecoTrack >)
Merge cosmic tracks.
Definition: MergerCosmicTracksModule.cc:63
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:216
Belle2::RecoTrack::getSortedPXDHitList
std::vector< Belle2::RecoTrack::UsedPXDHit * > getSortedPXDHitList() const
Return a sorted list of pxd hits. Sorted by the sortingParameter.
Definition: RecoTrack.h:467
Belle2::MergerCosmicTracksModule::m_minimumClusterSize
unsigned int m_minimumClusterSize
Minimal PXD cluster size for used PXD hits in cosmic track.
Definition: MergerCosmicTracksModule.h:59
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:82
Belle2::RecoTrack::getNumberOfSVDHits
unsigned int getNumberOfSVDHits() const
Return the number of svd hits.
Definition: RecoTrack.h:420
Belle2::MergerCosmicTracksModule::m_param_mergedRecoTracksStoreArrayName
std::string m_param_mergedRecoTracksStoreArrayName
StoreArray name where the merged reco track is written.
Definition: MergerCosmicTracksModule.h:53
Belle2::MergerCosmicTracksModule::MergerCosmicTracksModule
MergerCosmicTracksModule()
Create a new instance of the module.
Definition: MergerCosmicTracksModule.cc:27
Belle2::RecoTrack::hasSVDHits
bool hasSVDHits() const
Returns true if the track has svd hits.
Definition: RecoTrack.h:394
Belle2::RecoTrack::getSortedBKLMHitList
std::vector< Belle2::RecoTrack::UsedBKLMHit * > getSortedBKLMHitList() const
Return a sorted list of bklm hits. Sorted by the sortingParameter.
Definition: RecoTrack.h:470
Belle2::MergerCosmicTracksModule::event
void event() override
Do the selection.
Definition: MergerCosmicTracksModule.cc:212
Belle2::B2Vector3< double >
Belle2::RecoTrack::addCDCHit
bool addCDCHit(const UsedCDCHit *cdcHit, const unsigned int sortingParameter, RightLeftInformation rightLeftInformation=RightLeftInformation::c_undefinedRightLeftInformation, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a cdc hit with the given information to the reco track.
Definition: RecoTrack.h:240
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2::RecoTrack::addEKLMHit
bool addEKLMHit(const UsedEKLMHit *eklmHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds an eklm hit with the given information to the reco track.
Definition: RecoTrack.h:297
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:210
Belle2::RecoTrack::getTimeSeed
double getTimeSeed() const
Return the time seed stored in the reco track. ATTENTION: This is not the fitted time.
Definition: RecoTrack.h:500
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:78
Belle2::RecoTrack::getPositionSeed
TVector3 getPositionSeed() const
Return the position seed stored in the reco track. ATTENTION: This is not the fitted position.
Definition: RecoTrack.h:477
Belle2::RelationVector
Class for type safe access to objects that are referred to in relations.
Definition: DataStore.h:38
Belle2::RecoTrack::hasEKLMHits
bool hasEKLMHits() const
Returns true if the track has eklm hits.
Definition: RecoTrack.h:403
Belle2::MergerCosmicTracksModule::m_minimumNumHitCut
unsigned int m_minimumNumHitCut
Number of CDC hit per track required for cosmic track.
Definition: MergerCosmicTracksModule.h:57
Belle2::CDC::CDCGeometryPar::Instance
static CDCGeometryPar & Instance(const CDCGeometry *=nullptr)
Static method to get a reference to the CDCGeometryPar instance.
Definition: CDCGeometryPar.cc:41
Belle2::RecoTrack::addSVDHit
bool addSVDHit(const UsedSVDHit *svdHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a svd hit with the given information to the reco track.
Definition: RecoTrack.h:269
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:215
Belle2::RecoTrack::getSortedSVDHitList
std::vector< Belle2::RecoTrack::UsedSVDHit * > getSortedSVDHitList() const
Return a sorted list of svd hits. Sorted by the sortingParameter.
Definition: RecoTrack.h:464
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::RecoTrack::addBKLMHit
bool addBKLMHit(const UsedBKLMHit *bklmHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a bklm hit with the given information to the reco track.
Definition: RecoTrack.h:283
Belle2::RecoTrack::getSortedCDCHitList
std::vector< Belle2::RecoTrack::UsedCDCHit * > getSortedCDCHitList() const
Return a sorted list of cdc hits. Sorted by the sortingParameter.
Definition: RecoTrack.h:461
Belle2::RecoTrack::hasCDCHits
bool hasCDCHits() const
Returns true if the track has cdc hits.
Definition: RecoTrack.h:391
Belle2::RecoTrack::getNumberOfCDCHits
unsigned int getNumberOfCDCHits() const
Return the number of cdc hits.
Definition: RecoTrack.h:417
Belle2::RecoTrack::getMomentumSeed
TVector3 getMomentumSeed() const
Return the momentum seed stored in the reco track. ATTENTION: This is not the fitted momentum.
Definition: RecoTrack.h:484
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:562
Belle2::Track
Class that bundles various TrackFitResults.
Definition: Track.h:35
Belle2::RecoTrack::getChargeSeed
short int getChargeSeed() const
Return the charge seed stored in the reco track. ATTENTION: This is not the fitted charge.
Definition: RecoTrack.h:497
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::RecoTrack::hasPXDHits
bool hasPXDHits() const
Returns true if the track has pxd hits.
Definition: RecoTrack.h:397
Belle2::RecoTrack::getNumberOfEKLMHits
unsigned int getNumberOfEKLMHits() const
Return the number of eklm hits.
Definition: RecoTrack.h:429
Belle2::MergerCosmicTracksModule::m_param_recoTracksStoreArrayName
std::string m_param_recoTracksStoreArrayName
StoreArray name from which to read the reco tracks.
Definition: MergerCosmicTracksModule.h:51
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226
Belle2::RecoTrack::addPXDHit
bool addPXDHit(const UsedPXDHit *pxdHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a pxd hit with the given information to the reco track.
Definition: RecoTrack.h:255
Belle2::MergerCosmicTracksModule::initialize
void initialize() override
Register the store arrays and store obj pointers.
Definition: MergerCosmicTracksModule.cc:46
Belle2::RecoTrack::hasBKLMHits
bool hasBKLMHits() const
Returns true if the track has bklm hits.
Definition: RecoTrack.h:400
Belle2::ECLShower
Class to store ECL Showers.
Definition: ECLShower.h:42