ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
NSWL1::StripClusterTool Class Referenceabstract

interface for the StripTDS tools More...

#include <StripClusterTool.h>

Inheritance diagram for NSWL1::StripClusterTool:
Collaboration diagram for NSWL1::StripClusterTool:

Public Member Functions

 StripClusterTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~StripClusterTool ()=default
 
virtual StatusCode initialize () override
 
virtual void handle (const Incident &inc) override
 
virtual StatusCode cluster_strip_data (const EventContext &ctx, std::vector< std::unique_ptr< StripData >> &strips, std::vector< std::unique_ptr< StripClusterData >> &clusters) const override
 
virtual StatusCode cluster_strip_data (const EventContext &ctx, std::vector< std::unique_ptr< StripData >> &strips, std::vector< std::unique_ptr< StripClusterData > > &clusters) const =0
 
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 ()
 

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 init_branches ()
 init the branches More...
 
StatusCode book_branches ()
 book the branches to analyze the StripTds More...
 
void clear_ntuple_variables ()
 clear the variables used in the analysis More...
 
StatusCode fill_strip_validation_id (const EventContext &ctx, std::vector< std::unique_ptr< StripClusterData >> &clusters, std::vector< std::shared_ptr< std::vector< std::unique_ptr< StripData > >> > &cluster_cache) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ServiceHandle< IIncidentSvc > m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
 Athena/Gaudi incident Service. More...
 
const MuonGM::MuonDetectorManager * m_detManager
 MuonDetectorManager. More...
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
Gaudi::Property< bool > m_isMC {this, "IsMC", true, "This is MC"}
 
Gaudi::Property< bool > m_doNtuple {this, "DoNtuple", false, "Input the sTGC strip cluster branches into the analysis ntuple"}
 
SG::ReadHandleKey< MuonSimDataCollection > m_sTgcSdoContainerKey {this,"sTGC_SdoContainerName", "sTGC_SDO", "the name of the sTGC SDO container"}
 
TTree * m_tree {nullptr}
 ntuple for analysis More...
 
int m_cl_n ATLAS_THREAD_SAFE
 number of STRIP hit delivered More...
 
std::vector< int > *m_cl_charge ATLAS_THREAD_SAFE {nullptr}
 charge of hit STRIPs More...
 
std::vector< int > *m_cl_size ATLAS_THREAD_SAFE {nullptr}
 charge of hit STRIPs More...
 
std::vector< float > *m_cl_x ATLAS_THREAD_SAFE {nullptr}
 global x position of cluster More...
 
std::vector< float > *m_cl_y ATLAS_THREAD_SAFE {nullptr}
 global y position of cluster More...
 
std::vector< float > *m_cl_z ATLAS_THREAD_SAFE {nullptr}
 global z position of cluster More...
 
std::vector< float > *m_cl_lx ATLAS_THREAD_SAFE {nullptr}
 global x position of cluster More...
 
std::vector< float > *m_cl_ly ATLAS_THREAD_SAFE {nullptr}
 global y position of cluster More...
 
std::vector< float > *m_cl_lz ATLAS_THREAD_SAFE {nullptr}
 global z position of cluster More...
 
std::vector< float > *m_cl_ltgx ATLAS_THREAD_SAFE {nullptr}
 global x position of cluster More...
 
std::vector< float > *m_cl_ltgy ATLAS_THREAD_SAFE {nullptr}
 global y position of cluster More...
 
std::vector< float > *m_cl_ltgz ATLAS_THREAD_SAFE {nullptr}
 global z position of cluster More...
 
std::vector< float > *m_cl_truth_x ATLAS_THREAD_SAFE {nullptr}
 global x of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_y ATLAS_THREAD_SAFE {nullptr}
 global y of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_z ATLAS_THREAD_SAFE {nullptr}
 global z of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_lx ATLAS_THREAD_SAFE {nullptr}
 local x of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_ly ATLAS_THREAD_SAFE {nullptr}
 local y of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_lz ATLAS_THREAD_SAFE {nullptr}
 local z of first truth hit for strip in cluster More...
 
std::vector< float > *m_cl_truth_E ATLAS_THREAD_SAFE {nullptr}
 global energy of truth strip deposits More...
 
std::vector< int > *m_cl_truth_n ATLAS_THREAD_SAFE {nullptr}
 Cluster index for truth strip hits. More...
 
std::vector< int > *m_cl_side ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_isSmall ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_wedge ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_sector ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_module ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_layer ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_bandId ATLAS_THREAD_SAFE {nullptr}
 
std::vector< int > *m_cl_phiId ATLAS_THREAD_SAFE {nullptr}
 
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

interface for the StripTDS tools

This class implements the Strip Clustering offline simulation. It loops over the hits, readout from the StripTDSOffLineTool

