MeasurementAdder Class Reference

Algorithm class to translate the added detector hits (e.g. More...

#include <MeasurementAdder.h>

Collaboration diagram for MeasurementAdder:

Public Member Functions
	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, bool fromTrackCreator=false)
	Create a new instance of the measurement adder.
void	resetMeasurementCreatorsToDefaultSettings ()
	Reset the internal measurement creator storage to the default settings.
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 the measurement creators for the different detectors and use them here.
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 the measurement creators for the different detectors and use them here.
bool	addMeasurements (RecoTrack &recoTrack) const
	After you have filled the internal storage with measurement creators (either by providing your own or by using the default settings), you can use then to add measurements to the reco tracks with this function.

Private Member Functions
void	createGenfitMeasurementFactory ()
	Helper function to create a genfit::MeasurementFactory, needed in the MeasurementCreators.
template<class HitType, Const::EDetector detector>
void	addMeasurementsFromHitToRecoTrack (RecoTrack &recoTrack, RecoHitInformation &recoHitInformation, HitType *hit, const std::vector< std::shared_ptr< BaseMeasurementCreatorFromHit< HitType, detector > > > &measurementCreators, std::map< genfit::TrackPoint *, RecoHitInformation * > &trackPointHitMapping) const
	Helper: Go through all measurement creators in the given list and create the measurement with a given hit.
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 given hit.

Private Attributes
std::string	m_param_storeArrayNameOfPXDHits = ""
	The name of the store array for the PXD hits.
std::string	m_param_storeArrayNameOfSVDHits = ""
	The name of the store array for the SVD hits.
std::string	m_param_storeArrayNameOfCDCHits = ""
	The name of the store array for the CDC hits.
std::string	m_param_storeArrayNameOfBKLMHits = ""
	The name of the store array for the BKLM hits.
std::string	m_param_storeArrayNameOfEKLMHits = ""
	The name of the store array for the EKLM hits.
bool	m_skipDirtyCheck = false
	Flag to skip the dirty check. Useful when using non default measurement creators.
std::vector< std::shared_ptr< PXDBaseMeasurementCreator > >	m_pxdMeasurementCreators
	Internal storage of the PXD measurement creators.
std::vector< std::shared_ptr< SVDBaseMeasurementCreator > >	m_svdMeasurementCreators
	Internal storage of the SVD measurement creators.
std::vector< std::shared_ptr< CDCBaseMeasurementCreator > >	m_cdcMeasurementCreators
	Internal storage of the CDC measurement creators.
std::vector< std::shared_ptr< BKLMBaseMeasurementCreator > >	m_bklmMeasurementCreators
	Internal storage of the BKLM measurement creators.
std::vector< std::shared_ptr< EKLMBaseMeasurementCreator > >	m_eklmMeasurementCreators
	Internal storage of the EKLM measurement creators.
std::vector< std::shared_ptr< BaseMeasurementCreator > >	m_additionalMeasurementCreators
	Internal storage of the additional measurement creators.
genfit::MeasurementFactory< genfit::AbsMeasurement >	m_genfitMeasurementFactory
	Internal storage of the genfit measurement factory;.

Detailed Description

Algorithm class to translate the added detector hits (e.g.

CDCHits) to internal TrackPoints before fitting. This can be - depending on your setting - a non trivial process and should be taken care only by this class.

You probably do not have to use this class on your own but use the TrackFitter for that.

Before fitting a reco track with the track fitter class, you have to translate all detector signals into measurements (contained in TrackPoints) for genfit. This is done using predefined measurement creator classes.

If you do not want non-default settings, you can call the measurement adder class with the following lines of code:

MeasurementAdder measurementAdder; measurementAdder.setMeasurementCreatorsToDefaultSettings()

measurementAdder.addMeasurements(recoTrack);

After that, you can fit the track (see the TrackFitter class).

If you want to provide special settings, you can either create a list of MeasurementCreators for the three detectors and for the case without detector by yourself or you use the MeasurementCreatorFactories. Both cases are shown below:

MeasurementAdder measurementAdder; // Possibility 1 measurementAdder.setMeasurementCreators({ cdcMeasurementCreatorSharedPointer1, cdcMeasurementCreatorSharedPointer2, ...}, { svdMeasurementCreatorSharedPointer1, ...}, { pxdMeasurementCreatorSharedPointer1, ...}, { additionalMeasurementCreatorSharedPointer1, ...})

