dev: consistency checker

Author: lietava

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

@@ -173,7 +173,8 @@ 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;
+  uint64_t getTriggerClassMaskWInputs() const;
+  uint64_t getTriggerClassMaskWInputsNoTrgDets() const;
   std::vector<int> getTriggerClassList() const;
   uint32_t getRunNumber() { return mRunNumber; };
   std::vector<std::string> getDetectorList() const;

DataFormats/Detectors/CTP/src/Configuration.cxx

@@ -905,7 +905,7 @@ uint64_t CTPConfiguration::getTriggerClassMask() const
   }
   return clsmask;
 }
-uint64_t CTPConfiguration::getTriggerClassMaskOnlywInputs() const
+uint64_t CTPConfiguration::getTriggerClassMaskWInputs() const
 {
   uint64_t clsmask = 0;
   for (auto const& cls : mCTPClasses) {
@@ -916,6 +916,19 @@ uint64_t CTPConfiguration::getTriggerClassMaskOnlywInputs() const
   }
   return clsmask;
 }
+uint64_t CTPConfiguration::getTriggerClassMaskWInputsNoTrgDets() const
+{
+  uint64_t clsmask = 0;
+  for (auto const& cls : mCTPClasses) {
+    bool exclude = cls.name.find("TRUE") != std::string::npos; // ignoring internal ctp generators
+    exclude += cls.name.find("EMC") != std::string::npos; 
+    exclude += cls.name.find("TRD") != std::string::npos; 
+    exclude += cls.name.find("HMP") != std::string::npos; 
+    if(!exclude)
+      clsmask |= cls.classMask;
+  }
+  return clsmask;
+}
 // Hardware positions of classes
 std::vector<int> CTPConfiguration::getTriggerClassList() const
 {

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

@@ -55,9 +55,12 @@ class RawDataDecoder
   int init();
   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; }
+  int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> getClassErrorsA() {return mClassErrorsA; }
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> getClassErrorsB() { return mClassErrorsB; }
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> getClassCountersA() {return mClassCountersA; }
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> getClassCountersB() { return mClassCountersB; }
+  int getLostDueToShift() { return mLostDueToShift; }
  private:
   static constexpr uint32_t TF_TRIGGERTYPE_MASK = 0x800;
   static constexpr uint32_t HB_TRIGGERTYPE_MASK = 0x2;
@@ -86,8 +89,11 @@ class RawDataDecoder
   int mErrorTCR = 0;
   int mErrorMax = 5;
   bool mStickyError = false;
-  std::map<int,int> mClassErrors;
-  std::map<uint64_t,int> mInpErrors;
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> mClassErrorsA;
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> mClassErrorsB;   // from inputs
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> mClassCountersA;
+  std::array<uint64_t,o2::ctp::CTP_NCLASSES> mClassCountersB;  // from inputs
+  int mLostDueToShift = 0;
   CTPConfiguration mCTPConfig;
 };
 } // namespace ctp

Detectors/CTP/reconstruction/src/RawDataDecoder.cxx

@@ -294,13 +294,15 @@ int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2
   }
   if (mDoDigits & mDecodeInps) {
     uint64_t trgclassmask = 0xffffffffffffffff;
+    uint64_t trgclassmaskNOTRGDet = 0xffffffffffffffff;
     if (mCTPConfig.getRunNumber() != 0) {
-      trgclassmask = mCTPConfig.getTriggerClassMaskOnlywInputs();
+      trgclassmask = mCTPConfig.getTriggerClassMaskWInputs();
+      trgclassmaskNOTRGDet = mCTPConfig.getTriggerClassMaskWInputsNoTrgDets();
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
-    ret = shiftInputs(digitsMap, digits, mTFOrbit, trgclassmask);
+    ret = shiftInputs(digitsMap, digits, mTFOrbit);
     if (mCheckConsistency) {
-      ret = checkReadoutConsistentncy(digits, trgclassmask);
+      ret = checkReadoutConsistentncy(digits, trgclassmask, trgclassmaskNOTRGDet);
     }
   }
   if (mDoDigits && !mDecodeInps) {
@@ -592,10 +594,9 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
   return 0;
 }
 //
-int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask)
+int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
 {
   int ret = 0;
-  int lost = 0;
   static int nerror = 0;
   for (auto const& digit : digits) {
     // if class mask => inps
@@ -608,21 +609,20 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
           ret = 128;
           continue;
         }
+        mClassCountersA[i]++;
         uint64_t clsinpmask = cls->descriptor->getInputsMask();
         uint64_t diginpmask = digit.CTPInputMask.to_ullong();
         if (!((clsinpmask & diginpmask) == clsinpmask)) {
           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()]++;
+          mClassErrorsA[i]++;
           ret = 128;
         }
       }
     }
     // if inps => class mask
     for (auto const& cls : mCTPConfig.getCTPClasses()) {
-      uint64_t clsinpmask = cls.descriptor->getInputsMask();
+      uint64_t clsinpmask = cls.descriptor->getInputsMask();  // class definition
       uint64_t diginpmask = digit.CTPInputMask.to_ullong();
       uint64_t digclsmask = digit.CTPClassMask.to_ullong();
       if ((clsinpmask & diginpmask) == clsinpmask) {
@@ -631,21 +631,19 @@ 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) {
-            if(nerror < mErrorMax)
+            if((nerror < mErrorMax) && (cls.classMask & ~trgclassmaskNoTrgDet))
               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]++;
+            mClassErrorsB[cls.getIndex()]++;
             ret = 256;
           } else {
-            lost++;
+            mLostDueToShift++;
           }
         }
       }
     }
   }
-  if (lost) {
-    LOG(info) << "LOST classes because of shift:" << lost;
+  if (mLostDueToShift) {
+    LOG(debug) << "LOST classes because of shift:" << mLostDueToShift;
   }
   return ret;
 }

Detectors/CTP/workflow/src/RawDecoderSpec.cxx

@@ -71,6 +71,15 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
   std::cout << std::endl;
   LOG(info) << "Number of missing TF:" << nmiss << std::endl;
   LOG(info) << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsA = mDecoder.getClassCountersA();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsB = mDecoder.getClassCountersB();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEA = mDecoder.getClassErrorsA();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEB = mDecoder.getClassErrorsB();
+
+  for(int i = 0; i < o2::ctp::CTP_NCLASSES; i ++){
+    bool print = clsA[i] > 0 || clsB[i] > 0 || clsEA[i] > 0 || clsEB[i] > 0;
+    LOG(important) << "CLASS:" << i << " A:" << clsA[i] << " B:" << clsB[i] << " EA:" << clsEA[i] << " EB:" << clsEB[i];
+   }
 }
 void RawDecoderSpec::run(framework::ProcessingContext& ctx)
 {

Detectors/CTP/workflowScalers/CMakeLists.txt

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

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

@@ -18,7 +18,6 @@
 #include "DataFormatsCTP/Configuration.h"
 #include "BookkeepingApi/BkpClientFactory.h"
 #include "BookkeepingApi/BkpClient.h"
-#include <InfoLogger/InfoLogger.hxx>
 
 using namespace o2::bkp::api;
 namespace o2
@@ -73,7 +72,6 @@ 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/src/RunManager.cxx

@@ -221,9 +221,6 @@ 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();