Author
Jacob Searcy jsear.nosp@m.cy@c.nosp@m.ern.c.nosp@m.h

Definition at line 55 of file StripClusterTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ StripClusterTool()

NSWL1::StripClusterTool::StripClusterTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 11 of file StripClusterTool.cxx.

11  :
12  AthAlgTool(type,name,parent),
13  m_detManager(nullptr),
14  m_tree(nullptr)
15  {
16  declareInterface<NSWL1::IStripClusterTool>(this);
17  }

◆ ~StripClusterTool()

virtual NSWL1::StripClusterTool::~StripClusterTool ( )
virtualdefault

Member Function Documentation

◆ book_branches()

StatusCode NSWL1::StripClusterTool::book_branches ( )
private

book the branches to analyze the StripTds

Definition at line 96 of file StripClusterTool.cxx.

96  {
97  m_cl_n= 0;
98  m_cl_charge = new std::vector< int >();
99  m_cl_size = new std::vector< int >();
100  m_cl_x= new std::vector< float >();
101  m_cl_y= new std::vector< float >();
102  m_cl_z= new std::vector< float >();
103  m_cl_lx= new std::vector< float >();
104  m_cl_ly= new std::vector< float >();
105  m_cl_lz= new std::vector< float >();
106  m_cl_ltgx= new std::vector< float >();
107  m_cl_ltgy= new std::vector< float >();
108  m_cl_ltgz= new std::vector< float >();
109  m_cl_truth_x= new std::vector<float >();
110  m_cl_truth_y= new std::vector<float >();
111  m_cl_truth_z= new std::vector<float>();
112  m_cl_truth_lx= new std::vector<float >();
113  m_cl_truth_ly= new std::vector<float >();
114  m_cl_truth_lz= new std::vector<float>();
115  m_cl_truth_E= new std::vector<float >();
116  m_cl_truth_n= new std::vector<int >();
117  m_cl_side= new std::vector<int>();
118  m_cl_isSmall= new std::vector<int>();
119  m_cl_wedge= new std::vector<int>();
120  m_cl_sector= new std::vector<int>();
121  m_cl_module= new std::vector<int>();
122  m_cl_layer= new std::vector<int>();
123  m_cl_bandId= new std::vector<int>();
124  m_cl_phiId= new std::vector<int>();
125 
126  if (m_tree) {
127  std::string ToolName = name().substr( name().find("::")+2,std::string::npos );
128  const char* n = ToolName.c_str();
129  m_tree->Branch(TString::Format("%s_cl_n",n).Data(),&m_cl_n,TString::Format("%s_cl_n/i",n).Data());
130  m_tree->Branch(TString::Format("%s_cl_charge",n).Data(),&m_cl_charge);
131  m_tree->Branch(TString::Format("%s_cl_x",n).Data(),&m_cl_x);
132  m_tree->Branch(TString::Format("%s_cl_y",n).Data(),&m_cl_y);
133  m_tree->Branch(TString::Format("%s_cl_z",n).Data(),&m_cl_z);
134  m_tree->Branch(TString::Format("%s_cl_lx",n).Data(),&m_cl_lx);
135  m_tree->Branch(TString::Format("%s_cl_ly",n).Data(),&m_cl_ly);
136  m_tree->Branch(TString::Format("%s_cl_lz",n).Data(),&m_cl_lz);
137  m_tree->Branch(TString::Format("%s_cl_ltgx",n).Data(),&m_cl_ltgx);
138  m_tree->Branch(TString::Format("%s_cl_ltgy",n).Data(),&m_cl_ltgy);
139  m_tree->Branch(TString::Format("%s_cl_ltgz",n).Data(),&m_cl_ltgz);
140  m_tree->Branch(TString::Format("%s_cl_size",n).Data(),&m_cl_size);
141  m_tree->Branch(TString::Format("%s_cl_isSmall",n).Data(),&m_cl_isSmall);
142  m_tree->Branch(TString::Format("%s_cl_side",n).Data(),&m_cl_side);
143  m_tree->Branch(TString::Format("%s_cl_wedge",n).Data(),&m_cl_wedge);
144  m_tree->Branch(TString::Format("%s_cl_sector",n).Data(),&m_cl_sector);
145  m_tree->Branch(TString::Format("%s_cl_module",n).Data(),&m_cl_module);
146  m_tree->Branch(TString::Format("%s_cl_layer",n).Data(),&m_cl_layer);
147  m_tree->Branch(TString::Format("%s_cl_bandId",n).Data(),&m_cl_bandId);
148  m_tree->Branch(TString::Format("%s_cl_phiId",n).Data(),&m_cl_phiId);
149  m_tree->Branch(TString::Format("%s_cl_truth_x",n).Data(),&m_cl_truth_x);
150  m_tree->Branch(TString::Format("%s_cl_truth_y",n).Data(),&m_cl_truth_y);
151  m_tree->Branch(TString::Format("%s_cl_truth_z",n).Data(),&m_cl_truth_z);
152  m_tree->Branch(TString::Format("%s_cl_truth_lx",n).Data(),&m_cl_truth_lx);
153  m_tree->Branch(TString::Format("%s_cl_truth_ly",n).Data(),&m_cl_truth_ly);
154  m_tree->Branch(TString::Format("%s_cl_truth_lz",n).Data(),&m_cl_truth_lz);
155  m_tree->Branch(TString::Format("%s_cl_truth_E",n).Data(),&m_cl_truth_E);
156  m_tree->Branch(TString::Format("%s_cl_truth_n",n).Data(),&m_cl_truth_n);
157  }
158  return StatusCode::SUCCESS;
159  }