// Possibility 2 measurementAdder.setMeasurementCreatorsUsingFactories( mapOfCreatorNamesAndSettingsForCDC, mapOfCreatorNamesAndSettingsForSVD, mapOfCreatorNamesAndSettingsForPXD, mapOfCreatorNamesAndSettingsForAdditionalMeasurements )

measurementAdder.addMeasurements(recoTrack);

Definition at line 76 of file MeasurementAdder.h.

Constructor & Destructor Documentation

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,
		bool	fromTrackCreator = false )

Create a new instance of the measurement adder.

You probably only have to do this once in your module, except the case you want to test out different settings.

Configures whether the CDC Translators should be initialized by the FitterModule especially useful for VXD-only beamtest. In the future this could be changed to check implicitly if the cdc is available in the geometry.

Definition at line 38 of file MeasurementAdder.cc.

                         :
  m_param_storeArrayNameOfPXDHits(storeArrayNameOfPXDHits),
  m_param_storeArrayNameOfSVDHits(storeArrayNameOfSVDHits),
  m_param_storeArrayNameOfCDCHits(storeArrayNameOfCDCHits),
  m_param_storeArrayNameOfBKLMHits(storeArrayNameOfBKLMHits),
  m_param_storeArrayNameOfEKLMHits(storeArrayNameOfEKLMHits)
{
  if (initializeCDCTranslators) {
    // Create new Translators and give them to the CDCRecoHits.
    CDCRecoHit::setTranslators(new CDC::LinearGlobalADCCountTranslator(),
                               new CDC::RealisticCDCGeometryTranslator(true),
                               new CDC::RealisticTDCCountTranslator(true, fromTrackCreator),
                               true);
  }
  createGenfitMeasurementFactory();
  resetMeasurementCreatorsToDefaultSettings();
}

Member Function Documentation

addMeasurements()

bool addMeasurements

(

RecoTrack &

recoTrack

)

const

After you have filled the internal storage with measurement creators (either by providing your own or by using the default settings), you can use then to add measurements to the reco tracks with this function.

Attention

If you are using default measurement creators and the dirty flag of the reco track is not set, this method will return and not nothing, as we do not want to recreate all measurements twice. If you want to create all measurements again (because you used different settings before), you have to set the dirty flag of the reco track manually.

Returns true, if the track should be refitted afterwards and false else.

Definition at line 161 of file MeasurementAdder.cc.

