ATLAS Offline Software
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Muon::MuonChamberHoleRecoveryTool Class Referenceabstract

tool to select tracks More...

#include <MuonChamberHoleRecoveryTool.h>

Inheritance diagram for Muon::MuonChamberHoleRecoveryTool:
Collaboration diagram for Muon::MuonChamberHoleRecoveryTool:

Classes

struct  RecoveryState
 

Public Types

using NewTrackStates = std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > >
 

Public Member Functions

 MuonChamberHoleRecoveryTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~MuonChamberHoleRecoveryTool ()=default
 
StatusCode initialize () override
 
std::unique_ptr< Trk::Track > recover (const Trk::Track &track, const EventContext &ctx) const override
 returns a new track with holes recovered More...
 
void createHoleTSOSsForClusterChamber (const Identifier &detElId, const EventContext &ctx, const Trk::TrackParameters &pars, std::set< Identifier > &layIds, NewTrackStates &states) 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
 
virtual void createHoleTSOSsForClusterChamber (const Identifier &detElId, const EventContext &ctx, const Trk::TrackParameters &pars, std::set< Identifier > &layIds, std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > &states) const =0
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 access to tool interface More...
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

bool getNextMuonMeasurement (RecoveryState &trkRecov, RecoveryState::CopyTarget target) const
 Increments the internal iterator of the RecoveryState until the next muon measurement on track is found Measurements inside the MS volume or any scatterer are copied automatically copied onto the target vector. More...
 
void recoverHitsInChamber (const EventContext &ctx, RecoveryState &trkRecov) const
 Loops over all muon hits in a muon chamber and tries to find missed ones by checking each tracking layer for hits. More...
 
std::set< Identifier > holesInMdtChamber (const EventContext &ctx, const Amg::Vector3D &position, const Amg::Vector3D &direction, const Identifier &chId, const std::set< Identifier > &tubeIds) const
 calculate holes in a given chamber using local straight line extrapolation More...
 
void recoverMdtHits (const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &pars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
 
void recoverClusterHits (const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &chambPars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
 
std::set< Identifier > layersOnTrkIds (const Trk::Track &track) const
 Returns a set of all layer Identifiers of the associated track hits. More...
 
const Trk::TrkDetElementBase * getDetectorElement (const EventContext &ctx, const Identifier &id) const
 Returns the detector element associated with the muon Identifier. More...
 
std::set< Identifier > getHoleLayerIds (const Identifier &detElId, const std::set< Identifier > &knownLayers) const
 Returns a set of all layer Identifiers (GasGap + channel orientation) in a muon chamber of type X excluding the ones in the knownLayers set
More...
 
template<class Prd >
NewTrackStates recoverChamberClusters (const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &prdKey, const Identifier &chambId, const Trk::TrackParameters &parsInChamb, std::set< Identifier > &knownLayers) const
 Attempts to recover all missing hits in a chamber. More...
 
template<class Prd >
std::vector< const Prd * > loadPrepDataHits (const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &key, const std::set< Identifier > &layerIds) 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

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
 
ServiceHandle< Trk::ITrackingVolumesSvc > m_trackingVolumesSvc {this, "TrackingVolumesSvc", "TrackingVolumesSvc/TrackingVolumesSvc"}
 
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
 
ToolHandle< Trk::IExtrapolator > m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"}
 
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator > m_mdtRotCreator
 
ToolHandle< Muon::IMuonClusterOnTrackCreator > m_cscRotCreator
 
ToolHandle< Muon::IMuonClusterOnTrackCreator > m_clusRotCreator
 
ToolHandle< Trk::IResidualPullCalculator > m_pullCalculator
 
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
 
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}
 
SG::ReadHandleKey< Muon::CscPrepDataContainer > m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}
 
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}
 
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
 
SG::ReadHandleKey< Muon::sTgcPrepDataContainer > m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}
 
SG::ReadHandleKey< Muon::MMPrepDataContainer > m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}
 
SG::ReadCondHandleKey< Muon::MuonIntersectGeoData > m_chamberGeoKey {this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"}
 
Gaudi::Property< bool > m_addMeasurements {this, "AddMeasurements", true}
 
Gaudi::Property< bool > m_detectBadSort {this, "DetectBadSorting", false}
 
Gaudi::Property< double > m_associationPullCutEta {this, "AssociationPullCutEta", 3}
 
Gaudi::Property< double > m_associationPullCutPhi {this, "AssociationPullCutPhi", 10}
 
Gaudi::Property< double > m_adcCut {this, "AdcCut", 50}
 
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

tool to select tracks

Definition at line 34 of file MuonChamberHoleRecoveryTool.h.

Member Typedef Documentation

◆ NewTrackStates

using Muon::MuonChamberHoleRecoveryTool::NewTrackStates = std::vector<std::unique_ptr<const Trk::TrackStateOnSurface> >

Definition at line 40 of file MuonChamberHoleRecoveryTool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonChamberHoleRecoveryTool()

Muon::MuonChamberHoleRecoveryTool::MuonChamberHoleRecoveryTool ( const std::string &  ty,
const std::string &  na,
const IInterface *  pa 
)

Definition at line 89 of file MuonChamberHoleRecoveryTool.cxx.

89  :
90  AthAlgTool(ty, na, pa) {
91  declareInterface<IMuonHoleRecoveryTool>(this);
92  }

◆ ~MuonChamberHoleRecoveryTool()

virtual Muon::MuonChamberHoleRecoveryTool::~MuonChamberHoleRecoveryTool ( )
virtualdefault

Member Function Documentation

◆ createHoleTSOSsForClusterChamber() [1/2]

void Muon::MuonChamberHoleRecoveryTool::createHoleTSOSsForClusterChamber ( const Identifier &  detElId,
const EventContext &  ctx,
const Trk::TrackParameters &  pars,
std::set< Identifier > &  layIds,
NewTrackStates &  states 
) const
override

Definition at line 344 of file MuonChamberHoleRecoveryTool.cxx.

348  {
349  ATH_MSG_VERBOSE(" performing holes search in chamber " << m_idHelperSvc->toString(detElId));
350  recoverClusterHits(ctx, detElId, pars, states, layIds);
351  }

◆ createHoleTSOSsForClusterChamber() [2/2]

virtual void Muon::IMuonHoleRecoveryTool::createHoleTSOSsForClusterChamber ( const Identifier &  detElId,
const EventContext &  ctx,
const Trk::TrackParameters &  pars,
std::set< Identifier > &  layIds,
std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > &  states 
) const
pure virtualinherited

Implemented in Muon::MuonSegmentRegionRecoveryTool.

◆ 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

◆ getDetectorElement()

const Trk::TrkDetElementBase * Muon::MuonChamberHoleRecoveryTool::getDetectorElement ( const EventContext &  ctx,
const Identifier &  id 
) const
private

Returns the detector element associated with the muon Identifier.

Definition at line 354 of file MuonChamberHoleRecoveryTool.cxx.

355  {
356  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey, ctx};
357  const MuonGM::MuonDetectorManager* MuonDetMgr{*DetectorManagerHandle};
358  if (!MuonDetMgr) {
359  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
360  return nullptr;
361  }
362  if (m_idHelperSvc->isMdt(detElId))
363  return MuonDetMgr->getMdtReadoutElement(detElId);
364  else if (m_idHelperSvc->isTgc(detElId))
365  return MuonDetMgr->getTgcReadoutElement(detElId);
366  else if (m_idHelperSvc->isRpc(detElId))
367  return MuonDetMgr->getRpcReadoutElement(detElId);
368  else if (m_idHelperSvc->isCsc(detElId))
369  return MuonDetMgr->getCscReadoutElement(detElId);
370  // New Small Wheel
371  else if (m_idHelperSvc->issTgc(detElId))
372  return MuonDetMgr->getsTgcReadoutElement(detElId);
373  else if (m_idHelperSvc->isMM(detElId))
374  return MuonDetMgr->getMMReadoutElement(detElId);
375  return nullptr;
376  }

