#include <GlobalChiSquareFitterTool.h>

Inheritance diagram for ActsTrk::GlobalChiSquareFitterTool:

Collaboration diagram for ActsTrk::GlobalChiSquareFitterTool:

Public Types
using	StraightPropagator_t = Acts::Propagator< Acts::StraightLineStepper, Acts::Navigator >
	Type erased track fitter function. More...

using	CurvedPropagator_t = Acts::Propagator< Acts::SympyStepper, Acts::Navigator >

using	StraightFitter_t = Acts::Experimental::Gx2Fitter< StraightPropagator_t, MutableTrackStateBackend >

using	CurvedFitter_t = Acts::Experimental::Gx2Fitter< CurvedPropagator_t, MutableTrackStateBackend >

using	Gx2FitterOptions_t = Acts::Experimental::Gx2FitterOptions< MutableTrackStateBackend >
	Abbrivation of the configuration to launch the fit More...

using	Gx2FitterExtension_t = Acts::Experimental::Gx2FitterExtensions< MutableTrackStateBackend >
	Abbrivation of the fitter extensions. More...

Public Member Functions
virtual	~GlobalChiSquareFitterTool ()=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< MutableTrackContainer >	fit (const std::vector< ATLASUncalibSourceLink > &clusterList, const Acts::BoundTrackParameters &initialParams, const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const Acts::Surface *targetSurface=nullptr) const override
	fit a set of xAOD uncalibrated Measurements 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< MutableTrackContainer >	fit (const 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 StatusCode	fit (const EventContext &ctx, const TrackContainer::ConstTrackProxy &track, MutableTrackContainer &trackContainer, const Acts::PerigeeSurface &pSurface) const override

Private Types
using	TrackFitResult_t = IActsToTrkConverterTool::TrackFitResult_t

Private Member Functions
TrackFitResult_t	fit (const std::vector< Acts::SourceLink > &soureLinks, const Acts::BoundTrackParameters &initialPars, const Gx2FitterOptions_t &gx2fOptions, MutableTrackContainer &tracks) const
	Calls the underlying Acts::Gx2Fitter for a given configuration of measurements. More...

Gx2FitterOptions_t	configureFit (const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const Acts::Surface *surface, detail::SourceLinkType slType) const
	Helper method to pack the last information (Calibration, Alignment, B-Field, etc.) for the fit. More...

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

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

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

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

ToolHandle< MuonR4::ISpacePointCalibrator >	m_muonCalibrator {this, "MuonCalibrationTool", ""}

ToolHandle< Trk::IRIO_OnTrackCreator >	m_ROTcreator {this, "RotCreatorTool", ""}

Gaudi::Property< double >	m_option_outlierChi2Cut {this, "OutlierChi2Cut", 12.5}
	Chi2 cut used by the outlier finder. More...

Gaudi::Property< unsigned >	m_option_maxPropagationStep {this, "MaxPropagationStep", 5000}
	Maximum number of steps per propagation call. More...

Gaudi::Property< unsigned >	m_option_maxNavSurfaces {this, "MaxSurfacesPerNavStep", 100}
	Number of maximum surfaces to be tried before the navigrator aborts. More...

Gaudi::Property< bool >	m_option_includeELoss {this, "IncludeELoss", true}
	Consider particle's energy loss in the fit More...

Gaudi::Property< bool >	m_option_includeScat {this, "IncludeScattering", true}
	Consider multiple scattering of the particle. More...

Gaudi::Property< bool >	m_doReFitFromPRD {this, "DoReFitFromPRD", false}
	Convert the PRD to a ROT during the calibration. More...

Gaudi::Property< bool >	m_doStraightLine {this, "DoStraightLine" , false}
	Option to toggle whether a straight line fitter shall be used. More...

detail::TrkMeasurementCalibrator	m_trkMeasCalibrator {}
	Pass through calibrator of the Trk::MeasurementBase objects from the TrackState container. More...

detail::TrkPrepRawDataCalibrator	m_prdCalibrator {}
	Calibrator of the uncalibrated Trk::PrepRawData objects to RIO_OnTrack objects. More...

detail::TrkMeasSurfaceAccessor	m_trkMeasSurfAcc {}
	Surface accessor delegate for Trk::MeasurementBase objects. More...

detail::TrkPrepRawDataSurfaceAcc	m_prdSurfaceAcc {}
	Surface accessor delegate for Trk::PrepRawData objects. More...

detail::xAODUncalibMeasSurfAcc	m_unalibMeasSurfAcc {}
	Surface accessor delegate for xAOD::UncalibratedMeasurement objects. More...

detail::xAODUncalibMeasCalibrator	m_uncalibMeasCalibrator {}
	Calibrator for the uncalibrated xAOD::UnCalibratedMeasurement objects. More...

std::array< Gx2FitterExtension_t, s_nExtensions >	m_gx2fExtensions {}

std::unique_ptr< CurvedFitter_t >	m_fitter {nullptr}
	The underlying curved Acts fitter. More...

std::unique_ptr< StraightFitter_t >	m_slFitter {nullptr}
	The underlying straight line Acts fitter. More...

detail::FitterHelperFunctions::ATLASOutlierFinder	m_outlierFinder {0}

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

Static Private Attributes
static constexpr unsigned	s_nExtensions = static_cast<unsigned>(detail::SourceLinkType::nTypes)
	Array of all configured fitter extensions depending on which source link type is in use. More...

Detailed Description

Definition at line 64 of file GlobalChiSquareFitterTool.h.

Member Typedef Documentation

◆ CurvedFitter_t

using ActsTrk::GlobalChiSquareFitterTool::CurvedFitter_t = Acts::Experimental::Gx2Fitter<CurvedPropagator_t, MutableTrackStateBackend>

Definition at line 152 of file GlobalChiSquareFitterTool.h.

◆ CurvedPropagator_t

using ActsTrk::GlobalChiSquareFitterTool::CurvedPropagator_t = Acts::Propagator<Acts::SympyStepper, Acts::Navigator>

Definition at line 149 of file GlobalChiSquareFitterTool.h.

◆ Gx2FitterExtension_t

using ActsTrk::GlobalChiSquareFitterTool::Gx2FitterExtension_t = Acts::Experimental::Gx2FitterExtensions<MutableTrackStateBackend>

Abbrivation of the fitter extensions.

Definition at line 157 of file GlobalChiSquareFitterTool.h.

◆ Gx2FitterOptions_t

using ActsTrk::GlobalChiSquareFitterTool::Gx2FitterOptions_t = Acts::Experimental::Gx2FitterOptions<MutableTrackStateBackend>

Abbrivation of the configuration to launch the fit

Definition at line 155 of file GlobalChiSquareFitterTool.h.

◆ StraightFitter_t

using ActsTrk::GlobalChiSquareFitterTool::StraightFitter_t = Acts::Experimental::Gx2Fitter<StraightPropagator_t, MutableTrackStateBackend>

Definition at line 151 of file GlobalChiSquareFitterTool.h.

◆ StraightPropagator_t

using ActsTrk::GlobalChiSquareFitterTool::StraightPropagator_t = Acts::Propagator<Acts::StraightLineStepper, Acts::Navigator>

Type erased track fitter function.

Definition at line 148 of file GlobalChiSquareFitterTool.h.

◆ TrackFitResult_t

using ActsTrk::GlobalChiSquareFitterTool::TrackFitResult_t = IActsToTrkConverterTool::TrackFitResult_t

private

Definition at line 160 of file GlobalChiSquareFitterTool.h.

Constructor & Destructor Documentation

◆ ~GlobalChiSquareFitterTool()

virtual ActsTrk::GlobalChiSquareFitterTool::~GlobalChiSquareFitterTool ( )

virtualdefault

Member Function Documentation

◆ configureFit()

GlobalChiSquareFitterTool::Gx2FitterOptions_t ActsTrk::GlobalChiSquareFitterTool::configureFit	(	const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const Acts::Surface *	surface,
		detail::SourceLinkType	slType
	)		const

private

Helper method to pack the last information (Calibration, Alignment, B-Field, etc.) for the fit.

The parsed context objects need to prevail the call of the fit

Parameters

tgContext	Reference to the geometry context
mfContext	Reference to the passed magnetic field context
calContext	Reference to the calibration context
surface	Target surface on which the fit result is expressed.
slType	Switch of which source link type shall be used to access the surfaces from the measurements & for calibration

Definition at line 130 of file GlobalChiSquareFitterTool.cxx.

                                                                                {
     Acts::PropagatorPlainOptions propagationOption{tgContext, mfContext};
     propagationOption.maxSteps = m_option_maxPropagationStep;
     propagationOption.maxTargetSkipping = m_option_maxNavSurfaces;
     // Set the Gx2Fitter options
     return Gx2FitterOptions_t{tgContext, mfContext, calContext, 
                               m_gx2fExtensions[static_cast<int>(slType)], 
                               std::move(propagationOption),
                               surface, m_option_includeScat, 
                               m_option_includeELoss};
 }

◆ fit() [1/10]

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

overridevirtual

Definition at line 512 of file GlobalChiSquareFitterTool.cxx.

 {
   ATH_MSG_ERROR("Track refit method not implemented in GlobalChiSquareFitterTool yet");
   return StatusCode::FAILURE;
 }

◆ fit() [2/10]

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::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 208 of file GlobalChiSquareFitterTool.cxx.

                                          {
  
   // 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
   auto 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)};
  
   
  
   std::vector<Acts::SourceLink> trackSourceLinks;
   m_ATLASConverterTool->toSourceLinks(inputMeasSet, trackSourceLinks);
   // protection against error in the conversion from Atlas measurement to ACTS
   // source link
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue "
                 <<"with the converter, reject fit ");
     return nullptr;
   }
  
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(estimatedStartParameters, tgContext);
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
  
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext,
                                                 pSurface.get(), detail::SourceLinkType::TrkMeasurement);
   // Perform the fit
   auto result = fit(trackSourceLinks, initialParams, gx2fOptions, tracks);
   return m_ATLASConverterTool->convertFitResult(ctx, tracks, result,
                                                 Trk::TrackInfo::TrackFitter::GlobalChi2Fitter,
                                                 detail::SourceLinkType::TrkMeasurement);
 }

