#include <GaussianSumFitterTool.h>

Inheritance diagram for ActsTrk::GaussianSumFitterTool:

Collaboration diagram for ActsTrk::GaussianSumFitterTool:

Public Member Functions
	GaussianSumFitterTool (const std::string &, const std::string &, const IInterface *)

virtual	~GaussianSumFitterTool ()=default

virtual StatusCode	initialize () override

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	refit a track More...

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::PrepRawDataSet &, const Trk::TrackParameters &, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	fit a set of PrepRawData objects More...

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::MeasurementSet &, const Trk::TrackParameters &, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	fit a set of MeasurementBase objects More...

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &, const Trk::PrepRawDataSet &, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	extend a track fit including a new set of PrepRawData objects More...

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &, const Trk::MeasurementSet &, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	extend a track fit including a new set of MeasurementBase objects More...

virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Trk::Track &intrk1, const Trk::Track &intrk2, const Trk::RunOutlierRemoval runOutlier=false, const Trk::ParticleHypothesis matEffects=Trk::nonInteracting) const override
	combined track fit More...

virtual std::unique_ptr< ActsTrk::MutableTrackContainer >	fit (const ActsTrk::Seed &seed, const Acts::BoundTrackParameters &initialParams, const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const Acts::Surface &targetSurface) const override
	Acts seed fit. More...

virtual std::unique_ptr< ActsTrk::MutableTrackContainer >	fit (const std::vector< ActsTrk::ATLASUncalibSourceLink > &clusterList, const Acts::BoundTrackParameters &initialParams, const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const Acts::Surface *targetSurface) const override

virtual StatusCode	fit (const EventContext &ctx, const ActsTrk::TrackContainer::ConstTrackProxy &track, ActsTrk::MutableTrackContainer &trackContainer, const Acts::PerigeeSurface &pSurface) const override

Private Types
using	Fitter = Acts::GaussianSumFitter< Acts::Propagator< Acts::MultiEigenStepperLoop<>, Acts::Navigator >, Acts::AtlasBetheHeitlerApprox< 6, 5 >, ActsTrk::MutableTrackStateBackend >
	Type erased track fitter function. More...

using	DirectFitter = Acts::GaussianSumFitter< Acts::Propagator< Acts::MultiEigenStepperLoop<>, Acts::DirectNavigator >, Acts::AtlasBetheHeitlerApprox< 6, 5 >, ActsTrk::MutableTrackStateBackend >

Private Member Functions
Acts::GsfOptions< ActsTrk::MutableTrackStateBackend >	prepareOptions (const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const Acts::PerigeeSurface &surface) const

std::unique_ptr< Trk::Track >	performFit (const EventContext &ctx, const Acts::GeometryContext &tgContext, const Acts::GsfOptions< ActsTrk::MutableTrackStateBackend > &gsfOptions, const std::vector< Acts::SourceLink > &trackSourceLinks, const Acts::BoundTrackParameters &initialParams) const

std::unique_ptr< Trk::Track >	performDirectFit (const EventContext &ctx, const Acts::GeometryContext &tgContext, const Acts::GsfOptions< ActsTrk::MutableTrackStateBackend > &gsfOptions, const std::vector< Acts::SourceLink > &trackSourceLinks, const Acts::BoundTrackParameters &initialParams, const std::vector< const Acts::Surface * > &surfaces) const

std::unique_ptr< Trk::Track >	makeTrack (const EventContext &ctx, const Acts::GeometryContext &tgContext, ActsTrk::MutableTrackContainer &tracks, Acts::Result< typename ActsTrk::MutableTrackContainer::TrackProxy, std::error_code > &fitResult) const

const Acts::GsfExtensions< ActsTrk::MutableTrackStateBackend > &	getExtensions () const

const Acts::Logger &	logger () const
	Private access to the logger. More...

Private Attributes
ToolHandle< IActsExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", ""}

PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", ""}

ToolHandle< ActsTrk::IActsToTrkConverterTool >	m_ATLASConverterTool {this, "ATLASConverterTool", ""}

ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trkSummaryTool {this, "SummaryTool", "", "ToolHandle for track summary tool"}

ToolHandle< Trk::IBoundaryCheckTool >	m_boundaryCheckTool

Gaudi::Property< double >	m_option_outlierChi2Cut

Gaudi::Property< int >	m_option_maxPropagationStep

Gaudi::Property< int >	m_maxComponents

Gaudi::Property< bool >	m_useDirectNavigation

Gaudi::Property< bool >	m_refitOnly

Gaudi::Property< double >	m_weightCutOff

Gaudi::Property< std::string >	m_option_componentMergeMethod

Acts::ComponentMergeMethod	m_componentMergeMethod

std::unique_ptr< ActsTrk::detail::TrkMeasurementCalibrator >	m_calibrator {nullptr}

std::unique_ptr< Fitter >	m_fitter {nullptr}

std::unique_ptr< DirectFitter >	m_directFitter {nullptr}

detail::TrkMeasSurfaceAccessor	m_surfaceAccessor {}

Acts::GsfExtensions< ActsTrk::MutableTrackStateBackend >	m_gsfExtensions

ActsTrk::detail::FitterHelperFunctions::ATLASOutlierFinder	m_outlierFinder {0}

