ATLAS Offline Software
StripSegmentTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "GaudiKernel/ConcurrencyFlags.h"
6 
7 #include "TrigT1NSWSimTools/StripSegmentTool.h"
8 
9 namespace NSWL1 {
10 
11  StripSegmentTool::StripSegmentTool( const std::string& type, const std::string& name, const IInterface* parent) :
12  AthAlgTool(type,name,parent),
13  m_tree(nullptr)
14  {
15  declareInterface<NSWL1::IStripSegmentTool>(this);
16  }
17 
18  StatusCode StripSegmentTool::initialize() {
19  ATH_MSG_DEBUG("initializing " << name() );
20  ATH_MSG_DEBUG(name() << " configuration:");
21  const IInterface* parent = this->parent();
22  const INamedInterface* pnamed = dynamic_cast<const INamedInterface*>(parent);
23  const std::string& algo_name = pnamed->name();
24  if ( m_doNtuple ) {
25  if (Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
26  ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
27  return StatusCode::FAILURE;
28  }
29 
30  ATH_CHECK( m_incidentSvc.retrieve() );
31  m_incidentSvc->addListener(this,IncidentType::BeginEvent);
32 
33  if ( algo_name=="NSWL1Simulation" ) {
34  ITHistSvc* tHistSvc;
35  ATH_CHECK(service("THistSvc", tHistSvc));
36  std::string ntuple_name = algo_name+"Tree";
37  m_tree = nullptr;
38  ATH_CHECK(tHistSvc->getTree(ntuple_name,m_tree));
39  ATH_CHECK(this->book_branches());
40  }
41  }
42 
43  ATH_CHECK(m_idHelperSvc.retrieve());
44  ATH_CHECK(m_regSelTableKey.initialize());
45  return StatusCode::SUCCESS;
46  }
47 
48  void StripSegmentTool::handle(const Incident& inc) {
49  if( inc.type()==IncidentType::BeginEvent ) {
50  this->clear_ntuple_variables();
51  }
52  }
53 
54  StatusCode StripSegmentTool::FetchDetectorEnvelope(Envelope_t &env) const {
55  const MuonGM::MuonDetectorManager* p_det;
56  ATH_CHECK(detStore()->retrieve(p_det));
57  SG::ReadCondHandle<IRegSelLUTCondData> rh_stgcLUT(m_regSelTableKey);
58  const auto regSelector = dynamic_cast<const RegSelSiLUT*>(rh_stgcLUT->payload());
59  std::vector<const RegSelModule*> moduleList;
60  for(const auto& i : m_idHelperSvc->stgcIdHelper().idVector()) { // all modules
61  IdentifierHash moduleHashId;
62  m_idHelperSvc->stgcIdHelper().get_module_hash(i, moduleHashId);
63  moduleList.push_back(regSelector->Module(moduleHashId));
64  }
65  float etamin=-1;
66  float etamax=-1;
67  float rmin=-1;
68  float rmax=-1;
69  float zmin=-1;
70  float zmax=-1;
71  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->_etaMin()) < std::abs(M2->_etaMin());} );
72  etamin=moduleList.at(0)->_etaMin();
73  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->_etaMax()) > std::abs(M2->_etaMax());} );
74  etamax=moduleList.at(0)->_etaMax();
75  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->rMin()) < std::abs(M2->rMin());} );
76  rmin=moduleList.at(0)->rMin();
77  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->rMax()) > std::abs(M2->rMax());} );
78  rmax=moduleList.at(0)->rMax();
79  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->zMin()) < std::abs(M2->zMin());} );
80  zmin=moduleList.at(0)->zMin();
81  std::sort(moduleList.begin(),moduleList.end(),[](const auto& M1,const auto& M2){ return std::abs(M1->zMax()) > std::abs(M2->zMax());} );
82  zmax=moduleList.at(0)->zMax();
83 
84  if(rmin<=0 || rmax<=0) ATH_MSG_WARNING("Unable to fetch NSW r/z boundaries");
85  env.lower_r = rmin;
86  env.upper_r = rmax;
87  env.lower_eta = etamin;
88  env.upper_eta = etamax;
89  env.lower_z = zmin;
90  env.upper_z = zmax;
91  ATH_MSG_DEBUG("rmin=" << rmin << " rmax=" << rmax << " zmin=" << zmin << " zmax=" << zmax << " etamin=" << etamin << " etamax=" << etamax);
92  return StatusCode::SUCCESS;
93  }
94 
95  uint8_t StripSegmentTool::findRIdx(const float val, const Envelope_t &env) const {
96  unsigned int nSlices=(1<<m_rIndexBits); //256
97  std::pair<float,float> range;
98  switch(m_ridxScheme){
99  case 0:
100  range=std::make_pair(env.lower_r, env.upper_r);
101  break;
102  case 1:
103  range=std::make_pair(env.lower_eta, env.upper_eta);
104  break;
105  default:
106  break;
107  }
108  float step=(range.second-range.first)/nSlices;
109 
110  // the cases with val<=range.first or val>=range.second have been abandoned before
111  for(uint8_t i=0;i<nSlices;i++) {
112  if(range.first+i*step <= val && val < range.first+(i+1)*step) return i;
113  }
114  ATH_MSG_ERROR( "StripSegmentTool: findRIdx failed!");
115  return 0;
116  }
117 
118  uint8_t StripSegmentTool::findDtheta(const float val) const {
119  uint8_t nbins_dtheta=1<<m_dThetaBits;
120  float step_dtheta=(m_dtheta_max-m_dtheta_min)/nbins_dtheta;
121  for(uint8_t i=0;i<nbins_dtheta;++i) {
122  if(val<m_dtheta_min+i*step_dtheta) return i;
123  }
124  return 0;
125  }
126 
127  StatusCode StripSegmentTool::find_segments(std::vector< std::unique_ptr<StripClusterData> >& clusters,
128  const std::unique_ptr<Muon::NSW_TrigRawDataContainer>& trgContainer) const {
129  Envelope_t envelope;
130  ATH_CHECK(FetchDetectorEnvelope(envelope));
131 
132  if (clusters.empty()) {
133  ATH_MSG_WARNING("Received event with no clusters. Skipping...");
134  return StatusCode::SUCCESS;
135  }
136 
137  std::map<uint32_t, std::vector<std::unique_ptr<StripClusterData>>[2] > cluster_map; // gather clusters by hash_bandid and seperate in wedge
138 
139  int sectorid=-1; // [1,8]
140  int sideid=-1; // sideid==0: C
141  int sectorNumber=-1; // [1,16]
142  int hash=-1; // [1,32]
143 
144  int bandId=-1; // bandId is different for large and small sector type, the same for side / specific sector
145 
146  for(auto& cl : clusters){
147  // combine the side, sectortype, sectorid to form the hash
148  sideid=cl->sideId();
149  sectorid=cl->sectorId();
150  if(cl->isSmall()) sectorNumber=2*sectorid;
151  else sectorNumber=2*sectorid-1;
152  hash=16*sideid+sectorNumber;
153 
154  bandId=cl->bandId();
155 
156 
157  std::string id_str=std::to_string(hash)+"000"+std::to_string(bandId); // [1,32]*1000 + [0,90](could be extended in the future), the 1000 factor promise there's no confusion, such as '1'+'12" and '11'+'2'
158  uint32_t hash_bandid=atoi(id_str.c_str());
159 
160  // use the clusters in 2 wedges, with the same bandId, to form the sector segment
161  /*****************************************************************************************************/
162  auto item =cluster_map.find(hash_bandid);
163  if (item != cluster_map.end()){
164  item->second[cl->wedge()-1].push_back(std::move(cl));
165  }
166  else{
167  cluster_map[hash_bandid][cl->wedge()-1].push_back(std::move(cl));
168  }
169  }
170 
171  ATH_MSG_DEBUG(" Building NSW Segment RDO at hash=" << hash);
172 
173  for(const auto& band : cluster_map){//main band loop
174  int bandId=band.first;
175  if (band.second[0].size() == 0){
176  ATH_MSG_WARNING("Cluster size is zero for inner wedge trg with bandId "<<bandId<<"...skipping");
177  continue;
178  }
179  if(band.second[1].size() == 0){
180  ATH_MSG_WARNING("Cluster size is zero for outer wedge trg with bandId "<<bandId<<"...skipping");
181  continue;
182  }
183  float glx1=0;
184  float gly1=0;
185  float glx2=0;
186  float gly2=0;
187  float glx=0;
188  float gly=0;
189  float charge1=0;
190  float charge2=0;
191 
192  float eta=0;
193  float phi=0;
194  float theta=0;
195  float theta_inf=0;
196  float dtheta=0;
197  float eta_inf=0;
198 
199  // First measurement, corresponding to the inner wedge
200  float z1=0;
201  uint16_t sectorID = 0, bcID = 0;
202  char sectorSide = '-';
203  for( const auto& cl : band.second[0] ){
204  z1+=cl->globZ()*cl->charge();
205  glx1+=cl->globX()*cl->charge();
206  gly1+=cl->globY()*cl->charge();
207  charge1+=cl->charge();
208  sectorID = (cl->isSmall()) ? 2*cl->sectorId()-1 : 2*(cl->sectorId()-1);
209  sectorSide = (cl->sideId() == 0) ? 'C' : 'A';
210  bcID = cl->BCID();
211  }
212  auto trgRawData=std::make_unique< Muon::NSW_TrigRawData>(sectorID, sectorSide, bcID);
213 
214  // Second measurement, corresponding to the outer wedge
215  float z2=0;
216  for( const auto& cl : band.second[1] ){
217  z2+=cl->globZ()*cl->charge();
218  glx2+=cl->globX()*cl->charge();
219  gly2+=cl->globY()*cl->charge();
220  charge2+=cl->charge();
221  sectorID = (cl->isSmall()) ? 2*cl->sectorId()-1 : 2*(cl->sectorId()-1);
222  sectorSide = (cl->sideId() == 0) ? 'C' : 'A';
223  bcID = cl->BCID();
224  if (( sectorID != trgRawData->sectorId() ) ||
225  ( sectorSide != trgRawData->sectorSide() ) ||
226  ( bcID != trgRawData->bcId() )) ATH_MSG_WARNING("Possible mismatch between inner and outer wedge RDO parameters");
227  }
228  if(charge1!=0){
229  z1=z1/charge1;
230  glx1=glx1/charge1;
231  gly1=gly1/charge1;
232  }
233  if(charge2!=0){
234  z2=z2/charge2;
235  glx2=glx2/charge2;
236  gly2=gly2/charge2;
237  }
238 
239  //centroid calc
240  glx=(glx1+glx2)/2.;
241  gly=(gly1+gly2)/2.;
242  float avg_z=(z1+z2)/2.;
243 
244  //segment calc
245  ROOT::Math::XYZVector v3_centr1(glx1,gly1,z1), v3_centr2(glx2,gly2,z2);
246  ROOT::Math::XYZVector v3_segment = v3_centr2 - v3_centr1;
247  phi=v3_segment.Phi();
248  theta=v3_segment.Theta();
249  eta=v3_segment.Eta();
250 
251  //inf momentum track
252  theta_inf=v3_centr1.Theta();
253  eta_inf=v3_centr1.Eta();
254  dtheta=(theta-theta_inf)*1000;//In Milliradian
255 
256  ATH_MSG_DEBUG("StripSegmentTool: phi:" << phi << " theta:" << theta << " eta: " << eta << " theta_inf: " << theta_inf << " eta_inf: " << eta_inf << " dtheta: " << dtheta);
257 
258  //do not get confused. this one is trigger phiId
259  int phiId=band.second[0].at(0)->phiId();
260 
261  float rfar=envelope.upper_z*std::abs(std::tan(theta_inf));
262 
263  if( rfar >= envelope.upper_r || rfar < envelope.lower_r || std::abs(eta_inf) >= envelope.upper_eta || std::abs(eta_inf) < envelope.lower_eta){
264  ATH_MSG_WARNING("measured r/eta is out of detector envelope!");
265  return StatusCode::SUCCESS;
266  }
267 
268  uint8_t rIndex=0;
269  switch(m_ridxScheme) {
270  case 0:
271  rIndex=findRIdx(rfar, envelope);
272  break;
273  case 1:
274  rIndex=findRIdx(std::abs(eta_inf), envelope);
275  break;
276  default:
277  break;
278  }
279 
280  bool phiRes=true;
281  bool lowRes=false;//we do not have a recipe for a singlewedge trigger. so lowres is always false for now
282  uint8_t dtheta_int=findDtheta(dtheta);
283 
284  if (m_doNtuple) {
285  m_seg_wedge1_size->push_back(band.second[0].size());
286  m_seg_wedge2_size->push_back(band.second[1].size());
287  m_seg_bandId->push_back(bandId);
288  m_seg_phiId->push_back(phiId);
289  m_seg_rIdx->push_back(rIndex);
290  m_seg_theta->push_back(theta);
291  m_seg_dtheta->push_back(dtheta);
292  m_seg_dtheta_int->push_back(dtheta_int);
293  m_seg_eta->push_back(eta);
294  m_seg_eta_inf->push_back(eta_inf);
295  m_seg_phi->push_back(phi);
296  m_seg_global_x->push_back(glx);
297  m_seg_global_y->push_back(gly);
298  m_seg_global_z->push_back(avg_z);
299  }
300 
301  //However it needs to be kept an eye on... will be something in between 7 and 15 mrad needs to be decided
302  if(std::abs(dtheta)>15) continue;
303  auto rdo_segment= std::make_unique<Muon::NSW_TrigRawDataSegment>( dtheta_int, (uint8_t)phiId, (rIndex), lowRes, phiRes);
304  trgRawData->push_back(std::move(rdo_segment));
305  trgContainer->push_back(std::move(trgRawData));
306 
307  }//end of clmap loop
308  return StatusCode::SUCCESS;
309  }
310 
311  StatusCode StripSegmentTool::book_branches() {
312 
313  m_seg_theta = new std::vector< float >();
314  m_seg_dtheta = new std::vector< float >();
315  m_seg_dtheta_int = new std::vector< uint8_t >();
316  m_seg_eta = new std::vector< float >();
317  m_seg_eta_inf=new std::vector< float >();
318  m_seg_phi = new std::vector< float >();
319  m_seg_global_x = new std::vector< float >();
320  m_seg_global_y = new std::vector< float >();
321  m_seg_global_z = new std::vector< float >();
322  m_seg_bandId = new std::vector< int >();
323  m_seg_phiId = new std::vector< int >();
324  m_seg_rIdx=new std::vector< int >();
325  m_seg_wedge1_size = new std::vector< int >();
326  m_seg_wedge2_size = new std::vector< int >();
327 
328  if (m_tree) {
329  std::string ToolName = name().substr( name().find("::")+2,std::string::npos );
330  const char* n = ToolName.c_str();
331  m_tree->Branch(TString::Format("%s_seg_theta",n).Data(),&m_seg_theta);
332  m_tree->Branch(TString::Format("%s_seg_dtheta",n).Data(),&m_seg_dtheta);
333  m_tree->Branch(TString::Format("%s_seg_dtheta_int",n).Data(),&m_seg_dtheta_int);
334  m_tree->Branch(TString::Format("%s_seg_eta",n).Data(),&m_seg_eta);
335  m_tree->Branch(TString::Format("%s_seg_eta_inf",n).Data(),&m_seg_eta_inf);
336  m_tree->Branch(TString::Format("%s_seg_phi",n).Data(),&m_seg_phi);
337  m_tree->Branch(TString::Format("%s_seg_global_x",n).Data(),&m_seg_global_x);
338  m_tree->Branch(TString::Format("%s_seg_global_y",n).Data(),&m_seg_global_y);
339  m_tree->Branch(TString::Format("%s_seg_global_z",n).Data(),&m_seg_global_z);
340  m_tree->Branch(TString::Format("%s_seg_bandId",n).Data(),&m_seg_bandId);
341  m_tree->Branch(TString::Format("%s_seg_phiId",n).Data(),&m_seg_phiId);
342  m_tree->Branch(TString::Format("%s_seg_rIdx",n).Data(),&m_seg_rIdx);
343  m_tree->Branch(TString::Format("%s_seg_wedge1_size",n).Data(),&m_seg_wedge1_size);
344  m_tree->Branch(TString::Format("%s_seg_wedge2_size",n).Data(),&m_seg_wedge2_size);
345  }
346  return StatusCode::SUCCESS;
347  }
348 
349  void StripSegmentTool::clear_ntuple_variables() {
350  if(m_tree==nullptr) return;
351 
352  m_seg_theta->clear();
353  m_seg_dtheta->clear();
354  m_seg_dtheta_int->clear();
355  m_seg_eta->clear();
356  m_seg_eta_inf->clear();
357  m_seg_phi->clear();
358  m_seg_global_x->clear();
359  m_seg_global_y->clear();
360  m_seg_global_z->clear();
361  m_seg_bandId->clear();
362  m_seg_phiId->clear();
363  m_seg_rIdx->clear();
364  m_seg_wedge2_size->clear();
365  m_seg_wedge1_size->clear();
366  }
367 }
368 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
NSWL1::eta
float eta(float x, float y, float z)
Definition: GeoUtils.cxx:9
NSWL1::StripSegmentTool::findRIdx
uint8_t findRIdx(const float val, const Envelope_t &env) const
Definition: StripSegmentTool.cxx:95
NSWL1::StripSegmentTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: StripSegmentTool.h:85
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
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
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:176
Data
@ Data
Definition: BaseObject.h:11
NSWL1::StripSegmentTool::m_ridxScheme
Gaudi::Property< int > m_ridxScheme
Definition: StripSegmentTool.h:100
StateLessPT_NewConfig.Format
Format
Definition: StateLessPT_NewConfig.py:146
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
NSWL1::StripSegmentTool::clear_ntuple_variables
void clear_ntuple_variables()
clear the variables used in the analysis ntuple
Definition: StripSegmentTool.cxx:349
NSWL1::StripSegmentTool::initialize
virtual StatusCode initialize() override
Definition: StripSegmentTool.cxx:18
NSWL1::StripSegmentTool::m_dtheta_max
Gaudi::Property< float > m_dtheta_max
Definition: StripSegmentTool.h:99
NSWL1::StripSegmentTool::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Athena/Gaudi incident Service.
Definition: StripSegmentTool.h:93
Envelope_t::upper_r
float upper_r
Definition: StripSegmentTool.h:48
NSWL1::StripSegmentTool::m_doNtuple
Gaudi::Property< bool > m_doNtuple
Definition: StripSegmentTool.h:95
NSWL1::StripSegmentTool::StripSegmentTool
StripSegmentTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: StripSegmentTool.cxx:11
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
NSWL1::StripSegmentTool::FetchDetectorEnvelope
StatusCode FetchDetectorEnvelope(Envelope_t &env) const
Definition: StripSegmentTool.cxx:54
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
NSWL1::StripSegmentTool::m_rIndexBits
Gaudi::Property< int > m_rIndexBits
Definition: StripSegmentTool.h:96
lumiFormat.i
int i
Definition: lumiFormat.py:92
beamspotman.n
n
Definition: beamspotman.py:731
NSWL1::StripSegmentTool::handle
virtual void handle(const Incident &inc) override
Definition: StripSegmentTool.cxx:48
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:176
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Envelope_t::upper_z
float upper_z
Definition: StripSegmentTool.h:52
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
NSWL1::StripSegmentTool::m_dThetaBits
Gaudi::Property< int > m_dThetaBits
Definition: StripSegmentTool.h:97
Envelope_t::lower_r
float lower_r
Definition: StripSegmentTool.h:47
NSWL1::StripSegmentTool::m_dtheta_min
Gaudi::Property< float > m_dtheta_min
Definition: StripSegmentTool.h:98
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
NSWL1::StripSegmentTool::find_segments
virtual StatusCode find_segments(std::vector< std::unique_ptr< StripClusterData > > &, const std::unique_ptr< Muon::NSW_TrigRawDataContainer > &) const override
Definition: StripSegmentTool.cxx:127
item
Definition: ItemListSvc.h:43
NSWL1::StripSegmentTool::findDtheta
uint8_t findDtheta(const float) const
Definition: StripSegmentTool.cxx:118
Envelope_t::upper_eta
float upper_eta
Definition: StripSegmentTool.h:50
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
StripSegmentTool.h
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:49
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
NSWL1::StripSegmentTool::m_tree
TTree * m_tree
ntuple for analysis
Definition: StripSegmentTool.h:105
Envelope_t::lower_eta
float lower_eta
Definition: StripSegmentTool.h:49
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
RegSelSiLUT
Definition: RegSelSiLUT.h:41
LArCellBinning.step
step
Definition: LArCellBinning.py:158
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
Envelope_t
Definition: StripSegmentTool.h:46
AthAlgTool
Definition: AthAlgTool.h:26
NSWL1::StripSegmentTool::book_branches
StatusCode book_branches()
book the branches to analyze the StripTds behavior
Definition: StripSegmentTool.cxx:311
IdentifierHash
Definition: IdentifierHash.h:38
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
NSWL1::phi
float phi(float x, float y, float z)
Definition: GeoUtils.cxx:14
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
NSWL1
A trigger trigger candidate for a stgc sector.
Definition: NSWL1Simulation.cxx:9
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
NSWL1::StripSegmentTool::m_regSelTableKey
SG::ReadCondHandleKey< IRegSelLUTCondData > m_regSelTableKey
Definition: StripSegmentTool.h:86
WriteBchToCool.moduleList
moduleList
Definition: WriteBchToCool.py:72
RegSelCondData::payload
const T * payload() const
Definition: RegSelCondData.h:33
Generated on Sun Jun 30 2024 21:27:24 for ATLAS Offline Software by   doxygen 1.8.18