◆ clear_ntuple_variables()

void NSWL1::StripClusterTool::clear_ntuple_variables ( )
private

clear the variables used in the analysis

Definition at line 161 of file StripClusterTool.cxx.

161  {
162  if ( m_tree==0 ) return;
163 
164  //clear the ntuple variables
165  m_cl_n = 0;
166  m_cl_charge->clear();
167  m_cl_x->clear();
168  m_cl_y->clear();
169  m_cl_z->clear();
170  m_cl_lx->clear();
171  m_cl_ly->clear();
172  m_cl_lz->clear();
173  m_cl_ltgx->clear();
174  m_cl_ltgy->clear();
175  m_cl_ltgz->clear();
176  m_cl_size->clear();
177  m_cl_truth_x->clear();
178  m_cl_truth_y->clear();
179  m_cl_truth_z->clear();
180  m_cl_truth_E->clear();
181  m_cl_truth_n->clear();
182  m_cl_truth_lx->clear();
183  m_cl_truth_ly->clear();
184  m_cl_truth_lz->clear();
185  m_cl_side->clear();
186  m_cl_isSmall->clear();
187  m_cl_wedge->clear();
188  m_cl_sector->clear();
189  m_cl_module->clear();
190  m_cl_layer->clear();
191  m_cl_bandId->clear();
192  m_cl_phiId->clear();
193  }

◆ cluster_strip_data() [1/2]

virtual StatusCode NSWL1::IStripClusterTool::cluster_strip_data ( const EventContext &  ctx,
std::vector< std::unique_ptr< StripData >> &  strips,
std::vector< std::unique_ptr< StripClusterData > > &  clusters 
) const
pure virtualinherited

◆ cluster_strip_data() [2/2]

StatusCode NSWL1::StripClusterTool::cluster_strip_data ( const EventContext &  ctx,
std::vector< std::unique_ptr< StripData >> &  strips,
std::vector< std::unique_ptr< StripClusterData >> &  clusters 
) const
overridevirtual

Definition at line 373 of file StripClusterTool.cxx.

