#include <GaussianSumFitterTool.h>

Inheritance diagram for ActsTrk::GaussianSumFitterTool:

Collaboration diagram for ActsTrk::GaussianSumFitterTool:

Public Member Functions
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
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
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
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
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
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
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.
virtual std::unique_ptr< ActsTrk::MutableTrackContainer >	fit (const std::vector< const xAOD::UncalibratedMeasurement * > &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	TrackState_t = MutableTrackStateBackend::TrackStateProxy
	Abrivate the track state proxy.
using	Fitter
	Type erased track fitter function.
using	DirectFitter

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::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::GsfOptions< ActsTrk::MutableTrackStateBackend > &gsfOptions, const std::vector< Acts::SourceLink > &trackSourceLinks, const Acts::BoundTrackParameters &initialParams, const std::vector< const Acts::Surface * > &surfaces) const
const Acts::GsfExtensions< ActsTrk::MutableTrackStateBackend > &	getExtensions () const
const Acts::Logger &	logger () const
	Private access to the logger.

Private Attributes
ToolHandle< IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", ""}
PublicToolHandle< ITrackingGeometryTool >	m_trackingGeometryTool {this, "TrackingGeometryTool", ""}
PublicToolHandle< IGeometryRealmConvTool >	m_geometryConvTool {this, "GeometryRealmConvTool", ""}
ToolHandle< ITrackConverterTool >	m_ATLASConverterTool {this, "ATLASConverterTool", ""}
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trkSummaryTool {this, "SummaryTool", "", "ToolHandle for track summary tool"}
ToolHandle< Trk::IBoundaryCheckTool >	m_boundaryCheckTool
ToolHandle< Trk::IRIO_OnTrackCreator >	m_ROTcreator {this, "RotCreatorTool", ""}
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

Detailed Description

Definition at line 47 of file GaussianSumFitterTool.h.

Member Typedef Documentation

◆ DirectFitter

using ActsTrk::GaussianSumFitterTool::DirectFitter

private

Initial value:

Acts::GaussianSumFitter< Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::DirectNavigator>,

ActsTrk::MutableTrackStateBackend >

ActsTrk::MutableTrackStateBackend

Acts::VectorMultiTrajectory MutableTrackStateBackend

Definition TrackContainer.h:18

Definition at line 197 of file GaussianSumFitterTool.h.

◆ Fitter

using ActsTrk::GaussianSumFitterTool::Fitter

private

Initial value:

Acts::GaussianSumFitter< Acts::Propagator<Acts::MultiEigenStepperLoop<>, Acts::Navigator>,

ActsTrk::MutableTrackStateBackend >

Type erased track fitter function.

Definition at line 191 of file GaussianSumFitterTool.h.

◆ TrackState_t

using ActsTrk::GaussianSumFitterTool::TrackState_t = MutableTrackStateBackend::TrackStateProxy

private

Abrivate the track state proxy.

Definition at line 156 of file GaussianSumFitterTool.h.

Constructor & Destructor Documentation

