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

#include <MuonSystemExtensionTool.h>

Inheritance diagram for Muon::MuonSystemExtensionTool:
Collaboration diagram for Muon::MuonSystemExtensionTool:

Public Types

typedef std::vector< MuonLayerSurface > SurfaceVec
 

Public Member Functions

 MuonSystemExtensionTool (const std::string &type, const std::string &name, const IInterface *parent)
 Default AlgTool functions. More...
 
virtual ~MuonSystemExtensionTool ()=default
 
StatusCode initialize () override
 
bool muonSystemExtension (const EventContext &ctx, SystemExtensionCache &cache) const override
 get muon system extension More...
 
bool muonLayerInterSections (const EventContext &ctx, const MuonCombined::TagBase &cmb_tag, SystemExtensionCache &cache) const override
 Constructs the layer intersections from a primary muon track using the track states in the muon spectrometer. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool and IAlgTool interface methods. 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 initializeGeometry ()
 initialize geometry More...
 
bool initializeGeometryBarrel (int sector, const Amg::AngleAxis3D &sectorRotation)
 
bool initializeGeometryEndcap (int sector, MuonStationIndex::DetectorRegionIndex regionIndex, const Amg::AngleAxis3D &sectorRotation)
 
SurfaceVec getSurfacesForIntersection (const Trk::TrackParameters &muonEntryPars, const SystemExtensionCache &cache) const
 get surfaces to be intersected for a given start parameters More...
 
MuonSystemExtension::Intersection makeInterSection (const std::shared_ptr< const Trk::TrackParameters > &pars, const MuonLayerSurface &surf) 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< Trk::IParticleCaloExtensionTool > m_caloExtensionTool
 
ToolHandle< Trk::IExtrapolator > m_extrapolator
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
std::vector< std::vector< SurfaceVec > > m_referenceSurfaces
 reference surfaces per region and sector More...
 
MuonSectorMapping m_sectorMapping
 sector mapping helper More...
 
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 31 of file MuonSystemExtensionTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ SurfaceVec

typedef std::vector<MuonLayerSurface> Muon::MuonSystemExtensionTool::SurfaceVec

Definition at line 33 of file MuonSystemExtensionTool.h.

Constructor & Destructor Documentation

◆ MuonSystemExtensionTool()

Muon::MuonSystemExtensionTool::MuonSystemExtensionTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Default AlgTool functions.

Definition at line 32 of file MuonSystemExtensionTool.cxx.

32  :
33  AthAlgTool(type, name, parent) {
34  declareInterface<IMuonSystemExtensionTool>(this);
35  }

◆ ~MuonSystemExtensionTool()

virtual Muon::MuonSystemExtensionTool::~MuonSystemExtensionTool ( )
virtualdefault

Member Function Documentation

◆ 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

◆ getSurfacesForIntersection()

MuonSystemExtensionTool::SurfaceVec Muon::MuonSystemExtensionTool::getSurfacesForIntersection ( const Trk::TrackParameters &  muonEntryPars,
const SystemExtensionCache &  cache 
) const
private

get surfaces to be intersected for a given start parameters

Look whether one of the sectors has actually a recorded hit

Definition at line 274 of file MuonSystemExtensionTool.cxx.