◆ fit() [3/10]

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

overridevirtual

fit a set of PrepRawData objects

Definition at line 258 of file GlobalChiSquareFitterTool.cxx.

                                                                                                 {
   
   ATH_MSG_DEBUG("--> entering GlobalChiSquareFitterTool::fit(PRDS,TP,)");
  
   // Construct a perigee surface as the target surface
   auto 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)};
  
   std::vector<Acts::SourceLink> trackSourceLinks;
   m_ATLASConverterTool->toSourceLinks(inputPRDColl, trackSourceLinks);
   
   // protection against error in the conversion from Atlas measurement to ACTS
   // source link
   if (trackSourceLinks.empty()) {
     ATH_MSG_WARNING("input contain measurement but no source link created, probable issue "
                     "with the converter, reject fit ");
     return nullptr;
   }
  
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(estimatedStartParameters, tgContext);
  
   
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext,
                                                 pSurface.get(), detail::SourceLinkType::TrkPrepRawData);
  
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
   // Perform the fit
   auto result = fit(trackSourceLinks, initialParams, gx2fOptions, tracks);
  
   return m_ATLASConverterTool->convertFitResult(ctx, tracks, result,
                                   Trk::TrackInfo::TrackFitter::GlobalChi2Fitter,
                                   detail::SourceLinkType::TrkPrepRawData);
 }

