ATLAS Offline Software
LumiBlockMetaDataTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
10 #include "LumiBlockMetaDataTool.h"
11 
12 #include "StoreGate/StoreGateSvc.h"
14 
15 #include <algorithm>
16 
17 //___________________________________________________________________________
19  , const std::string& name
20  , const IInterface* parent)
21  : base_class(type, name, parent)
22  , m_pMetaDataStore ("StoreGateSvc/MetaDataStore", name)
23  , m_pInputStore ("StoreGateSvc/InputMetaDataStore", name)
24 {
25  // Here is where we create the LumiBlockRange objects. When we open a
26  // file, we fill the m_cacheInputRangeContainer from the input metadata store.
27  // When the file closes, we move the LumiBlockRange objects to the
28  // m_cacheOutputRangeContainer. Objects in the m_cacheOutputRangeContainer
29  // will be sorted and merged at the end of the job
30  // Note: the Suspect Range objects are kept in separate containers because
31  // once an object is suspect, it remains suspect forever
32  // If a file is only partially read, the objects in the m_cacheInputRangeContainer
33  // will be moved to the m_suspectOutputRangeContainer
34 
39 }
40 
41 //___________________________________________________________________________
43 }
44 
45 //___________________________________________________________________________
47  ATH_MSG_INFO( "in initialize()" );
48 
49  ATH_CHECK( m_pMetaDataStore.retrieve() );
50  ATH_CHECK( m_pInputStore.retrieve() );
51 
52  return(StatusCode::SUCCESS);
53 }
54 
55 //___________________________________________________________________________
57 {
58  std::string fileName = "Undefined ";
59  bool alreadyRecorded=false;
61  alreadyRecorded=true;
62  }
64  alreadyRecorded=true;
65  }
67  if(alreadyRecorded) return StatusCode::SUCCESS;
69  //
70  // Look for LB information on input store and transfer it to temporay cache
71  // ===========================================================================
72 
74  ATH_MSG_INFO(" Contains xAOD::LumiBlockRangeContainer " << m_LBColl_name);
75  const xAOD::LumiBlockRangeContainer* lbrange =nullptr;
77  if (!sc.isSuccess()) {
78  ATH_MSG_INFO( "Could not find unfinished xAOD::LumiBlockRangeContainer in input metadata store" );
79  return StatusCode::SUCCESS;
80  }
81  ATH_MSG_INFO( "xAOD::LumiBlockRangeContainer size" << lbrange->size() );
82  for ( const auto* lb : *lbrange ) {
85  }
86  }
88  ATH_MSG_INFO(" Contains xAOD::LumiBlockRangeContainer " << m_unfinishedLBColl_name);
89  const xAOD::LumiBlockRangeContainer* lbrange =nullptr;
91  if (!sc.isSuccess()) {
92  ATH_MSG_INFO( "Could not find unfinished xAOD::LumiBlockRangeContainer in input metadata store" );
93  return StatusCode::SUCCESS;
94  }
95  ATH_MSG_INFO( "xAOD::LumiBlockRangeContainer size" << lbrange->size() );
96  for ( const auto* lb : *lbrange ) {
99  }
100  }
102  ATH_MSG_INFO(" Contains xAOD::LumiBlockRangeContainer " << m_suspectLBColl_name);
103  const xAOD::LumiBlockRangeContainer* lbrange =nullptr;
105  if (!sc.isSuccess()) {
106  ATH_MSG_INFO( "Could not find suspect xAOD::LumiBlockRangeContainer in input metadata store" );
107  return StatusCode::SUCCESS;
108  }
109  ATH_MSG_INFO( "xAOD::LumiBlockRangeContainer size" << lbrange->size() );
110  for ( const auto* lb : *lbrange ) {
113  }
114  }
115  return(StatusCode::SUCCESS);
116 }
117 
119 {
120  m_fileCurrentlyOpened=false;
121  for (const auto range : m_cacheInputRangeContainer) {
122  auto iovr = std::make_unique<xAOD::LumiBlockRange>(*range);
123  m_cacheOutputRangeContainer.push_back(std::move(iovr));
124  }
126 
127  for (const auto range : m_cacheSuspectInputRangeContainer) {
128  auto iovr = std::make_unique<xAOD::LumiBlockRange>(*range);
130  }
132  return(StatusCode::SUCCESS);
133 }
134 
136 {
138  ATH_MSG_INFO( "MetaDataStop called when input file open: LumiBlock is suspect" );
139  for (const auto range : m_cacheInputRangeContainer) {
140  auto iovr = std::make_unique<xAOD::LumiBlockRange>(*range);
142  }
144  }
145 
146  ATH_CHECK( finishUp() );
147  return(StatusCode::SUCCESS);
148 }
149 
150 //__________________________________________________________________________
152  //
153  // stop() is called whenever the event loop is finished.
154  // ======================================================
155  ATH_MSG_VERBOSE( " finishUp: write lumiblocks to meta data store " );
156 
157  auto piovComplete = std::make_unique<xAOD::LumiBlockRangeContainer>();
158  auto piovCompleteAux = std::make_unique<xAOD::LumiBlockRangeAuxContainer>();
159  piovComplete->setStore( piovCompleteAux.get() );
160 
161  auto piovUnfinished = std::make_unique<xAOD::LumiBlockRangeContainer>();
162  auto piovUnfinishedAux = std::make_unique<xAOD::LumiBlockRangeAuxContainer>();
163  piovUnfinished->setStore( piovUnfinishedAux.get() );
164 
165  auto piovSuspect = std::make_unique<xAOD::LumiBlockRangeContainer>();
166  auto piovSuspectAux = std::make_unique<xAOD::LumiBlockRangeAuxContainer>();
167  piovSuspect->setStore( piovSuspectAux.get() );
168 
170  ATH_MSG_VERBOSE("Suspect OutputRangeCollection with size " << m_cacheSuspectOutputRangeContainer.size());
171  for (const auto range : m_cacheSuspectOutputRangeContainer) {
172  auto iovr = std::make_unique<xAOD::LumiBlockRange>(*range);
173  piovSuspect->push_back(std::move(iovr));
174  }
175  }
176 
178  ATH_MSG_VERBOSE("OutputRangeCollection with size " << m_cacheOutputRangeContainer.size());
180 
181  // Use tmp collection to do the merging
184  tempLBColl.setStore( p_tempAuxLBColl );
185 
186  // Sort and Merge LumiBlockRange objects if necessary
187  // Merge LumiBlockRange objects for same run and lumiblock
192  tempLBColl.push_back(iovr);
193  ATH_MSG_VERBOSE( "Push_back tmpLBColl with run "
194  << (*i)->startRunNumber() << " LB " << (*i)->startLumiBlockNumber() << " events seen "
195  << (*ilast)->eventsSeen() << " expected " << (*i)->eventsExpected());
196  ++i;
197  while (i != ie) {
198  if( ((*i)->startRunNumber()==(*ilast)->startRunNumber()) &&
199  ((*i)->stopRunNumber()==(*ilast)->stopRunNumber()) &&
200  ((*i)->startLumiBlockNumber()==(*ilast)->startLumiBlockNumber()) &&
201  ((*i)->stopLumiBlockNumber()==(*ilast)->stopLumiBlockNumber()) ) {
202 
203  if((*ilast)->eventsExpected()!=(*i)->eventsExpected()) {
204  ATH_MSG_WARNING( "Error: tmpLBColl with run " << (*i)->startRunNumber() << " LB " << (*i)->startLumiBlockNumber() << " events expected "
205  << (*ilast)->eventsExpected() << " and " << (*i)->eventsExpected() );
206  }
207  else {
208  ATH_MSG_VERBOSE( "Merge Run " << (*i)->startRunNumber() << " LB " << (*i)->startLumiBlockNumber()
209  << " events seen " << iovr->eventsSeen() << "+"
210  << (*i)->eventsSeen() << " and events expected "
211  << iovr->eventsExpected() );
212 
213  iovr->setEventsSeen((*i)->eventsSeen()+iovr->eventsSeen());
214  }
215  }
216  else {
217  iovr = new xAOD::LumiBlockRange(*(*i));
218 
219  ATH_MSG_VERBOSE( "Push_back tmpLBColl with run "
220  << iovr->startRunNumber() << " LB " << iovr->startLumiBlockNumber() << " events seen "
221  << iovr->eventsSeen() << " expected " << iovr->eventsExpected());
222 
223  tempLBColl.push_back(iovr);
224  ilast = i;
225  }
226  ++i;
227  }
228 
229  for (const auto range : tempLBColl) {
230  auto iovr = std::make_unique<xAOD::LumiBlockRange>(*range);
231  if(range->eventsSeen() == range->eventsExpected() ) {
232  piovComplete->push_back(std::move(iovr));
233  }
234  else if(range->eventsSeen() > range->eventsExpected() ) {
235  piovSuspect->push_back(std::move(iovr));
236  }
237  else {
238  piovUnfinished->push_back(std::move(iovr));
239  }
240  }
241  }
242 
243 
244  if(!piovComplete->empty()) {
245  ATH_MSG_DEBUG( "Number of Complete LumiBlocks:" << piovComplete->size() );
246  for (const auto range : *piovComplete) {
247  ATH_MSG_INFO("\t [ ("
248  << range->startRunNumber() << "," << range->startLumiBlockNumber()
249  << "):("
250  << range->startRunNumber() << "," << range->startLumiBlockNumber()
251  << ") eventsSeen = " << range->eventsSeen()
252  << ", eventsExpected = " << range->eventsExpected()
253  << " ]");
254  }
255  }
256 
257  if(!piovUnfinished->empty()) {
258  ATH_MSG_DEBUG( "Number of Unfinished LumiBlocks:" << piovUnfinished->size() );
259  for (const auto range : *piovUnfinished) {
260  ATH_MSG_INFO("\t [ ("
261  << range->startRunNumber() << "," << range->startLumiBlockNumber()
262  << "):("
263  << range->startRunNumber() << "," << range->startLumiBlockNumber()
264  << ") eventsSeen = " << range->eventsSeen()
265  << ", eventsExpected = " << range->eventsExpected()
266  << " ]");
267  }
268  }
269  if(!piovSuspect->empty()) {
270  ATH_MSG_DEBUG( "Number of Suspect LumiBlocks:" << piovSuspect->size() );
271  for (const auto range : *piovSuspect) {
272  ATH_MSG_INFO("\t [ ("
273  << range->startRunNumber() << "," << range->startLumiBlockNumber()
274  << "):("
275  << range->startRunNumber() << "," << range->startLumiBlockNumber()
276  << ") eventsSeen = " << range->eventsSeen()
277  << ", eventsExpected = " << range->eventsExpected()
278  << " ]");
279  }
280  }
281 
282  // Store the LumiBlockRangeContainer in the metadata store
283  // =======================================================
284  if (!piovComplete->empty()) {
285  ATH_MSG_INFO("Write Complete LumiBlocks with size " << piovComplete->size());
286  // Check if we have already written them out
289  "Complete LumiBlocks container with key "
290  << m_LBColl_name
291  << " already exists. Updating if there are missing LumiBlocks.");
292  xAOD::LumiBlockRangeContainer* complete = nullptr;
293  ATH_CHECK(m_pMetaDataStore->retrieve(complete, m_LBColl_name));
294 
295  for (const auto range : *piovComplete) {
296  // Check if this configuration is already in the existing container:
297  bool exists = false;
298  for (const auto existing : *complete) {
299  if ((existing->startRunNumber() == range->startRunNumber()) &&
300  (existing->stopRunNumber() == range->stopRunNumber()) &&
301  (existing->startLumiBlockNumber() == range->startLumiBlockNumber()) &&
302  (existing->stopLumiBlockNumber() == range->stopLumiBlockNumber()) &&
303  (existing->eventsSeen() == range->eventsSeen()) &&
304  (existing->eventsExpected() == range->eventsExpected())) {
305  exists = true;
306  break;
307  }
308  }
309  if (exists) {
310  continue;
311  }
312  // New LumiBlock, put it into the output container
313  ATH_MSG_INFO(
314  "Copying LumiBlock: [ ("
315  << range->startRunNumber() << "," << range->stopLumiBlockNumber()
316  << "):(" << range->startRunNumber() << ","
317  << range->stopLumiBlockNumber()
318  << ") eventsSeen = " << range->eventsSeen()
319  << ", eventsExpected = " << range->eventsExpected() << " ]");
321  complete->push_back(out);
322  *out = *range;
323  }
324  } else {
325  ATH_MSG_INFO("Recording "
326  << m_LBColl_name
327  << " LumiBlockRangeContainer in output MetaDataStore");
328  ATH_CHECK(m_pMetaDataStore->record(std::move(piovComplete), m_LBColl_name));
329  ATH_CHECK(m_pMetaDataStore->record(std::move(piovCompleteAux), m_LBColl_name + "Aux."));
330  }
331  }
332 
333  if (!piovUnfinished->empty()) {
334  ATH_MSG_INFO("Write Unfinished LumiBlocks with size " << piovUnfinished->size());
335  // Check if we have already written them out
338  "Unfinished LumiBlocks container with key "
340  << " already exists. Updating if there are missing LumiBlocks.");
341  xAOD::LumiBlockRangeContainer* unfinished = nullptr;
342  ATH_CHECK(m_pMetaDataStore->retrieve(unfinished, m_unfinishedLBColl_name));
343 
344  for (const auto range : *piovUnfinished) {
345  // Check if this configuration is already in the existing container:
346  bool exists = false;
347  for (const auto existing : *unfinished) {
348  if ((existing->startRunNumber() == range->startRunNumber()) &&
349  (existing->stopRunNumber() == range->stopRunNumber()) &&
350  (existing->startLumiBlockNumber() == range->startLumiBlockNumber()) &&
351  (existing->stopLumiBlockNumber() == range->stopLumiBlockNumber()) &&
352  (existing->eventsSeen() == range->eventsSeen()) &&
353  (existing->eventsExpected() == range->eventsExpected())) {
354  exists = true;
355  break;
356  }
357  }
358  if (exists) {
359  continue;
360  }
361  // New LumiBlock, put it into the output container
362  ATH_MSG_INFO(
363  "Copying LumiBlock: [ ("
364  << range->startRunNumber() << "," << range->stopLumiBlockNumber()
365  << "):(" << range->startRunNumber() << ","
366  << range->stopLumiBlockNumber()
367  << ") eventsSeen = " << range->eventsSeen()
368  << ", eventsExpected = " << range->eventsExpected() << " ]");
370  unfinished->push_back(out);
371  *out = *range;
372  }
373  } else {
374  ATH_MSG_INFO("Recording "
376  << " LumiBlockRangeContainer in output MetaDataStore");
377  ATH_CHECK(m_pMetaDataStore->record(std::move(piovUnfinished), m_unfinishedLBColl_name));
378  ATH_CHECK(m_pMetaDataStore->record(std::move(piovUnfinishedAux), m_unfinishedLBColl_name + "Aux."));
379  }
380  }
381 
382  if (!piovSuspect->empty()) {
383  ATH_MSG_INFO("Write Suspect LumiBlocks with size " << piovSuspect->size());
384  // Check if we have already written them out
387  "Suspect LumiBlocks container with key "
389  << " already exists. Updating if there are missing LumiBlocks.");
390  xAOD::LumiBlockRangeContainer* suspect = nullptr;
391  ATH_CHECK(m_pMetaDataStore->retrieve(suspect, m_suspectLBColl_name));
392 
393  for (const auto range : *piovSuspect) {
394  // Check if this configuration is already in the existing container:
395  bool exists = false;
396  for (const auto existing : *suspect) {
397  if ((existing->startRunNumber() == range->startRunNumber()) &&
398  (existing->stopRunNumber() == range->stopRunNumber()) &&
399  (existing->startLumiBlockNumber() == range->startLumiBlockNumber()) &&
400  (existing->stopLumiBlockNumber() == range->stopLumiBlockNumber()) &&
401  (existing->eventsSeen() == range->eventsSeen()) &&
402  (existing->eventsExpected() == range->eventsExpected())) {
403  exists = true;
404  break;
405  }
406  }
407  if (exists) {
408  continue;
409  }
410  // New LumiBlock, put it into the output container
411  ATH_MSG_INFO(
412  "Copying LumiBlock: [ ("
413  << range->startRunNumber() << "," << range->stopLumiBlockNumber()
414  << "):(" << range->startRunNumber() << ","
415  << range->stopLumiBlockNumber()
416  << ") eventsSeen = " << range->eventsSeen()
417  << ", eventsExpected = " << range->eventsExpected() << " ]");
419  suspect->push_back(out);
420  *out = *range;
421  }
422  } else {
423  ATH_MSG_INFO("Recording "
425  << " LumiBlockRangeContainer in output MetaDataStore");
426  ATH_CHECK(m_pMetaDataStore->record(std::move(piovSuspect), m_suspectLBColl_name));
427  ATH_CHECK(m_pMetaDataStore->record(std::move(piovSuspectAux), m_suspectLBColl_name + "Aux."));
428  }
429  }
430 
431  return(StatusCode::SUCCESS);
432 }
LumiBlockMetaDataTool::m_cacheInputRangeAuxContainer
xAOD::LumiBlockRangeAuxContainer m_cacheInputRangeAuxContainer
Definition: LumiBlockMetaDataTool.h:67
xAOD::LumiBlockRange_v1::startLumiBlockNumber
uint32_t startLumiBlockNumber() const
Get the luminosity block of the start time of the range.
LumiBlockMetaDataTool::m_CurrentFileName
std::string m_CurrentFileName
Definition: LumiBlockMetaDataTool.h:58
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
xAOD::LumiBlockRange_v1::eventsSeen
uint32_t eventsSeen() const
Get the number of seen/processed events in this luminosity block range.
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::LumiBlockRange_v1::eventsExpected
uint32_t eventsExpected() const
Get the number of expected events in this luminosity block range.
LumiBlockMetaDataTool::m_cacheInputRangeContainer
xAOD::LumiBlockRangeContainer m_cacheInputRangeContainer
Definition: LumiBlockMetaDataTool.h:66
xAOD::SortLumiBlockRangeByStart
Helper functor used to sort xAOD::LumiBlockRangeContainer-s.
Definition: SortLumiBlockRangeByStart.h:29
xAOD::LumiBlockRangeAuxContainer_v1
Auxiliary container for xAOD::LumiBlockRangeContainer_v1.
Definition: LumiBlockRangeAuxContainer_v1.h:34
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
LumiBlockMetaDataTool::m_suspectLBColl_name
Gaudi::Property< std::string > m_suspectLBColl_name
Definition: LumiBlockMetaDataTool.h:55
LumiBlockMetaDataTool::m_fileCurrentlyOpened
bool m_fileCurrentlyOpened
Definition: LumiBlockMetaDataTool.h:57
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LumiBlockMetaDataTool::LumiBlockMetaDataTool
LumiBlockMetaDataTool(const std::string &type, const std::string &name, const IInterface *parent)
The LumiBlockMetaDataTool reads luminosity metadata from input files and transfers it to output files...
Definition: LumiBlockMetaDataTool.cxx:18
LumiBlockMetaDataTool::finishUp
StatusCode finishUp()
Fill metaDataStore and ntuples.
Definition: LumiBlockMetaDataTool.cxx:151
LumiBlockMetaDataTool::m_cacheSuspectInputRangeContainer
xAOD::LumiBlockRangeContainer m_cacheSuspectInputRangeContainer
Definition: LumiBlockMetaDataTool.h:68
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
xAOD::LumiBlockRange
LumiBlockRange_v1 LumiBlockRange
Declare the latest version of the class.
Definition: LumiBlockRange.h:16
LumiBlockMetaDataTool::m_pInputStore
ServiceHandle< StoreGateSvc > m_pInputStore
Definition: LumiBlockMetaDataTool.h:61
LumiBlockMetaDataTool::m_unfinishedLBColl_name
Gaudi::Property< std::string > m_unfinishedLBColl_name
Definition: LumiBlockMetaDataTool.h:54
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:86
xAOD::LumiBlockRange_v1::startRunNumber
uint32_t startRunNumber() const
Get the run number of the start time of the range.
LumiBlockMetaDataTool::endInputFile
virtual StatusCode endInputFile(const SG::SourceID &) override
Function collecting the metadata from a new input file.
Definition: LumiBlockMetaDataTool.cxx:118
lumiFormat.i
int i
Definition: lumiFormat.py:85
LumiBlockMetaDataTool::m_cacheSuspectInputRangeAuxContainer
xAOD::LumiBlockRangeAuxContainer m_cacheSuspectInputRangeAuxContainer
Definition: LumiBlockMetaDataTool.h:69
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
xAOD::LumiBlockRangeAuxContainer
LumiBlockRangeAuxContainer_v1 LumiBlockRangeAuxContainer
Declare the latest version of the auxiliary container.
Definition: LumiBlockRangeAuxContainer.h:16
LumiBlockMetaDataTool::metaDataStop
virtual StatusCode metaDataStop() override
Function writing the collected metadata to the output.
Definition: LumiBlockMetaDataTool.cxx:135
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::LumiBlockRange_v1::setEventsSeen
void setEventsSeen(uint32_t value)
Set the number of seen/processed events in this luminosity block range.
SortLumiBlockRangeByStart.h
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
LumiBlockMetaDataTool.h
DataVector::clear
void clear()
Erase all the elements in the collection.
LumiBlockMetaDataTool::~LumiBlockMetaDataTool
virtual ~LumiBlockMetaDataTool()
Definition: LumiBlockMetaDataTool.cxx:42
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
python.output.AtlRunQueryRoot.lbrange
lbrange
Definition: AtlRunQueryRoot.py:989
LumiBlockMetaDataTool::m_cacheOutputRangeAuxContainer
xAOD::LumiBlockRangeAuxContainer m_cacheOutputRangeAuxContainer
Definition: LumiBlockMetaDataTool.h:73
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
LumiBlockMetaDataTool::m_cacheSuspectOutputRangeAuxContainer
xAOD::LumiBlockRangeAuxContainer m_cacheSuspectOutputRangeAuxContainer
Definition: LumiBlockMetaDataTool.h:75
LumiBlockMetaDataTool::initialize
virtual StatusCode initialize() override
Definition: LumiBlockMetaDataTool.cxx:46
LumiBlockMetaDataTool::beginInputFile
virtual StatusCode beginInputFile(const SG::SourceID &) override
Function collecting the metadata from a new input file.
Definition: LumiBlockMetaDataTool.cxx:56
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::sort
void sort()
Sort the container.
xAOD::LumiBlockRange_v1
Class describing a luminosity block range.
Definition: LumiBlockRange_v1.h:33
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LumiBlockMetaDataTool::m_cacheOutputRangeContainer
xAOD::LumiBlockRangeContainer m_cacheOutputRangeContainer
Definition: LumiBlockMetaDataTool.h:72
SG::SourceID
std::string SourceID
Definition: AthenaKernel/AthenaKernel/SourceID.h:25
LumiBlockMetaDataTool::m_LBColl_name
Gaudi::Property< std::string > m_LBColl_name
Definition: LumiBlockMetaDataTool.h:53
jobOptions.fileName
fileName
Definition: jobOptions.SuperChic_ALP2.py:39
python.dummyaccess.exists
def exists(filename)
Definition: dummyaccess.py:9
StoreGateSvc.h
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LumiBlockMetaDataTool::m_pMetaDataStore
ServiceHandle< StoreGateSvc > m_pMetaDataStore
Definition: LumiBlockMetaDataTool.h:60
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
LumiBlockMetaDataTool::m_cacheSuspectOutputRangeContainer
xAOD::LumiBlockRangeContainer m_cacheSuspectOutputRangeContainer
Definition: LumiBlockMetaDataTool.h:74
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.