Trk::GaussianSumFitter Class Reference

#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.
virtual	~GaussianSumFitter ()=default
	Virtual destructor.
virtual StatusCode	initialize () override final
	AlgTool initialise method.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () 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.
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.
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const RunOutlierRemoval, const ParticleHypothesis) const override final
	Refit a track.
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.
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.
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.

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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>
Helper methods
std::unique_ptr< MultiComponentStateOnSurfaceDV >	convertTrajToTrack (GSFTrajectory &trajectory) const
	Helper to convert the GSFTrajectory to a Trk::Track.
GSFTsos	makePerigee (const EventContext &ctx, Trk::IMultiStateExtrapolator::Cache &, const GSFTrajectory &smoothedTrajectory) const
	Produces a perigee from a smoothed trajectory.
bool	addCCOT (const EventContext &ctx, const Trk::CaloCluster_OnTrack *ccot, GSFTrajectory &smoothedTrajectory) const
	Methof to add the CaloCluster onto the track.
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.
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.
GSFTrajectory	smootherFit (const EventContext &ctx, Trk::IMultiStateExtrapolator::Cache &, GSFTrajectory &forwardTrajectory, const CaloCluster_OnTrack *ccot=nullptr) const
	Gsf smoothed trajectory.

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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()

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());
 
  }

declareProperty()

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.

{ return m_detStore; }

evtStore()

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.

{ 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 outlierRemoval, const ParticleHypothesis 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()

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

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

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

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.

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

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.

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

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.

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

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.

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

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.

                                          {this, "ReintegrateOutliers", true,
                                             "Reintegrate Outliers"};

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.

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

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.

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

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.

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

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.

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

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:

• GaussianSumFitter.h
• GaussianSumFitter.cxx