#include <GlobalChiSquareFitterTool.h>

Inheritance diagram for ActsTrk::GlobalChiSquareFitterTool:

Collaboration diagram for ActsTrk::GlobalChiSquareFitterTool:

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

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< ActsTrk::MutableTrackContainer >	fit (const EventContext &ctx, const std::vector< ActsTrk::ATLASUncalibSourceLink > &clusterList, const Acts::BoundTrackParameters &initialParams, const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const DetectorElementToActsGeometryIdMap &detectorElementToGeometryIdMap, 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< ActsTrk::MutableTrackContainer >	fit (const EventContext &ctx, const ActsTrk::Seed &seed, const Acts::BoundTrackParameters &initialParams, const Acts::GeometryContext &tgContext, const Acts::MagneticFieldContext &mfContext, const Acts::CalibrationContext &calContext, const DetectorElementToActsGeometryIdMap &detectorElementToGeometryIdMap) const override
	Acts seed fit. More...

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

Private Types
using	Fitter = Acts::Experimental::Gx2Fitter< Acts::Propagator< Acts::SympyStepper, Acts::Navigator >, ActsTrk::MutableTrackStateBackend >
	Type erased track fitter function. More...

Private Member Functions
std::unique_ptr< Trk::Track >	makeTrack (const EventContext &ctx, Acts::GeometryContext &tgContext, ActsTrk::MutableTrackContainer &tracks, Acts::Result< ActsTrk::MutableTrackContainer::TrackProxy, std::error_code > &fitResult, bool SourceLinkType=false) const

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

Private Attributes
ToolHandle< IActsExtrapolationTool >	m_extrapolationTool

ToolHandle< IActsTrackingGeometryTool >	m_trackingGeometryTool

ToolHandle< ActsTrk::IActsToTrkConverterTool >	m_ATLASConverterTool

ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trkSummaryTool

ToolHandle< Trk::IBoundaryCheckTool >	m_boundaryCheckTool

Gaudi::Property< double >	m_option_outlierChi2Cut

Gaudi::Property< int >	m_option_maxPropagationStep

Gaudi::Property< double >	m_option_seedCovarianceScale

std::unique_ptr< ActsTrk::detail::TrkMeasurementCalibrator >	m_calibrator

std::unique_ptr< Fitter >	m_fitter {nullptr}

Acts::Experimental::Gx2FitterExtensions< ActsTrk::MutableTrackStateBackend >	m_gx2fExtensions

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

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

ToolHandle< Trk::IRIO_OnTrackCreator >	m_broadROTcreator

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

Gaudi::Property< bool >	m_doReFitFromPRD

Detailed Description

Definition at line 77 of file GlobalChiSquareFitterTool.h.

Member Typedef Documentation

◆ Fitter

using ActsTrk::GlobalChiSquareFitterTool::Fitter = Acts::Experimental::Gx2Fitter< Acts::Propagator<Acts::SympyStepper, Acts::Navigator>, ActsTrk::MutableTrackStateBackend>

private

Type erased track fitter function.

Definition at line 202 of file GlobalChiSquareFitterTool.h.

Constructor & Destructor Documentation

◆ GlobalChiSquareFitterTool()

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

Definition at line 160 of file GlobalChiSquareFitterTool.cxx.

163 : base_class(t, n, p) {}

◆ ~GlobalChiSquareFitterTool()

virtual ActsTrk::GlobalChiSquareFitterTool::~GlobalChiSquareFitterTool ( )

virtualdefault

Member Function Documentation

◆ fit() [1/9]

std::unique_ptr< ActsTrk::MutableTrackContainer > ActsTrk::GlobalChiSquareFitterTool::fit	(	const EventContext &	ctx,
		const ActsTrk::Seed &	seed,
		const Acts::BoundTrackParameters &	initialParams,
		const Acts::GeometryContext &	tgContext,
		const Acts::MagneticFieldContext &	mfContext,
		const Acts::CalibrationContext &	calContext,
		const DetectorElementToActsGeometryIdMap &	detectorElementToGeometryIdMap
	)		const

overridevirtual

Acts seed fit.

Definition at line 881 of file GlobalChiSquareFitterTool.cxx.

           {
   const Acts::TrackingGeometry* actsTrackingGeometry =
       m_trackingGeometryTool->trackingGeometry().get();
   if (!actsTrackingGeometry) {
     throw std::runtime_error("No Acts tracking geometry.");
   }
  
   std::vector<ActsTrk::ATLASUncalibSourceLink> sourceLinks;
   sourceLinks.reserve(6);
  
   std::vector<const Acts::Surface*> surfaces;
   surfaces.reserve(6);
  
   const auto& sps = seed.sp();
   for (const xAOD::SpacePoint* sp : sps) {
     const auto& measurements = sp->measurements();
     for (const xAOD::UncalibratedMeasurement* umeas : measurements) {
       ActsTrk::ATLASUncalibSourceLink el(makeATLASUncalibSourceLink(umeas));
       sourceLinks.emplace_back(el);
       surfaces.push_back(ActsTrk::getSurfaceOfMeasurement(
           *actsTrackingGeometry, detectorElementToGeometryIdMap, *umeas));
     }
   }
   return fit(ctx, sourceLinks, initialParams, tgContext, mfContext, calContext,
              detectorElementToGeometryIdMap, surfaces.front());
 }

◆ fit() [2/9]

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

overridevirtual

Definition at line 916 of file GlobalChiSquareFitterTool.cxx.

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

◆ fit() [3/9]

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

overridevirtual

fit a set of xAOD uncalibrated Measurements

Definition at line 443 of file GlobalChiSquareFitterTool.cxx.

                                 {
   ATH_MSG_ERROR("The ACTS Global Chi Square Fitter has no direct fitter.");
   return nullptr;
 }

◆ fit() [4/9]

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 298 of file GlobalChiSquareFitterTool.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
   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3{0., 0., 0.});
  
   Acts::GeometryContext tgContext =
       m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext =
       m_extrapolationTool->getMagneticFieldContext(ctx);
   // CalibrationContext converter not implemented yet.
   Acts::CalibrationContext calContext = Acts::CalibrationContext();
  
   Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend>
       gx2fExtensions = m_gx2fExtensions;
  
   ATLASSourceLinkSurfaceAccessor surfaceAccessor{&(*m_ATLASConverterTool)};
   gx2fExtensions.surfaceAccessor
       .connect<&ATLASSourceLinkSurfaceAccessor::operator()>(&surfaceAccessor);
  
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
   // Set the Gx2Fitter options
   Acts::Experimental::Gx2FitterOptions gx2fOptions(
       tgContext, mfContext, calContext, gx2fExtensions, propagationOption,
       &(*pSurface), true, true);
  
   std::vector<Acts::SourceLink> trackSourceLinks;
   trackSourceLinks.reserve(inputMeasSet.size());
  
   for (auto it = inputMeasSet.begin(); it != inputMeasSet.end(); ++it) {
     trackSourceLinks.push_back(
         m_ATLASConverterTool->trkMeasurementToSourceLink(tgContext, **it));
   }
   // 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 track;
   }
  
   const auto& initialParams =
       m_ATLASConverterTool->trkTrackParametersToActsParameters(
           estimatedStartParameters, tgContext);
  
   ActsTrk::MutableTrackContainer tracks;
  
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                               initialParams, gx2fOptions, tracks);
   if (result.ok()) {
     track = makeTrack(ctx, tgContext, tracks, result);
   }
   return track;
 }