std::unique_ptr< const Acts::Logger >	m_logger {nullptr}
	logging instance More...

Detailed Description

Definition at line 46 of file GaussianSumFitterTool.h.

Member Typedef Documentation

◆ DirectFitter

using ActsTrk::GaussianSumFitterTool::DirectFitter = Acts::GaussianSumFitter< Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::DirectNavigator>, Acts::AtlasBetheHeitlerApprox<6, 5>, ActsTrk::MutableTrackStateBackend >

private

Definition at line 202 of file GaussianSumFitterTool.h.

◆ Fitter

using ActsTrk::GaussianSumFitterTool::Fitter = Acts::GaussianSumFitter< Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::Navigator>, Acts::AtlasBetheHeitlerApprox<6, 5>, ActsTrk::MutableTrackStateBackend >

private

Type erased track fitter function.

Definition at line 195 of file GaussianSumFitterTool.h.

Constructor & Destructor Documentation

◆ GaussianSumFitterTool()

ActsTrk::GaussianSumFitterTool::GaussianSumFitterTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 50 of file GaussianSumFitterTool.cxx.

                                               :
   base_class(t,n,p)
 {}

◆ ~GaussianSumFitterTool()

virtual ActsTrk::GaussianSumFitterTool::~GaussianSumFitterTool ( )

virtualdefault

Member Function Documentation

◆ fit() [1/9]

std::unique_ptr< ActsTrk::MutableTrackContainer > ActsTrk::GaussianSumFitterTool::fit	(	const ActsTrk::Seed &	seed,
		const Acts::BoundTrackParameters &	initialParams,
		const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const Acts::Surface &	targetSurface
	)		const

overridevirtual

Acts seed fit.

Definition at line 384 of file GaussianSumFitterTool.cxx.

 {
   ATH_MSG_VERBOSE("ACTS seed refit is not implemented in GaussianSumFitterTool");
   return nullptr;
 }

◆ fit() [2/9]

StatusCode ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const ActsTrk::TrackContainer::ConstTrackProxy &	track,
		ActsTrk::MutableTrackContainer &	trackContainer,
		const Acts::PerigeeSurface &	pSurface
	)		const

overridevirtual

Definition at line 408 of file GaussianSumFitterTool.cxx.

                                             {
   ATH_MSG_VERBOSE("GaussianSumFitterTool::fit(TrackProxy) called");
  
   const Acts::BoundTrackParameters initialParams = track.createParametersAtReference();
   std::vector<Acts::SourceLink> sourceLinks;
   std::vector<const Acts::Surface*> surfSequence;
  
   for (auto ts : track.trackStates()){
     surfSequence.push_back(&ts.referenceSurface());
     if (!ts.hasCalibrated()) {
       continue;
     }
     
     if (ts.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag)) {
       sourceLinks.push_back(Acts::SourceLink{detail::RefittingCalibrator::RefittingSourceLink(ts)});
     }
   }
  
   if (sourceLinks.size() < 2) {
     ATH_MSG_DEBUG("called to refit 0 or 1 sourceLink with too little information, reject fit");
     return StatusCode::SUCCESS;
   }
  
   Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
   Acts::CalibrationContext calContext{};
  
   Acts::GsfOptions<ActsTrk::MutableTrackStateBackend> gsfOptions = prepareOptions(tgContext, mfContext, calContext, pSurface);
   const Acts::TrackingGeometry* actsTrackingGeometry = m_trackingGeometryTool->trackingGeometry().get();
  
   if (!actsTrackingGeometry) {
     ATH_MSG_ERROR("No Acts tracking geometry.");
     return StatusCode::FAILURE;
   }
  
   detail::RefittingCalibrator calibrator;
  
   auto gsfExtensions = m_gsfExtensions;
   gsfExtensions.calibrator.connect<&detail::RefittingCalibrator::calibrate>(&calibrator);
   gsfExtensions.surfaceAccessor.connect<&detail::RefittingCalibrator::accessSurface>();
   gsfOptions.extensions = gsfExtensions;
   gsfOptions.abortOnError = false;
  
   if (m_useDirectNavigation) {
     m_directFitter->fit(sourceLinks.begin(), sourceLinks.end(), initialParams, gsfOptions, surfSequence, trackContainer);
   } else {
     m_fitter->fit(sourceLinks.begin(), sourceLinks.end(), initialParams, gsfOptions, trackContainer);
   }
  
   return StatusCode::SUCCESS;
 }

