VDColdboxDataInterface_tool.cc File Reference

#include "VDColdboxDataInterface.h"
#include <hdf5.h>
#include <iostream>
#include <list>
#include <set>
#include <sstream>
#include <cstring>
#include <string>
#include "TMath.h"
#include "TString.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "dunecore/DuneObj/DUNEHDF5FileInfo.h"
#include "dunecore/HDF5Utils/HDF5Utils.h"
#include "detdataformats/wib/WIBFrame.hpp"
#include "duneprototypes/Coldbox/vd/ChannelMap/VDColdboxChannelMapService.h"

Go to the source code of this file.

Functions
void	readFragmentsForEvent (art::Event &evt)

Function Documentation

void readFragmentsForEvent

(

art::Event &

evt

)

Definition at line 25 of file VDColdboxDataInterface_tool.cc.

{

  using namespace dune::HDF5Utils;
  auto infoHandle = evt.getHandle <raw::DUNEHDF5FileInfo> ("daq");
  std::cout << "Got infos? " << infoHandle << std::endl;
  
  const std::string & toplevel_groupname = infoHandle->GetEventGroupName();
  const std::string & file_name = infoHandle->GetFileName();
  hid_t file_id = infoHandle->GetHDF5FileHandle();

  std::cout << "Top-Level Group Name: " << toplevel_groupname << std::endl;
  std::cout << "HDF5 FileName: " << file_name << std::endl;
  
  // now look inside those "Top-Level Group Name" for "Detector type".
  hid_t requestedGroup = getGroupFromPath(file_id, toplevel_groupname);

  std::deque<std::string> detectorTypeNames = getMidLevelGroupNames(requestedGroup);
  
  for (auto& detectorTypeName : detectorTypeNames)
    {
      if (detectorTypeName == "TPC" && detectorTypeName != "TriggerRecordHeader")
        {
          std::cout << "  Detector type: " << detectorTypeName << std::endl;
          std::string geoPath = toplevel_groupname + "/" + detectorTypeName;
          hid_t geoGroup = getGroupFromPath(file_id,geoPath);
          std::deque<std::string> apaNames = getMidLevelGroupNames(geoGroup);
          
          // loop over APAs
          for (auto& apaName : apaNames)
            {
              std::string apaGroupPath = geoPath + "/" + apaName;
              std::cout << "     Geo path: " << apaGroupPath << std::endl;
              hid_t linkGroup = getGroupFromPath(file_id,apaGroupPath);
              std::deque<std::string> linkNames = getMidLevelGroupNames(linkGroup);
              
              // loop over Links
              for (auto& linkName : linkNames)
                {
                  std::string dataSetPath = apaGroupPath + "/" + linkName;
                  std::cout << "      Data Set Path: " << dataSetPath << std::endl;
                  hid_t datasetid = H5Dopen(linkGroup,linkName.data(),H5P_DEFAULT);
                  hsize_t ds_size = H5Dget_storage_size(datasetid);
                  std::cout << "      Data Set Size (bytes): " << ds_size << std::endl;
                  
                  if (ds_size < 80) continue;
                  
                  size_t narray = ds_size / sizeof(char);
                  size_t rdr = ds_size % sizeof(char);
                  if (rdr > 0 || narray == 0) narray++;
                  char *ds_data = new char[narray];
                  herr_t ecode = H5Dread(datasetid, H5T_STD_I8LE, H5S_ALL, H5S_ALL, H5P_DEFAULT, ds_data);
                  int firstbyte = ds_data[0];
                  firstbyte &= 0xFF;
                  int lastbyte = ds_data[narray-1];
                  lastbyte &= 0xFF;
                  
                  std::cout << std::hex << "      Retrieved data: ecode: " << ecode << "  first byte: " << firstbyte
                            << " last byte: " << lastbyte  << std::dec << std::endl;
                  

                  int magic_word = 0;
                  memcpy(&magic_word,&ds_data[0],4);
                  std::cout << "   Magic word: 0x" << std::hex << magic_word << std::dec << std::endl;
                  
                  int version = 0;
                  memcpy(&version, &ds_data[4],4);
                  std::cout << "   Version: " << std::dec << version << std::dec << std::endl;
                  
                  uint64_t fragsize=0;
                  memcpy(&fragsize, &ds_data[8],8);
                  std::cout << "   Frag Size: " << std::dec << fragsize << std::dec << std::endl;
                  
                  uint64_t trignum=0;
                  memcpy(&trignum, &ds_data[16],8);
                  std::cout << "   Trig Num: " << std::dec << trignum << std::dec << std::endl;
                  
                  uint64_t trig_timestamp=0;
                  memcpy(&trig_timestamp, &ds_data[24],8);
                  std::cout << "   Trig Timestamp: " << std::dec << trig_timestamp << std::dec << std::endl;
                  
                  uint64_t windowbeg=0;
                  memcpy(&windowbeg, &ds_data[32],8);
                  std::cout << "   Window Begin:   " << std::dec << windowbeg << std::dec << std::endl;
                  
                  uint64_t windowend=0;
                  memcpy(&windowend, &ds_data[40],8);
                  std::cout << "   Window End:     " << std::dec << windowend << std::dec << std::endl;
                  
                  int runno=0;
                  memcpy(&runno, &ds_data[48], 4);
                  std::cout << "   Run Number: " << std::dec << runno << std::endl;
                  
                  int errbits=0;
                  memcpy(&errbits, &ds_data[52], 4);
                  std::cout << "   Error bits: " << std::dec << errbits << std::endl;
                  
                  int fragtype=0;
                  memcpy(&fragtype, &ds_data[56], 4);
                  std::cout << "   Fragment type: " << std::dec << fragtype << std::endl;
                  
                  int fragpadding=0;
                  memcpy(&fragtype, &ds_data[60], 4);
                  std::cout << "   Fragment padding: " << std::dec << fragpadding << std::endl;
                  
                  int geoidversion=0;
                  memcpy(&geoidversion, &ds_data[64], 4);
                  std::cout << "   GeoID version: " << std::dec << geoidversion << std::endl;
                  
                  unsigned short geoidtype;
                  memcpy(&geoidtype, &ds_data[70], 1);
                  std::cout << "   GeoID type: " << geoidtype << std::endl;
                  
                  unsigned short geoidregion=0;
                  memcpy(&geoidregion, &ds_data[71], 1);
                  std::cout << "   GeoID region: " << std::dec << geoidregion << std::endl;
                  
                  int geoidelement=0;
                  memcpy(&geoidelement, &ds_data[72], 4);
                  std::cout << "   GeoID element: " << std::dec << geoidelement << std::endl;
                  
                  int geoidpadding=0;
                  memcpy(&geoidpadding, &ds_data[76], 4);
                  std::cout << "   GeoID padding: " << std::dec << geoidpadding << std::endl;
                  
                  delete[] ds_data;  // free up memory

                } 
            }
        }
    }

}