ATLAS Offline Software
Loading...
Searching...
No Matches
MuonValR4::StgcPrdVariables Class Referencefinal

One tester module reading all three Phase-II sTGC PRD collections. More...

#include <StgcPrdVariables.h>

Inheritance diagram for MuonValR4::StgcPrdVariables:

Public Types

using DataDependency = SG::VarHandleKey*

Public Member Functions

 StgcPrdVariables (MuonVal::MuonTesterTree &tree, const std::string &stripKey, const std::string &wireKey, const std::string &padKey, bool writeStripNumbers=true, bool writeStripCharges=true, bool writeStripTimes=true, MSG::Level msgLvl=MSG::INFO)
bool declare_keys () override final
 Declare dependencies on the configured strip, wire, and pad containers.
bool fill (const EventContext &ctx) override final
 Read the sTGC containers and append selected measurements to the tree.
unsigned int push_back (const xAOD::sTgcStripCluster &prd)
 Select a strip cluster for output.
unsigned int push_back (const xAOD::sTgcWireHit &prd)
 Select a wire hit for output.
unsigned int push_back (const xAOD::sTgcPadHit &prd)
 Select a pad hit for output.
void enableSeededDump ()
 Enable selection-based output.
void dumpAllHitsInChamber (const Identifier &chamberId)
 Include all sTGC measurements from the specified chamber in the output.
bool init () override final
 The init method checks whether the branch name has already registered to the MuonTree and tries then to add the branch to the tree --> return false if the branch has already been defined or the inclusion of the branch to the tree failed or the name of the branch is empty.
std::string name () const override final
 Returns the name of the branch.
bool initialized () const
 Returns whether the object has been initialized or not The outcome of the variable is bound to a successful call of the addToTree method.
TTree * tree () override final
 Returns the underlying TTree object.
const TTree * tree () const override final
std::vector< DataDependency > data_dependencies () override final
 Returns the data dependencies needed by the MuonTesterBranch.
bool msgLvl (const MSG::Level lvl) const
 Test the output level.
MsgStream & msg () const
 The standard message stream.
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream.
void setLevel (MSG::Level lvl)
 Change the current logging level.

Static Public Member Functions

static std::string eraseWhiteSpaces (const std::string &In)

Protected Member Functions

const Muon::IMuonIdHelperSvc * idHelperSvc () const
const MuonGMR4::MuonDetectorManager * getDetMgr () const
const ActsTrk::GeometryContext & getGeoCtx (const EventContext &ctx) const
template<class T>
bool addToTree (T &variable)
 Connects the Memory buffer with the TTree.
template<class Key>
bool declare_dependency (Key &key)
 Declares the ReadHandle/ ReadCondHandleKey as data dependency of the algorithm.
MuonTesterTree & parent ()
 Returns the reference to the MuonTesterTree parent.

Private Member Functions

void dumpStrip (const ActsTrk::GeometryContext &gctx, const xAOD::sTgcStripCluster &prd)
 Append a strip cluster's identifier and measurement data to the tree.
void dumpWire (const ActsTrk::GeometryContext &gctx, const xAOD::sTgcWireHit &prd)
 Append a wire hit's identifier and measurement data to the tree.
void dumpPad (const ActsTrk::GeometryContext &gctx, const xAOD::sTgcPadHit &prd)
 Append a pad hit's identifier and measurement data to the tree.
void clearEventSelection ()
 Clear the per-event measurement and chamber selections.
void initMessaging () const
 Initialize our message level and MessageSvc.

Private Attributes

SG::ReadHandleKey< xAOD::sTgcStripContainer > m_stripKey {}
 StoreGate key for the sTGC strip-cluster container.
SG::ReadHandleKey< xAOD::sTgcWireContainer > m_wireKey {}
 StoreGate key for the sTGC wire-hit container.
SG::ReadHandleKey< xAOD::sTgcPadContainer > m_padKey {}
 StoreGate key for the sTGC pad-hit container.
MuonVal::sTgcIdentifierBranch m_stripId {parent(), "StgcStrip"}
 Identifier branch for sTGC strip clusters.
MuonVal::ThreeVectorBranch m_stripGlobal {parent(), "StgcStrip_globalPos"}
 Global-frame position of each sTGC strip cluster.
MuonVal::VectorBranch< float > & m_stripLocal {parent().newVector<float>("StgcStrip_localPos")}
 Measured local position of each sTGC strip cluster.
MuonVal::VectorBranch< float > & m_stripCov {parent().newVector<float>("StgcStrip_localCov")}
 Local measurement variance of each sTGC strip cluster.
MuonVal::VectorBranch< short > & m_stripTime {parent().newVector<short>("StgcStrip_time")}
 Time recorded for each sTGC strip cluster.
MuonVal::VectorBranch< int > & m_stripCharge {parent().newVector<int>("StgcStrip_charge")}
 Charge recorded for each sTGC strip cluster.
MuonVal::VectorBranch< uint8_t > & m_stripAuthor {parent().newVector<uint8_t>("StgcStrip_author")}
 Reconstruction author code for each sTGC strip cluster.
MuonVal::sTgcIdentifierBranch m_wireId {parent(), "StgcWire"}
 Identifier branch for sTGC wire hits.
MuonVal::ThreeVectorBranch m_wireGlobal {parent(), "StgcWire_globalPos"}
 Global-frame position of each sTGC wire hit.
MuonVal::VectorBranch< float > & m_wireLocal {parent().newVector<float>("StgcWire_localPos")}
 Measured local position of each wire hit, along local Y.
MuonVal::VectorBranch< float > & m_wireCov {parent().newVector<float>("StgcWire_localCov")}
 Local measurement variance of each sTGC wire hit.
MuonVal::VectorBranch< short > & m_wireTime {parent().newVector<short>("StgcWire_time")}
 Time recorded for each sTGC wire hit.