◆ fit() [3/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::MeasurementSet &	inputMeasSet,
		const Trk::TrackParameters &	estimatedStartParameters,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

fit a set of MeasurementBase objects

Definition at line 180 of file GaussianSumFitterTool.cxx.

 {
   std::unique_ptr<Trk::Track> track = nullptr;
   // protection against not having measurements on the input track
   if (inputMeasSet.size() < 2) {
     ATH_MSG_DEBUG("called to refit empty measurement set or a measurement set with too little information, reject fit");
     return nullptr;
   }
  
   // Construct a perigee surface as the target surface
   std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
                                                    Acts::Vector3::Zero());
   
   const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   const Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
   const Acts::CalibrationContext calContext{getCalibrationContext(ctx)};
                          
   // Set the GaussianSumFitter options
   Acts::GsfOptions<ActsTrk::MutableTrackStateBackend>
     gsfOptions = prepareOptions(tgContext, 
                 mfContext, 
                 calContext, 
                 *pSurface);
  
   // Set abortOnError to false, else the refitting crashes if no forward propagation is done. Here, we just skip the event and continue.
   gsfOptions.abortOnError = false;
   
   std::vector< Acts::SourceLink > trackSourceLinks;
   m_ATLASConverterTool->toSourceLinks(inputMeasSet, trackSourceLinks);
  
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(estimatedStartParameters, tgContext);
   
   if(m_useDirectNavigation){
     
     std::vector<const Acts::Surface*> surfaces;
     surfaces.reserve(inputMeasSet.size());
     std::ranges::transform(trackSourceLinks, std::back_inserter(surfaces), m_surfaceAccessor);
     
     return performDirectFit(ctx,
                 tgContext,
                 gsfOptions,
                 trackSourceLinks,
                 initialParams,
                 surfaces);
   }else{
     return performFit(ctx,
               tgContext,
               gsfOptions,
               trackSourceLinks,
               initialParams);
   }
 }

