Merge pull request #10 from noferini/tof-dev

Enable conet mode in decoding and reco + fixes in CTF

Author: noferini

DataFormats/Detectors/TOF/include/DataFormatsTOF/CTF.h

@@ -35,7 +35,7 @@ struct CTFHeader {
   uint32_t firstOrbit = 0;    /// 1st orbit of TF
   uint16_t firstBC = 0;       /// 1st BC of TF
 
-  ClassDefNV(CTFHeader, 1);
+  ClassDefNV(CTFHeader, 2);
 };
 
 /// Compressed but not yet entropy-encoded infos
@@ -59,6 +59,7 @@ struct CompressedInfos {
   std::vector<uint32_t> orbitIncROF; /// increment of ROF orbit wrt orbit of previous ROF
   std::vector<uint32_t> ndigROF;     /// number of digits in ROF
   std::vector<uint32_t> ndiaROF;     /// number of diagnostic/pattern words in ROF
+  std::vector<uint32_t> ndiaCrate;   /// number of diagnostic/pattern words per crate in ROF
 
   // Hit data
   std::vector<uint16_t> timeFrameInc; /// time increment with respect of previous digit in TimeFrame units
@@ -72,17 +73,18 @@ struct CompressedInfos {
 
   void clear();
 
-  ClassDefNV(CompressedInfos, 1);
+  ClassDefNV(CompressedInfos, 2);
 };
 
 /// wrapper for the Entropy-encoded clusters of the TF
-struct CTF : public o2::ctf::EncodedBlocks<CTFHeader, 10, uint32_t> {
+struct CTF : public o2::ctf::EncodedBlocks<CTFHeader, 11, uint32_t> {
 
   static constexpr size_t N = getNBlocks();
   enum Slots { BLCbcIncROF,
                BLCorbitIncROF,
                BLCndigROF,
                BLCndiaROF,
+               BLCndiaCrate,
                BLCtimeFrameInc,
                BLCtimeTDCInc,
                BLCstripID,

DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h

@@ -63,7 +63,7 @@ class Cluster : public o2::BaseCluster<float>
   double getTime() const { return mTime; }                  // Cluster ToF getter
   void setTime(double time) { mTime = time; }               // Cluster ToF setter
   float getTot() const { return mTot; }                     // Cluster Charge getter
-  void setTot(int tot) { mTot = tot; }                      // Cluster ToT setter
+  void setTot(float tot) { mTot = tot; }                    // Cluster ToT setter
   int getL0L1Latency() const { return mL0L1Latency; };      // L0L1 latency
   void setL0L1Latency(int value) { mL0L1Latency = value; }; // L0-L1 latency
   int getDeltaBC() const { return mDeltaBC; };              // deltaBC

DataFormats/Detectors/TOF/src/CTF.cxx

@@ -22,6 +22,7 @@ void CompressedInfos::clear()
   orbitIncROF.clear();
   ndigROF.clear();
   ndiaROF.clear();
+  ndiaCrate.clear();
   timeFrameInc.clear();
   timeTDCInc.clear();
   stripID.clear();

DataFormats/Detectors/TOF/src/DataFormatsTOFLinkDef.h

@@ -28,6 +28,6 @@
 #pragma link C++ class o2::tof::CTFHeader + ;
 #pragma link C++ class o2::tof::CompressedInfos + ;
 #pragma link C++ class o2::tof::CTF + ;
-#pragma link C++ class o2::ctf::EncodedBlocks < o2::tof::CTFHeader, 10, uint32_t> + ;
+#pragma link C++ class o2::ctf::EncodedBlocks < o2::tof::CTFHeader, 11, uint32_t> + ;
 
 #endif

Detectors/GlobalTrackingWorkflow/tofworkflow/src/tof-reco-workflow.cxx

@@ -58,7 +58,10 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   workflowOptions.push_back(ConfigParamSpec{"input-desc", o2::framework::VariantType::String, "CRAWDATA", {"Input specs description string"}});
   workflowOptions.push_back(ConfigParamSpec{"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input readers"}});
   workflowOptions.push_back(ConfigParamSpec{"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writers"}});
+  workflowOptions.push_back(ConfigParamSpec{"conet-mode", o2::framework::VariantType::Bool, false, {"enable conet mode"}});
   workflowOptions.push_back(ConfigParamSpec{"configKeyValues", o2::framework::VariantType::String, "", {"Semicolon separated key=value strings ..."}});
+  workflowOptions.push_back(ConfigParamSpec{"disable-row-writing", o2::framework::VariantType::Bool, false, {"disable ROW in Digit writing"}});
+  workflowOptions.push_back(ConfigParamSpec{"write-decoding-errors", o2::framework::VariantType::Bool, false, {"trace errors in digits output when decoding"}});
 }
 
 #include "Framework/runDataProcessing.h" // the main driver
@@ -84,13 +87,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec specs;
 
   if (!cfgc.helpOnCommandLine()) {
-    std::string inputGRP = o2::base::NameConf::getGRPFileName();
-    o2::base::Propagator::initFieldFromGRP(inputGRP);
-    const auto grp = o2::parameters::GRPObject::loadFrom(inputGRP);
-    if (!grp) {
-      LOG(ERROR) << "This workflow needs a valid GRP file to start";
-      return specs;
-    }
     o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
     //  o2::conf::ConfigurableParam::writeINI("o2tofrecoflow_configuration.ini");
   }
@@ -107,6 +103,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   bool writedigit = 0;
   bool writeraw = 0;
   bool writectf = 0;
+  bool writeerr = 0;
 
   if (outputType.rfind("clusters") < outputType.size())
     writecluster = 1;
@@ -131,15 +128,31 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     clusterinput = 1;
   } else if (inputType == "raw") {
     rawinput = 1;
+    writeerr = cfgc.options().get<bool>("write-decoding-errors");
   } else if (inputType == "ctf") {
     ctfinput = 1;
   }
 