MuonVal::VectorBranch< int > & m_wireCharge {parent().newVector<int>("StgcWire_charge")}
 Charge recorded for each sTGC wire hit.
MuonVal::VectorBranch< uint8_t > & m_wireAuthor {parent().newVector<uint8_t>("StgcWire_author")}
 Reconstruction author code for each sTGC wire hit.
MuonVal::sTgcIdentifierBranch m_padId {parent(), "StgcPad"}
 Identifier branch for sTGC pad hits.
MuonVal::ThreeVectorBranch m_padGlobal {parent(), "StgcPad_globalPos"}
 Global-frame position of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padLocalX {parent().newVector<float>("StgcPad_localPosX")}
 Local X coordinate of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padLocalY {parent().newVector<float>("StgcPad_localPosY")}
 Local Y coordinate of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovXX {parent().newVector<float>("StgcPad_covXX")}
 Local XX covariance component of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovXY {parent().newVector<float>("StgcPad_covXY")}
 Local XY covariance component of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovYY {parent().newVector<float>("StgcPad_covYY")}
 Local YY covariance component of each sTGC pad hit.
MuonVal::VectorBranch< short > & m_padTime {parent().newVector<short>("StgcPad_time")}
 Time recorded for each sTGC pad hit.
MuonVal::VectorBranch< int > & m_padCharge {parent().newVector<int>("StgcPad_charge")}
 Charge recorded for each sTGC pad hit.
MuonVal::VectorBranch< uint8_t > & m_padAuthor {parent().newVector<uint8_t>("StgcPad_author")}
 Reconstruction author code for each sTGC pad hit.
MuonVal::MatrixBranch< uint16_t > * m_stripNumbers {nullptr}
 Optional per-cluster lists of constituent strip numbers; null when not booked.
MuonVal::MatrixBranch< int > * m_stripCharges {nullptr}
 Optional per-cluster lists of constituent strip charges; null when not booked.
MuonVal::MatrixBranch< short > * m_stripTimes {nullptr}
 Optional per-cluster lists of constituent strip times; null when not booked.
std::unordered_set< Identifier > m_filteredChamb {}
 Chamber identifiers whose measurements are included by the chamber filter.
std::unordered_map< Identifier, unsigned int > m_stripIdx {}
 Map from strip-cluster identifier to its output index.
std::unordered_map< Identifier, unsigned int > m_wireIdx {}
 Map from wire-hit identifier to its output index.
std::unordered_map< Identifier, unsigned int > m_padIdx {}
 Map from pad-hit identifier to its output index.
std::vector< const xAOD::sTgcStripCluster * > m_seedStrips {}
 Strip clusters explicitly selected for output in the current event.
std::vector< const xAOD::sTgcWireHit * > m_seedWires {}
 Wire hits explicitly selected for output in the current event.
std::vector< const xAOD::sTgcPadHit * > m_seedPads {}
 Pad hits explicitly selected for output in the current event.
bool m_applyFilter {false}
 Whether output is restricted to selected measurements and chambers.
const MuonGMR4::MuonDetectorManager * m_detMgr {}
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {"Muon::MuonIdHelperSvc/MuonIdHelperSvc", name()}
ActsTrk::GeoContextReadKey_t m_geoCtxKey {"ActsAlignment"}
TTree * m_tree {nullptr}
MuonTesterTree * m_parent {nullptr}
std::string m_name {}
bool m_init {false}
std::vector< DataDependency > m_dependencies {}
std::string m_nm
 Message source name.
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer.
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level.
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging).

Detailed Description

One tester module reading all three Phase-II sTGC PRD collections.

ROOT output is separated into StgcStrip_*, StgcWire_*, StgcPad_*. The constituent strip branches are booked only when selected.

Definition at line 25 of file StgcPrdVariables.h.

Member Typedef Documentation

◆ DataDependency

Constructor & Destructor Documentation

◆ StgcPrdVariables()

MuonValR4::StgcPrdVariables::StgcPrdVariables ( MuonVal::MuonTesterTree & tree,
const std::string & stripKey,
const std::string & wireKey,
const std::string & padKey,
bool writeStripNumbers = true,
bool writeStripCharges = true,
bool writeStripTimes = true,
MSG::Level msgLvl = MSG::INFO )
Parameters
treeTester tree that receives the output branches.
stripKeyStoreGate key for the sTGC strip-cluster container.
wireKeyStoreGate key for the sTGC wire-hit container.
padKeyStoreGate key for the sTGC pad-hit container.
writeStripNumbersWhether to write the per-cluster strip numbers.
writeStripChargesWhether to write the per-strip charges.
writeStripTimesWhether to write the per-strip times.
msgLvlMessage level used by the tester module.

Definition at line 64 of file StgcPrdVariables.cxx.

72 : TesterModuleBase{tree, "StgcPrds", msgLvl},
73 m_stripKey{stripKey},
74 m_wireKey{wireKey},
75 m_padKey{padKey}{
76 // Book optional branches only if requested, so no empty jagged
77 // vectors or baskets are written when a detail switch is false.
78 if (writeStripNumbers) {
79 m_stripNumbers = &parent().newMatrix<uint16_t>("StgcStrip_stripNumbers");
80 }
81 if (writeStripCharges) {
82 m_stripCharges = &parent().newMatrix<int>("StgcStrip_stripCharges");
83 }
84 if (writeStripTimes) {
85 m_stripTimes = &parent().newMatrix<short>("StgcStrip_stripTimes");
86 }
87}
bool msgLvl(const MSG::Level lvl) const
Test the output level.
MuonVal::MatrixBranch< short > * m_stripTimes
Optional per-cluster lists of constituent strip times; null when not booked.
SG::ReadHandleKey< xAOD::sTgcStripContainer > m_stripKey
StoreGate key for the sTGC strip-cluster container.
SG::ReadHandleKey< xAOD::sTgcPadContainer > m_padKey
StoreGate key for the sTGC pad-hit container.
MuonVal::MatrixBranch< uint16_t > * m_stripNumbers
Optional per-cluster lists of constituent strip numbers; null when not booked.
SG::ReadHandleKey< xAOD::sTgcWireContainer > m_wireKey
StoreGate key for the sTGC wire-hit container.
MuonVal::MatrixBranch< int > * m_stripCharges
Optional per-cluster lists of constituent strip charges; null when not booked.
TesterModuleBase(MuonTesterTree &tree, const std::string &grp_name, MSG::Level msglvl=MSG::Level::INFO)
virtual TTree * tree()=0
Returns the pointer to the underlying TTree object.
MuonTesterTree & parent()
Returns the reference to the MuonTesterTree parent.
MatrixBranch< T > & newMatrix(const std::string &name)
setWord1 uint16_t