◆ fit() [4/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::PrepRawDataSet &	,
		const Trk::TrackParameters &	,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

fit a set of PrepRawData objects

Definition at line 240 of file GaussianSumFitterTool.cxx.

 {
   ATH_MSG_DEBUG("Fit of PrepRawDataSet not yet implemented");
   return nullptr;
 }

◆ fit() [5/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::Track &	inputTrack,
		const Trk::MeasurementSet &	addMeasColl,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

extend a track fit including a new set of MeasurementBase objects

Definition at line 255 of file GaussianSumFitterTool.cxx.

 {
   ATH_MSG_VERBOSE ("--> enter GaussianSumFitter::fit(Track,Meas'BaseSet,,)");
   ATH_MSG_VERBOSE ("    with Track from author = " << inputTrack.info().dumpInfo());
  
   // protection, if empty MeasurementSet
   if (addMeasColl.empty()) {
     ATH_MSG_DEBUG( "client tries to add an empty MeasurementSet to the track fit." );
     return fit(ctx,inputTrack);
   }
  
   // protection against not having measurements on the input track
   if (!inputTrack.measurementsOnTrack() || (inputTrack.measurementsOnTrack()->size() < 2 && addMeasColl.empty())) {
     ATH_MSG_DEBUG("called to refit empty track or track with too little information, reject fit");
     return nullptr;
   }
  
   // protection against not having track parameters on the input track
   if (!inputTrack.trackParameters() || inputTrack.trackParameters()->empty()) {
     ATH_MSG_DEBUG("input fails to provide track parameters for seeding the GSF, reject fit");
     return nullptr;
   }
  
   std::unique_ptr<Trk::Track> track = nullptr;
  
   // Construct a perigee surface as the target surface
   std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
   
   const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   const Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
   const Acts::CalibrationContext calContext{getCalibrationContext(ctx)};
  
   // Set the GaussianSumFitter options
   Acts::GsfOptions<ActsTrk::MutableTrackStateBackend>
     gsfOptions = prepareOptions(tgContext, 
                 mfContext, 
                 calContext,
                 *pSurface);
  
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(inputTrack);
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(*(inputTrack.perigeeParameters()), tgContext);
  
   m_ATLASConverterTool->toSourceLinks(addMeasColl, trackSourceLinks);
  
   return performFit(ctx, tgContext, gsfOptions,
                     trackSourceLinks,
                     initialParams);
 }

◆ fit() [6/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::Track &	,
		const Trk::PrepRawDataSet &	,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

extend a track fit including a new set of PrepRawData objects

Definition at line 311 of file GaussianSumFitterTool.cxx.

 {
  
   ATH_MSG_DEBUG("Fit of Track with additional PrepRawDataSet not yet implemented");
   return nullptr;
 }

◆ fit() [7/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::Track &	inputTrack,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

refit a track

Definition at line 125 of file GaussianSumFitterTool.cxx.

 {
  
   
   std::unique_ptr<Trk::Track> track = nullptr;
   ATH_MSG_VERBOSE ("--> enter GaussianSumFitter::fit(Track,,)    with Track from author = "
        << inputTrack.info().dumpInfo());
  
   // protection against not having measurements on the input track
   if (!inputTrack.measurementsOnTrack() || inputTrack.measurementsOnTrack()->size() < 2) {
     ATH_MSG_DEBUG("called to refit empty track or track with too little information, reject fit");
     return nullptr;
   }
  
   // protection against not having track parameters on the input track
   if (!inputTrack.trackParameters() || inputTrack.trackParameters()->empty()) {
     ATH_MSG_DEBUG("input fails to provide track parameters for seeding the GSF, reject fit");
     return nullptr;
   }
  
   // Construct a perigee surface as the target surface
   std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3::Zero());
   
   const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   const Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
   const Acts::CalibrationContext calContext{getCalibrationContext(ctx)};
     
   // Set the GaussianSumFitter options
   Acts::GsfOptions<ActsTrk::MutableTrackStateBackend>
     gsfOptions = prepareOptions(tgContext, 
                 mfContext, 
                 calContext, 
                 *pSurface);
   gsfOptions.maxComponents = m_maxComponents;
   gsfOptions.weightCutoff = m_weightCutOff;
   gsfOptions.componentMergeMethod = m_componentMergeMethod;
   
  
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(inputTrack);
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters((*inputTrack.perigeeParameters()), tgContext);
  
   return performFit(ctx, 
             tgContext,
             gsfOptions,
             trackSourceLinks, 
             initialParams);
 }

◆ fit() [8/9]

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::fit	(	const EventContext &	ctx,
		const Trk::Track &	intrk1,
		const Trk::Track &	intrk2,
		const Trk::RunOutlierRemoval	runOutlier = `false`,
		const Trk::ParticleHypothesis	matEffects = `Trk::nonInteracting`
	)		const

overridevirtual

combined track fit

Definition at line 325 of file GaussianSumFitterTool.cxx.

 { 
   ATH_MSG_VERBOSE ("--> enter GaussianSumFitter::fit(Track,Track,)");
   ATH_MSG_VERBOSE ("    with Tracks from #1 = " << intrk1.info().dumpInfo()
                    << " and #2 = " << intrk2.info().dumpInfo());
  
   // protection, if empty track2
   if (!intrk2.measurementsOnTrack()) {
     ATH_MSG_DEBUG( "input #2 is empty try to fit track 1 alone" );
     return fit(ctx,intrk1);
   }
  
   // protection, if empty track1
   if (!intrk1.measurementsOnTrack()) {
     ATH_MSG_DEBUG( "input #1 is empty try to fit track 2 alone" );
     return fit(ctx,intrk2);
   }
  
   // protection against not having track parameters on the input track
   if (!intrk1.trackParameters() || intrk1.trackParameters()->empty()) {
     ATH_MSG_DEBUG("input #1 fails to provide track parameters for seeding the GSF, reject fit");
     return nullptr;
   }
  
    std::unique_ptr<Trk::Track> track = nullptr;
  
   // Construct a perigee surface as the target surface
    std::shared_ptr<Acts::PerigeeSurface> pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3::Zero());
   
   const Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
   const Acts::MagneticFieldContext mfContext = m_extrapolationTool->getMagneticFieldContext(ctx);
   const Acts::CalibrationContext calContext{getCalibrationContext(ctx)};
     
   // Set the GaussianSumFitter options
   Acts::GsfOptions<ActsTrk::MutableTrackStateBackend>
     gsfOptions = prepareOptions(tgContext, 
                 mfContext, 
                 calContext,
                 *pSurface);
  
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(intrk1);
   std::vector<Acts::SourceLink> trackSourceLinks2 = m_ATLASConverterTool->trkTrackToSourceLinks(intrk2);
   trackSourceLinks.insert(trackSourceLinks.end(), trackSourceLinks2.begin(), trackSourceLinks2.end());
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(*(intrk1.perigeeParameters()), tgContext);
  
   return performFit(ctx,
             tgContext,
             gsfOptions,
                     trackSourceLinks,
                     initialParams);
 }

◆ fit() [9/9]

std::unique_ptr< ActsTrk::MutableTrackContainer > ActsTrk::GaussianSumFitterTool::fit	(	const std::vector< ActsTrk::ATLASUncalibSourceLink > &	clusterList,
		const Acts::BoundTrackParameters &	initialParams,
		const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const Acts::Surface *	targetSurface
	)		const

overridevirtual

Definition at line 396 of file GaussianSumFitterTool.cxx.

 {
   ATH_MSG_VERBOSE("ACTS uncalib slink refit is not implemented in GaussianSumFitterTool");  
   return nullptr;
 }

◆ getExtensions()

const Acts::GsfExtensions< typename ActsTrk::MutableTrackStateBackend > & ActsTrk::GaussianSumFitterTool::getExtensions ( ) const

private

Definition at line 618 of file GaussianSumFitterTool.cxx.

 { 
   return m_gsfExtensions;
 }

◆ initialize()

StatusCode ActsTrk::GaussianSumFitterTool::initialize ( )

overridevirtual

Definition at line 56 of file GaussianSumFitterTool.cxx.

                                              {
   ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
  
   ATH_CHECK(m_trackingGeometryTool.retrieve());
   ATH_CHECK(m_extrapolationTool.retrieve());
   ATH_CHECK(m_ATLASConverterTool.retrieve());
   if (!m_refitOnly) {
     ATH_CHECK(m_trkSummaryTool.retrieve());
   }else{
     ATH_MSG_INFO("Running GSF without track summary");
   }
  
   m_logger = makeActsAthenaLogger(this, "Acts Gaussian Sum Refit");
  
   auto field = std::make_shared<ATLASMagneticFieldWrapper>();
   Acts::MultiEigenStepperLoop<> stepper(field);
   Acts::Navigator navigator( Acts::Navigator::Config{ m_trackingGeometryTool->trackingGeometry() },
                              logger().cloneWithSuffix("Navigator") );
   Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::Navigator> propagator(std::move(stepper), 
                      std::move(navigator),
                      logger().cloneWithSuffix("Prop"));
  
   Acts::AtlasBetheHeitlerApprox<6, 5> bha = Acts::makeDefaultBetheHeitlerApprox();
   m_fitter = std::make_unique<Fitter>(std::move(propagator), std::move(bha),
               logger().cloneWithSuffix("GaussianSumFitter"));
   
   // Direct Fitter
   if( m_useDirectNavigation ){
     Acts::DirectNavigator directNavigator( logger().cloneWithSuffix("DirectNavigator") );
     Acts::MultiEigenStepperLoop<> stepperDirect(field);
     Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::DirectNavigator> directPropagator(std::move(stepperDirect),
                                                 std::move(directNavigator),
                                                 logger().cloneWithSuffix("DirectPropagator"));
     Acts::AtlasBetheHeitlerApprox<6, 5> bhaDirect = Acts::makeDefaultBetheHeitlerApprox();
     m_directFitter = std::make_unique<DirectFitter>(std::move(directPropagator),std::move(bhaDirect),
                             logger().cloneWithSuffix("DirectGaussianSumFitter"));
  
   }
  
   m_gsfExtensions.updater.connect<&ActsTrk::detail::FitterHelperFunctions::gainMatrixUpdate<ActsTrk::MutableTrackStateBackend>>();
   m_calibrator = std::make_unique<ActsTrk::detail::TrkMeasurementCalibrator>();
   m_gsfExtensions.calibrator.connect<&ActsTrk::detail::TrkMeasurementCalibrator::calibrate<ActsTrk::MutableTrackStateBackend>>(m_calibrator.get());
  
   m_surfaceAccessor = detail::TrkMeasSurfaceAccessor{m_ATLASConverterTool.get()};
   m_gsfExtensions.surfaceAccessor.connect<&detail::TrkMeasSurfaceAccessor::operator()>(&m_surfaceAccessor);
   m_gsfExtensions.mixtureReducer.connect<&Acts::reduceMixtureWithKLDistance>();
   
   m_outlierFinder.StateChiSquaredPerNumberDoFCut = m_option_outlierChi2Cut;
   m_gsfExtensions.outlierFinder.connect<&ActsTrk::detail::FitterHelperFunctions::ATLASOutlierFinder::operator()<ActsTrk::MutableTrackStateBackend>>(&m_outlierFinder);
   if(m_option_componentMergeMethod == "Mean" ){
     m_componentMergeMethod = Acts::ComponentMergeMethod::eMean;
   }else if(m_option_componentMergeMethod == "MaxWeight"){
     m_componentMergeMethod = Acts::ComponentMergeMethod::eMaxWeight;
   }else{
     throw std::runtime_error("Unknown option for ComponentMergeMethod: " + m_option_componentMergeMethod.value());
   }
   
   ATH_MSG_INFO("ACTS GSF direct nav   " << m_useDirectNavigation.value());
   ATH_MSG_INFO("ACTS GSF max cmps     " << m_maxComponents.value());
   ATH_MSG_INFO("ACTS GSF merge meth   " << m_option_componentMergeMethod.value());
   ATH_MSG_INFO("ACTS GSF weight ctf   " << m_weightCutOff.value());
   ATH_MSG_INFO("ACTS GSF outlier chi2 " << m_option_outlierChi2Cut.value());
   
   return StatusCode::SUCCESS;
 }

◆ logger()

const Acts::Logger & ActsTrk::GaussianSumFitterTool::logger ( ) const

private

Private access to the logger.

Definition at line 625 of file GaussianSumFitterTool.cxx.

 { 
   return *m_logger;
 }

◆ makeTrack()

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::makeTrack	(	const EventContext &	ctx,
		const Acts::GeometryContext &	tgContext,
		ActsTrk::MutableTrackContainer &	tracks,
		Acts::Result< typename ActsTrk::MutableTrackContainer::TrackProxy, std::error_code > &	fitResult
	)		const

private

Definition at line 465 of file GaussianSumFitterTool.cxx.

 {
   if (not fitResult.ok()) 
     return nullptr;
  
   std::unique_ptr<Trk::Track> newtrack = nullptr;
   // Get the fit output object
   const auto& acts_track = fitResult.value();
   auto finalTrajectory = std::make_unique<Trk::TrackStates>();
   // initialise the number of dead Pixel and Acts strip
   int numberOfDeadPixel = 0;
   int numberOfDeadSCT = 0;
  
   std::vector<std::unique_ptr<const Acts::BoundTrackParameters>> actsSmoothedParam;
   // Loop over all the output state to create track state
   tracks.trackStateContainer().visitBackwards(acts_track.tipIndex(), 
                 [&] (const auto &state) -> void
   {
     // First only concider state with an associated detector element not in the TRT
     auto flag = state.typeFlags();
     const auto* associatedDetEl = state.referenceSurface().associatedDetectorElement();
     if (not associatedDetEl) 
       return;
     
     const auto* actsElement = dynamic_cast<const ActsDetectorElement*>(associatedDetEl);
     if (not actsElement) 
       return;
  
     const auto* upstreamDetEl = actsElement->upstreamDetectorElement();
     if (not upstreamDetEl) 
       return;
  
     ATH_MSG_VERBOSE("Try casting to TRT for if");
     if (dynamic_cast<const InDetDD::TRT_BaseElement*>(upstreamDetEl))
       return;
  
     const auto* trkDetElem = dynamic_cast<const Trk::TrkDetElementBase*>(upstreamDetEl);
     if (not trkDetElem)
       return;
  
     ATH_MSG_VERBOSE("trkDetElem type: " << static_cast<std::underlying_type_t<Trk::DetectorElemType>>(trkDetElem->detectorType()));
  
     ATH_MSG_VERBOSE("Try casting to SiDetectorElement");
     const auto* detElem = dynamic_cast<const InDetDD::SiDetectorElement*>(upstreamDetEl);
     if (not detElem)
       return;
     ATH_MSG_VERBOSE("detElem = " << detElem);
  
     // We need to determine the type of state 
     std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
     std::unique_ptr<Trk::TrackParameters> parm;
  
     // State is a hole (no associated measurement), use predicted parameters      
     if (flag.test(Acts::TrackStateFlag::HoleFlag)){
       ATH_MSG_VERBOSE("State is a hole (no associated measurement), use predicted parameters");
       const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
              state.predicted(),
              state.predictedCovariance(),
              acts_track.particleHypothesis());
       parm = m_ATLASConverterTool->actsTrackParametersToTrkParameters(actsParam, tgContext);
       auto boundaryCheck = m_boundaryCheckTool->boundaryCheck(*parm);
       // Check if this is a hole, a dead sensors or a state outside the sensor boundary
       ATH_MSG_VERBOSE("Check if this is a hole, a dead sensors or a state outside the sensor boundary");
       if(boundaryCheck == Trk::BoundaryCheckResult::DeadElement){
   if (detElem->isPixel()) {
     ++numberOfDeadPixel;
   }
   else if (detElem->isSCT()) {
     ++numberOfDeadSCT;
   }
   // Dead sensors states are not stored              
   return;
       } else if (boundaryCheck != Trk::BoundaryCheckResult::Candidate){
   // States outside the sensor boundary are ignored
   return;
       }
       typePattern.set(Trk::TrackStateOnSurface::Hole);
     }
     // The state was tagged as an outlier or was missed in the reverse filtering, use filtered parameters
     else if (flag.test(Acts::TrackStateFlag::OutlierFlag) or not state.hasSmoothed()) {
       ATH_MSG_VERBOSE("The state was tagged as an outlier or was missed in the reverse filtering, use filtered parameters");
       const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
              state.filtered(),
              state.filteredCovariance(),
              acts_track.particleHypothesis());
       parm = m_ATLASConverterTool->actsTrackParametersToTrkParameters(actsParam, tgContext);
       typePattern.set(Trk::TrackStateOnSurface::Outlier);
     }
     // The state is a measurement state, use smoothed parameters 
     else{
       ATH_MSG_VERBOSE("The state is a measurement state, use smoothed parameters");
  
       const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
              state.smoothed(),
              state.smoothedCovariance(),
              acts_track.particleHypothesis());
       
       actsSmoothedParam.push_back(std::make_unique<const Acts::BoundTrackParameters>(Acts::BoundTrackParameters(actsParam)));
       parm = m_ATLASConverterTool->actsTrackParametersToTrkParameters(actsParam, tgContext);
       typePattern.set(Trk::TrackStateOnSurface::Measurement);
     }
  
     std::unique_ptr<Trk::MeasurementBase> measState;
     if (state.hasUncalibratedSourceLink()){
       auto sl = state.getUncalibratedSourceLink().template get<ATLASSourceLink>();
       assert(sl);
       measState = sl->uniqueClone();
     }
     double nDoF = state.calibratedSize();
     auto quality =Trk::FitQualityOnSurface(state.chi2(), nDoF);
     const Trk::TrackStateOnSurface *perState = new Trk::TrackStateOnSurface(quality, std::move(measState), std::move(parm), nullptr, typePattern);
     // If a state was succesfully created add it to the trajectory 
     if (perState) {
       ATH_MSG_VERBOSE("State succesfully creates, adding it to the trajectory");
       finalTrajectory->insert(finalTrajectory->begin(), perState);
     }
   });
   
   // Convert the perigee state and add it to the trajectory
   const Acts::BoundTrackParameters actsPer(acts_track.referenceSurface().getSharedPtr(), 
                  acts_track.parameters(), 
                  acts_track.covariance(),
                  acts_track.particleHypothesis());
   std::unique_ptr<Trk::TrackParameters> per = m_ATLASConverterTool->actsTrackParametersToTrkParameters(actsPer, tgContext);
   std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
   typePattern.set(Trk::TrackStateOnSurface::Perigee);
   const Trk::TrackStateOnSurface *perState = new Trk::TrackStateOnSurface(nullptr, std::move(per), nullptr, typePattern);
   if (perState) finalTrajectory->insert(finalTrajectory->begin(), perState);
  
   // Create the track using the states
   Trk::TrackInfo newInfo(Trk::TrackInfo::TrackFitter::GaussianSumFilter, Trk::noHypothesis);
   newInfo.setTrackFitter(Trk::TrackInfo::TrackFitter::GaussianSumFilter); //Mark the fitter as GaussianSumFilter
   newtrack = std::make_unique<Trk::Track>(newInfo, std::move(finalTrajectory), nullptr);
   if (newtrack && !m_refitOnly) {
     // Create the track summary and update the holes information
     if (!newtrack->trackSummary()) {
       newtrack->setTrackSummary(std::make_unique<Trk::TrackSummary>());
       newtrack->trackSummary()->update(Trk::numberOfPixelHoles, 0);
       newtrack->trackSummary()->update(Trk::numberOfSCTHoles, 0);
       newtrack->trackSummary()->update(Trk::numberOfTRTHoles, 0);
       newtrack->trackSummary()->update(Trk::numberOfPixelDeadSensors, numberOfDeadPixel);
       newtrack->trackSummary()->update(Trk::numberOfSCTDeadSensors, numberOfDeadSCT);
     }
     m_trkSummaryTool->updateTrackSummary(ctx, *newtrack, true);
   }
   
   return newtrack;
 }

