#include <GaussianSumFitter.h>

Inheritance diagram for Trk::GaussianSumFitter:

Collaboration diagram for Trk::GaussianSumFitter:

Public Types
using	GSFTrajectory = std::vector< GSFTsos >

Public Member Functions
	GaussianSumFitter (const std::string &, const std::string &, const IInterface *)
	Constructor with parameters to be passed to AlgTool. More...

virtual	~GaussianSumFitter ()=default
	Virtual destructor. More...

virtual StatusCode	initialize () override final
	AlgTool initialise method. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Inteface method. The main one are the ones taking
Measurement or Raw Data inputs. The rest are implemented on top of these two. We follow the ITrackFitter interface but not all arguements are meaningfull We do not implement outlier remove. Actually by default we try to re-integrate possible outliers from non-GSF fits. The material effects actually applied are determined by the dedicated configured GsfExtrapolator.
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const PrepRawDataSet &, const TrackParameters &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Fit a collection of 'PrepRawData' objects using the Gaussian Sum Filter. More...

virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const MeasurementSet &, const TrackParameters &, const RunOutlierRemoval, const ParticleHypothesis particleHypothesis) const override final
	Fit a collection of 'RIO_OnTrack' objects using the Gaussian Sum Filter. More...

virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Refit a track. More...

virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const PrepRawDataSet &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Refit a track adding a PrepRawDataSet. More...

virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const MeasurementSet &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Refit a track adding a measurement base set. More...

virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const Track &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Combine two tracks by refitting their measurements. More...

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Helper methods
std::unique_ptr< MultiComponentStateOnSurfaceDV >	convertTrajToTrack (GSFTrajectory &trajectory) const
	Helper to convert the GSFTrajectory to a Trk::Track. More...

GSFTsos	makePerigee (const EventContext &ctx, Trk::IMultiStateExtrapolator::Cache &, const GSFTrajectory &smoothedTrajectory) const
	Produces a perigee from a smoothed trajectory. More...

bool	addCCOT (const EventContext &ctx, const Trk::CaloCluster_OnTrack *ccot, GSFTrajectory &smoothedTrajectory) const
	Methof to add the CaloCluster onto the track. More...

Actual implementation of the GSF formalism
template<typename T >
GSFTrajectory	forwardFit (const EventContext &ctx, IMultiStateExtrapolator::Cache &cache, const T &inputSet, const TrackParameters &estimatedTrackParametersNearOrigin) const
	Forward GSF fit. More...

template<typename T >
bool	stepForwardFit (const EventContext &ctx, IMultiStateExtrapolator::Cache &, GSFTrajectory &forwardTrajectory, const T *measurement, const Surface &surface, MultiComponentState &updatedState) const
	Progress one step along the forward fit. More...

GSFTrajectory	smootherFit (const EventContext &ctx, Trk::IMultiStateExtrapolator::Cache &, GSFTrajectory &forwardTrajectory, const CaloCluster_OnTrack *ccot=nullptr) const
	Gsf smoothed trajectory. More...

Private Attributes
ToolHandle< IMultiStateExtrapolator >	m_extrapolator

ToolHandle< IRIO_OnTrackCreator >	m_rioOnTrackCreator

Gaudi::Property< bool >	m_reintegrateOutliers

Gaudi::Property< bool >	m_refitOnMeasurementBase

Gaudi::Property< bool >	m_combineWithFitter

Gaudi::Property< bool >	m_useMode

Gaudi::Property< bool >	m_slimTransientMTSOS

Gaudi::Property< double >	m_cutChiSquaredPerNumberDOF

Gaudi::Property< unsigned int >	m_maximumNumberOfComponents

DoubleArrayProperty	m_smootherCovFactors

TrkParametersComparisonFunction	m_trkParametersComparisonFunction

Trk::ParticleHypothesis	m_particleHypothesis = Trk::electron

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 44 of file GaussianSumFitter.h.

Member Typedef Documentation

◆ GSFTrajectory

using Trk::GaussianSumFitter::GSFTrajectory = std::vector<GSFTsos>

Definition at line 124 of file GaussianSumFitter.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ GaussianSumFitter()

Trk::GaussianSumFitter::GaussianSumFitter	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Constructor with parameters to be passed to AlgTool.

Definition at line 161 of file GaussianSumFitter.cxx.

   : AthAlgTool(type, name, parent)
   , m_trkParametersComparisonFunction{}
 {
   declareInterface<ITrackFitter>(this);
 }

◆ ~GaussianSumFitter()

virtual Trk::GaussianSumFitter::~GaussianSumFitter ( )

virtualdefault

Virtual destructor.

Member Function Documentation

◆ addCCOT()

bool Trk::GaussianSumFitter::addCCOT	(	const EventContext &	ctx,
		const Trk::CaloCluster_OnTrack *	ccot,
		GSFTrajectory &	smoothedTrajectory
	)		const

