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::MuonPatternCalibration Class Reference

#include <MuonPatternCalibration.h>

Inheritance diagram for Muon::MuonPatternCalibration:
Collaboration diagram for Muon::MuonPatternCalibration:

Classes

struct  EtaPhiHits
 
struct  Region
 

Public Types

using ISPrd = std::pair< Amg::Vector3D, const MuonCluster * >
 
using ISPrdVec = std::vector< ISPrd >
 
using ISPrdMdt = std::pair< Amg::Vector3D, const MdtPrepData * >
 
using ISPrdMdtVec = std::vector< ISPrdMdt >
 
using RegionIdMap = std::map< int, ISPrdMdtVec >
 
using RegionMap = std::map< int, Region >
 
using ClusterVec = std::vector< const MuonClusterOnTrack * >
 
using MdtVec = std::vector< const MdtDriftCircleOnTrack * >
 
using MdtVecVec = std::vector< MdtVec >
 
using ROTsPerRegion = std::vector< ROTRegion >
 

Public Member Functions

 MuonPatternCalibration (const std::string &, const std::string &, const IInterface *)
 
virtual ~MuonPatternCalibration ()=default
 
virtual StatusCode initialize () override
 
StatusCode calibrate (const EventContext &ctx, const MuonPatternCombination &pat, ROTsPerRegion &hitsPerRegion) const override
 
int getRegionId (const Identifier &id) const override
 
bool checkForPhiMeasurements (const MuonPatternCombination &pat) const override
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 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

StatusCode createRegionMap (const EventContext &ctx, const MuonPatternCombination &pat, RegionMap &regionMap, bool hasPhiMeasurements) const
 
void printRegionMap (const RegionMap &regionMap) const
 
void calibrateRegionMap (const RegionMap &regionMap, IMuonPatternCalibration::ROTsPerRegion &hitsPerRegion) const
 