Member Function Documentation

◆ addToTree()

template<class T>
bool MuonVal::MuonTesterBranch::addToTree ( T & variable)
protectedinherited

Connects the Memory buffer with the TTree.

◆ clearEventSelection()

void MuonValR4::StgcPrdVariables::clearEventSelection ( )
private

Clear the per-event measurement and chamber selections.

Definition at line 53 of file StgcPrdVariables.cxx.

53 {
54 m_filteredChamb.clear();
55 m_stripIdx.clear();
56 m_wireIdx.clear();
57 m_padIdx.clear();
58 m_seedStrips.clear();
59 m_seedWires.clear();
60 m_seedPads.clear();
61 // Intentionally do NOT reset m_applyFilter (same as MM).
62}
std::vector< const xAOD::sTgcStripCluster * > m_seedStrips
Strip clusters explicitly selected for output in the current event.
std::unordered_map< Identifier, unsigned int > m_padIdx
Map from pad-hit identifier to its output index.
std::vector< const xAOD::sTgcWireHit * > m_seedWires
Wire hits explicitly selected for output in the current event.
std::unordered_map< Identifier, unsigned int > m_stripIdx
Map from strip-cluster identifier to its output index.
std::unordered_map< Identifier, unsigned int > m_wireIdx
Map from wire-hit identifier to its output index.
std::vector< const xAOD::sTgcPadHit * > m_seedPads
Pad hits explicitly selected for output in the current event.
std::unordered_set< Identifier > m_filteredChamb
Chamber identifiers whose measurements are included by the chamber filter.

◆ data_dependencies()

std::vector< MuonTesterBranch::DataDependency > MuonVal::MuonTesterBranch::data_dependencies ( )
finaloverridevirtualinherited

Returns the data dependencies needed by the MuonTesterBranch.

Implements MuonVal::IMuonTesterBranch.

Definition at line 61 of file MuonTesterBranch.cxx.

61{ return m_dependencies;}
std::vector< DataDependency > m_dependencies

◆ declare_dependency()

template<class Key>
bool MuonVal::MuonTesterBranch::declare_dependency ( Key & key)
protectedinherited

Declares the ReadHandle/ ReadCondHandleKey as data dependency of the algorithm.

◆ declare_keys()

bool MuonValR4::StgcPrdVariables::declare_keys ( )
finaloverridevirtual

Declare dependencies on the configured strip, wire, and pad containers.

Implements MuonValR4::TesterModuleBase.

Definition at line 90 of file StgcPrdVariables.cxx.

90 {
94}
bool declare_dependency(Key &key)
Declares the ReadHandle/ ReadCondHandleKey as data dependency of the algorithm.

◆ dumpAllHitsInChamber()

void MuonValR4::StgcPrdVariables::dumpAllHitsInChamber ( const Identifier & chamberId)

Include all sTGC measurements from the specified chamber in the output.

Parameters
chamberIdIdentifier of the chamber to include.

Definition at line 15 of file StgcPrdVariables.cxx.

15 {
16 m_applyFilter = true;
17 m_filteredChamb.insert( idHelperSvc()->chamberId(chamberId));
18}
bool m_applyFilter
Whether output is restricted to selected measurements and chambers.
const Muon::IMuonIdHelperSvc * idHelperSvc() const

◆ dumpPad()

void MuonValR4::StgcPrdVariables::dumpPad ( const ActsTrk::GeometryContext & gctx,
const xAOD::sTgcPadHit & prd )
private

Append a pad hit's identifier and measurement data to the tree.

Parameters
gctxGeometry context used to calculate the global position.
prdPad hit to write.

Definition at line 179 of file StgcPrdVariables.cxx.

179 {
180 const auto* pad = &prd;
181 const Identifier id{pad->identify()};
182 const auto* re = pad->readoutElement();
183 const Amg::Vector3D global{ re->localToGlobalTransform(gctx, pad->layerHash()) * pad->localMeasurementPos()};
184
185 const auto pos = pad->localPosition<2>();
186 const auto cov = pad->localCovariance<2>();
187
188 m_padId.push_back(id);
189 m_padGlobal.push_back(global);
190 m_padLocalX.push_back(pos[0]);
191 m_padLocalY.push_back(pos[1]);
192 m_padCovXX.push_back(cov(0, 0));
193 m_padCovXY.push_back(cov(0, 1));
194 m_padCovYY.push_back(cov(1, 1));
195 m_padTime.push_back(pad->time());
196 m_padCharge.push_back(pad->charge());
197 m_padAuthor.push_back(static_cast<uint8_t>(pad->author()));
198}
const std::regex re(r_e)
MuonVal::VectorBranch< int > & m_padCharge
Charge recorded for each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovYY
Local YY covariance component of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovXY
Local XY covariance component of each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padLocalY
Local Y coordinate of each sTGC pad hit.
MuonVal::VectorBranch< short > & m_padTime
Time recorded for each sTGC pad hit.
MuonVal::ThreeVectorBranch m_padGlobal
Global-frame position of each sTGC pad hit.
MuonVal::VectorBranch< uint8_t > & m_padAuthor
Reconstruction author code for each sTGC pad hit.
MuonVal::VectorBranch< float > & m_padCovXX
Local XX covariance component of each sTGC pad hit.
MuonVal::sTgcIdentifierBranch m_padId
Identifier branch for sTGC pad hits.
MuonVal::VectorBranch< float > & m_padLocalX
Local X coordinate of each sTGC pad hit.
const MuonGMR4::sTgcReadoutElement * readoutElement() const override final
Retrieve the associated sTgcReadoutElement.
Eigen::Matrix< double, 3, 1 > Vector3D