◆ performDirectFit()

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::performDirectFit	(	const EventContext &	ctx,
		const Acts::GeometryContext &	tgContext,
		const Acts::GsfOptions< ActsTrk::MutableTrackStateBackend > &	gsfOptions,
		const std::vector< Acts::SourceLink > &	trackSourceLinks,
		const Acts::BoundTrackParameters &	initialParams,
		const std::vector< const Acts::Surface * > &	surfaces
	)		const

private

Definition at line 23 of file GaussianSumFitterToolDirectFit.cxx.

 {
   if (!m_useDirectNavigation) {
     ATH_MSG_ERROR("ACTS GSF UseDirectNavigation is false, but direct navigation is used");
     return nullptr;
   }
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue with the converter, reject fit ");
     return nullptr;
   }
  
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
   auto result = m_directFitter->fit(trackSourceLinks.begin(),
                   trackSourceLinks.end(),
                   initialParams,
                   gsfOptions,
                   surfaces,
                   tracks);
  
   // Convert
   if (not result.ok()) return nullptr;
   return makeTrack(ctx, tgContext, tracks, result);
 }

◆ performFit()

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::performFit	(	const EventContext &	ctx,
		const Acts::GeometryContext &	tgContext,
		const Acts::GsfOptions< ActsTrk::MutableTrackStateBackend > &	gsfOptions,
		const std::vector< Acts::SourceLink > &	trackSourceLinks,
		const Acts::BoundTrackParameters &	initialParams
	)		const