◆ fit() [4/10]

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::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 352 of file GlobalChiSquareFitterTool.cxx.

                                          {
   ATH_MSG_VERBOSE("--> enter GlobalChiSquareFitterTool::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 GX2F, reject fit");
     return nullptr;
   }
  
   // Construct a perigee surface as the target surface
   auto 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)};
  
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(inputTrack);
   m_ATLASConverterTool->toSourceLinks(addMeasColl, trackSourceLinks);
   // protection against error in the conversion from Atlas measurement to ACTS
   // source link
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue "
                   <<"with the converter, reject fit ");
     return nullptr;
   }
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(*(inputTrack.perigeeParameters()), 
                                                                                       tgContext);
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
  
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext,
                                                 pSurface.get(), detail::SourceLinkType::TrkMeasurement);
   // Perform the fit
   auto result = fit(trackSourceLinks, initialParams, gx2fOptions, tracks);
   return m_ATLASConverterTool->convertFitResult(ctx, tracks, result,
                                 Trk::TrackInfo::TrackFitter::GlobalChi2Fitter,
                                 detail::SourceLinkType::TrkMeasurement);
 }

◆ fit() [5/10]

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::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 413 of file GlobalChiSquareFitterTool.cxx.

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

◆ fit() [6/10]

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::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 148 of file GlobalChiSquareFitterTool.cxx.

                                                   {
  
   ATH_MSG_VERBOSE("--> enter GlobalChiSquareFitterTool::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 GX2F, reject fit");
     return nullptr;
   }
  
   // Construct a perigee surface as the target surface
   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
  
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(inputTrack);
   // protection against error in the conversion from Atlas measurement to ACTS
   // source link
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue "
                 <<"with the converter, reject fit ");
     return nullptr;
   }
  
   const Acts::GeometryContext tgContext{m_trackingGeometryTool->getGeometryContext(ctx).context()};
   const Acts::MagneticFieldContext mfContext{m_extrapolationTool->getMagneticFieldContext(ctx)};
   const Acts::CalibrationContext calContext{getCalibrationContext(ctx)};
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters((*inputTrack.perigeeParameters()), tgContext);
  
   
   const Acts::BoundTrackParameters initialParamsWithHypothesis(
       initialParams.referenceSurface().getSharedPtr(),
       initialParams.parameters(), initialParams.covariance(), 
       ParticleHypothesis::convert(hypothesis));
  
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext, 
                                                 pSurface.get(), detail::SourceLinkType::TrkMeasurement);
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
   // Perform the fit
   auto result = fit(trackSourceLinks, initialParamsWithHypothesis, gx2fOptions, tracks);
  
   return m_ATLASConverterTool->convertFitResult(ctx, tracks, result,
                                                 Trk::TrackInfo::TrackFitter::GlobalChi2Fitter,
                                                 detail::SourceLinkType::TrkMeasurement);
 }