373  {
374 
375  if(strips.empty()){
376  ATH_MSG_WARNING("Received 0 strip hits... Skip event");
377  return StatusCode::SUCCESS;
378  }
379 
380  std::map<uint32_t, std::vector<std::unique_ptr<StripData>> > stripMap;
381  // Filter by layer:
382  for (auto& st : strips) {
383  // sideId [0, 1]
384  auto sideId = st->sideId();
385  // sectorType: small==0, large==1
386  auto sectorType = st->sectorType();
387  // sectorId [1,8]
388  auto sectorId = st->sectorId();
389  // etaId [1,3]
390  auto etaId = st->moduleId();
391  // wedgeId [1,2]
392  auto wedgeId = st->wedge();
393  // layer [1,4]
394  auto layerId = st->layer();
395 
396  // add 1 as the first placeholder, hence cache_hash always has 7 digits
397  std::string id_str = std::to_string(1)+std::to_string(sideId)+std::to_string(sectorType)+std::to_string(sectorId)+std::to_string(etaId)+std::to_string(wedgeId)+std::to_string(layerId);
398  const uint32_t cache_hash = atoi(id_str.c_str());
399 
400  auto it = stripMap.find(cache_hash);
401  if (it != stripMap.end()){
402  it->second.push_back(std::move(st));
403  }
404  else{
405  stripMap[cache_hash].push_back(std::move(st));
406  }
407 
408  }
409 
410  std::vector< std::shared_ptr<std::vector<std::unique_ptr<StripData> >> > cluster_cache;
411  for (auto &item : stripMap) {
412  std::vector<std::unique_ptr<StripData>>& stripList = item.second;
413 
414  //S.I sort strip w.r.t channelId in ascending order
415  std::sort(stripList.begin(), stripList.end(), [](const auto& s1,const auto& s2) { return s1->channelId()<s2->channelId(); });
416 
417  auto hit=stripList.begin();
418  ATH_MSG_DEBUG("Cluster Hits :" << (*hit)->channelId() << " " << m_idHelperSvc->stgcIdHelper().gasGap( (*hit)->Identity())
419  << " " << (*hit)->moduleId() << " " << (*hit)->sectorId() << " " << (*hit)->wedge() << " " << (*hit)->sideId() );
420  int first_ch=(*hit)->channelId();//channel id of the first strip
421  int prev_ch=-1;
422 
423  auto cr_cluster=std::make_shared< std::vector<std::unique_ptr<StripData>> >();
424 
425  for(auto& this_hit : stripList){
426  if(!(this_hit)->readStrip() ) continue;
427  if( ((this_hit)->bandId()==-1 || this_hit->phiId()==-1) ){
428  ATH_MSG_WARNING("Read Strip without BandId :" << (this_hit)->channelId() << " " << m_idHelperSvc->stgcIdHelper().gasGap( (this_hit)->Identity())
429  << " " << (this_hit)->moduleId() << " " << (this_hit)->sectorId() << " " << (this_hit)->wedge() << " " << (this_hit)->sideId() );
430  continue;
431  }
432 
433  if (prev_ch==-1){//for the first time...
434  prev_ch = first_ch;
435  cr_cluster->push_back(std::move(this_hit));
436  continue;
437  }
438 
439  int this_ch=(this_hit)->channelId();
440  if ( (this_ch < prev_ch)) {
441  ATH_MSG_ERROR("Hits Ordered incorrectly!!!" );
442  return StatusCode::FAILURE;
443  }
444 
445  if (this_ch == prev_ch || this_ch == prev_ch+1) cr_cluster->push_back(std::move(this_hit)); // form cluster with adjacent +-1 strips
446  else {
447  cluster_cache.push_back(std::move(cr_cluster)); //put the current cluster into the clusters buffer
448  cr_cluster=std::make_shared<std::vector<std::unique_ptr<StripData>>>(); //create a new empty cluster and assign this hit as the first hit
449  cr_cluster->push_back(std::move(this_hit));
450  }
451 
452  prev_ch=this_ch;
453  }
454 
455  if(!cr_cluster->empty()) cluster_cache.push_back(std::move(cr_cluster)); //don't forget the last cluster in the loop
456  }
457 
458  ATH_MSG_DEBUG("Found :" << cluster_cache.size() << " clusters");
459  ATH_CHECK(fill_strip_validation_id(ctx, clusters, cluster_cache));
460  cluster_cache.clear();
461 
462  return StatusCode::SUCCESS;
463  }

◆ 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

◆ fill_strip_validation_id()

StatusCode NSWL1::StripClusterTool::fill_strip_validation_id ( const EventContext &  ctx,
std::vector< std::unique_ptr< StripClusterData >> &  clusters,
std::vector< std::shared_ptr< std::vector< std::unique_ptr< StripData > >> > &  cluster_cache 
) const
private

Definition at line 195 of file StripClusterTool.cxx.

