Belle II Software  release-05-01-25
MeasurementAdder.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Nils Braun *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 #include <tracking/trackFitting/measurementCreator/adder/MeasurementAdder.h>
11 #include <tracking/trackFitting/measurementCreator/creators/CoordinateMeasurementCreator.h>
12 
13 #include <cdc/dataobjects/CDCRecoHit.h>
14 #include <pxd/reconstruction/PXDRecoHit.h>
15 #include <svd/reconstruction/SVDRecoHit.h>
16 #include <alignment/reconstruction/AlignableBKLMRecoHit.h>
17 #include <alignment/reconstruction/AlignableEKLMRecoHit.h>
18 
19 #include <cdc/translators/LinearGlobalADCCountTranslator.h>
20 #include <cdc/translators/RealisticCDCGeometryTranslator.h>
21 #include <cdc/translators/RealisticTDCCountTranslator.h>
22 
23 #include <genfit/MeasurementFactory.h>
24 #include <string>
25 
26 using namespace Belle2;
27 
28 
29 namespace {
31  template <class T>
32  bool checkTwoStoreArrayNames(const std::string& firstName, const std::string& secondName)
33  {
34  return ((firstName == secondName) or
35  (firstName.empty() and secondName == DataStore::defaultArrayName<T>()) or
36  (secondName.empty() and firstName == DataStore::defaultArrayName<T>()));
37  }
38 }
39 
41  const std::string& storeArrayNameOfPXDHits,
42  const std::string& storeArrayNameOfSVDHits,
43  const std::string& storeArrayNameOfCDCHits,
44  const std::string& storeArrayNameOfBKLMHits,
45  const std::string& storeArrayNameOfEKLMHits,
46  const bool initializeCDCTranslators) :
47  m_param_storeArrayNameOfPXDHits(storeArrayNameOfPXDHits),
48  m_param_storeArrayNameOfSVDHits(storeArrayNameOfSVDHits),
49  m_param_storeArrayNameOfCDCHits(storeArrayNameOfCDCHits),
50  m_param_storeArrayNameOfBKLMHits(storeArrayNameOfBKLMHits),
51  m_param_storeArrayNameOfEKLMHits(storeArrayNameOfEKLMHits)
52 {
56  if (initializeCDCTranslators) {
57  // Create new Translators and give them to the CDCRecoHits.
61  true);
62  }
65 }
66 
68 {
74 
75  // Create the related measurement factory
76  if (pxdHits.isOptional())
79  if (svdHits.isOptional())
82  if (cdcHits.isOptional())
85  if (bklmHits.isOptional())
88  if (eklmHits.isOptional())
91 }
92 
94 {
95  m_pxdMeasurementCreators = { std::shared_ptr<PXDBaseMeasurementCreator>(new PXDCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
96  m_svdMeasurementCreators = { std::shared_ptr<SVDBaseMeasurementCreator>(new SVDCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
97  m_cdcMeasurementCreators = { std::shared_ptr<CDCBaseMeasurementCreator>(new CDCCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
98  m_bklmMeasurementCreators = { std::shared_ptr<BKLMBaseMeasurementCreator>(new BKLMCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
99  m_eklmMeasurementCreators = { std::shared_ptr<EKLMBaseMeasurementCreator>(new EKLMCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
101 
102  m_skipDirtyCheck = false;
103 }
104 
106  const std::vector<std::shared_ptr<PXDBaseMeasurementCreator>>& pxdMeasurementCreators,
107  const std::vector<std::shared_ptr<SVDBaseMeasurementCreator>>& svdMeasurementCreators,
108  const std::vector<std::shared_ptr<CDCBaseMeasurementCreator>>& cdcMeasurementCreators,
109  const std::vector<std::shared_ptr<BKLMBaseMeasurementCreator>>& bklmMeasurementCreators,
110  const std::vector<std::shared_ptr<EKLMBaseMeasurementCreator>>& eklmMeasurementCreators,
111  const std::vector<std::shared_ptr<BaseMeasurementCreator>>& additionalMeasurementCreators)
112 {
113  m_pxdMeasurementCreators = pxdMeasurementCreators;
114  m_svdMeasurementCreators = svdMeasurementCreators;
115  m_cdcMeasurementCreators = cdcMeasurementCreators;
116  m_bklmMeasurementCreators = bklmMeasurementCreators;
117  m_eklmMeasurementCreators = eklmMeasurementCreators;
118  m_additionalMeasurementCreators = additionalMeasurementCreators;
119 
120  m_skipDirtyCheck = true;
121 }
122 
124  const std::map<std::string, std::map<std::string, std::string>>& pxdMeasurementCreators,
125  const std::map<std::string, std::map<std::string, std::string>>& svdMeasurementCreators,
126  const std::map<std::string, std::map<std::string, std::string>>& cdcMeasurementCreators,
127  const std::map<std::string, std::map<std::string, std::string>>& bklmMeasurementCreators,
128  const std::map<std::string, std::map<std::string, std::string>>& eklmMeasurementCreators,
129  const std::map<std::string, std::map<std::string, std::string>>& additionalMeasurementCreators)
130 {
131  PXDMeasurementCreatorFactory pxdMeasurementCreatorFactory(m_genfitMeasurementFactory);
132  SVDMeasurementCreatorFactory svdMeasurementCreatorFactory(m_genfitMeasurementFactory);
133  CDCMeasurementCreatorFactory cdcMeasurementCreatorFactory(m_genfitMeasurementFactory);
134  BKLMMeasurementCreatorFactory bklmMeasurementCreatorFactory(m_genfitMeasurementFactory);
135  EKLMMeasurementCreatorFactory eklmMeasurementCreatorFactory(m_genfitMeasurementFactory);
136  AdditionalMeasurementCreatorFactory additionalMeasurementCreatorFactory;
137 
138  pxdMeasurementCreatorFactory.setParameters(pxdMeasurementCreators);
139  svdMeasurementCreatorFactory.setParameters(svdMeasurementCreators);
140  cdcMeasurementCreatorFactory.setParameters(cdcMeasurementCreators);
141  bklmMeasurementCreatorFactory.setParameters(bklmMeasurementCreators);
142  eklmMeasurementCreatorFactory.setParameters(eklmMeasurementCreators);
143  additionalMeasurementCreatorFactory.setParameters(additionalMeasurementCreators);
144 
145  pxdMeasurementCreatorFactory.initialize();
146  svdMeasurementCreatorFactory.initialize();
147  cdcMeasurementCreatorFactory.initialize();
148  bklmMeasurementCreatorFactory.initialize();
149  eklmMeasurementCreatorFactory.initialize();
150  additionalMeasurementCreatorFactory.initialize();
151 
152  m_pxdMeasurementCreators = pxdMeasurementCreatorFactory.getCreators();
153  m_svdMeasurementCreators = svdMeasurementCreatorFactory.getCreators();
154  m_cdcMeasurementCreators = cdcMeasurementCreatorFactory.getCreators();
155  m_bklmMeasurementCreators = bklmMeasurementCreatorFactory.getCreators();
156  m_eklmMeasurementCreators = eklmMeasurementCreatorFactory.getCreators();
157  m_additionalMeasurementCreators = additionalMeasurementCreatorFactory.getCreators();
158 
159  m_skipDirtyCheck = true;
160 }
161 
163 {
164  B2ASSERT("Reco Track was built with another CDC store array: Reco Track "
165  << recoTrack.getStoreArrayNameOfCDCHits()
166  << ", this class " << m_param_storeArrayNameOfCDCHits,
167  checkTwoStoreArrayNames<RecoHitInformation::UsedCDCHit>(recoTrack.getStoreArrayNameOfCDCHits(), m_param_storeArrayNameOfCDCHits));
168  B2ASSERT("Reco Track was built with another SVD store array: Reco Track "
169  << recoTrack.getStoreArrayNameOfSVDHits()
170  << ", this class " << m_param_storeArrayNameOfSVDHits,
171  checkTwoStoreArrayNames<RecoHitInformation::UsedSVDHit>(recoTrack.getStoreArrayNameOfSVDHits(), m_param_storeArrayNameOfSVDHits));
172  B2ASSERT("Reco Track was built with another PXD store array: Reco Track "
173  << recoTrack.getStoreArrayNameOfPXDHits()
174  << ", this class " << m_param_storeArrayNameOfPXDHits,
175  checkTwoStoreArrayNames<RecoHitInformation::UsedPXDHit>(recoTrack.getStoreArrayNameOfPXDHits(), m_param_storeArrayNameOfPXDHits));
176  B2ASSERT("Reco Track was built with another BKLM store array: Reco Track "
177  << recoTrack.getStoreArrayNameOfBKLMHits()
178  << ", this class " << m_param_storeArrayNameOfBKLMHits,
179  checkTwoStoreArrayNames<RecoHitInformation::UsedBKLMHit>(recoTrack.getStoreArrayNameOfBKLMHits(),
181  B2ASSERT("Reco Track was built with another EKLM store array: Reco Track "
182  << recoTrack.getStoreArrayNameOfEKLMHits()
183  << ", this class " << m_param_storeArrayNameOfEKLMHits,
184  checkTwoStoreArrayNames<RecoHitInformation::UsedEKLMHit>(recoTrack.getStoreArrayNameOfEKLMHits(),
186 
187  if (m_cdcMeasurementCreators.size() == 0 and m_svdMeasurementCreators.size() == 0 and m_pxdMeasurementCreators.size() == 0 and
188  m_bklmMeasurementCreators.size() == 0 and m_eklmMeasurementCreators.size() == 0 and m_additionalMeasurementCreators.size() == 0) {
189  B2WARNING("No measurement creators where added to this instance, so no measurements where created. Did you forget to call setMeasurementCreators?");
190  return false;
191  }
192 
193  if (not recoTrack.getDirtyFlag() and not m_skipDirtyCheck) {
194  B2DEBUG(100, "Hit content did not change since last measurement adding and you are using default parameters." <<
195  "I will not add the measurements again. " <<
196  "If you still want to do so, set the dirty flag to true.");
197  return false;
198  }
199 
200  // Delete all other measurements.
202  recoTrack.setDirtyFlag();
203 
204  std::map<genfit::TrackPoint*, RecoHitInformation*> trackPointHitMapping;
205 
206  // Add the measurements created by the CDC, SVD and PXD measurement creators.
209  addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedPXDHit, Const::PXD>(recoTrack, recoHitInformation, pxdHit,
210  m_pxdMeasurementCreators, trackPointHitMapping);
211  });
214  addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedSVDHit, Const::SVD>(recoTrack, recoHitInformation, svdHit,
215  m_svdMeasurementCreators, trackPointHitMapping);
216  });
219  addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedCDCHit, Const::CDC>(recoTrack, recoHitInformation, cdcHit,
220  m_cdcMeasurementCreators, trackPointHitMapping);
221  });
224  addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedBKLMHit, Const::BKLM>(recoTrack, recoHitInformation, bklmHit,
225  m_bklmMeasurementCreators, trackPointHitMapping);
226  });
229  addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedEKLMHit, Const::EKLM>(recoTrack, recoHitInformation, EKLMHit,
230  m_eklmMeasurementCreators, trackPointHitMapping);
231  });
232 
233  // Special case is with the additional measurement creator factories. They do not need any hits:
235 
236  auto& genfitTrack = RecoTrackGenfitAccess::getGenfitTrack(recoTrack);
237 
238  genfitTrack.sort();
239 
240  // FIXME: hotfix:
241  // after we have a mapping between created track points and reco track information, we can use this mapping to
242  // write it back to the reco hit information. Please note, that we only store a single index for each
243  // reco hit information (although there could be multiple track points).
244  // We also assume that the track point vector is never changed again!
245  int counter = 0;
246  for (genfit::TrackPoint* trackPoint : genfitTrack.getPoints()) {
247  trackPointHitMapping[trackPoint]->setCreatedTrackPointID(counter);
248  counter += 1;
249  }
250 
251  return true;
252 }
253 
255  const std::vector<std::shared_ptr<BaseMeasurementCreator>>& measurementCreators) const
256 {
257  for (const auto& measurementCreator : measurementCreators) {
258  const std::vector<genfit::TrackPoint*>& trackPoints = measurementCreator->createMeasurementPoints(recoTrack);
259  for (genfit::TrackPoint* trackPoint : trackPoints) {
260  RecoTrackGenfitAccess::getGenfitTrack(recoTrack).insertPoint(trackPoint);
261  }
262  }
263 }
Belle2::MeasurementAdder::m_svdMeasurementCreators
std::vector< std::shared_ptr< SVDBaseMeasurementCreator > > m_svdMeasurementCreators
Internal storage of the SVD measurement creators.
Definition: MeasurementAdder.h:171
genfit::TrackPoint
Object containing AbsMeasurement and AbsFitterInfo objects.
Definition: TrackPoint.h:46
Belle2::PXDMeasurementCreatorFactory
Add all measurement creators related to PXD hits.
Definition: PXDMeasurementCreatorFactory.h:30
Belle2::MeasurementAdder::addMeasurements
bool addMeasurements(RecoTrack &recoTrack) const
After you have filled the internal storage with measurement creators (either by providing your own or...
Definition: MeasurementAdder.cc:162
Belle2::MeasurementAdder::MeasurementAdder
MeasurementAdder(const std::string &storeArrayNameOfPXDHits, const std::string &storeArrayNameOfSVDHits, const std::string &storeArrayNameOfCDCHits, const std::string &storeArrayNameOfBKLMHits, const std::string &storeArrayNameOfEKLMHits, const bool initializeCDCTranslators=true)
Create a new instance of the measurement adder.
Definition: MeasurementAdder.cc:40
Belle2::RecoTrackGenfitAccess::getGenfitTrack
static genfit::Track & getGenfitTrack(RecoTrack &recoTrack)
Give access to the RecoTrack's genfit::Track.
Definition: RecoTrack.cc:389
Belle2::CDC::RealisticTDCCountTranslator
Translator mirroring the realistic Digitization.
Definition: RealisticTDCCountTranslator.h:36
Belle2::CDCHit
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition: CDCHit.h:51
Belle2::CDC::LinearGlobalADCCountTranslator
This class simply assumes a linear translation through (0,0)
Definition: LinearGlobalADCCountTranslator.h:31
genfit::Track::insertPoint
void insertPoint(TrackPoint *point, int id=-1)
Insert TrackPoint BEFORE TrackPoint with position id, if id >= 0.
Definition: Track.cc:360
Belle2::MeasurementAdder::m_param_storeArrayNameOfBKLMHits
std::string m_param_storeArrayNameOfBKLMHits
The name of the store array for the BKLM hits.
Definition: MeasurementAdder.h:162
Belle2::RecoTrack::setDirtyFlag
void setDirtyFlag(const bool &dirtyFlag=true)
Set to true, if you want to rebuild the measurements and do the fit independent on changes of the hit...
Definition: RecoTrack.h:621
Belle2::MeasurementAdder::m_skipDirtyCheck
bool m_skipDirtyCheck
Flag to skip the dirty check. Useful when using non default measurement creators.
Definition: MeasurementAdder.h:166
Belle2::MeasurementAdder::m_genfitMeasurementFactory
genfit::MeasurementFactory< genfit::AbsMeasurement > m_genfitMeasurementFactory
Internal storage of the genfit measurement factory;.
Definition: MeasurementAdder.h:182
Belle2::MeasurementAdder::resetMeasurementCreatorsToDefaultSettings
void resetMeasurementCreatorsToDefaultSettings()
Reset the internal measurement creator storage to the default settings.
Definition: MeasurementAdder.cc:93
Belle2::CDCCoordinateMeasurementCreator
CoordinateMeasurementCreator< RecoHitInformation::UsedCDCHit, Const::CDC > CDCCoordinateMeasurementCreator
Needed for templating.
Definition: CoordinateMeasurementCreator.h:46
Belle2::MeasurementAdder::m_param_storeArrayNameOfEKLMHits
std::string m_param_storeArrayNameOfEKLMHits
The name of the store array for the EKLM hits.
Definition: MeasurementAdder.h:164
Belle2::CDCRecoHit::setTranslators
static void setTranslators(CDC::ADCCountTranslatorBase *const adcCountTranslator, CDC::CDCGeometryTranslatorBase *const cdcGeometryTranslator, CDC::TDCCountTranslatorBase *const tdcCountTranslator, bool useTrackTime=false, bool cosmics=false)
Setter for the Translators.
Definition: CDCRecoHit.cc:35
Belle2::EKLMMeasurementCreatorFactory
Add all measurement creators related to EKLM hits.
Definition: EKLMMeasurementCreatorFactory.h:29
Belle2::RecoTrack::getStoreArrayNameOfPXDHits
const std::string & getStoreArrayNameOfPXDHits() const
Name of the store array of the pxd hits.
Definition: RecoTrack.h:637
genfit::MeasurementProducer
Template class for a measurement producer module.
Definition: MeasurementProducer.h:76
Belle2::EKLMAlignmentHit
This dataobject is used only for EKLM alignment.
Definition: EKLMAlignmentHit.h:39
Belle2::MeasurementAdder::m_param_storeArrayNameOfSVDHits
std::string m_param_storeArrayNameOfSVDHits
The name of the store array for the SVD hits.
Definition: MeasurementAdder.h:158
genfit::Track::deleteTrackPointsAndFitStatus
void deleteTrackPointsAndFitStatus()
Delete all measurement information and the track points of the track. Does not delete track represent...
Definition: Track.cc:1624
Belle2::MeasurementAdder::resetMeasurementCreatorsUsingFactories
void resetMeasurementCreatorsUsingFactories(const std::map< std::string, std::map< std::string, std::string >> &pxdMeasurementCreators, const std::map< std::string, std::map< std::string, std::string >> &svdMeasurementCreators, const std::map< std::string, std::map< std::string, std::string >> &cdcMeasurementCreators, const std::map< std::string, std::map< std::string, std::string >> &bklmMeasurementCreators, const std::map< std::string, std::map< std::string, std::string >> &eklmMeasurementCreators, const std::map< std::string, std::map< std::string, std::string >> &additionalMeasurementCreators)
If you want to use non-default settings for the store arrays, you can create your own instances of th...
Definition: MeasurementAdder.cc:123
Belle2::MeasurementAdder::resetMeasurementCreators
void resetMeasurementCreators(const std::vector< std::shared_ptr< PXDBaseMeasurementCreator >> &pxdMeasurementCreators, const std::vector< std::shared_ptr< SVDBaseMeasurementCreator >> &svdMeasurementCreators, const std::vector< std::shared_ptr< CDCBaseMeasurementCreator >> &cdcMeasurementCreators, const std::vector< std::shared_ptr< BKLMBaseMeasurementCreator >> &bklmMeasurementCreators, const std::vector< std::shared_ptr< EKLMBaseMeasurementCreator >> &eklmMeasurementCreators, const std::vector< std::shared_ptr< BaseMeasurementCreator >> &additionalMeasurementCreators)
If you want to use non-default settings for the store arrays, you can create your own instances of th...
Definition: MeasurementAdder.cc:105
Belle2::BKLMCoordinateMeasurementCreator
CoordinateMeasurementCreator< RecoHitInformation::UsedBKLMHit, Const::BKLM > BKLMCoordinateMeasurementCreator
Hit to reco hit measurement creator for the BKLM.
Definition: CoordinateMeasurementCreator.h:52
Belle2::MeasurementCreatorFactory::getCreators
const std::vector< std::shared_ptr< BaseMeasurementCreatorType > > & getCreators() const
Return the creators to the module.
Definition: MeasurementCreatorFactory.h:77
Belle2::MeasurementAdder::m_additionalMeasurementCreators
std::vector< std::shared_ptr< BaseMeasurementCreator > > m_additionalMeasurementCreators
Internal storage of the additional measurement creators.
Definition: MeasurementAdder.h:179
Belle2::CDC::RealisticCDCGeometryTranslator
This class uses the realistic detector geometry (the one after alignment procedure) for the translati...
Definition: RealisticCDCGeometryTranslator.h:32
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:78
Belle2::SVDCoordinateMeasurementCreator
CoordinateMeasurementCreator< RecoHitInformation::UsedSVDHit, Const::SVD > SVDCoordinateMeasurementCreator
Hit to reco hit measurement creator for the SVD.
Definition: CoordinateMeasurementCreator.h:48
Belle2::CDCMeasurementCreatorFactory
Add all measurement creators related to CDC hits.
Definition: CDCMeasurementCreatorFactory.h:29
Belle2::RecoTrack::getStoreArrayNameOfCDCHits
const std::string & getStoreArrayNameOfCDCHits() const
Name of the store array of the cdc hits.
Definition: RecoTrack.h:631
Belle2::RecoTrack::mapOnHits
void mapOnHits(const std::string &storeArrayNameOfHits, std::function< void(RecoHitInformation &, HitType *)> const &mapFunction, std::function< bool(const RecoHitInformation &, const HitType *)> const &pickFunction)
Call a function on all hits of the given type in the store array, that are related to this track.
Definition: RecoTrack.h:655
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::MeasurementAdder::addMeasurementsToRecoTrack
void addMeasurementsToRecoTrack(RecoTrack &recoTrack, const std::vector< std::shared_ptr< BaseMeasurementCreator >> &measurementCreators) const
Helper: Go through all measurement creators in the given list and create the measurement without a gi...
Definition: MeasurementAdder.cc:254
Belle2::MeasurementCreatorFactory::setParameters
void setParameters(const std::map< std::string, std::map< std::string, std::string >> &creatorsWithParametersDictionary)
Set the parameters.
Definition: MeasurementCreatorFactory.h:89
genfit::MeasurementFactory::addProducer
void addProducer(int detID, AbsMeasurementProducer< measurement_T > *hitProd)
Register a producer module to the factory.
Definition: MeasurementFactory.h:97
Belle2::RecoHitInformation
This class stores additional information to every CDC/SVD/PXD hit stored in a RecoTrack.
Definition: RecoHitInformation.h:48
Belle2::MeasurementAdder::m_param_storeArrayNameOfCDCHits
std::string m_param_storeArrayNameOfCDCHits
The name of the store array for the CDC hits.
Definition: MeasurementAdder.h:160
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:41
Belle2::MeasurementAdder::m_bklmMeasurementCreators
std::vector< std::shared_ptr< BKLMBaseMeasurementCreator > > m_bklmMeasurementCreators
Internal storage of the BKLM measurement creators.
Definition: MeasurementAdder.h:175
Belle2::MeasurementAdder::m_cdcMeasurementCreators
std::vector< std::shared_ptr< CDCBaseMeasurementCreator > > m_cdcMeasurementCreators
Internal storage of the CDC measurement creators.
Definition: MeasurementAdder.h:173
Belle2::SVDMeasurementCreatorFactory
Add all measurement creators related to SVD hits.
Definition: SVDMeasurementCreatorFactory.h:30
Belle2::EKLMCoordinateMeasurementCreator
CoordinateMeasurementCreator< RecoHitInformation::UsedEKLMHit, Const::EKLM > EKLMCoordinateMeasurementCreator
Hit to reco hit measurement creator for the EKLM.
Definition: CoordinateMeasurementCreator.h:54
Belle2::BKLMMeasurementCreatorFactory
Add all measurement creators related to BKLM hits.
Definition: BKLMMeasurementCreatorFactory.h:29
Belle2::StoreArray::getPtr
TClonesArray * getPtr() const
Raw access to the underlying TClonesArray.
Definition: StoreArray.h:321
Belle2::SVDCluster
The SVD Cluster class This class stores all information about reconstructed SVD clusters.
Definition: SVDCluster.h:38
Belle2::MeasurementAdder::m_pxdMeasurementCreators
std::vector< std::shared_ptr< PXDBaseMeasurementCreator > > m_pxdMeasurementCreators
Internal storage of the PXD measurement creators.
Definition: MeasurementAdder.h:169
Belle2::RecoTrack::getDirtyFlag
bool getDirtyFlag() const
This returns true, if a hit was added after the last fit and measurement creation and a refit should ...
Definition: RecoTrack.h:614
Belle2::MeasurementAdder::m_eklmMeasurementCreators
std::vector< std::shared_ptr< EKLMBaseMeasurementCreator > > m_eklmMeasurementCreators
Internal storage of the EKLM measurement creators.
Definition: MeasurementAdder.h:177
Belle2::AdditionalMeasurementCreatorFactory
Add measurement creators that do not rely on a specific hit type, but rather add measurements without...
Definition: AdditionalMeasurementCreatorFactory.h:29
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::MeasurementAdder::m_param_storeArrayNameOfPXDHits
std::string m_param_storeArrayNameOfPXDHits
The name of the store array for the PXD hits.
Definition: MeasurementAdder.h:156
Belle2::RecoTrack::getStoreArrayNameOfEKLMHits
const std::string & getStoreArrayNameOfEKLMHits() const
Name of the store array of the eklm hits.
Definition: RecoTrack.h:643
Belle2::PXDCoordinateMeasurementCreator
CoordinateMeasurementCreator< RecoHitInformation::UsedPXDHit, Const::PXD > PXDCoordinateMeasurementCreator
Hit to reco hit measurement creator for the PXD.
Definition: CoordinateMeasurementCreator.h:50
Belle2::MeasurementAdder::createGenfitMeasurementFactory
void createGenfitMeasurementFactory()
Helper function to create a genfit::MeasurementFactory, needed in the MeasurementCreators.
Definition: MeasurementAdder.cc:67
Belle2::BKLMHit2d
Store one BKLM strip hit as a ROOT object.
Definition: BKLMHit2d.h:42
Belle2::MeasurementCreatorFactory::initialize
void initialize()
Use the parameters given to the module and create the measurement creators from them.
Definition: MeasurementCreatorFactory.h:48
Belle2::RecoTrack::getStoreArrayNameOfBKLMHits
const std::string & getStoreArrayNameOfBKLMHits() const
Name of the store array of the bklm hits.
Definition: RecoTrack.h:640
Belle2::RecoTrack::getStoreArrayNameOfSVDHits
const std::string & getStoreArrayNameOfSVDHits() const
Name of the store array of the svd hits.
Definition: RecoTrack.h:634