◆ fit() [7/10]

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::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 425 of file GlobalChiSquareFitterTool.cxx.

                                                    {
   ATH_MSG_VERBOSE("--> enter GlobalChiSquareFitterTool::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 GX2F, reject fit");
     return nullptr;
   }
  
   // Construct a perigee surface as the target surface
   auto 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)};
   
   std::vector<Acts::SourceLink> trackSourceLinks = m_ATLASConverterTool->trkTrackToSourceLinks(intrk1);
   std::vector<Acts::SourceLink> trackSourceLinks2 = m_ATLASConverterTool->trkTrackToSourceLinks(intrk2);
   trackSourceLinks.insert(trackSourceLinks.end(), std::make_move_iterator(trackSourceLinks2.begin()),
                           std::make_move_iterator(trackSourceLinks2.end()));
   // protection against error in the conversion from Atlas measurement to ACTS
   // source link
   if (trackSourceLinks.empty()) {
     ATH_MSG_DEBUG("input contain measurement but no source link created, probable issue "
                 <<"with the converter, reject fit ");
     return nullptr;
   }
  
   const auto initialParams = m_ATLASConverterTool->trkTrackParametersToActsParameters(*(intrk1.perigeeParameters()), tgContext);
  
  
   const Acts::BoundTrackParameters initialParamsWithHypothesis(
       initialParams.referenceSurface().getSharedPtr(),
       initialParams.parameters(), initialParams.covariance(), 
       ParticleHypothesis::convert(matEffects));
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   ActsTrk::MutableTrackContainer tracks( std::move(trackContainerBackEnd),
                                          std::move(multiTrajBackEnd));
  
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext,
                                                 pSurface.get(), detail::SourceLinkType::TrkMeasurement);
   // Perform the fit
   auto result = fit(trackSourceLinks, initialParamsWithHypothesis, gx2fOptions, tracks);
       
   return m_ATLASConverterTool->convertFitResult(ctx, tracks, result,
                                 Trk::TrackInfo::TrackFitter::GlobalChi2Fitter,
                                 detail::SourceLinkType::TrkMeasurement);
 }

◆ fit() [8/10]