◆ getHoleLayerIds()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::getHoleLayerIds ( const Identifier &  detElId,
const std::set< Identifier > &  knownLayers 
) const
private

Returns a set of all layer Identifiers (GasGap + channel orientation) in a muon chamber of type X excluding the ones in the knownLayers set

the second gas gap of the three layer stations does not have a phi measurement

Definition at line 456 of file MuonChamberHoleRecoveryTool.cxx.

457  {
458  std::set<Identifier> holeGaps{};
459  if (m_idHelperSvc->isMdt(detElId)) {
460  const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
461  for (int ml = 1; ml <= idHelper.numberOfMultilayers(detElId); ++ml) {
462  for (int layer = idHelper.tubeLayerMin(detElId);
463  layer <= idHelper.tubeLayerMax(detElId); ++layer) {
464  const Identifier layerId = idHelper.channelID(detElId, ml, layer, 1);
465  if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
466  }
467  }
468  } else if (m_idHelperSvc->isMM(detElId)) {
469  const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
470  for (int ml : {1 ,2}) {
471  for (int gap = MmIdHelper::gasGapMin(); gap <= MmIdHelper::gasGapMax(); ++gap) {
472  const Identifier layerId = idHelper.channelID(detElId, ml, gap, 1);
473  if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
474  }
475  }
476  } else if (m_idHelperSvc->issTgc(detElId)) {
477  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
478  using channelType = sTgcIdHelper::sTgcChannelTypes;
479  for (int ml : {1, 2}) {
480  for (const channelType chType : {channelType::Strip,
481  channelType::Pad,
482  channelType::Wire}){
483  for (int gap = sTgcIdHelper::gasGapMin();
484  gap <= sTgcIdHelper::gasGapMax(); ++gap) {
485  const Identifier layerId = idHelper.channelID(detElId, ml, gap, chType, 1);
486  if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
487  }
488  }
489  }
490  } else if (m_idHelperSvc->isTgc(detElId)) {
491  const TgcIdHelper& idHelper = m_idHelperSvc->tgcIdHelper();
492  const int gapMax{idHelper.gasGapMax(detElId)};
493  for (int gasgap = idHelper.gasGapMin(detElId);
494  gasgap < gapMax; ++gasgap){
495  for (int measPhi: {0,1}) {
497  if (gapMax == 3 && gasgap ==2 && measPhi == 1) continue;
498  const Identifier layerId = idHelper.channelID(detElId, gasgap, measPhi, 1);
499  if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
500  }
501  }
502  } else if (m_idHelperSvc->isRpc(detElId)) {
503  const RpcIdHelper& idHelper = m_idHelperSvc->rpcIdHelper();
504  const int doubZ{idHelper.doubletZ(detElId)};
505  const int gapMax{idHelper.gasGapMax(detElId)};
506  for (int phiGap = idHelper.doubletPhi(detElId);
507  phiGap <= RpcIdHelper::doubletPhiMax(); ++phiGap) {
508  for (int gap = idHelper.gasGapMin(detElId);
509  gap <= gapMax; ++gap) {
510  for (int measPhi: {0, 1}) {
511  const Identifier layerId = idHelper.channelID(detElId, doubZ, phiGap, gap, measPhi, 1);
512  if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
513  }
514  }
515  }
516  } else if (m_idHelperSvc->isCsc(detElId)) {
517  const CscIdHelper& idHelper{m_idHelperSvc->cscIdHelper()};
518  for (int layer = 1; layer <= 4; ++ layer) {
519  for (bool measPhi: {false, true}) {
520  const Identifier layId = idHelper.channelID(detElId, 2, layer, measPhi, 1);
521  if (!knownLayers.count(layId)) holeGaps.insert(layId);
522  }
523  }
524  }
525  return holeGaps;
526  }

◆ getNextMuonMeasurement()

bool Muon::MuonChamberHoleRecoveryTool::getNextMuonMeasurement ( RecoveryState &  trkRecov,
RecoveryState::CopyTarget  target 
) const
private

Increments the internal iterator of the RecoveryState until the next muon measurement on track is found Measurements inside the MS volume or any scatterer are copied automatically copied onto the target vector.

Copy all track states inside the MS

Scatteres AEOTs, material etc.

Definition at line 121 of file MuonChamberHoleRecoveryTool.cxx.

121  {
122  while(trkRecov.nextState()) {
123  const Trk::TrackParameters* pars = trkRecov.tsos()->trackParameters();
124  ATH_MSG_VERBOSE("Track parameters "<<(*pars));
126  const Trk::Volume& msVol{m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer)};
127  if (msVol.inside(pars->position())) {
128  ATH_MSG_VERBOSE("Tracking parameters are inside the MS");
129  trkRecov.copyState(target);
130  continue;
131  }
132 
133  if (trkRecov.tsos()->type(Trk::TrackStateOnSurface::Hole)) {
134  ATH_MSG_VERBOSE("Skip hole in MS");
135  continue;
136  }
138  const Trk::MeasurementBase* meas = trkRecov.tsos()->measurementOnTrack();
139  if (!meas) {
140  ATH_MSG_VERBOSE("The track state does not have an associated measurement");
141  trkRecov.copyState(target);
142  continue;
143  }
144  trkRecov.tsosId = m_edmHelperSvc->getIdentifier(*meas);
145  // Potentially a pseudo measurement. Anyway keep it
146  if (!trkRecov.tsosId.is_valid() || !m_idHelperSvc->isMuon(trkRecov.tsosId)) {
147  ATH_MSG_VERBOSE("No muon measurement");
148  trkRecov.copyState(target);
149  continue;
150  }
151  return true;
152  }
153  return false;
154  }

◆ holesInMdtChamber()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::holesInMdtChamber ( const EventContext &  ctx,
const Amg::Vector3D &  position,
const Amg::Vector3D &  direction,
const Identifier &  chId,
const std::set< Identifier > &  tubeIds 
) const
private

calculate holes in a given chamber using local straight line extrapolation

Parameters
parsTrackParameters in the chamber
chIdIdentifier of the chamber
tubeIdsset containing the Identifier of the hits that should not be counted as holes
Returns
a vector of hole Identifiers

Definition at line 378 of file MuonChamberHoleRecoveryTool.cxx.

