ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
Rec::CombinedMuonTrackFitter Class Reference

#include <CombinedMuonTrackFitter.h>

Inheritance diagram for Rec::CombinedMuonTrackFitter:
Collaboration diagram for Rec::CombinedMuonTrackFitter:

Public Member Functions

 CombinedMuonTrackFitter (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~CombinedMuonTrackFitter ()
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual std::unique_ptr< Trk::Track > fit (const EventContext &ctx, const Trk::Track &track, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const override
 
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 ()
 AlgTool and IAlgTool interface methods. More...
 

Protected Member Functions

std::unique_ptr< Trk::Track > fit (const EventContext &ctx, const Trk::MeasurementSet &measurementSet, const Trk::TrackParameters &perigeeStartValue, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const
 fit a set of MeasurementBase objects with starting value for perigeeParameters More...
 
std::unique_ptr< Trk::Track > fit (const EventContext &ctx, const Trk::Track &indetTrack, Trk::Track &extrapolatedTrack, const Trk::RunOutlierRemoval runOutlier, const Trk::ParticleHypothesis particleHypothesis) const
 combined muon fit More...
 
double normalizedChi2 (const Trk::Track &track) const
 
bool checkTrack (std::string_view txt, const Trk::Track *newTrack) const
 
unsigned int countAEOTs (const Trk::Track &track, const std::string &txt) const
 
bool loadMagneticField (const EventContext &ctx, MagField::AtlasFieldCache &field_cache) 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

ToolHandle< Rec::IMuidCaloTrackStateOnSurface > m_caloTSOS
 
ToolHandle< Muon::IMuonErrorOptimisationTool > m_muonErrorOptimizer
 
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
 
ToolHandle< Rec::IMuonTrackQuery > m_trackQuery
 
ToolHandle< Trk::ITrackSummaryTool > m_trackSummary
 
ToolHandle< Trk::ITrkMaterialProviderTool > m_materialUpdator
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
Gaudi::Property< double > m_badFitChi2 {this, "BadFitChi2", 2.5}
 
Gaudi::Property< double > m_zECToroid {this, "zECToroid", 10. * Gaudi::Units::meter}
 
Gaudi::Property< bool > m_updateWithCaloTG {this, "UpdateWithCaloTG", false}
 
Gaudi::Property< bool > m_useCaloTG {this, "UseCaloTG", false}
 
std::unique_ptr< const Trk::Volume > m_indetVolume {nullptr}
 
std::unique_ptr< const Trk::Volume > m_calorimeterVolume {nullptr}
 
std::unique_ptr< MessageHelper > m_messageHelper {std::make_unique<MessageHelper>(*this, 50)}
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

bool optimizeErrors (const EventContext &ctx, Trk::Track &track) 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...
 

Private Attributes

ToolHandle< Muon::IMuonTrackCleaner > m_cleaner
 
ToolHandle< Trk::ITrackFitter > m_fitter
 
ToolHandle< Trk::ITrackFitter > m_fitterSL
 
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
 
ServiceHandle< Trk::ITrackingVolumesSvc > m_trackingVolumesSvc {this, "TrackingVolumesSvc", "TrackingVolumesSvc/TrackingVolumesSvc"}
 
Gaudi::Property< bool > m_allowCleanerVeto {this, "AllowCleanerVeto", true}
 
Gaudi::Property< unsigned > m_maxWarnings
 
std::atomic_uint m_countCombinedCleanerVeto {0}
 
std::atomic_uint m_countExtensionCleanerVeto {0}
 
std::atomic_uint m_countStandaloneCleanerVeto {0}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 43 of file CombinedMuonTrackFitter.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CombinedMuonTrackFitter()

Rec::CombinedMuonTrackFitter::CombinedMuonTrackFitter ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 49 of file CombinedMuonTrackFitter.cxx.

49  :
50  AthAlgTool(type, name, parent) {
51  declareInterface<ICombinedMuonTrackFitter>(this);
52 
53 
54  }

◆ ~CombinedMuonTrackFitter()

Rec::CombinedMuonTrackFitter::~CombinedMuonTrackFitter ( )
virtualdefault

Member Function Documentation

◆ checkTrack()

bool Rec::CombinedMuonTrackFitter::checkTrack ( std::string_view  txt,
const Trk::Track *  newTrack 
) const
protected

Check that the combined track contains enough MS measurements

Definition at line 603 of file CombinedMuonTrackFitter.cxx.

603  {
604  if (!newTrack) return false;
605 
606  const DataVector<const Trk::TrackParameters>* pars = newTrack->trackParameters();
607  if (!pars || pars->empty() || !newTrack->fitQuality()) { return false; }
608  DataVector<const Trk::TrackParameters>::const_iterator it = pars->end() -1;
609 
610  if ((*it)->position().dot((*it)->momentum()) < 0) {
611  return false;
612  ATH_MSG_DEBUG(txt <<" "<< __FILE__<<":"<<__LINE__<< " ALARM position " << (*it)->position() << " direction " << (*it)->momentum().unit());
613  } else {
614  ATH_MSG_DEBUG(txt <<" "<< __FILE__<<":"<<__LINE__<< " OK position " << (*it)->position() << " direction " << (*it)->momentum().unit());
615  }
616 
617  for (const Trk::TrackParameters* par : *pars) {
618  if (!par->covariance()) { continue; }
619  if (!Amg::hasPositiveDiagElems(*par->covariance())) {
620  ATH_MSG_DEBUG(txt<<" "<<__FILE__<<":"<<__LINE__<< "covariance matrix has negative diagonal element, killing track "
621  <<std::endl<<Amg::toString(*par->covariance()));
622  return false;
623  }
624  }
625  unsigned int numberMS{0}, numberMSPrec{0};
627  Trk::TrackStates::const_reverse_iterator r = newTrack->trackStateOnSurfaces()->rbegin();
628  Trk::TrackStates::const_reverse_iterator rEnd = newTrack->trackStateOnSurfaces()->rend();
629  for (; r != rEnd; ++r) {
630  const Trk::TrackStateOnSurface* tsos{*r};
631  if (tsos->trackParameters() && m_calorimeterVolume->inside(tsos->trackParameters()->position())) break;
632 
633  if (tsos->measurementOnTrack()) {
634  ++numberMS;
635  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(tsos->measurementOnTrack());
636  numberMSPrec+= rot && !m_idHelperSvc->measuresPhi(rot->identify());
637  }
638  }
639 
640  ATH_MSG_VERBOSE( txt<< " "<<__FILE__<<":"<<__LINE__<<" "<< numberMS << "/"<< numberMSPrec<< " fitted MS measurements ");
641  // reject with insufficient MS measurements
642  if (numberMS < 5 || numberMSPrec < 3) {
643  return false;
644  }
645 
646  return true;
647  }

◆ countAEOTs()

unsigned int Rec::CombinedMuonTrackFitter::countAEOTs ( const Trk::Track &  track,
const std::string &  txt 
) const
protected

Definition at line 649 of file CombinedMuonTrackFitter.cxx.

649  {
650  const Trk::TrackStates* trackTSOS = track.trackStateOnSurfaces();
651  unsigned int naeots = 0;
652 
653  if (!trackTSOS){
654  ATH_MSG_ERROR("No trackStateOnSurfaces");
655  return naeots;
656  }
657 
658  for (const auto* m : *trackTSOS) {
659  if (m && m->alignmentEffectsOnTrack()) naeots++;
660  }
661 
662  ATH_MSG_DEBUG(" count AEOTs " << txt << " " << naeots);
663 
664  // add VEBOSE for checking TSOS order
665 
666 
667  int tsos{0}, nperigee{0};
668  for ( const Trk::TrackStateOnSurface* it : *trackTSOS) {
669  tsos++;
670 
671  if (it->type(Trk::TrackStateOnSurface::Perigee)) {
672  ATH_MSG_DEBUG("perigee");
673  nperigee++;
674  }
675 
676  if (it->trackParameters()) {
677  ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS tp "
678  << " r " << it->trackParameters()->position().perp() << " z "
679  << it->trackParameters()->position().z() << " momentum "
680  << it->trackParameters()->momentum().mag());
681  } else if (it->measurementOnTrack()) {
682  ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS mst "
683  << " r " << it->measurementOnTrack()->associatedSurface().center().perp() << " z "
684  << it->measurementOnTrack()->associatedSurface().center().z());
685  } else if (it->materialEffectsOnTrack()) {
686  ATH_MSG_VERBOSE(" check tsos " << tsos << " TSOS mat "
687  << " r "
688  << it->materialEffectsOnTrack()->associatedSurface().globalReferencePoint().perp()
689  << " z " << it->materialEffectsOnTrack()->associatedSurface().globalReferencePoint().z());
690  } else {
691  ATH_MSG_VERBOSE(" check tsos other than above " << tsos);
692  }
693  }
694 
695  ATH_MSG_VERBOSE(" track with number of TSOS perigees " << nperigee);
696 
697  return naeots;
698  }

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

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

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

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

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

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

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

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ finalize()

StatusCode Rec::CombinedMuonTrackFitter::finalize ( )
overridevirtual

Reimplemented in Rec::CombinedMuonTrackBuilder.

Definition at line 145 of file CombinedMuonTrackFitter.cxx.

145  {
146  ATH_MSG_INFO("Finalizing CombinedMuonTrackFitter:"
147  << m_countStandaloneCleanerVeto << " standalone fits with cleaner veto" << endmsg << " "
148  << m_countExtensionCleanerVeto << " extension fits with cleaner veto" << endmsg << " "
149  << m_countCombinedCleanerVeto << " combined fits with cleaner veto");
150  // // summarize WARNINGs
151  m_messageHelper->printSummary();
152  return StatusCode::SUCCESS;
153  }

◆ fit() [1/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext &  ctx,
const Trk::MeasurementSet &  measurementSet,
const Trk::TrackParameters &  perigeeStartValue,
const Trk::RunOutlierRemoval  runOutlier,
const Trk::ParticleHypothesis  particleHypothesis 
) const
protected

fit a set of MeasurementBase objects with starting value for perigeeParameters

Definition at line 323 of file CombinedMuonTrackFitter.cxx.

326  {
327  // check valid particleHypothesis
328  if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
329  // invalid particle hypothesis
330  std::stringstream ss;
331  ss << particleHypothesis;
332  m_messageHelper->printWarning(31, ss.str());
333  return nullptr;
334  }
335 
336  // select straightLine fitter when magnets downstream of leading measurement are off
337  MagField::AtlasFieldCache fieldCache;
338  // Get field cache object
339  if (!loadMagneticField(ctx, fieldCache)) return nullptr;
340 
341  const Trk::ITrackFitter* fitter = m_fitter.get();
342  if (!fieldCache.toroidOn() || std::abs(perigeeStartValue.position().z()) > m_zECToroid) {
343  fitter = m_fitterSL.get();
344  ATH_MSG_VERBOSE(" fit (track refit method): select SL fitter ");
345  }
346 
347  // redo ROTs: ID, CROT and MDT specific treatments
348  // if (m_redoRots) redoRots(track);
349 
350  // calo association (if relevant)
351 
352  // create Perigee if starting parameters given for a different surface type
353  std::unique_ptr<Trk::TrackParameters> perigee = perigeeStartValue.uniqueClone();
354  std::unique_ptr<Trk::PerigeeSurface> perigeeSurface;
355 
356  if (perigee->surfaceType() != Trk::SurfaceType::Perigee) {
357  Amg::Vector3D origin(perigeeStartValue.position());
358  perigeeSurface = std::make_unique<Trk::PerigeeSurface>(origin);
359 
360  perigee = std::make_unique<Trk::Perigee>(perigeeStartValue.position(), perigeeStartValue.momentum(), perigeeStartValue.charge(),
361  *perigeeSurface);
362  }
363 
364  // FIT
365  std::unique_ptr<Trk::Track> fittedTrack(fitter->fit(ctx, measurementSet, *perigee, false, particleHypothesis));
366 
367  if (!checkTrack("fitInterface2", fittedTrack.get())) { return nullptr; }
368 
369  // eventually this whole tool will use unique_ptrs
370  // in the meantime, this allows the MuonErrorOptimisationTool and MuonRefitTool to use them
371 
372  // track cleaning
373  if (runOutlier) {
374  // fit with optimized spectrometer errors
375 
376  if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
377  optimizeErrors(ctx, *fittedTrack)) {
378  ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
379  std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
380  if (checkTrack("fitInterface2Opt", optimizedTrack.get())) {
381  fittedTrack.swap(optimizedTrack);
382  if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " fit mstSet scaled errors Track ");
383  }
384 
385  }
386 
387  // chi2 before clean
388  double chi2Before = normalizedChi2(*fittedTrack);
389 
390  // muon cleaner
391  ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... ");
392 
393  if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " fit mstSet before cleaning ");
394 
395  std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
396 
397  if (msgLevel(MSG::DEBUG)) countAEOTs(*cleanTrack, " fit mstSet clean Track ");
398 
399  if (!checkTrack("fitInterface2Cleaner", cleanTrack.get())) { cleanTrack.reset(); }
400 
401  if (!cleanTrack) {
402  if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
403  ATH_MSG_DEBUG(" cleaner veto B");
404  ++m_countExtensionCleanerVeto;
405  fittedTrack.reset();
406  } else {
407  ATH_MSG_DEBUG(" keep original extension track despite cleaner veto ");
408  }
409  } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
410  double chi2After = normalizedChi2(*cleanTrack);
411  if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
412  ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
413  fittedTrack.swap(cleanTrack);
414  } else {
415  ATH_MSG_VERBOSE(" keep original track despite cleaning ");
416  }
417  }
418 
419  // FIXME: provide indet cleaner
420  ATH_MSG_VERBOSE(" Finished cleaning");
421  }
422  // have to use release until the whole code uses unique_ptr
423  return fittedTrack;
424  }

