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

This class provides the IPCTool for HDF Stream objects. More...

#include <AthenaHDFStreamTool.h>

Inheritance diagram for AthenaHDFStreamTool:
Collaboration diagram for AthenaHDFStreamTool:

Public Member Functions

 AthenaHDFStreamTool (const std::string &type, const std::string &name, const IInterface *parent)
 Standard Service Constructor. More...
 
virtual ~AthenaHDFStreamTool ()
 Destructor. More...
 
StatusCode initialize ()
 Gaudi Service Interface method implementations: More...
 
StatusCode finalize ()
 
StatusCode makeServer (int num, const std::string &streamPortSuffix)
 
bool isServer () const
 
StatusCode makeClient (int num, std::string &streamPortSuffix)
 
bool isClient () const
 
StatusCode putEvent ATLAS_NOT_THREAD_SAFE (long eventNumber, const void *source, std::size_t nbytes, unsigned int status) const
 
StatusCode getLockedEvent (void **target, unsigned int &status) const
 
StatusCode lockEvent (long eventNumber) const
 
StatusCode putObject (const void *source, std::size_t nbytes, int num=0)
 
StatusCode getObject (void **target, std::size_t &nbytes, int num=0)
 
StatusCode clearObject (const char **tokenString, int &num)
 
StatusCode lockObject (const char *tokenString, int num=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
 
virtual StatusCode putEvent ATLAS_NOT_THREAD_SAFE (long eventNumber, const void *source, size_t nbytes, unsigned int status) const =0
 
virtual StatusCode putObject (const void *source, size_t nbytes, int num=0)=0
 
virtual StatusCode getObject (void **target, size_t &nbytes, int num=0)=0
 

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

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

H5::H5File * m_file
 
H5::Group * m_group
 
std::string m_token
 
char * m_read_data
 
std::size_t m_read_size
 
std::size_t m_read_position
 
long long unsigned int m_event_iter
 
bool m_isClient
 
ServiceHandle< IIncidentSvc > m_incidentSvc
 
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

This class provides the IPCTool for HDF Stream objects.

Definition at line 53 of file AthenaHDFStreamTool.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

◆ AthenaHDFStreamTool()

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

Standard Service Constructor.

Definition at line 34 of file AthenaHDFStreamTool.cxx.

36  : 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 }

◆ ~AthenaHDFStreamTool()

AthenaHDFStreamTool::~AthenaHDFStreamTool ( )
virtual

Destructor.

Definition at line 50 of file AthenaHDFStreamTool.cxx.

50  {
51 }

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

virtual StatusCode putEvent IAthenaIPCTool::ATLAS_NOT_THREAD_SAFE ( long  eventNumber,
const void *  source,
size_t  nbytes,
unsigned int  status 
) const
pure virtualinherited

Implemented in AthenaSharedMemoryTool.

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

StatusCode putEvent AthenaHDFStreamTool::ATLAS_NOT_THREAD_SAFE ( long  eventNumber,
const void *  source,
std::size_t  nbytes,
unsigned int  status 
) const

◆ clearObject()

StatusCode AthenaHDFStreamTool::clearObject ( const char **  tokenString,
int &  num 
)
virtual

Implements IAthenaIPCTool.

Definition at line 417 of file AthenaHDFStreamTool.cxx.

417  {
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 }

◆ 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

◆ finalize()

StatusCode AthenaHDFStreamTool::finalize ( )

Definition at line 68 of file AthenaHDFStreamTool.cxx.

68  {
69  ATH_MSG_INFO("in finalize()");
70  return(::AthAlgTool::finalize());
71 }

◆ getLockedEvent()

StatusCode AthenaHDFStreamTool::getLockedEvent ( void **  target,
unsigned int &  status 
) const
virtual

Implements IAthenaIPCTool.

Definition at line 111 of file AthenaHDFStreamTool.cxx.

111  {
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 }

◆ getObject() [1/2]

virtual StatusCode IAthenaIPCTool::getObject ( void **  target,
size_t &  nbytes,
int  num = 0 
)
pure virtualinherited

Implemented in AthenaSharedMemoryTool.

◆ getObject() [2/2]

StatusCode AthenaHDFStreamTool::getObject ( void **  target,
std::size_t &  nbytes,
int  num = 0 
)

Definition at line 317 of file AthenaHDFStreamTool.cxx.

317  {
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 }

◆ initialize()

StatusCode AthenaHDFStreamTool::initialize ( )

Gaudi Service Interface method implementations:

Definition at line 54 of file AthenaHDFStreamTool.cxx.

54  {
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 }

◆ 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& IAthenaIPCTool::interfaceID ( )
inlinestaticinherited

Definition at line 17 of file IAthenaIPCTool.h.

17 { return IID_IAthenaIPCTool; }

◆ isClient()