275  {
276  // if in endcaps pick endcap surfaces
277  const double eta = muonEntryPars.position().eta();
278  MuonStationIndex::DetectorRegionIndex regionIndex = MuonStationIndex::Barrel;
279  if (eta < -1.05) regionIndex = MuonStationIndex::EndcapC;
280  if (eta > 1.05) regionIndex = MuonStationIndex::EndcapA;
281 
282  // in barrel pick primary sector
283  const double phi = muonEntryPars.position().phi();
284  std::vector<int> sectors;
285  m_sectorMapping.getSectors(phi, sectors);
286  SurfaceVec surfaces;
288  if (cache.useHitSectors) {
289  const auto map_itr = cache.sectorsWithHits->find(regionIndex);
290  if (map_itr == cache.sectorsWithHits->end()) {
291  ATH_MSG_DEBUG("No hits in detector region " << Muon::MuonStationIndex::regionName(regionIndex));
292  return surfaces;
293  }
294  std::vector<int>::const_iterator sec_itr = std::find_if(
295  sectors.begin(), sectors.end(), [&map_itr](const int& sector) -> bool { return map_itr->second.count(sector); });
296  if (sec_itr == sectors.end()) {
297  ATH_MSG_DEBUG("No hits found for sector " << m_sectorMapping.getSector(phi) << " in MuonStation "
298  << Muon::MuonStationIndex::regionName(regionIndex));
299  return surfaces;
300  }
301  }
302 
303  for (const int sector : sectors) {
304  surfaces.insert(surfaces.end(), m_referenceSurfaces[regionIndex][sector - 1].begin(),
305  m_referenceSurfaces[regionIndex][sector - 1].end());
306  }
307  auto sortFunction = (regionIndex == MuonStationIndex::Barrel)
308  ? [](const MuonLayerSurface& s1,
309  const MuonLayerSurface& s2) { return s1.surfacePtr->center().perp() < s2.surfacePtr->center().perp(); }
310  : [](const MuonLayerSurface& s1, const MuonLayerSurface& s2) {
311  return std::abs(s1.surfacePtr->center().z()) < std::abs(s2.surfacePtr->center().z());
312  };
313 
314  std::stable_sort(surfaces.begin(), surfaces.end(), sortFunction);
315  return surfaces;
316  }

◆ initialize()

StatusCode Muon::MuonSystemExtensionTool::initialize ( )
override

Definition at line 37 of file MuonSystemExtensionTool.cxx.

37  {
38  ATH_CHECK(m_caloExtensionTool.retrieve());
39  ATH_CHECK(m_extrapolator.retrieve());
40  ATH_CHECK(m_idHelperSvc.retrieve());
41  if (!initializeGeometry()) return StatusCode::FAILURE;
42 
43  return StatusCode::SUCCESS;
44  }

◆ initializeGeometry()

bool Muon::MuonSystemExtensionTool::initializeGeometry ( )
private

initialize geometry

Definition at line 46 of file MuonSystemExtensionTool.cxx.

46  {
47  // initialize reference surfaces hash vectors per region and sector
48  m_referenceSurfaces.resize(MuonStationIndex::DetectorRegionIndexMax);
49  for (auto& vec : m_referenceSurfaces) vec.resize(MuonStationIndex::numberOfSectors());
50 
51  // first build the barrel, we need different reference planes for all sectors
52  ATH_MSG_DEBUG("Initializing barrel ");
53  for (unsigned int sector = 1; sector <= 16; ++sector) {
54  // get rotation into sector frame
55  double sectorPhi = m_sectorMapping.sectorPhi(sector);
56  Amg::AngleAxis3D sectorRotation(sectorPhi, Amg::Vector3D(0., 0., 1.));
57  if (!initializeGeometryBarrel(sector, sectorRotation)) return false;
58 
59  if (!initializeGeometryEndcap(sector, MuonStationIndex::EndcapA, sectorRotation)) return false;
60  if (!initializeGeometryEndcap(sector, MuonStationIndex::EndcapC, sectorRotation)) return false;
61  }
62 
63  return true;
64  }

◆ initializeGeometryBarrel()

bool Muon::MuonSystemExtensionTool::initializeGeometryBarrel ( int  sector,
const Amg::AngleAxis3D &  sectorRotation 
)
private

Definition at line 111 of file MuonSystemExtensionTool.cxx.