◆ fit() [2/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext &  ctx,
const Trk::Track &  indetTrack,
Trk::Track &  extrapolatedTrack,
const Trk::RunOutlierRemoval  runOutlier,
const Trk::ParticleHypothesis  particleHypothesis 
) const
protected

combined muon fit

Definition at line 427 of file CombinedMuonTrackFitter.cxx.

429  {
430  // check valid particleHypothesis
431  if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
432  // invalid particle hypothesis
433  std::stringstream ss;
434  ss << particleHypothesis;
435  m_messageHelper->printWarning(32, ss.str());
436  return nullptr;
437  }
438 
439  // select straightLine fitter when solenoid and toroid are off
440  const Trk::ITrackFitter* fitter = m_fitter.get();
441  MagField::AtlasFieldCache fieldCache;
442  // Get field cache object
443  if (!loadMagneticField(ctx, fieldCache)) return nullptr;
444 
445  if (!fieldCache.toroidOn() && !fieldCache.solenoidOn()) {
446  fitter = m_fitterSL.get();
447  ATH_MSG_VERBOSE(" fit (combined muon fit method): select SL fitter ");
448  }
449 
450  // redo ROTs: ID, CROT and MDT specific treatments
451 
452  // calo association (for now just WARN if missing)
453  if (particleHypothesis == Trk::muon && !m_trackQuery->isCaloAssociated(extrapolatedTrack, ctx)) {
454  // combined muon track is missing the TSOS's describing calorimeter association
455  m_messageHelper->printWarning(33);
456  }
457 
458  // Updates the calo TSOS with the ones from TG+corrections
459  if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
460  ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined Fit ...");
461  m_materialUpdator->updateCaloTSOS(indetTrack, extrapolatedTrack);
462  }
463 
464  // FIT
465  ATH_MSG_VERBOSE(" perform combined fit... " << std::endl
466  << m_printer->print(indetTrack) << std::endl
467  << m_printer->print(extrapolatedTrack));
468 
469  std::unique_ptr<Trk::Track> fittedTrack(fitter->fit(ctx, indetTrack, extrapolatedTrack, false, particleHypothesis));
470 
471  if (!fittedTrack) return nullptr;
472  // track cleaning
473  if (runOutlier) {
474  // fit with optimized spectrometer errors
475 
476  if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
477  optimizeErrors(ctx, *fittedTrack)) {
478  ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
479  std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
480  if (checkTrack("Error opt", optimizedTrack.get()) &&
481  normalizedChi2(*optimizedTrack) < normalizedChi2(*fittedTrack)) {
482  fittedTrack.swap(optimizedTrack);
483  if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " cbfit scaled errors Track ");
484  }
485  }
486 
487  // chi2 before clean
488  double chi2Before = normalizedChi2(*fittedTrack);
489 
490  // muon cleaner
491  ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... " << m_printer->print(*fittedTrack) << std::endl
492  << m_printer->printStations(*fittedTrack));
493 
494  if (msgLevel(MSG::DEBUG)) { countAEOTs(*fittedTrack, " cb before clean Track "); }
495  std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
496  if (cleanTrack && msgLevel(MSG::DEBUG)) { countAEOTs(*cleanTrack, " cb after clean Track "); }
497 
498  if (!cleanTrack) {
499  if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
500  ATH_MSG_DEBUG("cleaner veto C "<<chi2Before<<" Cut: "<<m_badFitChi2);
501  ++m_countCombinedCleanerVeto;
502  fittedTrack.reset();
503  } else {
504  ATH_MSG_DEBUG(" keep original combined track despite cleaner veto ");
505  }
506  } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
507  double chi2After = normalizedChi2(*cleanTrack);
508  if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
509  ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
510  fittedTrack.swap(cleanTrack);
511  } else {
512  ATH_MSG_VERBOSE(" keep original track despite cleaning ");
513  }
514  }
515 
516  // FIXME: provide indet cleaner
517  ATH_MSG_VERBOSE(" finished cleaning");
518  }
519  // have to use release until the whole code uses unique_ptr
520  return fittedTrack;
521  }

