18#include "TObjString.h"
36 fxType =
new H5::CompType(datasize);
37 go4hdfdbg(
"TGo4HDF5DataHandle DDD created %s for size %ld \n",
fxTypeName.Data(), datasize);
57 fxType->insertMember(name, offset, new_member);
102 go4hdfdbg(
"TGo4HDF5DataHandle SetObjectPointer for %s with memptr 0x%lx and parentoffset 0x%lx has fxData:0x%lx\n",
116 go4hdfdbg(
"TTTTTTTT TGo4HDF5DataHandle %s - SetTopEvent sets pointer to %ld \n",
fxTypeName.Data(),
168 hsize_t offset[1]= {sequencenum};
169 hsize_t onerow[1] ={1};
170 fxFileSpace.selectHyperslab( H5S_SELECT_SET, onerow, offset );
174 go4hdfdbg(
"TGo4HDF5DataHandle::Read of %s has selected hyperslab for onerow:[%ld] offset:[%ld]\n",
175 fxTypeName.Data(),(
unsigned long) onerow[0], (
unsigned long) offset[0]);
185 entry->
Read(sequencenum, file);
195 go4hdfdbg(
"TGo4HDF5DataHandle::Write %s base function will extend dataset for %lld \n",
fxTypeName.Data(), sequencenum);
196 hsize_t offset[1] = { sequencenum };
197 hsize_t nextsize[1] = { sequencenum + 1 };
202 hsize_t onerow[1] = { 1 };
203 fxFileSpace.selectHyperslab(H5S_SELECT_SET, onerow, offset);
215 entry->
Write(sequencenum, file);
227 go4hdfdbg(
"TGo4HDF5BasicDataHandle ctor\n");
244 go4hdfdbg(
"TGo4HDF5DataHandle: AllocReadBuffer has created read buffer 0x%lx for size %ld \n",
256 hsize_t dims[1] = { 1};
257 hsize_t maxdims[1] = {H5S_UNLIMITED};
258 fxDataSpace=
new H5::DataSpace(rank, dims, maxdims);
261 hsize_t onerow[1] ={1};
262 hsize_t offset[1]= {0};
263 fxDataSpace->selectHyperslab( H5S_SELECT_SET, onerow, offset );
277 H5T_class_t type_class =
fxDataSet.getTypeClass();
279 if( type_class == H5T_COMPOUND)
283 go4hdfdbg(
"TGo4HDF5DataHandle::BuildReadDataSet finds in file compound type of size %ld \n", intype.getSize());
285 else if( type_class == H5T_VLEN)
287 H5::VarLenType vtype =
fxDataSet.getVarLenType();
288 H5::DataType entrytype = vtype.getSuper();
292 H5T_class_t entry_class = entrytype.getClass();
293 go4hdfdbg(
"TGo4HDF5DataHandle::BuildReadDataSet finds in file vlen type of size %ld, with entry class %d, size %ld \n",
294 vtype.getSize(), entry_class, entrytype.getSize());
295 if( entry_class == H5T_COMPOUND)
298 H5::DataType* ptype=&entrytype;
299 H5::CompType* entrycomp =
static_cast<H5::CompType*
>(ptype);
302 go4hdfdbg(
"TGo4HDF5DataHandle::BuildReadDataSet uses compound entry of vlen dtype %d \n", entry_class );
306 go4hdfdatahandlethrow(
"TGo4HDF5DataHandle: BuildReadDataSet - could not assign component entry of varlen data type !\n");
312 go4hdfdatahandlethrow(
"TGo4HDF5DataHandle: BuildReadDataSet - varlen data type without compound, but contains class %d!\n", entry_class);
317 go4hdfdatahandlethrow(
"TGo4HDF5DataHandle: BuildReadDataSet - file contains no compound or varlen data type, but type %d!\n",type_class)
323 std::vector<hsize_t> dims_out(frank, 0);
324 fxFileSpace.getSimpleExtentDims(dims_out.data(),
nullptr);
325 go4hdfdbg(
"TGo4HDF5DataHandle::BuildReadDataSet file dataspace has rank %d, dimensions:%d, #1. dimension=%ld \n",
326 frank,
fxFileSpace.getSimpleExtentDims(dims_out.data(),
nullptr), (
long) (dims_out[0]));
331 int nfilemembers= intype.getNmembers ();
332 int neventmembers=
fxType->getNmembers ();
335 go4hdfdbg(
"Type comparison: number of compound members: file %d, event %d\n",nfilemembers, neventmembers);
338 for (
int i = 0; i < nfilemembers; ++i)
340 H5::DataType mem_type=intype.getMemberDataType(i);
341 go4hdfdbg(
"\t %d: name:%s class:%s", i, intype.getMemberName(i).c_str(), mem_type.fromClass().c_str());
342 H5T_class_t mem_class = intype.getMemberClass(i);
343 if (mem_class == H5T_ARRAY)
345 H5::ArrayType artyp = intype.getMemberArrayType(i);
346 int ardim = artyp.getArrayNDims();
348 artyp.getArrayDims(dims);
349 go4hdfdbg(
" array dimensions:%d [", ardim);
350 for (
int j = 0; j < ardim; ++j)
358 go4hdfdbg(
"Dump Type from event structure:\n");
359 for (
int i = 0; i < neventmembers; ++i)
361 H5::DataType mem_type=
fxType->getMemberDataType(i);
362 go4hdfdbg(
"\t %d: name:%s class:%s", i, intype.getMemberName(i).c_str(), mem_type.fromClass().c_str());
363 H5T_class_t mem_class =
fxType->getMemberClass(i);
364 if (mem_class == H5T_ARRAY)
366 H5::ArrayType artyp =
fxType->getMemberArrayType(i);
367 int ardim = artyp.getArrayNDims();
369 artyp.getArrayDims(dims);
370 go4hdfdbg(
"array dimensions:%d [", ardim);
371 for (
int j = 0; j < ardim; ++j)
373 go4hdfdbg(
"%lu", (
unsigned long) dims[j]);
384 TString msg= TString::Format(
"BuildReadDataSet type mismatch between event structure(%s) and input from file (%s)\n",
385 fxType->fromClass().c_str(), intype.fromClass().c_str());
406 go4hdfdbg(
"TGo4HDF5BasicDataHandle: BuildWriteDataset for event set %s\n",
fxTypeName.Data());
408 hsize_t dims[1] = {1};
409 hsize_t maxdims[1] = {H5S_UNLIMITED};
410 fxDataSpace =
new H5::DataSpace(rank, dims, maxdims);
412 H5::DSetCreatPropList cparms;
413 hsize_t chunk_dims[1] = {1};
414 cparms.setChunk(rank, chunk_dims);
441 memcpy(target, source, copylen);
444 printf(
"Copy %ld bytes from %lx to %lx, fiReadOffset=%ld, fiDataSize=%ld \n", copylen, (
long)source, (
long)target,
468 go4hdfdbg(
"TGo4HDF5CompositeDataHandle ctor use go4 composite event component\n");
509 go4hdfdbg(
"TGo4HDF5VectorDataHandle ctor \n");
519 go4hdfdbg(
"TGo4HDF5VectorDataHandle ctor, typename is %s\n",
551 char **p_collection = (
char **)
fxData;
552 char **p_begin_ptr = p_collection;
553 char **p_end_ptr = p_collection + 1;
556 go4hdfdbg(
"TGo4HDF5VectorDataHandle SetObjectPointer has fxData=0x%lx elementsize=%ld\n",
568 static unsigned debugcount = 0;
569 char **p_cap_ptr = p_collection + 2;
571 if (debugcount < 10000)
574 "TGo4HDF5VectorDataHandle SetObjectPointer for count %d has collection size: %ld capacity: %ld pointer to buffer 0x%lx, ACTIVE=%d\n",
597 go4hdfdbg(
"TGo4HDF5VectorDataHandle: BuildWriteDataset for collection set %s \n",
fxTypeName.Data());
600 hsize_t dims[1] = { 1};
601 hsize_t maxdims[1] = {H5S_UNLIMITED};
602 fxDataSpace=
new H5::DataSpace(rank, dims, maxdims);
603 H5::DSetCreatPropList cparms;
604 hsize_t chunk_dims[1] ={1};
605 cparms.setChunk( rank, chunk_dims );
638 go4hdfdbg(
"TGo4HDF5VectorDataHandle::Read LLLL length after reading is %ld, buffer is 0x%lx \n",
694 TString vectorhandle = TString::Format(
"myevent->%s",
fxMemberHandle.Data());
695 TString copycom = TString::Format(
"%s * myevent= (%s *) %ld; %s.insert(%s.end(), (%s *) %ld, (%s *) %ld)",
699 go4hdfdbg(
"TGo4HDF5VectorDataHandle::Read will use command: %s \n", copycom.Data());
700 gROOT->ProcessLineFast(copycom.Data());
705 char **p_collection = (
char **)
fxData;
706 char **p_begin_ptr = p_collection;
707 char **p_end_ptr = p_collection + 1;
708 char **p_cap_ptr = p_collection + 2;
714 "TGo4HDF5VectorDataHandle::Read after INSERT has collection size: %ld capacity: %ld pointer to buffer 0x%lx, end: 0x%lx cap: 0x%lx\n",
715 len, cap, (
unsigned long) *p_begin_ptr, (
unsigned long) *p_end_ptr, (
unsigned long) *p_cap_ptr);
741 go4hdfdbg(
"TGo4HDF5VectorDataHandle::Write DO NOT WRITE inactive %s collection\n",
fxTypeName.Data());
754 go4hdfdbg(
"TGo4HDF5SubVectorDataHandle ctor \n");
771 size_t innersize=datatype.Size();
778 for(
unsigned int ix = 0; ix <
fxVarHandle.fxArray.len; ++ix)
783 TString fullname= TString::Format(
"%s[%d]",
GetTypeName(), ix );
784 TString membername = TString::Format(
"%s[%d]",
fxMemberHandle.Data(),ix);
787 "TGo4HDF5SubVectorDataHandle SetObjectPointer updating element %s, inner class is %s\n",
794 TString memberclass = TString::Format(
"vector<%s>",
fxInnerClassName.Data());
795 TString searchname = TString::Format(
"%s[%s]",fullname.Data(), memberclass.Data());
800 "TGo4HDF5SubVectorDataHandle SetObjectPointer finds element %s, already in subcomponents\n",
807 "TGo4HDF5SubVectorDataHandle SetObjectPointer creates new subcomponent %s \n",
810 subhandle =
AddSubMember(fullname.Data(), innersize, memberclass.Data());
819 void *super =
Data();
828 char *subvector = cursor;
830 size_t delta = (
char *) cursor - (
char *) super;
831 go4hdfdbg(
"TGo4HDF5SubVectorDataHandle SetObjectPointer sets parent offset %ld (subvector:0x%lx, super:0x%lx) cursor was 0x%lx\n",
832 delta, (
unsigned long) subvector, (
unsigned long) super, (
unsigned long) cursor);
857 go4hdfdbg(
"TGo4HDF5SubVectorDataHandle: BuildWriteDataset NOP for collection set %s \n",
fxTypeName.Data());
889 if (strstr(type,
"vector<vector"))
892 TString theName(name);
893 TString theCollection(type);
895 theName = theName.Append(theCollection);
899 TObjArray *tokens = theCollection.Tokenize(
"<");
902 TObjString* part =
dynamic_cast<TObjString*
>(tokens->At(2));
905 TString rtype = part->GetString();
906 TObjArray *stokens = rtype.Tokenize(
">");
909 TObjString* spart =
dynamic_cast<TObjString*
>(stokens->At(0));
910 TString valuetype = spart->GetString();
912 go4hdfdbg(
"TGo4HDF5DataHandleFactory::CreateDataHandle for %s sets inner class name to %s\n", type,
918 go4hdfdbg(
"TGo4HDF5DataHandleFactory::CreateDataHandle for %s could not evaluate valuetype from %ss\n", type,
919 theCollection.Data());
924 go4hdfdbg(
"TGo4HDF5DataHandleFactory::CreateDataHandle for %s could not evaluate valuetype from %ss\n", type,
925 theCollection.Data());
931 else if (strstr(type,
"vector"))
934 TString theName(name);
935 TString theCollection(type);
937 theName = theName.Append(theCollection);
943 else if (strstr(type,
"Go4Comp"))
#define go4hdfdatahandlethrow(args ...)
#define go4hdfdbg(args...)
The abstract base class for the data elements of which the unpacked events (or detector structure dat...
void SetErrMess(const char *txt)
To be used for modification of the message by the event source implementation.
static void FillTypeInfo(TGo4HDF5DataHandle *handle, TClass *rootclass, const char *basename=nullptr)
evaluate h5 type information from root class streamer
void Write(hsize_t sequencenum, H5::H5File *file) override
Write event of sequence number from file.
void AllocReadBuffer(size_t size)
(Re-)allocate read buffer depending on the object size read from file
void BuildWriteDataset(H5::H5File *file) override
create datasets for writing memory structure of type into file.
Char_t * fxReadBuffer
secondary read bounce buffer for hdf5
void Read(hsize_t sequencenum, H5::H5File *file) override
Read event of sequence number from file.
TGo4HDF5BasicDataHandle(const char *name, size_t datasize)
create new data handle
void BuildReadDataset(H5::H5File *file, TGo4HDF5Source *parent) override
create datasets and buffers for reading this structure from hdf5 file.
virtual ~TGo4HDF5BasicDataHandle()
Handle object to access composite event type datasets in hdf5 formatted file with go4 event data.
void Read(hsize_t sequencenum, H5::H5File *file) override
Read event of sequence number from file.
void Write(hsize_t sequencenum, H5::H5File *file) override
Write event of sequence number from file.
void BuildReadDataset(H5::H5File *file, TGo4HDF5Source *parent) override
create datasets and buffers for reading this structure from hdf5 file.
virtual ~TGo4HDF5CompositeDataHandle()
TGo4HDF5CompositeDataHandle(const char *name, size_t datasize)
create new data handle
void BuildWriteDataset(H5::H5File *file) override
create datasets for writing memory structure of type into file.
TGo4HDF5DataHandle * CreateDataHandle(const char *name, size_t datasize, const char *type)
create implementation of data handle by type
The base class to access a datatype with substructures in hdf5.
virtual void Write(hsize_t sequencenum, H5::H5File *file)
Write event of sequence number from file.
virtual void BuildWriteDataset(H5::H5File *file)
create datasets for writing memory structure of type into file.
void SetTopEventClass(const char *classname)
pass the top level event element class down the member hierarchy.
Bool_t fbDataSetExists
check on the fly if this handle has already created a dataset
virtual void Read(hsize_t sequencenum, H5::H5File *file)
Read event of sequence number from file.
virtual void SetObjectPointer(void *memptr)
define location of corresponding object in memory.
void SetTopEvent(TGo4EventElement *eve)
pass the top level event element down the member hierarchy.
TGo4HDF5DataHandle(const char *name, size_t datasize)
create new data handle
virtual ~TGo4HDF5DataHandle()
virtual void BuildReadDataset(H5::H5File *file, TGo4HDF5Source *parent)
create datasets and buffers for reading this structure from hdf5 file.
TGo4HDF5Source * fxParentSource
backpointer to parent source for exceptions
std::vector< TGo4HDF5DataHandle * > fxSubcomponents
collect sub-components of the referenced data object
TGo4HDF5DataHandle * FindSubMember(const char *name)
lookup if subcomponent of name already is in list.
void SetActive(Bool_t on)
const char * GetTypeName() const
TString fxEventClass
the top level event element classname to access the current data member from outside
void SetAllSubMembersActive(Bool_t on)
void SetMemberName(const char *name)
identifier for the member to access from outside using the top event handle
ULong_t fiEntries
number of event entries found in file dataspace
H5::DataSpace * fxDataSpace
dataspace in memory
Bool_t fbDataSetActive
we may disable this dataset temporarily from writing or reading useful for dynamic vector of vector c...
static TGo4HDF5DataHandleFactory fxFactory
TGo4HDF5DataHandle * AddSubMember(const char *name, size_t datasize, const char *collectiontype=nullptr)
create new subhandle for complex member component on heap.
TString fxMemberHandle
predefined interpreter access command e.g.
H5::DataSet fxDataSet
dataset containing the structure
H5::DataSpace fxFileSpace
dataspace in file
void InsertTypeMember(const H5std_string &name, size_t offset, const H5::DataType &new_member)
wrapper function to define contained structure member.
void SetMemberClass(const char *clname)
type of the member to access from outside
size_t fiReadOffset
begin of real eventdata payload after event object pointer
void SetParentOffset(size_t off)
remember location of this object relative to upper level object.
size_t fiDataSize
size of data structure in bytes, for redefining output dataset
size_t fiParentOffset
offset of this data structure relative to top level event object
TString fxMemberClass
classname of the entry for interpreter to operate e.g.
TString fxTypeName
identifier of the dataset
TGo4EventElement * fxEvent
the top level event element to access the current data member from outside
H5::CompType * fxType
component type representing the data structure
void * fxData
pointer to begin of data in memory
Event source which reads entries from a dataset in a hdf5 formatted file names of elements in hdf5 da...
Handle object to access datasets in hdf5 formatted file with go4 event data trial implementation for ...
void Read(hsize_t sequencenum, H5::H5File *file) override
Read event of sequence number from file.
TString fxInnerClassName
class that is contained in innermost vector
void Write(hsize_t sequencenum, H5::H5File *file) override
Write event of sequence number from file.
TGo4HDF5SubVectorDataHandle(const char *name, size_t datasize)
create new data handle
virtual ~TGo4HDF5SubVectorDataHandle()
void BuildReadDataset(H5::H5File *file, TGo4HDF5Source *parent) override
create datasets and buffers for reading this structure from hdf5 file.
void BuildWriteDataset(H5::H5File *file) override
create datasets for writing memory structure of type into file.
void SetObjectPointer(void *memptr) override
define location of corresponding object in memory.
void SetInnerClassName(const char *nm)
Handle object to access datasets in hdf5 formatted file with go4 event data implementation for std::v...
H5::CompType * fxCollection
collection type with fxType as entries
virtual ~TGo4HDF5VectorDataHandle()
size_t fiElementSize
size of the (collection element) structure
void BuildWriteDataset(H5::H5File *file) override
create datasets for writing memory structure of type into file.
void SetElementSize(size_t len)
remember size of a single element (structure) in this collection, if it is one.
TGo4HDF5VarContainer fxVarHandle
handle for variable arrays
TGo4HDF5VectorDataHandle(const char *name, size_t datasize)
create new data handle
void Write(hsize_t sequencenum, H5::H5File *ile) override
Write event of sequence number from file.
void Read(hsize_t sequencenum, H5::H5File *file) override
Read event of sequence number from file.
void SetObjectPointer(void *memptr) override
define location of corresponding object in memory.
void BuildReadDataset(H5::H5File *file, TGo4HDF5Source *parent) override
create datasets and buffers for reading this structure from hdf5 file.
static void Error(const char *text,...) GO4_PRINTF_ARGS
User shortcut for message with prio 3.
hdf5 needs structure containing the hvl_t to deal with it correctly