{
  B2ASSERT("Reco Track was built with another CDC store array: Reco Track "
           << recoTrack.getStoreArrayNameOfCDCHits()
           << ", this class " << m_param_storeArrayNameOfCDCHits,
           checkTwoStoreArrayNames<RecoHitInformation::UsedCDCHit>(recoTrack.getStoreArrayNameOfCDCHits(), m_param_storeArrayNameOfCDCHits));
  B2ASSERT("Reco Track was built with another SVD store array: Reco Track "
           << recoTrack.getStoreArrayNameOfSVDHits()
           << ", this class " << m_param_storeArrayNameOfSVDHits,
           checkTwoStoreArrayNames<RecoHitInformation::UsedSVDHit>(recoTrack.getStoreArrayNameOfSVDHits(), m_param_storeArrayNameOfSVDHits));
  B2ASSERT("Reco Track was built with another PXD store array: Reco Track "
           << recoTrack.getStoreArrayNameOfPXDHits()
           << ", this class " << m_param_storeArrayNameOfPXDHits,
           checkTwoStoreArrayNames<RecoHitInformation::UsedPXDHit>(recoTrack.getStoreArrayNameOfPXDHits(), m_param_storeArrayNameOfPXDHits));
  B2ASSERT("Reco Track was built with another BKLM store array: Reco Track "
           << recoTrack.getStoreArrayNameOfBKLMHits()
           << ", this class " << m_param_storeArrayNameOfBKLMHits,
           checkTwoStoreArrayNames<RecoHitInformation::UsedBKLMHit>(recoTrack.getStoreArrayNameOfBKLMHits(),
               m_param_storeArrayNameOfBKLMHits));
  B2ASSERT("Reco Track was built with another EKLM store array: Reco Track "
           << recoTrack.getStoreArrayNameOfEKLMHits()
           << ", this class " << m_param_storeArrayNameOfEKLMHits,
           checkTwoStoreArrayNames<RecoHitInformation::UsedEKLMHit>(recoTrack.getStoreArrayNameOfEKLMHits(),
               m_param_storeArrayNameOfEKLMHits));
 
  if (m_cdcMeasurementCreators.size() == 0 and m_svdMeasurementCreators.size() == 0 and m_pxdMeasurementCreators.size() == 0 and
      m_bklmMeasurementCreators.size() == 0 and m_eklmMeasurementCreators.size() == 0 and m_additionalMeasurementCreators.size() == 0) {
    B2WARNING("No measurement creators where added to this instance, so no measurements where created. Did you forget to call setMeasurementCreators?");
    return false;
  }
 
  if (not recoTrack.getDirtyFlag() and not m_skipDirtyCheck) {
    B2DEBUG(100, "Hit content did not change since last measurement adding and you are using default parameters." <<
            "I will not add the measurements again. " <<
            "If you still want to do so, set the dirty flag to true.");
    return false;
  }
 
  // Delete all other measurements.
  RecoTrackGenfitAccess::getGenfitTrack(recoTrack).deleteTrackPointsAndFitStatus();
  recoTrack.setDirtyFlag();
 
  std::map<genfit::TrackPoint*, RecoHitInformation*> trackPointHitMapping;
 
  // Add the measurements created by the CDC, SVD and PXD measurement creators.
  recoTrack.mapOnHits<RecoHitInformation::UsedPXDHit>(m_param_storeArrayNameOfPXDHits, [&](RecoHitInformation & recoHitInformation,
  RecoHitInformation::UsedPXDHit * pxdHit) {
    addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedPXDHit, Const::PXD>(recoTrack, recoHitInformation, pxdHit,
        m_pxdMeasurementCreators, trackPointHitMapping);
  });
  recoTrack.mapOnHits<RecoHitInformation::UsedSVDHit>(m_param_storeArrayNameOfSVDHits, [&](RecoHitInformation & recoHitInformation,
  RecoHitInformation::UsedSVDHit * svdHit) {
    addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedSVDHit, Const::SVD>(recoTrack, recoHitInformation, svdHit,
        m_svdMeasurementCreators, trackPointHitMapping);
  });
  recoTrack.mapOnHits<RecoHitInformation::UsedCDCHit>(m_param_storeArrayNameOfCDCHits, [&](RecoHitInformation & recoHitInformation,
  RecoHitInformation::UsedCDCHit * cdcHit) {
    addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedCDCHit, Const::CDC>(recoTrack, recoHitInformation, cdcHit,
        m_cdcMeasurementCreators, trackPointHitMapping);
  });
  recoTrack.mapOnHits<RecoHitInformation::UsedBKLMHit>(m_param_storeArrayNameOfBKLMHits, [&](RecoHitInformation & recoHitInformation,
  RecoHitInformation::UsedBKLMHit * bklmHit) {
    addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedBKLMHit, Const::BKLM>(recoTrack, recoHitInformation, bklmHit,
        m_bklmMeasurementCreators, trackPointHitMapping);
  });
  recoTrack.mapOnHits<RecoHitInformation::UsedEKLMHit>(m_param_storeArrayNameOfEKLMHits, [&](RecoHitInformation & recoHitInformation,
  RecoHitInformation::UsedEKLMHit * EKLMHit) {
    addMeasurementsFromHitToRecoTrack<RecoHitInformation::UsedEKLMHit, Const::EKLM>(recoTrack, recoHitInformation, EKLMHit,
        m_eklmMeasurementCreators, trackPointHitMapping);
  });
 
  // Special case is with the additional measurement creator factories. They do not need any hits:
  addMeasurementsToRecoTrack(recoTrack, m_additionalMeasurementCreators);
 
  auto& genfitTrack = RecoTrackGenfitAccess::getGenfitTrack(recoTrack);
 
  genfitTrack.sort();
 
  // FIXME: hotfix:
  // after we have a mapping between created track points and reco track information, we can use this mapping to
  // write it back to the reco hit information. Please note, that we only store a single index for each
  // reco hit information (although there could be multiple track points).
  // We also assume that the track point vector is never changed again!
  int counter = 0;
  for (genfit::TrackPoint* trackPoint : genfitTrack.getPoints()) {
    trackPointHitMapping[trackPoint]->setCreatedTrackPointID(counter);
    counter += 1;
  }
 
  return true;
}