379  {
380 
381  SG::ReadCondHandle<Muon::MuonIntersectGeoData> interSectSvc{m_chamberGeoKey,ctx};
382  if (!interSectSvc.isValid()) {
383  ATH_MSG_ERROR("Failed to retrieve chamber intersection service");
384  throw std::runtime_error("No chamber intersection service");
385  }
386  const MuonGM::MdtReadoutElement* readoutEle = interSectSvc->detMgr()->getMdtReadoutElement(chId);
387 
388  MuonStationIntersect intersect = interSectSvc->tubesCrossedByTrack(chId, position, direction);
389 
390  // clear hole vector
391  std::set<Identifier> holes;
392  for (unsigned int ii = 0; ii < intersect.tubeIntersects().size(); ++ii) {
393  const MuonTubeIntersect& tint = intersect.tubeIntersects()[ii];
394 
395  if (tubeIds.count(tint.tubeId)) { continue; }
396  ATH_MSG_VERBOSE(" intersect " << m_idHelperSvc->toString(tint.tubeId) << " dist wire " << tint.rIntersect
397  << " dist to tube end " << tint.xIntersect);
398 
399  if (std::abs(tint.rIntersect) > readoutEle->innerTubeRadius() || tint.xIntersect > -10.) {
400  ATH_MSG_VERBOSE(" not counted");
401  continue;
402  }
403  // check whether there is a hit in this tube
404  ATH_MSG_VERBOSE(" hole tube");
405  holes.insert(tint.tubeId);
406 
407  }
408  return holes;
409  }

◆ initialize()

StatusCode Muon::MuonChamberHoleRecoveryTool::initialize ( )
override

Definition at line 94 of file MuonChamberHoleRecoveryTool.cxx.

94  {
95  ATH_CHECK(m_DetectorManagerKey.initialize());
96  ATH_CHECK(m_edmHelperSvc.retrieve());
97  ATH_CHECK(m_idHelperSvc.retrieve());
98  ATH_CHECK(m_trackingVolumesSvc.retrieve());
99  ATH_CHECK(m_printer.retrieve());
100  ATH_CHECK(m_extrapolator.retrieve());
101 
102 
103  ATH_CHECK(m_key_csc.initialize(!m_key_csc.empty()));
104  ATH_CHECK(m_key_stgc.initialize(!m_key_stgc.empty()));
105  ATH_CHECK(m_key_mm.initialize(!m_key_mm.empty()));
106 
107  ATH_CHECK(m_key_mdt.initialize(!m_key_mdt.empty()));
108  ATH_CHECK(m_key_tgc.initialize(!m_key_tgc.empty()));
109  ATH_CHECK(m_key_rpc.initialize(!m_key_rpc.empty()));
110 
111  ATH_CHECK(m_cscRotCreator.retrieve(DisableTool{m_key_csc.empty()}));
112 
113  const bool hasClusKey = !m_key_stgc.empty() || !m_key_mm.empty() || !m_key_tgc.empty() || !m_key_rpc.empty();
114  ATH_CHECK(m_clusRotCreator.retrieve(EnableTool{hasClusKey}));
115  ATH_CHECK(m_mdtRotCreator.retrieve(EnableTool{!m_key_mdt.empty()}));
116  ATH_CHECK(m_pullCalculator.retrieve());
117 
118  ATH_CHECK(m_chamberGeoKey.initialize());
119  return StatusCode::SUCCESS;
120  }

◆ 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& Muon::IMuonHoleRecoveryTool::interfaceID ( )
inlinestaticinherited

access to tool interface

Definition at line 23 of file IMuonHoleRecoveryTool.h.

23  {
24  static const InterfaceID IID_IMuonHoleRecoveryTool("Muon::IMuonHoleRecoveryTool", 1, 0);
25  return IID_IMuonHoleRecoveryTool;
26  }

◆ layersOnTrkIds()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::layersOnTrkIds ( const Trk::Track &  track) const
private

Returns a set of all layer Identifiers of the associated track hits.

Definition at line 156 of file MuonChamberHoleRecoveryTool.cxx.

156  {
157  std::set<Identifier> layerIds{};
158  for (const Trk::TrackStateOnSurface* tsos: *track.trackStateOnSurfaces()){
159  const Trk::MeasurementBase* meas = tsos->measurementOnTrack();
160  if (!meas) continue;
161  const Identifier measId = m_edmHelperSvc->getIdentifier(*meas);
162 
163  if (!m_idHelperSvc->isMuon(measId)) continue;
164  layerIds.insert(measId);
165  layerIds.insert(m_idHelperSvc->layerId(measId));
166  // split competing ROTs into constituents
167  const CompetingMuonClustersOnTrack* comp = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
168  if (!comp) { continue; }
169 
170  for (const Muon::MuonClusterOnTrack* clust : comp->containedROTs()) {
171  layerIds.insert(m_idHelperSvc->layerId(clust->identify()));
172  }
173  }
174  return layerIds;
175  }

◆ loadPrepDataHits()

template<class Prd >
std::vector< const Prd * > Muon::MuonChamberHoleRecoveryTool::loadPrepDataHits ( const EventContext &  ctx,
const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &  key,
const std::set< Identifier > &  layerIds 
) const
private

Create a subset of Identifiers

Sort the Mdt prepdatas per Identifier as there's the possibily 2 DC can exist for the same channel

Definition at line 410 of file MuonChamberHoleRecoveryTool.cxx.

412  {
413  std::vector<const Prd*> collectedHits{};
414  if (key.empty()) {
415  ATH_MSG_DEBUG("No container configured for "<<typeid(Prd).name());
416  return collectedHits;
417  }
418  SG::ReadHandle<MuonPrepDataContainerT<Prd>> prdContainer{key, ctx};
419  if (!prdContainer.isPresent()) {
420  ATH_MSG_FATAL("Failed to load prep data collection "<<key.fullKey());
421  throw std::runtime_error("Invalid prepdata container");
422  }
424  std::set<IdentifierHash> chamberIds{};
425  std::transform(gasGapIds.begin(), gasGapIds.end(),
426  std::inserter(chamberIds, chamberIds.end()),
427  [this](const Identifier& id){
428  return m_idHelperSvc->moduleHash(id);
429  });
430  for (const IdentifierHash& moduleHash : chamberIds) {
431  const MuonPrepDataCollection<Prd>* prdColl = prdContainer->indexFindPtr(moduleHash);
432  if (!prdColl) continue;
433  collectedHits.reserve(collectedHits.size() + prdColl->size());
434  for (const Prd* prd: *prdColl) {
435  bool appendPrd{false};
436  if constexpr (std::is_same<Prd, MdtPrepData>::value) {
437  appendPrd = gasGapIds.count(prd->identify());
438  } else {
439  appendPrd = gasGapIds.count(m_idHelperSvc->layerId(prd->identify()));
440  }
441  if (appendPrd) {
442  ATH_MSG_VERBOSE(__func__<<"() - Add prd candidate "<<m_printer->print(*prd));
443  collectedHits.push_back(prd);
444  }
445  }
446  }
449  if constexpr(std::is_same<Prd, MdtPrepData>::value) {
450  std::sort(collectedHits.begin(), collectedHits.end(), [](const Prd* a, const Prd* b){
451  return a->identify() < b->identify();
452  });
453  }
454  return collectedHits;
455  }

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

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