111  {
112  MuonChamberLayerDescription chamberLayerDescription;
113 
114  SurfaceVec& surfaces = m_referenceSurfaces[MuonStationIndex::Barrel][sector - 1];
115  constexpr double xToZRotation = -M_PI_2;
116 
117  for (unsigned int stationLayer = MuonStationIndex::BI; stationLayer <= MuonStationIndex::BE; ++stationLayer) {
118  // skip BEE if in small sectors, not installed
119  if (stationLayer == MuonStationIndex::BE && MuonStationIndexHelpers::isSmall(sector)) continue;
120 
121  // calculate reference position from radial position of the laeyr
122  MuonStationIndex::LayerIndex layer = MuonStationIndex::toLayerIndex((MuonStationIndex::StIndex)(stationLayer));
123  MuonChamberLayerDescriptor layerDescriptor = chamberLayerDescription.getDescriptor(sector, MuonStationIndex::Barrel, layer);
124  Amg::Vector3D positionInSector(layerDescriptor.referencePosition, 0., 0.);
125  Amg::Vector3D globalPosition = sectorRotation * positionInSector;
126 
127  // reference transform + surface
128  Amg::Transform3D trans(sectorRotation * Amg::AngleAxis3D(xToZRotation, Amg::Vector3D(0., 1., 0.)));
129  trans.pretranslate(globalPosition);
130  Trk::PlaneSurface* surface = new Trk::PlaneSurface(trans);
131 
132  MuonLayerSurface data(MuonLayerSurface::SurfacePtr(surface), sector, MuonStationIndex::Barrel, layer);
133  surfaces.push_back(std::move(data));
134 
135  // sanity checks
136  if (msgLvl(MSG::VERBOSE)) {
137  Amg::Vector3D lpos3d = surface->transform().inverse() * globalPosition;
138  // Amg::Vector3D lpos3d2 = surface->transform().inverse()*globalPosition2;
139  Amg::Vector2D lpos;
140  surface->globalToLocal(globalPosition, globalPosition, lpos);
141  double sectorPhi = m_sectorMapping.sectorPhi(sector);
142 
143  ATH_MSG_VERBOSE(" sector " << sector << " layer " << MuonStationIndex::layerName(layer) << " phi " << sectorPhi
144  << " ref theta " << globalPosition.theta() << " phi " << globalPosition.phi() << " r "
145  << globalPosition.perp() << " pos " << globalPosition.x() << " " << globalPosition.y() << " "
146  << globalPosition.z() << " lpos3d " << lpos3d.x() << " " << lpos3d.y() << " " << lpos3d.z()
147  << " normal: x " << surface->normal().x() << " y " << surface->normal().y() << " z "
148  << surface->normal().z());
149  }
150  }
151  return true;
152  }

◆ initializeGeometryEndcap()

bool Muon::MuonSystemExtensionTool::initializeGeometryEndcap ( int  sector,
MuonStationIndex::DetectorRegionIndex  regionIndex,
const Amg::AngleAxis3D &  sectorRotation 
)
private

Definition at line 66 of file MuonSystemExtensionTool.cxx.

67  {
68  ATH_MSG_DEBUG("Initializing endcap: sector " << sector << " " << MuonStationIndex::regionName(regionIndex));
69 
70  SurfaceVec& surfaces = m_referenceSurfaces[regionIndex][sector - 1];
71  MuonChamberLayerDescription chamberLayerDescription;
72 
73  static const std::vector<MuonStationIndex::StIndex> layers = {MuonStationIndex::EI, MuonStationIndex::EE, MuonStationIndex::EM,
74  MuonStationIndex::EO};
75 
76  for (const MuonStationIndex::StIndex& stLayer : layers) {
77  // calculate reference position from radial position of the layer
78  MuonStationIndex::LayerIndex layer = MuonStationIndex::toLayerIndex(stLayer);
79  MuonChamberLayerDescriptor layerDescriptor = chamberLayerDescription.getDescriptor(sector, regionIndex, layer);
80  Amg::Vector3D globalPosition(0., 0., layerDescriptor.referencePosition);
81 
82  // reference transform + surface
83  Amg::Transform3D trans(sectorRotation); //*Amg::AngleAxis3D(xToZRotation,Amg::Vector3D(0.,1.,0.)
84  trans.pretranslate(globalPosition);
85 
86  Trk::PlaneSurface* surface = new Trk::PlaneSurface(trans);
87  MuonLayerSurface data(MuonLayerSurface::SurfacePtr(surface), sector, regionIndex, layer);
88  surfaces.push_back(std::move(data));
89 
90  // sanity checks
91  if (msgLvl(MSG::VERBOSE)) {
92  for (unsigned int test = 0; test < 2; ++test) {
93  Amg::Vector3D lpos3d = surface->transform().inverse() * globalPosition;
94  Amg::Vector2D lpos;
95  surface->globalToLocal(globalPosition, globalPosition, lpos);
96 
97  ATH_MSG_VERBOSE(" sector " << sector << " layer " << MuonStationIndex::layerName(layer) << " hit x "
98  << globalPosition.x() << " hit z " << globalPosition.z() << " lpos3d " << lpos3d.x() << " "
99  << lpos3d.y() << " " << lpos3d.z() << " lpos " << lpos[Trk::loc1] << " " << lpos[Trk::loc2]
100  << " center " << surface->center().z() << " normal: phi " << surface->normal().phi()
101  << " theta " << surface->normal().theta() << " normal: x " << surface->normal().x() << " y "
102  << surface->normal().y() << " z " << surface->normal().z());
103  globalPosition[0] += 100;
104  }
105  }
106  }
107  ATH_MSG_VERBOSE(" Total number of surfaces " << surfaces.size());
108  return true;
109  }

