ATLAS Offline Software
Loading...
Searching...
No Matches
TileMuonFilterAlg Class Reference

#include <TileMuonFilterAlg.h>

Inheritance diagram for TileMuonFilterAlg:
Collaboration diagram for TileMuonFilterAlg:

Public Member Functions

 TileMuonFilterAlg (const std::string &name, ISvcLocator *pSvcLocator)
 ~TileMuonFilterAlg ()
virtual StatusCode initialize ()
virtual StatusCode execute ()
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

std::string m_inputTracks
std::string m_outputTracks
std::string m_inputMuons
std::string m_outputMuons
std::string m_inputCells
std::string m_outputCells
std::string m_muonCells
float m_muonPt
float m_muonEta
float m_muonCellR
float m_isoCone
float m_ErelCut
bool m_dumpLarCells
bool m_useCuts
short m_trackType
ToolHandle< ITrackToolsm_trackInCalo
DataObjIDColl m_extendedExtraObjects
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 33 of file TileMuonFilterAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileMuonFilterAlg()

TileMuonFilterAlg::TileMuonFilterAlg ( const std::string & name,
ISvcLocator * pSvcLocator )

Definition at line 22 of file TileMuonFilterAlg.cxx.

22 :
23 AthAlgorithm( name, pSvcLocator ), m_trackInCalo("TrackTools")
24{
25//=======================================
26 declareProperty("InputTracks", m_inputTracks = "inDetTrackParticles");
27 declareProperty("InputMuons", m_inputMuons = "Muons");
28 declareProperty("OutputMuons", m_outputMuons = "SelectedMuons");
29 declareProperty("OutputTracks", m_outputTracks = "SelectedTracks");
30 declareProperty("InputCells", m_inputCells = "AODCellContainer");
31 declareProperty("OutputCells", m_outputCells = "SelectedCells");
32 declareProperty("MuonCells", m_muonCells = "muonCells");
33 declareProperty("MuonPtCut", m_muonPt = 10000.);
34 declareProperty("MuonEtaCut", m_muonEta = 1.7);
35 declareProperty("MuonCellR", m_muonCellR = 1.0);
36 declareProperty("IsoCone", m_isoCone = 0.4);
37 declareProperty("ErelCut", m_ErelCut = 0.1);
38 declareProperty("DumpLArCells", m_dumpLarCells = false);
39 declareProperty("UseCuts", m_useCuts = false);
40 declareProperty("TrackTools", m_trackInCalo);
41 declareProperty("TrackType", m_trackType = 1);
42}
AthAlgorithm()
Default constructor:
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
std::string m_outputMuons
ToolHandle< ITrackTools > m_trackInCalo
std::string m_inputTracks
std::string m_outputCells
std::string m_outputTracks

◆ ~TileMuonFilterAlg()

TileMuonFilterAlg::~TileMuonFilterAlg ( )
inline

Definition at line 39 of file TileMuonFilterAlg.h.

39{};

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode TileMuonFilterAlg::execute ( )
virtual

Returns true if this Muon passes the MCP ID hit cuts (see the MCP twiki for definitions: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonPerformance)

primaryTrackParticle() Returns a pointer (which should not usually be NULL, but might be if the muon has been stripped of information) to the primary TrackParticle corresponding to the MuonType of this muon. This is determined in the following order:

  1. CombinedTrackParticle
  2. InnerDetectorTrackParticle
  3. MuonSpectrometerTrackParticle

primaryTrackParticle() Returns a pointer (which should not usually be NULL, but might be if the muon has been stripped of information) to the primary TrackParticle corresponding to the MuonType of this muon. This is determined in the following order:

  1. CombinedTrackParticle
  2. InnerDetectorTrackParticle
  3. MuonSpectrometerTrackParticle

Definition at line 55 of file TileMuonFilterAlg.cxx.