◆ recover()

std::unique_ptr< Trk::Track > Muon::MuonChamberHoleRecoveryTool::recover ( const Trk::Track &  track,
const EventContext &  ctx 
) const
overridevirtual

returns a new track with holes recovered

Copy all parameters befor the MS onto the new track state

Start an iterative recovery looping over each chamber

Implements Muon::IMuonHoleRecoveryTool.

Definition at line 177 of file MuonChamberHoleRecoveryTool.cxx.

177  {
178  ATH_MSG_DEBUG(" performing hole search track " << std::endl
179  << m_printer->print(track) << std::endl
180  << m_printer->printMeasurements(track));
181 
182  RecoveryState recovState{track};
183  recovState.layersOnTrk = layersOnTrkIds(track);
184 
186  getNextMuonMeasurement(recovState, RecoveryState::CopyTarget::GlobalTrkStates);
188  recoverHitsInChamber(ctx, recovState);
189  std::unique_ptr<Trk::Track> newTrack = std::make_unique<Trk::Track>(track.info(), recovState.releaseStates(),
190  track.fitQuality() ? track.fitQuality()->uniqueClone() : nullptr);
191  return newTrack;
192  }

◆ recoverChamberClusters()

template<class Prd >
NewTrackStates Muon::MuonChamberHoleRecoveryTool::recoverChamberClusters ( const EventContext &  ctx,
const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &  prdKey,
const Identifier &  chambId,
const Trk::TrackParameters &  parsInChamb,
std::set< Identifier > &  knownLayers 
) const
private

Attempts to recover all missing hits in a chamber.

The hit is out of bounds --> continue

Loop over all prd candidates

The surface cannot be reached. Discard the prd

Compare the pad & local positions

Calculate the pull by hand

For one reason or another, the pads have 1D covariances

Check whether the pull is reasonable

Assign the best pad onto the track

Calculate the track pull

the best clusters are found. Put them onto the track

Next loop over the reamining parameters at surface to create holes

Definition at line 527 of file MuonChamberHoleRecoveryTool.cxx.

531  {
532  NewTrackStates recoveredStates{};
533  const std::set<Identifier> missingLayers = getHoleLayerIds(detElId, knownLayers);
534  std::vector<const Prd*> prdCandidates = loadPrepDataHits(ctx, prdKey, missingLayers);
536  using LayerParsMap = std::map<Identifier, std::unique_ptr<Trk::TrackParameters>>;
537  LayerParsMap parsAtSurfMap{};
538  for (const Identifier& holeId : missingLayers) {
539  const Trk::TrkDetElementBase* detEl = getDetectorElement(ctx, holeId);
540  const Trk::Surface& surf{detEl->surface(holeId)};
541  std::unique_ptr<Trk::TrackParameters> pars = m_extrapolator->extrapolateDirectly(ctx, parsInChamb, surf,
542  Trk::anyDirection, false, Trk::muon);
543  if (!pars) {
544  ATH_MSG_VERBOSE("Surface layer "<<m_idHelperSvc->toStringGasGap(holeId)<<" cannot be reached");
545  continue;
546  }
547  if (!Amg::hasPositiveDiagElems(*pars->covariance())) {
548  ATH_MSG_DEBUG("Uncertainties of extraploation to "<<m_idHelperSvc->toStringGasGap(holeId)<<" blew up");
549  continue;
550  }
551  const Amg::Vector2D locExPos{pars->parameters()[Trk::locX],
552  pars->parameters()[Trk::locY]};
553  bool inbounds{false};
554  if constexpr(std::is_same<Prd, MMPrepData>::value) {
555  inbounds = static_cast<const MuonGM::MMReadoutElement*>(detEl)->insideActiveBounds(holeId, locExPos, 10.,10.);
556  } else {
557  inbounds = surf.insideBounds(locExPos, 10., 10.);
558  }
560  if (!inbounds) {
561  ATH_MSG_VERBOSE("Extrapolation to layer "<<m_idHelperSvc->toStringGasGap(holeId)
562  <<" is outside of the chamber "<<Amg::toString(locExPos, 2));
563  continue;
564  }
565  parsAtSurfMap[holeId] = std::move(pars);
566  }
567  ClusterLayerMap bestClusterInLay;
569  for (const Prd* hit : prdCandidates) {
570  const Identifier layId = m_idHelperSvc->layerId(hit->identify());
572  LayerParsMap::const_iterator pars_itr = parsAtSurfMap.find(layId);
573  if (pars_itr == parsAtSurfMap.end()) {
574  continue;
575  }
576  const std::unique_ptr<Trk::TrackParameters>& parsInLay{pars_itr->second};
577  std::unique_ptr<MuonClusterOnTrack> calibClus{};
578  if constexpr(std::is_same<Prd, CscPrepData>::value) {
579  calibClus.reset(m_cscRotCreator->createRIO_OnTrack(*hit,
580  parsInLay->position(),
581  parsInLay->momentum().unit()));
582  } else {
583  calibClus.reset(m_clusRotCreator->createRIO_OnTrack(*hit,
584  parsInLay->position(),
585  parsInLay->momentum().unit()));
586  }
587  if (!calibClus) continue;
588 
589  if constexpr (std::is_same<Prd, sTgcPrepData>::value) {
590  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
591  if (idHelper.channelType(hit->identify()) == sTgcIdHelper::sTgcChannelTypes::Pad){
593  const Amg::Vector2D locExPos{parsInLay->parameters()[Trk::locX],
594  parsInLay->parameters()[Trk::locY]};
595 
596  const MuonGM::MuonPadDesign* pad = hit->detectorElement()->getPadDesign(hit->identify());
597  const Amg::Vector2D padDist = pad->distanceToPad(locExPos, idHelper.channel(hit->identify()));
598 
600  const double xCov = std::hypot(Amg::error(*parsInLay->covariance(), Trk::locX),
601  Amg::error(hit->localCovariance(), Trk::locX));
603  const double yCov =Amg::error(*parsInLay->covariance(), Trk::locY);
604 
605  const double xPull = padDist.x() / xCov;
606  const double yPull = padDist.y() / yCov;
607 
608  ATH_MSG_VERBOSE(__func__<<"() - check "<<m_printer->print(*calibClus)
609  <<" diff "<<Amg::toString(padDist, 2)
610  <<" covariance: ("<<xCov<<", "<<yCov<<")"
611  <<" pull: ("<<xPull<<","<<yPull<<").");
612 
614  if (xPull > m_associationPullCutEta || yPull > m_associationPullCutPhi) continue;
615  const double pull = std::hypot(xPull, yPull);
616 
618  PullCluster& bestClus = bestClusterInLay[layId];
619  if (bestClus.pull < pull) continue;
620  bestClus.pull = pull;
621  bestClus.clus = std::move(calibClus);
622  bestClus.pars = parsInLay->uniqueClone();
623  continue;
624  }
625  }
626 
628  std::optional<const Trk::ResidualPull> resPull{
629  m_pullCalculator->residualPull(calibClus.get(), parsInLay.get(),
630  Trk::ResidualPull::Unbiased)};
631  if (!resPull || resPull->pull().empty()) {
632  continue;
633  }
634 
635  const double pull = std::abs(resPull->pull().front());
636  const double pullCut = m_idHelperSvc->measuresPhi(layId) ? m_associationPullCutPhi
637  : m_associationPullCutEta;
638  if (pull > pullCut) continue;
639 
640  PullCluster& bestClus = bestClusterInLay[layId];
641  if (bestClus.pull < pull) continue;
642  bestClus.pull = pull;
643  bestClus.clus = std::move(calibClus);
644  bestClus.pars = parsInLay->uniqueClone();
645 
646  }
648  for (auto& [layerId, foundClus]: bestClusterInLay) {
649  ATH_MSG_VERBOSE(__func__<<"() recovered hit " << m_printer->print(*foundClus.clus)<<" pull: "<<foundClus.pull);
650  std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createMeasTSOS(std::move(foundClus.clus),
651  std::move(foundClus.pars),
652  Trk::TrackStateOnSurface::Measurement);
653  recoveredStates.emplace_back(std::move(tsos));
654  knownLayers.insert(layerId);
655  parsAtSurfMap[layerId].reset();
656  }
658  for (auto& [layerId, exPars] : parsAtSurfMap) {
659  if (!exPars) continue;
660  ATH_MSG_VERBOSE(__func__<<"() add new hole state "<<m_idHelperSvc->toStringGasGap(layerId));
661  recoveredStates.emplace_back(MuonTSOSHelper::createHoleTSOS(std::move(exPars)));
662  }
663  return recoveredStates;
664  }