◆ fit() [5/9]

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 371 of file GlobalChiSquareFitterTool.cxx.

                                          {
   ATH_MSG_DEBUG("--> entering GlobalChiSquareFitterTool::fit(PRDS,TP,)");
  
   std::unique_ptr<Trk::Track> track = nullptr;
  
   // Construct a perigee surface as the target surface
   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3{0., 0., 0.});
  
   Acts::GeometryContext tgContext =
       m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext =
       m_extrapolationTool->getMagneticFieldContext(ctx);
   // CalibrationContext converter not implemented yet.
   Acts::CalibrationContext calContext = Acts::CalibrationContext();
  
   Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend>
       gx2fExtensions = m_gx2fExtensions;
  
   PRDSourceLinkCalibratorGX2F calibrator{};  // @TODO: Set tool pointers
   calibrator.rotCreator = m_ROTcreator.get();
   calibrator.broadRotCreator = m_broadROTcreator.get();
   calibrator.converterTool = m_ATLASConverterTool.get();
   gx2fExtensions.calibrator.connect<&PRDSourceLinkCalibratorGX2F::calibrate<
       ActsTrk::MutableTrackStateBackend>>(&calibrator);
  
   PRDSourceLinkSurfaceAccessorGX2F surfaceAccessor{m_ATLASConverterTool.get()};
   gx2fExtensions.surfaceAccessor
       .connect<&PRDSourceLinkSurfaceAccessorGX2F::operator()>(&surfaceAccessor);
  
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
   // Set the Gx2Fitter options
   Acts::Experimental::Gx2FitterOptions gx2fOptions(
       tgContext, mfContext, calContext, gx2fExtensions, propagationOption,
       &(*pSurface), true, true);
  
   std::vector<Acts::SourceLink> trackSourceLinks;
   trackSourceLinks.reserve(inputPRDColl.size());
  
   for (const Trk::PrepRawData* prd : inputPRDColl) {
     trackSourceLinks.push_back(Acts::SourceLink{PRDSourceLinkGX2F{prd}});
   }
   // 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 track;
   }
  
   const auto& initialParams =
       m_ATLASConverterTool->trkTrackParametersToActsParameters(
           estimatedStartParameters, tgContext);
  
   ActsTrk::MutableTrackContainer tracks;
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                               initialParams, gx2fOptions, tracks);
   if (result.ok()) {
     track = makeTrack(ctx, tgContext, tracks, result, true);
   }
   return track;
 }