55 {
56//=======================================
57 switch(m_trackType)
58 {
59 case 0: m_inputTracks = "CombinedMuonTrackParticles"; break;
60 case 1: m_inputTracks = "InDetTrackParticles" ; break;
61 case 2: m_inputTracks = "MuonSpectrometerTrackParticles" ; break;
62 default: m_inputTracks = "CombinedMuonTrackParticles"; break;
63 } // SWITCH
64
65
66 //Get the input tracks
67 const TRACKCONTAINER* inputTracks = 0;
68 CHECK( evtStore()->retrieve( inputTracks, m_inputTracks ) );
69
70 //Get the input Muons
71 const MUONCONTAINER* inputMuons = 0;
72 CHECK( evtStore()->retrieve( inputMuons, m_inputMuons ) );
73 ATH_MSG_DEBUG("Number of Muons: " << inputMuons->size());
74
75 //Allocate the output Muons container
76 MUONCONTAINER* outputMuons = new MUONCONTAINER;
77 MUONAUXCONTAINER* outputAuxMuons = new MUONAUXCONTAINER;
78 outputMuons->setStore( outputAuxMuons );
79
80
81 //Allocate the output tracks container
82 TRACKCONTAINER * outputTracks = new TRACKCONTAINER;
83 TRACKAUXCONTAINER* outputAuxTracks = new TRACKAUXCONTAINER;
84 outputTracks->setStore( outputAuxTracks );
85
86
87 //Get input cells
88 const CELLCONTAINER* inputCells = 0;
89 CHECK( evtStore()->retrieve( inputCells, m_inputCells ) );
90
91 //Allocate output cells container
92 ConstDataVector<CELLCONTAINER>* outputCells = new ConstDataVector<CELLCONTAINER>( SG::VIEW_ELEMENTS );
93 CHECK( evtStore()->record( outputCells, m_outputCells ) );
94
95 //Allocate cells container which will be refilled for every muon; temporary use only
96 ConstDataVector<CELLCONTAINER>* tmpCells = new ConstDataVector<CELLCONTAINER>( SG::VIEW_ELEMENTS );
97
98 //===============================================
99 const int Ncut=7;
100 int cut[Ncut];
101 for( int i = 0; i < Ncut; ++i) cut[i] = 0;
102 //===============================================
103
104 //Select Muons and corresponding tracks
105 MUONCONTAINER::const_iterator muonItr = inputMuons->begin();
106 MUONCONTAINER::const_iterator muonEnd = inputMuons->end();
107 for(; muonItr != muonEnd; ++muonItr ){
108 const MUON* muon = *muonItr;
109 if(!muon){ ATH_MSG_INFO("Not a valid muon"); continue; }
110 //Cut 0: combined muon // probably it is better to use this cut
111 if( m_useCuts && muon->muonType()!=xAOD::Muon::Combined ) continue;
112 cut[0]++;
113 //Cut 1: transverse momentum
114 if( m_useCuts && muon->pt() < m_muonPt ) continue;
115 cut[1]++;
116 //Cut 2: Eta
117 if( m_useCuts && fabs(muon->eta()) > m_muonEta ) continue;
118 cut[2]++;
119 if( m_useCuts )
120 {
121 //============Cut 3: Criteria for the associated inner detector track (all muon collections)=========
124 //if( !muon->passesIDCuts() ) continue; //it always returns flase when running on Muon Stream of data12 periodB
125 }
126 cut[3]++;
127 //=====================================================================================================
128
129 //===============save only muons which have the xAOD::TrackParticle of given m_trackType===========
136 const TRACK* muon_track = 0;
137 switch(m_trackType)
138 {
139 case 0: muon_track = muon->trackParticle(xAOD::Muon::CombinedTrackParticle); break;
140 case 1: muon_track = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle); break;
141 case 2: muon_track = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle); break;
142 default: muon_track = muon->primaryTrackParticle(); break;
143 } // SWITCH
144 if(!muon_track) continue;
145 cut[4]++;
146 //====================================================================
147
148 //Cut 5: Isolation
149 double Econe=0.;
150 TRACKCONTAINER::const_iterator trackItr = inputTracks->begin();
151 TRACKCONTAINER::const_iterator trackEnd = inputTracks->end();
152 for(; trackItr != trackEnd; ++trackItr ){
153 const TRACK* track = *trackItr;
154 if(muon_track==track) continue;
155 double dif_eta = muon_track->eta() - track->eta();
156 double dif_phi = muon_track->phi() - track->phi();
157 if(dif_phi<0) dif_phi=-dif_phi;
158 if(dif_phi>M_PI){dif_phi=2*M_PI-dif_phi;}
159 double deltaR = sqrt(dif_eta*dif_eta+dif_phi*dif_phi);
160 if(deltaR<m_isoCone) Econe += track->e();
161 }
162 if( m_useCuts && Econe/muon_track->e() > m_ErelCut ) continue;
163 cut[5]++;
164
165 //Fill the muon container
166 MUON* tmpMuon = new MUON();
167 tmpMuon->makePrivateStore( muon );
168 outputMuons->push_back(tmpMuon);
169 }// Muons loop
170
171
172 //Allocate output association between muons and cells
173 ASSOCCONTAINER* muonCells = new ASSOCCONTAINER_CONSTRUCTOR(outputMuons->size());
174 CHECK( evtStore()->record( muonCells, m_muonCells ) );
175 ASSOCCONTAINER::iterator assocItr = muonCells->begin();
176
177
178 muonItr = outputMuons->begin();
179 muonEnd = outputMuons->end();
180 for(; muonItr != muonEnd; ++muonItr ){
181 const MUON* muon = *muonItr;
182
189 const TRACK* muon_track = 0;
190 switch(m_trackType)
191 {
192 case 0: muon_track = muon->trackParticle(xAOD::Muon::CombinedTrackParticle); break;
193 case 1: muon_track = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle); break;
194 case 2: muon_track = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle); break;
195 default: muon_track = muon->primaryTrackParticle(); break;
196 } // SWITCH
197 if(!muon_track) continue;
198
199 //save the track associated to muon
200 TRACK* tmpTrack = new TRACK();
201 tmpTrack->makePrivateStore( muon_track );
202 outputTracks->push_back(tmpTrack);
203
204 tmpCells->clear();
205 m_trackInCalo->getCellsWithinConeAroundTrack(muon_track, inputCells, tmpCells, m_muonCellR , m_dumpLarCells );
206
207 //loop over the selected cells in order to associat to muon
208 CELLCONTAINER::const_iterator cellItr = tmpCells->begin();
209 CELLCONTAINER::const_iterator cellEnd = tmpCells->end();
210 for( ;cellItr != cellEnd; ++cellItr){
211 const CELL* cell = *cellItr;
212 unsigned int i=0;
213 while(i!=outputCells->size()){if(outputCells->at(i)==cell){break;}i++;}
214 if(i==outputCells->size()){
215 outputCells->push_back(cell);
216 }
217 assocItr->push_back(i);//FIXME
218 }
219 ++assocItr;
220 }// output Muons loop
221
222 //for( int i = 0; i < Ncut; ++i) ATH_MSG_INFO(" cut["<<i<<"] = "<< cut[i] );
223
224 ATH_MSG_DEBUG("Number of selected Muons: "<< outputMuons->size() );
225 ATH_MSG_DEBUG("Number of selected cells: " << outputCells->size());
226
227 CHECK( evtStore()->record(outputMuons, m_outputMuons) );
228 CHECK( evtStore()->record(outputAuxMuons,m_outputMuons+"Aux.") );
229 CHECK( evtStore()->record(outputTracks, m_outputTracks) );
230 CHECK( evtStore()->record(outputAuxTracks,m_outputTracks+"Aux.") );
231
232 delete tmpCells; // clean up memory
233 return StatusCode::SUCCESS;
234}
#define M_PI
Scalar deltaR(const MatrixBase< Derived > &vec) const
#define ATH_MSG_INFO(x)
#define ATH_MSG_DEBUG(x)
#define CHECK(...)
Evaluate an expression and check for errors.
xAOD::TrackParticleAuxContainer TRACKAUXCONTAINER
xAOD::TrackParticle TRACK
CaloCell CELL
CALORIMETER INCLUDES.
CaloCellContainer CELLCONTAINER
xAOD::TrackParticleContainer TRACKCONTAINER
xAOD::MuonContainer MUONCONTAINER
xAOD::Muon MUON
D3PD INCLUDES.
xAOD::MuonAuxContainer MUONAUXCONTAINER
std::vector< std::vector< int > > ASSOCCONTAINER
#define ASSOCCONTAINER_CONSTRUCTOR(size)
value_type push_back(value_type pElem)
Add an element to the end of the collection.
iterator begin() noexcept
Return an iterator pointing at the beginning of the collection.
iterator end() noexcept
Return an iterator pointing past the end of the collection.
ElementProxy at(size_type n)
Access an element, as an lvalue.
void clear()
Erase all the elements in the collection.
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
value_type push_back(value_type pElem)
Add an element to the end of the collection.
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
void makePrivateStore()
Create a new (empty) private store for this object.
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
virtual double e() const override final
The total energy of the particle.
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
retrieve(aClass, aKey=None)
Definition PyKernel.py:110

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51{
52 // If we didn't find any symlinks to add, just return the collection
53 // from the base class. Otherwise, return the extended collection.
54 if (!m_extendedExtraObjects.empty()) {
56 }
57 return Algorithm::extraOutputDeps();
58}
DataObjIDColl m_extendedExtraObjects