◆ 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::IMuonSystemExtensionTool::interfaceID ( )
inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 35 of file IMuonSystemExtensionTool.h.

35  {
36  static const InterfaceID IID_IMuonSystemExtensionTool("Muon::IMuonSystemExtensionTool", 1, 0);
37  return IID_IMuonSystemExtensionTool;
38  }

◆ makeInterSection()

MuonSystemExtension::Intersection Muon::MuonSystemExtensionTool::makeInterSection ( const std::shared_ptr< const Trk::TrackParameters > &  pars,
const MuonLayerSurface &  surf 
) const
private

Definition at line 246 of file MuonSystemExtensionTool.cxx.

246  {
247  if (sharedPtr && it.regionIndex != MuonStationIndex::Barrel) {
248  // in the endcaps we need to update the sector and check that we are in the correct sector
249  double phi = sharedPtr->position().phi();
250  std::vector<int> sectors;
251  m_sectorMapping.getSectors(phi, sectors);
252 
253  // loop over sectors, if the surface sector and the sector in the loop are either both large or small, pick
254  // the sector
255  int sector = -1;
256  for (const int& sec : sectors) {
257  if (it.sector % 2 == sec % 2) {
258  sector = sec;
259  break;
260  }
261  }
262  ATH_MSG_DEBUG(" sector " << it.sector << " selected " << sector << " nsectors " << sectors);
263  // only select if we found a matching sector in the set
264  if (sector != -1) {
265  MuonSystemExtension::Intersection intersection{sharedPtr, it};
266  intersection.layerSurface.sector = sector;
267  return intersection;
268  }
269  return MuonSystemExtension::Intersection{nullptr, it};
270  }
271  return MuonSystemExtension::Intersection{sharedPtr, it};
272  }

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

◆ muonLayerInterSections()

bool Muon::MuonSystemExtensionTool::muonLayerInterSections ( const EventContext &  ctx,
const MuonCombined::TagBase &  cmb_tag,
SystemExtensionCache &  cache 
) const
overridevirtual

Constructs the layer intersections from a primary muon track using the track states in the muon spectrometer.

Get the proper surfaces for the intersections

Copy all track parameters in the MS into a separate vector

Calculate the minimum distance to the plane

We are trying to reconstruct the layer extensions of a combined track. There is no way that this can fail

Implements Muon::IMuonSystemExtensionTool.

Definition at line 317 of file MuonSystemExtensionTool.cxx.