◆ fit() [6/9]

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 460 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;
   }
  
   std::unique_ptr<Trk::Track> track = nullptr;
  
   // Construct a perigee surface as the target surface
   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3{0., 0., 0.});
  
   Acts::GeometryContext tgContext =
       m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext =
       m_extrapolationTool->getMagneticFieldContext(ctx);
   // CalibrationContext converter not implemented yet.
   Acts::CalibrationContext calContext = Acts::CalibrationContext();
  
   Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend>
       gx2fExtensions = m_gx2fExtensions;
  
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
   // Set the Gx2Fitter options
   Acts::Experimental::Gx2FitterOptions gx2fOptions(
       tgContext, mfContext, calContext, gx2fExtensions, propagationOption,
       &(*pSurface), true, true);
  
   std::vector<Acts::SourceLink> trackSourceLinks =
       m_ATLASConverterTool->trkTrackToSourceLinks(tgContext, inputTrack);
   const auto& initialParams =
       m_ATLASConverterTool->trkTrackParametersToActsParameters(
           *(inputTrack.perigeeParameters()), tgContext);
  
   for (auto it = addMeasColl.begin(); it != addMeasColl.end(); ++it) {
     trackSourceLinks.push_back(
         m_ATLASConverterTool->trkMeasurementToSourceLink(tgContext, **it));
   }
   // 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 track;
   }
  
   ActsTrk::MutableTrackContainer tracks;
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                               initialParams, gx2fOptions, tracks);
   if (result.ok()) {
     track = makeTrack(ctx, tgContext, tracks, result);
   }
   return track;
 }

◆ fit() [7/9]

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 548 of file GlobalChiSquareFitterTool.cxx.

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

