Trk::iPatFitter Class Reference

Main Fitter tool providing the implementation for the different fitting, extension and refitting use cases. More...

#include <iPatFitter.h>

Inheritance diagram for Trk::iPatFitter:

Collaboration diagram for Trk::iPatFitter:

Classes
class	FitState

Public Types
typedef IMaterialAllocator::Garbage_t	Garbage_t

Public Member Functions
	iPatFitter (const std::string &type, const std::string &name, const IInterface *parent, bool isGlobalFit=false)
virtual	~iPatFitter ()=default
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.
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.
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.
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.
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.
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.
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

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

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
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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Main Fitter tool providing the implementation for the different fitting, extension and refitting use cases.

Definition at line 37 of file iPatFitter.h.

Member Typedef Documentation

Garbage_t

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

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

iPatFitter()

Trk::iPatFitter::iPatFitter	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent,
		bool	isGlobalFit = false )

Definition at line 37 of file iPatFitter.cxx.

    : AthAlgTool(type, name, parent),
      m_globalFit(globalFit),
      m_stepField(Trk::MagneticFieldProperties(Trk::FullField)) {
  m_messageHelper = std::make_unique<MessageHelper>(*this, 26);
  declareInterface<ITrackFitter>(this);
}

~iPatFitter()

virtual Trk::iPatFitter::~iPatFitter ( )

virtualdefault

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

private

Definition at line 590 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()) {
      const Amg::Vector3D position = s.trackParameters()->position();
      bool const 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()) {
      const Amg::Vector3D direction = s.trackParameters()->momentum().unit();
      const 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 const 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) {
      const 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();
      }
      const 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;
}

addMeasurements() [2/2]

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

private

Definition at line 517 of file iPatFitter.cxx.

                                                                        {
  // extrapolation to set FittedTrajectory
  const 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();
  const 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) {
        const double distance =
            startDirection.dot(intersection.position() - startPosition);
        Amg::Vector3D positionMst = (**m).globalPosition();
        const 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);
  }
}

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

finalize()

StatusCode Trk::iPatFitter::finalize ( )

overridevirtual

Definition at line 132 of file iPatFitter.cxx.

                                {
  // print summary statistics
  const double fits = static_cast<double>(m_countFitAttempts);
  double goodFit = 0.;
  double iterations = 0.;
 
  //avoid printing for 0 fit attempts
  if (m_countFitAttempts) {
    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) {
    const 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;
}

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

overridevirtual

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 343 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 const trackInfo(TrackInfo::iPatTrackFitter, particleHypothesis);
  return performFit(fitState, particleHypothesis, trackInfo, nullptr, nullptr,
                    garbage);
}

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

overridevirtual

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 280 of file iPatFitter.cxx.

                                      {
  m_countFitAttempts++;
  // PrepRawDataSet interface not implemented
  m_messageHelper->printWarning(4);
  return nullptr;
}

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

overridevirtual

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

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

overridevirtual

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 269 of file iPatFitter.cxx.

                                      {
  m_countFitAttempts++;
  // track + PrepRawDataSet interface not implemented
  m_messageHelper->printWarning(3);
  return nullptr;
}

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

overridevirtual

RE-FIT A TRACK.

Implements Trk::ITrackFitter.

Definition at line 259 of file iPatFitter.cxx.

                                                       {
  auto [fittedTrack, fitState] =
      fitWithState(ctx, track, runOutlier, particleHypothesis);
  // cppcheck-suppress returnStdMoveLocal; clang requires the move() here.
  return std::move(fittedTrack);
}

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

overridevirtual

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

fitWithState()

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

protected

Definition at line 176 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)};
    }
 
    const 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 const 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)};
}

initialize()

StatusCode Trk::iPatFitter::initialize ( )

overridevirtual

Definition at line 46 of file iPatFitter.cxx.

                                  {
  // fill WARNING messages
  m_messageHelper->setMaxNumberOfMessagesPrinted(m_maxWarnings);
  m_messageHelper->setMessage(0,
                              "fit (Track): 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;
}

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

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.

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

private

std::scoped_lock lock(m_fitProcedureMutex);

Definition at line 901 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(Trk::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;
}

printTSOS()

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

private

Definition at line 1090 of file iPatFitter.cxx.

                                                   {
  // debugging aid
  MsgStream log(msgSvc(), name());
 
  msg(MSG::INFO) << " track with " << track.trackStateOnSurfaces()->size()
                 << " TSOS " << endmsg;
  int tsos = 0;
  for (Trk::TrackStates::const_iterator t =
           track.trackStateOnSurfaces()->begin();
       t != track.trackStateOnSurfaces()->end(); ++t, ++tsos) {
    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;
  }
}

refit()

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

private

Definition at line 1128 of file iPatFitter.cxx.

                                                                          {
  ATH_MSG_VERBOSE(" refit ");
  const unsigned countGoodFits = m_countGoodFits;
  const unsigned countIterations = m_countIterations;
  m_countRefitAttempts++;
  // outlier removal not implemented
  if (runOutlier) {
    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;
    }
 
    const 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 const 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());
  const 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;
}

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

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_aggregateMaterial

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

