TRD fix for empty frames

DataFormats/Detectors/TRD/CMakeLists.txt

@@ -18,7 +18,6 @@ o2_add_library(DataFormatsTRD
                        src/CompressedDigit.cxx
                        src/CTF.cxx
                        src/Digit.cxx
-                       src/EventRecord.cxx
                PUBLIC_LINK_LIBRARIES O2::CommonDataFormat O2::SimulationDataFormat)
 
 o2_target_root_dictionary(DataFormatsTRD

Detectors/TRD/reconstruction/CMakeLists.txt

@@ -19,6 +19,7 @@ o2_add_library(TRDReconstruction
                        src/CompressedRawReader.cxx
                        src/DataReaderTask.cxx
                        src/CruCompressorTask.cxx
+                       src/EventRecord.cxx
                PUBLIC_LINK_LIBRARIES O2::TRDBase
                                      O2::DataFormatsTRD
                                      O2::DataFormatsTPC

Detectors/TRD/reconstruction/include/TRDReconstruction/CruRawReader.h

@@ -33,7 +33,7 @@
 #include "DataFormatsTRD/Constants.h"
 #include "TRDBase/Digit.h"
 #include "CommonDataFormat/InteractionRecord.h"
-#include "DataFormatsTRD/EventRecord.h"
+#include "TRDReconstruction/EventRecord.h"
 
 namespace o2::trd
 {
@@ -92,6 +92,8 @@ class CruRawReader
   std::vector<Digit>& getDigits(InteractionRecord& ir) { return mEventRecords.getDigits(ir); };
   //  std::vector<o2::trd::TriggerRecord> getIR() { return mEventTriggers; }
   void getParsedObjects(std::vector<Tracklet64>& tracklets, std::vector<Digit>& cdigits, std::vector<TriggerRecord>& triggers);
+  void getParsedObjectsandClear(std::vector<Tracklet64>& tracklets, std::vector<Digit>& digits, std::vector<TriggerRecord>& triggers);
+  void buildDPLOutputs(o2::framework::ProcessingContext& outputs);
   int getDigitsFound() { return mTotalDigitsFound; }
   int getTrackletsFound() { return mTotalTrackletsFound; }
   int sumTrackletsFound() { return mEventRecords.sumTracklets(); }

Detectors/TRD/reconstruction/include/TRDReconstruction/DataReaderTask.h

@@ -38,7 +38,7 @@ class DataReaderTask : public Task
   DataReaderTask(bool compresseddata, bool byteswap, bool verbose, bool headerverbose, bool dataverbose) : mCompressedData(compresseddata), mByteSwap(byteswap), mVerbose(verbose), mHeaderVerbose(headerverbose), mDataVerbose(dataverbose) {}
   ~DataReaderTask() override = default;
   void init(InitContext& ic) final;
-  void sendData(ProcessingContext& pc);
+  void sendData(ProcessingContext& pc, bool blankframe = false);
   void run(ProcessingContext& pc) final;
 
  private:
@@ -47,16 +47,15 @@ class DataReaderTask : public Task
                                          // in both cases we pull the data from the vectors build message and pass on.
                                          // they will internally produce a vector of digits and a vector tracklets and associated indexing.
                                          // TODO templatise this and 2 versions of datareadertask, instantiated with the relevant parser.
-  std::vector<Tracklet64> mTracklets;
-  std::vector<Digit> mDigits;
-  std::vector<o2::trd::TriggerRecord> mTriggers;
-  //  std::vector<o2::trd::FlpStats> mStats;
 
   bool mVerbose{false};        // verbos output general debuggign and info output.
   bool mDataVerbose{false};    // verbose output of data unpacking
   bool mHeaderVerbose{false};  // verbose output of headers
   bool mCompressedData{false}; // are we dealing with the compressed data from the flp (send via option)
   bool mByteSwap{true};        // whether we are to byteswap the incoming data, mc is not byteswapped, raw data is (too be changed in cru at some point)
+                               //  o2::header::DataDescription mDataDesc; // Data description of the incoming data
+  std::string mDataDesc;
+  o2::header::DataDescription mUserDataDescription = o2::header::gDataDescriptionInvalid; // alternative user-provided description to pick
 };
 
 } // namespace o2::trd

DataFormats/Detectors/TRD/include/DataFormatsTRD/EventRecord.h → Detectors/TRD/reconstruction/include/TRDReconstruction/EventRecord.h

@@ -19,6 +19,11 @@
 #include "FairLogger.h"
 #include "DataFormatsTRD/Tracklet64.h"
 
+namespace o2::framework
+{
+class ProcessingContext;
+}
+
 namespace o2::trd
 {
 class Digit;
@@ -74,8 +79,6 @@ class EventRecord
   BCData mBCData;                       /// orbit and Bunch crossing data of the physics trigger
   std::vector<Digit> mDigits{};         /// digit data, for this event
   std::vector<Tracklet64> mTracklets{}; /// tracklet data, for this event
-
-  ClassDefNV(EventRecord, 1);
 };
 
 class EventStorage
@@ -92,7 +95,10 @@ class EventStorage
   void addTracklet(InteractionRecord& ir, Tracklet64& tracklet);
   void addTracklets(InteractionRecord& ir, std::vector<Tracklet64>& tracklets);
   void addTracklets(InteractionRecord& ir, std::vector<Tracklet64>::iterator& start, std::vector<Tracklet64>::iterator& end);
-  void unpackDataForSending(std::vector<TriggerRecord>& triggers, std::vector<Tracklet64>& tracklets, std::vector<Digit>& digits);
+  void unpackData(std::vector<TriggerRecord>& triggers, std::vector<Tracklet64>& tracklets, std::vector<Digit>& digits);
+  void sendData(o2::framework::ProcessingContext& pc);
+  //this could replace by keeing a running total on addition TODO
+  void sumTrackletsDigitsTriggers(uint64_t& tracklets, uint64_t& digits, uint64_t& triggers);
   int sumTracklets();
   int sumDigits();
   std::vector<Tracklet64>& getTracklets(InteractionRecord& ir);
@@ -104,7 +110,6 @@ class EventStorage
   //these 2 are hacks to be able to send bak a blank vector if interaction record is not found.
   std::vector<Tracklet64> mDummyTracklets;
   std::vector<Digit> mDummyDigits;
-  ClassDefNV(EventStorage, 1);
 };
 std::ostream& operator<<(std::ostream& stream, const EventRecord& trg);
 