319  {
320 
321  const Trk::Track* cmb_trk = cmb_tag.primaryTrack();
322  if (!cmb_trk){
323  ATH_MSG_WARNING("A combined tag without any track? Please check "<<cmb_tag.toString());
324  return false;
325  }
327  const Trk::TrackParameters* entry_pars = cache.candidate->getCaloExtension()->muonEntryLayerIntersection();
328  const Trk::TrackStates* const cmb_tsos = cmb_trk->trackStateOnSurfaces();
330  std::vector<const Trk::TrackStateOnSurface*> ms_tsos;
331  ms_tsos.reserve(cmb_tsos->size());
332  std::copy_if(cmb_tsos->begin(), cmb_tsos->end(), ms_tsos.end(),[this, entry_pars](const Trk::TrackStateOnSurface* tsos){
333  if (!(tsos->type(Trk::TrackStateOnSurface::Perigee) || tsos->type(Trk::TrackStateOnSurface::Parameter)))
334  return false;
335  const Trk::TrackParameters* params = tsos->trackParameters();
336  if (!params) return false;
337  const Trk::Surface& surf = params->associatedSurface();
338  if (!surf.associatedDetectorElement()) {
339  return entry_pars->associatedSurface().normal().dot(params->position() - entry_pars->associatedSurface().center())>0;
340  }
341  return m_idHelperSvc->isMuon(surf.associatedDetectorElement()->identify());
342  });
343 
344  if (ms_tsos.empty()){
345  ATH_MSG_VERBOSE("A combined track without track parameters in the MS. THat should not happen");
346  return false;
347  }
348 
349  SurfaceVec surfaces = getSurfacesForIntersection(*entry_pars, cache);
350  if (surfaces.empty()) {
351  ATH_MSG_DEBUG("MS extenion without surfaces.. "<<cache.candidate->toString());
352  return false;
353  }
354 
355  std::vector<Muon::MuonSystemExtension::Intersection> intersections;
356 
357  std::vector<const Trk::TrackStateOnSurface*>::const_iterator itr = ms_tsos.begin();
358  std::vector<const Trk::TrackStateOnSurface*>::const_iterator end = ms_tsos.end();
359  for (const Muon::MuonLayerSurface& it : surfaces) {
360  const Trk::Surface& surf = *(it.surfacePtr);
362  itr = std::min_element(itr, end, [&surf](const Trk::TrackStateOnSurface* a, const Trk::TrackStateOnSurface* b) {
363  return std::abs(surf.normal().dot(a->trackParameters()->position() - surf.center())) <
364  std::abs(surf.normal().dot(b->trackParameters()->position() - surf.center()));
365  });
366  const Trk::TrackParameters* trk_pars = (*itr)->trackParameters();
367 
368  const Amg::Vector3D pos = trk_pars->position();
369  const bool isBarrel = it.regionIndex == MuonStationIndex::Barrel;
370  ATH_MSG_VERBOSE("Distance of closest parameters to the surface: "<< std::sqrt(std::abs(surf.normal().dot(pos - surf.center()))));
371 
372 
373 
374  const Trk::PropDirection dir = (isBarrel && pos.perp2() < surf.center().perp2()) ||
375  (!isBarrel && std::abs(pos.z()) < std::abs(surf.center().z()) ) ? Trk::alongMomentum : Trk::oppositeMomentum;
376  std::shared_ptr<const Trk::TrackParameters> exPars{m_extrapolator->extrapolate(ctx, *trk_pars, surf, dir, false, Trk::muon)};
377  if (!exPars) {
378  ATH_MSG_WARNING("Failed to extrapolate track @ "<<to_string(*trk_pars)<<" to surface "<<std::endl<<surf);
379  continue;
380  }
381  MuonSystemExtension::Intersection intersect = makeInterSection(exPars,it);
382  if (intersect.trackParameters) intersections.push_back(std::move(intersect));
383  }
386  if (intersections.empty()) {
387  ATH_MSG_DEBUG("Failed to find the intersections for the combined track");
388  return false;
389  }
390  cache.candidate->setExtension(std::make_unique<MuonSystemExtension>(entry_pars, std::move(intersections)));
391 
392  return true;
393  }

◆ muonSystemExtension()

bool Muon::MuonSystemExtensionTool::muonSystemExtension ( const EventContext &  ctx,
SystemExtensionCache &  cache 
) const
overridevirtual

get muon system extension

Get the calo extension

Implements Muon::IMuonSystemExtensionTool.

Definition at line 154 of file MuonSystemExtensionTool.cxx.