◆ fit() [8/9]

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 211 of file GlobalChiSquareFitterTool.cxx.

                                          {
   std::unique_ptr<Trk::Track> track = nullptr;
   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{0., 0., 0.});
  
   Acts::GeometryContext tgContext =
       m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext =
       m_extrapolationTool->getMagneticFieldContext(ctx);
   // CalibrationContext converter not implemented yet.
   Acts::CalibrationContext calContext = Acts::CalibrationContext();
  
   Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend>
       gx2fExtensions = m_gx2fExtensions;
  
   ATLASSourceLinkSurfaceAccessor surfaceAccessor{&(*m_ATLASConverterTool)};
   gx2fExtensions.surfaceAccessor
       .connect<&ATLASSourceLinkSurfaceAccessor::operator()>(&surfaceAccessor);
  
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
   // Set the Gx2Fitter options
   Acts::Experimental::Gx2FitterOptions gx2fOptions(
       tgContext, mfContext, calContext, gx2fExtensions, propagationOption,
       &(*pSurface), true, true);
  
   std::vector<Acts::SourceLink> trackSourceLinks =
       m_ATLASConverterTool->trkTrackToSourceLinks(tgContext, 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 track;
   }
  
   const auto& initialParams =
       m_ATLASConverterTool->trkTrackParametersToActsParameters(
           (*inputTrack.perigeeParameters()), tgContext);
  
   // @TODO: Synchronize with prtHypothesis
   Acts::ParticleHypothesis hypothesis = Acts::ParticleHypothesis::pion();
  
   const Acts::BoundTrackParameters initialParamsWithHypothesis(
       initialParams.referenceSurface().getSharedPtr(),
       initialParams.parameters(), initialParams.covariance(), hypothesis);
  
   ActsTrk::MutableTrackContainer tracks;
  
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                               initialParamsWithHypothesis, gx2fOptions, tracks);
   if (result.ok()) {
     track = makeTrack(ctx, tgContext, tracks, result);
   }
   return track;
 }

◆ fit() [9/9]

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 560 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;
   }
  
   std::unique_ptr<Trk::Track> track = nullptr;
  
   // Construct a perigee surface as the target surface
   auto pSurface = Acts::Surface::makeShared<Acts::PerigeeSurface>(
       Acts::Vector3{0., 0., 0.});
  
   Acts::GeometryContext tgContext =
       m_trackingGeometryTool->getGeometryContext(ctx).context();
   Acts::MagneticFieldContext mfContext =
       m_extrapolationTool->getMagneticFieldContext(ctx);
   // CalibrationContext converter not implemented yet.
   Acts::CalibrationContext calContext = Acts::CalibrationContext();
  
   Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend>
       gx2fExtensions = m_gx2fExtensions;
  
   Acts::PropagatorPlainOptions propagationOption(tgContext, mfContext);
   propagationOption.maxSteps = m_option_maxPropagationStep;
   // Set the Gx2Fitter options
   Acts::Experimental::Gx2FitterOptions gx2fOptions(
       tgContext, mfContext, calContext, gx2fExtensions, propagationOption,
       &(*pSurface), true, true);
  
   std::vector<Acts::SourceLink> trackSourceLinks =
       m_ATLASConverterTool->trkTrackToSourceLinks(tgContext, intrk1);
   std::vector<Acts::SourceLink> trackSourceLinks2 =
       m_ATLASConverterTool->trkTrackToSourceLinks(tgContext, intrk2);
   trackSourceLinks.insert(trackSourceLinks.end(), trackSourceLinks2.begin(),
                           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 track;
   }
  
   const auto& initialParams =
       m_ATLASConverterTool->trkTrackParametersToActsParameters(
           *(intrk1.perigeeParameters()), tgContext);
  
   Acts::ParticleHypothesis hypothesis = Acts::ParticleHypothesis::pion();
  
   const Acts::BoundTrackParameters initialParamsWithHypothesis(
       initialParams.referenceSurface().getSharedPtr(),
       initialParams.parameters(), initialParams.covariance(), hypothesis);
  
   ActsTrk::MutableTrackContainer tracks;
   // Perform the fit
   auto result = m_fitter->fit(trackSourceLinks.begin(), trackSourceLinks.end(),
                               initialParamsWithHypothesis, gx2fOptions, tracks);
   if (result.ok()) {
     track = makeTrack(ctx, tgContext, tracks, result);
   }
   return track;
 }