private

Definition at line 20 of file GaussianSumFitterToolFullFit.cxx.

 {
   if(m_useDirectNavigation){
     ATH_MSG_ERROR("ACTS GSF UseDirectNavigation is true, but standard navigation is used");
     return nullptr;
   }
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue with the converter, reject fit ");
     return nullptr;
   }
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                   initialParams, gsfOptions, tracks);
  
   // Convert
   if (not result.ok()) return nullptr;
   return makeTrack(ctx, tgContext, tracks, result);
 }

◆ prepareOptions()

Acts::GsfOptions< typename ActsTrk::MutableTrackStateBackend > ActsTrk::GaussianSumFitterTool::prepareOptions	(	const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const Acts::PerigeeSurface &	surface
	)		const

private

Definition at line 631 of file GaussianSumFitterTool.cxx.

 {
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
  
   Acts::GsfOptions<typename ActsTrk::MutableTrackStateBackend> gsfOptions(tgContext, mfContext, calContext);
   gsfOptions.extensions=m_gsfExtensions;
   gsfOptions.propagatorPlainOptions=propagationOption;
   gsfOptions.referenceSurface = &surface;
  
   // Set abortOnError to false, else the refitting crashes if no forward propagation is done. Here, we just skip the event and continue.
   gsfOptions.abortOnError = false;
   gsfOptions.maxComponents = m_maxComponents;
   gsfOptions.weightCutoff = m_weightCutOff;
   gsfOptions.componentMergeMethod = m_componentMergeMethod;
  
   return gsfOptions;
 }