154  {
156  if (!cache.candidate->getCaloExtension()) {
157  if (!cache.extensionContainer) {
158  std::unique_ptr<Trk::CaloExtension> caloExtension =
159  m_caloExtensionTool->caloExtension(ctx, cache.candidate->indetTrackParticle());
160  if (!caloExtension || !caloExtension->muonEntryLayerIntersection()) {
161  ATH_MSG_VERBOSE("Failed to create the calo extension for "<<cache.candidate->toString());
162  return false;
163  }
164  cache.candidate->setExtension(caloExtension);
165  } else {
166  const Trk::CaloExtension* caloExtension = m_caloExtensionTool->caloExtension(cache.candidate->indetTrackParticle(),
167  *cache.extensionContainer);
168  if (!caloExtension || !caloExtension->muonEntryLayerIntersection()) {
169  ATH_MSG_VERBOSE("Failed to create the calo extension for "<<cache.candidate->toString());
170  return false;
171  }
172  cache.candidate->setExtension(caloExtension);
173  }
174  }
175 
176  if (!cache.createSystemExtension) {
177  ATH_MSG_VERBOSE("No system extension is required for "<<cache.candidate->toString());
178  return true;
179  }
180  // get entry parameters, use it as current parameter for the extrapolation
181  const Trk::TrackParameters* currentPars = cache.candidate->getCaloExtension()->muonEntryLayerIntersection();
182 
183  // get reference surfaces
184  ATH_MSG_VERBOSE(" getSurfacesForIntersection " << currentPars);
185  SurfaceVec surfaces = getSurfacesForIntersection(*currentPars, cache);
186 
187  // store intersections
188  std::vector<MuonSystemExtension::Intersection> intersections;
189 
190  // garbage collection
191  std::vector<std::shared_ptr<const Trk::TrackParameters> > trackParametersVec;
192 
193  // loop over reference surfaces
194  for (const Muon::MuonLayerSurface& it : surfaces) {
195  // extrapolate to next layer
196  const Trk::Surface& surface = *it.surfacePtr;
197  ATH_MSG_VERBOSE(" startPars: "<<to_string(*currentPars));
198  ATH_MSG_VERBOSE(" destination: sector " << it.sector << " " << MuonStationIndex::regionName(it.regionIndex) << " "
199  << MuonStationIndex::layerName(it.layerIndex) << " phi " << surface.center().phi()
200  << " r " << surface.center().perp() << " z " << surface.center().z());
201 
202  std::unique_ptr<const Trk::TrackParameters> exPars{
203  m_extrapolator->extrapolate(ctx, *currentPars, surface, Trk::alongMomentum, false, Trk::muon)};
204  if (!exPars) {
205  ATH_MSG_VERBOSE("extrapolation failed, trying next layer ");
206  continue;
207  }
208  ATH_MSG_DEBUG("Extrapolated in event "<<ctx.eventID().event_number()<<" track @ "<<to_string(*exPars));
209 
210  // reject intersections with very big uncertainties (parallel to surface)
211  constexpr double TenMeter = 10. * Gaudi::Units::meter;
212  const double sigma_lx = Amg::error(*exPars->covariance(), Trk::locX);
213  const double sigma_ly = Amg::error(*exPars->covariance(), Trk::locY);
214  if (!Amg::hasPositiveDiagElems(*exPars->covariance()) || std::max(sigma_lx, sigma_ly) > TenMeter){
215  ATH_MSG_DEBUG("Reject bad extrapolation "<<to_string(*exPars));
216  continue;
217  }
218 
219  // create shared pointer and add to garbage collection
220  std::shared_ptr<const Trk::TrackParameters> sharedPtr{std::move(exPars)};
221  trackParametersVec.emplace_back(sharedPtr);
222 
223  MuonSystemExtension::Intersection intersection = makeInterSection(sharedPtr, it);
224  if (intersection.trackParameters) intersections.push_back(std::move(intersection));
225 
226  constexpr double TenCm = 10. * Gaudi::Units::cm;
227  if(std::hypot(sigma_lx, sigma_ly) < std::max(TenCm, 10. * std::hypot(Amg::error(*currentPars->covariance(), Trk::locX),
228  Amg::error(*currentPars->covariance(), Trk::locY)))) {
229  // only update the parameters if errors don't blow up
230  currentPars = sharedPtr.get();
231  } else {
232  ATH_MSG_DEBUG("Extrapolation reached at "<<to_string(*sharedPtr)<<" has larger uncertainties than "<<
233  to_string(*currentPars));
234  }
235  }
236  ATH_MSG_DEBUG("Completed extrapolation: destinations " << surfaces.size() << " intersections " << intersections.size());
237  if (intersections.empty()){
238  ATH_MSG_DEBUG("No system extensions are made for "<<cache.candidate->toString()
239  <<" will accept the candidate: "<< (!cache.requireSystemExtension ? "si": "no"));
240  return !cache.requireSystemExtension;
241  }
242  cache.candidate->setExtension(
243  std::make_unique<MuonSystemExtension>(cache.candidate->getCaloExtension()->muonEntryLayerIntersection(), std::move(intersections)));
244  return true;
245  }

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

ToolHandle<Trk::IParticleCaloExtensionTool> Muon::MuonSystemExtensionTool::m_caloExtensionTool
private
Initial value:
{
this,
"ParticleCaloExtensionTool",
"Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool",
}

Definition at line 60 of file MuonSystemExtensionTool.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_extrapolator

ToolHandle<Trk::IExtrapolator> Muon::MuonSystemExtensionTool::m_extrapolator
private
Initial value:
{
this,
"Extrapolator",
"Trk::Extrapolator/AtlasExtrapolator",
}