197  {
198 
199  ATH_MSG_DEBUG("Cluster cache received " << cluster_cache.size());
200 
201  bool first_strip=true;
202  for(const auto &this_cl : cluster_cache){
203  float x_pos=0;
204  float y_pos=0;
205  float z_pos=0;
206 
207  float x_lpos=0;
208  float y_lpos=0;
209  float z_lpos=0;
210 
211  int charge=0;
212  int n_strip=0;
213 
214  first_strip=true;
215  float locx=-999999;
216  float locy=-999999;
217  if (this_cl->empty()){
218  ATH_MSG_WARNING("Zero size cluster!!");
219  continue;
220  }
221 
222  const MuonSimDataCollection* sdo_container = nullptr;
223  if(m_isMC) {
224  SG::ReadHandle<MuonSimDataCollection> readMuonSimDataCollection( m_sTgcSdoContainerKey, ctx );
225  if( !readMuonSimDataCollection.isValid() ){
226  ATH_MSG_WARNING("could not retrieve the sTGC SDO container: it will not be possible to associate the MC truth");
227  return StatusCode::FAILURE;
228  }
229  sdo_container = readMuonSimDataCollection.cptr();
230  }
231 
232  for(const auto &strip_cl : *this_cl){
233  n_strip++;
234  ATH_MSG_DEBUG("Start strip" << n_strip);
235  // Save truth deposits associated with cluster should be the same on for the whole strip, so take the first one need to work on this logic
236  if(m_isMC && first_strip) {
237  first_strip=false;
238  Identifier Id = strip_cl->Identity();
239  const MuonGM::sTgcReadoutElement* rdoEl = m_detManager->getsTgcReadoutElement(Id);
240  auto it = sdo_container->find(Id);
241  if(it == sdo_container->end()) continue;
242  const MuonSimData strip_sdo = it->second;
243  std::vector<MuonSimData::Deposit> deposits;
244  strip_sdo.deposits(deposits);
245  //retrieve the info of the first associated hit, i.e. the fastest in time
246  if (deposits.size()!=1) ATH_MSG_WARNING("Multiple cluster hits for strip!");
247  if (deposits.empty()){
248  ATH_MSG_WARNING("Empty hit here");
249  continue;
250  }
251 
252  int truth_barcode = deposits[0].first.barcode();
253  double truth_localPosX = deposits[0].second.firstEntry();
254  double truth_localPosY = deposits[0].second.secondEntry();
255  Amg::Vector3D hit_gpos(0.,0.,0.);
256  Amg::Vector2D lpos(truth_localPosX,truth_localPosY);
257  rdoEl->surface(Id).localToGlobal(lpos, hit_gpos,hit_gpos);
258  double truth_globalPosX = hit_gpos.x();
259  double truth_globalPosY = hit_gpos.y();
260  double truth_globalPosZ = hit_gpos.z();
261  float truth_energy = strip_sdo.word();
262 
263  if(std::abs(locx-lpos.x())>.001 || std::abs(locy - lpos.y())>.001){
264  ATH_MSG_DEBUG("OLD locx " << locx << " new locx " << lpos.x() << " b " << int(locx!=lpos.x()));
265  ATH_MSG_DEBUG("OLD locy " << locy << " new locy " << lpos.y() << " b " << int(locy!=lpos.y()));
266  ATH_MSG_DEBUG("Cluster hit, truth barcode = " << truth_barcode);
267  ATH_MSG_DEBUG("Cluster hit, truth globalPosX = " << truth_globalPosX
268  << ", truth globalPosY = " << truth_globalPosY
269  << ", truth globalPosZ = " << truth_globalPosZ
270  << ", truth enegy deposit = " << truth_energy);
271  ATH_MSG_DEBUG("Cluster hit, truth localPosX = " << lpos.x()
272  << ", truth localPosY = " << lpos.y()
273  << ", truth enegy deposit = " << truth_energy);
274 
275  if (m_doNtuple) {
276  m_cl_truth_x->push_back( hit_gpos.x() );
277  m_cl_truth_y->push_back( hit_gpos.y() );
278  m_cl_truth_z->push_back( hit_gpos.z() );
279 
280  m_cl_truth_lx->push_back( lpos.x() );
281  m_cl_truth_ly->push_back( lpos.y() );
282  m_cl_truth_lz->push_back( 0 );
283  m_cl_truth_E->push_back( truth_energy );
284  }
285  }
286  }
287 
288  float s_charge=strip_cl->strip_charge_6bit();
289  charge+=s_charge;
290  x_pos+=strip_cl->globX()*s_charge;
291  y_pos+=strip_cl->globY()*s_charge;
292  z_pos+=strip_cl->globZ()*s_charge;
293 
294  x_lpos+=(strip_cl->locX())*s_charge;
295  y_lpos+=(strip_cl->locY())*s_charge;
296  z_lpos+=(strip_cl->locZ())*s_charge;
297 
298 
299  ATH_MSG_DEBUG("Cluster ------------------------------------------" );
300  ATH_MSG_DEBUG("Cluster strip charge: " << s_charge);
301  ATH_MSG_DEBUG("Cluster strip loc X: " << strip_cl->locX());
302  ATH_MSG_DEBUG("Cluster strip loc Y: " << strip_cl->locY());
303  ATH_MSG_DEBUG("Cluster strip glob X: " << strip_cl->globX());
304  ATH_MSG_DEBUG("Cluster strip glob Y: " << strip_cl->globY());
305  ATH_MSG_DEBUG("Cluster strip glob Z: " << strip_cl->globZ());
306  ATH_MSG_DEBUG("Cluster strip locx dist: " << locx-strip_cl->locX());
307  ATH_MSG_DEBUG("Cluster strip charge o dist: " << s_charge/(locx-strip_cl->locX()));
308  ATH_MSG_DEBUG("Channel " << strip_cl->channelId());
309 
310  }//end of this_cl loop
311 
312  if (charge != 0){
313  if ( std::abs(x_pos/charge)<200. && std::abs(y_pos/charge)<200.){
314  ATH_MSG_WARNING("Cluster ------------------------------------------" );
315  ATH_MSG_WARNING("Cluster strip charge: " << charge );
316  ATH_MSG_WARNING("Cluster strip glob X: " << x_pos << x_pos/charge);
317  ATH_MSG_WARNING("Cluster strip glob Y: " << y_pos << y_pos/charge);
318  ATH_MSG_WARNING("Cluster strip glob Z: " << z_pos << z_pos/charge);
319  }
320  x_pos=x_pos/charge;
321  y_pos=y_pos/charge;
322  z_pos=z_pos/charge;
323  x_lpos=x_lpos/charge;
324  y_lpos=y_lpos/charge;
325  z_lpos=z_lpos/charge;
326  }
327  if (m_doNtuple) {
328  m_cl_x->push_back(x_pos);
329  m_cl_y->push_back(y_pos);
330  m_cl_z->push_back(z_pos);
331 
332  m_cl_lx->push_back(x_lpos);
333  m_cl_ly->push_back(y_lpos);
334  m_cl_lz->push_back(z_lpos);
335  m_cl_charge->push_back(charge);
336  m_cl_size->push_back(n_strip);
337 
338  m_cl_side->push_back(this_cl->at(0)->sideId() );
339  m_cl_isSmall->push_back(this_cl->at(0)->isSmall() );
340  m_cl_wedge->push_back(this_cl->at(0)->wedge());
341  m_cl_sector->push_back(this_cl->at(0)->sectorId());
342  m_cl_module->push_back(this_cl->at(0)->moduleId() );
343  m_cl_layer->push_back(this_cl->at(0)->layer());
344  m_cl_bandId->push_back(this_cl->at(0)->bandId());
345  m_cl_phiId->push_back(this_cl->at(0)->phiId());
346  }
347  ATH_MSG_DEBUG("Cluster dump with X:" << x_pos << " Y: " << y_pos << " Z: " << z_pos << " cluster charge: " << charge);
348  ATH_MSG_DEBUG("Cluster dump with lX:" << x_lpos << " lY: " << y_lpos << " lZ: " << z_lpos << " cluster charge: " << charge);
349 
350  auto stripClOfflData=std::make_unique<StripClusterOfflineData>(
351  this_cl->at(0)->bandId(),
352  this_cl->at(0)->trig_BCID(),
353  this_cl->at(0)->sideId(),
354  this_cl->at(0)->phiId(),
355  this_cl->at(0)->isSmall(),
356  this_cl->at(0)->moduleId(),
357  this_cl->at(0)->sectorId(),
358  this_cl->at(0)->wedge(),
359  this_cl->at(0)->layer(),
360  n_strip,
361  charge,
362  x_pos,
363  y_pos,
364  z_pos);
365  clusters.push_back(std::move(stripClOfflData));
366  }
367  if (m_doNtuple) m_cl_n = clusters.size();
368  ATH_MSG_DEBUG("Finished Fill");
369  return StatusCode::SUCCESS;
370  }