private

Methof to add the CaloCluster onto the track.

special method to account for possible additional measurement from the calorimeter

Definition at line 765 of file GaussianSumFitter.cxx.

 {
   const GSFTsos& currentMultiStateOS = smoothedTrajectory.back();
   if (!ccot) {
     return false;
   }
   const auto& currentMultiComponentState = currentMultiStateOS.multiComponentState;
   const Trk::MeasurementBase* measurement = currentMultiStateOS.measurementOnTrack.get();
   if (!measurement) {
      return false;
   }
   const Trk::Surface& currentSurface = measurement->associatedSurface();
  
   //Create a ccot that we will own. So we use it to build our own TSOS
   auto ownCCOT = ccot->uniqueClone();
   // Extrapolate to the Calo to get prediction
   Trk::MultiComponentState extrapolatedToCaloState = m_extrapolator->extrapolateDirectly(
     ctx, currentMultiComponentState, ownCCOT->associatedSurface(),
     Trk::alongMomentum, false);
  
   if (extrapolatedToCaloState.empty()) {
     return false;
   }
   // Update newly extrapolated state with measurement
   Trk::FitQualityOnSurface fitQuality;
   Trk::MultiComponentState updatedStateAtCalo =
       Trk::GsfMeasurementUpdator::update(std::move(extrapolatedToCaloState),
                                          *ownCCOT, fitQuality);
   if (updatedStateAtCalo.empty()) {
     return false;
   }
  
   // Extrapolate back to the surface near the origin
   auto improvedState = m_extrapolator->extrapolateDirectly(
       ctx, updatedStateAtCalo, currentSurface, Trk::oppositeMomentum,
       false);
  
   if (improvedState.empty()) {
     return false;
   }
  // Combine the improved state after extrapolating back from the calo
  // and find the mode of the distribution
   std::unique_ptr<Trk::TrackParameters> combinedSingleState =
       MultiComponentStateCombiner::combineToSingle(improvedState, m_useMode);
  
   // Now build a dummy measurement for the improved estimation
   AmgSymMatrix(5) covMatrix;
   covMatrix.setZero();
   covMatrix(0, 0) = 1e6;
   const Trk::DefinedParameter locX(0, Trk::locX);
   Trk::LocalParameters locpars(locX);
   auto pseudoMeasurement = std::make_unique<Trk::PseudoMeasurementOnTrack>(
     std::move(locpars), std::move(covMatrix), currentSurface);
  
   // Build TSOS at the surface of calo
   smoothedTrajectory.emplace_back(
       fitQuality,
       std::move(ownCCOT),
       nullptr,
       std::move(updatedStateAtCalo));
  
   // Build a TSOS using the dummy measurement and and the final combined state
   smoothedTrajectory.emplace_back(
       FitQualityOnSurface{},
       // We do not add the fitquality again. As this would be the one we
       // add at calo. Here not a real measurement
       std::move(pseudoMeasurement),
       std::move(combinedSingleState),
       std::move(improvedState));
  
   return true;
 }

◆ convertTrajToTrack()

std::unique_ptr< MultiComponentStateOnSurfaceDV > Trk::GaussianSumFitter::convertTrajToTrack ( GSFTrajectory & trajectory ) const

private

Helper to convert the GSFTrajectory to a Trk::Track.