◆ dumpStrip()

void MuonValR4::StgcPrdVariables::dumpStrip ( const ActsTrk::GeometryContext & gctx,
const xAOD::sTgcStripCluster & prd )
private

Append a strip cluster's identifier and measurement data to the tree.

Parameters
gctxGeometry context used to calculate the global position.
prdStrip cluster to write.

Definition at line 143 of file StgcPrdVariables.cxx.

143 {
144 const auto* strip = &prd;
145 const Identifier id{strip->identify()};
146 const auto* re = strip->readoutElement();
147 const Amg::Vector3D global{ re->localToGlobalTransform(gctx, strip->layerHash()) * strip->localMeasurementPos()};
148
149 m_stripId.push_back(id);
150 m_stripGlobal.push_back(global);
151 m_stripLocal.push_back(strip->localPosition<1>()[0]);
152 m_stripCov.push_back(strip->localCovariance<1>()(0, 0));
153 m_stripTime.push_back(strip->time());
154 m_stripCharge.push_back(strip->charge());
155 m_stripAuthor.push_back(static_cast<uint8_t>(strip->author()));
156 //m_stripQuality.push_back(static_cast<uint8_t>(strip->quality()));
157
158 if (m_stripNumbers) m_stripNumbers->push_back(strip->stripNumbers());
159 if (m_stripCharges) m_stripCharges->push_back(strip->stripCharges());
160 if (m_stripTimes) m_stripTimes->push_back(strip->stripTimes());
161}
MuonVal::VectorBranch< float > & m_stripLocal
Measured local position of each sTGC strip cluster.
MuonVal::VectorBranch< short > & m_stripTime
Time recorded for each sTGC strip cluster.
MuonVal::ThreeVectorBranch m_stripGlobal
Global-frame position of each sTGC strip cluster.
MuonVal::VectorBranch< int > & m_stripCharge
Charge recorded for each sTGC strip cluster.
MuonVal::sTgcIdentifierBranch m_stripId
Identifier branch for sTGC strip clusters.
MuonVal::VectorBranch< float > & m_stripCov
Local measurement variance of each sTGC strip cluster.
MuonVal::VectorBranch< uint8_t > & m_stripAuthor
Reconstruction author code for each sTGC strip cluster.

◆ dumpWire()

void MuonValR4::StgcPrdVariables::dumpWire ( const ActsTrk::GeometryContext & gctx,
const xAOD::sTgcWireHit & prd )
private

Append a wire hit's identifier and measurement data to the tree.

Parameters
gctxGeometry context used to calculate the global position.
prdWire hit to write.

Definition at line 163 of file StgcPrdVariables.cxx.

163 {
164 const auto* wire = &prd;
165 const Identifier id{wire->identify()};
166 const auto* re = wire->readoutElement();
167 const Amg::Vector3D global{ re->localToGlobalTransform(gctx, wire->layerHash()) * wire->localMeasurementPos()};
168
169 m_wireId.push_back(id);
170 m_wireGlobal.push_back(global);
171 // The scalar localPosition<1>() is along local Y for wires.
172 m_wireLocal.push_back(wire->localPosition<1>()[0]);
173 m_wireCov.push_back(wire->localCovariance<1>()(0, 0));
174 m_wireTime.push_back(wire->time());
175 m_wireCharge.push_back(wire->charge());
176 m_wireAuthor.push_back(static_cast<uint8_t>(wire->author()));
177}
MuonVal::VectorBranch< short > & m_wireTime
Time recorded for each sTGC wire hit.
MuonVal::VectorBranch< int > & m_wireCharge
Charge recorded for each sTGC wire hit.
MuonVal::ThreeVectorBranch m_wireGlobal
Global-frame position of each sTGC wire hit.
MuonVal::VectorBranch< float > & m_wireCov
Local measurement variance of each sTGC wire hit.
MuonVal::VectorBranch< uint8_t > & m_wireAuthor
Reconstruction author code for each sTGC wire hit.
MuonVal::sTgcIdentifierBranch m_wireId
Identifier branch for sTGC wire hits.
MuonVal::VectorBranch< float > & m_wireLocal
Measured local position of each wire hit, along local Y.

◆ enableSeededDump()

void MuonValR4::StgcPrdVariables::enableSeededDump ( )

Enable selection-based output.

Only explicitly selected measurements and measurements from chambers * passed to dumpAllHitsInChamber() are written.

Definition at line 11 of file StgcPrdVariables.cxx.

11 {
12 m_applyFilter = true;
13}

◆ eraseWhiteSpaces()

std::string MuonVal::MuonTesterBranch::eraseWhiteSpaces ( const std::string & In)
staticinherited

Definition at line 56 of file MuonTesterBranch.cxx.

56 {
57 std::string out = In;
58 out.erase(std::remove_if(out.begin(), out.end(), isspace), out.end());
59 return out;
60}
DataModel_detail::iterator< DVL > remove_if(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end, Predicate pred)
Specialization of remove_if for DataVector/List.

◆ fill()

bool MuonValR4::StgcPrdVariables::fill ( const EventContext & ctx)
finaloverridevirtual

Read the sTGC containers and append selected measurements to the tree.