◆ initialize()

StatusCode ActsTrk::GlobalChiSquareFitterTool::initialize ( )

overridevirtual

Definition at line 165 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_trkSummaryTool.retrieve());
   if (m_doReFitFromPRD) {
     ATH_CHECK(m_ROTcreator.retrieve());
     ATH_CHECK(m_broadROTcreator.retrieve());
   }
  
   m_logger = makeActsAthenaLogger(this, "Gx2fRefit");
  
   auto field = std::make_shared<ATLASMagneticFieldWrapper>();
  
   // Fitter
   Acts::SympyStepper stepper(field);
   Acts::Navigator navigator(
       Acts::Navigator::Config{m_trackingGeometryTool->trackingGeometry()},
       logger().cloneWithSuffix("Navigator"));
   Acts::Propagator<Acts::SympyStepper, Acts::Navigator> propagator(
       stepper, std::move(navigator), logger().cloneWithSuffix("Prop"));
  
   m_fitter = std::make_unique<Fitter>(
       std::move(propagator), logger().cloneWithSuffix("GlobalChiSquareFitter"));
  
   m_calibrator = std::make_unique<ActsTrk::detail::TrkMeasurementCalibrator>(
       *m_ATLASConverterTool);
   m_outlierFinder.StateChiSquaredPerNumberDoFCut = m_option_outlierChi2Cut;
  
   m_gx2fExtensions.outlierFinder
       .connect<&ActsTrk::detail::FitterHelperFunctions::ATLASOutlierFinder::
                operator()<ActsTrk::MutableTrackStateBackend>>(&m_outlierFinder);
   m_gx2fExtensions.updater
       .connect<&ActsTrk::detail::FitterHelperFunctions::gainMatrixUpdate<
           ActsTrk::MutableTrackStateBackend>>();
   m_gx2fExtensions.calibrator
       .connect<&ActsTrk::detail::TrkMeasurementCalibrator::calibrate<
           ActsTrk::MutableTrackStateBackend>>(m_calibrator.get());
  
   return StatusCode::SUCCESS;
 }

◆ logger()

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

inlineprivate

Private access to the logger.

Definition at line 213 of file GlobalChiSquareFitterTool.h.

213 { return *m_logger; }

◆ makeTrack()

std::unique_ptr< Trk::Track > ActsTrk::GlobalChiSquareFitterTool::makeTrack	(	const EventContext &	ctx,
		Acts::GeometryContext &	tgContext,
		ActsTrk::MutableTrackContainer &	tracks,
		Acts::Result< ActsTrk::MutableTrackContainer::TrackProxy, std::error_code > &	fitResult,
		bool	SourceLinkType = `false`
	)		const

private