◆ fit() [3/3]

std::unique_ptr< Trk::Track > Rec::CombinedMuonTrackFitter::fit ( const EventContext &  ctx,
const Trk::Track &  track,
const Trk::RunOutlierRemoval  runOutlier,
const Trk::ParticleHypothesis  particleHypothesis 
) const
overridevirtual

Implements Rec::ICombinedMuonTrackFitter.

Definition at line 154 of file CombinedMuonTrackFitter.cxx.

156  {
157  ATH_MSG_VERBOSE(" fit() " << m_printer->print(track) << std::endl
158  << m_printer->printMeasurements(track) << std::endl
159  << m_printer->printStations(track));
160  // check valid particleHypothesis
161  if (particleHypothesis != Trk::muon && particleHypothesis != Trk::nonInteracting) {
162  // invalid particle hypothesis
163  std::stringstream ss;
164  ss << particleHypothesis;
165  m_messageHelper->printWarning(29, ss.str());
166  return nullptr;
167  }
168 
169  // check if combined or subsystem track
170  bool isCombined = m_trackQuery->isCombined(track, ctx);
171  // select straightLine fitter when magnets downstream of leading measurement are off
172  const Trk::ITrackFitter* fitter = m_fitter.get();
173  MagField::AtlasFieldCache fieldCache;
174  // Get field cache object
175 
176  if (!loadMagneticField(ctx, fieldCache)) return nullptr;
177 
178  if (!fieldCache.toroidOn() && !(isCombined && fieldCache.solenoidOn())) {
179  fitter = m_fitterSL.get();
180  ATH_MSG_VERBOSE(" fit (track refit method): select SL fitter ");
181  }
182 
183  // redo ROTs: ID, CROT and MDT specific treatments
184  // if (m_redoRots) redoRots(track);
185 
186  // perform fit after ensuring calo is associated for combined tracks
187  // calo association for combined tracks (WARN if missing from input)
188  std::unique_ptr<Trk::Track> fittedTrack = std::make_unique<Trk::Track>(track);
189  if (isCombined && particleHypothesis == Trk::muon && !m_trackQuery->isCaloAssociated(*fittedTrack, ctx)) {
190  // about to add the TSOS's describing calorimeter association to a combined muon;
191  m_messageHelper->printWarning(30);
192 
193  auto combinedTSOS = std::make_unique<Trk::TrackStates>();
194 
195  combinedTSOS->reserve(fittedTrack->trackStateOnSurfaces()->size() + 3);
196  bool caloAssociated = false;
197 
198  // run-2 schema, update default eloss with parametrised value
199  if (m_useCaloTG) {
200  ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined (re)Fit ...");
201  m_materialUpdator->updateCaloTSOS(*fittedTrack);
202  caloAssociated = true;
203  }
204 
205  for (const Trk::TrackStateOnSurface* in_tsos : *fittedTrack->trackStateOnSurfaces()) {
206  if (caloAssociated) {
207  combinedTSOS->push_back(in_tsos->clone());
208  } else if ((in_tsos->measurementOnTrack() && m_indetVolume->inside(in_tsos->measurementOnTrack()->globalPosition())) ||
209  (in_tsos->trackParameters() && m_indetVolume->inside(in_tsos->trackParameters()->position()))) {
210  combinedTSOS->push_back(in_tsos->clone());
211  } else {
212  std::unique_ptr<const Trk::TrackStateOnSurface> tsos = m_caloTSOS->innerTSOS(ctx, *fittedTrack->perigeeParameters());
213  if (tsos) {
214  combinedTSOS->push_back(std::move(tsos));
215  const Trk::TrackParameters* parameters = combinedTSOS->back()->trackParameters();
216  if (in_tsos->type(Trk::TrackStateOnSurface::CaloDeposit)) {
217  combinedTSOS->push_back(in_tsos->clone());
218  tsos = m_caloTSOS->outerTSOS(ctx, *parameters);
219  if (tsos) combinedTSOS->push_back(std::move(tsos));
220  } else {
221  tsos = m_caloTSOS->middleTSOS(ctx, *parameters);
222  if (tsos) combinedTSOS->push_back(std::move(tsos));
223  tsos = m_caloTSOS->outerTSOS(ctx, *parameters);
224  if (tsos) combinedTSOS->push_back(std::move(tsos));
225  combinedTSOS->push_back(in_tsos->clone());
226  }
227  }
228  caloAssociated = true;
229  }
230  }
231 
232  std::unique_ptr<Trk::Track> combinedTrack = std::make_unique<Trk::Track>(fittedTrack->info(), std::move(combinedTSOS), nullptr);
233 
234  if (msgLevel(MSG::DEBUG)) countAEOTs(*combinedTrack, " combinedTrack track before fit ");
235 
236  caloAssociated = m_trackQuery->isCaloAssociated(*combinedTrack, ctx);
237 
238  // Updates the calo TSOS with the ones from TG+corrections
239  if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
240  ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Combined (re)Fit ...");
241  m_materialUpdator->updateCaloTSOS(*combinedTrack);
242  }
243  // FIT
244  fittedTrack = fitter->fit(ctx, *combinedTrack, false, particleHypothesis);
245  } else {
246  // Updates the calo TSOS with the ones from TG+corrections
247  if (m_updateWithCaloTG && !m_useCaloTG && particleHypothesis == Trk::muon) {
248  ATH_MSG_VERBOSE("Updating Calorimeter TSOS in Muon Standalone Fit ...");
249  m_materialUpdator->updateCaloTSOS(*fittedTrack);
250  }
251 
252  // FIT
253  fittedTrack = fitter->fit(ctx, *fittedTrack, false, particleHypothesis);
254  }
255 
256  // quit if fit has failed
257  if (!fittedTrack) return nullptr;
258 
259 
260  if (!checkTrack("fitInterface1", fittedTrack.get())) return nullptr;
261 
262 
263  // eventually this whole tool will use unique_ptrs
264  // in the meantime, this allows the MuonErrorOptimisationTool and MuonRefitTool to use them
265  // track cleaning
266  if (runOutlier) {
267  // fit with optimized spectrometer errors
268 
269  const double chi2BeforeOptimizer = normalizedChi2(*fittedTrack);
270  if (!m_muonErrorOptimizer.empty() && !fittedTrack->info().trackProperties(Trk::TrackInfo::StraightTrack) &&
271  optimizeErrors(ctx, *fittedTrack)) {
272  ATH_MSG_VERBOSE(" perform spectrometer error optimization after cleaning ");
273  std::unique_ptr<Trk::Track> optimizedTrack = m_muonErrorOptimizer->optimiseErrors(*fittedTrack, ctx);
274  if (checkTrack("fitInterface1Opt", optimizedTrack.get()) && chi2BeforeOptimizer > normalizedChi2(*optimizedTrack)) {
275  fittedTrack.swap(optimizedTrack);
276  if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " re fit scaled errors Track ");
277  }
278  }
279 
280  // chi2 before clean
281  const double chi2Before = normalizedChi2(*fittedTrack);
282 
283  // muon cleaner
284  ATH_MSG_VERBOSE(__FILE__<<":"<<__LINE__<<" perform track cleaning... " << m_printer->print(*fittedTrack) << std::endl
285  << m_printer->printStations(*fittedTrack));
286 
287  if (msgLevel(MSG::DEBUG)) countAEOTs(*fittedTrack, " refit: fitted track before cleaning ");
288 
289  std::unique_ptr<Trk::Track> cleanTrack = m_cleaner->clean(*fittedTrack, ctx);
290 
291  if (msgLevel(MSG::DEBUG)) countAEOTs(*cleanTrack, " refit: after cleaning");
292 
293  if (!checkTrack("fitInterface1Cleaner", cleanTrack.get())) { cleanTrack.reset(); }
294 
295  if (!cleanTrack) {
296  if (m_allowCleanerVeto && chi2Before > m_badFitChi2) {
297  ATH_MSG_DEBUG(" cleaner veto A "<<chi2Before<<" "<<m_badFitChi2<<" "<<m_printer->printMeasurements(*fittedTrack) );
298  ++m_countStandaloneCleanerVeto;
299  fittedTrack.reset();
300  } else {
301  ATH_MSG_DEBUG(" keep original standalone track despite cleaner veto ");
302  }
303  } else if (!(*cleanTrack->perigeeParameters() == *fittedTrack->perigeeParameters())) {
304  double chi2After = normalizedChi2(*cleanTrack);
305 
306  if (chi2After < m_badFitChi2 || chi2After < chi2Before) {
307  ATH_MSG_VERBOSE(" found and removed spectrometer outlier(s) ");
308  fittedTrack.swap(cleanTrack);
309  } else {
310  ATH_MSG_VERBOSE(" keep original track despite cleaning ");
311  }
312  }
313 
314  // FIXME: provide indet cleaner
315  if (fittedTrack) {
316  ATH_MSG_VERBOSE(" finished track cleaning... " << m_printer->print(*fittedTrack) << std::endl
317  << m_printer->printStations(*fittedTrack));
318  }
319  }
320  return fittedTrack;
321  }