Detectors/TRD/reconstruction/src/CruRawReader.cxx

@@ -23,6 +23,14 @@
 #include "TRDReconstruction/TrackletsParser.h"
 #include "DataFormatsTRD/Constants.h"
 
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/RawDeviceService.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/DataSpecUtils.h"
+#include "Framework/Output.h"
+#include "Framework/InputRecordWalker.h"
+
 #include <cstring>
 #include <string>
 #include <vector>
@@ -414,32 +422,21 @@ void CruRawReader::getParsedObjects(std::vector<Tracklet64>& tracklets, std::vec
 {
   int digitcountsum = 0;
   int trackletcountsum = 0;
-  mEventRecords.unpackDataForSending(triggers, tracklets, digits);
-  /*for(auto eventrecord: mEventRecords)//loop over triggers incase they have already been done.
-  {
-  int digitcount=0;
-  int trackletcount=0;
-    int start,end;
-    LOG(info) << __func__ << " " << tracklets.size() << " "
-              << cdigits.size()<< " trackletv size:"<< mEventRecords.getTracklets(ir.getBCData());
-    for(auto trackletv: mEventStores.getTracklets(ir.getBCData())){
-      //loop through the vector of ranges
-      start=trackletv.getFirstEntry();
-      end= start+trackletv.getEntries();
-      LOG(info) << "insert tracklets from " << start<< "  " << end;
-      tracklets.insert(tracklets.end(),mEventTracklets.begin()+start, mEventTracklets.begin()+end);
-      trackletcount+=trackletv.getEntries();
-    }
-    for(auto digitv: mEventStores.getDigits(ir.getBCData())){
-      start=digitv.getFirstEntry();
-      end= start+digitv.getEntries();
-      LOG(info) << "insert digits from " << start<< "  " << end;
-      cdigits.insert(cdigits.end(),mEventCompressedDigits.begin()+start , mEventCompressedDigits.begin()+end);
-      digitcount+=digitv.getEntries();
-    }
-    triggers.emplace_back(ir.getBCData(),digitcountsum,digitcount,trackletcountsum,trackletcount);
-    digitcountsum+=digitcount;
-    trackletcountsum+=trackletcount;
-  }*/
+  mEventRecords.unpackData(triggers, tracklets, digits);
+}
+
+void CruRawReader::getParsedObjectsandClear(std::vector<Tracklet64>& tracklets, std::vector<Digit>& digits, std::vector<TriggerRecord>& triggers)
+{
+  getParsedObjects(tracklets, digits, triggers);
+  clearall();
 }
+
+//write the output data directly to the given DataAllocator from the datareader task.
+void CruRawReader::buildDPLOutputs(o2::framework::ProcessingContext& pc)
+{
+  mEventRecords.sendData(pc);
+  //    pc.outputs().snapshot(Output{o2::header::gDataOriginTRD,"STATS",0,Lifetime::Timerframe},mStats);
+  clearall(); // having now written the messages clear for next.
+}
+
 } // namespace o2::trd

