add back support for old format to RawEventOutputModuleForBU

smorovic · smorovic · commit 6f88cd8e21e7 · 2025-06-28T10:34:10.000+02:00
DaqFakeReader reverted to FEDRawDataCollection so that this is also tested, as it is in use
diff --git a/EventFilter/Utilities/plugins/DaqFakeReader.cc b/EventFilter/Utilities/plugins/DaqFakeReader.cc
@@ -11,7 +11,7 @@
 
 #include "EventFilter/Utilities/interface/GlobalEventNumber.h"
 
-#include "DataFormats/FEDRawData/interface/RawDataBuffer.h"
+#include "DataFormats/FEDRawData/interface/FEDRawData.h"
 
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
@@ -26,6 +26,11 @@
 using namespace std;
 using namespace edm;
 
+////////////////////////////////////////////////////////////////////////////////
+// construction/destruction
+////////////////////////////////////////////////////////////////////////////////
+
+//______________________________________________________________________________
 DaqFakeReader::DaqFakeReader(const edm::ParameterSet& pset)
     : runNum(1),
       eventNum(1),
@@ -66,41 +71,27 @@ DaqFakeReader::DaqFakeReader(const edm::ParameterSet& pset)
         static_cast<long unsigned int>(std::chrono::high_resolution_clock::now().time_since_epoch().count());
     srand(time_count & 0xffffffff);
   }
-  produces<RawDataBuffer>();
+  produces<FEDRawDataCollection>();
 }
 