+  if (ctfinput || rawinput) {
+  } else {
+    if (!cfgc.helpOnCommandLine()) {
+      std::string inputGRP = o2::base::NameConf::getGRPFileName();
+      o2::base::Propagator::initFieldFromGRP(inputGRP);
+      const auto grp = o2::parameters::GRPObject::loadFrom(inputGRP);
+      if (!grp) {
+        LOG(ERROR) << "This workflow needs a valid GRP file to start";
+        return specs;
+      }
+    }
+  }
+
   auto useMC = !cfgc.options().get<bool>("disable-mc");
   auto useCCDB = cfgc.options().get<bool>("use-ccdb");
   auto useFIT = cfgc.options().get<bool>("use-fit");
   bool disableRootInput = cfgc.options().get<bool>("disable-root-input") || rawinput;
   bool disableRootOutput = cfgc.options().get<bool>("disable-root-output");
+  bool conetmode = cfgc.options().get<bool>("conet-mode");
+  bool disableROWwriting = cfgc.options().get<bool>("disable-row-writing");
 
   LOG(INFO) << "TOF RECO WORKFLOW configuration";
   LOG(INFO) << "TOF input = " << cfgc.options().get<std::string>("input-type");
@@ -151,6 +164,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   LOG(INFO) << "TOF use-fit = " << cfgc.options().get<std::string>("use-fit");
   LOG(INFO) << "TOF disable-root-input = " << disableRootInput;
   LOG(INFO) << "TOF disable-root-output = " << disableRootOutput;