◆ initialize()

StatusCode Rec::CombinedMuonTrackFitter::initialize ( )
overridevirtual

Reimplemented in Rec::CombinedMuonTrackBuilder.

Definition at line 56 of file CombinedMuonTrackFitter.cxx.

56  {
57  ATH_MSG_DEBUG("Initializing CombinedMuonTrackFitter.");
58  ATH_MSG_DEBUG(" with options: ");
59 
60  if (m_allowCleanerVeto) ATH_MSG_DEBUG(" AllowCleanerVeto");
61  if (!m_muonErrorOptimizer.empty()) ATH_MSG_DEBUG(" ErrorOptimisation");
62 
63  // fill WARNING messages
64  m_messageHelper->setMaxNumberOfMessagesPrinted(m_maxWarnings);
65  m_messageHelper->setMessage(0, "combinedFit:: missing MeasuredPerigee for indet track");
66  m_messageHelper->setMessage(1, "combinedFit:: fail with MS removed by cleaner");
67  m_messageHelper->setMessage(2, "combinedFit:: fail with perigee outside indet");
68  m_messageHelper->setMessage(3, "combinedFit:: fail with missing caloEnergy");
69  m_messageHelper->setMessage(4, "combinedFit:: final combined track lost, this should not happen");
70  m_messageHelper->setMessage(5, "indetExtension:: reject with insufficient MS measurements");
71  m_messageHelper->setMessage(6, "standaloneFit:: input vertex fails dynamic_cast");
72  m_messageHelper->setMessage(7, "standaloneFit:: missing MeasuredPerigee for spectrometer track");
73  m_messageHelper->setMessage(8, "standaloneFit:: missing TrackParameters on prefit");
74  m_messageHelper->setMessage(9, "standaloneFit:: prefit fails parameter extrapolation to calo");
75  m_messageHelper->setMessage(10, "standaloneFit:: extrapolated track missing TrackParameters at calo scatterer");
76  m_messageHelper->setMessage(11, "standaloneFit:: final track lost, this should not happen");
77  m_messageHelper->setMessage(12, "standaloneFit:: fail as calo incorrectly described");
78  m_messageHelper->setMessage(13, "standaloneRefit:: fail track as no TSOS with type CaloDeposit");
79  m_messageHelper->setMessage(14, "standaloneRefit:: no inner material");
80  m_messageHelper->setMessage(15, "standaloneRefit:: no inner parameters");
81  m_messageHelper->setMessage(16, "standaloneRefit:: innerScattering dynamic_cast failed");
82  m_messageHelper->setMessage(17, "standaloneRefit:: no TSOS of type CaloDeposit found");
83  m_messageHelper->setMessage(18, "standaloneRefit:: no inner scattering TSOS found");
84  m_messageHelper->setMessage(19, "standaloneRefit:: no middle material");
85  m_messageHelper->setMessage(20, "standaloneRefit:: no middle parameters");
86  m_messageHelper->setMessage(21, "standaloneRefit:: no CaloDeposit TSOS found");
87  m_messageHelper->setMessage(22, "standaloneRefit:: no outer material");
88  m_messageHelper->setMessage(23, "standaloneRefit:: no outer parameters");
89  m_messageHelper->setMessage(24, "standaloneRefit:: outerScattering dynamic_cast failed");
90  m_messageHelper->setMessage(25, "standaloneRefit:: no outerScattering or CaloDeposit TSOS found");
91  m_messageHelper->setMessage(26, "standaloneRefit:: failed propagation to innerTSOS");
92  m_messageHelper->setMessage(27, "standaloneRefit:: failed propagation to middleTSOS");
93  m_messageHelper->setMessage(28, "standaloneRefit:: fail as calo incorrectly described");
94  m_messageHelper->setMessage(29, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
95  m_messageHelper->setMessage(30, "fit:: about to add the TSOS's describing calorimeter association to a combined muon");
96  m_messageHelper->setMessage(31, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
97  m_messageHelper->setMessage(32, "fit:: particle hypothesis must be 0 or 2 (nonInteracting or muon). Requested: ");
98  m_messageHelper->setMessage(33, "fit:: combined muon track is missing the TSOS's describing calorimeter association");
99  m_messageHelper->setMessage(34, "appendSelectedTSOS:: skip duplicate measurement ");
100  m_messageHelper->setMessage(35, "caloEnergyParameters:: muonTrack without caloEnergy association");
101  m_messageHelper->setMessage(36, "caloEnergyParameters:: combinedTrack without caloEnergy association");
102  m_messageHelper->setMessage(37, "createMuonTrack:: should never happen: FSR caloEnergy delete");
103  m_messageHelper->setMessage(38, "createSpectrometerTSOS:: missing MeasuredPerigee for spectrometer track");
104  m_messageHelper->setMessage(39, "createSpectrometerTSOS:: skip unrecognized TSOS without TrackParameters. Type: ");
105  m_messageHelper->setMessage(40, "createSpectrometerTSOS:: skip duplicate measurement on same Surface. Type: ");
106  m_messageHelper->setMessage(41, "entrancePerigee:: missing TrackingGeometrySvc - no perigee will be added at MS entrance");
107  m_messageHelper->setMessage(42, "extrapolatedParameters:: missing MeasuredPerigee for spectrometer track");
108  m_messageHelper->setMessage(43, "extrapolatedParameters:: missing spectrometer parameters on spectrometer track");
109  m_messageHelper->setMessage(44, "final track lost, this should not happen");
110  m_messageHelper->setMessage(45, "momentumUpdate:: update failed, keeping original value");
111  m_messageHelper->setMessage(46, "reallocateMaterial:: null perigeeStartValue");
112  m_messageHelper->setMessage(47, "reallocateMaterial:: refit fails");
113  m_messageHelper->setMessage(48, "standaloneFit:: insufficient measurements on input spectrometer track");
114  m_messageHelper->setMessage(49, "standaloneFit:: inconsistent TSOS on input spectrometer track");
115 
116  ATH_CHECK(m_printer.retrieve());
117  ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
118  ATH_MSG_DEBUG("Setup handle for key " << m_fieldCacheCondObjInputKey);
119  ATH_CHECK(m_muonErrorOptimizer.retrieve(DisableTool{m_muonErrorOptimizer.empty()}));
120 
121  ATH_CHECK(m_caloTSOS.retrieve());
122  ATH_MSG_DEBUG("Retrieved tool " << m_caloTSOS);
123  ATH_CHECK(m_cleaner.retrieve());
124  ATH_MSG_DEBUG("Retrieved tool " << m_cleaner);
125 
126  ATH_CHECK(m_fitter.retrieve());
127  ATH_CHECK(m_fitterSL.retrieve());
128  ATH_CHECK(m_idHelperSvc.retrieve());
129 
130  ATH_CHECK(m_trackingVolumesSvc.retrieve());
131  ATH_MSG_DEBUG("Retrieved Svc " << m_trackingVolumesSvc);
132  m_calorimeterVolume = std::make_unique<Trk::Volume>(m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer));
133  m_indetVolume = std::make_unique<Trk::Volume>(m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::CalorimeterEntryLayer));
134 
135  ATH_CHECK(m_trackQuery.retrieve());
136  ATH_MSG_DEBUG("Retrieved tool " << m_trackQuery);
137  ATH_CHECK(m_trackSummary.retrieve());
138  ATH_MSG_DEBUG("Retrieved tool " << m_trackSummary);
139  ATH_CHECK(m_materialUpdator.retrieve());
140  ATH_MSG_DEBUG("Retrieved tool " << m_materialUpdator);
141 
142  return StatusCode::SUCCESS;
143  }

