dev: checkConsistency and ctp.cfg

Author: Roman Lietava

DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h

@@ -173,6 +173,7 @@ class CTPConfiguration
   uint64_t getDecrtiptorInputsMask(const std::string& name) const;
   std::map<o2::detectors::DetID::ID, std::vector<CTPInput>> getDet2InputMap();
   uint64_t getTriggerClassMask() const;
+  uint64_t getTriggerClassMaskOnlywInputs() const;
   std::vector<int> getTriggerClassList() const;
   uint32_t getRunNumber() { return mRunNumber; };
   std::vector<std::string> getDetectorList() const;
@@ -203,6 +204,17 @@ class CTPConfiguration
 
 std::ostream& operator<<(std::ostream& in, const CTPConfiguration& conf);
 
+struct CtpCfg
+{
+  CtpCfg() = default;
+  std::string filename = "/home/alice/trigger/DBCTP/ctp.cfg";
+  CtpCfg readAndSave();
+  uint32_t TFOrbits = 0;
+  int ccdb = -1;          // -1 means def constructor was called
+  uint32_t orbitShift = 0;
+  uint32_t irInputs_1_24 = 0;
+  uint32_t irInputs_25_48 = 0;
+};
 } // namespace ctp
 } // namespace o2
 #endif //_CTP_CONFIGURATION_H_

DataFormats/Detectors/CTP/src/Configuration.cxx

@@ -905,6 +905,17 @@ uint64_t CTPConfiguration::getTriggerClassMask() const
   }
   return clsmask;
 }
+uint64_t CTPConfiguration::getTriggerClassMaskOnlywInputs() const
+{
+  uint64_t clsmask = 0;
+  for (auto const& cls : mCTPClasses) {
+    if( cls.name.find("TRUE") != std::string::npos) {  // ignoring internal ctp generators
+      continue;
+    }
+    clsmask |= cls.classMask;
+  }
+  return clsmask;
+}
 // Hardware positions of classes
 std::vector<int> CTPConfiguration::getTriggerClassList() const
 {
@@ -1153,6 +1164,44 @@ int CTPInputsConfiguration::getInputIndexFromName(std::string& name)
   return 0xff;
 }
 
+CtpCfg CtpCfg::readAndSave()
+{
+  std::ifstream ctpcfg(filename);
+  if (ctpcfg.is_open()) {
+    std::string line;
+    while (std::getline(ctpcfg, line)) {
+      o2::utils::Str::trim(line);
+      if (line.size() == 0) {
+        continue;
+      }
+      if (line[0] == '#') {
+        continue;
+      }
+      std::vector<std::string> tokens = o2::utils::Str::tokenize(line, ' ');
+      size_t ntokens = tokens.size();
+      if(ntokens < 2) {
+        LOG(warn) << "Not enough tokens";
+        return *this;
+      }
+      if(tokens[0].find("TForbits") != std::string::npos) {
+        TFOrbits = std::atol(tokens[1].c_str());
+      } else if(tokens[0].find("ccdb") != std::string::npos) {
+        ccdb = std::atoi(tokens[1].c_str());
+      } else if(tokens[0].find("orbitshift") != std::string::npos) {
+        orbitShift = std::atol(tokens[1].c_str());
+      } else if(tokens[0].find("ir_inputs") != std::string::npos){
+        irInputs_1_24 = std::stoul(tokens[1].c_str(), nullptr, 16);
+        irInputs_25_48 = std::stoul(tokens[2].c_str(), nullptr, 16);
+      } else {
+        LOG(warn) << " Token not found:" << tokens[0];
+      }
+    }
+  } else {
+    LOG(warn) << "Can not open file:" << filename;
+  }
+  return *this;
+}
+
 std::ostream& o2::ctp::operator<<(std::ostream& in, const o2::ctp::CTPConfiguration& conf)
 {
   conf.printStream(in);

Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h

@@ -56,7 +56,8 @@ class RawDataDecoder
   static int shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit, std::bitset<48>& inpmask, int64_t shift, int level, std::map<o2::InteractionRecord, CTPDigit>& digmap);
   static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
   int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff);
-
+  std::map<int,int> getClassErrors() {return mClassErrors; }
+  std::map<uint64_t,int> getInpError() { return mInpErrors; }
  private:
   static constexpr uint32_t TF_TRIGGERTYPE_MASK = 0x800;
   static constexpr uint32_t HB_TRIGGERTYPE_MASK = 0x2;
@@ -83,8 +84,10 @@ class RawDataDecoder
   // error verbosness
   int mErrorIR = 0;
   int mErrorTCR = 0;
-  int mErrorMax = 3;
+  int mErrorMax = 5;
   bool mStickyError = false;
+  std::map<int,int> mClassErrors;
+  std::map<uint64_t,int> mInpErrors;
   CTPConfiguration mCTPConfig;
 };
 } // namespace ctp

Detectors/CTP/reconstruction/src/RawDataDecoder.cxx