+  LOG(INFO) << "TOF conet-mode = " << conetmode;
+  LOG(INFO) << "TOF disable-row-writing = " << disableROWwriting;
+  LOG(INFO) << "TOF write-decoding-errors = " << writeerr;
 
   if (clusterinput) {
     LOG(INFO) << "Insert TOF Cluster Reader";
@@ -167,13 +183,13 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   } else if (rawinput) {
     LOG(INFO) << "Insert TOF Compressed Raw Decoder";
     auto inputDesc = cfgc.options().get<std::string>("input-desc");
-    specs.emplace_back(o2::tof::getCompressedDecodingSpec(inputDesc));
+    specs.emplace_back(o2::tof::getCompressedDecodingSpec(inputDesc, conetmode));
     useMC = 0;
 
     if (writedigit && !disableRootOutput) {
       // add TOF digit writer without mc labels
       LOG(INFO) << "Insert TOF Digit Writer";
-      specs.emplace_back(o2::tof::getTOFDigitWriterSpec(0));
+      specs.emplace_back(o2::tof::getTOFDigitWriterSpec(0, writeerr));
     }
   } else if (ctfinput) {
     LOG(INFO) << "Insert TOF CTF decoder";

Detectors/TOF/base/include/TOFBase/Digit.h

@@ -114,10 +114,23 @@ struct ReadoutWindowData {
   // for given trigger (or BC or RO frame)
   o2::dataformats::RangeReference<int, int> ref;
   o2::dataformats::RangeReference<int, int> refDiagnostic;
+
+  // crate info for diagnostic patterns
+  int mNdiaCrate[72] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
   InteractionRecord mFirstIR{0, 0};
 
   const InteractionRecord& getBCData() const { return mFirstIR; }
 
+  void addedDiagnostic(int crate) { mNdiaCrate[crate]++; }
+  void setDiagnosticInCrate(int crate, int val) { mNdiaCrate[crate] = val; }
+  int getDiagnosticInCrate(int crate) const { return mNdiaCrate[crate]; }
+
   void setBCData(int orbit, int bc)
   {
     mFirstIR.orbit = orbit;

Detectors/TOF/base/include/TOFBase/WindowFiller.h

@@ -24,8 +24,15 @@ namespace tof
 
 class WindowFiller
 {
-
  public:
+  struct PatternData {
+    uint32_t pattern;
+    int icrate;
+    ulong row;
+
+    PatternData(uint32_t patt = 0, int icr = 0, ulong rw = 0) : pattern(patt), icrate(icr), row(rw) {}
+  };
+
   WindowFiller() { initObj(); };
   ~WindowFiller() = default;
 
@@ -42,6 +49,7 @@ class WindowFiller
 
   std::vector<Digit>* getDigitPerTimeFrame() { return &mDigitsPerTimeFrame; }
   std::vector<ReadoutWindowData>* getReadoutWindowData() { return &mReadoutWindowData; }
+  std::vector<ReadoutWindowData>* getReadoutWindowDataFiltered() { return &mReadoutWindowDataFiltered; }
 
   void fillOutputContainer(std::vector<Digit>& digits);
   void flushOutputContainer(std::vector<Digit>& digits); // flush all residual buffered data
@@ -52,6 +60,17 @@ class WindowFiller
 
   void setFirstIR(const o2::InteractionRecord& ir) { mFirstIR = ir; }
 
+  void maskNoiseRate(int val) { mMaskNoiseRate = val; }
+
+  void clearCounts()
+  {
+    for (int i = 0; i < o2::tof::Geo::NCHANNELS; i++)
+      mChannelCounts[i] = 0;
+  }
+
+  std::vector<uint32_t>& getPatterns() { return mPatterns; }
+  void addPattern(const uint32_t val, int icrate, int orbit, int bc) { mCratePatterns.emplace_back(val, icrate, orbit * 3 + (bc + 100) / 1188); }
+
  protected:
   // info TOF timewindow
   Int_t mReadoutWindowCurrent = 0;
@@ -61,13 +80,18 @@ class WindowFiller
   bool mContinuous = true;
   bool mFutureToBeSorted = false;
 
+  // only needed from Decoder
+  int mMaskNoiseRate = -1;
+  int mChannelCounts[o2::tof::Geo::NCHANNELS]; // count of channel hits in the current TF (if MaskNoiseRate enabled)
+
   // digit info
   //std::vector<Digit>* mDigits;
 
   static const int MAXWINDOWS = 2; // how many readout windows we can buffer
 
   std::vector<Digit> mDigitsPerTimeFrame;
   std::vector<ReadoutWindowData> mReadoutWindowData;
+  std::vector<ReadoutWindowData> mReadoutWindowDataFiltered;
 
   int mIcurrentReadoutWindow = 0;
 
@@ -79,6 +103,11 @@ class WindowFiller
   // arrays with digit and MCLabels out of the current readout windows (stored to fill future readout window)
   std::vector<Digit> mFutureDigits;
 
+  std::vector<uint32_t> mPatterns;
+  std::vector<uint64_t> mErrors;
+
+  std::vector<PatternData> mCratePatterns;
+
   void fillDigitsInStrip(std::vector<Strip>* strips, int channel, int tdc, int tot, uint64_t nbc, UInt_t istrip, uint32_t triggerorbit = 0, uint16_t triggerbunch = 0);
   //  void fillDigitsInStrip(std::vector<Strip>* strips, o2::dataformats::MCTruthContainer<o2::tof::MCLabel>* mcTruthContainer, int channel, int tdc, int tot, int nbc, UInt_t istrip, Int_t trackID, Int_t eventID, Int_t sourceID);
 

Detectors/TOF/base/src/WindowFiller.cxx

@@ -95,6 +95,7 @@ void WindowFiller::reset()
 
   mDigitsPerTimeFrame.clear();
   mReadoutWindowData.clear();
+  mReadoutWindowDataFiltered.clear();
 
   mFirstIR.bc = 0;
   mFirstIR.orbit = 0;
@@ -124,8 +125,34 @@ void WindowFiller::fillOutputContainer(std::vector<Digit>& digits)
     int orbit_shift = mReadoutWindowData.size() / 3;
     int bc_shift = (mReadoutWindowData.size() % 3) * Geo::BC_IN_WINDOW;
     info.setBCData(mFirstIR.orbit + orbit_shift, mFirstIR.bc + bc_shift);
-    if (digits.size())
+    int firstPattern = mPatterns.size();
+    int npatterns = 0;
+
+    // check if patterns are in the current row
+    int ipatt = mCratePatterns.size() - 1;
+    for (std::vector<PatternData>::reverse_iterator it = mCratePatterns.rbegin(); it != mCratePatterns.rend(); ++it) {
+      if (it->row > mReadoutWindowCurrent)
+        break;
+
+      if (it->row < mReadoutWindowCurrent) { // this should not happen
+        LOG(ERROR) << "One pattern skipped because appears to occur early of the current row " << it->row << " < " << mReadoutWindowCurrent << " ?!";
+        mCratePatterns.erase(mCratePatterns.begin() + ipatt);
+      } else {
+        mPatterns.push_back(it->pattern);
+        info.addedDiagnostic(it->icrate);
+
+        mCratePatterns.erase(mCratePatterns.begin() + ipatt);
+        npatterns++;
+      }
+      ipatt--;
+    }
+
+    info.setFirstEntryDia(firstPattern);
+    info.setNEntriesDia(npatterns);
+    if (digits.size()) {
       mDigitsPerTimeFrame.insert(mDigitsPerTimeFrame.end(), digits.begin(), digits.end());
+      mReadoutWindowDataFiltered.push_back(info);
+    }
     mReadoutWindowData.push_back(info);
   }
 
@@ -149,6 +176,10 @@ void WindowFiller::flushOutputContainer(std::vector<Digit>& digits)
 { // flush all residual buffered data
   // TO be implemented
 
+  // sort patterns (diagnostic words) in time
+  std::sort(mCratePatterns.begin(), mCratePatterns.end(),
+            [](PatternData a, PatternData b) { if(a.row == b.row) return a.icrate > b.icrate; else return a.row > b.row; });
+
   for (Int_t i = 0; i < MAXWINDOWS; i++) {
     int n = 0;
     for (int j = 0; j < mStrips[i].size(); j++)
@@ -294,7 +325,8 @@ void WindowFiller::checkIfReuseFutureDigitsRO() // the same but using readout in
         strips = mStripsNext[isnext - 1];
       }
 
-      fillDigitsInStrip(strips, digit->getChannel(), digit->getTDC(), digit->getTOT(), digit->getBC(), digit->getChannel() / Geo::NPADS);
+      if (mMaskNoiseRate < 0 || mChannelCounts[digit->getChannel()] < mMaskNoiseRate)
+        fillDigitsInStrip(strips, digit->getChannel(), digit->getTDC(), digit->getTOT(), digit->getBC(), digit->getChannel() / Geo::NPADS);
 
       // int labelremoved = digit->getLabel();
       mFutureDigits.erase(mFutureDigits.begin() + idigit);

Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h

@@ -74,6 +74,7 @@ void CTFCoder::encode(VEC& buff, const gsl::span<const ReadoutWindowData>& rofRe
     MD::EENCODE, //BLCorbitIncROF
     MD::EENCODE, //BLCndigROF
     MD::EENCODE, //BLCndiaROF
+    MD::EENCODE, //BLCndiaCrate
     MD::EENCODE, //BLCtimeFrameInc
     MD::EENCODE, //BLCtimeTDCInc
     MD::EENCODE, //BLCstripID
@@ -100,6 +101,7 @@ void CTFCoder::encode(VEC& buff, const gsl::span<const ReadoutWindowData>& rofRe
   ENCODETOF(cc.orbitIncROF,  CTF::BLCorbitIncROF,  0);
   ENCODETOF(cc.ndigROF,      CTF::BLCndigROF,      0);
   ENCODETOF(cc.ndiaROF,      CTF::BLCndiaROF,      0);
+  ENCODETOF(cc.ndiaCrate,    CTF::BLCndiaCrate,    0);
   ENCODETOF(cc.timeFrameInc, CTF::BLCtimeFrameInc, 0);
   ENCODETOF(cc.timeTDCInc,   CTF::BLCtimeTDCInc,   0);
   ENCODETOF(cc.stripID,      CTF::BLCstripID,      0);
@@ -124,6 +126,7 @@ void CTFCoder::decode(const CTF::base& ec, VROF& rofRecVec, VDIG& cdigVec, VPAT&
   DECODETOF(cc.orbitIncROF,  CTF::BLCorbitIncROF);
   DECODETOF(cc.ndigROF,      CTF::BLCndigROF);
   DECODETOF(cc.ndiaROF,      CTF::BLCndiaROF);
+  DECODETOF(cc.ndiaCrate,    CTF::BLCndiaCrate);
 
   DECODETOF(cc.timeFrameInc, CTF::BLCtimeFrameInc);
   DECODETOF(cc.timeTDCInc,   CTF::BLCtimeTDCInc);
@@ -161,6 +164,9 @@ void CTFCoder::decompress(const CompressedInfos& cc, VROF& rofRecVec, VDIG& cdig
     rofRec.setNEntries(cc.ndigROF[irof]);
     rofRec.setFirstEntryDia(ndiagnostic);
     rofRec.setNEntriesDia(cc.ndiaROF[irof]);
+    for (int icrate = 0; icrate < 72; icrate++)
+      rofRec.setDiagnosticInCrate(icrate, cc.ndiaCrate[irof * 72 + icrate]);
+
     firstEntry += cc.ndigROF[irof];
     ndiagnostic += cc.ndiaROF[irof];
 

Detectors/TOF/reconstruction/include/TOFReconstruction/Decoder.h

@@ -71,6 +71,9 @@ class Decoder : public WindowFiller
 
   char* nextPage(void* current, int shift = 8192);
 
+  std::vector<uint64_t>& getErrors() { return mErrors; }
+  void addError(const uint32_t val, int icrate) { mErrors.push_back((uint64_t(icrate) << 32) + val); }
+
  protected:
   static const int NCRU = 4;