Parameters
ctxEvent context used to retrieve the containers and geometry.
Returns
True if all three containers are valid and processed; false otherwise.

Implements MuonVal::IMuonTesterBranch.

Definition at line 96 of file StgcPrdVariables.cxx.

96 {
97 const ActsTrk::GeometryContext& gctx{getGeoCtx(ctx)};
98
99 SG::ReadHandle<xAOD::sTgcStripContainer> strips{m_stripKey, ctx};
100 SG::ReadHandle<xAOD::sTgcWireContainer> wires{m_wireKey, ctx};
101 SG::ReadHandle<xAOD::sTgcPadContainer> pads{m_padKey, ctx};
102
103 if (!strips.isValid() || !wires.isValid() || !pads.isValid()) {
104 ATH_MSG_ERROR("Missing sTGC PRD container(s): "
105 << m_stripKey.fullKey() << " (valid=" << strips.isValid() << "), "
106 << m_wireKey.fullKey() << " (valid=" << wires.isValid() << "), "
107 << m_padKey.fullKey() << " (valid=" << pads.isValid() << ")");
109 return false;
110 }
111
112 // The explicit seeds are written first. push_back() indices therefore
113 // correspond to their positions in the resulting per-type output vectors.
114 for (const auto* prd : m_seedStrips) dumpStrip(gctx, *prd);
115 for (const auto* prd : m_seedWires) dumpWire(gctx, *prd);
116 for (const auto* prd : m_seedPads) dumpPad(gctx, *prd);
117
118 // Then append the other hits, subject to the optional chamber filter.
119 // The maps already contain seeded IDs; insert new IDs as they are dumped.
120 for (const auto* prd : *strips) {
121 const Identifier id{prd->identify()};
122 if (m_applyFilter && !m_filteredChamb.count(idHelperSvc()->chamberId(id))) continue;
123 if (!m_stripIdx.emplace(id, m_stripIdx.size()).second) continue;
124 dumpStrip(gctx, *prd);
125 }
126 for (const auto* prd : *wires) {
127 const Identifier id{prd->identify()};
128 if (m_applyFilter && !m_filteredChamb.count(idHelperSvc()->chamberId(id))) continue;
129 if (!m_wireIdx.emplace(id, m_wireIdx.size()).second) continue;
130 dumpWire(gctx, *prd);
131 }
132 for (const auto* prd : *pads) {
133 const Identifier id{prd->identify()};
134 if (m_applyFilter && !m_filteredChamb.count(idHelperSvc()->chamberId(id))) continue;
135 if (!m_padIdx.emplace(id, m_padIdx.size()).second) continue;
136 dumpPad(gctx, *prd);
137 }
138
140 return true;
141}
#define ATH_MSG_ERROR(x,...)
void dumpWire(const ActsTrk::GeometryContext &gctx, const xAOD::sTgcWireHit &prd)
Append a wire hit's identifier and measurement data to the tree.
void dumpPad(const ActsTrk::GeometryContext &gctx, const xAOD::sTgcPadHit &prd)
Append a pad hit's identifier and measurement data to the tree.
void clearEventSelection()
Clear the per-event measurement and chamber selections.
void dumpStrip(const ActsTrk::GeometryContext &gctx, const xAOD::sTgcStripCluster &prd)
Append a strip cluster's identifier and measurement data to the tree.
const ActsTrk::GeometryContext & getGeoCtx(const EventContext &ctx) const
virtual bool isValid() override final
Can the handle be successfully dereferenced?

◆ getDetMgr()

const MuonGMR4::MuonDetectorManager * MuonValR4::TesterModuleBase::getDetMgr ( ) const
protectedinherited

Definition at line 20 of file TesterModuleBase.cxx.

20 {
21 return m_detMgr;
22 }
const MuonGMR4::MuonDetectorManager * m_detMgr

◆ getGeoCtx()

const ActsTrk::GeometryContext & MuonValR4::TesterModuleBase::getGeoCtx ( const EventContext & ctx) const
protectedinherited

Definition at line 23 of file TesterModuleBase.cxx.

23 {
24 const ActsTrk::GeometryContext* geoCtx{nullptr};
25 if (!SG::get(geoCtx, m_geoCtxKey, ctx).isSuccess()) {
26 THROW_EXCEPTION("Failed to retrieve "<<m_geoCtxKey.fullKey());
27 }
28 return *geoCtx;
29 }
ActsTrk::GeoContextReadKey_t m_geoCtxKey
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
#define THROW_EXCEPTION(MESSAGE)
Definition throwExcept.h:10

◆ idHelperSvc()

const Muon::IMuonIdHelperSvc * MuonValR4::TesterModuleBase::idHelperSvc ( ) const
protectedinherited

Definition at line 19 of file TesterModuleBase.cxx.

19{ return m_idHelperSvc.get(); }
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc

◆ init()

bool MuonValR4::TesterModuleBase::init ( )
finaloverridevirtualinherited

The init method checks whether the branch name has already registered to the MuonTree and tries then to add the branch to the tree --> return false if the branch has already been defined or the inclusion of the branch to the tree failed or the name of the branch is empty.

Implements MuonVal::IMuonTesterBranch.

Definition at line 31 of file TesterModuleBase.cxx.

31 {
32 ServiceHandle<StoreGateSvc> detStore{"StoreGateSvc/DetectorStore", name()};
33 if (!detStore.retrieve().isSuccess() || !detStore->retrieve(m_detMgr).isSuccess()) return false;
34 if (!declare_dependency(m_geoCtxKey)) return false;
35 if (!m_idHelperSvc.retrieve().isSuccess()) return false;
36 return declare_keys();
37 }
virtual bool declare_keys()=0
std::string name() const override final
Returns the name of the branch.

◆ initialized()

bool MuonVal::MuonTesterBranch::initialized ( ) const
inherited