◆ initialize()

StatusCode TileMuonFilterAlg::initialize ( )
virtual

Definition at line 45 of file TileMuonFilterAlg.cxx.

45 {
46//=======================================
47 ATH_MSG_INFO("TileMuonFilterAlg::initialize()");
48
49 CHECK(m_trackInCalo.retrieve());
50
51 return StatusCode::SUCCESS;
52}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Algorithm >::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< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
384 }
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)

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
366 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

66 {
68
69 if (sc.isFailure()) {
70 return sc;
71 }
72 ServiceHandle<ICondSvc> cs("CondSvc",name());
73 for (auto h : outputHandles()) {
74 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75 // do this inside the loop so we don't create the CondSvc until needed
76 if ( cs.retrieve().isFailure() ) {
77 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78 return StatusCode::SUCCESS;
79 }
80 if (cs->regHandle(this,*h).isFailure()) {
81 sc = StatusCode::FAILURE;
82 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83 << " with CondSvc");
84 }
85 }
86 }
87 return sc;
88}
#define ATH_MSG_ERROR(x)
#define ATH_MSG_WARNING(x)
static Double_t sc
virtual StatusCode sysInitialize() override
Override sysInitialize.
AthCommonDataStore(const std::string &name, T... args)
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
::StatusCode StatusCode
StatusCode definition for legacy code.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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) {
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
std::vector< SG::VarHandleKeyArray * > m_vhka

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dumpLarCells

bool TileMuonFilterAlg::m_dumpLarCells
private

Definition at line 58 of file TileMuonFilterAlg.h.

◆ m_ErelCut

float TileMuonFilterAlg::m_ErelCut
private

Definition at line 57 of file TileMuonFilterAlg.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_inputCells

std::string TileMuonFilterAlg::m_inputCells
private

Definition at line 50 of file TileMuonFilterAlg.h.

◆ m_inputMuons

std::string TileMuonFilterAlg::m_inputMuons
private

Definition at line 48 of file TileMuonFilterAlg.h.

◆ m_inputTracks

std::string TileMuonFilterAlg::m_inputTracks
private

Definition at line 46 of file TileMuonFilterAlg.h.

◆ m_isoCone

float TileMuonFilterAlg::m_isoCone
private

Definition at line 56 of file TileMuonFilterAlg.h.

◆ m_muonCellR

float TileMuonFilterAlg::m_muonCellR
private

Definition at line 55 of file TileMuonFilterAlg.h.

◆ m_muonCells

std::string TileMuonFilterAlg::m_muonCells
private

Definition at line 52 of file TileMuonFilterAlg.h.

◆ m_muonEta

float TileMuonFilterAlg::m_muonEta
private

Definition at line 54 of file TileMuonFilterAlg.h.

◆ m_muonPt

float TileMuonFilterAlg::m_muonPt
private

Definition at line 53 of file TileMuonFilterAlg.h.

◆ m_outputCells

std::string TileMuonFilterAlg::m_outputCells
private

Definition at line 51 of file TileMuonFilterAlg.h.

◆ m_outputMuons

std::string TileMuonFilterAlg::m_outputMuons
private

Definition at line 49 of file TileMuonFilterAlg.h.

◆ m_outputTracks

std::string TileMuonFilterAlg::m_outputTracks
private

Definition at line 47 of file TileMuonFilterAlg.h.

◆ m_trackInCalo

ToolHandle<ITrackTools> TileMuonFilterAlg::m_trackInCalo
private

Definition at line 63 of file TileMuonFilterAlg.h.

◆ m_trackType

short TileMuonFilterAlg::m_trackType
private

Definition at line 60 of file TileMuonFilterAlg.h.

◆ m_useCuts

bool TileMuonFilterAlg::m_useCuts
private

Definition at line 59 of file TileMuonFilterAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


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