Detectors/TRD/reconstruction/src/DataReader.cxx

@@ -29,12 +29,12 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
 
   std::vector<o2::framework::ConfigParamSpec> options{
-    {"trd-datareader-inputspec", VariantType::String, "RAWDATA", {"TRD raw data spec"}},
     {"trd-datareader-output-desc", VariantType::String, "TRDTLT", {"Output specs description string"}},
     {"trd-datareader-verbose", VariantType::Bool, false, {"Enable verbose epn data reading"}},
     {"trd-datareader-headerverbose", VariantType::Bool, false, {"Enable verbose header info"}},
     {"trd-datareader-dataverbose", VariantType::Bool, false, {"Enable verbose data info"}},
     {"trd-datareader-compresseddata", VariantType::Bool, false, {"The incoming data is compressed or not"}},
+    {"ignore-dist-stf", VariantType::Bool, false, {"do not subscribe to FLP/DISTSUBTIMEFRAME/0 message (no lost TF recovery)"}},
     {"trd-datareader-enablebyteswapdata", VariantType::Bool, false, {"byteswap the incoming data, raw data needs it and simulation does not."}}};
 
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
@@ -55,44 +55,39 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   //  o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   // o2::conf::ConfigurableParam::writeINI("o2trdrawreader-workflow_configuration.ini");
 
-  auto inputspec = cfgc.options().get<std::string>("trd-datareader-inputspec");
   //auto outputspec = cfgc.options().get<std::string>("trd-datareader-outputspec");
   auto verbose = cfgc.options().get<bool>("trd-datareader-verbose");
   auto byteswap = cfgc.options().get<bool>("trd-datareader-enablebyteswapdata");
   auto compresseddata = cfgc.options().get<bool>("trd-datareader-compresseddata");
   auto headerverbose = cfgc.options().get<bool>("trd-datareader-headerverbose");
   auto dataverbose = cfgc.options().get<bool>("trd-datareader-dataverbose");
-
+  auto askSTFDist = !cfgc.options().get<bool>("ignore-dist-stf");
   std::vector<OutputSpec> outputs;
   outputs.emplace_back("TRD", "TRACKLETS", 0, Lifetime::Timeframe);
   outputs.emplace_back("TRD", "DIGITS", 0, Lifetime::Timeframe);
   outputs.emplace_back("TRD", "TRKTRGRD", 0, Lifetime::Timeframe);
   //outputs.emplace_back("TRD", "FLPSTAT", 0, Lifetime::Timeframe);
-  LOG(info) << "input spec is:" << inputspec;
   LOG(info) << "enablebyteswap :" << byteswap;
   AlgorithmSpec algoSpec;
   algoSpec = AlgorithmSpec{adaptFromTask<o2::trd::DataReaderTask>(compresseddata, byteswap, verbose, headerverbose, dataverbose)};
 
   WorkflowSpec workflow;
 
-  /*
-   * This is originally replicated from TOF
-     We define at run time the number of devices to be attached
-     to the workflow and the input matching string of the device.
-     This is is done with a configuration string like the following
-     one, where the input matching for each device is provide in
-     comma-separated strings. For instance
-  */
-
-  //  std::stringstream ssconfig(inputspec);
   std::string iconfig;
   std::string inputDescription;
   int idevice = 0;
-  //  LOG(info) << "expected incoming data definition : " << inputspec;
-  // this is probably never going to be used but would to nice to know hence here.
+  auto orig = o2::header::gDataOriginTRD;
+  auto inputs = o2::framework::select(std::string("x:TRD/RAWDATA").c_str());
+  for (auto& inp : inputs) {
+    // take care of case where our data is not in the time frame
+    inp.lifetime = Lifetime::Optional;
+  }
+  if (askSTFDist) {
+    inputs.emplace_back("stdDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
+  }
   workflow.emplace_back(DataProcessorSpec{
     std::string("trd-datareader"), // left as a string cast incase we append stuff to the string
-    select(std::string("x:TRD/" + inputspec).c_str()),
+    inputs,                        //select(std::string("x:TRD/" + inputspec).c_str()),
     outputs,
     algoSpec,
     Options{}});