Trk::iPatGlobalFitter Class Reference

GlobalTrackFitter tool providing methods used during alignment. More...

#include <iPatGlobalFitter.h>

Inheritance diagram for Trk::iPatGlobalFitter:

Collaboration diagram for Trk::iPatGlobalFitter:

Public Types
typedef IMaterialAllocator::Garbage_t	Garbage_t

Public Member Functions
	iPatGlobalFitter (const std::string &type, const std::string &name, const IInterface *parent)
	~iPatGlobalFitter (void)
Track *	alignmentFit (AlignmentCache &, const Track &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis matEffects=Trk::nonInteracting) const
	RE-FIT A TRACK FOR ALIGNMENT. More...
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	RE-FIT A TRACK. More...
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const PrepRawDataSet &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	RE-FIT A TRACK, ADDING A PRD SET. More...
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const PrepRawDataSet &, const TrackParameters &perigeeStartValue, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	FIT A TRACK TO A SET OF PrepRawData. More...
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const MeasurementSet &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	RE-FIT A TRACK, ADDING A FITTABLE MEASUREMENT SET. More...
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const MeasurementSet &, const TrackParameters &perigeeStartValue, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	FIT A TRACK TO A SET OF MEASUREMENTBASE. More...
virtual std::unique_ptr< Track >	fit (const EventContext &ctx, const Track &, const Track &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const override
	COMBINE TWO TRACKS BY REFITTING. 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 > &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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
std::pair< std::unique_ptr< Track >, std::unique_ptr< FitState > >	fitWithState (const EventContext &ctx, const Track &, const RunOutlierRemoval runOutlier=false, const ParticleHypothesis particleHypothesis=Trk::nonInteracting) const
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...

Protected Attributes
std::unique_ptr< FitProcedure >	m_fitProcedure
std::mutex	m_fitProcedureMutex
const bool	m_globalFit = false

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< Amg::MatrixX >	derivMatrix (const FitState &fitState) const
	GlobalTrackFitter methods: access to the matrix of derivatives used during the latest track fit. More...
std::unique_ptr< Amg::MatrixX >	fullCovarianceMatrix (const FitState &fitState) const
	access to the global fitter's full covariance matrix More...
void	setMinIterations (int minIterations)
	set method for the minimum number of iterations for (alignment) friend More...
void	addMeasurements (const EventContext &ctx, std::vector< FitMeasurement * > &measurements, const MeasurementSet &measurementSet, const FitParameters &parameters) const
bool	addMeasurements (const EventContext &ctx, std::vector< FitMeasurement * > &measurements, const FitParameters &parameters, ParticleHypothesis particleHypothesis, const Trk::TrackStates &trackTSOS) const
std::unique_ptr< Track >	performFit (FitState &fitState, const ParticleHypothesis particleHypothesis, const TrackInfo &trackInfo, const Trk::TrackStates *leadingTSOS, const FitQuality *perigeeQuality, Garbage_t &garbage) const
void	printTSOS (const Track &) const
void	refit (const EventContext &ctx, FitState &fitState, const Track &track, const RunOutlierRemoval runOutlier, const ParticleHypothesis particleHypothesis) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static int	iterationsOfLastFit (const FitState &fitState)
	access to the number of iterations taken by the latest track fit More...

Private Attributes
bool	m_allParameters
Gaudi::Property< bool >	m_aggregateMaterial {this, "AggregateMaterial", true}
Gaudi::Property< bool >	m_asymmetricCaloEnergy
Gaudi::Property< bool >	m_fullCombinedFit {this, "FullCombinedFit", true}
Gaudi::Property< bool >	m_lineFit {this, "LineFit", false}
Gaudi::Property< double >	m_lineMomentum
ToolHandle< IMaterialAllocator >	m_materialAllocator
ToolHandle< IIntersector >	m_rungeKuttaIntersector
ToolHandle< IIntersector >	m_solenoidalIntersector
ToolHandle< IPropagator >	m_stepPropagator
ToolHandle< IIntersector >	m_straightLineIntersector
ServiceHandle< ITrackingVolumesSvc >	m_trackingVolumesSvc
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool
Gaudi::Property< double >	m_orderingTolerance
Gaudi::Property< unsigned >	m_maxWarnings
Gaudi::Property< bool >	m_constrainedAlignmentEffects
Gaudi::Property< bool >	m_extendedDebug {this, "ExtendedDebug", false}
Gaudi::Property< int >	m_forcedRefitsForValidation
Gaudi::Property< int >	m_maxIterations {this, "MaxIterations", 25}
std::unique_ptr< Trk::Volume >	m_calorimeterVolume
std::unique_ptr< Trk::Volume >	m_indetVolume
Trk::MagneticFieldProperties	m_stepField
std::atomic< unsigned >	m_countFitAttempts = 0
std::atomic< unsigned >	m_countGoodFits = 0
std::atomic< unsigned >	m_countIterations = 0
std::atomic< unsigned >	m_countRefitAttempts = 0
std::atomic< unsigned >	m_countGoodRefits = 0
std::atomic< unsigned >	m_countRefitIterations = 0
std::unique_ptr< MessageHelper >	m_messageHelper
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

GlobalTrackFitter tool providing methods used during alignment.

Definition at line 26 of file iPatGlobalFitter.h.

Member Typedef Documentation

Garbage_t

typedef IMaterialAllocator::Garbage_t Trk::iPatFitter::Garbage_t

inherited

Definition at line 39 of file iPatFitter.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

iPatGlobalFitter()

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

Definition at line 22 of file iPatGlobalFitter.cxx.

    : iPatFitter(type, name, parent, true), m_allParameters(false) {
  declareInterface<IGlobalTrackFitter>(this);
  declareProperty("AllParameters", m_allParameters);
}

~iPatGlobalFitter()

Trk::iPatGlobalFitter::~iPatGlobalFitter ( void  )

default

Member Function Documentation

addMeasurements() [1/2]

bool Trk::iPatFitter::addMeasurements ( const EventContext &  ctx, std::vector< FitMeasurement * > &  measurements, const FitParameters &  parameters, ParticleHypothesis  particleHypothesis, const Trk::TrackStates &  trackTSOS  ) const

privateinherited

Definition at line 593 of file iPatFitter.cxx.

                                                      {
  // create vector of any TSOS'es which require fitted alignment corrections
  std::vector<Identifier> misAlignedTSOS;
  std::vector<int> misAlignmentNumbers;
  int misAlignmentNumber = 0;
  int tsos = 0;
  //  BUG that shifts ...   misAlignmentNumbers.push_back(misAlignmentNumber);
  for (Trk::TrackStates::const_iterator i = trackStateOnSurfaces.begin();
       i != trackStateOnSurfaces.end(); ++i, ++tsos) {
    const TrackStateOnSurface& r = (**i);
    if (!r.alignmentEffectsOnTrack() || !r.trackParameters()) {
      continue;
    }
    const AlignmentEffectsOnTrack& AEOT = *r.alignmentEffectsOnTrack();
    ++misAlignmentNumber;
    for (const Identifier& a : AEOT.vectorOfAffectedTSOS()) {
      misAlignedTSOS.push_back(a);
      misAlignmentNumbers.push_back(misAlignmentNumber);
    }
    if (m_extendedDebug) {
      ATH_MSG_DEBUG(
          " tsos " << tsos << " misAlignedTSOS.size() " << misAlignedTSOS.size()
                   << "        misAlignmentNumber " << misAlignmentNumber
                   << "  offset " << AEOT.deltaTranslation() << " +- "
                   << AEOT.sigmaDeltaTranslation() << "  rotation "
                   << AEOT.deltaAngle() << " +- " << AEOT.sigmaDeltaAngle());
    }
  }
 
  // create ordered list of FitMeasurements
  bool haveMaterial = false;
  bool haveMeasurement = false;
  int hit = measurements.size();
  double previousDistance = -m_orderingTolerance;
  double previousDistanceR = previousDistance;
  double previousDistanceZ = previousDistance;
  bool reorder = false;
  const bool skipVertexMeasurement = !measurements.empty();
  const Amg::Vector3D startDirection = parameters.direction();
  const Amg::Vector3D& startPosition = parameters.position();
  const TrackSurfaceIntersection& vertex = parameters.intersection();
  TrackSurfaceIntersection intersection = vertex;
  bool measurementsFlipped = false;
  double qOverP = parameters.qOverP();
  const ExtrapolationType type = FittedTrajectory;
  tsos = 0;
  for (Trk::TrackStates::const_iterator i = trackStateOnSurfaces.begin();
       i != trackStateOnSurfaces.end(); ++i, ++hit, ++tsos) {
    const TrackStateOnSurface& s = (**i);
    std::unique_ptr<FitMeasurement> measurement1;
    std::unique_ptr<FitMeasurement> measurement2;
    const Surface* surface = nullptr;
    if (s.materialEffectsOnTrack() && s.trackParameters()) {
      Amg::Vector3D position = s.trackParameters()->position();
      bool calo = (!m_indetVolume->inside(position) &&
                   m_calorimeterVolume->inside(position));
      qOverP = s.trackParameters()->parameters()[Trk::qOverP];
      surface = &s.trackParameters()->associatedSurface();
 
      // skip negligibly thin scatterers (exception for CaloEnergy)
      bool keepScatterer = true;
      if (s.materialEffectsOnTrack()->thicknessInX0() < 0.0001) {
        keepScatterer = false;
        if (calo) {
          const MaterialEffectsOnTrack* meot =
              dynamic_cast<const MaterialEffectsOnTrack*>(
                  s.materialEffectsOnTrack());
          if (meot) {
            const EnergyLoss* energyLoss = meot->energyLoss();
            if (energyLoss &&
                std::abs(energyLoss->deltaE()) > 0.1 * Gaudi::Units::MeV) {
              keepScatterer = true;
            }
          }
        }
      }
      if (keepScatterer) {
        measurement1 = std::make_unique<FitMeasurement>(
            s.materialEffectsOnTrack(),
            Trk::ParticleMasses::mass[particleHypothesis], position, qOverP,
            calo);
        if (!calo && !haveMaterial &&
            (haveMeasurement || s.measurementOnTrack())) {
          haveMaterial = true;
        }
      } else {
        ATH_MSG_DEBUG("don't keep thin scatterer");
        continue;
      }
    } else if (s.alignmentEffectsOnTrack() && s.trackParameters()) {
      Amg::Vector3D direction = s.trackParameters()->momentum().unit();
      Amg::Vector3D position = s.trackParameters()->position();
      measurement1 = std::make_unique<FitMeasurement>(
          s.alignmentEffectsOnTrack(), direction, position);
    }
    const Trk::MeasurementBase* measurementBase = s.measurementOnTrack();
    if (measurementBase) {
      if (!Amg::hasPositiveDiagElems(measurementBase->localCovariance())) {
        continue;
      }
      // option to skip vertex measurement (i.e. when not at front of list)
      if (skipVertexMeasurement &&
          dynamic_cast<const PerigeeSurface*>(&s.surface())) {
        measurement1.reset();
        continue;
      }
      haveMeasurement = true;
      surface = &s.measurementOnTrack()->associatedSurface();
      measurement2 =
          std::make_unique<FitMeasurement>(hit, nullptr, measurementBase);
      if (s.type(TrackStateOnSurface::Outlier)) {
        measurement2->setOutlier();
      }
      // redundant surely??
      // if (measurement2->isCluster() || measurement2->isDrift())
      // haveMeasurement = true;
      //        if (misAlignmentNumber && misAlignedTSOS.back() == *s)
      //        {
      //        measurement2->alignmentParameter(misAlignmentNumber);
      //        misAlignedTSOS.pop_back();
      //        misAlignmentNumbers.pop_back();
      //        misAlignmentNumber  = misAlignmentNumbers.back();
      //        }
      //
      //        Peter
      //        measurement2->alignmentParameter(0);
      if (misAlignmentNumber) {
        Identifier id = Identifier();
        if (measurementBase) {
          const Trk::RIO_OnTrack* rot =
              dynamic_cast<const Trk::RIO_OnTrack*>(measurementBase);
          if (rot) {
            id = rot->identify();
          } else {
            const Muon::CompetingMuonClustersOnTrack* crot =
                dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>(
                    measurementBase);
            if (crot && !crot->containedROTs().empty() &&
                crot->containedROTs().front()) {
              id = crot->containedROTs().front()->identify();
            }
          }
        }
        for (unsigned int im = 0; im < misAlignedTSOS.size(); ++im) {
          if (misAlignedTSOS[im] != id) {
            continue;
          }
          measurement2->alignmentParameter(misAlignmentNumbers[im]);
        }
        if (m_extendedDebug) {
          for (unsigned int im = 0; im < misAlignedTSOS.size(); ++im) {
            if (misAlignedTSOS[im] != id) {
              continue;
            }
            if (measurement2->isDrift()) {
              ATH_MSG_DEBUG(" tsos " << tsos << "   Drift Measurement im " << im
                                     << "  with misAlignmentNumber "
                                     << misAlignmentNumbers[im]);
            } else {
              ATH_MSG_DEBUG(" tsos " << tsos << " Cluster Measurement im " << im
                                     << "  with misAlignmentNumber "
                                     << misAlignmentNumbers[im]);
            }
          }
        }
      }
    } else if (!measurement1 && s.trackParameters()) {
      if (s.type(TrackStateOnSurface::Hole)) {
        measurement2 = std::make_unique<FitMeasurement>(s);
      } else if (s.type(TrackStateOnSurface::Perigee)) {
        if (i == trackStateOnSurfaces.begin()) {
          continue;
        }
        const Perigee* perigee =
            dynamic_cast<const Perigee*>(s.trackParameters());
        if (!perigee) {
          continue;
        }
        measurement2 = std::make_unique<FitMeasurement>(*perigee);
      } else if (s.type(TrackStateOnSurface::Parameter)) {
        continue;
      } else {
        // TSOS type not understood.
        m_messageHelper->printWarning(16, s.dumpType());
        continue;
      }
    } else if (s.materialEffectsOnTrack()) {
      surface = &s.materialEffectsOnTrack()->associatedSurface();
    } else if (s.alignmentEffectsOnTrack()) {
      surface = &s.alignmentEffectsOnTrack()->associatedSurface();
    } else {
      // skip TSOS with missing trackParameters
      // this should never happen (i.e. where's the surface?)
      m_messageHelper->printWarning(17, s.dumpType());
      continue;
    }
 
    // current intersection
    if (s.trackParameters() && (measurement1 || measurement2)) {
      Amg::Vector3D direction = s.trackParameters()->momentum().unit();
      if (startDirection.dot(direction) < 0.) {
        measurementsFlipped = true;
        direction = -direction;
        if (measurement1) {
          measurement1->flipDriftDirection();
        }
        if (measurement2) {
          measurement2->flipDriftDirection();
        }
      }
      qOverP = s.trackParameters()->parameters()[Trk::qOverP];
      intersection = TrackSurfaceIntersection(
          s.trackParameters()->position(), direction, 0.);
    } else if (surface) {
      std::optional<TrackSurfaceIntersection> newIntersection =
          m_stepPropagator->intersectSurface(ctx, *surface, intersection,
                                             qOverP, m_stepField, Trk::muon);
 
      if (!newIntersection) {
        m_messageHelper->printWarning(18);
        measurement2.reset();
        continue;
      }
 
      intersection = std::move(*newIntersection);
      if (s.materialEffectsOnTrack()) {
        const Amg::Vector3D& position = intersection.position();
        bool calo = (!m_indetVolume->inside(position) &&
                     m_calorimeterVolume->inside(position));
        measurement1 = std::make_unique<FitMeasurement>(
            s.materialEffectsOnTrack(),
            Trk::ParticleMasses::mass[particleHypothesis],
            intersection.position(), qOverP, calo);
        if (!calo && !haveMaterial && haveMeasurement) {
          haveMaterial = true;
        }
      } else if (!measurement2) {
        // TSOS skipped
        m_messageHelper->printWarning(19, s.dumpType());
        // delete intersection;
        continue;
      }
    }
 
    // check if ordering OK
    if (!reorder) {
      double distance =
          startDirection.dot(intersection.position() - startPosition);
      Amg::Vector3D positionMst = startPosition;
      if (s.measurementOnTrack()) {
        positionMst = s.measurementOnTrack()->globalPosition();
      }
      if (s.materialEffectsOnTrack()) {
        positionMst = s.materialEffectsOnTrack()->associatedSurface().center();
      }
      double distanceR = std::sqrt((positionMst.x() - startPosition.x()) *
                                       (positionMst.x() - startPosition.x()) +
                                   (positionMst.y() - startPosition.y()) *
                                       (positionMst.y() - startPosition.y()));
      double distanceZ = (positionMst.z() - startPosition.z());
      if (startDirection.z() < 0) {
        distanceZ = -distanceZ;
      }
      if (distance < previousDistance && distanceR < previousDistanceR &&
          distanceZ < previousDistanceZ) {
        reorder = true;
        ATH_MSG_DEBUG(" reorder 3D distance "
                      << distance - previousDistance << " R distance "
                      << distanceR - previousDistanceR << " Z distance "
                      << distanceZ - previousDistanceZ);
      }
      previousDistance = distance - m_orderingTolerance;
      previousDistanceR = distanceR - m_orderingTolerance;
      previousDistanceZ = distanceZ - m_orderingTolerance;
    }
 
    // insert measurement(s) in list
    if (measurement1) {
      if (measurement2) {
        TrackSurfaceIntersection intersectionCopy = intersection;
        measurement1->intersection(type, intersectionCopy);
        measurements.push_back(measurement1.release());
      } else {
        measurement1->intersection(type, intersection);
        measurement1->qOverP(qOverP);
        measurements.push_back(measurement1.release());
      }
    }
    if (measurement2) {
      measurement2->intersection(type, intersection);
      measurement2->qOverP(qOverP);
      measurements.push_back(measurement2.release());
    }
  }
 
  // reorder if necessary
  if (reorder) {
    m_materialAllocator->orderMeasurements(measurements, startDirection,
                                           startPosition);
  }
  if (measurementsFlipped) {
    ATH_MSG_VERBOSE("flipped track measurement order");
  }
 
  // flag whether material has already been allocated
  return haveMaterial;
}
 
std::unique_ptr<Trk::Track> iPatFitter::performFit(
    FitState& fitState, const ParticleHypothesis particleHypothesis,

addMeasurements() [2/2]

void Trk::iPatFitter::addMeasurements ( const EventContext &  ctx, std::vector< FitMeasurement * > &  measurements, const MeasurementSet &  measurementSet, const FitParameters &  parameters  ) const

privateinherited

Definition at line 520 of file iPatFitter.cxx.

                                                                        {
  // extrapolation to set FittedTrajectory
  double qOverP = parameters.qOverP();
  double previousDistance = -m_orderingTolerance;
  double previousDistanceR = previousDistance;
  double previousDistanceZ = previousDistance;
  bool reorder = false;
 
  Amg::Vector3D startDirection = parameters.direction();
  Amg::Vector3D startPosition = parameters.position();
  ExtrapolationType type = FittedTrajectory;
  TrackSurfaceIntersection intersection = parameters.intersection();
 
  TrackSurfaceIntersection startIntersection = intersection ;
  int hit = measurements.size();
  for (MeasurementSet::const_iterator m = measurementSet.begin();
       m != measurementSet.end(); ++m, ++hit) {
    std::optional<TrackSurfaceIntersection> newIntersection{
        m_stepPropagator->intersectSurface(ctx, (**m).associatedSurface(),
                                           startIntersection, qOverP,
                                           m_stepField, Trk::muon)};
    if (newIntersection) {
      intersection = std::move(*newIntersection);
 
      // check if ordering OK
      if (!reorder) {
        double distance =
            startDirection.dot(intersection.position() - startPosition);
        Amg::Vector3D positionMst = (**m).globalPosition();
        double distanceR = std::sqrt((positionMst.x() - startPosition.x()) *
                                         (positionMst.x() - startPosition.x()) +
                                     (positionMst.y() - startPosition.y()) *
                                         (positionMst.y() - startPosition.y()));
        double distanceZ = (positionMst.z() - startPosition.z());
        if (startDirection.z() < 0) {
          distanceZ = -distanceZ;
        }
        if (distance < previousDistance && distanceR < previousDistanceR &&
            distanceZ < previousDistanceZ) {
          reorder = true;
          ATH_MSG_DEBUG(" reorder 3D distance "
                        << distance - previousDistance << " R distance "
                        << distanceR - previousDistanceR << " Z distance "
                        << distanceZ - previousDistanceZ);
        }
        previousDistance = distance - m_orderingTolerance;
        previousDistanceR = distanceR - m_orderingTolerance;
        previousDistanceZ = distanceZ - m_orderingTolerance;
      }
    } else {
      // FIXME
      // no intersection to MeasurementSet
      m_messageHelper->printWarning(15);
      continue;
    }
    auto measurement = std::make_unique<FitMeasurement>(hit, nullptr, *m);
    measurement->intersection(type, intersection);
    measurement->qOverP(qOverP);
    measurements.push_back(measurement.release());
    // remember the last intersection for the next loop iteration
    startIntersection = (measurements.back()->intersection(type));
  }
 
  // reorder if necessary
  if (reorder) {
    m_materialAllocator->orderMeasurements(measurements, startDirection,
                                           startPosition);
  }
}
 
bool iPatFitter::addMeasurements(
    const EventContext& ctx, std::vector<FitMeasurement*>& measurements,

alignmentFit()

Track * Trk::iPatGlobalFitter::alignmentFit ( AlignmentCache &  , const Track &  , const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

virtual

RE-FIT A TRACK FOR ALIGNMENT.

Since it is not our but the fitter model's decision if to re-fit on PRD or ROT level, it is made pure virtual.

Implements Trk::IGlobalTrackFitter.

Definition at line 32 of file iPatGlobalFitter.cxx.

                                               {
  //  @TODO ensure the number of iterations is passed through to the fitter
  // setMinIterations (alignCache.m_minIterations);
  if (alignCache.m_derivMatrix != nullptr) {
    delete alignCache.m_derivMatrix;
  }
  alignCache.m_derivMatrix = nullptr;
 
  if (alignCache.m_fullCovarianceMatrix != nullptr) {
    delete alignCache.m_fullCovarianceMatrix;
  }
  alignCache.m_fullCovarianceMatrix = nullptr;
  alignCache.m_iterationsOfLastFit = 0;
 
  auto [refittedTrack, fitState] =
      fitWithState(Gaudi::Hive::currentContext(), trk, runOutlier, matEffects);
 
  if (refittedTrack) {
    alignCache.m_derivMatrix = derivMatrix(*fitState).release();
    alignCache.m_fullCovarianceMatrix =
        fullCovarianceMatrix(*fitState).release();
    alignCache.m_iterationsOfLastFit = iterationsOfLastFit(*fitState);
  }
  return refittedTrack.release();
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

derivMatrix()

std::unique_ptr< Amg::MatrixX > Trk::iPatGlobalFitter::derivMatrix ( const FitState &  fitState ) const

private

GlobalTrackFitter methods: access to the matrix of derivatives used during the latest track fit.

Definition at line 61 of file iPatGlobalFitter.cxx.

                                    {
  // copy derivatives to a new HepMatrix
  if (!fitState.hasMeasurements() || !fitState.parameters) {
    return nullptr;
  }
 
  int numberParameters = 5;
  if (m_allParameters) {
    numberParameters = fitState.parameters->numberParameters();
  }
  int rows = 0;
 
  for (const FitMeasurement* m : fitState.getMeasurements()) {
    if (!m->isPositionMeasurement()) {
      continue;
    }
    rows += m->numberDoF();
  }
 
  if (!numberParameters || !rows) {
    return nullptr;
  }
 
  ATH_MSG_VERBOSE(" DerivMatrix : " << fitState.getMeasurements().size()
                                    << " measurement objects giving " << rows
                                    << " rows and " << numberParameters
                                    << " columns (parameters)");
 
  auto derivativeMatrix =
      std::make_unique<Amg::MatrixX>(rows, numberParameters);
  int row = 0;
  for (const FitMeasurement* m : fitState.getMeasurements()) {
    if (!m->numberDoF() || !m->isPositionMeasurement()) {
      continue;
    }
    double norm = 0.;
    if (m->weight() > 0.) {
      norm = 1. / m->weight();
    }
 
    for (int col = 0; col < numberParameters; ++col) {
      (*derivativeMatrix)(row, col) = norm * m->derivative(col);
    }
 
    // take care of units for momentum derivs
    (*derivativeMatrix)(row, 4) *= Gaudi::Units::TeV;
    if (fitState.parameters->fitEnergyDeposit()) {
      (*derivativeMatrix)(row, 5) *= Gaudi::Units::TeV;
    }
    ++row;
    if (m->numberDoF() < 2) {
      continue;
    }
 
    // pixel measurements
    norm = 0.;
    if (m->weight2() > 0.)
      norm = 1. / m->weight2();
    for (int col = 0; col < numberParameters; ++col) {
      (*derivativeMatrix)(row, col) = norm * m->derivative2(col);
    }
    (*derivativeMatrix)(row, 4) *= Gaudi::Units::TeV;
    if (fitState.parameters->fitEnergyDeposit()) {
      (*derivativeMatrix)(row, 5) *= Gaudi::Units::TeV;
    }
    ++row;
  }
 
  if (row != rows) {
    ATH_MSG_WARNING("iPatGlobalFitter: inconsistent #rows in deriv matrix ");
  }
 
  return derivativeMatrix;
}

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

{ 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.

{ 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

finalize()

StatusCode Trk::iPatFitter::finalize ( )

overridevirtualinherited

Definition at line 135 of file iPatFitter.cxx.

                          {
    goodFit = static_cast<double>(100 * m_countGoodFits) / fits;
    if (m_countGoodFits) {
      iterations = static_cast<double>(m_countIterations) /
                   static_cast<double>(m_countGoodFits);
    }
    ATH_MSG_INFO(std::setiosflags(std::ios::fixed)
                 << "finalized after " << m_countFitAttempts
                 << " track-fits attempted, out of which " << std::setw(5)
                 << std::setprecision(1) << goodFit
                 << "% converged, taking an average " << std::setw(5)
                 << std::setprecision(2) << iterations << " iterations");
  }
  if (m_forcedRefitsForValidation) {
    double refits = static_cast<double>(m_countRefitAttempts);
    double goodRefit = 0.;
    double refitIterations = 0.;
    if (m_countRefitAttempts) {
      goodRefit = static_cast<double>(100 * m_countGoodRefits) / refits;
    }
    if (m_countGoodRefits) {
      refitIterations = static_cast<double>(m_countRefitIterations) /
                        static_cast<double>(m_countGoodRefits);
    }
    ATH_MSG_INFO(std::setiosflags(std::ios::fixed)
                 << "finalized after " << m_countRefitAttempts
                 << "     refits attempted, out of which " << std::setw(5)
                 << std::setprecision(1) << goodRefit
                 << "% converged, taking an average " << std::setw(5)
                 << std::setprecision(2) << refitIterations << " iterations");
  }
 
  m_messageHelper->printSummary();
 
  return StatusCode::SUCCESS;
}
 
auto iPatFitter::fitWithState(const EventContext& ctx, const Track& track,
                              const RunOutlierRemoval runOutlier,

fit() [1/6]

std::unique_ptr< Trk::Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const MeasurementSet &  measSet, const TrackParameters &  params, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

FIT A TRACK TO A SET OF MEASUREMENTBASE.

Main fit method. The TrackParameters is a first estimate for the track, represented close to the origin.

Implements Trk::ITrackFitter.

Definition at line 346 of file iPatFitter.cxx.

                                                       {
  ATH_MSG_VERBOSE(" fit from measurement set + perigeeStartValue ");
  m_countFitAttempts++;
  // outlier removal not implemented
  if (runOutlier) {
    m_messageHelper->printWarning(9);
  }
 
  const Perigee* perigee = dynamic_cast<const Perigee*>(&perigeeStartValue);
  if (!perigee) {
    // track without Perigee start value
    m_messageHelper->printWarning(10);
    return nullptr;
  }
 
  FitState fitState;
  fitState.parameters = std::make_unique<FitParameters>(*perigee);
 
  // set up the measurements (and material)
  fitState.newMeasurements();
  addMeasurements(ctx, fitState.getMeasurements(), measurementSet,
                  *fitState.parameters);
  Garbage_t garbage;
  if (particleHypothesis != Trk::nonInteracting) {
    m_materialAllocator->allocateMaterial(
        fitState.getMeasurements(), particleHypothesis, *fitState.parameters,
        perigeeStartValue, garbage);
  }
 
  // perform fit and return fitted track
  TrackInfo trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  return performFit(fitState, particleHypothesis, trackInfo, nullptr, nullptr,
                    garbage);
}
 
std::unique_ptr<Track> iPatFitter::fit(
    const EventContext& ctx, const Track& indetTrack,

fit() [2/6]

std::unique_ptr< Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const PrepRawDataSet &  prepRawSet, const TrackParameters &  params, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

FIT A TRACK TO A SET OF PrepRawData.

Main fit method. The TrackParameters is a first estimate for the track, represented close to the origin. Use-cases can be thought of that make it necessary to control toggling outlier removal and material effects not via job options (once-per-job) but at each call (toggle within event, large set of fast fit followed by one final full fit).

Implements Trk::ITrackFitter.

Definition at line 283 of file iPatFitter.cxx.

                                      {
  m_countFitAttempts++;
  // PrepRawDataSet interface not implemented
  m_messageHelper->printWarning(4);
  return nullptr;
}
 
std::unique_ptr<Track> iPatFitter::fit(
    const EventContext& ctx, const Track& track,

fit() [3/6]

std::unique_ptr< Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const Track &  track, const MeasurementSet &  measSet, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

RE-FIT A TRACK, ADDING A FITTABLE MEASUREMENT SET.

this method will use the vector of measurements from the existing track and refit adding the new measurements. The code is in this class, but can be overwritten by inheriting classes.

Implements Trk::ITrackFitter.

Definition at line 294 of file iPatFitter.cxx.

                                                       {
  ATH_MSG_VERBOSE(" track + measurementSet fit ");
  m_countFitAttempts++;
  // outlier removal not implemented
  if (runOutlier) {
    m_messageHelper->printWarning(5);
  }
 
  // create starting parameters
  if (!track.trackStateOnSurfaces()) {
    // track without trackStateOnSurfaces
    m_messageHelper->printWarning(6);
    return nullptr;
  }
  const Perigee* perigee = dynamic_cast<const Perigee*>(
      (**track.trackStateOnSurfaces()->begin()).trackParameters());
  if (!perigee) {
    // track without measuredPerigee
    m_messageHelper->printWarning(7);
    return nullptr;
  }
 
  FitState fitState;
  fitState.parameters = std::make_unique<FitParameters>(*perigee);
 
  // set up the measurements (and material)
  fitState.newMeasurements();
  if (addMeasurements(ctx, fitState.getMeasurements(), *fitState.parameters,
                      particleHypothesis, *track.trackStateOnSurfaces()))
    m_messageHelper->printWarning(8);  // FIX needed: material may
                                       // get double counted
  addMeasurements(ctx, fitState.getMeasurements(), measurementSet,
                  *fitState.parameters);
  Garbage_t garbage;
  if (particleHypothesis != Trk::nonInteracting) {
    const TrackParameters& endParams =
        *(track.trackStateOnSurfaces()->back()->trackParameters());
    m_materialAllocator->allocateMaterial(
        fitState.getMeasurements(), particleHypothesis, *fitState.parameters,
        endParams, garbage);
  }
 
  // perform fit and return fitted track
  TrackInfo trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  trackInfo.addPatternReco(track.info());
  return performFit(fitState, particleHypothesis, trackInfo,
                    track.trackStateOnSurfaces(), track.fitQuality(), garbage);
}
 
std::unique_ptr<Trk::Track> iPatFitter::fit(
    const EventContext& ctx, const MeasurementSet& measurementSet,

fit() [4/6]

std::unique_ptr< Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const Track &  track, const PrepRawDataSet &  prepRawSet, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

RE-FIT A TRACK, ADDING A PRD SET.

this method will disintegrate the track back to PRD and call the fit(PRDset) method.

Implements Trk::ITrackFitter.

Definition at line 272 of file iPatFitter.cxx.

                                      {
  m_countFitAttempts++;
  // track + PrepRawDataSet interface not implemented
  m_messageHelper->printWarning(3);
  return nullptr;
}
 
std::unique_ptr<Track> iPatFitter::fit(
    const EventContext&, const PrepRawDataSet& /*prepRawDataSet*/,

fit() [5/6]

std::unique_ptr< Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const Track &  track, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

RE-FIT A TRACK.

Implements Trk::ITrackFitter.

Definition at line 262 of file iPatFitter.cxx.

                                                       {
  auto [fittedTrack, fitState] =
      fitWithState(ctx, track, runOutlier, particleHypothesis);
  // cppcheck-suppress returnStdMoveLocal; clang requires the move() here.
  return std::move(fittedTrack);
}
 
std::unique_ptr<Track> iPatFitter::fit(
    const EventContext&, const Track& /*track*/,

fit() [6/6]

std::unique_ptr< Track > Trk::iPatFitter::fit ( const EventContext &  ctx, const Track &  track1, const Track &  track2, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  matEffects = Trk::nonInteracting  ) const

overridevirtualinherited

COMBINE TWO TRACKS BY REFITTING.

Specifically designed for combined muon fits, allowing to extract extra informations (ID-exit & MS-entrance parameters, layers, Mefos) from already fitted tracks.

Implements Trk::ITrackFitter.

Definition at line 385 of file iPatFitter.cxx.

                                                       {
  ATH_MSG_VERBOSE(" combined muon fit ");
  m_countFitAttempts++;
  // outlier removal not implemented
  if (runOutlier) {
    m_messageHelper->printWarning(11);
  }
 
  // indet (full refit to measurements or use measured perigee)
  bool haveMaterial = true;
  FitState fitState;
  fitState.newMeasurements();
  if (indetTrack.perigeeParameters()) {
    fitState.parameters =
        std::make_unique<FitParameters>(*indetTrack.perigeeParameters());
  } else if (spectrometerTrack.perigeeParameters() &&
             m_indetVolume->inside(spectrometerTrack.perigeeParameters()
                                       ->associatedSurface()
                                       .center())) {
    fitState.parameters =
        std::make_unique<FitParameters>(*spectrometerTrack.perigeeParameters());
  } else {
    // combined muon fit without Perigee start value"
    m_messageHelper->printWarning(12);
    return nullptr;
  }
 
  // get both perigee parameters, use most precise for momentum starting value
  const Perigee* indetPerigee =
      dynamic_cast<const Perigee*>(indetTrack.perigeeParameters());
  const Perigee* spectrometerPerigee =
      dynamic_cast<const Perigee*>(spectrometerTrack.perigeeParameters());
  if (spectrometerPerigee &&
      !m_indetVolume->inside(
          spectrometerPerigee->associatedSurface().center())) {
    spectrometerPerigee = nullptr;
  }
  if (!spectrometerTrack.info().trackProperties(
          Trk::TrackInfo::StraightTrack) &&
      spectrometerPerigee) {
    if (indetTrack.info().trackProperties(Trk::TrackInfo::StraightTrack) ||
        !indetPerigee || !indetPerigee->covariance()) {
      fitState.parameters->qOverP(
          spectrometerPerigee->parameters()[Trk::qOverP]);
      ATH_MSG_VERBOSE(" set starting momentum from spectrometer "
                      << 1. /
                             (fitState.parameters->qOverP() * Gaudi::Units::GeV)
                      << " GeV");
    } else if (indetPerigee) {
      if (spectrometerPerigee->covariance() &&
          (*spectrometerPerigee->covariance())(Trk::qOverP, Trk::qOverP) <
              (*indetPerigee->covariance())(Trk::qOverP, Trk::qOverP)) {
        fitState.parameters->qOverP(
            spectrometerPerigee->parameters()[Trk::qOverP]);
        ATH_MSG_VERBOSE(
            " set starting momentum from spectrometer "
            << 1. / (fitState.parameters->qOverP() * Gaudi::Units::GeV)
            << " GeV");
      }
    }
  }
 
  if (m_fullCombinedFit) {
    // set up the measurements
    if (!indetTrack.trackStateOnSurfaces()) {
      // fail as indet track without trackStateOnSurfaces
      m_messageHelper->printWarning(13);
      return nullptr;
    }
    if (!addMeasurements(ctx, fitState.getMeasurements(), *fitState.parameters,
                         particleHypothesis,
                         *indetTrack.trackStateOnSurfaces())) {
      haveMaterial = false;
    }
  }
 
  // add the spectrometer measurements
  if (!addMeasurements(ctx, fitState.getMeasurements(), *fitState.parameters,
                       particleHypothesis,
                       *spectrometerTrack.trackStateOnSurfaces())) {
    haveMaterial = false;
  }
  Garbage_t garbage;
  if (!haveMaterial && particleHypothesis != Trk::nonInteracting) {
    Perigee* startingPerigee = fitState.parameters->startingPerigee();
    if (startingPerigee) {
      m_materialAllocator->allocateMaterial(
          fitState.getMeasurements(), particleHypothesis, *fitState.parameters,
          *startingPerigee, garbage);
      delete startingPerigee;
    }
  }
 
  // create starting parameters, perform fit and return fitted track
  TrackInfo trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  trackInfo.addPatternReco(indetTrack.info());
  trackInfo.addPatternReco(spectrometerTrack.info());
  if (m_fullCombinedFit) {
    std::unique_ptr<Trk::Track> fittedTrack = performFit(
        fitState, particleHypothesis, trackInfo, nullptr, nullptr, garbage);
 
    // validation
    for (int i = 0; i < m_forcedRefitsForValidation; ++i) {
      if (fittedTrack) {
        refit(ctx, fitState, *fittedTrack, runOutlier, particleHypothesis);
      }
    }
 
    return fittedTrack;
  }  // hybrid fit
  if (!indetPerigee) {
    // fail combined muon fit as indet track without measuredPerigee
    m_messageHelper->printWarning(14);
    return nullptr;
  }
  fitState.getMeasurements().insert(fitState.getMeasurements().begin(),
                                    new FitMeasurement(*indetPerigee));
  FitParameters measuredParameters(*indetPerigee);
  std::unique_ptr<Trk::Track> fittedTrack = performFit(
      fitState, particleHypothesis, trackInfo,
      indetTrack.trackStateOnSurfaces(), indetTrack.fitQuality(), garbage);
 
  // validation
  for (int i = 0; i < m_forcedRefitsForValidation; ++i) {
    if (fittedTrack) {
      refit(ctx, fitState, *fittedTrack, runOutlier, particleHypothesis);
    }
  }
 
  return fittedTrack;
}
 
void iPatFitter::addMeasurements(const EventContext& ctx,
                                 std::vector<FitMeasurement*>& measurements,

fitWithState()

auto Trk::iPatFitter::fitWithState ( const EventContext &  ctx, const Track &  track, const RunOutlierRemoval  runOutlier = false, const ParticleHypothesis  particleHypothesis = Trk::nonInteracting  ) const

protectedinherited

Definition at line 179 of file iPatFitter.cxx.

                                                              {
  ATH_MSG_VERBOSE(" track fit ");
  auto fitState = std::make_unique<FitState>();
 
  m_countFitAttempts++;
  // outlier removal not implemented
  if (runOutlier) {
    m_messageHelper->printWarning(0);
  }  // TODO Make thread-safe
 
  // create Perigee if starting parameters are for a different surface type
  const Perigee* perigeeParameters = track.perigeeParameters();
  // Note: we don't own the Perigee from perigeeParameters(), but if it returns
  // nullptr, we have to make our own, and we need to delete it, so it's put in
  // this unique_ptr
  std::unique_ptr<Perigee> newPerigee;
  std::unique_ptr<PerigeeSurface> perigeeSurface;
 
  if (!perigeeParameters) {
    auto i = track.trackStateOnSurfaces()->begin();
    while (i != track.trackStateOnSurfaces()->end() &&
           !(**i).trackParameters()) {
      i++;
    }
    const TrackStateOnSurface& s = (**i);
    if (!s.trackParameters()) {
      // input track without parameters
      m_messageHelper->printWarning(1);
      return {nullptr, std::move(fitState)};
    }
 
    Amg::Vector3D origin(s.trackParameters()->position());
    perigeeSurface = std::make_unique<PerigeeSurface>(origin);
    newPerigee = std::make_unique<Perigee>(
        s.trackParameters()->position(), s.trackParameters()->momentum(),
        s.trackParameters()->charge(), *perigeeSurface);
  }
 
  const Perigee& perigee =
      newPerigee ? *newPerigee : *perigeeParameters;  // Use the valid Perigee
 
  fitState->parameters = std::make_unique<FitParameters>(perigee);
 
  // set up the measurements
  if (!track.trackStateOnSurfaces()) {
    // input track without trackStateOnSurfaces
    m_messageHelper->printWarning(2);  // TODO Make thread-safe
    return {nullptr, std::move(fitState)};
  }
 
  fitState->newMeasurements();
 
  bool haveMaterial =
      addMeasurements(ctx, fitState->getMeasurements(), *fitState->parameters,
                      particleHypothesis, *track.trackStateOnSurfaces());
 
  // allocate material
  Garbage_t garbage;
  if (!haveMaterial && particleHypothesis != Trk::nonInteracting) {
    m_materialAllocator->allocateMaterial(
        fitState->getMeasurements(), particleHypothesis, *fitState->parameters,
        perigee, garbage);
  }
 
  // perform fit and return fitted track
  TrackInfo trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  trackInfo.addPatternReco(track.info());
  std::unique_ptr<Trk::Track> fittedTrack{performFit(
      *fitState, particleHypothesis, trackInfo, nullptr, nullptr, garbage)};
 
  // validation
  for (int i = 0; i < m_forcedRefitsForValidation; ++i) {
    if (fittedTrack) {
      refit(ctx, *fitState, *fittedTrack, runOutlier, particleHypothesis);
    }
  }
 
  return {std::move(fittedTrack), std::move(fitState)};
}
 
std::unique_ptr<Track> iPatFitter::fit(
    const EventContext& ctx, const Track& track,

fullCovarianceMatrix()

std::unique_ptr< Amg::MatrixX > Trk::iPatGlobalFitter::fullCovarianceMatrix ( const FitState &  fitState ) const

private

access to the global fitter's full covariance matrix

Definition at line 137 of file iPatGlobalFitter.cxx.

                                    {
  int numberParameters = 5;
 
  if (m_allParameters) {
    numberParameters = fitState.parameters->numberParameters();
  }
  ATH_MSG_VERBOSE(" FullCovarianceMatrix for " << numberParameters
                                               << " parameters");
 
  return std::make_unique<Amg::MatrixX>(m_fitProcedure->fullCovariance()->block(
      0, 0, numberParameters, numberParameters));
}

initialize()

StatusCode Trk::iPatFitter::initialize ( )

overridevirtualinherited

Definition at line 49 of file iPatFitter.cxx.

                                          : outlier removal not implemented");
  m_messageHelper->setMessage(1, "fit (Track): track without perigee");
  m_messageHelper->setMessage(
      2, "fit (Track): track without trackStateOnSurfaces");
  m_messageHelper->setMessage(
      3, "fit (Track + PrepRawDataSet): interface not implemented");
  m_messageHelper->setMessage(
      4, "fit (PrepRawDataSet): interface not implemented");
  m_messageHelper->setMessage(
      5, "fit (Track + MeasurementSet): outlier removal not implemented");
  m_messageHelper->setMessage(
      6, "fit (Track + MeasurementSet): track without trackStateOnSurfaces");
  m_messageHelper->setMessage(
      7, "fit (Track + MeasurementSet): track without measuredPerigee");
  m_messageHelper->setMessage(
      8, "fit (Track + MeasurementSet): FIX material may get double counted");
  m_messageHelper->setMessage(
      9, "fit (Perigee + MeasurementSet): outlier removal not implemented");
  m_messageHelper->setMessage(10,
                              "fit (Perigee + MeasurementSet): null perigee");
  m_messageHelper->setMessage(
      11, "fit (combined muon): outlier removal not implemented");
  m_messageHelper->setMessage(12,
                              "fit (combined muon): no perigee start value");
  m_messageHelper->setMessage(
      13, "fit (combined muon): indet track without trackStateOnSurfaces");
  m_messageHelper->setMessage(
      14, "fit (combined muon): indet track without measuredPerigee");
  m_messageHelper->setMessage(
      15, "addMeasurements: no intersection to MeasurementSet");
  m_messageHelper->setMessage(
      16, "addMeasurements: skip TSOS as not understood. Type: ");
  m_messageHelper->setMessage(
      17, "addMeasurements: skip TSOS with missing trackParameters. Type: ");
  m_messageHelper->setMessage(
      18,
      "addMeasurements: skip measurement as fail to intersect associated "
      "surface from given starting parameters");
  m_messageHelper->setMessage(19, "addMeasurements: TSOS skipped. Type: ");
  m_messageHelper->setMessage(20,
                              "fail fit as CaloDeposit outside calo volume");
  m_messageHelper->setMessage(
      21, "conflicting energy deposit sign for inDet material");
  m_messageHelper->setMessage(
      22, "conflicting energy deposit sign for spectrometer material");
  m_messageHelper->setMessage(23, "excessive calorimeter energy loss : ");
  m_messageHelper->setMessage(24, "excessive spectrometer energy loss : ");
  m_messageHelper->setMessage(25, "flipped track measurement order");
 
  ATH_CHECK(m_materialAllocator.retrieve());
  ATH_CHECK(m_rungeKuttaIntersector.retrieve());
  ATH_CHECK(m_solenoidalIntersector.retrieve());
  ATH_CHECK(m_stepPropagator.retrieve());
  ATH_CHECK(m_straightLineIntersector.retrieve());
 
  // need to create the IndetExit and MuonEntrance TrackingVolumes
  if (m_trackingVolumesSvc.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve Svc " << m_trackingVolumesSvc);
    return StatusCode::FAILURE;
  }
  m_calorimeterVolume =
      std::make_unique<Trk::Volume>(m_trackingVolumesSvc->volume(
          ITrackingVolumesSvc::MuonSpectrometerEntryLayer));
  m_indetVolume = std::make_unique<Volume>(
      m_trackingVolumesSvc->volume(ITrackingVolumesSvc::CalorimeterEntryLayer));
 
  ATH_CHECK(m_trackSummaryTool.retrieve());
 
  // can now create FitProcedure class
  m_fitProcedure = std::make_unique<FitProcedure>(
      m_constrainedAlignmentEffects, m_extendedDebug, m_lineFit,
      m_rungeKuttaIntersector, m_solenoidalIntersector,
      m_straightLineIntersector, m_stepPropagator, m_indetVolume.get(),
      m_maxIterations,
      1);  // useStepPropagator
  // useStepPropagator 0 means not used (so Intersector used)
  // 1 Intersector not used and StepPropagator used with FullField
  // 2 StepPropagator with FastField propagation
  // 99 debug mode where both are ran with FullField
  return StatusCode::SUCCESS;
}
 
StatusCode iPatFitter::finalize() {
  // print summary statistics

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

iterationsOfLastFit()

int Trk::iPatGlobalFitter::iterationsOfLastFit ( const FitState &  fitState )

staticprivate

access to the number of iterations taken by the latest track fit

Definition at line 151 of file iPatGlobalFitter.cxx.

                                                                  {
  return fitState.iterations;
}

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.

performFit()

std::unique_ptr< Trk::Track > Trk::iPatFitter::performFit ( FitState &  fitState, const ParticleHypothesis  particleHypothesis, const TrackInfo &  trackInfo, const Trk::TrackStates *  leadingTSOS, const FitQuality *  perigeeQuality, Garbage_t &  garbage  ) const

privateinherited

std::scoped_lock lock(m_fitProcedureMutex);

Definition at line 904 of file iPatFitter.cxx.

                                                                {
  std::vector<FitMeasurement*>& measurements = fitState.getMeasurements();
  FitParameters* parameters = fitState.parameters.get();
  // initialize the scattering centres
  m_materialAllocator->initializeScattering(measurements);
 
  // set fixed momentum in lineFit case according to configuration
  if (m_lineFit) {
    parameters->fitMomentum(false);
    if (m_lineMomentum > 0.) {
      parameters->qOverP(1. / m_lineMomentum);
    }
  }
 
  // perform fit
  MsgStream log(msgSvc(), name());
  Trk::FitProcedure::Cache cache(m_fitProcedure->constrainedAlignmentEffects());
 
  // This lock should no be needed , leaving it for now
  //  until we are sure all function pass thread safety
  //  requirements
 
  const FitProcedureQuality& quality =
      m_fitProcedure->execute(cache, m_asymmetricCaloEnergy, log, measurements,
                              parameters, perigeeQuality);
  std::unique_ptr<Track> fittedTrack;
  if (!quality.fitCode()) {
    // include leading material
    m_materialAllocator->addLeadingMaterial(measurements, particleHypothesis,
                                            *parameters, garbage);
 
    // construct the fitted track
    fittedTrack.reset(m_fitProcedure->constructTrack(
        cache, measurements, *parameters, trackInfo, leadingTSOS));
    if (fittedTrack) {
      // set StraightLine when momentum unfitted
      if (!parameters->fitMomentum()) {
        fittedTrack->info().setTrackProperties(TrackInfo::StraightTrack);
      }
 
      // special check for CaloDeposit - parameters must be inside calorimeter
      for (const Trk::TrackStateOnSurface* tsos :
           *fittedTrack->trackStateOnSurfaces()) {
        if (!tsos->type(TrackStateOnSurface::CaloDeposit)) {
          continue;
        }
        if (tsos->trackParameters()) {
          const Amg::Vector3D position = tsos->trackParameters()->position();
          if (!m_indetVolume->inside(position) &&
              m_calorimeterVolume->inside(position)) {
            break;
          }
        }
        // something badly wrong: WARN and kill track
        // fail fit as CaloDeposit outside calo volume
        ATH_MSG_DEBUG(
            "fail fit as CaloDeposit outside calo volume: " << (*fittedTrack));
        fittedTrack.reset();
        break;
      }
    }
 
    // statistics for successful fit
    if (fittedTrack) {
      ++m_countGoodFits;
      m_countIterations += quality.iterations();
      fitState.iterations = quality.iterations();
 
      // report material
      if (msgLvl(MSG::DEBUG)) {
        int calo = 0;
        double caloX0 = 0.;
        double caloEloss = 0.;
        int indet = 0;
        double indetX0 = 0.;
        double indetEloss = 0.;
        int spect = 0;
        double spectX0 = 0.;
        double spectEloss = 0.;
        for (FitMeasurement* m : measurements) {
          if (m->isEnergyDeposit()) {
            calo++;
            caloEloss += m->energyLoss();
          } else if (!m->isScatterer()) {
            continue;
          }
 
          if (m_indetVolume->inside(m->position())) {
            indet++;
            indetX0 += m->materialEffects()->thicknessInX0();
            indetEloss += m->energyLoss();
            // conflicting energy deposit sign for inDet material
            if (m->energyLoss() * indetEloss < 0.) {
              m_messageHelper->printWarning(21);
            }
            continue;
          }
          if (m_calorimeterVolume->inside(
                  m->intersection(FittedTrajectory).position())) {
            calo++;
            caloX0 += m->materialEffects()->thicknessInX0();
            continue;
          }
 
          spect++;
          spectX0 += m->materialEffects()->thicknessInX0();
          spectEloss += m->energyLoss();
          // conflicting energy deposit sign for spectrometer material
          if (m->energyLoss() * spectEloss < 0.) {
            m_messageHelper->printWarning(22);
          }
        }
 
        // WARN in case of bug #56297
        if (calo) {
          // excessive calorimeter energy loss
          if (std::abs(caloEloss) > 200. * Gaudi::Units::GeV &&
              m_messageHelper->wouldPrintWarning(23)) {
            std::stringstream ss;
            ss << caloEloss / Gaudi::Units::GeV << " for track with P "
               << fittedTrack->perigeeParameters()->momentum().mag() /
                      Gaudi::Units::GeV
               << " GeV";
            m_messageHelper->printWarning(23, ss.str());
          }
 
          // excessive spectrometer energy loss
          if ((std::abs(spectEloss) > (0.5 * Gaudi::Units::GeV)) &&
              (std::abs(spectEloss * caloX0) >
               std::abs(4. * caloEloss * spectX0)) &&
              m_messageHelper->wouldPrintWarning(24)) {
            std::stringstream ss;
            ss << spectEloss / Gaudi::Units::GeV << " ( "
               << caloEloss / Gaudi::Units::GeV
               << " calorimeter energy loss). Track has P "
               << fittedTrack->perigeeParameters()->momentum().mag() /
                      Gaudi::Units::GeV
               << " GeV";
            m_messageHelper->printWarning(24, ss.str());
          }
        }
 
        msg(MSG::VERBOSE) << std::setiosflags(std::ios::fixed);
        if (indet) {
          msg() << std::setw(5) << indet << " indet scatterers with"
                << " material: X0" << std::setw(6) << std::setprecision(3)
                << indetX0;
          if (calo && caloEloss < 0.) {
            msg() << "  energyGain";
          } else {
            msg() << "  energyLoss";
          }
          msg() << std::setw(6) << std::setprecision(3)
                << indetEloss / Gaudi::Units::GeV << ",";
        }
 
        if (spect) {
          msg() << std::setw(5) << spect << " spectrometer scatterers with"
                << " material: X0" << std::setw(8) << std::setprecision(3)
                << spectX0;
          if (calo && caloEloss < 0.) {
            msg() << "  energyGain";
          } else {
            msg() << "  energyLoss";
          }
          msg() << std::setw(7) << std::setprecision(3)
                << spectEloss / Gaudi::Units::GeV;
        }
 
        if (!indet && !spect) {
          msg() << "    0 scatterers - no tracking material";
        }
        msg() << endmsg;
      }
    }
  }
 
  // generate a track summary for this candidate
  if ((m_trackSummaryTool.isEnabled()) && (fittedTrack != nullptr)) {
    m_trackSummaryTool->computeAndReplaceTrackSummary(*fittedTrack, false);
  }
 
  return fittedTrack;
}
 
void iPatFitter::printTSOS(const Track& track) const {
  // debugging aid

printTSOS()

void Trk::iPatFitter::printTSOS ( const Track &  track ) const

privateinherited

Definition at line 1093 of file iPatFitter.cxx.

                                                              {
    msg() << std::setiosflags(std::ios::fixed | std::ios::right) << " TSOS# "
          << std::setw(3) << tsos << "   parameters:   " << std::setw(7)
          << std::setprecision(1) << (**t).trackParameters()->position().perp()
          << std::setw(8) << std::setprecision(4)
          << (**t).trackParameters()->position().phi() << std::setw(9)
          << std::setprecision(1) << (**t).trackParameters()->position().z()
          << " position  " << std::setw(8) << std::setprecision(4)
          << (**t).trackParameters()->momentum().phi() << " phi  "
          << std::setw(7) << std::setprecision(4)
          << (**t).trackParameters()->momentum().theta() << " theta  "
          << std::setw(9) << std::setprecision(4)
          << (**t).trackParameters()->momentum().mag() / Gaudi::Units::GeV
          << " GeV";
 
    if ((**t).measurementOnTrack()) {
      msg() << "  meas ";
    } else {
      msg() << "       ";
    }
    if ((**t).materialEffectsOnTrack()) {
      msg() << "  scat ";
    } else {
      msg() << "       ";
    }
    msg() << (**t).dumpType() << endmsg;
  }
}
 
void iPatFitter::refit(const EventContext& ctx, FitState& fitState,
                       const Track& track, const RunOutlierRemoval runOutlier,

refit()

void Trk::iPatFitter::refit ( const EventContext &  ctx, FitState &  fitState, const Track &  track, const RunOutlierRemoval  runOutlier, const ParticleHypothesis  particleHypothesis  ) const

privateinherited

Definition at line 1131 of file iPatFitter.cxx.

                  {
    m_messageHelper->printWarning(0);
  }
 
  // create Perigee if starting parameters are for a different surface type
  const Perigee* perigeeParameters = track.perigeeParameters();
  // Note: we don't own the Perigee from perigeeParameters(), but if it returns
  // nullptr, we have to make our own, and we need to delete it, so it's put in
  // this unique_ptr
  std::unique_ptr<Perigee> newPerigee;
  std::unique_ptr<PerigeeSurface> perigeeSurface;
 
  if (!perigeeParameters) {
    auto i = track.trackStateOnSurfaces()->begin();
    while (i != track.trackStateOnSurfaces()->end() &&
           !(**i).trackParameters()) {
      i++;
    }
    const TrackStateOnSurface& s = (**i);
    if (!s.trackParameters()) {
      // input track without parameters
      m_messageHelper->printWarning(1);
      m_countGoodRefits += m_countGoodFits - countGoodFits;
      m_countGoodFits = countGoodFits;
      m_countRefitIterations += m_countIterations - countIterations;
      m_countIterations = countIterations;
      return;
    }
 
    Amg::Vector3D origin(s.trackParameters()->position());
    perigeeSurface = std::make_unique<PerigeeSurface>(origin);
    newPerigee = std::make_unique<Perigee>(
        s.trackParameters()->position(), s.trackParameters()->momentum(),
        s.trackParameters()->charge(), *perigeeSurface);
  }
 
  const Perigee& perigee =
      newPerigee ? *newPerigee : *perigeeParameters;  // Use the valid Perigee
 
  fitState.parameters = std::make_unique<FitParameters>(perigee);
 
  // set up the measurements
  if (!track.trackStateOnSurfaces()) {
    // input track without trackStateOnSurfaces
    m_messageHelper->printWarning(2);
    m_countGoodRefits += m_countGoodFits - countGoodFits;
    m_countGoodFits = countGoodFits;
    m_countRefitIterations += m_countIterations - countIterations;
    m_countIterations = countIterations;
    return;
  }
 
  fitState.newMeasurements();
 
  bool haveMaterial =
      addMeasurements(ctx, fitState.getMeasurements(), *fitState.parameters,
                      particleHypothesis, *track.trackStateOnSurfaces());
 
  // allocate material
  Garbage_t garbage;
  if (!haveMaterial && particleHypothesis != Trk::nonInteracting) {
    m_materialAllocator->allocateMaterial(
        fitState.getMeasurements(), particleHypothesis, *fitState.parameters,
        perigee, garbage);
  }
 
  // perform fit and return fitted track
  TrackInfo trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  trackInfo.addPatternReco(track.info());
  std::unique_ptr<Trk::Track> fittedTrack{performFit(
      fitState, particleHypothesis, trackInfo, nullptr, nullptr, garbage)};
 
  m_countGoodRefits += m_countGoodFits - countGoodFits;
  m_countGoodFits = countGoodFits;
  m_countRefitIterations += m_countIterations - countIterations;
  m_countIterations = countIterations;
}
}  // namespace Trk

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

setMinIterations()

void Trk::iPatGlobalFitter::setMinIterations ( int  minIterations )

private

set method for the minimum number of iterations for (alignment) friend

Definition at line 155 of file iPatGlobalFitter.cxx.

                                                         {
  m_fitProcedure->setMinIterations(minIterations);
}

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_aggregateMaterial

Gaudi::Property<bool> Trk::iPatFitter::m_aggregateMaterial {this, "AggregateMaterial", true}

privateinherited

Definition at line 183 of file iPatFitter.h.

m_allParameters

bool Trk::iPatGlobalFitter::m_allParameters

private

Definition at line 52 of file iPatGlobalFitter.h.

m_asymmetricCaloEnergy

Gaudi::Property<bool> Trk::iPatFitter::m_asymmetricCaloEnergy

privateinherited

Initial value:

{this, "AsymmetricCaloEnergy",
                                               true}

Definition at line 184 of file iPatFitter.h.

m_calorimeterVolume

std::unique_ptr<Trk::Volume> Trk::iPatFitter::m_calorimeterVolume

privateinherited

Definition at line 225 of file iPatFitter.h.

m_constrainedAlignmentEffects

Gaudi::Property<bool> Trk::iPatFitter::m_constrainedAlignmentEffects

privateinherited

Initial value:

{
      this, "ConstrainedAlignmentEffects", false}

Definition at line 217 of file iPatFitter.h.

m_countFitAttempts

std::atomic<unsigned> Trk::iPatFitter::m_countFitAttempts = 0

mutableprivateinherited

Definition at line 230 of file iPatFitter.h.

m_countGoodFits

std::atomic<unsigned> Trk::iPatFitter::m_countGoodFits = 0

mutableprivateinherited

Definition at line 231 of file iPatFitter.h.

m_countGoodRefits

std::atomic<unsigned> Trk::iPatFitter::m_countGoodRefits = 0

mutableprivateinherited

Definition at line 234 of file iPatFitter.h.

m_countIterations

std::atomic<unsigned> Trk::iPatFitter::m_countIterations = 0

mutableprivateinherited

Definition at line 232 of file iPatFitter.h.

m_countRefitAttempts

std::atomic<unsigned> Trk::iPatFitter::m_countRefitAttempts = 0

mutableprivateinherited

Definition at line 233 of file iPatFitter.h.

m_countRefitIterations

std::atomic<unsigned> Trk::iPatFitter::m_countRefitIterations = 0

mutableprivateinherited

Definition at line 235 of file iPatFitter.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_extendedDebug

Gaudi::Property<bool> Trk::iPatFitter::m_extendedDebug {this, "ExtendedDebug", false}

privateinherited

Definition at line 219 of file iPatFitter.h.

m_fitProcedure

std::unique_ptr<FitProcedure> Trk::iPatFitter::m_fitProcedure

protectedinherited

Definition at line 148 of file iPatFitter.h.

m_fitProcedureMutex

std::mutex Trk::iPatFitter::m_fitProcedureMutex

mutableprotectedinherited

Definition at line 149 of file iPatFitter.h.

m_forcedRefitsForValidation

Gaudi::Property<int> Trk::iPatFitter::m_forcedRefitsForValidation

privateinherited

Initial value:

{
      this, "ForcedRefitsForValidation", 0}

Definition at line 220 of file iPatFitter.h.

m_fullCombinedFit

Gaudi::Property<bool> Trk::iPatFitter::m_fullCombinedFit {this, "FullCombinedFit", true}

privateinherited

Definition at line 186 of file iPatFitter.h.

m_globalFit

const bool Trk::iPatFitter::m_globalFit = false

protectedinherited

Definition at line 152 of file iPatFitter.h.

m_indetVolume

std::unique_ptr<Trk::Volume> Trk::iPatFitter::m_indetVolume

privateinherited

Definition at line 226 of file iPatFitter.h.

m_lineFit

Gaudi::Property<bool> Trk::iPatFitter::m_lineFit {this, "LineFit", false}

privateinherited

Definition at line 187 of file iPatFitter.h.

m_lineMomentum

Gaudi::Property<double> Trk::iPatFitter::m_lineMomentum

privateinherited

Initial value:

{this, "LineMomentum",
                                         100. * Gaudi::Units::GeV}

Definition at line 188 of file iPatFitter.h.

m_materialAllocator

ToolHandle<IMaterialAllocator> Trk::iPatFitter::m_materialAllocator

privateinherited

Initial value:

{
      this, "MaterialAllocator", "Trk::MaterialAllocator/MaterialAllocator"}

Definition at line 191 of file iPatFitter.h.

m_maxIterations

Gaudi::Property<int> Trk::iPatFitter::m_maxIterations {this, "MaxIterations", 25}

privateinherited

Definition at line 222 of file iPatFitter.h.

m_maxWarnings

Gaudi::Property<unsigned> Trk::iPatFitter::m_maxWarnings

privateinherited

Initial value:

{
      this, "MaxNumberOfWarnings", 10,
      "Maximum number of permitted WARNING messages per message type."}

Definition at line 212 of file iPatFitter.h.

m_messageHelper

std::unique_ptr<MessageHelper> Trk::iPatFitter::m_messageHelper

privateinherited

Definition at line 238 of file iPatFitter.h.

m_orderingTolerance

Gaudi::Property<double> Trk::iPatFitter::m_orderingTolerance

privateinherited

Initial value:

{this, "OrderingTolerance",
                                              1. * Gaudi::Units::mm}

Definition at line 210 of file iPatFitter.h.

m_rungeKuttaIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_rungeKuttaIntersector

privateinherited

Initial value:

{
      this, "RungeKuttaIntersector",
      "Trk::RungeKuttaIntersector/RungeKuttaIntersector"}

Definition at line 193 of file iPatFitter.h.

m_solenoidalIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_solenoidalIntersector

privateinherited

Initial value:

{
      this, "SolenoidalIntersector",
      "Trk::SolenoidalIntersector/SolenoidalIntersector"}

Definition at line 196 of file iPatFitter.h.

m_stepField

Trk::MagneticFieldProperties Trk::iPatFitter::m_stepField

privateinherited

Definition at line 227 of file iPatFitter.h.

m_stepPropagator

ToolHandle<IPropagator> Trk::iPatFitter::m_stepPropagator

privateinherited

Initial value:

{
      this, "Propagator", "Trk::STEP_Propagator/AtlasSTEP_Propagator"}

Definition at line 199 of file iPatFitter.h.

m_straightLineIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_straightLineIntersector

privateinherited

Initial value:

{
      this, "StraightLineIntersector",
      "Trk::StraightLineIntersector/StraightLineIntersector"}

Definition at line 201 of file iPatFitter.h.

m_trackingVolumesSvc

ServiceHandle<ITrackingVolumesSvc> Trk::iPatFitter::m_trackingVolumesSvc

privateinherited

Initial value:

{
      this, "TrackingVolumesSvc", "TrackingVolumesSvc/TrackingVolumesSvc"}

Definition at line 204 of file iPatFitter.h.

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> Trk::iPatFitter::m_trackSummaryTool

privateinherited

Initial value:

{
      this, "TrackSummaryTool", "MuonTrackSummaryTool"}

Definition at line 206 of file iPatFitter.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:

• iPatGlobalFitter.h
• iPatGlobalFitter.cxx