ATLAS Offline Software
AthenaHDFStreamTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /* file contains the implementation for the AthenaHDFStreamTool class.
6  * @author Peter van Gemmeren <gemmeren@anl.gov>
7  **/
8 
9 #include "AthenaHDFStreamTool.h"
10 
11 #include "GaudiKernel/FileIncident.h"
12 
13 #include "StorageSvc/DbReflex.h"
14 #include "RootUtils/APRDefaults.h"
15 #include "CxxUtils/starts_with.h"
16 
17 #include "H5Cpp.h"
18 #include "H5File.h"
19 #include "H5Group.h"
20 
21 static const char* const fmt_oid = "[OID=%08lX%08lX-%016llX]";
22 static const char* const fmt_aux = "[AUX=%08lX]";
23 
24 namespace{
25  void
26  stringBefore(std::string & s, char sc){
27  auto n = s.find(sc);
28  if (n!=std::string::npos) s.resize(n);
29  return;
30  }
31 }
32 
33 //___________________________________________________________________________
34 AthenaHDFStreamTool::AthenaHDFStreamTool(const std::string& type,
35  const std::string& name,
36  const IInterface* parent) : AthAlgTool(type, name, parent),
37  m_file(nullptr),
38  m_group(nullptr),
39  m_token(""),
40  m_read_data(nullptr),
41  m_read_size(0),
42  m_read_position(0),
43  m_event_iter(0),
44  m_isClient(false),
45  m_incidentSvc("IncidentSvc", name) {
46  declareInterface<IAthenaIPCTool>(this);
47 }
48 
49 //___________________________________________________________________________
50 AthenaHDFStreamTool::~AthenaHDFStreamTool() {
51 }
52 
53 //___________________________________________________________________________
54 StatusCode AthenaHDFStreamTool::initialize() {
55  if (!::AthAlgTool::initialize().isSuccess()) {
56  ATH_MSG_FATAL("Cannot initialize AthAlgTool base class.");
57  return(StatusCode::FAILURE);
58  }
59  // Retrieve IncidentSvc
60  if (!m_incidentSvc.retrieve().isSuccess()) {
61  ATH_MSG_FATAL("Cannot get IncidentSvc");
62  return(StatusCode::FAILURE);
63  }
64  return(StatusCode::SUCCESS);
65 }
66 
67 //___________________________________________________________________________
68 StatusCode AthenaHDFStreamTool::finalize() {
69  ATH_MSG_INFO("in finalize()");
70  return(::AthAlgTool::finalize());
71 }
72 
73 //___________________________________________________________________________
74 StatusCode AthenaHDFStreamTool::makeServer(int/* num*/, const std::string& /*streamPortSuffix*/) {
75  ATH_MSG_ERROR("AthenaHDFStreamTool::makeServer");
76  return(StatusCode::FAILURE);
77 }
78 
79 //___________________________________________________________________________
80 bool AthenaHDFStreamTool::isServer() const {
81  return(false);
82 }
83 
84 //___________________________________________________________________________
85 StatusCode AthenaHDFStreamTool::makeClient(int num, std::string& /*streamPortSuffix*/) {
86  ATH_MSG_INFO("AthenaHDFStreamTool::makeClient: " << num);
87 
88  if (num > 0) {
89  m_file = new H5::H5File( "test.h5", H5F_ACC_TRUNC ); //FIXME, hardcoded filename
90  m_group = new H5::Group(m_file->createGroup("data"));
91  } else {
92  m_file = new H5::H5File( "test.h5", H5F_ACC_RDONLY );
93  m_group = new H5::Group(m_file->openGroup("data"));
94  }
95  m_isClient = true;
96  return(StatusCode::SUCCESS);
97 }
98 
99 //___________________________________________________________________________
100 bool AthenaHDFStreamTool::isClient() const {
101  return(m_isClient);
102 }
103 
104 //___________________________________________________________________________
105 StatusCode AthenaHDFStreamTool::putEvent(long/* eventNumber*/, const void* /* source*/, std::size_t/* nbytes*/, unsigned int/* status*/) const {
106  ATH_MSG_ERROR("AthenaHDFStreamTool::putEvent");
107  return(StatusCode::FAILURE);
108 }
109 
110 //___________________________________________________________________________
111 StatusCode AthenaHDFStreamTool::getLockedEvent(void** target, unsigned int&/* status*/) const {
112  ATH_MSG_INFO("AthenaHDFStreamTool::getLockedEvent");
113  const std::string dh_entry = "POOLContainer(DataHeader)_entry";
114  H5::DataSet dataset = m_group->openDataSet(dh_entry);
115  if (m_event_iter + 1 >= dataset.getInMemDataSize()/8) { // End of File
116  FileIncident endFileIncident(name(), "EndInputFile", "HDF:test.h5"); //FIXME, hardcoded filename
117  m_incidentSvc->fireIncident(endFileIncident);
118  ATH_MSG_INFO("AthenaHDFStreamTool::getLockedEvent: no more events = " << m_event_iter);
119  return(StatusCode::RECOVERABLE);
120  }
121 
122  const hsize_t offset[1] = {m_event_iter};
123  H5::DataSpace filespace = dataset.getSpace();
124  const hsize_t mem_size[1] = {2};
125  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
126  H5::DataSpace memspace(1, mem_size);
127  long long unsigned int ds_data[2] = {0, 0};
128  dataset.read(ds_data, H5::PredType::NATIVE_ULLONG, memspace, filespace);
129  std::size_t nbytes = ds_data[1] - ds_data[0];
130  m_token = "[DB=00000000-0000-0000-0000-000000000000][CNT=POOLContainer(DataHeader)][CLID=4DDBD295-EFCE-472A-9EC8-15CD35A9EB8D][TECH=00000401]";
131  char text[64];
132  sprintf(text, fmt_oid, 0ul, nbytes, m_event_iter);
133  text[40] = 0;
134  m_token += text;
135 
136  const int length = m_token.size() + 2; //FIXME: copy token
137  *target = new char[length];
138  std::memcpy(static_cast<char*>(*target), m_token.c_str(), length - 1);
139  target[length - 1] = 0;
140  return(StatusCode::SUCCESS);
141 }
142 
143 //___________________________________________________________________________
144 StatusCode AthenaHDFStreamTool::lockEvent(long eventNumber) const {
145  ATH_MSG_VERBOSE("AthenaHDFStreamTool::lockEvent: " << eventNumber);
146  m_event_iter = eventNumber;
147  if (eventNumber == 0) {
148  FileIncident beginFileIncident(name(), "BeginInputFile", "HDF:test.h5"); //FIXME, hardcoded filename
149  m_incidentSvc->fireIncident(beginFileIncident);
150  }
151  return(StatusCode::SUCCESS);
152 }
153 
154 //___________________________________________________________________________
155 StatusCode AthenaHDFStreamTool::putObject(const void* source, std::size_t nbytes, int/* num*/) {
156  if (nbytes == 0 || m_token.empty()) {
157  return(StatusCode::SUCCESS);
158  }
159  ATH_MSG_INFO("AthenaHDFStreamTool::putObject: source = " << source << ", nbytes = " << nbytes);
160 
161  if (m_token.find("[CONT=") != std::string::npos) m_token.replace(m_token.find("[CONT="), 6, "[CNT=");
162  std::string ds_name = m_token.substr(m_token.find("[CNT=") + 5);
163  stringBefore(ds_name,']');
164  while (ds_name.find("/") != std::string::npos) { ds_name = ds_name.replace(ds_name.find("/"), 1, "_"); }
165 
166  m_token.replace(m_token.find("[TECH="), 15, "[TECH=00000401]");
167  std::string className = m_token.substr(m_token.find("[PNAME=") + 7);
168  stringBefore(className, ']');
169 
170  long long unsigned int positionCount = 0;
171  if (m_token.find("[CLID=") == std::string::npos) { // Core object
172  m_token += "[CLID=" + pool::DbReflex::guid(RootType::ByNameNoQuiet(className)).toString() + "]";
173  } else { // Aux Store extension
174  char text[64];
175  sprintf(text, fmt_aux, nbytes);
176  text[15] = 0;
177  H5::DataSet dataset = m_group->openDataSet(ds_name);
178  const hsize_t offset[1] = {dataset.getInMemDataSize()};
179  positionCount = offset[0];
180  const hsize_t ds_size[1] = {offset[0] + 15};
181  dataset.extend(ds_size);
182  H5::DataSpace filespace = dataset.getSpace();
183  const hsize_t mem_size[1] = {15};
184  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
185  H5::DataSpace memspace(1, mem_size);
186  dataset.write(text, H5::PredType::NATIVE_CHAR, memspace, filespace);
187  }
188 
189 // Write Payload data
190  if (!m_group->exists(ds_name)) { //if dataset doesn't exist, create it otherwise extend it
191  const hsize_t maxdim[1] = {H5S_UNLIMITED};
192  const hsize_t ds_size[1] = {nbytes};
193  H5::DataSpace filespace(1, ds_size, maxdim);
194  H5::DSetCreatPropList ds_prop;
195  hsize_t chunkdim[1] = {nbytes};
196  if( CxxUtils::starts_with(ds_name, APRDefaults::TTreeNames::EventData) ||
197  CxxUtils::starts_with(ds_name, APRDefaults::TTreeNames::EventTag) ) {
198  if (nbytes < 512) {
199  chunkdim[0] = 4096;
200  } else if (nbytes < 16 * 512) {
201  chunkdim[0] = 4 * 4096;
202  } else {
203  chunkdim[0] = (int(nbytes / 4096) + 1) * 4096;
204  }
205  }
206  ds_prop.setChunk(1, chunkdim);
207  char fill_val[1] = {0};
208  ds_prop.setFillValue(H5::PredType::NATIVE_CHAR, fill_val);
209  H5::DataSet dataset = m_group->createDataSet(ds_name, H5::PredType::NATIVE_CHAR, filespace, ds_prop);
210  dataset.write(source, H5::PredType::NATIVE_CHAR);
211  } else {
212  H5::DataSet dataset = m_group->openDataSet(ds_name);
213  const hsize_t offset[1] = {dataset.getInMemDataSize()};
214  positionCount = offset[0];
215  const hsize_t ds_size[1] = {offset[0] + nbytes};
216  dataset.extend(ds_size);
217  H5::DataSpace filespace = dataset.getSpace();
218  const hsize_t mem_size[1] = {nbytes};
219  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
220  H5::DataSpace memspace(1, mem_size);
221  dataset.write(source, H5::PredType::NATIVE_CHAR, memspace, filespace);
222  }
223  if (m_token.find("[OID=") == std::string::npos) { // Core object
224  char text[64];
225  sprintf(text, fmt_oid, 0ul, nbytes, positionCount);
226  text[40] = 0;
227  m_token += text;
228  } else {
229  char text[64];
230  std::size_t firstU, firstL;
231  long long unsigned int second;
232  ::sscanf(m_token.substr(m_token.find("[OID="), 40).c_str(), fmt_oid, &firstU, &firstL, &second);
233  if (firstU == 0ul) { //FIXME1
234  firstU = firstL; // Keep Core object size
235  }
236  firstL = positionCount + nbytes - second;
237  sprintf(text, fmt_oid, firstU, firstL, second); // FIXME
238  text[40] = 0;
239  m_token.replace(m_token.find("[OID="), 39, text);
240  }
241 
242  std::string entry_name = ds_name.substr(ds_name.find('(') + 1);
243  stringBefore(entry_name,')');
244 // For DataHeader, store entry point
245  if (entry_name == "DataHeader" || entry_name == "DataHeaderForm") {
246  auto dh_entry = ds_name + "_entry";
247  if (!m_group->exists(dh_entry)) {
248  const hsize_t maxdim[1] = {H5S_UNLIMITED};
249  const hsize_t ds_size[1] = {2};
250  H5::DataSpace filespace(1, ds_size, maxdim);
251  H5::DSetCreatPropList ds_prop;
252  const hsize_t chunkdim[1] = {512};
253  ds_prop.setChunk(1, chunkdim);
254  char fill_val[1] = {0};
255  ds_prop.setFillValue(H5::PredType::NATIVE_ULLONG, fill_val);
256  H5::DataSet dataset = m_group->createDataSet(dh_entry, H5::PredType::NATIVE_ULLONG, filespace, ds_prop);
257  long long unsigned int ds_data[2] = {positionCount, positionCount + nbytes};
258  dataset.write(ds_data, H5::PredType::NATIVE_ULLONG);
259  } else {
260  H5::DataSet dataset = m_group->openDataSet(dh_entry);
261  const hsize_t offset[1] = {dataset.getInMemDataSize()/8};//FIXME
262  const hsize_t ds_size[1] = {offset[0] + 1};
263  dataset.extend(ds_size);
264  H5::DataSpace filespace = dataset.getSpace();
265  const hsize_t mem_size[1] = {1};
266  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
267  H5::DataSpace memspace(1, mem_size);
268  long long unsigned int ds_data[1] = {positionCount + nbytes};
269  dataset.write(ds_data, H5::PredType::NATIVE_ULLONG, memspace, filespace);
270  }
271  if (entry_name == "DataHeader") {
272  auto dh_form_entry = ds_name + "_form_entry";
273  if (!m_group->exists(dh_form_entry)) {
274  const hsize_t maxdim[1] = {H5S_UNLIMITED};
275  const hsize_t ds_size[1] = {1};
276  H5::DataSpace filespace(1, ds_size, maxdim);
277  H5::DSetCreatPropList ds_prop;
278  const hsize_t chunkdim[1] = {512};
279  ds_prop.setChunk(1, chunkdim);
280  char fill_val[1] = {0};
281  ds_prop.setFillValue(H5::PredType::NATIVE_ULLONG, fill_val);
282  H5::DataSet dataset = m_group->createDataSet(dh_form_entry, H5::PredType::NATIVE_ULLONG, filespace, ds_prop);
283  long long unsigned int ds_data[1] = {0};
284  dataset.write(ds_data, H5::PredType::NATIVE_ULLONG);
285  } else {
286  H5::DataSet dataset = m_group->openDataSet(dh_form_entry);
287  const hsize_t offset[1] = {dataset.getInMemDataSize()/8};//FIXME
288  const hsize_t ds_size[1] = {offset[0] + 1};
289  dataset.extend(ds_size);
290  H5::DataSpace filespace = dataset.getSpace();
291  const hsize_t mem_size[1] = {1};
292  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
293  H5::DataSpace memspace(1, mem_size);
294  auto dh_form_entry_name = ds_name.substr(0, ds_name.find('(')) + "Form(DataHeaderForm)_entry";
295  H5::DataSet dh_form_dataset = m_group->openDataSet(dh_form_entry_name);
296  long long unsigned int ds_data[1] = {dh_form_dataset.getInMemDataSize()/8 - 1};//FIXME
297  dataset.write(ds_data, H5::PredType::NATIVE_ULLONG, memspace, filespace);
298  }
299  }
300  if (entry_name == "DataHeaderForm") {
301  auto dh_entry_name = ds_name.substr(0, ds_name.find('(') - 4) + "(DataHeader)_form_entry";
302  H5::DataSet dataset = m_group->openDataSet(dh_entry_name);
303  const hsize_t offset[1] = {dataset.getInMemDataSize()/8 - 1};//FIXME
304  H5::DataSpace filespace = dataset.getSpace();
305  const hsize_t mem_size[1] = {1};
306  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
307  H5::DataSpace memspace(1, mem_size);
308  H5::DataSet dh_form_dataset = m_group->openDataSet(ds_name + "_entry");
309  long long unsigned int ds_data[1] = {dh_form_dataset.getInMemDataSize()/8 - 1};//FIXME
310  dataset.write(ds_data, H5::PredType::NATIVE_ULLONG, memspace, filespace);
311  }
312  }
313  return(StatusCode::SUCCESS);
314 }
315 
316 //___________________________________________________________________________
317 StatusCode AthenaHDFStreamTool::getObject(void** target, std::size_t& nbytes, int/* num*/) {
318  if (m_token.empty()) {
319  return(StatusCode::SUCCESS);
320  }
321  ATH_MSG_INFO("AthenaHDFStreamTool::getObject: token = " << m_token);
322 
323  std::string clid_name = m_token.substr(m_token.find("[CLID=") + 6);
324  stringBefore(clid_name,']');
325  std::string ds_name = m_token.substr(m_token.find("[CNT=") + 5);
326  stringBefore(ds_name, ']');
327  if (ds_name.empty()) {
328  return(StatusCode::SUCCESS);
329  }
330  while (ds_name.find('/') != std::string::npos) { ds_name = ds_name.replace(ds_name.find('/'), 1, "_"); }
331 
332  std::string oid_name = m_token.substr(m_token.find("[OID="));
333  auto n = oid_name.find(']') + 1;
334  oid_name.resize(n);
335  std::size_t firstU, firstL;
336  long long unsigned int second;
337  ::sscanf(oid_name.c_str(), fmt_oid, &firstU, &firstL, &second);
338  if (m_read_size > m_read_position + 15) { // aux store data already read
339  std::size_t aux_size = 0;
340  ::sscanf(m_read_data + m_read_position, fmt_aux, &aux_size);
341  m_read_position += 15;
342  *target = m_read_data + m_read_position;
343  nbytes = aux_size;
344  m_read_position += nbytes;
345  char text[64];
346  sprintf(text, fmt_oid, m_read_position, firstL, second); // FIXME
347  text[40] = 0;
348  m_token.replace(m_token.find("[OID="), 39, text);
349  return(StatusCode::SUCCESS);
350  } else if (m_read_size > 0) {
351  return(StatusCode::FAILURE);
352  }
353 
354  std::string entry_name = ds_name.substr(ds_name.find('(') + 1);
355  stringBefore(entry_name,')');
356 // For DataHeader, get stored size
357  if (entry_name == "DataHeader") {
358  if (clid_name == "7BE56CEF-C866-4BEE-9348-A5F34B5F1DAD") { // DataHeaderForm Token is copied from DataHeader, change container name
359  ds_name.replace(ds_name.find("(DataHeader)"), 12, "Form(DataHeaderForm)");
360  second = m_event_iter; //FIXME, store real DHF id somewhere...
361  } else if (clid_name == "00000000-0000-0000-0000-000000000000") { // Return DataHeader Token, for createAddress
362  if (firstL > 0) { //FIXME1
363  m_token.clear();
364  } else {
365  m_token.replace(m_token.find("[CLID="), 43, "[CLID=4DDBD295-EFCE-472A-9EC8-15CD35A9EB8D]");
366  m_token.replace(m_token.find("[TECH="), 15, "[TECH=00000401]");
367  }
368  nbytes = m_token.size();
369  *target = const_cast<char*>(m_token.c_str());//FIXME
370  return(StatusCode::SUCCESS);
371  } else {
372  m_event_iter = second;
373  }
374 
375  auto dh_entry = ds_name + "_entry";
376  H5::DataSet dataset = m_group->openDataSet(dh_entry);
377  if (second + 1 >= dataset.getInMemDataSize()/8) {
378  return(StatusCode::FAILURE);
379  }
380  const hsize_t offset[1] = {second};
381  H5::DataSpace filespace = dataset.getSpace();
382  const hsize_t mem_size[1] = {2};
383  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
384  H5::DataSpace memspace(1, mem_size);
385  long long unsigned int ds_data[2] = {0, 0};
386  dataset.read(ds_data, H5::PredType::NATIVE_ULLONG, memspace, filespace);
387  firstL = ds_data[1] - ds_data[0]; //FIXME1
388  second = ds_data[0];
389  }
390 
391  if (!m_group->exists(ds_name)) {
392  return(StatusCode::FAILURE);
393  }
394  H5::DataSet dataset = m_group->openDataSet(ds_name);
395  if (second + firstL > dataset.getInMemDataSize()) {
396  return(StatusCode::FAILURE);
397  }
398  const hsize_t offset[1] = {second};
399  H5::DataSpace filespace = dataset.getSpace();
400  const hsize_t mem_size[1] = {firstL};
401  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
402  H5::DataSpace memspace(1, mem_size);
403  m_read_data = new char[firstL];
404  m_read_size = firstL;
405  dataset.read(m_read_data, H5::PredType::NATIVE_CHAR, memspace, filespace);
406  *target = m_read_data;
407  if (firstU > 0) {
408  ::sscanf(m_read_data + firstL - 15, fmt_aux, &nbytes);
409  } else {
410  nbytes = firstL;
411  }
412  m_read_position = nbytes;
413  return(StatusCode::SUCCESS);
414 }
415 
416 //___________________________________________________________________________
417 StatusCode AthenaHDFStreamTool::clearObject(const char** tokenString, int&/* num*/) {
418  std::size_t firstU, firstL;
419  long long unsigned int second;
420  ::sscanf(m_token.substr(m_token.find("[OID="), 40).c_str(), fmt_oid, &firstU, &firstL, &second);
421  std::string ds_name = m_token.substr(m_token.find("[CNT=") + 5);
422  stringBefore(ds_name, ']');
423  while (ds_name.find('/') != std::string::npos) { ds_name = ds_name.replace(ds_name.find('/'), 1, "_"); }
424 
425  if (firstU > 0 || ds_name.substr(ds_name.length() - 5, 4) == "Aux.") {
426  if (firstU == 0) firstU = firstL;
427  char text[64];
428  sprintf(text, fmt_aux, firstU);
429  text[15] = 0;
430  H5::DataSet dataset = m_group->openDataSet(ds_name);
431  const hsize_t offset[1] = {dataset.getInMemDataSize()};
432  const hsize_t ds_size[1] = {offset[0] + 15};
433  dataset.extend(ds_size);
434  H5::DataSpace filespace = dataset.getSpace();
435  const hsize_t mem_size[1] = {15};
436  filespace.selectHyperslab(H5S_SELECT_SET, mem_size, offset);
437  H5::DataSpace memspace(1, mem_size);
438  dataset.write(text, H5::PredType::NATIVE_CHAR, memspace, filespace);
439  firstL += 15;
440  firstU = 1ul;
441  sprintf(text, fmt_oid, firstU, firstL, second); // FIXME
442  text[40] = 0;
443  m_token.replace(m_token.find("[OID="), 39, text);
444  }
445  // Return an empty token string for DataHeaderForm, to indicate HDF5 can't update DataHeader after it was written.
446  std::string entry_name = ds_name.substr(ds_name.find('(') + 1);
447  stringBefore(entry_name, ')');
448  if (entry_name == "DataHeaderForm") {
449  m_token.clear();
450  }
451  *tokenString = m_token.c_str();
452  return(StatusCode::SUCCESS);
453 }
454 
455 //___________________________________________________________________________
456 StatusCode AthenaHDFStreamTool::lockObject(const char* tokenString, int/* num*/) {
457  m_token = tokenString;
458  delete [] m_read_data; m_read_data = nullptr;
459  m_read_size = 0;
460  m_read_position = 0;
461  return(StatusCode::SUCCESS);
462 }
AthenaHDFStreamTool::lockEvent
StatusCode lockEvent(long eventNumber) const
Definition: AthenaHDFStreamTool.cxx:144
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
AthenaHDFStreamTool::initialize
StatusCode initialize()
Gaudi Service Interface method implementations:
Definition: AthenaHDFStreamTool.cxx:54
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:53
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
AthenaHDFStreamTool::~AthenaHDFStreamTool
virtual ~AthenaHDFStreamTool()
Destructor.
Definition: AthenaHDFStreamTool.cxx:50
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
CxxUtils::starts_with
bool starts_with(const char *s, const char *prefix)
Test whether one null-terminated byte string starts with another.
TScopeAdapter::ByNameNoQuiet
static TScopeAdapter ByNameNoQuiet(const std::string &name, Bool_t load=kTRUE)
Definition: RootType.cxx:581
DbReflex.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AthenaHDFStreamTool::makeClient
StatusCode makeClient(int num, std::string &streamPortSuffix)
Definition: AthenaHDFStreamTool.cxx:85
AthenaHDFStreamTool::getLockedEvent
StatusCode getLockedEvent(void **target, unsigned int &status) const
Definition: AthenaHDFStreamTool.cxx:111
initialize
void initialize()
Definition: run_EoverP.cxx:894
APRDefaults::TTreeNames::EventTag
static constexpr const char * EventTag
Definition: APRDefaults.h:13
Guid::toString
const std::string toString() const
Automatic conversion to string representation.
Definition: Guid.cxx:58
AthenaHDFStreamTool::isClient
bool isClient() const
Definition: AthenaHDFStreamTool.cxx:100
AthenaHDFStreamTool::m_read_size
std::size_t m_read_size
Definition: AthenaHDFStreamTool.h:83
AthenaHDFStreamTool::m_read_position
std::size_t m_read_position
Definition: AthenaHDFStreamTool.h:84
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
AthenaHDFStreamTool::putObject
StatusCode putObject(const void *source, std::size_t nbytes, int num=0)
Definition: AthenaHDFStreamTool.cxx:155
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
m_file
std::unique_ptr< TFile > m_file
description: this is a custom writer for the old-school drivers that don't use an actual writer
Definition: OutputStreamData.cxx:52
JetTagCalibConfig.className
string className
Definition: JetTagCalibConfig.py:31
AthenaHDFStreamTool::m_token
std::string m_token
Definition: AthenaHDFStreamTool.h:81
APRDefaults.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaHDFStreamTool::m_read_data
char * m_read_data
Definition: AthenaHDFStreamTool.h:82
AthenaHDFStreamTool::lockObject
StatusCode lockObject(const char *tokenString, int num=0)
Definition: AthenaHDFStreamTool.cxx:456
dataset
Definition: dataset.h:27
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
starts_with.h
C++20-like starts_with/ends_with for strings.
AthenaHDFStreamTool::m_event_iter
long long unsigned int m_event_iter
Definition: AthenaHDFStreamTool.h:85
AthenaHDFStreamTool::isServer
bool isServer() const
Definition: AthenaHDFStreamTool.cxx:80
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
AthenaHDFStreamTool::finalize
StatusCode finalize()
Definition: AthenaHDFStreamTool.cxx:68
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
AthenaHDFStreamTool.h
This file contains the class definition for the AthenaHDFStreamTool class.
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
AthenaHDFStreamTool::makeServer
StatusCode makeServer(int num, const std::string &streamPortSuffix)
Definition: AthenaHDFStreamTool.cxx:74
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
makeTransCanvas.text
text
Definition: makeTransCanvas.py:11
AthenaHDFStreamTool::getObject
StatusCode getObject(void **target, std::size_t &nbytes, int num=0)
Definition: AthenaHDFStreamTool.cxx:317
AthenaHDFStreamTool::m_file
H5::H5File * m_file
Definition: AthenaHDFStreamTool.h:79
COOLRates.target
target
Definition: COOLRates.py:1106
AthAlgTool
Definition: AthAlgTool.h:26
APRDefaults::TTreeNames::EventData
static constexpr const char * EventData
Definition: APRDefaults.h:12
AthenaHDFStreamTool::m_isClient
bool m_isClient
Definition: AthenaHDFStreamTool.h:86
AthenaHDFStreamTool::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: AthenaHDFStreamTool.h:87
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
AthenaHDFStreamTool::clearObject
StatusCode clearObject(const char **tokenString, int &num)
Definition: AthenaHDFStreamTool.cxx:417
AthenaHDFStreamTool::AthenaHDFStreamTool
AthenaHDFStreamTool(const std::string &type, const std::string &name, const IInterface *parent)
Standard Service Constructor.
Definition: AthenaHDFStreamTool.cxx:34
AthenaHDFStreamTool::m_group
H5::Group * m_group
Definition: AthenaHDFStreamTool.h:80
pool::DbReflex::guid
static Guid guid(const TypeH &id)
Determine Guid (normalized string form) from reflection type.
Generated on Sun Jun 30 2024 21:10:43 for ATLAS Offline Software by   doxygen 1.8.18