addMeasurementsFromHitToRecoTrack()

template<class HitType, Const::EDetector detector>

void addMeasurementsFromHitToRecoTrack ( RecoTrack & recoTrack, RecoHitInformation & recoHitInformation, HitType * hit, const std::vector< std::shared_ptr< BaseMeasurementCreatorFromHit< HitType, detector > > > & measurementCreators, std::map< genfit::TrackPoint *, RecoHitInformation * > & trackPointHitMapping ) const

inlineprivate

Helper: Go through all measurement creators in the given list and create the measurement with a given hit.

Definition at line 188 of file MeasurementAdder.h.

    {
      if (not recoHitInformation.useInFit()) {
        return;
      }
 
      genfit::Track& genfitTrack = RecoTrackGenfitAccess::getGenfitTrack(recoTrack);
 
      for (const auto& measurementCreator : measurementCreators) {
        const std::vector<genfit::TrackPoint*>& trackPoints = measurementCreator->createMeasurementPoints(hit, recoTrack,
                                                              recoHitInformation);
        for (genfit::TrackPoint* trackPoint : trackPoints) {
          genfitTrack.insertPoint(trackPoint);
          // FIXME: hotfix: to get a correct mapping between reco hit information and the track point.
          // We are not able to store the TrackPoint in the RecoHitInformation directly because of problems in streaming
          // the genfit::TrackPoint. So what we do is store the index of the track points in the vector of the genfit::Track.
          // As this vector is sorted after this function, we can not set it here directly.
          trackPointHitMapping[trackPoint] = &recoHitInformation;
        }
      }
    }

addMeasurementsToRecoTrack()

void addMeasurementsToRecoTrack ( RecoTrack & recoTrack, const std::vector< std::shared_ptr< BaseMeasurementCreator > > & measurementCreators ) const

private

Helper: Go through all measurement creators in the given list and create the measurement without a given hit.

Definition at line 253 of file MeasurementAdder.cc.

{
  for (const auto& measurementCreator : measurementCreators) {
    const std::vector<genfit::TrackPoint*>& trackPoints = measurementCreator->createMeasurementPoints(recoTrack);
    for (genfit::TrackPoint* trackPoint : trackPoints) {
      RecoTrackGenfitAccess::getGenfitTrack(recoTrack).insertPoint(trackPoint);
    }
  }
}

createGenfitMeasurementFactory()

void createGenfitMeasurementFactory ( )

private

Helper function to create a genfit::MeasurementFactory, needed in the MeasurementCreators.

Definition at line 66 of file MeasurementAdder.cc.

{
  StoreArray<RecoHitInformation::UsedCDCHit> cdcHits(m_param_storeArrayNameOfCDCHits);
  StoreArray<RecoHitInformation::UsedSVDHit> svdHits(m_param_storeArrayNameOfSVDHits);
  StoreArray<RecoHitInformation::UsedPXDHit> pxdHits(m_param_storeArrayNameOfPXDHits);
  StoreArray<RecoHitInformation::UsedBKLMHit> bklmHits(m_param_storeArrayNameOfBKLMHits);
  StoreArray<RecoHitInformation::UsedEKLMHit> eklmHits(m_param_storeArrayNameOfEKLMHits);
 
  // Create the related measurement factory
  if (pxdHits.isOptional())
    m_genfitMeasurementFactory.addProducer(Const::PXD,
                                           new genfit::MeasurementProducer<RecoHitInformation::UsedPXDHit, PXDRecoHit>(pxdHits.getPtr()));
  if (svdHits.isOptional())
    m_genfitMeasurementFactory.addProducer(Const::SVD,
                                           new genfit::MeasurementProducer<RecoHitInformation::UsedSVDHit, SVDRecoHit>(svdHits.getPtr()));
  if (cdcHits.isOptional())
    m_genfitMeasurementFactory.addProducer(Const::CDC,
                                           new genfit::MeasurementProducer<RecoHitInformation::UsedCDCHit, CDCRecoHit>(cdcHits.getPtr()));
  if (bklmHits.isOptional())
    m_genfitMeasurementFactory.addProducer(Const::BKLM,
                                           new genfit::MeasurementProducer<RecoHitInformation::UsedBKLMHit, AlignableBKLMRecoHit>(bklmHits.getPtr()));
  if (eklmHits.isOptional())
    m_genfitMeasurementFactory.addProducer(Const::EKLM,
                                           new genfit::MeasurementProducer<RecoHitInformation::UsedEKLMHit, AlignableEKLMRecoHit>(eklmHits.getPtr()));
}

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 the measurement creators for the different detectors and use them here.