◆ handle()

void NSWL1::StripClusterTool::handle ( const Incident &  inc)
overridevirtual

Definition at line 57 of file StripClusterTool.cxx.

57  {
58  if( inc.type()==IncidentType::BeginEvent ) {
59  this->clear_ntuple_variables();
60  }
61  }

◆ init_branches()

StatusCode NSWL1::StripClusterTool::init_branches ( )
private

init the branches

Definition at line 63 of file StripClusterTool.cxx.

63  {
64  m_cl_n = 0;
65  m_cl_charge = nullptr;
66  m_cl_size = nullptr;
67  m_cl_x = nullptr;
68  m_cl_y = nullptr;
69  m_cl_z = nullptr;
70  m_cl_lx = nullptr;
71  m_cl_ly = nullptr;
72  m_cl_lz = nullptr;
73  m_cl_ltgx = nullptr;
74  m_cl_ltgy = nullptr;
75  m_cl_ltgz = nullptr;
76  m_cl_truth_x = nullptr;
77  m_cl_truth_y = nullptr;
78  m_cl_truth_z = nullptr;
79  m_cl_truth_lx = nullptr;
80  m_cl_truth_ly = nullptr;
81  m_cl_truth_lz = nullptr;
82  m_cl_truth_E = nullptr;
83  m_cl_truth_n = nullptr;
84  m_cl_side = nullptr;
85  m_cl_isSmall = nullptr;
86  m_cl_wedge = nullptr;
87  m_cl_sector = nullptr;
88  m_cl_module = nullptr;
89  m_cl_layer = nullptr;
90  m_cl_bandId = nullptr;
91  m_cl_phiId = nullptr;
92 
93  return StatusCode::SUCCESS;
94  }

◆ initialize()

StatusCode NSWL1::StripClusterTool::initialize ( )
overridevirtual

Definition at line 19 of file StripClusterTool.cxx.