@@ -295,7 +295,7 @@ int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2
   if (mDoDigits & mDecodeInps) {
     uint64_t trgclassmask = 0xffffffffffffffff;
     if (mCTPConfig.getRunNumber() != 0) {
-      trgclassmask = mCTPConfig.getTriggerClassMask();
+      trgclassmask = mCTPConfig.getTriggerClassMaskOnlywInputs();
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
     ret = shiftInputs(digitsMap, digits, mTFOrbit, trgclassmask);
@@ -530,12 +530,6 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
 int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
 {
   // int nClasswoInp = 0; // counting classes without input which should never happen
-  int nLM = 0;
-  int nL0 = 0;
-  int nL1 = 0;
-  int nTwI = 0;
-  int nTwoI = 0;
-  int nTwoIlost = 0;
   std::map<o2::InteractionRecord, CTPDigit> digitsMapShifted;
   auto L0shift = o2::ctp::TriggerOffsetsParam::Instance().LM_L0;
   auto L1shift = L0shift + o2::ctp::TriggerOffsetsParam::Instance().L0_L1;
@@ -593,60 +587,35 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
     }
   }
   for (auto const& dig : digitsMapShifted) {
-    auto d = dig.second;
-    if ((d.CTPInputMask & LMMASKInputs).count()) {
-      nLM++;
-    }
-    if ((d.CTPInputMask & L0MASKInputs).count()) {
-      nL0++;
-    }
-    if ((d.CTPInputMask & L1MASKInputs).count()) {
-      nL1++;
-    }
-    if ((d.CTPClassMask).to_ulong() & trgclassmask) {
-      if (d.CTPInputMask.count()) {
-        nTwI++;
-      } else {
-        if (d.intRecord.bc == (o2::constants::lhc::LHCMaxBunches - L1shift)) { // input can be lost because latency class-l1input = 1
-          nTwoIlost++;
-        } else {
-          // LOG(error) << d.intRecord << " " << d.CTPClassMask << " " << d.CTPInputMask;
-          // std::cout << "ERROR:" << std::hex << d.CTPClassMask << " " << d.CTPInputMask << std::dec << std::endl;
-          nTwoI++;
-        }
-      }
-    }
     digits.push_back(dig.second);
   }
-  int ret = 0;
-  if (nTwoI) { // Trigger class wo Input
-    LOG(error) << "LM:" << nLM << " L0:" << nL0 << " L1:" << nL1 << " TwI:" << nTwI << " Trigger classes wo input:" << nTwoI;
-    ret = 64;
-  }
-  if (nTwoIlost) {
-    LOG(warn) << " Trigger classes wo input from diff latency 1:" << nTwoIlost;
-  }
-  return ret;
+  return 0;
 }
 //
 int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask)
 {
   int ret = 0;
   int lost = 0;
+  static int nerror = 0;
   for (auto const& digit : digits) {
     // if class mask => inps
     for (int i = 0; i < digit.CTPClassMask.size(); i++) {
       if (digit.CTPClassMask[i] & trgclassmask) {
         const CTPClass* cls = mCTPConfig.getCTPClassFromHWIndex(i);
         if (cls == nullptr) {
-          LOG(error) << "Class mask index not found in CTP config:" << i;
+          if(nerror < mErrorMax)
+            LOG(error) << "Class mask index not found in CTP config:" << i;
           ret = 128;
           continue;
         }
         uint64_t clsinpmask = cls->descriptor->getInputsMask();
         uint64_t diginpmask = digit.CTPInputMask.to_ullong();
         if (!((clsinpmask & diginpmask) == clsinpmask)) {
-          LOG(error) << "CTP class:" << cls->name << " inpmask:" << clsinpmask << " not compatible with inputs mask:" << diginpmask;
+          if(nerror < mErrorMax)
+            LOG(error) << "CTP class:" << cls->name << " inpmask:" << clsinpmask << " not compatible with inputs mask:" << diginpmask;
+          auto result = mClassErrors.insert({cls->getIndex(),1});
+          if(!result.second)
+            mClassErrors[cls->getIndex()]++;
           ret = 128;
         }
       }
@@ -662,7 +631,11 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
           int32_t offset = BCShiftCorrection + o2::ctp::TriggerOffsetsParam::Instance().LM_L0 + o2::ctp::TriggerOffsetsParam::Instance().L0_L1_classes - 1;
           offset = o2::constants::lhc::LHCMaxBunches - offset;
           if (digit.intRecord.bc < offset) {
-            LOG(error) << "CTP class:" << cls.name << " inpmask:" << clsinpmask << " cls mask:" << cls.classMask << " not found in digit:" << digit;
+            if(nerror < mErrorMax)
+              LOG(error) << "CTP class:" << cls.name << " inpmask:" << clsinpmask << " cls mask:" << cls.classMask << " not found in digit:" << digit;
+            auto result = mInpErrors.insert({diginpmask,1});
+            if(!result.second)
+              mInpErrors[diginpmask]++;
             ret = 256;
           } else {
             lost++;

Detectors/CTP/workflow/src/RawDecoderSpec.cxx

@@ -69,8 +69,8 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
     o0 = TFOrbits[i];
   }
   std::cout << std::endl;
-  std::cout << "Number of missing TF:" << nmiss << std::endl;
-  std::cout << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  LOG(info) << "Number of missing TF:" << nmiss << std::endl;
+  LOG(info) << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
 }
 void RawDecoderSpec::run(framework::ProcessingContext& ctx)
 {

Detectors/CTP/workflowScalers/CMakeLists.txt

@@ -13,7 +13,8 @@ o2_add_library(CTPWorkflowScalers
                SOURCES src/RunManager.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::DataFormatsCTP
-                                    AliceO2::BookkeepingApi)
+                                    AliceO2::BookkeepingApi
+                                    AliceO2::InfoLogger)
 o2_target_root_dictionary(CTPWorkflowScalers HEADERS
   include/CTPWorkflowScalers/ctpCCDBManager.h)
 o2_add_executable(

Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h

@@ -18,6 +18,7 @@
 #include "DataFormatsCTP/Configuration.h"
 #include "BookkeepingApi/BkpClientFactory.h"
 #include "BookkeepingApi/BkpClient.h"
+#include <InfoLogger/InfoLogger.hxx>
 
 using namespace o2::bkp::api;
 namespace o2
@@ -72,6 +73,7 @@ class CTPRunManager : public ctpCCDBManager
   int mEOX = 0; // redundancy check
   int mNew = 1; // 1 - no CCDB: used for QC
   int mQCWritePeriod = 3; // Time in 10secs between two writes to QCCD
+  AliceO2::InfoLogger::InfoLogger mInfoLogger;
   ClassDefNV(CTPRunManager, 7);
 };
 } // namespace ctp

Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h

@@ -29,6 +29,7 @@ class ctpCCDBManager
   int saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart);
   int saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long timeStart);
   int saveOrbitReset(long timeStamp);