Member Data Documentation

◆ m_ATLASConverterTool

ToolHandle<ActsTrk::IActsToTrkConverterTool> ActsTrk::GaussianSumFitterTool::m_ATLASConverterTool {this, "ATLASConverterTool", ""}

private

Definition at line 164 of file GaussianSumFitterTool.h.

◆ m_boundaryCheckTool

ToolHandle<Trk::IBoundaryCheckTool> ActsTrk::GaussianSumFitterTool::m_boundaryCheckTool

private

Initial value:

{this, 
                                                           "BoundaryCheckTool", 
                                                           "",
                                                           "Boundary checking tool for detector sensitivities"}

Definition at line 166 of file GaussianSumFitterTool.h.

◆ m_calibrator

std::unique_ptr<ActsTrk::detail::TrkMeasurementCalibrator> ActsTrk::GaussianSumFitterTool::m_calibrator {nullptr}

private

Definition at line 199 of file GaussianSumFitterTool.h.

◆ m_componentMergeMethod

Acts::ComponentMergeMethod ActsTrk::GaussianSumFitterTool::m_componentMergeMethod

private

Definition at line 192 of file GaussianSumFitterTool.h.

◆ m_directFitter

std::unique_ptr<DirectFitter> ActsTrk::GaussianSumFitterTool::m_directFitter {nullptr}

private

Definition at line 205 of file GaussianSumFitterTool.h.