19  {
20  ATH_MSG_DEBUG( "initializing " << name() );
21  ATH_MSG_DEBUG( name() << " configuration:");
22  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_doNtuple.name() << ((m_doNtuple)? "[True]":"[False]")
23  << std::setfill(' ') << std::setiosflags(std::ios::right) );
24 
25  ATH_CHECK(m_sTgcSdoContainerKey.initialize(m_isMC));
26 
27  const IInterface* parent = this->parent();
28  const INamedInterface* pnamed = dynamic_cast<const INamedInterface*>(parent);
29  const std::string& algo_name = pnamed->name();
30 
31  if ( m_doNtuple ) {
32  if (Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
33  ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
34  return StatusCode::FAILURE;
35  }
36 
37  ATH_CHECK( m_incidentSvc.retrieve() );
38  m_incidentSvc->addListener(this,IncidentType::BeginEvent);
39 
40  if ( algo_name=="NSWL1Simulation" ){
41  SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
42  ATH_CHECK( tHistSvc.isValid() );
43  m_tree = 0;
44  std::string ntuple_name = algo_name+"Tree";
45  ATH_CHECK(this->init_branches());
46  ATH_CHECK(tHistSvc->getTree(ntuple_name,m_tree));
47  ATH_CHECK(this->book_branches());
48  }
49  }
50 
51  // retrieve the MuonDetectormanager
52  ATH_CHECK(detStore()->retrieve( m_detManager ));
53  ATH_CHECK(m_idHelperSvc.retrieve());
54  return StatusCode::SUCCESS;
55  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

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

◆ interfaceID()

static const InterfaceID& NSWL1::IStripClusterTool::interfaceID ( )
inlinestaticinherited

Definition at line 41 of file IStripClusterTool.h.

41  {
42  static const InterfaceID IID_IStripClusterTool("NSWL1::IStripClusterTool", 1 ,0);
43  return IID_IStripClusterTool;
44  }

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

◆ 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

◆ ATLAS_THREAD_SAFE [1/28]

int m_cl_n NSWL1::StripClusterTool::ATLAS_THREAD_SAFE
mutableprivate

number of STRIP hit delivered

Definition at line 90 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [2/28]

std::vector<int>* m_cl_charge NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

charge of hit STRIPs

Definition at line 91 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [3/28]

std::vector<int>* m_cl_size NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

charge of hit STRIPs

Definition at line 92 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [4/28]

std::vector<float>* m_cl_x NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global x position of cluster

Definition at line 93 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [5/28]

std::vector<float>* m_cl_y NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global y position of cluster

Definition at line 94 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [6/28]

std::vector<float>* m_cl_z NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global z position of cluster

Definition at line 95 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [7/28]

std::vector<float>* m_cl_lx NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global x position of cluster

Definition at line 96 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [8/28]

std::vector<float>* m_cl_ly NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global y position of cluster

Definition at line 97 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [9/28]

std::vector<float>* m_cl_lz NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global z position of cluster

Definition at line 98 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [10/28]

std::vector<float>* m_cl_ltgx NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global x position of cluster

Definition at line 99 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [11/28]

std::vector<float>* m_cl_ltgy NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global y position of cluster

Definition at line 100 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [12/28]

std::vector<float>* m_cl_ltgz NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global z position of cluster

Definition at line 101 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [13/28]

std::vector<float>* m_cl_truth_x NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global x of first truth hit for strip in cluster

Definition at line 103 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [14/28]

std::vector<float>* m_cl_truth_y NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global y of first truth hit for strip in cluster

Definition at line 104 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [15/28]

std::vector<float>* m_cl_truth_z NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global z of first truth hit for strip in cluster

Definition at line 105 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [16/28]

std::vector<float>* m_cl_truth_lx NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

local x of first truth hit for strip in cluster

Definition at line 107 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [17/28]

std::vector<float>* m_cl_truth_ly NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

local y of first truth hit for strip in cluster

Definition at line 108 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [18/28]

std::vector<float>* m_cl_truth_lz NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

local z of first truth hit for strip in cluster

Definition at line 109 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [19/28]

std::vector<float>* m_cl_truth_E NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

global energy of truth strip deposits

Definition at line 111 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [20/28]

std::vector<int>* m_cl_truth_n NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Cluster index for truth strip hits.

Definition at line 112 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [21/28]

std::vector<int>* m_cl_side NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 114 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [22/28]

std::vector<int>* m_cl_isSmall NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 115 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [23/28]

std::vector<int>* m_cl_wedge NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 116 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [24/28]

std::vector<int>* m_cl_sector NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 117 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [25/28]

std::vector<int>* m_cl_module NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 118 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [26/28]

std::vector<int>* m_cl_layer NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 119 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [27/28]

std::vector<int>* m_cl_bandId NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 120 of file StripClusterTool.h.

◆ ATLAS_THREAD_SAFE [28/28]

