access packet descripton & event sync, fix file reading

Author: wiechula

Detectors/TPC/reconstruction/include/TPCReconstruction/RawReaderCRU.h

@@ -498,6 +498,8 @@ class RawReaderCRU
 {
  public:
   class PacketDescriptor;
+  using PacketDescriptorMap = std::vector<PacketDescriptor>;
+  using PacketDescriptorMapArray = std::array<PacketDescriptorMap, MaxNumberOfLinks>;
 
   /// constructor
   /// \param
@@ -645,6 +647,9 @@ class RawReaderCRU
   /// output file prefix
   const std::string& getOutputFilePrefix() const { return mOutputFilePrefix; }
 
+  /// get packet descriptor map array
+  const PacketDescriptorMapArray& getPacketDescriptorMaps() const { return mPacketDescriptorMaps; }
+
   //===========================================================================
   //===| Nested helper classes |===============================================
   //
@@ -723,26 +728,25 @@ class RawReaderCRU
   //
 
  private:
-  using PacketDescriptorMap = std::vector<PacketDescriptor>;
-  uint32_t mDebugLevel;                                                    ///< debug level
-  uint32_t mVerbosity;                                                     ///< verbosity
-  uint32_t mNumTimeBins;                                                   ///< number of time bins to process
-  uint32_t mLink;                                                          ///< present link being processed
-  uint32_t mStream;                                                        ///< present stream being processed
-  uint32_t mEventNumber = 0;                                               ///< current event number to process
-  uint32_t mReaderNumber = 0;                                              ///< raw reader number in manager
-  CRU mCRU;                                                                ///< CRU
-  size_t mFileSize;                                                        ///< size of the input file
-  bool mDumpTextFiles = false;                                             ///< dump debugging text files
-  bool mFillADCdataMap = true;                                             ///< fill the ADC data map
-  bool mForceCRU = false;                                                  ///< force CRU: overwrite value from RDH
-  bool mFileIsScanned = false;                                             ///< if file was already scanned
-  std::array<uint32_t, MaxNumberOfLinks> mPacketsPerLink;                  ///< array to keep track of the number of packets per link
-  std::bitset<MaxNumberOfLinks> mLinkPresent;                              ///< info if link is present in data; information retrieved from scanning the RDH headers
-  std::array<PacketDescriptorMap, MaxNumberOfLinks> mPacketDescriptorMaps; ///< array to hold vectors thhe packet descriptors
-  std::string mInputFileName;                                              ///< input file name
-  std::string mOutputFilePrefix;                                           ///< input file name
-  std::array<SyncArray, MaxNumberOfLinks> mSyncPositions{};                ///< sync positions for each link
+  uint32_t mDebugLevel;                                     ///< debug level
+  uint32_t mVerbosity;                                      ///< verbosity
+  uint32_t mNumTimeBins;                                    ///< number of time bins to process
+  uint32_t mLink;                                           ///< present link being processed
+  uint32_t mStream;                                         ///< present stream being processed
+  uint32_t mEventNumber = 0;                                ///< current event number to process
+  uint32_t mReaderNumber = 0;                               ///< raw reader number in manager
+  CRU mCRU;                                                 ///< CRU
+  size_t mFileSize;                                         ///< size of the input file
+  bool mDumpTextFiles = false;                              ///< dump debugging text files
+  bool mFillADCdataMap = true;                              ///< fill the ADC data map
+  bool mForceCRU = false;                                   ///< force CRU: overwrite value from RDH
+  bool mFileIsScanned = false;                              ///< if file was already scanned
+  std::array<uint32_t, MaxNumberOfLinks> mPacketsPerLink;   ///< array to keep track of the number of packets per link
+  std::bitset<MaxNumberOfLinks> mLinkPresent;               ///< info if link is present in data; information retrieved from scanning the RDH headers
+  PacketDescriptorMapArray mPacketDescriptorMaps;           ///< array to hold vectors thhe packet descriptors
+  std::string mInputFileName;                               ///< input file name
+  std::string mOutputFilePrefix;                            ///< input file name
+  std::array<SyncArray, MaxNumberOfLinks> mSyncPositions{}; ///< sync positions for each link
   // not so nice but simplest way to store the ADC data
   std::map<PadPos, std::vector<uint16_t>> mADCdata; ///< decoded ADC data
   RawReaderCRUManager* mManager{nullptr};           ///< event synchronization information
@@ -952,6 +956,9 @@ class RawReaderCRUManager
     }
   }
 
+  /// get the event sync
+  const RawReaderCRUEventSync& getEventSync() const { return mEventSync; }
+
   /// get number of all events
   size_t getNumberOfEvents() const { return mEventSync.getNumberOfEvents(); }
 

Detectors/TPC/reconstruction/src/RawReaderCRU.cxx

@@ -231,9 +231,9 @@ int RawReaderCRU::scanFile()
   RDH rdh;
   uint32_t currentPacket = 0;
   uint32_t lastHeartbeatOrbit = 0;
+  size_t currentPos = 0;
 
-  while ((currentPacket < numPackets) && !file.eof()) {
-    const size_t currentPos = file.tellg();
+  while ((currentPos < mFileSize) && !file.eof()) {
 
     // ===| read in the RawDataHeader at the current position |=================
     file >> rdh;
@@ -349,6 +349,7 @@ int RawReaderCRU::scanFile()
     // std::cout << "Position after read : " << std::dec << file.tellg() << std::endl;
     file.seekg(offset, file.cur);
     ++currentPacket;
+    currentPos = file.tellg();
   }
 
   // close the File
@@ -905,7 +906,7 @@ void RawReaderCRU::writeGBTDataPerLink(std::string_view outputDirectory, int max
 
   // loop over events
   for (int eventNumber = 0; eventNumber < getNumberOfEvents(); ++eventNumber) {
-    if ((maxEvents > -1) && (eventNumber > maxEvents)) {
+    if ((maxEvents > -1) && (eventNumber >= maxEvents)) {
       break;
     }
 
@@ -916,11 +917,12 @@ void RawReaderCRU::writeGBTDataPerLink(std::string_view outputDirectory, int max
       if (!linkInfo.IsPresent) {
         continue;
       }
+      printf("Event %4d, Link %2d\n", eventNumber, iLink);
 
       const int ep = iLink >= 12;
       const int link = iLink - (ep)*12;
       auto outputFileName = fmt::format("{}/CRU_{:02}_EP_{}_Link_{:02}", outputDirectory.data(), mCRU, ep, link);
-      std::ofstream outputFile(outputFileName, std::ios_base::binary);
+      std::ofstream outputFile(outputFileName, std::ios_base::binary | std::ios_base::app);
 
       for (auto packetNumber : linkInfo.PacketPositions) {
         const auto& packet = mPacketDescriptorMaps[iLink][packetNumber];
@@ -1136,8 +1138,15 @@ void RawReaderCRUManager::copyEvents(const std::vector<uint32_t> eventNumbers, s
 {
   // make sure events have been built
   init();
-  for (auto& rawReader : mRawReadersCRU) {
-    rawReader->copyEvents(eventNumbers, outputDirectory.data(), mode);
+  const auto& cruSeen = mEventSync.getCRUSeen();
+
+  for (size_t iCRU = 0; iCRU < cruSeen.size(); ++iCRU) {
+    const auto readerNumber = cruSeen[iCRU];
+    if (readerNumber >= 0) {
+      auto& reader = mRawReadersCRU[readerNumber];
+      reader->forceCRU(iCRU);
+      reader->copyEvents(eventNumbers, outputDirectory.data(), mode);
+    }
   }
 }