std::unique_ptr< MutableTrackContainer > ActsTrk::GlobalChiSquareFitterTool::fit	(	const 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 494 of file GlobalChiSquareFitterTool.cxx.

                                             {
   
   std::vector<ATLASUncalibSourceLink> sourceLinks;
   sourceLinks.reserve(6);
   
   for (const xAOD::SpacePoint* sp : seed.sp()) {
     sourceLinks.insert(sourceLinks.end(), sp->measurements().begin(), sp->measurements().end());
   }
   return fit(sourceLinks, initialParams, tgContext, mfContext, calContext, &targetSurface);
 }

◆ fit() [9/10]

GlobalChiSquareFitterTool::TrackFitResult_t ActsTrk::GlobalChiSquareFitterTool::fit	(	const std::vector< Acts::SourceLink > &	soureLinks,
		const Acts::BoundTrackParameters &	initialPars,
		const Gx2FitterOptions_t &	gx2fOptions,
		MutableTrackContainer &	tracks
	)		const

inlineprivate

Calls the underlying Acts::Gx2Fitter for a given configuration of measurements.

Parameters

sourceLinks	List of measurements to fit
initialPars	Initial estimate of the track parameters
gx2fOptions	Configuration options needed to execute the fit
tracks	Track container into which the new track is appended

Definition at line 120 of file GlobalChiSquareFitterTool.cxx.

                                                                         {
     return ATH_LIKELY(m_fitter) ? 
         m_fitter->fit(soureLinks.begin(), soureLinks.end(), initialPars, gx2fOptions, tracks) :
         m_slFitter->fit(soureLinks.begin(), soureLinks.end(), initialPars, gx2fOptions, tracks);
 }

◆ fit() [10/10]

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

overridevirtual

fit a set of xAOD uncalibrated Measurements

Definition at line 305 of file GlobalChiSquareFitterTool.cxx.

                                             {
   
   if (measList.empty()) {
       ATH_MSG_DEBUG("No measurements given. Nothing to do");
       return nullptr;
   }
   // Construct a perigee surface as the target surface
   std::shared_ptr<Acts::Surface> pSurface{};
   if (!targetSurface) {
     pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(Acts::Vector3::Zero());
     targetSurface = pSurface.get();
   }
  
   std::vector<Acts::SourceLink> sourceLinks;
   sourceLinks.reserve(measList.size());
   std::ranges::transform(measList, std::back_inserter(sourceLinks), 
                          [](const xAOD::UncalibratedMeasurement* meas){
                              return detail::xAODUncalibMeasCalibrator::pack(meas);
                          });
  
   Gx2FitterOptions_t gx2fOptions = configureFit(tgContext, mfContext, calContext,
                                                 targetSurface, detail::SourceLinkType::xAODUnCalibMeas);
  
  
   ActsTrk::MutableTrackBackend trackContainerBackEnd;
   ActsTrk::MutableTrackStateBackend multiTrajBackEnd;
   auto tracks = std::make_unique<MutableTrackContainer>( std::move(trackContainerBackEnd),
                                                          std::move(multiTrajBackEnd) ); 
   // Perform the fit
   auto result = fit(sourceLinks, initialParams, gx2fOptions, *tracks);
   if (not result.ok()) {
       ATH_MSG_VERBOSE("Global chi2 fit failed");
       return nullptr;
   }
   return tracks;
 }

◆ initialize()

StatusCode ActsTrk::GlobalChiSquareFitterTool::initialize ( )

overridevirtual

Configure the fit extensions for Trk::MeasuremenBase pass through fits.

Configure the fit extensions for Trk::PrepRawData fits

Needs to be filled with live.

Connect the muon types with the muon calibrator

Definition at line 45 of file GlobalChiSquareFitterTool.cxx.

                                                  {
  
   ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
   ATH_CHECK(m_trackingGeometryTool.retrieve());
   ATH_CHECK(m_extrapolationTool.retrieve());
   ATH_CHECK(m_ATLASConverterTool.retrieve());
   ATH_CHECK(m_ROTcreator.retrieve(EnableTool{m_doReFitFromPRD}));
   ATH_CHECK(m_muonCalibrator.retrieve(EnableTool{!m_muonCalibrator.empty()}));
  
   m_logger = makeActsAthenaLogger(this, "Gx2fRefit");
   if (!m_doStraightLine){
       // Fitter
       Acts::SympyStepper stepper{std::make_shared<ATLASMagneticFieldWrapper>()};
       Acts::Navigator::Config navConfig{m_trackingGeometryTool->trackingGeometry()};
       Acts::Navigator navigator(std::move(navConfig), logger().cloneWithSuffix("Navigator"));
       CurvedPropagator_t propagator{stepper, std::move(navigator), logger().cloneWithSuffix("Prop")};
  
       m_fitter = std::make_unique<CurvedFitter_t>(std::move(propagator), 
                                                   logger().cloneWithSuffix("GlobalChiSquareFitter"));
   } else {
       Acts::StraightLineStepper stepper{};
       Acts::Navigator::Config navConfig{m_trackingGeometryTool->trackingGeometry()};
       Acts::Navigator navigator(std::move(navConfig), logger().cloneWithSuffix("Navigator"));
       StraightPropagator_t propagator{stepper, std::move(navigator), logger().cloneWithSuffix("Prop")};
  
       m_slFitter = std::make_unique<StraightFitter_t>(std::move(propagator), 
                                                       logger().cloneWithSuffix("GlobalChiSquareFitter"));
   }
  
  
   m_outlierFinder.StateChiSquaredPerNumberDoFCut = m_option_outlierChi2Cut;
  
   Gx2FitterExtension_t extensionTemplate{};
   extensionTemplate.outlierFinder.connect<&detail::FitterHelperFunctions::ATLASOutlierFinder::operator()
                                             <MutableTrackStateBackend>>(&m_outlierFinder);
   extensionTemplate.updater.connect<&detail::FitterHelperFunctions::gainMatrixUpdate<MutableTrackStateBackend>>();
  
   {
     m_trkMeasCalibrator = detail::TrkMeasurementCalibrator{};
     m_trkMeasSurfAcc = detail::TrkMeasSurfaceAccessor{m_ATLASConverterTool.get()};
  
     Gx2FitterExtension_t& configureMe = m_gx2fExtensions[static_cast<int>(detail::SourceLinkType::TrkMeasurement)];
     configureMe = extensionTemplate;
     configureMe.calibrator.connect<&detail::TrkMeasurementCalibrator::calibrate<MutableTrackStateBackend>>(&m_trkMeasCalibrator);
     configureMe.surfaceAccessor.connect<&detail::TrkMeasSurfaceAccessor::operator()>(&m_trkMeasSurfAcc);
   }
   {
     m_prdCalibrator = detail::TrkPrepRawDataCalibrator{m_ATLASConverterTool.get(), m_ROTcreator.get()};
     m_prdSurfaceAcc = detail::TrkPrepRawDataSurfaceAcc{m_ATLASConverterTool.get()};
     Gx2FitterExtension_t& configureMe = m_gx2fExtensions[static_cast<int>(detail::SourceLinkType::TrkPrepRawData)];
     configureMe = extensionTemplate;
     configureMe.calibrator.connect<&detail::TrkPrepRawDataCalibrator::calibrate<MutableTrackStateBackend>>(&m_prdCalibrator);
     configureMe.surfaceAccessor.connect<&detail::TrkPrepRawDataSurfaceAcc::operator()>(&m_prdSurfaceAcc);
   }
   {
     m_unalibMeasSurfAcc = detail::xAODUncalibMeasSurfAcc{m_trackingGeometryTool.get()};
     Gx2FitterExtension_t& configureMe = m_gx2fExtensions[static_cast<int>(detail::SourceLinkType::xAODUnCalibMeas)];
     configureMe = extensionTemplate;
     configureMe.surfaceAccessor.connect<&detail::xAODUncalibMeasSurfAcc::operator()>(&m_unalibMeasSurfAcc);
     configureMe.calibrator.connect<&detail::xAODUncalibMeasCalibrator::calibrate>(&m_uncalibMeasCalibrator);
     if (m_muonCalibrator.isEnabled()) {
       for (const auto& muonType : {xAOD::UncalibMeasType::MdtDriftCircleType, xAOD::UncalibMeasType::RpcStripType, 
                                    xAOD::UncalibMeasType::TgcStripType, xAOD::UncalibMeasType::MMClusterType, 
                                    xAOD::UncalibMeasType::sTgcStripType}) {
         m_uncalibMeasCalibrator.connect<&MuonR4::ISpacePointCalibrator::calibrateSourceLink>(muonType, m_muonCalibrator.get());
       }
     }
   }
   return StatusCode::SUCCESS;
 }