std::vector<int>* m_cl_phiId NSWL1::StripClusterTool::ATLAS_THREAD_SAFE {nullptr}
private

Definition at line 122 of file StripClusterTool.h.

◆ m_detManager

const MuonGM::MuonDetectorManager* NSWL1::StripClusterTool::m_detManager
private

MuonDetectorManager.

Definition at line 79 of file StripClusterTool.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_doNtuple

Gaudi::Property<bool> NSWL1::StripClusterTool::m_doNtuple {this, "DoNtuple", false, "Input the sTGC strip cluster branches into the analysis ntuple"}
private

Definition at line 83 of file StripClusterTool.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> NSWL1::StripClusterTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 80 of file StripClusterTool.h.

◆ m_incidentSvc

ServiceHandle< IIncidentSvc > NSWL1::StripClusterTool::m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
private

Athena/Gaudi incident Service.

Definition at line 78 of file StripClusterTool.h.

◆ m_isMC

Gaudi::Property<bool> NSWL1::StripClusterTool::m_isMC {this, "IsMC", true, "This is MC"}
private

Definition at line 82 of file StripClusterTool.h.

◆ m_sTgcSdoContainerKey

SG::ReadHandleKey<MuonSimDataCollection> NSWL1::StripClusterTool::m_sTgcSdoContainerKey {this,"sTGC_SdoContainerName", "sTGC_SDO", "the name of the sTGC SDO container"}
private

Definition at line 84 of file StripClusterTool.h.

◆ m_tree

TTree* NSWL1::StripClusterTool::m_tree {nullptr}
private

ntuple for analysis

Definition at line 89 of file StripClusterTool.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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
MuonSimData::word
int word() const
Definition: MuonSimData.h:89
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Data
@ Data
Definition: BaseObject.h:11
StateLessPT_NewConfig.Format
Format
Definition: StateLessPT_NewConfig.py:146
NSWL1::StripClusterTool::m_sTgcSdoContainerKey
SG::ReadHandleKey< MuonSimDataCollection > m_sTgcSdoContainerKey
Definition: StripClusterTool.h:84
skel.it
it
Definition: skel.GENtoEVGEN.py:396
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
NSWL1::StripClusterTool::init_branches
StatusCode init_branches()
init the branches
Definition: StripClusterTool.cxx:63
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
NSWL1::StripClusterTool::fill_strip_validation_id
StatusCode fill_strip_validation_id(const EventContext &ctx, std::vector< std::unique_ptr< StripClusterData >> &clusters, std::vector< std::shared_ptr< std::vector< std::unique_ptr< StripData > >> > &cluster_cache) const
Definition: StripClusterTool.cxx:195
MuonGM::MuonClusterReadoutElement::surface
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
Definition: MuonClusterReadoutElement.h:123
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
NSWL1::StripClusterTool::book_branches
StatusCode book_branches()
book the branches to analyze the StripTds
Definition: StripClusterTool.cxx:96
NSWL1::StripClusterTool::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Athena/Gaudi incident Service.
Definition: StripClusterTool.h:78
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
MuonSimData::deposits
void deposits(std::vector< Deposit > &deposits) const
Definition: MuonSimData.h:99
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonGM::sTgcReadoutElement
An sTgcReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station c...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:30
MuonSimDataCollection
Definition: MuonSimDataCollection.h:21
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
NSWL1::StripClusterTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition: StripClusterTool.h:83
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:122
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
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
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
charge
double charge(const T &p)
Definition: AtlasPID.h:538
MuonSimData
Definition: MuonSimData.h:62
item
Definition: ItemListSvc.h:43
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
NSWL1::StripClusterTool::m_tree
TTree * m_tree
ntuple for analysis
Definition: StripClusterTool.h:89
a
TList * a
Definition: liststreamerinfos.cxx:10
h
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
MuonGM::MuonDetectorManager::getsTgcReadoutElement
const sTgcReadoutElement * getsTgcReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:259
Trk::PlaneSurface::localToGlobal
virtual void localToGlobal(const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const override final
Specified for PlaneSurface: LocalToGlobal method without dynamic memory allocation.
Definition: PlaneSurface.cxx:204
NSWL1::StripClusterTool::clear_ntuple_variables
void clear_ntuple_variables()
clear the variables used in the analysis
Definition: StripClusterTool.cxx:161
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
NSWL1::StripClusterTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: StripClusterTool.h:80
NSWL1::StripClusterTool::m_detManager
const MuonGM::MuonDetectorManager * m_detManager
MuonDetectorManager.
Definition: StripClusterTool.h:79
NSWL1::StripClusterTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition: StripClusterTool.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 22:22:20 for ATLAS Offline Software by   doxygen 1.8.18