+  int saveCtpCfg(uint32_t runNumber, long timeStamp);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run, bool& ok);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
   CTPRunScalers getScalersFromCCDB(long timestamp, std::string, bool& ok);
@@ -46,7 +47,8 @@ class ctpCCDBManager
   const std::string mQCDBPathCTPScalers = "qc/CTP/Scalers";
   const std::string mCCDBPathSoxOrbit = "CTP/Calib/FirstRunOrbit";
   const std::string mCCDBPathOrbitReset = "CTP/Calib/OrbitReset";
-  ClassDefNV(ctpCCDBManager, 1);
+  const std::string mCCDBPathCtpCfg = "CTP/Config/CtpCfg";
+  ClassDefNV(ctpCCDBManager, 2);
 };
 } // namespace ctp
 } // namespace o2

Detectors/CTP/workflowScalers/src/RunManager.cxx

@@ -122,7 +122,7 @@ int CTPRunManager::loadRun(const std::string& cfg)
   //
   mRunsLoaded[runnumber] = activerun;
   saveRunConfigToCCDB(&activerun->cfg, timeStamp);
-
+  saveCtpCfg(runnumber, timeStamp);
   return 0;
 }
 int CTPRunManager::setRunConfigBK(uint32_t runNumber, const std::string& cfg)
@@ -221,6 +221,9 @@ int CTPRunManager::addScalers(uint32_t irun, std::time_t time, bool start)
 int CTPRunManager::processMessage(std::string& topic, const std::string& message)
 {
   LOG(info) << "Processing message with topic:" << topic;
+  std::string ahoj = "ahoj kniznica";
+  mInfoLogger.logInfo(ahoj);
+  LOG(important) << " ahoj important";
   std::string firstcounters;
   if (topic.find("clear") != std::string::npos) {
     mRunsLoaded.clear();

Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx

@@ -167,6 +167,34 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   }
   return 0;
 }
+int ctpCCDBManager::saveCtpCfg(uint32_t runNumber, long timeStart)
+{
+  if (mCCDBHost == "none") {
+    LOG(info) << "CtpCfg not written to CCDB none";
+    return 0;
+  }
+  CtpCfg ctpcfg;
+  ctpcfg.readAndSave();
+  using namespace std::chrono_literals;
+  std::chrono::seconds days3 = 259200s;
+  std::chrono::seconds min10 = 600s;
+  long time3days = std::chrono::duration_cast<std::chrono::milliseconds>(days3).count();
+  long time10min = std::chrono::duration_cast<std::chrono::milliseconds>(min10).count();
+  long tmin = timeStart - time10min;
+  long tmax = timeStart + time3days;
+  o2::ccdb::CcdbApi api;
+  map<string, string> metadata; // can be empty
+  metadata["runNumber"] = std::to_string(runNumber);
+  api.init(mCCDBHost.c_str());  // or http://localhost:8080 for a local installation
+  // store abitrary user object in strongly typed manner
+  int ret = 0; //api.storeAsTFileAny(&vect, mCCDBPathCtpCfg, metadata, tmin, tmax);
+  if (ret == 0) {
+    LOG(info) << "CtpCfg  saved in ccdb:" << mCCDBHost << " tmin:" << tmin << " tmax:" << tmax;
+  } else {
+    LOG(error) << "CtpCfg Problem writing to database ret:" << ret;
+  }
+  return 0;
+}
 CTPConfiguration ctpCCDBManager::getConfigFromCCDB(long timestamp, std::string run, bool& ok)
 {
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();