private

Definition at line 183 of file iPatFitter.h.

{this, "AggregateMaterial", true};

m_asymmetricCaloEnergy

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

private

Initial value:

{this, "AsymmetricCaloEnergy",
                                               true}

Definition at line 184 of file iPatFitter.h.

                                            {this, "AsymmetricCaloEnergy",
                                               true};

m_calorimeterVolume

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

private

Definition at line 225 of file iPatFitter.h.

m_constrainedAlignmentEffects

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

private

Initial value:

{
      this, "ConstrainedAlignmentEffects", false}

Definition at line 217 of file iPatFitter.h.

                                                   {
      this, "ConstrainedAlignmentEffects", false};

m_countFitAttempts

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

mutableprivate

Definition at line 230 of file iPatFitter.h.

m_countGoodFits

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

mutableprivate

Definition at line 231 of file iPatFitter.h.

m_countGoodRefits

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

mutableprivate

Definition at line 234 of file iPatFitter.h.

m_countIterations

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

mutableprivate

Definition at line 232 of file iPatFitter.h.

m_countRefitAttempts

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

mutableprivate

Definition at line 233 of file iPatFitter.h.

m_countRefitIterations

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

mutableprivate

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}

private

Definition at line 219 of file iPatFitter.h.

{this, "ExtendedDebug", false};

m_fitProcedure

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

protected

Definition at line 148 of file iPatFitter.h.

m_fitProcedureMutex

std::mutex Trk::iPatFitter::m_fitProcedureMutex

mutableprotected

Definition at line 149 of file iPatFitter.h.

m_forcedRefitsForValidation

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

private

Initial value:

{
      this, "ForcedRefitsForValidation", 0}

Definition at line 220 of file iPatFitter.h.

                                                {
      this, "ForcedRefitsForValidation", 0};

m_fullCombinedFit

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

private

Definition at line 186 of file iPatFitter.h.

{this, "FullCombinedFit", true};

m_globalFit

const bool Trk::iPatFitter::m_globalFit = false

protected

Definition at line 152 of file iPatFitter.h.

m_indetVolume

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

private

Definition at line 226 of file iPatFitter.h.

m_lineFit

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

private

Definition at line 187 of file iPatFitter.h.

{this, "LineFit", false};

m_lineMomentum

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

private

Initial value:

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

Definition at line 188 of file iPatFitter.h.

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

m_materialAllocator

ToolHandle<IMaterialAllocator> Trk::iPatFitter::m_materialAllocator

private

Initial value:

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

Definition at line 191 of file iPatFitter.h.

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

m_maxIterations

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

private

Definition at line 222 of file iPatFitter.h.

{this, "MaxIterations", 25};

m_maxWarnings

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

private

Initial value:

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

Definition at line 212 of file iPatFitter.h.

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

m_messageHelper

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

private

Definition at line 238 of file iPatFitter.h.

m_orderingTolerance

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

private

Initial value:

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

Definition at line 210 of file iPatFitter.h.

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

m_rungeKuttaIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_rungeKuttaIntersector

private

Initial value:

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

Definition at line 193 of file iPatFitter.h.

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

m_solenoidalIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_solenoidalIntersector

private

Initial value:

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

Definition at line 196 of file iPatFitter.h.

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

m_stepField

Trk::MagneticFieldProperties Trk::iPatFitter::m_stepField

private

Definition at line 227 of file iPatFitter.h.

m_stepPropagator

ToolHandle<IPropagator> Trk::iPatFitter::m_stepPropagator

private

Initial value:

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

Definition at line 199 of file iPatFitter.h.

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

m_straightLineIntersector

ToolHandle<IIntersector> Trk::iPatFitter::m_straightLineIntersector

private

Initial value:

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

Definition at line 201 of file iPatFitter.h.

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

m_trackingVolumesSvc

ServiceHandle<ITrackingVolumesSvc> Trk::iPatFitter::m_trackingVolumesSvc

private

Initial value:

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

Definition at line 204 of file iPatFitter.h.

                                                         {
      this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"};

m_trackSummaryTool

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

private

Initial value:

{
      this, "TrackSummaryTool", "MuonTrackSummaryTool"}

Definition at line 206 of file iPatFitter.h.

                                                             {
      this, "TrackSummaryTool", "MuonTrackSummaryTool"};

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:

• iPatFitter.h
• iPatFitter.cxx