Returns whether the object has been initialized or not The outcome of the variable is bound to a successful call of the addToTree method.

Definition at line 52 of file MuonTesterBranch.cxx.

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40{
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
std::string m_nm
Message source name.
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
std::atomic< MSG::Level > m_lvl
Current logging level.
IMessageSvc * getMessageSvc(bool quiet=false)
int outputLevel(const IMessageSvc *ims, const std::string &source)

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

168{
169 MsgStream* ms = m_msg_tls.get();
170 if (!ms) {
171 if (!m_initialized.test_and_set()) initMessaging();
172 ms = new MsgStream(m_imsg,m_nm);
173 m_msg_tls.reset( ms );
174 }
175
176 ms->setLevel (m_lvl);
177 return *ms;
178}
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels).
void initMessaging() const
Initialize our message level and MessageSvc.

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

183{ return msg() << lvl; }
MsgStream & msg() const
The standard message stream.

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152{
153 // If user did not set explicit message level we have to initialize
154 // the messaging and retrieve the default via the MessageSvc.
155 if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
156
157 if (m_lvl <= lvl) {
158 msg() << lvl;
159 return true;
160 } else {
161 return false;
162 }
163}

◆ name()

std::string MuonVal::MuonTesterBranch::name ( ) const
finaloverridevirtualinherited

Returns the name of the branch.

Implements MuonVal::IMuonTesterBranch.

Definition at line 51 of file MuonTesterBranch.cxx.

51{ return m_name; }

◆ parent()

MuonTesterTree & MuonVal::MuonTesterBranch::parent ( )
protectedinherited

Returns the reference to the MuonTesterTree parent.

Definition at line 38 of file MuonTesterBranch.cxx.

38 {
39 if (!m_parent) {
40 ATH_MSG_WARNING("The parent of " << name() << " is null.");
41 }
42 return *m_parent;
43}
#define ATH_MSG_WARNING(x,...)

◆ push_back() [1/3]

unsigned int MuonValR4::StgcPrdVariables::push_back ( const xAOD::sTgcPadHit & prd)

Select a pad hit for output.

Parameters
prdPad hit to select.
Returns
Its index in the pad output, reusing the index if already selected.

Definition at line 42 of file StgcPrdVariables.cxx.

42 {
43 m_applyFilter = true;
44 const auto [it, inserted] = m_padIdx.emplace( prd.identify(), m_padIdx.size());
45
46 if (inserted) {
47 m_seedPads.push_back(&prd);
48 }
49
50 return it->second;
51}
const Identifier & identify() const
Returns the Athena identifier of the measurement.

◆ push_back() [2/3]

unsigned int MuonValR4::StgcPrdVariables::push_back ( const xAOD::sTgcStripCluster & prd)

Select a strip cluster for output.

Parameters
prdStrip cluster to select.
Returns
Its index in the strip output, reusing the index if already selected.

Definition at line 20 of file StgcPrdVariables.cxx.

20 {
21 m_applyFilter = true;
22 const auto [it, inserted] = m_stripIdx.emplace( prd.identify(), m_stripIdx.size());
23
24 if (inserted) {
25 m_seedStrips.push_back(&prd);
26 }
27
28 return it->second;
29}

◆ push_back() [3/3]

unsigned int MuonValR4::StgcPrdVariables::push_back ( const xAOD::sTgcWireHit & prd)

Select a wire hit for output.

Parameters
prdWire hit to select.
Returns
Its index in the wire output, reusing the index if already selected.

Definition at line 31 of file StgcPrdVariables.cxx.

31 {
32 m_applyFilter = true;
33 const auto [it, inserted] = m_wireIdx.emplace( prd.identify(), m_wireIdx.size());
34
35 if (inserted) {
36 m_seedWires.push_back(&prd);
37 }
38
39 return it->second;
40}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29{
30 m_lvl = lvl;
31}

◆ tree() [1/2]

const TTree * MuonVal::MuonTesterBranch::tree ( ) const
finaloverridevirtualinherited

Implements MuonVal::IMuonTesterBranch.

Definition at line 54 of file MuonTesterBranch.cxx.

54{ return m_tree; }

◆ tree() [2/2]

TTree * MuonVal::MuonTesterBranch::tree ( )
finaloverridevirtualinherited

Returns the underlying TTree object.

Implements MuonVal::IMuonTesterBranch.

Definition at line 53 of file MuonTesterBranch.cxx.

53{ return m_tree; }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

◆ m_applyFilter

bool MuonValR4::StgcPrdVariables::m_applyFilter {false}
private

Whether output is restricted to selected measurements and chambers.

Definition at line 191 of file StgcPrdVariables.h.

191{false};

◆ m_dependencies

std::vector<DataDependency> MuonVal::MuonTesterBranch::m_dependencies {}
privateinherited

Definition at line 62 of file MuonTesterBranch.h.

62{};

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* MuonValR4::TesterModuleBase::m_detMgr {}
privateinherited

Definition at line 32 of file TesterModuleBase.h.

32{};

◆ m_filteredChamb

std::unordered_set<Identifier> MuonValR4::StgcPrdVariables::m_filteredChamb {}
private

Chamber identifiers whose measurements are included by the chamber filter.

Definition at line 174 of file StgcPrdVariables.h.

174{};

◆ m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonValR4::TesterModuleBase::m_geoCtxKey {"ActsAlignment"}
privateinherited

Definition at line 34 of file TesterModuleBase.h.

34{"ActsAlignment"};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonValR4::TesterModuleBase::m_idHelperSvc {"Muon::MuonIdHelperSvc/MuonIdHelperSvc", name()}
privateinherited

Definition at line 33 of file TesterModuleBase.h.

33{"Muon::MuonIdHelperSvc/MuonIdHelperSvc", name()};

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_init

bool MuonVal::MuonTesterBranch::m_init {false}
privateinherited

Definition at line 61 of file MuonTesterBranch.h.