bool AthenaHDFStreamTool::isClient ( ) const
virtual

Implements IAthenaIPCTool.

Definition at line 100 of file AthenaHDFStreamTool.cxx.

100  {
101  return(m_isClient);
102 }

◆ isServer()

bool AthenaHDFStreamTool::isServer ( ) const
virtual

Implements IAthenaIPCTool.

Definition at line 80 of file AthenaHDFStreamTool.cxx.

80  {
81  return(false);
82 }

◆ lockEvent()

StatusCode AthenaHDFStreamTool::lockEvent ( long  eventNumber) const
virtual

Implements IAthenaIPCTool.

Definition at line 144 of file AthenaHDFStreamTool.cxx.

144  {
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 }

◆ lockObject()

StatusCode AthenaHDFStreamTool::lockObject ( const char *  tokenString,
int  num = 0 
)
virtual

Implements IAthenaIPCTool.

Definition at line 456 of file AthenaHDFStreamTool.cxx.

456  {
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 }

◆ makeClient()

StatusCode AthenaHDFStreamTool::makeClient ( int  num,
std::string &  streamPortSuffix 
)
virtual

Implements IAthenaIPCTool.

Definition at line 85 of file AthenaHDFStreamTool.cxx.

85  {
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 }

◆ makeServer()

StatusCode AthenaHDFStreamTool::makeServer ( int  num,
const std::string &  streamPortSuffix 
)
virtual

Implements IAthenaIPCTool.

Definition at line 74 of file AthenaHDFStreamTool.cxx.

74  {
75  ATH_MSG_ERROR("AthenaHDFStreamTool::makeServer");
76  return(StatusCode::FAILURE);
77 }

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

◆ putObject() [1/2]

virtual StatusCode IAthenaIPCTool::putObject ( const void *  source,
size_t  nbytes,
int  num = 0 
)
pure virtualinherited

Implemented in AthenaSharedMemoryTool.

◆ putObject() [2/2]

StatusCode AthenaHDFStreamTool::putObject ( const void *  source,
std::size_t  nbytes,
int  num = 0 
)

Definition at line 155 of file AthenaHDFStreamTool.cxx.

155  {
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 }

◆ 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

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

long long unsigned int AthenaHDFStreamTool::m_event_iter
mutableprivate

Definition at line 85 of file AthenaHDFStreamTool.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_file

H5::H5File* AthenaHDFStreamTool::m_file
private

Definition at line 79 of file AthenaHDFStreamTool.h.

◆ m_group

H5::Group* AthenaHDFStreamTool::m_group
private

Definition at line 80 of file AthenaHDFStreamTool.h.

◆ m_incidentSvc

ServiceHandle<IIncidentSvc> AthenaHDFStreamTool::m_incidentSvc
private

Definition at line 87 of file AthenaHDFStreamTool.h.

◆ m_isClient

bool AthenaHDFStreamTool::m_isClient
private

Definition at line 86 of file AthenaHDFStreamTool.h.

◆ m_read_data

char* AthenaHDFStreamTool::m_read_data
mutableprivate

Definition at line 82 of file AthenaHDFStreamTool.h.

◆ m_read_position

std::size_t AthenaHDFStreamTool::m_read_position
mutableprivate

Definition at line 84 of file AthenaHDFStreamTool.h.

◆ m_read_size

std::size_t AthenaHDFStreamTool::m_read_size
mutableprivate

Definition at line 83 of file AthenaHDFStreamTool.h.

◆ m_token

std::string AthenaHDFStreamTool::m_token
mutableprivate

Definition at line 81 of file AthenaHDFStreamTool.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.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
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
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
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
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
initialize
void initialize()
Definition: run_EoverP.cxx:894
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
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::m_read_size
std::size_t m_read_size
Definition: AthenaHDFStreamTool.h:83
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
JetTagCalibConfig.className
string className
Definition: JetTagCalibConfig.py:31
AthenaHDFStreamTool::m_token
std::string m_token
Definition: AthenaHDFStreamTool.h:81
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
beamspotman.n
n
Definition: beamspotman.py:731
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaHDFStreamTool::m_read_data
char * m_read_data
Definition: AthenaHDFStreamTool.h:82
dataset
Definition: dataset.h:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
AthenaHDFStreamTool::m_event_iter
long long unsigned int m_event_iter
Definition: AthenaHDFStreamTool.h:85
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
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
a
TList * a
Definition: liststreamerinfos.cxx:10
h
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
makeTransCanvas.text
text
Definition: makeTransCanvas.py:11
AthenaHDFStreamTool::m_file
H5::H5File * m_file
Definition: AthenaHDFStreamTool.h:79
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
COOLRates.target
target
Definition: COOLRates.py:1106
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
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
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 Fri Jun 28 2024 21:39:06 for ATLAS Offline Software by   doxygen 1.8.18