ATLAS Offline Software
TRTCondStoreText.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include <fstream>
6 #include <iostream>
7 #include <string>
8 #include "TRTCondStoreText.h"
13 
14 
15 
22 TRTCondStoreText::TRTCondStoreText(const std::string& name, ISvcLocator* pSvcLocator):AthAlgorithm (name, pSvcLocator){}
23 
25 {
26 
27  // Get TRT ID helper
28  ATH_CHECK(detStore()->retrieve(m_trtid, "TRT_ID"));
29 
30  // Format of input text file
31  int format = 0;
32  if (m_par_caltextfile != ""){
33  ATH_MSG_INFO(" input text file supplied " << m_par_caltextfile);
34  if (StatusCode::SUCCESS != checkTextFile(m_par_caltextfile, format)){
35  ATH_MSG_FATAL("Could not read format of text file" << m_par_caltextfile);
36  return StatusCode::FAILURE;
37  }
38  ATH_MSG_INFO(" Found format " << format << " in text file " << m_par_caltextfile);
39  }
40  else{
41  ATH_MSG_FATAL(" No input text file supplied. Nothing can be done. ");
42  return StatusCode::FAILURE;
43  }
44 
45  ATH_MSG_INFO(" Read calibration constants from text file " << m_par_caltextfile);
46  if (StatusCode::SUCCESS != readTextFile(m_par_caltextfile, format)){
47  ATH_MSG_FATAL("Could not read calibration objects from text file " << m_par_caltextfile);
48  return StatusCode::FAILURE;
49  }
50 
51  return StatusCode::SUCCESS;
52 }
53 
55 
56  StatusCode sc = StatusCode::SUCCESS;
57  return sc;
58 }
59 
61 
62  StatusCode sc = StatusCode::SUCCESS;
63  return sc;
64 }
65 
67 {
68 
69  StatusCode sc=StatusCode::SUCCESS ;
70  std::ifstream infile(filename.c_str()) ;
71  if(!infile) {
72  ATH_MSG_ERROR( "Cannot find input file " << filename ) ;
73  sc=StatusCode::FAILURE;
74  } else {
75  // read the format tag. if none, default to 0
76  format = 0 ;
77  char line[512] ;
78  infile.getline(line,512) ;
79  std::string linestring(line) ;
80  size_t pos = linestring.find("Fileformat") ;
81  if(pos != std::string::npos) {
82  sscanf(line,"# Fileformat=%d",&format) ;
83  } else {
84  ATH_MSG_WARNING( "Input file has no Fileformat identifier. Assuming format=0.");
85  // 'rewind' the file
86 
87  infile.close() ;
88  infile.open(filename.c_str()) ;
89  }
90  }
91  infile.close() ;
92  return sc ;
93 }
94 
96 {
97 
98  StatusCode sc=StatusCode::SUCCESS ;
99  std::ifstream infile(filename.c_str()) ;
100  if(!infile) {
101  ATH_MSG_ERROR( "Cannot find input file " << filename ) ;
102  } else {
103  // read the format tag. if none, default to 0
104  format = 0 ;
105  char line[512] ;
106  infile.getline(line,512) ;
107  std::string linestring(line) ;
108  size_t pos = linestring.find("Fileformat") ;
109  if(pos != std::string::npos) {
110  sscanf(line,"# Fileformat=%d",&format) ;
111  } else {
112  ATH_MSG_WARNING( "Input file has no Fileformat identifier. Assuming format=1");
113  // 'rewind' the file
114 
115  infile.close() ;
116  infile.open(filename.c_str()) ;
117  }
118  ATH_MSG_INFO( "Reading calibration data from text file " << filename << " format " << format ) ;
119  switch(format) {
120  case 1: sc=readTextFile_Format1(infile) ; break ;
121  case 2: sc=readTextFile_Format2(infile) ; break ;
122  case 3: sc=readTextFile_Format3(infile) ; break ;
124  }
125  }
126  infile.close() ;
127 
128  return sc ;
129 }
130 
131 
133 {
134 
135 
136  enum ReadMode { ReadingRtRelation, ReadingStrawT0, ReadingGarbage } ;
137  ReadMode readmode =ReadingGarbage ;
138 
139  // The OutputConditionAlg only works with old-style conditions access, so create raw pointers here.
140 
143 
144  char line[512] ;
145  int nrtrelations(0), nstrawt0(0) ;
146  while( infile.getline(line,512) ) {
147  if(line[0] == '#') {
148  // line with tag
149  std::string linestring(line) ;
150  if(linestring.find("RtRelation") != std::string::npos) {
151  readmode = ReadingRtRelation ;
152  ATH_MSG_INFO(" Found line with Rt tag ");
153 
154  } else if (linestring.find("StrawT0") != std::string::npos) {
155  readmode = ReadingStrawT0 ;
156  ATH_MSG_INFO(" Found line with T0 tag ");
157 
158  }else readmode = ReadingGarbage ;
159  } else if( readmode != ReadingGarbage) {
160  std::istringstream is(line) ;
161  // read the id
163  is >> id ;
164  // read the semicolon that end the id
165  char dummy ;
166  is >> dummy ;
167 
168  // read the object
169  if( readmode == ReadingRtRelation ) {
170 
171 
173  rtContainer->set( id,rt);
174  delete rt ;
175  ++nrtrelations ;
176  } else if( readmode == ReadingStrawT0 ) {
177 
178  float t0(0), t0err(0) ;
179  is >> t0 >> t0err;
180 
181  //skip straws with t0=0. The
182  if(t0==0) continue;
183 
184  t0Container->setT0( id, t0, t0err );
185  //debug
186  //id.print();
187  //std::cout << " t0 " << t0 << " t0err " << t0err << std::endl;
188  ++nstrawt0 ;
189  }
190  }
191  }
192 
193  // Check that containers were filled
194 
195  size_t t0footprint = t0Container->footprint() ;
196  size_t rtfootprint = rtContainer->footprint() ;
197 
198 
199  ATH_MSG_INFO( "read " << nstrawt0 << " t0 and " << nrtrelations << " rt from file. "
200  << " t0/rt footprints " << t0footprint << " / " << rtfootprint ) ;
201 
202 
203  //Record the containers the old way for the OutputConditionsAlg
204 
205  if(t0Container->initialize().isFailure()) ATH_MSG_WARNING("Could not initialize T0 Container for key " << m_par_t0containerkey);
206  ATH_MSG_INFO(" Recording T0 container ");
207  if( (detStore()->record(t0Container,m_par_t0containerkey))!=StatusCode::SUCCESS ) {
208  ATH_MSG_ERROR("Could not record T0 container for key " << m_par_t0containerkey << " with DetStore ");
209  return StatusCode::FAILURE;
210  } else {
211  if(StatusCode::SUCCESS!=detStore()->retrieve(t0Container,m_par_t0containerkey)) {
212  ATH_MSG_FATAL( "Could not retrieve data handle for StrawT0Container " );
213  return StatusCode::FAILURE ;
214  } else {
215  ATH_MSG_INFO("Successfully recorded T0 Container " << m_par_t0containerkey << " with DetStore ");
216  }
217  }
218 
219 
220  ATH_MSG_INFO(" Recording RT container ");
221  if( (detStore()->record(rtContainer,m_par_rtcontainerkey))!=StatusCode::SUCCESS ) {
222  ATH_MSG_ERROR("Could not record RT container for key " << m_par_rtcontainerkey << " with DetStore ");
223  return StatusCode::FAILURE;
224  } else {
225  if(StatusCode::SUCCESS!=detStore()->retrieve(rtContainer,m_par_rtcontainerkey)) {
226  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
227  return StatusCode::FAILURE ;
228  } else {
229  ATH_MSG_INFO("Successfully recorded RT Container " << m_par_rtcontainerkey << " with DetStore ");
230  }
231  }
232 
233 
234  return StatusCode::SUCCESS ;
235 }
236 
238 {
239 
240 
241  enum ReadMode { ReadingRtRelation, ReadingErrors, ReadingStrawT0, ReadingGarbage } ;
242  ReadMode readmode =ReadingGarbage ;
243  char line[512] ;
244  int nrtrelations(0), nerrors(0), nstrawt0(0) ;
245 
246  // The OutputConditionAlg only works with old-style access, so create a raw pointer.
250 
251 
252  while( infile.getline(line,512) ) {
253  if(line[0] == '#') {
254  // line with tag
255  std::string linestring(line) ;
256  if( linestring.find("RtRelation") != std::string::npos) {
257  readmode = ReadingRtRelation ;
258  ATH_MSG_INFO(" Found line with Rt tag ");
259  rtContainer->clear() ;
260  } else if(linestring.find("StrawT0") != std::string::npos) {
261  readmode = ReadingStrawT0 ;
262  ATH_MSG_INFO(" Found line with T0 tag ");
263  t0Container->clear() ;
264  } else if(linestring.find("RtErrors") != std::string::npos) {
265  readmode = ReadingErrors ;
266  ATH_MSG_INFO(" Found line with Error tag ");
267  errContainer->clear() ;
268  } else { readmode = ReadingGarbage ; }
269  } else if( readmode != ReadingGarbage) {
270  std::istringstream is(line) ;
271  // read the id
273  is >> id ;
274  // read the semicolon that end the id
275  char dummy ;
276  is >> dummy ;
277  // read the object
278  if( readmode == ReadingRtRelation ) {
279 
281  rtContainer->set( id,rt);
282  delete rt ;
283  ++nrtrelations ;
284 
285  } else if( readmode == ReadingErrors ) {
286 
288  errContainer->set( id,err);
289  delete err ;
290  ++nerrors ;
291 
292  } else if( readmode == ReadingStrawT0 ) {
293 
294  float t0(0), t0err(0) ;
295  is >> t0 >> t0err ;
296  t0Container->setT0( id, t0, t0err );
297 
298  ++nstrawt0 ;
299  }
300  }
301  }
302 
303  size_t t0footprint = t0Container->footprint() ;
304  size_t rtfootprint = rtContainer->footprint() ;
305  size_t errfootprint = errContainer->footprint() ;
306 
307  ATH_MSG_INFO( "read " << nstrawt0 << " t0 and " << nerrors << " errors and " << nrtrelations << " rt relations "
308  << " t0/rt/err footprints " << t0footprint << " / " << rtfootprint << " / " << errfootprint ) ;
309 
310  //Record the containers the old way for the OutputConditionsAlg
311  if(t0Container->initialize().isFailure()) ATH_MSG_WARNING("Could not initialize T0 Container for key " << m_par_t0containerkey);
312  ATH_MSG_INFO(" Recording T0 container ");
313  if( (detStore()->record(t0Container,m_par_t0containerkey))!=StatusCode::SUCCESS ) {
314  ATH_MSG_ERROR("Could not record T0 container for key " << m_par_t0containerkey << " with DetStore ");
315  return StatusCode::FAILURE;
316  } else {
317  if(StatusCode::SUCCESS!=detStore()->retrieve(t0Container,m_par_t0containerkey)) {
318  ATH_MSG_FATAL( "Could not retrieve data handle for StrawT0Container " );
319  return StatusCode::FAILURE ;
320  } else {
321  ATH_MSG_INFO("Successfully recorded T0 Container " << m_par_t0containerkey << " with DetStore ");
322  }
323  }
324 
325 
326  ATH_MSG_INFO(" Recording RT container ");
327  if( (detStore()->record(rtContainer,m_par_rtcontainerkey))!=StatusCode::SUCCESS ) {
328  ATH_MSG_ERROR("Could not record RT container for key " << m_par_rtcontainerkey << " with DetStore ");
329  return StatusCode::FAILURE;
330  } else {
331  if(StatusCode::SUCCESS!=detStore()->retrieve(rtContainer,m_par_rtcontainerkey)) {
332  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
333  return StatusCode::FAILURE ;
334  } else {
335  ATH_MSG_INFO("Successfully recorded RT Container " << m_par_rtcontainerkey << " with DetStore ");
336  }
337  }
338 
339  ATH_MSG_INFO(" Recording Error container ");
340  if( (detStore()->record(errContainer,m_par_errcontainerkey))!=StatusCode::SUCCESS ) {
341  ATH_MSG_ERROR("Could not record Error container for key " << m_par_errcontainerkey << " with DetStore ");
342  return StatusCode::FAILURE;
343  } else {
344  if(StatusCode::SUCCESS!=detStore()->retrieve(errContainer,m_par_errcontainerkey)) {
345  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
346  return StatusCode::FAILURE ;
347  } else {
348  ATH_MSG_INFO("Successfully recorded Error Container " << m_par_errcontainerkey << " with DetStore ");
349  }
350  }
351 
352  return StatusCode::SUCCESS ;
353 }
354 
355 
357 {
358 
359  // The OutputConditionAlg only works with old-style access, so create a raw pointer.
364 
365 
366  enum ReadMode { ReadingRtRelation, ReadingErrors, ReadingSlopes, ReadingStrawT0, ReadingGarbage } ;
367  ReadMode readmode =ReadingGarbage ;
368  char line[512] ;
369  int nrtrelations(0), nerrors(0), nslopes(0), nstrawt0(0) ;
370 
371  while( infile.getline(line,512) ) {
372  if(line[0] == '#') {
373  // line with tag
374  std::string linestring(line) ;
375  if( linestring.find("RtRelation") != std::string::npos) {
376  readmode = ReadingRtRelation ;
377  rtContainer->clear() ;
378  ATH_MSG_INFO(" Found line with Rt tag ");
379  } else if(linestring.find("RtErrors") != std::string::npos) {
380  readmode = ReadingErrors ;
381  errContainer->clear() ;
382  ATH_MSG_INFO(" Found line with Error tag ");
383  } else if(linestring.find("RtSlopes") != std::string::npos) {
384  readmode = ReadingSlopes ;
385  slopeContainer->clear() ;
386  ATH_MSG_INFO(" Found line with Slope tag ");
387  } else if(linestring.find("StrawT0") != std::string::npos) {
388  readmode = ReadingStrawT0 ;
389  t0Container->clear() ;
390  ATH_MSG_INFO(" Found line with T0 tag ");
391  } else { readmode = ReadingGarbage ; }
392  } else if( readmode != ReadingGarbage) {
393  std::istringstream is(line) ;
394  // read the id
396  is >> id ;
397  // read the semicolon that end the id
398  char dummy ;
399  is >> dummy ;
400  // read the object
401  if( readmode == ReadingRtRelation ) {
402 
404  rtContainer->set( id,rt);
405  delete rt ;
406  ++nrtrelations ;
407 
408  } else if( readmode == ReadingErrors ) {
409 
411  errContainer->set( id,err);
412  delete err ;
413  ++nerrors ;
414 
415  } else if( readmode == ReadingSlopes ) {
416 
418  slopeContainer->set( id,slope);
419  delete slope ;
420  ++nslopes ;
421 
422  } else if( readmode == ReadingStrawT0 ) {
423 
424  float t0(0), t0err(0) ;
425  is >> t0 >> t0err ;
426  t0Container->setT0( id, t0, t0err );
427  ++nstrawt0 ;
428  }
429  }
430  }
431 
432  size_t t0footprint = t0Container->footprint() ;
433  size_t rtfootprint = rtContainer->footprint() ;
434  size_t errfootprint = errContainer->footprint() ;
435  size_t slopefootprint = slopeContainer->footprint() ;
436 
437  ATH_MSG_INFO( "read " << nstrawt0 << " t0 and " << nerrors << " errors and " << nrtrelations << " rt relations and " << nslopes << " error slopes "
438  << " t0/rt/err/slope footprints " << t0footprint << " / " << rtfootprint << " / " << errfootprint << " / " << slopefootprint) ;
439 
440 
441  //Record the containers the old way for the OutputConditionsAlg
442  if(t0Container->initialize().isFailure()) ATH_MSG_WARNING("Could not initialize T0 Container for key " << m_par_t0containerkey);
443  ATH_MSG_INFO(" Recording T0 container ");
444  if( (detStore()->record(t0Container,m_par_t0containerkey))!=StatusCode::SUCCESS ) {
445  ATH_MSG_ERROR("Could not record T0 container for key " << m_par_t0containerkey << " with DetStore ");
446  return StatusCode::FAILURE;
447  } else {
448  if(StatusCode::SUCCESS!=detStore()->retrieve(t0Container,m_par_t0containerkey)) {
449  ATH_MSG_FATAL( "Could not retrieve data handle for StrawT0Container " );
450  return StatusCode::FAILURE ;
451  } else {
452  ATH_MSG_INFO("Successfully recorded T0 Container " << m_par_t0containerkey << " with DetStore ");
453  }
454  }
455 
456 
457  ATH_MSG_INFO(" Recording RT container ");
458  if( (detStore()->record(rtContainer,m_par_rtcontainerkey))!=StatusCode::SUCCESS ) {
459  ATH_MSG_ERROR("Could not record RT container for key " << m_par_rtcontainerkey << " with DetStore ");
460  return StatusCode::FAILURE;
461  } else {
462  if(StatusCode::SUCCESS!=detStore()->retrieve(rtContainer,m_par_rtcontainerkey)) {
463  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
464  return StatusCode::FAILURE ;
465  } else {
466  ATH_MSG_INFO("Successfully recorded RT Container " << m_par_rtcontainerkey << " with DetStore ");
467  }
468  }
469 
470  ATH_MSG_INFO(" Recording Error container ");
471  if( (detStore()->record(errContainer,m_par_errcontainerkey))!=StatusCode::SUCCESS ) {
472  ATH_MSG_ERROR("Could not record Error container for key " << m_par_errcontainerkey << " with DetStore ");
473  return StatusCode::FAILURE;
474  } else {
475  if(StatusCode::SUCCESS!=detStore()->retrieve(errContainer,m_par_errcontainerkey)) {
476  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
477  return StatusCode::FAILURE ;
478  } else {
479  ATH_MSG_INFO("Successfully recorded Error Container " << m_par_errcontainerkey << " with DetStore ");
480  }
481  }
482 
483  ATH_MSG_INFO(" Recording Slope container ");
484  if( (detStore()->record(slopeContainer,m_par_slopecontainerkey))!=StatusCode::SUCCESS ) {
485  ATH_MSG_ERROR("Could not record Slope container for key " << m_par_slopecontainerkey << " with DetStore ");
486  return StatusCode::FAILURE;
487  } else {
488  if(StatusCode::SUCCESS!=detStore()->retrieve(slopeContainer,m_par_slopecontainerkey)) {
489  ATH_MSG_FATAL( "Could not retrieve data handle for RtRelationContainer " );
490  return StatusCode::FAILURE ;
491  } else {
492  ATH_MSG_INFO("Successfully recorded Slope Container " << m_par_slopecontainerkey << " with DetStore ");
493  }
494  }
495 
496 
497  return StatusCode::SUCCESS ;
498 }
499 
500 
502 {
505  m_trtid->straw(id),level ) ;
506 }
507 
508 
509 
510 
511 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TRTCondStoreText::checkTextFile
virtual StatusCode checkTextFile(const std::string &file, int &format)
read calibration from text file into TDS
Definition: TRTCondStoreText.cxx:66
TRTCondStoreText::m_par_rtcontainerkey
Gaudi::Property< std::string > m_par_rtcontainerkey
Definition: TRTCondStoreText.h:60
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DinesRtRelation.h
TRTCondStoreText::finalize
virtual StatusCode finalize(void) override
Definition: TRTCondStoreText.cxx:60
run.infile
string infile
Definition: run.py:13
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TRTCond::MultChanContainer::set
void set(const ExpandedIdentifier &id, const typename DaughterContainer::value_type &t)
set a value
Definition: MultChanContainer.h:223
TRTCond::StrawT0MultChanContainer::setT0
void setT0(const ExpandedIdentifier &id, float t0, float t0err)
set t0
Definition: StrawT0MultChanContainer.h:55
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
TRTCondStoreText::readTextFile_Format3
virtual StatusCode readTextFile_Format3(std::istream &)
Definition: TRTCondStoreText.cxx:356
TRTCondStoreText::m_par_errcontainerkey
Gaudi::Property< std::string > m_par_errcontainerkey
Definition: TRTCondStoreText.h:58
TRTCond::MultChanContainer::clear
void clear()
clear all layercontainers
Definition: MultChanContainer.h:307
TRTCondStoreText::TRTCondStoreText
TRTCondStoreText(const std::string &name, ISvcLocator *pSvcLocator)
constructor
Definition: TRTCondStoreText.cxx:22
TRTCondStoreText::initialize
virtual StatusCode initialize(void) override
Definition: TRTCondStoreText.cxx:24
BasicRtRelation.h
TRTCondStoreText::execute
virtual StatusCode execute(void) override
Definition: TRTCondStoreText.cxx:54
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TRTCondStoreText.h
Algorithm to read TRT Conditions objects from text file and stream them to db.
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TRTCond::RtRelation
Definition: RtRelation.h:27
TRT_ID::straw
int straw(const Identifier &id) const
Definition: TRT_ID.h:896
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
TRTCond::RtRelationFactory::readFromFile
static RtRelation * readFromFile(std::istream &is)
read method
Definition: RtRelationFactory.h:33
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
BinnedRtRelation.h
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TRTCond::MultChanContainer::initialize
StatusCode initialize()
Initialization done after creation or read back - derived classes may augment the functionality.
Definition: MultChanContainer.h:376
TRT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: TRT_ID.h:860
TRT_ID::straw_layer
int straw_layer(const Identifier &id) const
Definition: TRT_ID.h:887
TRT_ID::layer_or_wheel
int layer_or_wheel(const Identifier &id) const
Definition: TRT_ID.h:878
TRTCondStoreText::readTextFile_Format1
virtual StatusCode readTextFile_Format1(std::istream &)
Definition: TRTCondStoreText.cxx:132
AthAlgorithm
Definition: AthAlgorithm.h:47
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TRT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: TRT_ID.h:869
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
TRTCondStoreText::readTextFile_Format2
virtual StatusCode readTextFile_Format2(std::istream &)
Definition: TRTCondStoreText.cxx:237
RtRelationFactory.h
python.CaloAddPedShiftConfig.default
default
Definition: CaloAddPedShiftConfig.py:43
TRTCondStoreText::m_par_slopecontainerkey
Gaudi::Property< std::string > m_par_slopecontainerkey
Definition: TRTCondStoreText.h:59
TRTCond::MultChanContainer::footprint
size_t footprint() const
return the memory allocated by the layercontainers.
Definition: MultChanContainer.h:315
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TRTCondStoreText::m_par_caltextfile
Gaudi::Property< std::string > m_par_caltextfile
Definition: TRTCondStoreText.h:62
TRTCondStoreText::m_par_t0containerkey
Gaudi::Property< std::string > m_par_t0containerkey
Definition: TRTCondStoreText.h:61
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
TRTCondStoreText::readTextFile
virtual StatusCode readTextFile(const std::string &file, int &format)
Definition: TRTCondStoreText.cxx:95
TRTCond::ExpandedIdentifier
Identifier for TRT detector elements in the conditions code.
Definition: InnerDetector/InDetConditions/TRT_ConditionsData/TRT_ConditionsData/ExpandedIdentifier.h:30
TRTCond::StrawT0MultChanContainer
Definition: StrawT0MultChanContainer.h:31
TRTCondStoreText::m_trtid
const TRT_ID * m_trtid
trt id helper
Definition: TRTCondStoreText.h:65
TRTCondStoreText::trtcondid
virtual TRTCond::ExpandedIdentifier trtcondid(const Identifier &id, int level=TRTCond::ExpandedIdentifier::STRAW) const
create an TRTCond::ExpandedIdentifier from a TRTID identifier
Definition: TRTCondStoreText.cxx:501
TRTCond::RtRelationMultChanContainer
Definition: RtRelationMultChanContainer.h:29
Identifier
Definition: IdentifierFieldParser.cxx:14