Definition at line 65 of file MuonSystemExtensionTool.h.

◆ m_idHelperSvc

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

Definition at line 71 of file MuonSystemExtensionTool.h.

◆ m_referenceSurfaces

std::vector<std::vector<SurfaceVec> > Muon::MuonSystemExtensionTool::m_referenceSurfaces
private

reference surfaces per region and sector

Definition at line 75 of file MuonSystemExtensionTool.h.

◆ m_sectorMapping

MuonSectorMapping Muon::MuonSystemExtensionTool::m_sectorMapping
private

sector mapping helper

Definition at line 78 of file MuonSystemExtensionTool.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:
Muon::MuonStationIndex::BE
@ BE
Definition: MuonStationIndex.h:25
Trk::PlaneSurface::globalToLocal
virtual bool globalToLocal(const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override final
Specified for PlaneSurface: GlobalToLocal method without dynamic memory allocation - boolean checks i...
Definition: PlaneSurface.cxx:213
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
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.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
Muon::MuonStationIndex::EndcapA
@ EndcapA
Definition: MuonStationIndex.h:49
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
Trk::locX
@ locX
Definition: ParamDefs.h:43
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:44
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
Trk::CaloExtension
Tracking class to hold the extrapolation from a particle from the ID to the muon system (or the other...
Definition: CaloExtension.h:18
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Muon::MuonStationIndex::EO
@ EO
Definition: MuonStationIndex.h:26
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Muon::MuonSystemExtensionTool::getSurfacesForIntersection
SurfaceVec getSurfacesForIntersection(const Trk::TrackParameters &muonEntryPars, const SystemExtensionCache &cache) const
get surfaces to be intersected for a given start parameters
Definition: MuonSystemExtensionTool.cxx:274
Muon::MuonSectorMapping::getSectors
void getSectors(double phi, std::vector< int > &sectors) const
returns the main sector plus neighboring if the phi position is in an overlap region
Definition: MuonSectorMapping.h:93
Muon::MuonSystemExtensionTool::m_sectorMapping
MuonSectorMapping m_sectorMapping
sector mapping helper
Definition: MuonSystemExtensionTool.h:78
Muon::MuonStationIndex::LayerIndex
LayerIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:38
module_driven_slicing.layers
layers
Definition: module_driven_slicing.py:114
skel.it
it
Definition: skel.GENtoEVGEN.py:423
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Muon::MuonSystemExtensionTool::initializeGeometry
bool initializeGeometry()
initialize geometry
Definition: MuonSystemExtensionTool.cxx:46
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Muon::MuonSystemExtensionTool::initializeGeometryEndcap
bool initializeGeometryEndcap(int sector, MuonStationIndex::DetectorRegionIndex regionIndex, const Amg::AngleAxis3D &sectorRotation)
Definition: MuonSystemExtensionTool.cxx:66
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Trk::loc2
@ loc2
generic first and second local coordinate
Definition: ParamDefs.h:41
Muon::MuonStationIndex::BI
@ BI
Definition: MuonStationIndex.h:25
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
MuonCombined::TagBase::primaryTrack
virtual const Trk::Track * primaryTrack() const
access to primary muon system track, zero if non available
Definition: TagBase.h:89
TrigInDetValidation_Base.test
test
Definition: TrigInDetValidation_Base.py:144
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
Muon::MuonSystemExtensionTool::m_referenceSurfaces
std::vector< std::vector< SurfaceVec > > m_referenceSurfaces
reference surfaces per region and sector
Definition: MuonSystemExtensionTool.h:75
Trk::CaloExtension::muonEntryLayerIntersection
const TrackParameters * muonEntryLayerIntersection() const
access to intersection with the muon entry layer return NULL if the intersection failed
Definition: CaloExtension.h:70
intersection
std::vector< std::string > intersection(std::vector< std::string > &v1, std::vector< std::string > &v2)
Definition: compareFlatTrees.cxx:25
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
Muon::MuonSectorMapping::getSector
int getSector(double phi) const
returns the sector corresponding to the phi position
Definition: MuonSectorMapping.h:82
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Muon::MuonStationIndex::numberOfSectors
static unsigned int numberOfSectors()
return total number of sectors
Definition: MuonStationIndex.h:106
Muon::MuonSystemExtensionTool::SurfaceVec
std::vector< MuonLayerSurface > SurfaceVec
Definition: MuonSystemExtensionTool.h:33
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
Trk::PropDirection
PropDirection
Definition: PropDirection.h:19
Muon::MuonStationIndex::regionName
static const std::string & regionName(DetectorRegionIndex index)
convert DetectorRegionIndex into a string
Definition: MuonStationIndex.cxx:176
AthCommonDataStore
Definition: AthCommonDataStore.h:52
python.SystemOfUnits.meter
int meter
Definition: SystemOfUnits.py:61
Muon::MuonSystemExtensionTool::initializeGeometryBarrel
bool initializeGeometryBarrel(int sector, const Amg::AngleAxis3D &sectorRotation)
Definition: MuonSystemExtensionTool.cxx:111
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Muon::MuonLayerSurface
types
Definition: MuonLayerSurface.h:15
Muon::MuonStationIndex::EI
@ EI
Definition: MuonStationIndex.h:26
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Muon::MuonStationIndex::Barrel
@ Barrel
Definition: MuonStationIndex.h:49
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Muon::MuonSystemExtensionTool::makeInterSection
MuonSystemExtension::Intersection makeInterSection(const std::shared_ptr< const Trk::TrackParameters > &pars, const MuonLayerSurface &surf) const
Definition: MuonSystemExtensionTool.cxx:246
Muon::MuonLayerSurface::SurfacePtr
std::shared_ptr< const Trk::Surface > SurfacePtr
Definition: MuonLayerSurface.h:16
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AnalysisUtils::copy_if
Out copy_if(In first, const In &last, Out res, const Pred &p)
Definition: IFilterUtils.h:30
Trk::Surface::normal
virtual const Amg::Vector3D & normal() const
Returns the normal vector of the Surface (i.e.
Muon::MuonSectorMapping::sectorPhi
double sectorPhi(int sector) const
returns the centeral phi position of a sector in radians
Definition: MuonSectorMapping.h:77
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::MuonStationIndex::layerName
static const std::string & layerName(LayerIndex index)
convert LayerIndex into a string
Definition: MuonStationIndex.cxx:192
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
Trk::muon
@ muon
Definition: ParticleHypothesis.h:28
Muon::MuonStationIndex::toLayerIndex
static LayerIndex toLayerIndex(ChIndex index)
convert ChIndex into LayerIndex
Definition: MuonStationIndex.cxx:56
DataVector< const Trk::TrackStateOnSurface >
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
beamspotman.dir
string dir
Definition: beamspotman.py:623
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
Muon::MuonStationIndex::DetectorRegionIndex
DetectorRegionIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:47
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:192
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
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
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Muon::MuonStationIndex::DetectorRegionIndexMax
@ DetectorRegionIndexMax
Definition: MuonStationIndex.h:50
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
MuonCombined::TagBase::toString
virtual std::string toString() const =0
print content to string
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
a
TList * a
Definition: liststreamerinfos.cxx:10
h
Amg::intersect
std::optional< double > intersect(const AmgVector(N)&posA, const AmgVector(N)&dirA, const AmgVector(N)&posB, const AmgVector(N)&dirB)
Calculates the closest approach of two lines.
Definition: GeoPrimitivesHelpers.h:302
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Muon::MuonStationIndex::EndcapC
@ EndcapC
Definition: MuonStationIndex.h:49
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
Muon::MuonSystemExtensionTool::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: MuonSystemExtensionTool.h:65
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Muon::MuonStationIndexHelpers::isSmall
static bool isSmall(int sector)
returns whether a sector is small
Definition: MuonStationIndexHelpers.cxx:26
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition: GeoPrimitives.h:45
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:790
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
Muon::MuonSystemExtensionTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonSystemExtensionTool.h:71
Muon::MuonStationIndex::EE
@ EE
Definition: MuonStationIndex.h:26
Trk::loc1
@ loc1
Definition: ParamDefs.h:40
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
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
Muon::MuonSystemExtensionTool::m_caloExtensionTool
ToolHandle< Trk::IParticleCaloExtensionTool > m_caloExtensionTool
Definition: MuonSystemExtensionTool.h:60
Muon::MuonStationIndex::EM
@ EM
Definition: MuonStationIndex.h:26
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
Generated on Fri Jun 28 2024 22:22:38 for ATLAS Offline Software by   doxygen 1.8.18