◆ recoverClusterHits()

void Muon::MuonChamberHoleRecoveryTool::recoverClusterHits ( const EventContext &  ctx,
const Identifier &  chId,
const Trk::TrackParameters &  chambPars,
NewTrackStates &  newStates,
std::set< Identifier > &  knownLayers 
) const
private

Definition at line 324 of file MuonChamberHoleRecoveryTool.cxx.

327  {
328 
329  NewTrackStates recovered{};
330  if (m_idHelperSvc->isRpc(chambId)) {
331  recovered = recoverChamberClusters(ctx, m_key_rpc, chambId, pars, knownLayers);
332  } else if (m_idHelperSvc->isTgc(chambId)) {
333  recovered = recoverChamberClusters(ctx, m_key_tgc, chambId, pars, knownLayers);
334  } else if (m_idHelperSvc->isCsc(chambId)) {
335  recovered = recoverChamberClusters(ctx, m_key_csc, chambId, pars, knownLayers);
336  } else if (m_idHelperSvc->isMM(chambId)) {
337  recovered = recoverChamberClusters(ctx, m_key_mm, chambId, pars, knownLayers);
338  } else if (m_idHelperSvc->issTgc(chambId)) {
339  recovered = recoverChamberClusters(ctx, m_key_stgc, chambId, pars, knownLayers);
340  }
341  states.insert(states.end(), std::make_move_iterator(recovered.begin()),
342  std::make_move_iterator(recovered.end()));
343  }

◆ recoverHitsInChamber()

void Muon::MuonChamberHoleRecoveryTool::recoverHitsInChamber ( const EventContext &  ctx,
RecoveryState &  trkRecov 
) const
private

Loops over all muon hits in a muon chamber and tries to find missed ones by checking each tracking layer for hits.

If a new chamber is reached another iteration of the method is called

Collect all hits in a chamber

New chamber added

Definition at line 193 of file MuonChamberHoleRecoveryTool.cxx.

193  {
194  const Muon::MuonStationIndex::ChIndex currStation = m_idHelperSvc->chamberIndex(trkRecov.tsosId);
196  std::set<Identifier> chambInStation{};
197  do {
198  if (currStation != m_idHelperSvc->chamberIndex(trkRecov.tsosId)) {
199  trkRecov.finalizeChamber();
200  recoverHitsInChamber(ctx, trkRecov);
201  return;
202  }
203  trkRecov.copyState(RecoveryState::CopyTarget::ChamberTrkStates);
205  if (chambInStation.insert(m_idHelperSvc->chamberId(trkRecov.tsosId)).second) {
206  if (m_idHelperSvc->isMdt(trkRecov.tsosId)) {
207  recoverMdtHits(ctx, trkRecov.tsosId, *trkRecov.tsos()->trackParameters(),
208  trkRecov.chamberStates, trkRecov.layersOnTrk);
209  } else {
210  recoverClusterHits(ctx, trkRecov.tsosId, *trkRecov.tsos()->trackParameters(),
211  trkRecov.chamberStates, trkRecov.layersOnTrk);
212  }
213  }
214  } while (getNextMuonMeasurement(trkRecov, RecoveryState::CopyTarget::ChamberTrkStates));
215  trkRecov.finalizeChamber();
216  }

◆ recoverMdtHits()

void Muon::MuonChamberHoleRecoveryTool::recoverMdtHits ( const EventContext &  ctx,
const Identifier &  chId,
const Trk::TrackParameters &  pars,
NewTrackStates &  newStates,
std::set< Identifier > &  knownLayers 
) const
private

calculate Amg::Vector2D using surf to obtain sign

calculate side

update sign

pointer to resPull

Overwrite the previous drift circle if the pull of this one is better or it's an outlier

Definition at line 217 of file MuonChamberHoleRecoveryTool.cxx.