61{false};

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

◆ m_name

std::string MuonVal::MuonTesterBranch::m_name {}
privateinherited

Definition at line 60 of file MuonTesterBranch.h.

60{};

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_padAuthor

MuonVal::VectorBranch<uint8_t>& MuonValR4::StgcPrdVariables::m_padAuthor {parent().newVector<uint8_t>("StgcPad_author")}
private

Reconstruction author code for each sTGC pad hit.

Definition at line 163 of file StgcPrdVariables.h.

163{parent().newVector<uint8_t>("StgcPad_author")};
VectorBranch< T > & newVector(const std::string &name)
Creates new branches and returns their reference.

◆ m_padCharge

MuonVal::VectorBranch<int>& MuonValR4::StgcPrdVariables::m_padCharge {parent().newVector<int>("StgcPad_charge")}
private

Charge recorded for each sTGC pad hit.

Definition at line 161 of file StgcPrdVariables.h.

161{parent().newVector<int>("StgcPad_charge")};

◆ m_padCovXX

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_padCovXX {parent().newVector<float>("StgcPad_covXX")}
private

Local XX covariance component of each sTGC pad hit.

Definition at line 153 of file StgcPrdVariables.h.

153{parent().newVector<float>("StgcPad_covXX")};

◆ m_padCovXY

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_padCovXY {parent().newVector<float>("StgcPad_covXY")}
private

Local XY covariance component of each sTGC pad hit.

Definition at line 155 of file StgcPrdVariables.h.

155{parent().newVector<float>("StgcPad_covXY")};

◆ m_padCovYY

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_padCovYY {parent().newVector<float>("StgcPad_covYY")}
private

Local YY covariance component of each sTGC pad hit.

Definition at line 157 of file StgcPrdVariables.h.

157{parent().newVector<float>("StgcPad_covYY")};

◆ m_padGlobal

MuonVal::ThreeVectorBranch MuonValR4::StgcPrdVariables::m_padGlobal {parent(), "StgcPad_globalPos"}
private

Global-frame position of each sTGC pad hit.

Definition at line 147 of file StgcPrdVariables.h.

147{parent(), "StgcPad_globalPos"};

◆ m_padId

MuonVal::sTgcIdentifierBranch MuonValR4::StgcPrdVariables::m_padId {parent(), "StgcPad"}
private

Identifier branch for sTGC pad hits.

Definition at line 145 of file StgcPrdVariables.h.

145{parent(), "StgcPad"};

◆ m_padIdx

std::unordered_map<Identifier, unsigned int> MuonValR4::StgcPrdVariables::m_padIdx {}
private

Map from pad-hit identifier to its output index.

Definition at line 181 of file StgcPrdVariables.h.

181{};

◆ m_padKey

SG::ReadHandleKey<xAOD::sTgcPadContainer> MuonValR4::StgcPrdVariables::m_padKey {}
private

StoreGate key for the sTGC pad-hit container.

Definition at line 110 of file StgcPrdVariables.h.

110{};

◆ m_padLocalX

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_padLocalX {parent().newVector<float>("StgcPad_localPosX")}
private

Local X coordinate of each sTGC pad hit.

Definition at line 149 of file StgcPrdVariables.h.

149{parent().newVector<float>("StgcPad_localPosX")};

◆ m_padLocalY

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_padLocalY {parent().newVector<float>("StgcPad_localPosY")}
private

Local Y coordinate of each sTGC pad hit.

Definition at line 151 of file StgcPrdVariables.h.

151{parent().newVector<float>("StgcPad_localPosY")};

◆ m_padTime

MuonVal::VectorBranch<short>& MuonValR4::StgcPrdVariables::m_padTime {parent().newVector<short>("StgcPad_time")}
private

Time recorded for each sTGC pad hit.

Definition at line 159 of file StgcPrdVariables.h.

159{parent().newVector<short>("StgcPad_time")};

◆ m_parent

MuonTesterTree* MuonVal::MuonTesterBranch::m_parent {nullptr}
privateinherited

Definition at line 59 of file MuonTesterBranch.h.

59{nullptr};

◆ m_seedPads

std::vector<const xAOD::sTgcPadHit*> MuonValR4::StgcPrdVariables::m_seedPads {}
private

Pad hits explicitly selected for output in the current event.

Definition at line 188 of file StgcPrdVariables.h.

188{};

◆ m_seedStrips

std::vector<const xAOD::sTgcStripCluster*> MuonValR4::StgcPrdVariables::m_seedStrips {}
private

Strip clusters explicitly selected for output in the current event.

Definition at line 184 of file StgcPrdVariables.h.

184{};

◆ m_seedWires

std::vector<const xAOD::sTgcWireHit*> MuonValR4::StgcPrdVariables::m_seedWires {}
private

Wire hits explicitly selected for output in the current event.

Definition at line 186 of file StgcPrdVariables.h.

186{};

◆ m_stripAuthor

MuonVal::VectorBranch<uint8_t>& MuonValR4::StgcPrdVariables::m_stripAuthor {parent().newVector<uint8_t>("StgcStrip_author")}
private

Reconstruction author code for each sTGC strip cluster.

Definition at line 126 of file StgcPrdVariables.h.

126{parent().newVector<uint8_t>("StgcStrip_author")};

◆ m_stripCharge

MuonVal::VectorBranch<int>& MuonValR4::StgcPrdVariables::m_stripCharge {parent().newVector<int>("StgcStrip_charge")}
private

Charge recorded for each sTGC strip cluster.

Definition at line 124 of file StgcPrdVariables.h.

124{parent().newVector<int>("StgcStrip_charge")};

◆ m_stripCharges

MuonVal::MatrixBranch<int>* MuonValR4::StgcPrdVariables::m_stripCharges {nullptr}
private

Optional per-cluster lists of constituent strip charges; null when not booked.