◆ m_extrapolationTool

ToolHandle<IActsExtrapolationTool> ActsTrk::GaussianSumFitterTool::m_extrapolationTool {this, "ExtrapolationTool", ""}

private

Definition at line 162 of file GaussianSumFitterTool.h.

◆ m_fitter

std::unique_ptr<Fitter> ActsTrk::GaussianSumFitterTool::m_fitter {nullptr}

private

Definition at line 200 of file GaussianSumFitterTool.h.

◆ m_gsfExtensions

Acts::GsfExtensions<ActsTrk::MutableTrackStateBackend> ActsTrk::GaussianSumFitterTool::m_gsfExtensions

private

Definition at line 209 of file GaussianSumFitterTool.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::GaussianSumFitterTool::m_logger {nullptr}

private

logging instance

Definition at line 214 of file GaussianSumFitterTool.h.

◆ m_maxComponents

Gaudi::Property< int > ActsTrk::GaussianSumFitterTool::m_maxComponents

private

Initial value:

{this, "MaxComponents", 12,

"Maximum number of components in GSF"}

Definition at line 177 of file GaussianSumFitterTool.h.

◆ m_option_componentMergeMethod

Gaudi::Property<std::string> ActsTrk::GaussianSumFitterTool::m_option_componentMergeMethod

private

Initial value:

{this, "ComponentMergeMethod", "MaxWeight"

, "method to merge components {Mean, MaxWeight}"}

Definition at line 189 of file GaussianSumFitterTool.h.

◆ m_option_maxPropagationStep

Gaudi::Property< int > ActsTrk::GaussianSumFitterTool::m_option_maxPropagationStep

private

Initial value:

{this, "MaxPropagationStep", 5000,

"Maximum number of steps for one propagate call"}

Definition at line 174 of file GaussianSumFitterTool.h.

◆ m_option_outlierChi2Cut

Gaudi::Property< double > ActsTrk::GaussianSumFitterTool::m_option_outlierChi2Cut

private

Initial value:

{this, "OutlierChi2Cut", 12.5,

"Chi2 cut used by the outlier finder" }

Definition at line 172 of file GaussianSumFitterTool.h.

◆ m_outlierFinder

ActsTrk::detail::FitterHelperFunctions::ATLASOutlierFinder ActsTrk::GaussianSumFitterTool::m_outlierFinder {0}

private

Definition at line 211 of file GaussianSumFitterTool.h.

◆ m_refitOnly

Gaudi::Property<bool> ActsTrk::GaussianSumFitterTool::m_refitOnly

private

Initial value:

{this, "RefitOnly", false,

"Do refit only. Track summary will not be added"}

Definition at line 183 of file GaussianSumFitterTool.h.

◆ m_surfaceAccessor

detail::TrkMeasSurfaceAccessor ActsTrk::GaussianSumFitterTool::m_surfaceAccessor {}

private

Definition at line 208 of file GaussianSumFitterTool.h.

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsTrk::GaussianSumFitterTool::m_trackingGeometryTool {this, "TrackingGeometryTool", ""}

private

Definition at line 163 of file GaussianSumFitterTool.h.

◆ m_trkSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> ActsTrk::GaussianSumFitterTool::m_trkSummaryTool {this, "SummaryTool", "", "ToolHandle for track summary tool"}

private

Definition at line 165 of file GaussianSumFitterTool.h.

◆ m_useDirectNavigation

Gaudi::Property<bool> ActsTrk::GaussianSumFitterTool::m_useDirectNavigation

private

Initial value:

{this, "UseDirectNavigation", false,

"GSF with direct navigation when refitting measurements"}

Definition at line 180 of file GaussianSumFitterTool.h.

◆ m_weightCutOff

Gaudi::Property< double > ActsTrk::GaussianSumFitterTool::m_weightCutOff

private

Initial value:

{this, "WeightCutOff", 1.e-4,

"component weight cut off"}

Definition at line 186 of file GaussianSumFitterTool.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DirectFitter

◆ Fitter

Constructor & Destructor Documentation

◆ GaussianSumFitterTool()

◆ ~GaussianSumFitterTool()

Member Function Documentation

◆ fit() [1/9]

◆ fit() [2/9]

◆ fit() [3/9]

◆ fit() [4/9]

◆ fit() [5/9]

◆ fit() [6/9]

◆ fit() [7/9]

◆ fit() [8/9]

◆ fit() [9/9]

◆ getExtensions()

◆ initialize()

◆ logger()

◆ makeTrack()

◆ performDirectFit()

◆ performFit()

◆ prepareOptions()

Member Data Documentation

◆ m_ATLASConverterTool

◆ m_boundaryCheckTool

◆ m_calibrator

◆ m_componentMergeMethod

◆ m_directFitter

◆ m_extrapolationTool

◆ m_fitter

◆ m_gsfExtensions

◆ m_logger

◆ m_maxComponents

◆ m_option_componentMergeMethod

◆ m_option_maxPropagationStep

◆ m_option_outlierChi2Cut

◆ m_outlierFinder

◆ m_refitOnly

◆ m_surfaceAccessor

◆ m_trackingGeometryTool

◆ m_trkSummaryTool

◆ m_useDirectNavigation

◆ m_weightCutOff