void insertCluster (const MuonCluster &mdt, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
 
void insertMdt (const MdtPrepData &clus, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
 
template<class ContType >
StatusCode loadFromStoreGate (const EventContext &ctx, const SG::ReadHandleKey< ContType > &key, const ContType *&cont_ptr) const
 load the container from storegate given a ReadHandleKey. More...
 
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< IMdtDriftCircleOnTrackCreator > m_mdtCreator
 
ToolHandle< IMuonClusterOnTrackCreator > m_clusterCreator
 
PublicToolHandle< MuonEDMPrinterTool > m_printer
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
Gaudi::Property< bool > m_doMultiAnalysis {this, "DoMultiChamberAnalysis", true}
 
Gaudi::Property< double > m_dropDistance {this, "DropDistance", 1500.}
 
Gaudi::Property< double > m_phiAngleCut {this, "AngleCutPhi", 1.e9}
 
Gaudi::Property< bool > m_doSummary {this, "DoSummary", false}
 
Gaudi::Property< bool > m_recoverTriggerHits {this, "RecoverTriggerHits", true}
 
Gaudi::Property< bool > m_removeDoubleMdtHits {this, "RemoveDoubleMdtHits", true}
 
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_keyRpc {this, "RpcPrepDataContainer","RPC_Measurements"}
 
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_keyTgc {this, "TgcPrepDataContainer","TGC_Measurements"}
 
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 30 of file MuonPatternCalibration.h.

Member Typedef Documentation

◆ ClusterVec

using Muon::IMuonPatternCalibration::ClusterVec = std::vector<const MuonClusterOnTrack*>
inherited

Definition at line 26 of file IMuonPatternCalibration.h.

◆ ISPrd

using Muon::MuonPatternCalibration::ISPrd = std::pair<Amg::Vector3D, const MuonCluster*>

Definition at line 32 of file MuonPatternCalibration.h.

◆ ISPrdMdt

using Muon::MuonPatternCalibration::ISPrdMdt = std::pair<Amg::Vector3D, const MdtPrepData*>

Definition at line 35 of file MuonPatternCalibration.h.

◆ ISPrdMdtVec

using Muon::MuonPatternCalibration::ISPrdMdtVec = std::vector<ISPrdMdt>

Definition at line 36 of file MuonPatternCalibration.h.

◆ ISPrdVec

using Muon::MuonPatternCalibration::ISPrdVec = std::vector<ISPrd>

Definition at line 33 of file MuonPatternCalibration.h.

◆ MdtVec

using Muon::IMuonPatternCalibration::MdtVec = std::vector<const MdtDriftCircleOnTrack*>
inherited

Definition at line 27 of file IMuonPatternCalibration.h.

◆ MdtVecVec

using Muon::IMuonPatternCalibration::MdtVecVec = std::vector<MdtVec>
inherited

Definition at line 28 of file IMuonPatternCalibration.h.

◆ RegionIdMap

using Muon::MuonPatternCalibration::RegionIdMap = std::map<int, ISPrdMdtVec>

Definition at line 37 of file MuonPatternCalibration.h.

◆ RegionMap

using Muon::MuonPatternCalibration::RegionMap = std::map<int, Region>

Definition at line 49 of file MuonPatternCalibration.h.

◆ ROTsPerRegion

using Muon::IMuonPatternCalibration::ROTsPerRegion = std::vector<ROTRegion>
inherited

Definition at line 55 of file IMuonPatternCalibration.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonPatternCalibration()

Muon::MuonPatternCalibration::MuonPatternCalibration ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 22 of file MuonPatternCalibration.cxx.

23  : AthAlgTool(t, n, p) {
24  declareInterface<IMuonPatternCalibration>(this);
25 }

◆ ~MuonPatternCalibration()

virtual Muon::MuonPatternCalibration::~MuonPatternCalibration ( )
virtualdefault

Member Function Documentation

◆ calibrate()

StatusCode Muon::MuonPatternCalibration::calibrate ( const EventContext &  ctx,
const MuonPatternCombination &  pat,
ROTsPerRegion &  hitsPerRegion 
) const
overridevirtual

Implements Muon::IMuonPatternCalibration.

Definition at line 42 of file MuonPatternCalibration.cxx.

42  {
43  Muon::MuonPatternCalibration::RegionMap regionMap;
44  bool hasPhiMeasurements = checkForPhiMeasurements(pattern);
45  ATH_CHECK(createRegionMap(ctx, pattern, regionMap, hasPhiMeasurements));
46  // calibrate hits
47  calibrateRegionMap(regionMap, hitsPerRegion);
48  return StatusCode::SUCCESS;
49 }

◆ calibrateRegionMap()

void Muon::MuonPatternCalibration::calibrateRegionMap ( const RegionMap &  regionMap,
IMuonPatternCalibration::ROTsPerRegion &  hitsPerRegion 
) const
private

Definition at line 431 of file MuonPatternCalibration.cxx.

432  {
433 
434 
435  for (const auto& [regionId, regMeasColl] : regionMap) {
436 
437  ROTRegion rotRegion{};
438  rotRegion.regionId = regionId;
439  rotRegion.regionPos = regMeasColl.regionPos;
440  rotRegion.regionDir = regMeasColl.regionDir;
441 
442  for (const auto& [globalPos, prd] : regMeasColl.triggerPrds) {
443  std::unique_ptr<const MuonClusterOnTrack> cluster{m_clusterCreator->createRIO_OnTrack(*prd, globalPos)};
444  if (!cluster) continue;
445  rotRegion.push_back(std::move(cluster));
446  }
447  for (const auto& [regionId, MdtsWithIsect] :regMeasColl.mdtPrdsPerChamber) {
448  ATH_MSG_VERBOSE("Run over region id "<<regionId);
449  MdtVec mdtROTs{};
450  for (const auto& [globalPos, prd] : MdtsWithIsect) {
451  ATH_MSG_VERBOSE("Calibrate prd"<<m_idHelperSvc->toString(prd->identify())
452  <<",tdc: "<<prd->tdc()<<",adc: "<<prd->adc()<<" at "<<Amg::toString(globalPos));
453  const MdtDriftCircleOnTrack* mdt = m_mdtCreator->createRIO_OnTrack(*prd, globalPos, &globalPos);
454  if (!mdt) {
455  ATH_MSG_VERBOSE("Failed to calibrate " << m_idHelperSvc->toString(prd->identify()));
456  continue;
457  }
458  mdtROTs.push_back(mdt);
459  }
460  if (!mdtROTs.empty()) rotRegion.push_back(std::move(mdtROTs));
461  }
462  hitsPerRegion.push_back(std::move(rotRegion));
463  }
464 }

◆ checkForPhiMeasurements()

bool Muon::MuonPatternCalibration::checkForPhiMeasurements ( const MuonPatternCombination &  pat) const
overridevirtual

Exclude the sTGC hits. MM hits do not have phi measurements

Implements Muon::IMuonPatternCalibration.

Definition at line 61 of file MuonPatternCalibration.cxx.

61  {
62 
63  for (const MuonPatternChamberIntersect& intersect : pat.chamberData()) {
64  for (const Trk::PrepRawData* prd : intersect.prepRawDataVec()){
65  const Identifier id = prd->identify();
67  if (!m_idHelperSvc->issTgc(id) &&
68  m_idHelperSvc->measuresPhi(id)) return true;
69  }
70  }
71  return false;
72 }

◆ createRegionMap()

StatusCode Muon::MuonPatternCalibration::createRegionMap ( const EventContext &  ctx,
const MuonPatternCombination &  pat,
RegionMap &  regionMap,
bool  hasPhiMeasurements 
) const
private

Try to recover missing phi clusters:

  • loop over the clusters in the region and sort them by collection
  • count the number of eta and phi clusters per collection

Remove the NSW hits from the segment building

Definition at line 75 of file MuonPatternCalibration.cxx.

77 {
78  if (hasPhiMeasurements)
79  ATH_MSG_DEBUG("pattern has phi measurements using extrapolation to determine second coordinate");
80  else
81  ATH_MSG_DEBUG("No phi measurements using center tubes");
82 
83 
84  const Muon::TgcPrepDataContainer* tgcPrdCont{nullptr};
85  const Muon::RpcPrepDataContainer* rpcPrdCont{nullptr};
86  ATH_CHECK(loadFromStoreGate(ctx, m_keyRpc, rpcPrdCont));
87  ATH_CHECK(loadFromStoreGate(ctx, m_keyTgc, tgcPrdCont));
88 
89  for (const MuonPatternChamberIntersect& isect : pat.chamberData()) {
90 
91  if (isect.prepRawDataVec().empty()) continue;
92 
93  const Amg::Vector3D& patpose = isect.intersectPosition();
94  const Amg::Vector3D patdire = isect.intersectDirection().unit();
95 
101  std::map<int, EtaPhiHits> etaPhiHitsPerChamber;
102  std::set<Identifier> clusterIds;
103 
104 
105  const Trk::PrepRawData* prd = isect.prepRawDataVec().front();
106  const Identifier id = prd->identify();
107 
108  // apply cut on the opening angle between pattern and chamber phi
109  // do some magic to avoid problems at phi = 0 and 2*pi
110  double phiStart = patdire.phi();
111  double chPhi = prd->detectorElement()->center().phi();
112  constexpr double phiRange = 0.75 * M_PI;
113  constexpr double phiRange2 = 0.25 * M_PI;
114  double phiOffset = 0.;
115  if (phiStart > phiRange || phiStart < -phiRange)
116  phiOffset = 2 * M_PI;
117  else if (phiStart > -phiRange2 && phiStart < phiRange2)
118  phiOffset = M_PI;
119 
120  if (phiOffset > 1.5 * M_PI) {
121  if (phiStart < 0) phiStart += phiOffset;
122  if (chPhi < 0) chPhi += phiOffset;
123  } else if (phiOffset > 0.) {
124  phiStart += phiOffset;
125  chPhi += phiOffset;
126  }
127  double dphi = std::abs(phiStart - chPhi);
128 
129  if (dphi > m_phiAngleCut) {
130  ATH_MSG_DEBUG("Large angular phi difference between pattern and chamber, phi pattern "
131  << patdire.phi() << " phi chamber " << prd->detectorElement()->center().phi());
132  continue;
133  }
134 
135  // map to find duplicate hits in the chamber
136  std::map<Identifier, const MdtPrepData*> idMdtMap{};
137 
138  for (const Trk::PrepRawData* isect_prd : isect.prepRawDataVec()) {
139 
140  if (isect_prd->type(Trk::PrepRawDataType::MdtPrepData)) {
141  const MdtPrepData* mdt = dynamic_cast<const MdtPrepData*>(isect_prd);
142  if (m_removeDoubleMdtHits) {
143  const MdtPrepData*& previousMdt = idMdtMap[mdt->identify()];
144  if (!previousMdt || previousMdt->tdc() > mdt->tdc())
145  previousMdt = mdt;
146  else
147  continue;
148  }
149  insertMdt(*mdt, regionMap, patpose, patdire, hasPhiMeasurements);
150  continue;
151  }
152  else if (isect_prd->type(Trk::PrepRawDataType::MMPrepData) || isect_prd->type(Trk::PrepRawDataType::sTgcPrepData)){
153  continue;
154  }
155  const MuonCluster* clus = dynamic_cast<const MuonCluster*>(isect_prd);
156  if (!clus) continue;
157  const Identifier id = clus->identify();
158  if (!clusterIds.insert(id).second) continue;
159 
160  if (m_recoverTriggerHits) {
161  bool measuresPhi = m_idHelperSvc->measuresPhi(id);
162  int colHash = clus->collectionHash();
163  EtaPhiHits& hitsPerChamber = etaPhiHitsPerChamber[colHash];
164  if (measuresPhi)
165  ++hitsPerChamber.nphi;
166  else
167  ++hitsPerChamber.neta;
168  }
169  insertCluster(*clus, regionMap, patpose, patdire, hasPhiMeasurements);
170  }
171  for (const auto& [coll_hash, hits] : etaPhiHitsPerChamber) {
172  if ((hits.neta > 0 && hits.nphi == 0) || (hits.nphi > 0 && hits.neta == 0)) {
173  if (m_idHelperSvc->isRpc(id) && rpcPrdCont) {
174 
175  const Muon::RpcPrepDataCollection* prd_coll = rpcPrdCont->indexFindPtr(coll_hash);
176  if (!prd_coll) {
177  ATH_MSG_VERBOSE("RpcPrepDataCollection not found in container!!"<< m_keyRpc);
178  continue;
179  }
180  for (const Muon::RpcPrepData* rpc_prd : *prd_coll) {
181  if (!clusterIds.insert(rpc_prd->identify()).second) continue;
182  insertCluster(*rpc_prd, regionMap, patpose, patdire, hasPhiMeasurements);
183  }
184  } else if (m_idHelperSvc->isTgc(id) && tgcPrdCont) {
185  const Muon::TgcPrepDataCollection* prd_coll = tgcPrdCont->indexFindPtr(coll_hash);
186  if (!prd_coll) {
187  ATH_MSG_DEBUG("TgcPrepDataCollection not found in container!! "<< m_keyTgc);
188  continue;
189  }
190 
191  for (const Muon::TgcPrepData* tgc_prd : *prd_coll) {
192  if (!clusterIds.insert(tgc_prd->identify()).second) continue;
193  insertCluster(*tgc_prd, regionMap, patpose, patdire, hasPhiMeasurements);
194  }
195  }
196  }
197  }
198  }
199  return StatusCode::SUCCESS;
200 }

◆ 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

◆ getRegionId()

int Muon::MuonPatternCalibration::getRegionId ( const Identifier &  id) const
overridevirtual

Implements Muon::IMuonPatternCalibration.

Definition at line 52 of file MuonPatternCalibration.cxx.

52  {
53 
54  // simple division of MuonSpectrometer in regions using barrel/endcap seperation plus
55  // inner/middle/outer seperation
56  return m_idHelperSvc->stationIndex(id)* ( m_idHelperSvc->stationEta(id) > 0 ? 1 : -1);
57 }

◆ initialize()

StatusCode Muon::MuonPatternCalibration::initialize ( )
overridevirtual

Definition at line 28 of file MuonPatternCalibration.cxx.

29 {
30  ATH_MSG_VERBOSE("MuonPatternCalibration::Initializing");
31  ATH_CHECK(m_mdtCreator.retrieve());
32  ATH_CHECK(m_printer.retrieve());
33  ATH_CHECK(m_idHelperSvc.retrieve());
34  ATH_CHECK(m_clusterCreator.retrieve());
35  ATH_CHECK(m_keyRpc.initialize());
36  ATH_CHECK(m_keyTgc.initialize());
37  return StatusCode::SUCCESS;
38 }

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

◆ insertCluster()

void Muon::MuonPatternCalibration::insertCluster ( const MuonCluster &  mdt,
RegionMap &  regionMap,
const Amg::Vector3D &  patpose,
const Amg::Vector3D &  patdire,
bool  hasPhiMeasurements 
) const
private

Definition at line 203 of file MuonPatternCalibration.cxx.

205 {
206 
207  const Identifier id = clus.identify();
208  // check whether we are measuring phi or eta
209  const bool measuresPhi = m_idHelperSvc->measuresPhi(id);
210 
211  Amg::Vector3D globalpos = clus.globalPosition();
212  Amg::Vector3D intersect{Amg::Vector3D::Zero()};
213 
214  if (hasPhiMeasurements) {
215  // if there is a phi measurement in the pattern use the global direction to calculate the intersect with
216  // measurement plane and use the intersect to calculate the position along the strip
217 
218  // calculate intersect pattern measurement plane
219  const Trk::Surface& surf = clus.detectorElement()->surface(id);
220  Amg::Vector3D planepostion = surf.center();
221  Amg::Vector3D planenormal = surf.normal();
222  double denom = patdire.dot(planenormal);
223  double u = (planenormal.dot(planepostion - patpose)) / (denom);
224  Amg::Vector3D piOnPlane = (patpose + u * patdire);
225 
226  // transform to local plane coordiantes
227  const Amg::Transform3D gToLocal = clus.detectorElement()->surface().transform().inverse();
228  Amg::Vector3D ilpos = gToLocal * piOnPlane;
229  Amg::Vector3D glpos = gToLocal * globalpos;
230 
231  // strip length
232  double striplen(0.);
233 
234  // projective strips
235  bool hasPointingPhiStrips = false;
236 
237  // detector specific stuff
238  const RpcPrepData* rpc = dynamic_cast<const RpcPrepData*>(&clus);
239  if (rpc) {
240  striplen = rpc->detectorElement()->StripLength(measuresPhi);
241  } else {
242  const TgcPrepData* tgc = dynamic_cast<const TgcPrepData*>(&clus);
243  if (!tgc) return;
244 
245  int gasGap = m_idHelperSvc->tgcIdHelper().gasGap(id);
246  if (measuresPhi) {
247  hasPointingPhiStrips = true;
248  striplen = tgc->detectorElement()->stripLength();
249  } else {
250  int wire = m_idHelperSvc->tgcIdHelper().channel(id);
251  striplen = tgc->detectorElement()->gangCentralWidth(gasGap, wire);
252  }
253  }
254 
255  // set the position along the strip
256  if (!measuresPhi) {
257  glpos[0] = ilpos.x();
258  } else {
259  if (hasPointingPhiStrips) {
260  // do some special for tgcs
261  glpos[1] = ilpos.y();
262  } else {
263  glpos[1] = ilpos.y();
264  }
265  }
266 
267  // transform back to global coordinates
268  intersect = gToLocal.inverse() * glpos;
269  Amg::Vector3D dif = globalpos - intersect;
270  if ((intersect - piOnPlane).mag() > m_dropDistance || dif.mag() > 0.5 * striplen + m_dropDistance) {
271 
272  ATH_MSG_VERBOSE(">>>> extrapolated position far outside volume, dropping hit "
273  << m_idHelperSvc->toString(id) << ". dist along strip " << dif.mag() << " 1/2 strip len "
274  << 0.5 * striplen << " dist measurement plane " << (intersect - piOnPlane).mag());
275  return;
276  }
277  if (dif.mag() > 0.5 * striplen) {
278  Amg::Vector3D newpos = globalpos - dif * (0.5 * striplen / dif.mag());
279 
280  ATH_MSG_VERBOSE(">>>> extrapolated position outside volume, shifting position "
281  << m_idHelperSvc->toString(id) << ". position along strip " << dif.mag() << " 1/2 tube len "
282  << 0.5 * striplen << " dist To strip " << (intersect - piOnPlane).mag()
283  << ". dist to newpos " << (newpos - globalpos).mag() << " pos " << newpos);
284 
285  intersect = newpos;
286  }
287  } else {
288  // no phi measurements, use strip center
289  intersect = globalpos;
290  }
291 
292  // enter hit in map
293  int regionId = getRegionId(id);
294 
295  Region& region = regionMap[regionId];
296  if (!region.init) {
297  region.regionDir = patdire;
298  region.regionPos = patpose;
299  region.init = true;
300  }
301  region.triggerPrds.emplace_back(intersect, &clus);
302 }

◆ insertMdt()

void Muon::MuonPatternCalibration::insertMdt ( const MdtPrepData &  clus,
RegionMap &  regionMap,
const Amg::Vector3D &  patpose,
const Amg::Vector3D &  patdire,
bool  hasPhiMeasurements 
) const
private

Definition at line 306 of file MuonPatternCalibration.cxx.

308 {
309 
310  Amg::Vector3D intersect{Amg::Vector3D::Zero()};
311  const Identifier& id = mdt.identify();
312 
313  const MuonGM::MdtReadoutElement* detEl = mdt.detectorElement();
314  const Amg::Vector3D& tubePos = mdt.globalPosition();
315 
316  if (hasPhiMeasurements) {
317  // if there is a phi measurement in the pattern use the global direction to calculate the intersect with the
318  // tube use the intersect to calculate the second coordinate
319 
320  const Amg::Transform3D amdbToGlobal = detEl->AmdbLRSToGlobalTransform();
321 
322 
323  // calculate intersect pattern measurement plane
324  const Amg::Vector3D& planepostion = tubePos;
325 
326  // always project on plane with normal in radial direction
327  Amg::Vector3D planenormal = m_idHelperSvc->mdtIdHelper().isBarrel(id)
328  ? amdbToGlobal.linear() * Amg::Vector3D(0., 0., 1.)
329  : amdbToGlobal.linear() * Amg::Vector3D(0., 1., 0.);
330 
331  double denom = patdire.dot(planenormal);
332  double u = (planenormal.dot(planepostion - patpose)) / (denom);
333  Amg::Vector3D piOnPlane = (patpose + u * patdire);
334 
335  Amg::Vector3D lpiOnPlane = amdbToGlobal.inverse() * piOnPlane;
336  Amg::Vector3D ltubePos = amdbToGlobal.inverse() * tubePos;
337 
338  intersect = amdbToGlobal * Amg::Vector3D(lpiOnPlane.x(), ltubePos.y(), ltubePos.z());
339 
340  Amg::Vector3D dif = tubePos - intersect;
341  double tubelen = detEl->getActiveTubeLength(m_idHelperSvc->mdtIdHelper().tubeLayer(id),
342  m_idHelperSvc->mdtIdHelper().tube(id));
343 
344  if (dif.mag() > 0.5 * tubelen) {
345  Amg::Vector3D newpos = tubePos - dif * (0.5 * tubelen / dif.mag());
346 
347  ATH_MSG_VERBOSE(">>>> extrapolated position outside volume, shifting position "
348  << m_idHelperSvc->toString(id) << ". position along strip " << dif.mag() << " 1/2 tube len "
349  << 0.5 * tubelen << " dist To Wire " << (piOnPlane - intersect).mag() << ". dist to newpos "
350  << (newpos - tubePos).mag() << " pos " << newpos);
351 
352  intersect = newpos;
353  }
354  } else {
355  // not phi measurement, use tube center
356  intersect = tubePos;
357  }
358 
359  // enter hit in map
360  Identifier elId = m_idHelperSvc->mdtIdHelper().elementID(id);
361 
362  MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(elId);
363  int chFlag = elId.get_identifier32().get_compact();
364  if (m_doMultiAnalysis) {
365  if (m_idHelperSvc->isSmallChamber(id)) {
366  ATH_MSG_VERBOSE(" Small chamber " << m_idHelperSvc->toString(elId));
367  chFlag = 0;
368  if (chIndex == MuonStationIndex::BIS) {
369  int eta = m_idHelperSvc->stationEta(elId);
370  if (std::abs(eta) == 8) {
371  ATH_MSG_VERBOSE(" BIS8 chamber " << m_idHelperSvc->toString(elId));
372  chFlag = 3;
373  }
374  }
375  } else {
376  ATH_MSG_VERBOSE(" Large chamber " << m_idHelperSvc->toString(elId));
377  chFlag = 1;
378  if (chIndex == MuonStationIndex::BIL) {
379  std::string stName = m_idHelperSvc->chamberNameString(id);
380  if (stName[2] == 'R') {
381  ATH_MSG_VERBOSE(" BIR chamber " << m_idHelperSvc->toString(elId));
382  chFlag = 2;
383  }
384  } else if (chIndex == MuonStationIndex::BOL) {
385  if (std::abs(m_idHelperSvc->stationEta(id)) == 7) {
386  ATH_MSG_VERBOSE(" BOE chamber " << m_idHelperSvc->toString(elId));
387  chFlag = 4;
388  }
389  }
390  }
391  int phi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
392 
393  chFlag += 10 * phi;
394  }
395  // use center tube for region assignment
396  int regionId = getRegionId(id);
397 
398  Region& region = regionMap[regionId];
399  if (!region.init) {
400  region.regionPos = patpose;
401  region.regionDir = patdire;
402  region.init = true;
403  }
404  region.mdtPrdsPerChamber[chFlag].emplace_back(intersect, &mdt);
405 }

◆ interfaceID()

static const InterfaceID& Muon::IMuonPatternCalibration::interfaceID ( )
inlinestaticinherited

access to tool interface

Definition at line 58 of file IMuonPatternCalibration.h.

58  {
59  static const InterfaceID IID_IMuonPatternCalibration("Muon::IMuonPatternCalibration", 1, 0);
60  return IID_IMuonPatternCalibration;
61  }

◆ loadFromStoreGate()

template<class ContType >
StatusCode Muon::MuonPatternCalibration::loadFromStoreGate ( const EventContext &  ctx,
const SG::ReadHandleKey< ContType > &  key,
const ContType *&  cont_ptr 
) const
private

load the container from storegate given a ReadHandleKey.

If the key is empty a nullptr will be returned

Definition at line 466 of file MuonPatternCalibration.cxx.

468  {
469  if (key.empty()){
470  ATH_MSG_VERBOSE("Empty key given for "<<typeid(ContType).name()<<".");
471  cont_ptr = nullptr;
472  return StatusCode::SUCCESS;
473  }
474  SG::ReadHandle<ContType> readHandle{key, ctx};
475  if (!readHandle.isValid()) {
476  ATH_MSG_FATAL("Failed to retrieve "<<key.fullKey()<<" from store gate");
477  return StatusCode::FAILURE;
478  }
479  cont_ptr = readHandle.cptr();
480  return StatusCode::SUCCESS;
481 }

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

◆ printRegionMap()

void Muon::MuonPatternCalibration::printRegionMap ( const RegionMap &  regionMap) const
private

Definition at line 408 of file MuonPatternCalibration.cxx.

409 {
410 
411  ATH_MSG_INFO("Summarizing input");
412 
413  for (const auto& [detRegionId, chamberData] : regionMap) {
414  ATH_MSG_INFO("new region " << detRegionId << " trigger " << chamberData.triggerPrds.size() << " mdt ch "
415  << chamberData.mdtPrdsPerChamber.size());
416  if (!chamberData.triggerPrds.empty()) ATH_MSG_INFO("trigger hits " << chamberData.triggerPrds.size());
417 
418  for (const auto& [globalPos, prd] : chamberData.triggerPrds) {
419  ATH_MSG_INFO(" " << m_printer->print(*prd)<<" "<<globalPos);
420  }
421  for (const auto& [statId, MdtChamHits]: chamberData.mdtPrdsPerChamber) {
422  ATH_MSG_INFO("new MDT chamber with " << MdtChamHits.size() << " hits");
423  for (const auto& [globalPos, prd] : MdtChamHits) {
424  ATH_MSG_INFO(" " << m_printer->print(*prd)<<" "<<globalPos);
425  }
426  }
427  }
428 }

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

ToolHandle<IMuonClusterOnTrackCreator> Muon::MuonPatternCalibration::m_clusterCreator
private
Initial value:
{
this,
"ClusterCreator",
"Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator",
}

Definition at line 88 of file MuonPatternCalibration.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_doMultiAnalysis

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_doMultiAnalysis {this, "DoMultiChamberAnalysis", true}
private

Definition at line 105 of file MuonPatternCalibration.h.

◆ m_doSummary

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_doSummary {this, "DoSummary", false}
private

Definition at line 108 of file MuonPatternCalibration.h.

◆ m_dropDistance

Gaudi::Property<double> Muon::MuonPatternCalibration::m_dropDistance {this, "DropDistance", 1500.}
private

Definition at line 106 of file MuonPatternCalibration.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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonPatternCalibration::m_idHelperSvc
private
Initial value:
{
this,
"MuonIdHelperSvc",
"Muon::MuonIdHelperSvc/MuonIdHelperSvc",
}

Definition at line 99 of file MuonPatternCalibration.h.

◆ m_keyRpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> Muon::MuonPatternCalibration::m_keyRpc {this, "RpcPrepDataContainer","RPC_Measurements"}
private

Definition at line 112 of file MuonPatternCalibration.h.

◆ m_keyTgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> Muon::MuonPatternCalibration::m_keyTgc {this, "TgcPrepDataContainer","TGC_Measurements"}
private

Definition at line 113 of file MuonPatternCalibration.h.

◆ m_mdtCreator

ToolHandle<IMdtDriftCircleOnTrackCreator> Muon::MuonPatternCalibration::m_mdtCreator
private
Initial value:
{
this,
"MdtCreator",
"",
}

Definition at line 83 of file MuonPatternCalibration.h.

◆ m_phiAngleCut

Gaudi::Property<double> Muon::MuonPatternCalibration::m_phiAngleCut {this, "AngleCutPhi", 1.e9}
private

Definition at line 107 of file MuonPatternCalibration.h.

◆ m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonPatternCalibration::m_printer
private
Initial value:
{
this,
"Printer",
"Muon::MuonEDMPrinterTool",
}

Definition at line 93 of file MuonPatternCalibration.h.

◆ m_recoverTriggerHits

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_recoverTriggerHits {this, "RecoverTriggerHits", true}
private

Definition at line 109 of file MuonPatternCalibration.h.

◆ m_removeDoubleMdtHits

Gaudi::Property<bool> Muon::MuonPatternCalibration::m_removeDoubleMdtHits {this, "RemoveDoubleMdtHits", true}
private

Definition at line 110 of file MuonPatternCalibration.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::BIS
@ BIS
Definition: MuonStationIndex.h:17
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
Muon::MuonPatternCalibration::m_removeDoubleMdtHits
Gaudi::Property< bool > m_removeDoubleMdtHits
Definition: MuonPatternCalibration.h:110
Trk::PrepRawDataType::MdtPrepData
@ MdtPrepData
Muon::IMuonPatternCalibration::MdtVec
std::vector< const MdtDriftCircleOnTrack * > MdtVec
Definition: IMuonPatternCalibration.h:27
Muon::MuonPrepDataContainer
Template for Muon PRD containers (which are basically collections of MuonPrepDataCollections).
Definition: MuonPrepDataContainer.h:42
Muon::MuonPatternCalibration::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonPatternCalibration.h:99
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonGM::MuonReadoutElement::AmdbLRSToGlobalTransform
virtual Amg::Transform3D AmdbLRSToGlobalTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:145
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::PrepRawDataType::TgcPrepData
@ TgcPrepData
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
Trk::PrepRawDataType::MMPrepData
@ MMPrepData
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
Muon::MuonPatternCalibration::m_printer
PublicToolHandle< MuonEDMPrinterTool > m_printer
Definition: MuonPatternCalibration.h:93
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
M_PI
#define M_PI
Definition: ActiveFraction.h:11
Muon::MuonPatternCalibration::getRegionId
int getRegionId(const Identifier &id) const override
Definition: MuonPatternCalibration.cxx:52
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
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::MuonPatternCalibration::calibrateRegionMap
void calibrateRegionMap(const RegionMap &regionMap, IMuonPatternCalibration::ROTsPerRegion &hitsPerRegion) const
Definition: MuonPatternCalibration.cxx:431
Trk::PrepRawDataType::RpcPrepData
@ RpcPrepData
Muon::MuonPatternCalibration::m_recoverTriggerHits
Gaudi::Property< bool > m_recoverTriggerHits
Definition: MuonPatternCalibration.h:109
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Muon::MuonPatternCalibration::m_clusterCreator
ToolHandle< IMuonClusterOnTrackCreator > m_clusterCreator
Definition: MuonPatternCalibration.h:88
Muon::MuonPatternCalibration::RegionMap
std::map< int, Region > RegionMap
Definition: MuonPatternCalibration.h:49
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Identifier32::get_compact
value_type get_compact(void) const
Get the compact id.
Definition: Identifier32.h:171
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:50
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
MuonGM::MdtReadoutElement::getActiveTubeLength
double getActiveTubeLength(const int tubeLayer, const int tube) const
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
dumpNswErrorDb.linear
def linear
Definition: dumpNswErrorDb.py:23
Region
Region
Definition: TrigL2HitResidual.h:14
Trk::Surface::normal
virtual const Amg::Vector3D & normal() const
Returns the normal vector of the Surface (i.e.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::MuonPatternCalibration::insertCluster
void insertCluster(const MuonCluster &mdt, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
Definition: MuonPatternCalibration.cxx:203
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
MuonGM::MuonReadoutElement::globalPosition
const Amg::Vector3D globalPosition() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:47
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
compute_lumi.denom
denom
Definition: compute_lumi.py:76
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Muon::MuonPatternCalibration::m_dropDistance
Gaudi::Property< double > m_dropDistance
Definition: MuonPatternCalibration.h:106
Muon::MuonPatternCalibration::checkForPhiMeasurements
bool checkForPhiMeasurements(const MuonPatternCombination &pat) const override
Definition: MuonPatternCalibration.cxx:61
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::PrepRawData
Definition: PrepRawData.h:62
dso-stats.pat
pat
Definition: dso-stats.py:39
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
Muon::MuonPatternCalibration::loadFromStoreGate
StatusCode loadFromStoreGate(const EventContext &ctx, const SG::ReadHandleKey< ContType > &key, const ContType *&cont_ptr) const
load the container from storegate given a ReadHandleKey.
Definition: MuonPatternCalibration.cxx:466
Muon::MuonPatternCalibration::insertMdt
void insertMdt(const MdtPrepData &clus, RegionMap &regionMap, const Amg::Vector3D &patpose, const Amg::Vector3D &patdire, bool hasPhiMeasurements) const
Definition: MuonPatternCalibration.cxx:306
Amg
Definition of ATLAS Math & Geometry primitives (Amg)
Definition: AmgStringHelpers.h:19
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Trk::PrepRawDataType::sTgcPrepData
@ sTgcPrepData
MuonCluster
Definition: Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h:46
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Muon::MuonPatternCalibration::m_phiAngleCut
Gaudi::Property< double > m_phiAngleCut
Definition: MuonPatternCalibration.h:107
Muon::MuonPatternCalibration::m_keyTgc
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_keyTgc
Definition: MuonPatternCalibration.h:113
a
TList * a
Definition: liststreamerinfos.cxx:10
Muon::MuonPatternCalibration::m_mdtCreator
ToolHandle< IMdtDriftCircleOnTrackCreator > m_mdtCreator
Definition: MuonPatternCalibration.h:83
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
Muon::MuonStationIndex::BIL
@ BIL
Definition: MuonStationIndex.h:17
Muon::TgcPrepData
Class to represent TGC measurements.
Definition: TgcPrepData.h:32
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
Muon::MuonStationIndex::ChIndex
ChIndex
enum to classify the different chamber layers in the muon spectrometer
Definition: MuonStationIndex.h:15
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Muon::MuonPatternCalibration::createRegionMap
StatusCode createRegionMap(const EventContext &ctx, const MuonPatternCombination &pat, RegionMap &regionMap, bool hasPhiMeasurements) const
Definition: MuonPatternCalibration.cxx:75
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LArCellBinning.phiRange
phiRange
Filling Phi ranges.
Definition: LArCellBinning.py:107
Muon::MuonPatternCalibration::m_keyRpc
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_keyRpc
Definition: MuonPatternCalibration.h:112
Identifier::get_identifier32
Identifier32 get_identifier32(void) const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Muon::MuonPatternCalibration::m_doMultiAnalysis
Gaudi::Property< bool > m_doMultiAnalysis
Definition: MuonPatternCalibration.h:105
Trk::TrkDetElementBase::center
virtual const Amg::Vector3D & center() const =0
Return the center of the element.
Muon::MuonStationIndex::BOL
@ BOL
Definition: MuonStationIndex.h:17
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
fitman.k
k
Definition: fitman.py:528
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Trk::PrepRawData::detectorElement
virtual const TrkDetElementBase * detectorElement() const =0
return the detector element corresponding to this PRD The pointer will be zero if the det el is not d...
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Fri Jun 28 2024 22:22:22 for ATLAS Offline Software by   doxygen 1.8.18