For this method, you have to create the measurement creators by yourself.

It is assumed, that you only do this for non-default settings. This is why all measurement points will be recreated (independent on the dirty flag) and the track must be refitted afterwards.

Definition at line 104 of file MeasurementAdder.cc.

{
  m_pxdMeasurementCreators = pxdMeasurementCreators;
  m_svdMeasurementCreators = svdMeasurementCreators;
  m_cdcMeasurementCreators = cdcMeasurementCreators;
  m_bklmMeasurementCreators = bklmMeasurementCreators;
  m_eklmMeasurementCreators = eklmMeasurementCreators;
  m_additionalMeasurementCreators = additionalMeasurementCreators;
 
  m_skipDirtyCheck = true;
}

resetMeasurementCreatorsToDefaultSettings()

void resetMeasurementCreatorsToDefaultSettings

(

)

Reset the internal measurement creator storage to the default settings.

The measurements will not be recreated if the dirty flag is not set (the hit content did not change).

Definition at line 92 of file MeasurementAdder.cc.

{
  m_pxdMeasurementCreators = { std::shared_ptr<PXDBaseMeasurementCreator>(new PXDCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
  m_svdMeasurementCreators = { std::shared_ptr<SVDBaseMeasurementCreator>(new SVDCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
  m_cdcMeasurementCreators = { std::shared_ptr<CDCBaseMeasurementCreator>(new CDCCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
  m_bklmMeasurementCreators = { std::shared_ptr<BKLMBaseMeasurementCreator>(new BKLMCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
  m_eklmMeasurementCreators = { std::shared_ptr<EKLMBaseMeasurementCreator>(new EKLMCoordinateMeasurementCreator(m_genfitMeasurementFactory)) };
  m_additionalMeasurementCreators.clear();
 
  m_skipDirtyCheck = false;
}

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 the measurement creators for the different detectors and use them here.

In this method, the measurement creators are created by MeasurementCreatorFactories. For this, you have to give a map in the form { "creatorName" : { "parameterName1": parameterValue1, "parameterName2": parameterValue2, ... }, "otherCreatorName" : { "otherParameterName1": otherParameterValue1, ... }, ... } for each detector and for additional measurements. See the MeasurementCreatorFactories for more details.

It is assumed, that you only do this for non-default settings. This is why all measurement points will be recreated (independent on the dirty flag) and the track must be refitted afterwards.

Definition at line 122 of file MeasurementAdder.cc.

{
  PXDMeasurementCreatorFactory pxdMeasurementCreatorFactory(m_genfitMeasurementFactory);
  SVDMeasurementCreatorFactory svdMeasurementCreatorFactory(m_genfitMeasurementFactory);
  CDCMeasurementCreatorFactory cdcMeasurementCreatorFactory(m_genfitMeasurementFactory);
  BKLMMeasurementCreatorFactory bklmMeasurementCreatorFactory(m_genfitMeasurementFactory);
  EKLMMeasurementCreatorFactory eklmMeasurementCreatorFactory(m_genfitMeasurementFactory);
  AdditionalMeasurementCreatorFactory additionalMeasurementCreatorFactory;
 
  pxdMeasurementCreatorFactory.setParameters(pxdMeasurementCreators);
  svdMeasurementCreatorFactory.setParameters(svdMeasurementCreators);
  cdcMeasurementCreatorFactory.setParameters(cdcMeasurementCreators);
  bklmMeasurementCreatorFactory.setParameters(bklmMeasurementCreators);
  eklmMeasurementCreatorFactory.setParameters(eklmMeasurementCreators);
  additionalMeasurementCreatorFactory.setParameters(additionalMeasurementCreators);
 
  pxdMeasurementCreatorFactory.initialize();
  svdMeasurementCreatorFactory.initialize();
  cdcMeasurementCreatorFactory.initialize();
  bklmMeasurementCreatorFactory.initialize();
  eklmMeasurementCreatorFactory.initialize();
  additionalMeasurementCreatorFactory.initialize();
 
  m_pxdMeasurementCreators = pxdMeasurementCreatorFactory.getCreators();
  m_svdMeasurementCreators = svdMeasurementCreatorFactory.getCreators();
  m_cdcMeasurementCreators = cdcMeasurementCreatorFactory.getCreators();
  m_bklmMeasurementCreators = bklmMeasurementCreatorFactory.getCreators();
  m_eklmMeasurementCreators = eklmMeasurementCreatorFactory.getCreators();
  m_additionalMeasurementCreators = additionalMeasurementCreatorFactory.getCreators();
 
  m_skipDirtyCheck = true;
}

Member Data Documentation

m_additionalMeasurementCreators

std::vector<std::shared_ptr<BaseMeasurementCreator> > m_additionalMeasurementCreators

private

Internal storage of the additional measurement creators.

Definition at line 178 of file MeasurementAdder.h.

m_bklmMeasurementCreators

std::vector<std::shared_ptr<BKLMBaseMeasurementCreator> > m_bklmMeasurementCreators

private

Internal storage of the BKLM measurement creators.

Definition at line 174 of file MeasurementAdder.h.

m_cdcMeasurementCreators

std::vector<std::shared_ptr<CDCBaseMeasurementCreator> > m_cdcMeasurementCreators

private

Internal storage of the CDC measurement creators.

Definition at line 172 of file MeasurementAdder.h.

m_eklmMeasurementCreators

std::vector<std::shared_ptr<EKLMBaseMeasurementCreator> > m_eklmMeasurementCreators

private

Internal storage of the EKLM measurement creators.

Definition at line 176 of file MeasurementAdder.h.

m_genfitMeasurementFactory

genfit::MeasurementFactory<genfit::AbsMeasurement> m_genfitMeasurementFactory

private

Internal storage of the genfit measurement factory;.

Definition at line 181 of file MeasurementAdder.h.

m_param_storeArrayNameOfBKLMHits

std::string m_param_storeArrayNameOfBKLMHits = ""

private

The name of the store array for the BKLM hits.

Definition at line 161 of file MeasurementAdder.h.

m_param_storeArrayNameOfCDCHits

std::string m_param_storeArrayNameOfCDCHits = ""

private

The name of the store array for the CDC hits.

Definition at line 159 of file MeasurementAdder.h.

m_param_storeArrayNameOfEKLMHits

std::string m_param_storeArrayNameOfEKLMHits = ""

private

The name of the store array for the EKLM hits.

Definition at line 163 of file MeasurementAdder.h.

m_param_storeArrayNameOfPXDHits

std::string m_param_storeArrayNameOfPXDHits = ""

private

The name of the store array for the PXD hits.

Definition at line 155 of file MeasurementAdder.h.

m_param_storeArrayNameOfSVDHits

std::string m_param_storeArrayNameOfSVDHits = ""

private

The name of the store array for the SVD hits.

Definition at line 157 of file MeasurementAdder.h.

m_pxdMeasurementCreators

std::vector<std::shared_ptr<PXDBaseMeasurementCreator> > m_pxdMeasurementCreators

private

Internal storage of the PXD measurement creators.

Definition at line 168 of file MeasurementAdder.h.

m_skipDirtyCheck

bool m_skipDirtyCheck = false

private

Flag to skip the dirty check. Useful when using non default measurement creators.

Definition at line 165 of file MeasurementAdder.h.

m_svdMeasurementCreators

std::vector<std::shared_ptr<SVDBaseMeasurementCreator> > m_svdMeasurementCreators

private

Internal storage of the SVD measurement creators.

Definition at line 170 of file MeasurementAdder.h.

---

The documentation for this class was generated from the following files:

• tracking/trackFitting/measurementCreator/adder/include/MeasurementAdder.h
• tracking/trackFitting/measurementCreator/adder/src/MeasurementAdder.cc