Definition at line 500 of file GaussianSumFitter.cxx.

                                     {
   const bool slimTransientMTSOS = m_slimTransientMTSOS;
   auto MTSOS = std::make_unique<MultiComponentStateOnSurfaceDV>();
   MTSOS->reserve(trajectory.size());
   for (GSFTsos& state : trajectory) {
     MTSOS->push_back(state.convert(slimTransientMTSOS));
   }
   return MTSOS;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                      {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fit() [1/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const MeasurementSet &	measurementSet,
		const TrackParameters &	estimatedParametersNearOrigin,
		const	RunOutlierRemoval,
		const ParticleHypothesis	particleHypothesis
	)		const

finaloverridevirtual

Fit a collection of 'RIO_OnTrack' objects using the Gaussian Sum Filter.

Interface method Fitting of a set of MeasurementBase objects This is the main method for MeasurementBase fitting.

This requires that an trackParameters object be supplied also as an initial guess

Implements Trk::ITrackFitter.

Definition at line 411 of file GaussianSumFitter.cxx.

 {
   if (measurementSet.size() < 3) {
     ATH_MSG_WARNING("Requesting fit with less than 3 Measurements!!!");
     return nullptr;
   }
   // We need to separate the possible CaloCluster on Track
   // measurement from the rest
   const Trk::CaloCluster_OnTrack* ccot(nullptr);
  
   Trk::MeasurementSet cleanedMeasurementSet;
   cleanedMeasurementSet.reserve(measurementSet.size());
  
   for (const auto* meas : measurementSet) {
     if (!meas) {
       ATH_MSG_WARNING("There is an empty MeasurementBase object ! ");
       continue;
     }
     if (meas->type(Trk::MeasurementBaseType::CaloCluster_OnTrack)) {
       ccot = static_cast<const Trk::CaloCluster_OnTrack*>(meas);
     } else {
       cleanedMeasurementSet.push_back(meas);
     }
   }
  
   // We need a sorted measurement set
   Trk::MeasurementSet sortedMeasurementSet =
       MeasurementSet(cleanedMeasurementSet);
  
   const Trk::MeasurementBaseComparisonFunction
       measurementBaseComparisonFunction(
           estimatedParametersNearOrigin.position(),
           estimatedParametersNearOrigin.momentum());
   sort(sortedMeasurementSet.begin(), sortedMeasurementSet.end(),
        measurementBaseComparisonFunction);
  
   // Create Extrapolator cache that holds material effects cache;
   Trk::IMultiStateExtrapolator::Cache extrapolatorCache;
  
   // Perform GSF forwards fit
   GSFTrajectory forwardTrajectory =
       forwardFit(ctx, extrapolatorCache, sortedMeasurementSet,
                  estimatedParametersNearOrigin);
  
   if (forwardTrajectory.empty()) {
     return nullptr;
   }
  
   // Perform GSF smoother operation
   GSFTrajectory smoothedTrajectory = smootherFit(
       ctx, extrapolatorCache, forwardTrajectory, ccot);
   if (smoothedTrajectory.empty()) {
     return nullptr;
   }
  
   // fit quality
   std::unique_ptr<FitQuality> fitQuality = buildFitQuality(smoothedTrajectory);
   if (!fitQuality) {
     return nullptr;
   }
  
   // Create parameters at perigee if needed
   auto perigeeMultiStateOnSurface = makePerigee(
       ctx, extrapolatorCache, smoothedTrajectory);
   if (!perigeeMultiStateOnSurface.multiComponentState.empty()) {
     smoothedTrajectory.push_back(std::move(perigeeMultiStateOnSurface));
   } else {
     return nullptr;
   }
  
   // Reverse the order of the TSOS's to make be order flow from inside to out
   std::reverse(smoothedTrajectory.begin(), smoothedTrajectory.end());
  
   // Create track
   Trk::TrackInfo info(Trk::TrackInfo::GaussianSumFilter, m_particleHypothesis);
   info.setTrackProperties(TrackInfo::BremFit);
   info.setTrackProperties(TrackInfo::BremFitSuccessful);
   return std::make_unique<Track>(info, convertTrajToTrack(smoothedTrajectory),
                                  std::move(fitQuality));
 }

◆ fit() [2/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const PrepRawDataSet &	prepRawDataSet,
		const TrackParameters &	estimatedParametersNearOrigin,
		const	RunOutlierRemoval,
		const	ParticleHypothesis
	)		const

finaloverridevirtual

Fit a collection of 'PrepRawData' objects using the Gaussian Sum Filter.

Interface Method Fitting of a set of PrepRawData objects This is the main method for PrepRawData fitting.

This requires that an trackParameters object be supplied also as an initial guess

Implements Trk::ITrackFitter.

Definition at line 341 of file GaussianSumFitter.cxx.

 {
   if (prepRawDataSet.size() < 3) {
     ATH_MSG_WARNING("Requesting Fit with less than three prep Raw Data!!!");
     return nullptr;
   }
   // We need a sorted PrepRawDataSet
   Trk::PrepRawDataSet sortedPrepRawDataSet = PrepRawDataSet(prepRawDataSet);
   const Trk::PrepRawDataComparisonFunction prdComparisonFunction =
       Trk::PrepRawDataComparisonFunction(
           estimatedParametersNearOrigin.position(),
           estimatedParametersNearOrigin.momentum());
  
   std::sort(sortedPrepRawDataSet.begin(), sortedPrepRawDataSet.end(),
             prdComparisonFunction);
  
   // Create Extrapolator cache that holds material effects cache;
   Trk::IMultiStateExtrapolator::Cache extrapolatorCache;
   // Perform GSF forward fit
   GSFTrajectory forwardTrajectory =
       forwardFit(ctx, extrapolatorCache, sortedPrepRawDataSet,
                  estimatedParametersNearOrigin);
  
   if (forwardTrajectory.empty()) {
     return nullptr;
   }
   // Perform GSF smoother operation
   GSFTrajectory smoothedTrajectory = smootherFit(
       ctx, extrapolatorCache, forwardTrajectory);
   if (smoothedTrajectory.empty()) {
     return nullptr;
   }
  
   // Fit quality
   std::unique_ptr<FitQuality> fitQuality = buildFitQuality(smoothedTrajectory);
   if (!fitQuality) {
     return nullptr;
   }
  
   // Create parameters at perigee if needed
   auto perigeeMultiStateOnSurface = makePerigee(
       ctx, extrapolatorCache, smoothedTrajectory);
   if (!perigeeMultiStateOnSurface.multiComponentState.empty()) {
     smoothedTrajectory.push_back(std::move(perigeeMultiStateOnSurface));
   } else {
     return nullptr;
   }
  
   // Reverse the order of the TSOS's after the smoother
   // to make be order flow from inside to out
   std::reverse(smoothedTrajectory.begin(), smoothedTrajectory.end());
  
   // Create Trk::Track
   Trk::TrackInfo info(Trk::TrackInfo::GaussianSumFilter, m_particleHypothesis);
   info.setTrackProperties(TrackInfo::BremFit);
   info.setTrackProperties(TrackInfo::BremFitSuccessful);
   return std::make_unique<Track>(info, convertTrajToTrack(smoothedTrajectory),
                                  std::move(fitQuality));
 }

◆ fit() [3/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const Track &	inputTrack,
		const MeasurementSet &	addSet,
		const RunOutlierRemoval	runOutlier,
		const ParticleHypothesis	matEffects
	)		const

finaloverridevirtual

Refit a track adding a measurement base set.

Interface method Refit a track adding a RIO_OnTrack set.

Implements Trk::ITrackFitter.

Definition at line 269 of file GaussianSumFitter.cxx.

 {
   // Check that the input track has well defined parameters
   if (inputTrack.trackParameters()->empty()) {
     ATH_MSG_FATAL("No estimation of track parameters near origin!");
     return nullptr;
   }
   // Check that the input track has associated MeasurementBase objects
   if (inputTrack.trackStateOnSurfaces()->empty()) {
     ATH_MSG_FATAL(
         "Attempting to fit track to empty MeasurementBase "
         "collection!");
     return nullptr;
   }
   // Retrieve the set of track parameters closest to the reference point
   const Trk::TrackParameters* paramNearestRef = *(std::min_element(
       inputTrack.trackParameters()->begin(),
       inputTrack.trackParameters()->end(), m_trkParametersComparisonFunction));
  
   MeasurementSet measurementSet =
       stripMeasurements(inputTrack, &addSet, m_reintegrateOutliers);
   return fit(ctx, measurementSet, *paramNearestRef, runOutlier, matEffects);
 }

◆ fit() [4/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const Track &	intrk,
		const PrepRawDataSet &	addPrdColl,
		const RunOutlierRemoval	runOutlier,
		const ParticleHypothesis	matEffects
	)		const

finaloverridevirtual

Refit a track adding a PrepRawDataSet.

Interface method Refit a track adding a PrepRawData set.

Implements Trk::ITrackFitter.

Definition at line 240 of file GaussianSumFitter.cxx.

 {
   // Check that the input track has well defined parameters
   if (intrk.trackParameters()->empty()) {
     ATH_MSG_FATAL("No track parameters on Track!");
     return nullptr;
   }
   // Check that the input track has associated MeasurementBase objects
   if (intrk.trackStateOnSurfaces()->empty()) {
     ATH_MSG_FATAL("Empty MeasurementBase ");
     return nullptr;
   }
   // determine the Track Parameter closest to the reference
   const TrackParameters* paramNearestRef = *(std::min_element(
       intrk.trackParameters()->begin(), intrk.trackParameters()->end(),
       m_trkParametersComparisonFunction));
   PrepRawDataSet prepRawDataSet =
       stripPrepRawData(intrk, &addPrdColl, m_reintegrateOutliers);
   return fit(ctx, prepRawDataSet, *paramNearestRef, runOutlier, matEffects);
 }

◆ fit() [5/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const Track &	inputTrack,
		const	RunOutlierRemoval,
		const	ParticleHypothesis
	)		const

finaloverridevirtual

Refit a track.

Interface Method Refitting of an input track.

Extract the measurementBase or PrepRawData and refit.

Implements Trk::ITrackFitter.

Definition at line 200 of file GaussianSumFitter.cxx.

 {
   // Check that the input track has well defined parameters
   if (inputTrack.trackParameters()->empty()) {
     ATH_MSG_FATAL("No track parameters on Track!");
     return nullptr;
   }
   // Check that the input track has associated MeasurementBase objects
   if (inputTrack.trackStateOnSurfaces()->empty()) {
     ATH_MSG_FATAL("Empty MeasurementBase ");
     return nullptr;
   }
   // Retrieve the set of track parameters closest to the reference point
   const Trk::TrackParameters* paramNearestRef =
     *(std::min_element(inputTrack.trackParameters()->begin(),
                        inputTrack.trackParameters()->end(),
                        m_trkParametersComparisonFunction));
  
   // Rrefit using measurement base then
   if (m_refitOnMeasurementBase) {
     MeasurementSet measurementSet =
         stripMeasurements(inputTrack, nullptr, m_reintegrateOutliers);
     return fit(ctx, measurementSet, *paramNearestRef, outlierRemoval,
                particleHypothesis);
   }
   // Refit using PrepRawData level then
   PrepRawDataSet prepRawDataSet =
       stripPrepRawData(inputTrack, nullptr, m_reintegrateOutliers);
   return fit(ctx, prepRawDataSet, *paramNearestRef, outlierRemoval,
              particleHypothesis);
 }

◆ fit() [6/6]

std::unique_ptr< Trk::Track > Trk::GaussianSumFitter::fit	(	const EventContext &	ctx,
		const Track &	intrk1,
		const Track &	intrk2,
		const RunOutlierRemoval	runOutlier,
		const ParticleHypothesis	matEffects
	)		const

finaloverridevirtual

Combine two tracks by refitting their measurements.

@bried Interface method to Combine two tracks by their measurement

Implements Trk::ITrackFitter.

Definition at line 301 of file GaussianSumFitter.cxx.

                                                {
   // protection against not having measurements on the input tracks
   if (!intrk1.trackStateOnSurfaces() || !intrk2.trackStateOnSurfaces() ||
       intrk1.trackStateOnSurfaces()->size() < 2) {
     ATH_MSG_WARNING(
         "called to refit empty track or track with too little "
         "information, reject fit");
     return nullptr;
   }
   if (!intrk1.trackParameters() || intrk1.trackParameters()->empty()) {
     ATH_MSG_WARNING(
         "input #1 fails to provide track parameters for "
         "seeding the GXF, reject fit");
     return nullptr;
   }
   // Here we assume that the reference paramrs are the beginning
   // of the 1st track.
   const TrackParameters* minPar = *(intrk1.trackParameters()->begin());
   MeasurementSet measurementSet1 =
       stripMeasurements(intrk1, nullptr, m_reintegrateOutliers);
   MeasurementSet measurementSet2 =
       stripMeasurements(intrk2, nullptr, m_reintegrateOutliers);
  
   for (const auto* meas : measurementSet2) {
     measurementSet1.push_back(meas);
   }
  
   return fit(ctx, measurementSet1, *minPar, runOutlier, matEffects);
 }

◆ forwardFit()

template<typename T >

GSFTrajectory Trk::GaussianSumFitter::forwardFit	(	const EventContext &	ctx,
		IMultiStateExtrapolator::Cache &	cache,
		const T &	inputSet,
		const TrackParameters &	estimatedTrackParametersNearOrigin
	)		const

private

Forward GSF fit.

◆ initialize()

StatusCode Trk::GaussianSumFitter::initialize ( )

finaloverridevirtual

AlgTool initialise method.

Definition at line 171 of file GaussianSumFitter.cxx.

 {
  
   if (m_maximumNumberOfComponents > GSFConstants::maxNumberofStateComponents) {
     ATH_MSG_FATAL("Requested MaximumNumberOfComponents > "
                   << GSFConstants::maxNumberofStateComponents);
     return StatusCode::FAILURE;
   }
   // GSF extrapolator
   ATH_CHECK(m_extrapolator.retrieve());
   // We need a to create RIO_OnTrack (calibrated/corrected)
   // measurements only if we start from PrePRawData.
   if (!m_refitOnMeasurementBase) {
     ATH_CHECK(m_rioOnTrackCreator.retrieve());
   } else {
     m_rioOnTrackCreator.disable();
   }
   // Initialise the closest track parameters search algorithm
   const Amg::Vector3D referencePosition(0, 0, 0);
   m_trkParametersComparisonFunction = Trk::TrkParametersComparisonFunction(referencePosition);
   m_particleHypothesis = m_extrapolator->particleHypothesis();
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& Trk::ITrackFitter::interfaceID ( )

inlinestaticinherited

Definition at line 45 of file ITrackFitter.h.

   {
     return IID_ITrackFitter;
   }

◆ makePerigee()

GSFTsos Trk::GaussianSumFitter::makePerigee	(	const EventContext &	ctx,
		Trk::IMultiStateExtrapolator::Cache &	extrapolatorCache,
		const GSFTrajectory &	smoothedTrajectory
	)		const

private

Produces a perigee from a smoothed trajectory.

Helper creating a multicomponent perigee TrackStateOnSurface.

Definition at line 515 of file GaussianSumFitter.cxx.

 {
  
   // Start at the end of the smoothed trajectory
   // we should be the closest to perigee/origin.
   const GSFTsos&
     multiComponentStateOnSurfaceNearestOrigin = smoothedTrajectory.back();
   const Trk::MultiComponentState* multiComponentState =
     &(multiComponentStateOnSurfaceNearestOrigin.multiComponentState);
  
   // Extrapolate to perigee
   const Trk::PerigeeSurface perigeeSurface;
   Trk::MultiComponentState stateExtrapolatedToPerigee =
     m_extrapolator->extrapolate(ctx,
                                 extrapolatorCache,
                                 *multiComponentState,
                                 perigeeSurface,
                                 Trk::oppositeMomentum,
                                 false);
  
   if (stateExtrapolatedToPerigee.empty()) {
     return {};
   }
  
   // Determine the combined state
   std::unique_ptr<Trk::TrackParameters> combinedPerigee =
     MultiComponentStateCombiner::combineToSingle(stateExtrapolatedToPerigee, m_useMode);
  
   // Perigee is an additional MultiComponentStateOnSurface
   std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes>
     pattern(0);
   pattern.set(Trk::TrackStateOnSurface::Perigee);
  
   if(std::abs(combinedPerigee->position().z())>5000.) {
     ATH_MSG_WARNING("Pathological perigee well outside of tracking detector!! Returning {}");
     return {};
   }
  
   if (std::abs(combinedPerigee->parameters()[Trk::qOverP]) > 1e8) {
     ATH_MSG_WARNING(
       "makePerigee() about to return with 0 momentum!! Returning {}");
     return {};
   }
  
   return {Trk::FitQualityOnSurface{},
           nullptr,
           std::move(combinedPerigee),
           std::move(stateExtrapolatedToPerigee),
           pattern};
 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ smootherFit()

Trk::GaussianSumFitter::GSFTrajectory Trk::GaussianSumFitter::smootherFit	(	const EventContext &	ctx,
		Trk::IMultiStateExtrapolator::Cache &	extrapolatorCache,
		GSFTrajectory &	forwardTrajectory,
		const CaloCluster_OnTrack *	ccot = `nullptr`
	)		const

private

Gsf smoothed trajectory.

This method can handle additional info like calorimeter cluster constraints. It also produces what we actually store in Trk::Tracks.

Definition at line 585 of file GaussianSumFitter.cxx.

 {
   if (forwardTrajectory.empty()) {
     ATH_MSG_ERROR(
       "Attempting to smooth an empty forward trajectory... Exiting!");
     return {};
   }
  
   GSFTrajectory smoothedTrajectory;
   smoothedTrajectory.reserve(forwardTrajectory.size());
   // For the smoother we start from the end and we go
   // back. We need to find the the first track
   // state on surface  in this reverse direction
   auto trackStateOnSurfaceItr = forwardTrajectory.rbegin();
   bool foundMeasurement = false;
   for (; trackStateOnSurfaceItr != forwardTrajectory.rend(); ++trackStateOnSurfaceItr) {
     if (!(*trackStateOnSurfaceItr).typeFlags.test(TrackStateOnSurface::Measurement)) {
       smoothedTrajectory.emplace_back(std::move(*trackStateOnSurfaceItr));
     } else {
       foundMeasurement = true;
       break;
     }
   }
   if(!foundMeasurement){
     return {};
   }
   // This is the 1st track state on surface for a measurement
   // in the reverse direction. Our starting point for the smoother
   auto smootherPredictionMultiState = std::move(trackStateOnSurfaceItr->multiComponentState);
   // Perform an update with the measurement.
   // This will be the first entry in the trajectory
   std::unique_ptr<Trk::MeasurementBase> firstSmootherMeasurementOnTrack =
       std::move(trackStateOnSurfaceItr->measurementOnTrack);
   if (!firstSmootherMeasurementOnTrack) {
     ATH_MSG_WARNING(
         "Initial state on surface in smoother does not have an associated "
         "MeasurementBase object");
     return {};
   }
   Trk::FitQualityOnSurface fitQuality;
   Trk::MultiComponentState firstSmoothedState =
     Trk::GsfMeasurementUpdator::update(std::move(smootherPredictionMultiState),
                                        *firstSmootherMeasurementOnTrack,
                                        fitQuality);
   if (firstSmoothedState.empty()) {
     return {};
   }
   if (!MultiComponentStateHelpers::allHaveCovariance(firstSmoothedState)) {
     ATH_MSG_WARNING(
       "Not all components have covariance. Rejecting smoothed state.");
     return {};
   }
   // The first in reverse (last in normal order) TSOS is also special
   // for the EDM. Sso we also  a proper collapse
   // of the multi component to single TrackParameter
   std::unique_ptr<Trk::TrackParameters> combinedFirstSmoothedState =
       MultiComponentStateCombiner::combineToSingle(firstSmoothedState,
                                                    m_useMode);
   smoothedTrajectory.emplace_back(
       fitQuality, std::move(firstSmootherMeasurementOnTrack),
       std::move(combinedFirstSmoothedState),
       MultiComponentStateHelpers::clone(firstSmoothedState));
   const auto& updatedFirstStateOnSurface = smoothedTrajectory.back();
   //
   // Now we are ready to proceed
   // Generate a prediction with an inflated covariance of all components
   // in the first smoothed state.
   // This way there is no dependance on error of prediction
   //
   // NB local Y and theta need care due to TRT.
   //
   Trk::MultiComponentState smoothedStateWithScaledError =
       MultiComponentStateHelpers::WithScaledError(
           std::move(firstSmoothedState), m_smootherCovFactors[0],
           m_smootherCovFactors[1], m_smootherCovFactors[2],
           m_smootherCovFactors[3], m_smootherCovFactors[4]);
   // Do the 1st update using the state with inflated covariance.
   Trk::FitQualityOnSurface fitQualityWithScaledErrors;
   Trk::MultiComponentState updatedState = Trk::GsfMeasurementUpdator::update(
     std::move(smoothedStateWithScaledError),
     *(updatedFirstStateOnSurface.measurementOnTrack),
     fitQualityWithScaledErrors);
   if (updatedState.empty()) {
     ATH_MSG_WARNING("Smoother prediction could not be determined");
     return {};
   }
   // loopUpdatedState points to the most recent predicted MultiComponentState.
   Trk::MultiComponentState* loopUpdatedState = &updatedState;
   // Increase reverse iterator by one.
   ++trackStateOnSurfaceItr;
   // The is the last one we will see as we go back.
   auto lasttrackStateOnSurface = forwardTrajectory.rend() - 1;
   // And this is the pre-last
   auto secondLastTrackStateOnSurface = forwardTrajectory.rend() - 2;
   //Loop
   for (; trackStateOnSurfaceItr != forwardTrajectory.rend();++trackStateOnSurfaceItr) {
     auto& trackStateOnSurface = (*trackStateOnSurfaceItr);
     // Retrieve the MeasurementBase object from the TrackStateOnSurface object
     auto measurement = std::move(trackStateOnSurface.measurementOnTrack);
     if (!measurement) {
       ATH_MSG_WARNING("MeasurementBase object could not be extracted from a "
                       "measurement TSOS...continuing");
       continue;
     }
     // Create prediction for the next measurement surface.
     // For the smoother the direction of propagation
     // is opposite to the direction of momentum
     Trk::MultiComponentState extrapolatedState = m_extrapolator->extrapolate(
         ctx, extrapolatorCache, (*loopUpdatedState),
         measurement->associatedSurface(), Trk::oppositeMomentum, false);
  
     if (extrapolatedState.empty()) {
       return {};
     }
     // Handle the case where Original measurement was flagged as an outlier.
     if (!trackStateOnSurface.typeFlags.test(TrackStateOnSurface::Measurement)) {
       std::bitset<TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> type(
           0);
       type.set(TrackStateOnSurface::Outlier);
       smoothedTrajectory.emplace_back(FitQualityOnSurface(1, 1),
                                       std::move(measurement), nullptr,
                                       std::move(extrapolatedState), type);
       loopUpdatedState = &(smoothedTrajectory.back().multiComponentState);
       continue;
     }
     // Update with the measurement
     updatedState = Trk::GsfMeasurementUpdator::update(
         std::move(extrapolatedState), *measurement, fitQuality);
     if (updatedState.empty()) {
       ATH_MSG_WARNING("Could not update the multi-component state");
       return {};
     }
     // last in reverse (first in normal order) is special for the EDM
     const bool islast = (trackStateOnSurfaceItr == lasttrackStateOnSurface);
     if (m_combineWithFitter) {
       // Optional combine smoother state with fitter state
       const Trk::MultiComponentState& forwardsMultiState =
           trackStateOnSurface.multiComponentState;
       Trk::MultiComponentState combinedfitterState =
           Trk::TwoStateCombiner::combine(forwardsMultiState, updatedState,
                                          m_maximumNumberOfComponents);
       if (combinedfitterState.empty()) {
         ATH_MSG_WARNING(
             "Could not combine state from forward fit with "
             "smoother state");
         return {};
       }
       auto combinedFitQuality = Trk::GsfMeasurementUpdator::fitQuality(
           combinedfitterState, *measurement);
       smoothedTrajectory.emplace_back(
           smootherHelper(std::move(combinedfitterState), std::move(measurement),
                          combinedFitQuality, islast, m_useMode));
     } else {
       // If combination with forwards state is not done
       smoothedTrajectory.emplace_back(
           smootherHelper(std::move(updatedState), std::move(measurement),
                          fitQuality, islast, m_useMode));
     }
     // Handle adding measurement from calo if it is present
     if (ccot && trackStateOnSurfaceItr == secondLastTrackStateOnSurface) {
       if (!addCCOT(ctx, ccot, smoothedTrajectory)) {
         ATH_MSG_WARNING("Could not add Calo Cluster On Track Measurement");
         return {};
       }
     }
     // For the next iteration start from last added
     loopUpdatedState = &(smoothedTrajectory.back().multiComponentState);
   }  // End for loop over all components
   return smoothedTrajectory;
 }

◆ stepForwardFit()

template<typename T >

bool Trk::GaussianSumFitter::stepForwardFit	(	const EventContext &	ctx,
		IMultiStateExtrapolator::Cache &	,
		GSFTrajectory &	forwardTrajectory,
		const T *	measurement,
		const Surface &	surface,
		MultiComponentState &	updatedState
	)		const

private

Progress one step along the forward fit.

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ m_combineWithFitter

Gaudi::Property<bool> Trk::GaussianSumFitter::m_combineWithFitter

private

Initial value:

{
     this, "CombineStateWithFitter", false,
     "Combine with forwards state during Smoothing"}

Definition at line 189 of file GaussianSumFitter.h.

◆ m_cutChiSquaredPerNumberDOF

Gaudi::Property<double> Trk::GaussianSumFitter::m_cutChiSquaredPerNumberDOF

private

Initial value:

{

this, "StateChi2PerNDOFCut", 50., "Cut on Chi2 per NDOF"}

Definition at line 202 of file GaussianSumFitter.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extrapolator

ToolHandle<IMultiStateExtrapolator> Trk::GaussianSumFitter::m_extrapolator

private

Initial value:

{

this, "ToolForExtrapolation", "Trk::GsfExtrapolator/GsfExtrapolator", ""}

Definition at line 176 of file GaussianSumFitter.h.

◆ m_maximumNumberOfComponents

Gaudi::Property<unsigned int> Trk::GaussianSumFitter::m_maximumNumberOfComponents

private

Initial value:

{

this, "MaximumNumberOfComponents", 12, "Maximum number of components"}

Definition at line 205 of file GaussianSumFitter.h.

◆ m_particleHypothesis

Trk::ParticleHypothesis Trk::GaussianSumFitter::m_particleHypothesis = Trk::electron

private

Definition at line 216 of file GaussianSumFitter.h.

◆ m_refitOnMeasurementBase

Gaudi::Property<bool> Trk::GaussianSumFitter::m_refitOnMeasurementBase

private

Initial value:

{

this, "RefitOnMeasurementBase", true, "Refit On Measurement Base"}

Definition at line 186 of file GaussianSumFitter.h.

◆ m_reintegrateOutliers

Gaudi::Property<bool> Trk::GaussianSumFitter::m_reintegrateOutliers

private

Initial value:

{this, "ReintegrateOutliers", true,

"Reintegrate Outliers"}

Definition at line 183 of file GaussianSumFitter.h.

◆ m_rioOnTrackCreator

ToolHandle<IRIO_OnTrackCreator> Trk::GaussianSumFitter::m_rioOnTrackCreator

private

Initial value:

{
     this, "ToolForROTCreation", "",
     "Tool for converting Raw Data to measurements"}

Definition at line 179 of file GaussianSumFitter.h.

◆ m_slimTransientMTSOS

Gaudi::Property<bool> Trk::GaussianSumFitter::m_slimTransientMTSOS

private

Initial value:

{
     this, "slimTransientMTSOS", true,
     "Slim the transient MTSOS . Keeping just the combined state and not all "
     "components"}

Definition at line 197 of file GaussianSumFitter.h.

◆ m_smootherCovFactors

DoubleArrayProperty Trk::GaussianSumFitter::m_smootherCovFactors

private

Initial value:

{
     this,
     "smootherStartCovFactors",
     {15., 5., 15., 5., 15.},
     "Inflation factors for the covariance at the start of smoothing [LocX, LocY, phi, "
     "theta, q / p]"}

Definition at line 208 of file GaussianSumFitter.h.

◆ m_trkParametersComparisonFunction

TrkParametersComparisonFunction Trk::GaussianSumFitter::m_trkParametersComparisonFunction

private

Definition at line 215 of file GaussianSumFitter.h.

◆ m_useMode

Gaudi::Property<bool> Trk::GaussianSumFitter::m_useMode

private

Initial value:

{
     this, "useMode", true,
     "Collapse MultiComponent States using Mode rather than Mean"}

Definition at line 193 of file GaussianSumFitter.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ GSFTrajectory

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ GaussianSumFitter()

◆ ~GaussianSumFitter()

Member Function Documentation

◆ addCCOT()

◆ convertTrajToTrack()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fit() [1/6]

◆ fit() [2/6]

◆ fit() [3/6]

◆ fit() [4/6]

◆ fit() [5/6]

◆ fit() [6/6]

◆ forwardFit()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ makePerigee()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ smootherFit()

◆ stepForwardFit()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_combineWithFitter

◆ m_cutChiSquaredPerNumberDOF

◆ m_detStore

◆ m_evtStore

◆ m_extrapolator

◆ m_maximumNumberOfComponents

◆ m_particleHypothesis

◆ m_refitOnMeasurementBase

◆ m_reintegrateOutliers

◆ m_rioOnTrackCreator

◆ m_slimTransientMTSOS

◆ m_smootherCovFactors

◆ m_trkParametersComparisonFunction

◆ m_useMode

◆ m_varHandleArraysDeclared

◆ m_vhka