◆ 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& Rec::ICombinedMuonTrackFitter::interfaceID ( )
inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 41 of file ICombinedMuonTrackFitter.h.

41  {
42  static const InterfaceID IID_ICombinedMuonTrackFitter("ICombinedMuonTrackFitter", 1, 0);
43  return IID_ICombinedMuonTrackFitter;
44  }

◆ loadMagneticField()

bool Rec::CombinedMuonTrackFitter::loadMagneticField ( const EventContext &  ctx,
MagField::AtlasFieldCache &  field_cache 
) const
protected

Definition at line 537 of file CombinedMuonTrackFitter.cxx.

537  {
538  SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldCondObj{m_fieldCacheCondObjInputKey, ctx};
539  if (!fieldCondObj.isValid()) {
540  ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
541  return false;
542  }
543  fieldCondObj->getInitializedCache(fieldCache);
544  return true;
545  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ normalizedChi2()

double Rec::CombinedMuonTrackFitter::normalizedChi2 ( const Trk::Track &  track) const
protected

Definition at line 524 of file CombinedMuonTrackFitter.cxx.

524  {
525  double chi2 = 999999.;
526  if (track.fitQuality()) {
527  if (track.fitQuality()->numberDoF()) {
528  chi2 = track.fitQuality()->chiSquared() / track.fitQuality()->doubleNumberDoF();
529  } else {
530  chi2 = m_badFitChi2;
531  }
532  }
533 
534  return chi2;
535  }

◆ optimizeErrors()

bool Rec::CombinedMuonTrackFitter::optimizeErrors ( const EventContext &  ctx,
Trk::Track &  track 
) const
private

Definition at line 546 of file CombinedMuonTrackFitter.cxx.

546  {
547  const Trk::MuonTrackSummary* muonSummary = nullptr;
548  const Trk::TrackSummary* summary = track.trackSummary();
549 
550  if (summary) {
551  muonSummary = summary->muonTrackSummary();
552  } else {
553  m_trackSummary->updateTrack(ctx, track);
554  summary = track.trackSummary();
555  muonSummary = summary->muonTrackSummary();
556  }
557 
558  if (!muonSummary) return false;
559 
560 
561  unsigned int optimize{0},nBarrel{0}, nEndcap{0}, nSmall{0}, nLarge{0};
562 
563  for (const Trk::MuonTrackSummary::ChamberHitSummary& summary : muonSummary->chamberHitSummary()) {
564  const Identifier& id = summary.chamberId();
565  bool isMdt = m_idHelperSvc->isMdt(id);
566  if (!isMdt) continue;
567 
568  Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
569 
570  if (stIndex == Muon::MuonStationIndex::BE) { optimize = 1; }
571 
572  if (stIndex == Muon::MuonStationIndex::BI && m_idHelperSvc->chamberIndex(id) == Muon::MuonStationIndex::BIS &&
573  std::abs(m_idHelperSvc->stationEta(id)) > 6) {
574  optimize = 2;
575  }
576 
577  if (stIndex == Muon::MuonStationIndex::BI || stIndex == Muon::MuonStationIndex::BM || stIndex == Muon::MuonStationIndex::BO ||
578  stIndex == Muon::MuonStationIndex::BE) {
579  nBarrel++;
580  }
581 
582  if (stIndex == Muon::MuonStationIndex::EI || stIndex == Muon::MuonStationIndex::EM || stIndex == Muon::MuonStationIndex::EO ||
583  stIndex == Muon::MuonStationIndex::EE) {
584  nEndcap++;
585  }
586 
587  if (m_idHelperSvc->isSmallChamber(id)) {
588  nSmall++;
589  } else {
590  nLarge++;
591  }
592  }
593 
594  if (nBarrel > 0 && nEndcap > 0) { optimize += 10; }
595 
596  if (nSmall > 0 && nLarge > 0) { optimize += 100; }
597 
598  if (optimize > 0) { ATH_MSG_DEBUG(" OptimizeErrors with value " << optimize); }
599 
600  return optimize > 0;
601  }

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

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

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_allowCleanerVeto

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_allowCleanerVeto {this, "AllowCleanerVeto", true}
private

Definition at line 139 of file CombinedMuonTrackFitter.h.

◆ m_badFitChi2

Gaudi::Property<double> Rec::CombinedMuonTrackFitter::m_badFitChi2 {this, "BadFitChi2", 2.5}
protected

Definition at line 144 of file CombinedMuonTrackFitter.h.

◆ m_calorimeterVolume

std::unique_ptr<const Trk::Volume> Rec::CombinedMuonTrackFitter::m_calorimeterVolume {nullptr}
protected

Definition at line 152 of file CombinedMuonTrackFitter.h.

◆ m_caloTSOS

ToolHandle<Rec::IMuidCaloTrackStateOnSurface> Rec::CombinedMuonTrackFitter::m_caloTSOS
protected
Initial value:
{
this,
"CaloTSOS",
"",
}

Definition at line 99 of file CombinedMuonTrackFitter.h.

◆ m_cleaner

ToolHandle<Muon::IMuonTrackCleaner> Rec::CombinedMuonTrackFitter::m_cleaner
private
Initial value:
{
this,
"Cleaner",
"Muon::MuonTrackCleaner/MuidTrackCleaner",
}

Definition at line 82 of file CombinedMuonTrackFitter.h.

◆ m_countCombinedCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countCombinedCleanerVeto {0}
mutableprivate

Definition at line 158 of file CombinedMuonTrackFitter.h.

◆ m_countExtensionCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countExtensionCleanerVeto {0}
mutableprivate

Definition at line 159 of file CombinedMuonTrackFitter.h.

◆ m_countStandaloneCleanerVeto

std::atomic_uint Rec::CombinedMuonTrackFitter::m_countStandaloneCleanerVeto {0}
mutableprivate

Definition at line 160 of file CombinedMuonTrackFitter.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_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Rec::CombinedMuonTrackFitter::m_fieldCacheCondObjInputKey
private
Initial value:
{this, "AtlasFieldCacheCondObj", "fieldCondObj",
"Name of the Magnetic Field conditions object key"}

Definition at line 133 of file CombinedMuonTrackFitter.h.

◆ m_fitter

ToolHandle<Trk::ITrackFitter> Rec::CombinedMuonTrackFitter::m_fitter
private
Initial value:
{
this,
"Fitter",
"Trk::iPatFitter/iPatFitter",
}

Definition at line 87 of file CombinedMuonTrackFitter.h.

◆ m_fitterSL

ToolHandle<Trk::ITrackFitter> Rec::CombinedMuonTrackFitter::m_fitterSL
private
Initial value:
{
this,
"SLFitter",
"Trk::iPatFitter/iPatSLFitter",
}

Definition at line 92 of file CombinedMuonTrackFitter.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Rec::CombinedMuonTrackFitter::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
protected

Definition at line 129 of file CombinedMuonTrackFitter.h.

◆ m_indetVolume

std::unique_ptr<const Trk::Volume> Rec::CombinedMuonTrackFitter::m_indetVolume {nullptr}
protected

Definition at line 151 of file CombinedMuonTrackFitter.h.

◆ m_materialUpdator

ToolHandle<Trk::ITrkMaterialProviderTool> Rec::CombinedMuonTrackFitter::m_materialUpdator
protected
Initial value:
{
this,
"CaloMaterialProvider",
"",
}

Definition at line 124 of file CombinedMuonTrackFitter.h.

◆ m_maxWarnings

Gaudi::Property<unsigned> Rec::CombinedMuonTrackFitter::m_maxWarnings
private
Initial value:
{this, "MaxNumberOfWarnings", 10,
"Maximum number of permitted WARNING messages per message type."}

Definition at line 140 of file CombinedMuonTrackFitter.h.

◆ m_messageHelper

std::unique_ptr<MessageHelper> Rec::CombinedMuonTrackFitter::m_messageHelper {std::make_unique<MessageHelper>(*this, 50)}
protected

Definition at line 155 of file CombinedMuonTrackFitter.h.

◆ m_muonErrorOptimizer

ToolHandle<Muon::IMuonErrorOptimisationTool> Rec::CombinedMuonTrackFitter::m_muonErrorOptimizer
protected
Initial value:
{
this,
"MuonErrorOptimizer",
"",
}

Definition at line 104 of file CombinedMuonTrackFitter.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Rec::CombinedMuonTrackFitter::m_printer
protected
Initial value:
{
this,
"Printer",
"Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
}

Definition at line 109 of file CombinedMuonTrackFitter.h.

◆ m_trackingVolumesSvc

ServiceHandle<Trk::ITrackingVolumesSvc> Rec::CombinedMuonTrackFitter::m_trackingVolumesSvc {this, "TrackingVolumesSvc", "TrackingVolumesSvc/TrackingVolumesSvc"}
private

Definition at line 136 of file CombinedMuonTrackFitter.h.

◆ m_trackQuery

ToolHandle<Rec::IMuonTrackQuery> Rec::CombinedMuonTrackFitter::m_trackQuery
protected
Initial value:
{
this,
"TrackQuery",
"Rec::MuonTrackQuery/MuonTrackQuery",
}

Definition at line 114 of file CombinedMuonTrackFitter.h.

◆ m_trackSummary

ToolHandle<Trk::ITrackSummaryTool> Rec::CombinedMuonTrackFitter::m_trackSummary
protected
Initial value:
{
this,
"TrackSummaryTool",
"Trk::TrackSummaryTool/MuidTrackSummaryTool",
}

Definition at line 119 of file CombinedMuonTrackFitter.h.

◆ m_updateWithCaloTG

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_updateWithCaloTG {this, "UpdateWithCaloTG", false}
protected

Definition at line 147 of file CombinedMuonTrackFitter.h.

◆ m_useCaloTG

Gaudi::Property<bool> Rec::CombinedMuonTrackFitter::m_useCaloTG {this, "UseCaloTG", false}
protected

Definition at line 148 of file CombinedMuonTrackFitter.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.

◆ m_zECToroid

Gaudi::Property<double> Rec::CombinedMuonTrackFitter::m_zECToroid {this, "zECToroid", 10. * Gaudi::Units::meter}
protected

Definition at line 146 of file CombinedMuonTrackFitter.h.

The documentation for this class was generated from the following files:
Muon::MuonStationIndex::BIS
@ BIS
Definition: MuonStationIndex.h:17
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
beamspotman.r
def r
Definition: beamspotman.py:676
LArSamples::FitterData::fitter
const ShapeFitter * fitter
Definition: ShapeFitter.cxx:23
Muon::MuonStationIndex::BE
@ BE
Definition: MuonStationIndex.h:25
Trk::TrackStateOnSurface::CaloDeposit
@ CaloDeposit
This TSOS contains a CaloEnergy object.
Definition: TrackStateOnSurface.h:135
Trk::TrackStateOnSurface::Perigee
@ Perigee
This represents a perigee, and so will contain a Perigee object only.
Definition: TrackStateOnSurface.h:117
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Trk::Track::fitQuality
const FitQuality * fitQuality() const
return a pointer to the fit quality const-overload
Amg::hasPositiveDiagElems
bool hasPositiveDiagElems(const AmgSymMatrix(N) &mat)
Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above defin...
Definition: EventPrimitivesCovarianceHelpers.h:96
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::ParametersBase::charge
double charge() const
Returns the charge.
DataVector::rend
const_reverse_iterator rend() const noexcept
Return a const_reverse_iterator pointing at the beginning of the collection.
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Rec::CombinedMuonTrackFitter::m_trackingVolumesSvc
ServiceHandle< Trk::ITrackingVolumesSvc > m_trackingVolumesSvc
Definition: CombinedMuonTrackFitter.h:136
Muon::MuonStationIndex::EO
@ EO
Definition: MuonStationIndex.h:26
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Rec::CombinedMuonTrackFitter::m_messageHelper
std::unique_ptr< MessageHelper > m_messageHelper
Definition: CombinedMuonTrackFitter.h:155
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::Track::info
const TrackInfo & info() const
Returns a const ref to info of a const tracks.
Trk::ParametersBase::surfaceType
constexpr virtual SurfaceType surfaceType() const override=0
Returns the Surface Type enum for the surface used to define the derived class.
Rec::CombinedMuonTrackFitter::m_updateWithCaloTG
Gaudi::Property< bool > m_updateWithCaloTG
Definition: CombinedMuonTrackFitter.h:147
skel.it
it
Definition: skel.GENtoEVGEN.py:396
Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer
@ MuonSpectrometerEntryLayer
Tracking Volume which defines the entrance surfaces of the MS.
Definition: ITrackingVolumesSvc.h:41
Rec::CombinedMuonTrackFitter::m_badFitChi2
Gaudi::Property< double > m_badFitChi2
Definition: CombinedMuonTrackFitter.h:144
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Rec::CombinedMuonTrackFitter::m_muonErrorOptimizer
ToolHandle< Muon::IMuonErrorOptimisationTool > m_muonErrorOptimizer
Definition: CombinedMuonTrackFitter.h:104
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Muon::MuonStationIndex::BI
@ BI
Definition: MuonStationIndex.h:25
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
MagField::AtlasFieldCache::toroidOn
bool toroidOn() const
LArSamples::ShapeFitter::fit
bool fit(const LArSamples::AbsShape &data, const AbsShape &reference, double &k, double &deltaT, double &chi2, const ScaledErrorData *sed=0) const
Definition: ShapeFitter.cxx:32
Trk::combinedTrack
void combinedTrack(long int ICH, double *pv0, double *covi, double BMAG, double *par, double *covo)
Definition: XYZtrp.cxx:113
Trk::ITrackFitter
Definition: ITrackFitter.h:42
Trk::MuonTrackSummary::ChamberHitSummary
structure to hold information per chamber in the muon system
Definition: MuonTrackSummary.h:32
Trk::MuonTrackSummary::chamberHitSummary
const std::vector< ChamberHitSummary > & chamberHitSummary() const
access to the vector of chamber hit summaries on the track
Definition: MuonTrackSummary.h:148
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
Trk::TrackInfo::StraightTrack
@ StraightTrack
A straight track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:84
Rec::CombinedMuonTrackFitter::checkTrack
bool checkTrack(std::string_view txt, const Trk::Track *newTrack) const
Definition: CombinedMuonTrackFitter.cxx:603
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Rec::CombinedMuonTrackFitter::loadMagneticField
bool loadMagneticField(const EventContext &ctx, MagField::AtlasFieldCache &field_cache) const
Definition: CombinedMuonTrackFitter.cxx:537
Muon::MuonStationIndex::BM
@ BM
Definition: MuonStationIndex.h:25
Rec::CombinedMuonTrackFitter::m_trackSummary
ToolHandle< Trk::ITrackSummaryTool > m_trackSummary
Definition: CombinedMuonTrackFitter.h:119
Rec::CombinedMuonTrackFitter::m_indetVolume
std::unique_ptr< const Trk::Volume > m_indetVolume
Definition: CombinedMuonTrackFitter.h:151
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Muon::MuonStationIndex::EI
@ EI
Definition: MuonStationIndex.h:26
Rec::CombinedMuonTrackFitter::m_countExtensionCleanerVeto
std::atomic_uint m_countExtensionCleanerVeto
Definition: CombinedMuonTrackFitter.h:159
Rec::CombinedMuonTrackFitter::m_fitterSL
ToolHandle< Trk::ITrackFitter > m_fitterSL
Definition: CombinedMuonTrackFitter.h:92
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
test_pyathena.parent
parent
Definition: test_pyathena.py:15
Rec::CombinedMuonTrackFitter::m_calorimeterVolume
std::unique_ptr< const Trk::Volume > m_calorimeterVolume
Definition: CombinedMuonTrackFitter.h:152
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Rec::CombinedMuonTrackFitter::m_trackQuery
ToolHandle< Rec::IMuonTrackQuery > m_trackQuery
Definition: CombinedMuonTrackFitter.h:114
Trk::MuonTrackSummary
Detailed track summary for the muon system Give access to hit counts per chamber.
Definition: MuonTrackSummary.h:26
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
Rec::CombinedMuonTrackFitter::m_caloTSOS
ToolHandle< Rec::IMuidCaloTrackStateOnSurface > m_caloTSOS
Definition: CombinedMuonTrackFitter.h:99
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
DataVector::rbegin
const_reverse_iterator rbegin() const noexcept
Return a const_reverse_iterator pointing past the end of the collection.
MagField::AtlasFieldCache::solenoidOn
bool solenoidOn() const
status of the magnets
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Rec::CombinedMuonTrackFitter::m_fieldCacheCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
Definition: CombinedMuonTrackFitter.h:133
Rec::CombinedMuonTrackFitter::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: CombinedMuonTrackFitter.h:129
Trk::ITrackingVolumesSvc::CalorimeterEntryLayer
@ CalorimeterEntryLayer
Tracking Volume which defines the entrance srufaces of the calorimeter.
Definition: ITrackingVolumesSvc.h:40
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Rec::CombinedMuonTrackFitter::m_allowCleanerVeto
Gaudi::Property< bool > m_allowCleanerVeto
Definition: CombinedMuonTrackFitter.h:139
Trk::Track::trackParameters
const DataVector< const TrackParameters > * trackParameters() const
Return a pointer to a vector of TrackParameters.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:97
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
Trk::SurfaceType::Perigee
@ Perigee
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
DataVector< const Trk::TrackStateOnSurface >::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Standard const_reverse_iterator.
Definition: DataVector.h:846
Rec::CombinedMuonTrackFitter::optimizeErrors
bool optimizeErrors(const EventContext &ctx, Trk::Track &track) const
Definition: CombinedMuonTrackFitter.cxx:546
Trk::nonInteracting
@ nonInteracting
Definition: ParticleHypothesis.h:25
Rec::CombinedMuonTrackFitter::m_countCombinedCleanerVeto
std::atomic_uint m_countCombinedCleanerVeto
Definition: CombinedMuonTrackFitter.h:158
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Rec::CombinedMuonTrackFitter::m_zECToroid
Gaudi::Property< double > m_zECToroid
Definition: CombinedMuonTrackFitter.h:146
a
TList * a
Definition: liststreamerinfos.cxx:10
h
Rec::CombinedMuonTrackFitter::m_fitter
ToolHandle< Trk::ITrackFitter > m_fitter
Definition: CombinedMuonTrackFitter.h:87
Muon::MuonStationIndex::BO
@ BO
Definition: MuonStationIndex.h:25
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Rec::CombinedMuonTrackFitter::m_countStandaloneCleanerVeto
std::atomic_uint m_countStandaloneCleanerVeto
Definition: CombinedMuonTrackFitter.h:160
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
DEBUG
#define DEBUG
Definition: page_access.h:11
MagField::AtlasFieldCache
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h)
Definition: AtlasFieldCache.h:43
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Rec::CombinedMuonTrackFitter::m_materialUpdator
ToolHandle< Trk::ITrkMaterialProviderTool > m_materialUpdator
Definition: CombinedMuonTrackFitter.h:124
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
Muon::MuonStationIndex::EE
@ EE
Definition: MuonStationIndex.h:26
Rec::CombinedMuonTrackFitter::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: CombinedMuonTrackFitter.h:109
Rec::CombinedMuonTrackFitter::normalizedChi2
double normalizedChi2(const Trk::Track &track) const
Definition: CombinedMuonTrackFitter.cxx:524
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Trk::TrackInfo::trackProperties
bool trackProperties(const TrackProperties &property) const
Access methods for track properties.
Rec::CombinedMuonTrackFitter::countAEOTs
unsigned int countAEOTs(const Trk::Track &track, const std::string &txt) const
Definition: CombinedMuonTrackFitter.cxx:649
Muon::MuonStationIndex::EM
@ EM
Definition: MuonStationIndex.h:26
Rec::CombinedMuonTrackFitter::m_useCaloTG
Gaudi::Property< bool > m_useCaloTG
Definition: CombinedMuonTrackFitter.h:148
fitman.k
k
Definition: fitman.py:528
Rec::CombinedMuonTrackFitter::m_maxWarnings
Gaudi::Property< unsigned > m_maxWarnings
Definition: CombinedMuonTrackFitter.h:140
Rec::CombinedMuonTrackFitter::m_cleaner
ToolHandle< Muon::IMuonTrackCleaner > m_cleaner
Definition: CombinedMuonTrackFitter.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Thu Nov 7 2024 22:24:28 for ATLAS Offline Software by   doxygen 1.8.18