220  {
221 
222 
223  std::set<Identifier> chHoles = holesInMdtChamber(ctx, pars.position(), pars.momentum().unit(), chId, knownLayers);
224  ATH_MSG_VERBOSE(" chamber " << m_idHelperSvc->toStringChamber(chId) << " has holes " << chHoles.size());
225  if (chHoles.empty()) return;
226 
227  const std::vector<const MdtPrepData*> prdCandidates{loadPrepDataHits<MdtPrepData>(ctx, m_key_mdt, chHoles)};
228  bool addedState{false};
229  for (const MdtPrepData* mdtPrd : prdCandidates) {
230  const Trk::StraightLineSurface& surf{mdtPrd->detectorElement()->surface(mdtPrd->identify())};
231  std::unique_ptr<Trk::TrackParameters> exPars = m_extrapolator->extrapolateDirectly(ctx, pars, surf, Trk::anyDirection, false, Trk::muon);
232  if (!exPars) {
233  ATH_MSG_WARNING("Propagation to "<<m_idHelperSvc->toString(mdtPrd->identify())<<" failed.");
234  continue;
235  }
236 
238  Amg::Vector2D locPos{Amg::Vector2D::Zero()};
239  if (!surf.globalToLocal(exPars->position(), exPars->momentum(), locPos)) {
240  ATH_MSG_DEBUG(" failed to calculate drift sign ");
241  continue;
242  }
243  if (!surf.insideBounds(locPos)) {
244  chHoles.erase(mdtPrd->identify());
245  continue;
246  }
247 
248  // calibrate Mdt PRD
249  const Amg::Vector3D momentum = exPars->momentum();
250  std::unique_ptr<MdtDriftCircleOnTrack> mdtROT{m_mdtRotCreator->createRIO_OnTrack(*mdtPrd,
251  exPars->position(),
252  &momentum)};
253  if (!mdtROT) continue;
254 
256  Trk::DriftCircleSide side = locPos[Trk::driftRadius] < 0 ? Trk::LEFT : Trk::RIGHT;
258  m_mdtRotCreator->updateSign(*mdtROT, side);
259 
261  std::optional<const Trk::ResidualPull> resPull{m_pullCalculator->residualPull(mdtROT.get(),
262  exPars.get(),
263  Trk::ResidualPull::Unbiased)};
264  if (!resPull) { continue; }
265 
266  const double pull = resPull->pull().front();
267  const double radialResidual = std::abs(mdtROT->localParameters()[Trk::locR]) -
268  std::abs(exPars->parameters()[Trk::locR]);
269 
270  unsigned int hitFlag = 1;
271  if (mdtPrd->adc() < m_adcCut || mdtPrd->status() != MdtStatusDriftTime)
272  hitFlag = 3; // noise
273  else if (std::abs(pull) < m_associationPullCutEta)
274  hitFlag = 0; // hit on track
275  else if (radialResidual > 0.)
276  hitFlag = 2; // out of time
277 
278  ATH_MSG_VERBOSE(__func__<<"() - Recover "<<m_printer->print(*mdtROT)<<" pull: "<<pull<<" hitFlag: "<<hitFlag);
279  std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createMeasTSOS(std::move(mdtROT),
280  std::move(exPars),
281  (hitFlag != 0 || !m_addMeasurements) ?
282  Trk::TrackStateOnSurface::Outlier :
283  Trk::TrackStateOnSurface::Measurement);
284 
285  if (!addedState) {
286  newStates.emplace_back(std::move(tsos));
287  addedState = true;
288  } else {
289  const MdtDriftCircleOnTrack* prevDC = static_cast<const MdtDriftCircleOnTrack*>(newStates.back()->measurementOnTrack());
290  if (prevDC->identify() != mdtPrd->identify()) {
291  newStates.emplace_back(std::move(tsos));
292  } else {
293  ATH_MSG_DEBUG("Two hits recorded for the same tube "<<std::endl<<
294  " *** current: "<<m_printer->print(*tsos->measurementOnTrack())<<std::endl<<
295  " *** previous: "<<m_printer->print(*prevDC));
296  std::optional<Trk::ResidualPull> prevPullObj{m_pullCalculator->residualPull(prevDC,
297  tsos->trackParameters(),
298  Trk::ResidualPull::Unbiased)};
299  const double prevPull = prevPullObj->pull().front();
301  if (std::abs(pull) < std::abs(prevPull) ||
302  (tsos->type(Trk::TrackStateOnSurface::Measurement) &&
303  newStates.back()->type(Trk::TrackStateOnSurface::Outlier))) {
304  newStates.back() = std::move(tsos);
305  }
306 
307  }
308  }
309  chHoles.erase(mdtPrd->identify());
310  knownLayers.insert(mdtPrd->identify());
311  }
312 
313  for (const Identifier& hole : chHoles) {
314  const Trk::Surface& surf{getDetectorElement(ctx, hole)->surface(hole)};
315  std::unique_ptr<Trk::TrackParameters> exPars = m_extrapolator->extrapolateDirectly(ctx, pars, surf, Trk::anyDirection, false, Trk::muon);
316  if (!exPars) {
317  ATH_MSG_WARNING("Propagation to "<<m_idHelperSvc->toString(hole)<<" failed.");
318  continue;
319  }
320  ATH_MSG_VERBOSE(__func__<<"() - Add hole "<<m_idHelperSvc->toString(hole));
321  newStates.emplace_back(MuonTSOSHelper::createHoleTSOS(std::move(exPars)));
322  }
323  }

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

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_adcCut {this, "AdcCut", 50}
private

Definition at line 197 of file MuonChamberHoleRecoveryTool.h.

◆ m_addMeasurements

Gaudi::Property<bool> Muon::MuonChamberHoleRecoveryTool::m_addMeasurements {this, "AddMeasurements", true}
private

Definition at line 192 of file MuonChamberHoleRecoveryTool.h.

◆ m_associationPullCutEta

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_associationPullCutEta {this, "AssociationPullCutEta", 3}
private

Definition at line 195 of file MuonChamberHoleRecoveryTool.h.

◆ m_associationPullCutPhi

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_associationPullCutPhi {this, "AssociationPullCutPhi", 10}
private

Definition at line 196 of file MuonChamberHoleRecoveryTool.h.

◆ m_chamberGeoKey

SG::ReadCondHandleKey<Muon::MuonIntersectGeoData> Muon::MuonChamberHoleRecoveryTool::m_chamberGeoKey {this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"}
private

Definition at line 190 of file MuonChamberHoleRecoveryTool.h.

◆ m_clusRotCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_clusRotCreator
private
Initial value:
{this, "ClusterRotCreator",
"Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator",
"IMuonClusterOnTrackCreator for RPC, TGC, NSW hits"}

Definition at line 173 of file MuonChamberHoleRecoveryTool.h.

◆ m_cscRotCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_cscRotCreator
private
Initial value:
{
this, "CscRotCreator", "", "IMuonClusterOnTrackCreator for cscs"}

Definition at line 171 of file MuonChamberHoleRecoveryTool.h.

◆ m_detectBadSort

Gaudi::Property<bool> Muon::MuonChamberHoleRecoveryTool::m_detectBadSort {this, "DetectBadSorting", false}
private

Definition at line 193 of file MuonChamberHoleRecoveryTool.h.

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MuonChamberHoleRecoveryTool::m_DetectorManagerKey
private
Initial value:
{this, "DetectorManagerKey", "MuonDetectorManager",
"Key of input MuonDetectorManager condition data"}

Definition at line 179 of file MuonChamberHoleRecoveryTool.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_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> Muon::MuonChamberHoleRecoveryTool::m_edmHelperSvc
private
Initial value:
{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
"Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 158 of file MuonChamberHoleRecoveryTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> Muon::MuonChamberHoleRecoveryTool::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"}
private

Definition at line 167 of file MuonChamberHoleRecoveryTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonChamberHoleRecoveryTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 157 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_csc

SG::ReadHandleKey<Muon::CscPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}
private

Definition at line 183 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_mdt

SG::ReadHandleKey<Muon::MdtPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}
private

Definition at line 182 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_mm

SG::ReadHandleKey<Muon::MMPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}
private

Definition at line 187 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_rpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
private

Definition at line 185 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_stgc

SG::ReadHandleKey<Muon::sTgcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}
private

Definition at line 186 of file MuonChamberHoleRecoveryTool.h.

◆ m_key_tgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}
private

Definition at line 184 of file MuonChamberHoleRecoveryTool.h.

◆ m_mdtRotCreator

ToolHandle<Muon::IMdtDriftCircleOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_mdtRotCreator
private
Initial value:
{this, "MdtRotCreator",
"Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator",
"IMdtDriftCircleOnTrackCreator full calibration"}