Definition at line 647 of file GlobalChiSquareFitterTool.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 consider states 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)");
           const Acts::BoundTrackParameters actsParam(
               state.referenceSurface().getSharedPtr(), state.smoothed(),
               state.smoothedCovariance(), 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);
         } else if (flag.test(Acts::TrackStateFlag::OutlierFlag)) {
           ATH_MSG_VERBOSE("The state was tagged as an outlier");
           const Acts::BoundTrackParameters actsParam(
               state.referenceSurface().getSharedPtr(), state.smoothed(),
               state.smoothedCovariance(), acts_track.particleHypothesis());
           parm = m_ATLASConverterTool->actsTrackParametersToTrkParameters(
               actsParam, tgContext);
           typePattern.set(Trk::TrackStateOnSurface::Outlier);
         } else {
           ATH_MSG_VERBOSE("The state is a measurement state");
  
           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() && !SourceLinkType) {
           auto sl =
               state.getUncalibratedSourceLink().template get<ATLASSourceLink>();
           assert(sl);
           measState = sl->uniqueClone();
         } else if (state.hasUncalibratedSourceLink() && SourceLinkType) {
           // If the SourceLink is of type PRDSourceLinkGX2F, we need to create
           // the RIO_OnTrack here.
           auto sl = state.getUncalibratedSourceLink()
                         .template get<PRDSourceLinkGX2F>()
                         .prd;
  
           // ROT creation
           const IdentifierHash idHash = sl->detectorElement()->identifyHash();
           int dim = state.calibratedSize();
           std::unique_ptr<Trk::RIO_OnTrack> rot;
           if (dim == 1) {
             const InDet::SCT_Cluster* sct_Cluster =
                 dynamic_cast<const InDet::SCT_Cluster*>(sl);
             if (!sct_Cluster) {
               ATH_MSG_ERROR("ERROR could not cast PRD to SCT_Cluster");
               return;
             }
             rot = std::make_unique<InDet::SCT_ClusterOnTrack>(
                 sct_Cluster,
                 Trk::LocalParameters(Trk::DefinedParameter(
                     state.template calibrated<1>()[0], Trk::loc1)),
                 state.template calibratedCovariance<1>(), idHash);
           } else if (dim == 2) {
             const InDet::PixelCluster* pixelCluster =
                 dynamic_cast<const InDet::PixelCluster*>(sl);
             if (!pixelCluster) {
               // sometimes even with dim=2, only the SCT_Cluster implementation
               // work for RIO_OnTrack creation
               ATH_MSG_VERBOSE(
                   "Dimension is 2 but we need SCT_Cluster for this "
                   "measurement");
               const InDet::SCT_Cluster* sct_Cluster =
                   dynamic_cast<const InDet::SCT_Cluster*>(sl);
               rot = std::make_unique<InDet::SCT_ClusterOnTrack>(
                   sct_Cluster,
                   Trk::LocalParameters(Trk::DefinedParameter(
                       state.template calibrated<1>()[0], Trk::loc1)),
                   state.template calibratedCovariance<1>(), idHash);
             } else {
               rot = std::make_unique<InDet::PixelClusterOnTrack>(
                   pixelCluster,
                   Trk::LocalParameters(state.template calibrated<2>()),
                   state.template calibratedCovariance<2>(), idHash);
             }
           } else {
             throw std::domain_error("Cannot handle measurement dim>2");
           }
           measState = rot->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 successfully created add it to the trajectory
         if (perState) {
           ATH_MSG_VERBOSE(
               "State successfully created, 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::GlobalChi2Fitter,
                          Trk::noHypothesis);
   // Mark the fitter as GlobalChi2Fitter
   newInfo.setTrackFitter(Trk::TrackInfo::TrackFitter::GlobalChi2Fitter);
   newtrack = std::make_unique<Trk::Track>(newInfo, std::move(finalTrajectory),
                                           nullptr);
   if (newtrack) {
     // 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;
 }

Member Data Documentation

◆ m_ATLASConverterTool

ToolHandle<ActsTrk::IActsToTrkConverterTool> ActsTrk::GlobalChiSquareFitterTool::m_ATLASConverterTool

private

Initial value:

{

this, "ATLASConverterTool", ""}

Definition at line 180 of file GlobalChiSquareFitterTool.h.

◆ m_boundaryCheckTool

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

private

Initial value:

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

Definition at line 184 of file GlobalChiSquareFitterTool.h.

◆ m_broadROTcreator

ToolHandle<Trk::IRIO_OnTrackCreator> ActsTrk::GlobalChiSquareFitterTool::m_broadROTcreator

private

Initial value:

{

this, "BroadRotCreatorTool", ""}

Definition at line 218 of file GlobalChiSquareFitterTool.h.

◆ m_calibrator

std::unique_ptr<ActsTrk::detail::TrkMeasurementCalibrator> ActsTrk::GlobalChiSquareFitterTool::m_calibrator

private

Initial value:

{

nullptr}

Definition at line 198 of file GlobalChiSquareFitterTool.h.

◆ m_doReFitFromPRD

Gaudi::Property<bool> ActsTrk::GlobalChiSquareFitterTool::m_doReFitFromPRD

private

Initial value:

{this, "DoReFitFromPRD", false,

"Do Refit From PRD instead of ROT"}

Definition at line 222 of file GlobalChiSquareFitterTool.h.

◆ m_extrapolationTool

ToolHandle<IActsExtrapolationTool> ActsTrk::GlobalChiSquareFitterTool::m_extrapolationTool

private

Initial value:

{

this, "ExtrapolationTool", ""}

Definition at line 176 of file GlobalChiSquareFitterTool.h.

◆ m_fitter

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

private

Definition at line 205 of file GlobalChiSquareFitterTool.h.

◆ m_gx2fExtensions

Acts::Experimental::Gx2FitterExtensions<ActsTrk::MutableTrackStateBackend> ActsTrk::GlobalChiSquareFitterTool::m_gx2fExtensions

private

Definition at line 208 of file GlobalChiSquareFitterTool.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::GlobalChiSquareFitterTool::m_logger

private

logging instance

Definition at line 216 of file GlobalChiSquareFitterTool.h.

◆ m_option_maxPropagationStep

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

private

Initial value:

{
      this, "MaxPropagationStep", 5000,
      "Maximum number of steps for one propagate call"}

Definition at line 191 of file GlobalChiSquareFitterTool.h.

◆ m_option_outlierChi2Cut

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

private

Initial value:

{

this, "OutlierChi2Cut", 12.5, "Chi2 cut used by the outlier finder"}

Definition at line 189 of file GlobalChiSquareFitterTool.h.

◆ m_option_seedCovarianceScale

Gaudi::Property<double> ActsTrk::GlobalChiSquareFitterTool::m_option_seedCovarianceScale

private

Initial value:

{
      this, "SeedCovarianceScale", 100.,
      "Scale factor for the input seed covariance when doing refitting"}

Definition at line 194 of file GlobalChiSquareFitterTool.h.

◆ m_outlierFinder

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

private

Definition at line 210 of file GlobalChiSquareFitterTool.h.

◆ m_ROTcreator

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

private

Definition at line 220 of file GlobalChiSquareFitterTool.h.

◆ m_trackingGeometryTool

ToolHandle<IActsTrackingGeometryTool> ActsTrk::GlobalChiSquareFitterTool::m_trackingGeometryTool

private

Initial value:

{

this, "TrackingGeometryTool", ""}

Definition at line 178 of file GlobalChiSquareFitterTool.h.

◆ m_trkSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> ActsTrk::GlobalChiSquareFitterTool::m_trkSummaryTool

private

Initial value:

{

this, "SummaryTool", "", "ToolHandle for track summary tool"}

Definition at line 182 of file GlobalChiSquareFitterTool.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

◆ Fitter

Constructor & Destructor Documentation

◆ GlobalChiSquareFitterTool()

◆ ~GlobalChiSquareFitterTool()

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]

◆ initialize()

◆ logger()

◆ makeTrack()

Member Data Documentation

◆ m_ATLASConverterTool

◆ m_boundaryCheckTool

◆ m_broadROTcreator

◆ m_calibrator

◆ m_doReFitFromPRD

◆ m_extrapolationTool

◆ m_fitter

◆ m_gx2fExtensions

◆ m_logger

◆ m_option_maxPropagationStep

◆ m_option_outlierChi2Cut

◆ m_option_seedCovarianceScale

◆ m_outlierFinder

◆ m_ROTcreator

◆ m_trackingGeometryTool

◆ m_trkSummaryTool