-int DaqFakeReader::fillRawData(Event& e, RawDataBuffer*& data) {
-  // a null pointer is passed, need to allocate the fed collection
-  totSize_ = 0;
-  logSizes_.clear();
-  logSizeIndex_ = 0;
+//______________________________________________________________________________
+DaqFakeReader::~DaqFakeReader() {}
 
-  if (!empty_events) {
-    getSizes(FEDNumbering::MINSiPixelFEDID, FEDNumbering::MAXSiPixelFEDID, meansize, width);
-    if (haveSiStrip_)
-      getSizes(FEDNumbering::MINSiStripFEDID, FEDNumbering::MAXSiStripFEDID, meansize, width);
-    if (haveECAL_)
-      getSizes(FEDNumbering::MINECALFEDID, FEDNumbering::MAXECALFEDID, meansize, width);
-    if (haveHCAL_)
-      getSizes(FEDNumbering::MINHCALFEDID, FEDNumbering::MAXHCALFEDID, meansize, width);
-    if (haveDT_)
-      getSizes(FEDNumbering::MINDTFEDID, FEDNumbering::MAXDTFEDID, meansize, width);
-    if (haveCSC_)
-      getSizes(FEDNumbering::MINCSCFEDID, FEDNumbering::MAXCSCFEDID, meansize, width);
-    if (haveRPC_)
-      getSizes(FEDNumbering::MINRPCFEDID, FEDNumbering::MAXRPCFEDID, meansize, width);
-    logSizes_.push_back(sizeof(tcds::Raw_v1) + 16);
-    totSize_ += sizeof(tcds::Raw_v1) + 16;
-  }
+////////////////////////////////////////////////////////////////////////////////
+// implementation of member functions
+////////////////////////////////////////////////////////////////////////////////
 
-  data = new RawDataBuffer(totSize_);
-  data->setPhase1Range();
+//______________________________________________________________________________
+int DaqFakeReader::fillRawData(Event& e, FEDRawDataCollection*& data) {
+  // a null pointer is passed, need to allocate the fed collection
+  data = new FEDRawDataCollection();
   EventID eID = e.id();
   auto ls = e.luminosityBlock();
 
   if (!empty_events) {
     // Fill the EventID
     eventNum++;
+    // FIXME:
 
     if (haveSiPixel_)
       fillFEDs(FEDNumbering::MINSiPixelFEDID, FEDNumbering::MAXSiPixelFEDID, eID, *data, meansize, width);
@@ -126,81 +117,74 @@ int DaqFakeReader::fillRawData(Event& e, RawDataBuffer*& data) {
 }
 
 void DaqFakeReader::produce(Event& e, EventSetup const& es) {
-  RawDataBuffer* fedbuffer = nullptr;
-  fillRawData(e, fedbuffer);
-  std::unique_ptr<RawDataBuffer> bare_product(fedbuffer);
+  edm::Handle<FEDRawDataCollection> rawdata;
+  FEDRawDataCollection* fedcoll = nullptr;
+  fillRawData(e, fedcoll);
+  std::unique_ptr<FEDRawDataCollection> bare_product(fedcoll);
   e.put(std::move(bare_product));
 }
 
-void DaqFakeReader::getSizes(const int fedmin, const int fedmax, float meansize, float width) {
-  // FIXME: last ID included?
-  for (int fedId = fedmin; fedId <= fedmax; ++fedId) {
-    // Generate size...
-    float logsiz = CLHEP::RandGauss::shoot(std::log(meansize), std::log(meansize) - std::log(width / 2.));
-    logSizes_.push_back(logsiz);
-    size_t size = int(std::exp(logsiz));
-    size -= size % 8;  // all blocks aligned to 64 bit words
-    totSize_ += size + 16;
-  }
-}
-
+//______________________________________________________________________________
 void DaqFakeReader::fillFEDs(
-    const int fedmin, const int fedmax, EventID& eID, RawDataBuffer& data, float meansize, float width) {
+    const int fedmin, const int fedmax, EventID& eID, FEDRawDataCollection& data, float meansize, float width) {
   // FIXME: last ID included?
   for (int fedId = fedmin; fedId <= fedmax; ++fedId) {
     // Generate size...
-    assert(logSizeIndex_ < logSizes_.size());
-    float logsiz = logSizes_[logSizeIndex_];
-    logSizeIndex_++;
+    float logsiz = CLHEP::RandGauss::shoot(std::log(meansize), std::log(meansize) - std::log(width / 2.));
     size_t size = int(std::exp(logsiz));
     size -= size % 8;  // all blocks aligned to 64 bit words
 
-    unsigned char* feddata = data.addSource(fedId, nullptr, size + 16);
+    FEDRawData& feddata = data.FEDData(fedId);
+    // Allocate space for header+trailer+payload
+    feddata.resize(size + 16);
 
     if (fillRandom_) {
       //fill FED with random values
       size_t size_ui = size - size % sizeof(unsigned int);
       for (size_t i = 0; i < size_ui; i += sizeof(unsigned int)) {
-        *((unsigned int*)(feddata + i)) = (unsigned int)rand();
+        *((unsigned int*)(feddata.data() + i)) = (unsigned int)rand();
       }
       //remainder
       for (size_t i = size_ui; i < size; i++) {
-        *(feddata + i) = rand() & 0xff;
+        *(feddata.data() + i) = rand() & 0xff;
       }
     }
 
     // Generate header
-    FEDHeader::set(feddata,
+    FEDHeader::set(feddata.data(),
                    1,            // Trigger type
                    eID.event(),  // LV1_id (24 bits)
                    0,            // BX_id
                    fedId);       // source_id
 
+    // Payload = all 0s...
+
     // Generate trailer
     int crc = 0;  // FIXME : get CRC
-    FEDTrailer::set(feddata + 8 + size,
+    FEDTrailer::set(feddata.data() + 8 + size,
                     size / 8 + 2,  // in 64 bit words!!!
                     crc,
                     0,   // Evt_stat
                     0);  // TTS bits
   }
 }
 
-void DaqFakeReader::fillTCDSFED(EventID& eID, RawDataBuffer& data, uint32_t ls, timeval* now) {
+void DaqFakeReader::fillTCDSFED(EventID& eID, FEDRawDataCollection& data, uint32_t ls, timeval* now) {
   uint32_t fedId = tcdsFEDID_;
+  FEDRawData& feddata = data.FEDData(fedId);
   uint32_t size = sizeof(tcds::Raw_v1);
-  unsigned char* feddata = data.addSource(fedId, nullptr, size + 16);
+  feddata.resize(size + 16);
 
   uint64_t orbitnr = 0;
   uint16_t bxid = 0;
 
-  FEDHeader::set(feddata,
+  FEDHeader::set(feddata.data(),
                  1,            // Trigger type
                  eID.event(),  // LV1_id (24 bits)
                  bxid,         // BX_id
                  fedId);       // source_id
 
-  tcds::Raw_v1* tcds = reinterpret_cast<tcds::Raw_v1*>(feddata + FEDHeader::length);
+  tcds::Raw_v1* tcds = reinterpret_cast<tcds::Raw_v1*>(feddata.data() + FEDHeader::length);
   tcds::BST_v1* bst = const_cast<tcds::BST_v1*>(&tcds->bst);
   tcds::Header_v1* header = const_cast<tcds::Header_v1*>(&tcds->header);
 
@@ -217,7 +201,7 @@ void DaqFakeReader::fillTCDSFED(EventID& eID, RawDataBuffer& data, uint32_t ls,
   const_cast<uint32_t&>(header->lumiSection) = ls;
 
   int crc = 0;  // only full event crc32c checked in HLT, not FED CRC16
-  FEDTrailer::set(feddata + 8 + size,
+  FEDTrailer::set(feddata.data() + 8 + size,
                   size / 8 + 2,  // in 64 bit words!!!
                   crc,
                   0,   // Evt_stat
diff --git a/EventFilter/Utilities/plugins/DaqFakeReader.h b/EventFilter/Utilities/plugins/DaqFakeReader.h
@@ -14,25 +14,40 @@
 #include "FWCore/Framework/interface/LuminosityBlock.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "DataFormats/Provenance/interface/EventID.h"
-#include "DataFormats/FEDRawData/interface/RawDataBuffer.h"
+#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
 #include <algorithm>
 
 class DaqFakeReader : public edm::one::EDProducer<> {
 public:
+  //
+  // construction/destruction
+  //
   DaqFakeReader(const edm::ParameterSet& pset);
-  ~DaqFakeReader() override {}
+  ~DaqFakeReader() override;
+
+  //
+  // public member functions
+  //
 
   // Generate and fill FED raw data for a full event
-  virtual int fillRawData(edm::Event& e, RawDataBuffer*& data);
+  virtual int fillRawData(edm::Event& e, FEDRawDataCollection*& data);
+
   void produce(edm::Event&, edm::EventSetup const&) override;
+
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
-  void getSizes(const int, const int, float meansize, float width);
-  void fillFEDs(const int, const int, edm::EventID& eID, RawDataBuffer& data, float meansize, float width);
-  void fillTCDSFED(edm::EventID& eID, RawDataBuffer& data, uint32_t ls, timeval* now);
+  //
+  // private member functions
+  //
+  void fillFEDs(const int, const int, edm::EventID& eID, FEDRawDataCollection& data, float meansize, float width);
+  void fillTCDSFED(edm::EventID& eID, FEDRawDataCollection& data, uint32_t ls, timeval* now);
   virtual void beginLuminosityBlock(edm::LuminosityBlock const& iL, edm::EventSetup const& iE);
 
+private:
+  //
+  // member data
+  //
   edm::RunNumber_t runNum;
   edm::EventNumber_t eventNum;
   bool empty_events;
@@ -52,10 +67,6 @@ class DaqFakeReader : public edm::one::EDProducer<> {
   bool haveDT_ = false;
   bool haveCSC_ = false;
   bool haveRPC_ = false;
-
-  uint32_t totSize_ = 0;
-  std::vector<float> logSizes_;
-  uint16_t logSizeIndex_;
 };
 
 #endif
diff --git a/EventFilter/Utilities/plugins/RawEventOutputModuleForBU.h b/EventFilter/Utilities/plugins/RawEventOutputModuleForBU.h
@@ -47,9 +47,12 @@ class RawEventOutputModuleForBU : public edm::one::OutputModule<edm::one::WatchR
   void endLuminosityBlock(edm::LuminosityBlockForOutput const&) override;
 
   std::unique_ptr<Consumer> templateConsumer_;
+  const edm::EDGetTokenT<FEDRawDataCollection> tokenFRD_;
   const edm::EDGetTokenT<RawDataBuffer> token_;
   const unsigned int numEventsPerFile_;
   const unsigned int frdVersion_;
+  std::string rawProductName_;
+  unsigned int rawProductType_ = 0;
   std::vector<unsigned int> sourceIdList_;
   unsigned int totevents_ = 0;
   unsigned int index_ = 0;
@@ -60,10 +63,18 @@ RawEventOutputModuleForBU<Consumer>::RawEventOutputModuleForBU(edm::ParameterSet
     : edm::one::OutputModuleBase::OutputModuleBase(ps),
       edm::one::OutputModule<edm::one::WatchRuns, edm::one::WatchLuminosityBlocks>(ps),
       templateConsumer_(new Consumer(ps)),
+      tokenFRD_(consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("source"))),
       token_(consumes<RawDataBuffer>(ps.getParameter<edm::InputTag>("source"))),
       numEventsPerFile_(ps.getParameter<unsigned int>("numEventsPerFile")),
       frdVersion_(ps.getParameter<unsigned int>("frdVersion")),
+      rawProductName_(ps.getUntrackedParameter<std::string>("rawProductName")),
       sourceIdList_(ps.getUntrackedParameter<std::vector<unsigned int>>("sourceIdList", std::vector<unsigned int>())) {
+  if (rawProductName_ == "FEDRawDataCollection")
+    rawProductType_ = 1;
+  else if (rawProductName_ == "RawDataBuffer")
+    rawProductType_ = 2;
+  else
+    throw cms::Exception("RawEventOutputModuleForBU") << "Unknown raw product specified";
   if (frdVersion_ > 0 && frdVersion_ < 5)
     throw cms::Exception("RawEventOutputModuleForBU")
         << "Generating data with FRD version " << frdVersion_ << " is no longer supported";
@@ -89,23 +100,49 @@ void RawEventOutputModuleForBU<Consumer>::write(edm::EventForOutput const& e) {
   totevents_++;
   // serialize the FEDRawDataCollection into the format that we expect for
   // FRDEventMsgView objects (may be better ways to do this)
+  edm::Handle<FEDRawDataCollection> fedBuffers;
   edm::Handle<RawDataBuffer> fedBuffer;
-  e.getByToken(token_, fedBuffer);
+
+  unsigned int usedRawType = 0;
+  if (rawProductType_ == 1) {
+    e.getByToken(tokenFRD_, fedBuffers);
+    usedRawType = 1;
+  } else if (rawProductType_ == 2) {
+    e.getByToken(token_, fedBuffer);
+    usedRawType = 2;
+  }
+  assert(usedRawType);
 
   // determine the expected size of the FRDEvent IN bytes
   int headerSize = edm::streamer::FRDHeaderVersionSize[frdVersion_];
   int expectedSize = headerSize;
-  int nFeds = FEDNumbering::lastFEDId() + 1;  //TODO!
+  //for FEDRawDataCollection
+  int nFeds = FEDNumbering::lastFEDId() + 1;
 
-  if (!sourceIdList_.empty()) {
-    for (int idx : sourceIdList_) {
-      auto singleFED = fedBuffer->fragmentData(idx);
-      expectedSize += singleFED.size();
+  if (usedRawType == 1) {
+    if (!sourceIdList_.empty()) {
+      for (int idx : sourceIdList_) {
+        auto singleFED = fedBuffers->FEDData(idx);
+        expectedSize += singleFED.size();
+      }
+    } else {
+      for (int idx = 0; idx < nFeds; ++idx) {
+        auto singleFED = fedBuffers->FEDData(idx);
+        expectedSize += singleFED.size();
+      }
     }
-  } else {
-    for (int idx = 0; idx < nFeds; ++idx) {
-      auto singleFED = fedBuffer->fragmentData(idx);
-      expectedSize += singleFED.size();
+  } else if (usedRawType == 2) {
+    if (!sourceIdList_.empty()) {
+      for (int idx : sourceIdList_) {
+        auto singleFED = fedBuffer->fragmentData(idx);
+        expectedSize += singleFED.size();
+      }
+    } else {
+      //for (int idx = 0; idx < nFeds; ++idx) {
+      for (auto it = fedBuffer->map().begin(); it != fedBuffer->map().end(); it++) {
+        auto singleFED = fedBuffer->fragmentData(it);
+        expectedSize += singleFED.size();
+      }
     }
   }
 
@@ -134,17 +171,37 @@ void RawEventOutputModuleForBU<Consumer>::write(edm::EventForOutput const& e) {
     *bufPtr++ = 0;
   }
   uint32_t* payloadPtr = bufPtr;
-  if (!sourceIdList_.empty()) {
-    for (int idx : sourceIdList_) {
-      auto singleFED = fedBuffer->fragmentData(idx);
-      memcpy(bufPtr, &singleFED.data()[0], singleFED.size());
-      bufPtr += singleFED.size() / 4;
+  if (usedRawType == 1) {
+    if (!sourceIdList_.empty()) {
+      for (int idx : sourceIdList_) {
+        FEDRawData singleFED = fedBuffers->FEDData(idx);
+        if (singleFED.size() > 0) {
+          memcpy(bufPtr, singleFED.data(), singleFED.size());
+          bufPtr += singleFED.size() / 4;
+        }
+      }
+    } else {
+      for (int idx = 0; idx < nFeds; ++idx) {
+        FEDRawData singleFED = fedBuffers->FEDData(idx);
+        if (singleFED.size() > 0) {
+          memcpy(bufPtr, singleFED.data(), singleFED.size());
+          bufPtr += singleFED.size() / 4;
+        }
+      }
     }
-  } else {
-    for (auto it = fedBuffer->map().begin(); it != fedBuffer->map().end(); it++) {
-      auto singleFED = fedBuffer->fragmentData(it);
-      memcpy(bufPtr, &singleFED.data()[0], singleFED.size());
-      bufPtr += singleFED.size() / 4;
+  } else if (usedRawType == 2) {
+    if (!sourceIdList_.empty()) {
+      for (int idx : sourceIdList_) {
+        auto singleFED = fedBuffer->fragmentData(idx);
+        memcpy(bufPtr, &singleFED.data()[0], singleFED.size());
+        bufPtr += singleFED.size() / 4;
+      }
+    } else {
+      for (auto it = fedBuffer->map().begin(); it != fedBuffer->map().end(); it++) {
+        auto singleFED = fedBuffer->fragmentData(it);
+        memcpy(bufPtr, &singleFED.data()[0], singleFED.size());
+        bufPtr += singleFED.size() / 4;
+      }
     }
   }
   if (frdVersion_) {
@@ -195,6 +252,8 @@ void RawEventOutputModuleForBU<Consumer>::fillDescriptions(edm::ConfigurationDes
   desc.add<edm::InputTag>("source", edm::InputTag("rawDataCollector"));
   desc.add<unsigned int>("numEventsPerFile", 100);
   desc.add<unsigned int>("frdVersion", 6);
+  desc.addUntracked<std::string>("rawProductName", "FEDRawDataCollection")
+      ->setComment("FEDRawDataCollection or RawDataBuffer");
   desc.addUntracked<std::vector<unsigned int>>("sourceIdList", std::vector<unsigned int>());
   Consumer::extendDescription(desc);
 
diff --git a/EventFilter/Utilities/test/startBU.py b/EventFilter/Utilities/test/startBU.py