◆ ~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 415 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 439 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().hasMeasurement()) {
      sourceLinks.push_back(ts.getUncalibratedSourceLink());
    }
  }
 
  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{getCalibrationContext(ctx)};
 
  Acts::GsfOptions<ActsTrk::MutableTrackStateBackend> gsfOptions = prepareOptions(tgContext, mfContext, calContext, pSurface);
 
  detail::RefittingCalibrator calibrator{m_geometryConvTool.get(), m_ROTcreator.get()};
  using xAODUnCalibrator_t = detail::OnTrackCalibrator<ActsTrk::MutableTrackStateBackend>;
  auto xODCalibrator = xAODUnCalibrator_t::NoCalibration(m_trackingGeometryTool.get());
  calibrator.connect<&xAODUnCalibrator_t::calibrate>(xAOD::UncalibMeasType::PixelClusterType, &xODCalibrator);
  calibrator.connect<&xAODUnCalibrator_t::calibrate>(xAOD::UncalibMeasType::StripClusterType, &xODCalibrator);
  
 
  detail::RefittingSurfaceAccesor surfaceAcc{m_geometryConvTool.get(),
                                             m_trackingGeometryTool.get()};
 
  auto gsfExtensions = m_gsfExtensions;
  gsfExtensions.calibrator.connect<&detail::RefittingCalibrator::calibrate>(&calibrator);
  gsfExtensions.surfaceAccessor.connect<&detail::RefittingSurfaceAccesor::operator()>(&surfaceAcc);
  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 215 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;
  detail::MeasurementCalibratorBase::pack(inputMeasSet, trackSourceLinks);
 
  const auto initialParams = m_geometryConvTool->convertTrackParametersToActs(ctx, estimatedStartParameters);
  
  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,
                gsfOptions,
                trackSourceLinks,
                initialParams,
                surfaces);
  }else{
    return performFit(ctx,
              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 273 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 288 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_geometryConvTool->convertTrackParametersToActs(ctx, *inputTrack.perigeeParameters());
 
  detail::MeasurementCalibratorBase::pack(addMeasColl, trackSourceLinks);
 
  return performFit(ctx, 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 344 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 161 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_geometryConvTool->convertTrackParametersToActs(ctx, *inputTrack.perigeeParameters());
 
  return performFit(ctx, 
            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 358 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_geometryConvTool->convertTrackParametersToActs(ctx, *intrk1.perigeeParameters());
 
  return performFit(ctx, gsfOptions,
                    trackSourceLinks,
                    initialParams);
}

◆ fit() [9/9]

std::unique_ptr< ActsTrk::MutableTrackContainer > ActsTrk::GaussianSumFitterTool::fit	(	const std::vector< const xAOD::UncalibratedMeasurement * > &	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 427 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 498 of file GaussianSumFitterTool.cxx.

{ 
  return m_gsfExtensions;
}

◆ initialize()

StatusCode ActsTrk::GaussianSumFitterTool::initialize ( )

overridevirtual

Definition at line 81 of file GaussianSumFitterTool.cxx.

                                             {
  ATH_MSG_DEBUG(name() << "::" << __FUNCTION__);
 
  ATH_CHECK(m_trackingGeometryTool.retrieve());
  ATH_CHECK(m_extrapolationTool.retrieve());
  ATH_CHECK(m_ATLASConverterTool.retrieve());
  ATH_CHECK(m_geometryConvTool.retrieve());
  ATH_CHECK(m_trkSummaryTool.retrieve(EnableTool{!m_refitOnly}));
  if (m_refitOnly) {
    ATH_MSG_INFO("Running GSF without track summary");
  }
  ATH_CHECK(m_ROTcreator.retrieve(EnableTool{!m_ROTcreator.empty()}));
 
  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"));
 
  // Use the GeantSim Bethe-Heitler parameterisation, which clamps at X/X0=0.20
  // matching the behaviour in Trk::ElectronCombinedMaterialEffects. The files
  // store coefficients in logit(z) space; transform=true applies sigmoid/exp to
  // recover physical z in (0,1).
  const std::string bhLow  = PathResolver::find_file("GeantSim_LT01_cdf_nC6_O5.par", "DATAPATH");
  const std::string bhHigh = PathResolver::find_file("GeantSim_GT01_cdf_nC6_O5.par", "DATAPATH");
  ATH_MSG_INFO("ACTS GSF: loading GeantSim BH parameterisation (" << bhLow << ", " << bhHigh << ")");
  auto bha = std::make_shared<Acts::AtlasBetheHeitlerApprox>(
      readBHParFile(bhLow), readBHParFile(bhHigh),
      /*lowTransform=*/true, /*highTransform=*/true,
      /*lowLimit=*/0.1, /*highLimit=*/0.2, /*clampToRange=*/true,
      /*noChangeLimit=*/0.0001, /*singleGaussianLimit=*/0.002);
  m_fitter = std::make_unique<Fitter>(std::move(propagator), 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"));
    m_directFitter = std::make_unique<DirectFitter>(std::move(directPropagator), bha,
                            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<TrackState_t>>(m_calibrator.get());
 
  m_surfaceAccessor = detail::TrkMeasSurfaceAccessor{m_geometryConvTool.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 505 of file GaussianSumFitterTool.cxx.

{ 
  return *m_logger;
}

◆ performDirectFit()

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::performDirectFit	(	const EventContext &	ctx,
		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);
 
  return m_ATLASConverterTool->convertFitResult(ctx, result,
                                                Trk::TrackInfo::TrackFitter::GaussianSumFilter);
}

◆ performFit()

std::unique_ptr< Trk::Track > ActsTrk::GaussianSumFitterTool::performFit	(	const EventContext &	ctx,
		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);
 
  return m_ATLASConverterTool->convertFitResult(ctx, result,
                                                Trk::TrackInfo::TrackFitter::GaussianSumFilter);
}

◆ 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 511 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<ITrackConverterTool> ActsTrk::GaussianSumFitterTool::m_ATLASConverterTool {this, "ATLASConverterTool", ""}

private

Definition at line 160 of file GaussianSumFitterTool.h.

160{this, "ATLASConverterTool", ""};

◆ m_boundaryCheckTool

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

private

Initial value:

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

Definition at line 162 of file GaussianSumFitterTool.h.

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

◆ m_calibrator

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

private

Definition at line 194 of file GaussianSumFitterTool.h.

194{nullptr};

◆ m_componentMergeMethod

Acts::ComponentMergeMethod ActsTrk::GaussianSumFitterTool::m_componentMergeMethod

private

Definition at line 188 of file GaussianSumFitterTool.h.

◆ m_directFitter

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

private

Definition at line 199 of file GaussianSumFitterTool.h.

199{nullptr};

◆ m_extrapolationTool

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

private

Definition at line 157 of file GaussianSumFitterTool.h.

157{this, "ExtrapolationTool", ""};

◆ m_fitter

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

private

Definition at line 195 of file GaussianSumFitterTool.h.

195{nullptr};

◆ m_geometryConvTool

PublicToolHandle<IGeometryRealmConvTool> ActsTrk::GaussianSumFitterTool::m_geometryConvTool {this, "GeometryRealmConvTool", ""}

private

Definition at line 159 of file GaussianSumFitterTool.h.

159{this, "GeometryRealmConvTool", ""};

◆ m_gsfExtensions

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

private

Definition at line 203 of file GaussianSumFitterTool.h.

◆ m_logger

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

private

logging instance

Definition at line 208 of file GaussianSumFitterTool.h.

208{nullptr};

◆ m_maxComponents

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

private

Initial value:

{this, "MaxComponents", 12,

"Maximum number of components in GSF"}

Definition at line 173 of file GaussianSumFitterTool.h.

173 {this, "MaxComponents", 12,

174 "Maximum number of components in GSF"};

◆ 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 185 of file GaussianSumFitterTool.h.

185 {this, "ComponentMergeMethod", "MaxWeight"

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

◆ 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 170 of file GaussianSumFitterTool.h.

170 {this, "MaxPropagationStep", 5000,

171 "Maximum number of steps for one propagate call"};

◆ 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 168 of file GaussianSumFitterTool.h.

168 {this, "OutlierChi2Cut", 12.5,

169 "Chi2 cut used by the outlier finder" };

◆ m_outlierFinder

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

private

Definition at line 205 of file GaussianSumFitterTool.h.

205{0};

◆ 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 179 of file GaussianSumFitterTool.h.

179 {this, "RefitOnly", false,

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

◆ m_ROTcreator

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

private

Definition at line 166 of file GaussianSumFitterTool.h.

166{this, "RotCreatorTool", ""};

◆ m_surfaceAccessor

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

private

Definition at line 202 of file GaussianSumFitterTool.h.

202{};

◆ m_trackingGeometryTool

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

private

Definition at line 158 of file GaussianSumFitterTool.h.

158{this, "TrackingGeometryTool", ""};

◆ m_trkSummaryTool

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

private

Definition at line 161 of file GaussianSumFitterTool.h.

161{this, "SummaryTool", "", "ToolHandle for track summary tool"};

◆ 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 176 of file GaussianSumFitterTool.h.

176 {this, "UseDirectNavigation", false,

177 "GSF with direct navigation when refitting measurements"};

◆ m_weightCutOff

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

private

Initial value:

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

"component weight cut off"}

Definition at line 182 of file GaussianSumFitterTool.h.

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

183 "component weight cut off"};

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

◆ TrackState_t

Constructor & Destructor Documentation

◆ ~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()

◆ performDirectFit()

◆ performFit()

◆ prepareOptions()

Member Data Documentation

◆ m_ATLASConverterTool

◆ m_boundaryCheckTool

◆ m_calibrator

◆ m_componentMergeMethod

◆ m_directFitter

◆ m_extrapolationTool

◆ m_fitter

◆ m_geometryConvTool

◆ m_gsfExtensions

◆ m_logger

◆ m_maxComponents

◆ m_option_componentMergeMethod

◆ m_option_maxPropagationStep

◆ m_option_outlierChi2Cut

◆ m_outlierFinder

◆ m_refitOnly

◆ m_ROTcreator

◆ m_surfaceAccessor

◆ m_trackingGeometryTool

◆ m_trkSummaryTool

◆ m_useDirectNavigation

◆ m_weightCutOff