Definition at line 168 of file MuonChamberHoleRecoveryTool.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonChamberHoleRecoveryTool::m_printer {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
private

Definition at line 166 of file MuonChamberHoleRecoveryTool.h.

◆ m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> Muon::MuonChamberHoleRecoveryTool::m_pullCalculator
private
Initial value:
{this, "PullCalculator",
"Trk::ResidualPullCalculator/ResidualPullCalculator"}

Definition at line 176 of file MuonChamberHoleRecoveryTool.h.

◆ m_trackingVolumesSvc

ServiceHandle<Trk::ITrackingVolumesSvc> Muon::MuonChamberHoleRecoveryTool::m_trackingVolumesSvc {this, "TrackingVolumesSvc", "TrackingVolumesSvc/TrackingVolumesSvc"}
private

Definition at line 161 of file MuonChamberHoleRecoveryTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
plotting.yearwise_luminosity_vs_mu.comp
comp
Definition: yearwise_luminosity_vs_mu.py:23
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
Muon::MuonChamberHoleRecoveryTool::m_key_mm
SG::ReadHandleKey< Muon::MMPrepDataContainer > m_key_mm
Definition: MuonChamberHoleRecoveryTool.h:187
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
MuonGM::MuonPadDesign
Parameters defining the design of the readout sTGC pads.
Definition: MuonPadDesign.h:40
Muon::MuonChamberHoleRecoveryTool::m_key_stgc
SG::ReadHandleKey< Muon::sTgcPrepDataContainer > m_key_stgc
Definition: MuonChamberHoleRecoveryTool.h:186
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Muon::MuonChamberHoleRecoveryTool::layersOnTrkIds
std::set< Identifier > layersOnTrkIds(const Trk::Track &track) const
Returns a set of all layer Identifiers of the associated track hits.
Definition: MuonChamberHoleRecoveryTool.cxx:156
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
Muon::MuonChamberHoleRecoveryTool::m_addMeasurements
Gaudi::Property< bool > m_addMeasurements
Definition: MuonChamberHoleRecoveryTool.h:192
Muon::MuonChamberHoleRecoveryTool::getNextMuonMeasurement
bool getNextMuonMeasurement(RecoveryState &trkRecov, RecoveryState::CopyTarget target) const
Increments the internal iterator of the RecoveryState until the next muon measurement on track is fou...
Definition: MuonChamberHoleRecoveryTool.cxx:121
Muon::MuonChamberHoleRecoveryTool::recoverChamberClusters
NewTrackStates recoverChamberClusters(const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &prdKey, const Identifier &chambId, const Trk::TrackParameters &parsInChamb, std::set< Identifier > &knownLayers) const
Attempts to recover all missing hits in a chamber.
Definition: MuonChamberHoleRecoveryTool.cxx:527
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
Trk::locX
@ locX
Definition: ParamDefs.h:37
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
Muon::MuonChamberHoleRecoveryTool::loadPrepDataHits
std::vector< const Prd * > loadPrepDataHits(const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd >> &key, const std::set< Identifier > &layerIds) const
Definition: MuonChamberHoleRecoveryTool.cxx:410
sTgcIdHelper::gasGapMax
static int gasGapMax()
Definition: sTgcIdHelper.cxx:1044
TgcIdHelper
Definition: TgcIdHelper.h:50
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Muon::MuonChamberHoleRecoveryTool::m_key_rpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_key_rpc
Definition: MuonChamberHoleRecoveryTool.h:185
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
Muon::MuonChamberHoleRecoveryTool::m_key_mdt
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_key_mdt
Definition: MuonChamberHoleRecoveryTool.h:182
RpcIdHelper::doubletZ
int doubletZ(const Identifier &id) const
Definition: RpcIdHelper.cxx:1061
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
Muon::MuonTSOSHelper::createHoleTSOS
static std::unique_ptr< Trk::TrackStateOnSurface > createHoleTSOS(std::unique_ptr< Trk::TrackParameters > pars)
create a hole TSOS, takes ownership of the pointers
Definition: MuonTSOSHelper.h:92
Muon::MuonChamberHoleRecoveryTool::m_cscRotCreator
ToolHandle< Muon::IMuonClusterOnTrackCreator > m_cscRotCreator
Definition: MuonChamberHoleRecoveryTool.h:171
sTgcIdHelper::gasGapMin
static int gasGapMin()
Definition: sTgcIdHelper.cxx:1042
Trk::ResidualPull::Unbiased
@ Unbiased
RP with track state that has measurement not included.
Definition: ResidualPull.h:57
Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer
@ MuonSpectrometerEntryLayer
Tracking Volume which defines the entrance surfaces of the MS.
Definition: ITrackingVolumesSvc.h:41
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::TrackStateOnSurface::measurementOnTrack
const MeasurementBase * measurementOnTrack() const
returns MeasurementBase const overload
athena.value
value
Definition: athena.py:124
Muon::MuonChamberHoleRecoveryTool::NewTrackStates
std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > NewTrackStates
Definition: MuonChamberHoleRecoveryTool.h:40
Trk::TrkDetElementBase
Definition: TrkDetElementBase.h:52
RpcIdHelper::doubletPhiMax
static int doubletPhiMax()
Definition: RpcIdHelper.cxx:1093
Trk::locR
@ locR
Definition: ParamDefs.h:44
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Muon::MuonChamberHoleRecoveryTool::recoverHitsInChamber
void recoverHitsInChamber(const EventContext &ctx, RecoveryState &trkRecov) const
Loops over all muon hits in a muon chamber and tries to find missed ones by checking each tracking la...
Definition: MuonChamberHoleRecoveryTool.cxx:193
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
RpcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int doubletR, int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const
Definition: RpcIdHelper.cxx:939
sTgcIdHelper::sTgcChannelTypes
sTgcChannelTypes
Definition: sTgcIdHelper.h:190
CaloSwCorrections.gap
def gap(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:212
RpcIdHelper
Definition: RpcIdHelper.h:51
Muon::MuonChamberHoleRecoveryTool::getDetectorElement
const Trk::TrkDetElementBase * getDetectorElement(const EventContext &ctx, const Identifier &id) const
Returns the detector element associated with the muon Identifier.
Definition: MuonChamberHoleRecoveryTool.cxx:354
Muon::MdtStatusDriftTime
@ MdtStatusDriftTime
The tube produced a vaild measurement.
Definition: MdtDriftCircleStatus.h:34
Muon::MuonChamberHoleRecoveryTool::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: MuonChamberHoleRecoveryTool.h:166
Muon::MuonChamberHoleRecoveryTool::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: MuonChamberHoleRecoveryTool.h:167
RpcIdHelper::gasGapMin
static int gasGapMin()
Definition: RpcIdHelper.cxx:1095
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Muon::MuonChamberHoleRecoveryTool::m_associationPullCutEta
Gaudi::Property< double > m_associationPullCutEta
Definition: MuonChamberHoleRecoveryTool.h:195
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
TRT::Hit::side
@ side
Definition: HitInfo.h:83
Muon::MuonChamberHoleRecoveryTool::m_chamberGeoKey
SG::ReadCondHandleKey< Muon::MuonIntersectGeoData > m_chamberGeoKey
Definition: MuonChamberHoleRecoveryTool.h:190
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
Trk::TrackStateOnSurface::type
bool type(const TrackStateOnSurfaceType type) const
Use this method to find out if the TSoS is of a certain type: i.e.
Muon::MuonChamberHoleRecoveryTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonChamberHoleRecoveryTool.h:157
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
Muon::MuonChamberHoleRecoveryTool::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MuonChamberHoleRecoveryTool.h:179
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
Muon::MuonChamberHoleRecoveryTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: MuonChamberHoleRecoveryTool.h:158
Muon::MuonChamberHoleRecoveryTool::m_pullCalculator
ToolHandle< Trk::IResidualPullCalculator > m_pullCalculator
Definition: MuonChamberHoleRecoveryTool.h:176
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
urldecode::states
states
Definition: urldecode.h:39
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:53
Muon::MuonTSOSHelper::createMeasTSOS
static std::unique_ptr< Trk::TrackStateOnSurface > createMeasTSOS(std::unique_ptr< Trk::MeasurementBase > meas, std::unique_ptr< Trk::TrackParameters > pars, Trk::TrackStateOnSurface::TrackStateOnSurfaceType type)
create a TSOS with a measurement, takes ownership of the pointers
Definition: MuonTSOSHelper.h:62
Trk::RIGHT
@ RIGHT
the drift radius is positive (see Trk::AtaStraightLine)
Definition: DriftCircleSide.h:22
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
MdtIdHelper
Definition: MdtIdHelper.h:61
Trk::TrkDetElementBase::surface
virtual const Surface & surface() const =0
Return surface associated with this detector element.
MmIdHelper::gasGapMax
static int gasGapMax()
Definition: MmIdHelper.cxx:827
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:282
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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
Muon::MuonChamberHoleRecoveryTool::m_clusRotCreator
ToolHandle< Muon::IMuonClusterOnTrackCreator > m_clusRotCreator
Definition: MuonChamberHoleRecoveryTool.h:173
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
Muon::MuonChamberHoleRecoveryTool::getHoleLayerIds
std::set< Identifier > getHoleLayerIds(const Identifier &detElId, const std::set< Identifier > &knownLayers) const
Returns a set of all layer Identifiers (GasGap + channel orientation) in a muon chamber of type X exc...
Definition: MuonChamberHoleRecoveryTool.cxx:456
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
TgcIdHelper::gasGapMax
static int gasGapMax(bool triplet)
Definition: TgcIdHelper.cxx:663
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
Trk::MeasurementBase
Definition: MeasurementBase.h:58
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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
RpcIdHelper::gasGapMax
int gasGapMax() const
Definition: RpcIdHelper.cxx:1097
sTgcIdHelper
Definition: sTgcIdHelper.h:55
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Muon::MuonChamberHoleRecoveryTool::recoverMdtHits
void recoverMdtHits(const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &pars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
Definition: MuonChamberHoleRecoveryTool.cxx:217
Trk::DriftCircleSide
DriftCircleSide
Enumerates the 'side' of the wire on which the tracks passed (i.e.
Definition: DriftCircleSide.h:16
Muon::MuonChamberHoleRecoveryTool::m_key_csc
SG::ReadHandleKey< Muon::CscPrepDataContainer > m_key_csc
Definition: MuonChamberHoleRecoveryTool.h:183
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
a
TList * a
Definition: liststreamerinfos.cxx:10
Muon::MuonChamberHoleRecoveryTool::holesInMdtChamber
std::set< Identifier > holesInMdtChamber(const EventContext &ctx, const Amg::Vector3D &position, const Amg::Vector3D &direction, const Identifier &chId, const std::set< Identifier > &tubeIds) const
calculate holes in a given chamber using local straight line extrapolation
Definition: MuonChamberHoleRecoveryTool.cxx:378
h
MmIdHelper
Definition: MmIdHelper.h:54
CscIdHelper
Definition: CscIdHelper.h:52
Amg::intersect
std::optional< double > intersect(const AmgVector(N)&posA, const AmgVector(N)&dirA, const AmgVector(N)&posB, const AmgVector(N)&dirB)
Calculates the point of closest approach of two lines.
Definition: GeoPrimitivesHelpers.h:325
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Muon::MuonChamberHoleRecoveryTool::m_key_tgc
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_key_tgc
Definition: MuonChamberHoleRecoveryTool.h:184
copySelective.target
string target
Definition: copySelective.py:37
Muon::MuonChamberHoleRecoveryTool::m_trackingVolumesSvc
ServiceHandle< Trk::ITrackingVolumesSvc > m_trackingVolumesSvc
Definition: MuonChamberHoleRecoveryTool.h:161
MuonGM::MMReadoutElement
An MMReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station con...
Definition: MMReadoutElement.h:25
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
Muon::MuonChamberHoleRecoveryTool::RecoveryState::CopyTarget::ChamberTrkStates
@ ChamberTrkStates
Muon::MuonChamberHoleRecoveryTool::m_adcCut
Gaudi::Property< double > m_adcCut
Definition: MuonChamberHoleRecoveryTool.h:197
TgcIdHelper::gasGapMin
static int gasGapMin()
Definition: TgcIdHelper.cxx:661
Muon::MuonChamberHoleRecoveryTool::m_mdtRotCreator
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator > m_mdtRotCreator
Definition: MuonChamberHoleRecoveryTool.h:168
Muon::MuonStationIndex::ChIndex
ChIndex
enum to classify the different chamber layers in the muon spectrometer
Definition: MuonStationIndex.h:15
Trk::hole
@ hole
Definition: MeasurementType.h:36
TgcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int gasGap, int isStrip, int channel) const
Definition: TgcIdHelper.cxx:583
Trk::LEFT
@ LEFT
the drift radius is negative (see Trk::AtaStraightLine)
Definition: DriftCircleSide.h:20
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Muon::MuonChamberHoleRecoveryTool::recoverClusterHits
void recoverClusterHits(const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &chambPars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
Definition: MuonChamberHoleRecoveryTool.cxx:324
Muon::MuonChamberHoleRecoveryTool::RecoveryState::CopyTarget::GlobalTrkStates
@ GlobalTrkStates
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Trk::Volume
Definition: Volume.h:35
MuonGM::MuonPadDesign::distanceToPad
Amg::Vector2D distanceToPad(const Amg::Vector2D &pos, int channel) const
Definition: MuonPadDesign.cxx:118
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Muon::MuonChamberHoleRecoveryTool::m_associationPullCutPhi
Gaudi::Property< double > m_associationPullCutPhi
Definition: MuonChamberHoleRecoveryTool.h:196
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
Trk::StraightLineSurface
Definition: StraightLineSurface.h:51
Muon::MuonClusterOnTrack
Base class for Muon cluster RIO_OnTracks.
Definition: MuonClusterOnTrack.h:34
fitman.k
k
Definition: fitman.py:528
MmIdHelper::gasGapMin
static int gasGapMin()
Definition: MmIdHelper.cxx:815
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
RpcIdHelper::doubletPhi
int doubletPhi(const Identifier &id) const
Definition: RpcIdHelper.cxx:1063
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 22:19:13 for ATLAS Offline Software by   doxygen 1.8.18