Definition at line 168 of file StgcPrdVariables.h.

168{nullptr};

◆ m_stripCov

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_stripCov {parent().newVector<float>("StgcStrip_localCov")}
private

Local measurement variance of each sTGC strip cluster.

Definition at line 120 of file StgcPrdVariables.h.

120{parent().newVector<float>("StgcStrip_localCov")};

◆ m_stripGlobal

MuonVal::ThreeVectorBranch MuonValR4::StgcPrdVariables::m_stripGlobal {parent(), "StgcStrip_globalPos"}
private

Global-frame position of each sTGC strip cluster.

Definition at line 116 of file StgcPrdVariables.h.

116{parent(), "StgcStrip_globalPos"};

◆ m_stripId

MuonVal::sTgcIdentifierBranch MuonValR4::StgcPrdVariables::m_stripId {parent(), "StgcStrip"}
private

Identifier branch for sTGC strip clusters.

Definition at line 114 of file StgcPrdVariables.h.

114{parent(), "StgcStrip"};

◆ m_stripIdx

std::unordered_map<Identifier, unsigned int> MuonValR4::StgcPrdVariables::m_stripIdx {}
private

Map from strip-cluster identifier to its output index.

Definition at line 177 of file StgcPrdVariables.h.

177{};

◆ m_stripKey

SG::ReadHandleKey<xAOD::sTgcStripContainer> MuonValR4::StgcPrdVariables::m_stripKey {}
private

StoreGate key for the sTGC strip-cluster container.

Definition at line 106 of file StgcPrdVariables.h.

106{};

◆ m_stripLocal

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_stripLocal {parent().newVector<float>("StgcStrip_localPos")}
private

Measured local position of each sTGC strip cluster.

Definition at line 118 of file StgcPrdVariables.h.

118{parent().newVector<float>("StgcStrip_localPos")};

◆ m_stripNumbers

MuonVal::MatrixBranch<uint16_t>* MuonValR4::StgcPrdVariables::m_stripNumbers {nullptr}
private

Optional per-cluster lists of constituent strip numbers; null when not booked.

Definition at line 166 of file StgcPrdVariables.h.

166{nullptr};

◆ m_stripTime

MuonVal::VectorBranch<short>& MuonValR4::StgcPrdVariables::m_stripTime {parent().newVector<short>("StgcStrip_time")}
private

Time recorded for each sTGC strip cluster.

Definition at line 122 of file StgcPrdVariables.h.

122{parent().newVector<short>("StgcStrip_time")};

◆ m_stripTimes

MuonVal::MatrixBranch<short>* MuonValR4::StgcPrdVariables::m_stripTimes {nullptr}
private

Optional per-cluster lists of constituent strip times; null when not booked.

Definition at line 170 of file StgcPrdVariables.h.

170{nullptr};

◆ m_tree

TTree* MuonVal::MuonTesterBranch::m_tree {nullptr}
privateinherited

Definition at line 58 of file MuonTesterBranch.h.

58{nullptr};

◆ m_wireAuthor

MuonVal::VectorBranch<uint8_t>& MuonValR4::StgcPrdVariables::m_wireAuthor {parent().newVector<uint8_t>("StgcWire_author")}
private

Reconstruction author code for each sTGC wire hit.

Definition at line 142 of file StgcPrdVariables.h.

142{parent().newVector<uint8_t>("StgcWire_author")};

◆ m_wireCharge

MuonVal::VectorBranch<int>& MuonValR4::StgcPrdVariables::m_wireCharge {parent().newVector<int>("StgcWire_charge")}
private

Charge recorded for each sTGC wire hit.

Definition at line 140 of file StgcPrdVariables.h.

140{parent().newVector<int>("StgcWire_charge")};

◆ m_wireCov

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_wireCov {parent().newVector<float>("StgcWire_localCov")}
private

Local measurement variance of each sTGC wire hit.

Definition at line 136 of file StgcPrdVariables.h.

136{parent().newVector<float>("StgcWire_localCov")};

◆ m_wireGlobal

MuonVal::ThreeVectorBranch MuonValR4::StgcPrdVariables::m_wireGlobal {parent(), "StgcWire_globalPos"}
private

Global-frame position of each sTGC wire hit.

Definition at line 132 of file StgcPrdVariables.h.

132{parent(), "StgcWire_globalPos"};

◆ m_wireId

MuonVal::sTgcIdentifierBranch MuonValR4::StgcPrdVariables::m_wireId {parent(), "StgcWire"}
private

Identifier branch for sTGC wire hits.

Definition at line 130 of file StgcPrdVariables.h.

130{parent(), "StgcWire"};

◆ m_wireIdx

std::unordered_map<Identifier, unsigned int> MuonValR4::StgcPrdVariables::m_wireIdx {}
private

Map from wire-hit identifier to its output index.

Definition at line 179 of file StgcPrdVariables.h.

179{};

◆ m_wireKey

SG::ReadHandleKey<xAOD::sTgcWireContainer> MuonValR4::StgcPrdVariables::m_wireKey {}
private

StoreGate key for the sTGC wire-hit container.

Definition at line 108 of file StgcPrdVariables.h.

108{};

◆ m_wireLocal

MuonVal::VectorBranch<float>& MuonValR4::StgcPrdVariables::m_wireLocal {parent().newVector<float>("StgcWire_localPos")}
private

Measured local position of each wire hit, along local Y.

Definition at line 134 of file StgcPrdVariables.h.

134{parent().newVector<float>("StgcWire_localPos")};

◆ m_wireTime

MuonVal::VectorBranch<short>& MuonValR4::StgcPrdVariables::m_wireTime {parent().newVector<short>("StgcWire_time")}
private

Time recorded for each sTGC wire hit.

Definition at line 138 of file StgcPrdVariables.h.

138{parent().newVector<short>("StgcWire_time")};

The documentation for this class was generated from the following files: