Merge branch 'AliceO2Group:dev' into cholmcc_generatos

Author: Christian Holm Christensen

CCDB/include/CCDB/CCDBDownloader.h

@@ -29,8 +29,6 @@ typedef struct uv_signal_s uv_signal_t;
 typedef struct uv_async_s uv_async_t;
 typedef struct uv_handle_s uv_handle_t;
 
-using namespace std;
-
 namespace o2::ccdb
 {
 

Common/SimConfig/src/SimConfig.cxx

@@ -93,11 +93,12 @@ void SimConfig::determineActiveModules(std::vector<std::string> const& inputargs
 #ifdef ENABLE_UPGRADES
     if (mIsRun5) {
       for (int d = DetID::First; d <= DetID::Last; ++d) {
-        if (d == DetID::IT3 || d == DetID::TRK || d == DetID::FT3 || d == DetID::FCT) {
+        if (d == DetID::TRK || d == DetID::FT3 || d == DetID::FCT) {
           activeModules.emplace_back(DetID::getName(d));
         }
       }
       activeModules.emplace_back("A3IP");
+      activeModules.emplace_back("A3ABSO");
     } else {
 #endif
       // add passive components manually (make a PassiveDetID for them!)

Common/Utils/include/CommonUtils/ConfigurableParam.h

@@ -15,6 +15,7 @@
 #define COMMON_SIMCONFIG_INCLUDE_SIMCONFIG_CONFIGURABLEPARAM_H_
 
 #include <vector>
+#include <cassert>
 #include <map>
 #include <unordered_map>
 #include <boost/property_tree/ptree.hpp>

Common/Utils/include/CommonUtils/ShmManager.h

@@ -23,10 +23,12 @@
 #include <cstddef>
 #include <atomic>
 
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
 #include <boost/interprocess/managed_external_buffer.hpp>
 #include <boost/interprocess/allocators/allocator.hpp>
+#endif
 
-#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__) && !defined(__APPLE__)
 // this shared mem mode is meant for compiled stuff in o2-sim; not for ROOT sessions
 #define USESHM 1
 #endif
@@ -116,8 +118,10 @@ class ShmManager
   void* tryAttach(bool& success);
   size_t getPointerOffset(void* ptr) const { return (size_t)((char*)ptr - (char*)mBufferPtr); }
 
+#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
   boost::interprocess::wmanaged_external_buffer* boostmanagedbuffer;
   boost::interprocess::allocator<char, boost::interprocess::wmanaged_external_buffer::segment_manager>* boostallocator;
+#endif
 };
 
 } // namespace utils

Common/Utils/src/ShmManager.cxx

@@ -119,8 +119,8 @@ bool ShmManager::createGlobalSegment(int nsegments)
     return false;
   }
 
-  LOG(info) << "CREATING SIM SHARED MEM SEGMENT FOR " << nsegments << " WORKERS";
 #ifdef USESHM
+  LOG(info) << "CREATING SIM SHARED MEM SEGMENT FOR " << nsegments << " WORKERS";
   // LOG(info) << "SIZEOF ShmMetaInfo " << sizeof(ShmMetaInfo);
   const auto totalsize = sizeof(ShmMetaInfo) + SHMPOOLSIZE * nsegments;
   if ((mShmID = shmget(IPC_PRIVATE, totalsize, IPC_CREAT | 0666)) == -1) {

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

@@ -29,13 +29,16 @@ namespace ctp
 struct CTFHeader : public o2::ctf::CTFDictHeader {
   uint64_t lumiCounts = 0;    /// FT0 Luminosity counts moving average over lumiNHBFs orbits
   uint64_t lumiCountsFV0 = 0; /// FV0 Luminosity counts moving average over lumiNHBFs orbits
-  uint32_t lumiNHBFs = 0;  /// Number of HBFs over which lumi is integrated
-  uint32_t lumiOrbit = 0;  /// 1st orbit of TF where lumi was updated, can be compared with firstOrbit
-  uint32_t nTriggers = 0;  /// number of triggers
-  uint32_t firstOrbit = 0; /// orbit of 1st trigger
-  uint16_t firstBC = 0;    /// bc of 1st trigger
-
-  ClassDefNV(CTFHeader, 3);
+  uint32_t lumiNHBFs = 0;     /// Number of HBFs over which lumi is integrated
+  uint32_t lumiNHBFsFV0 = 0;  /// Number of FV0 HBFs over which lumi is integrated
+  uint32_t lumiOrbit = 0;     /// 1st orbit of TF where lumi was updated, can be compared with firstOrbit
+  uint32_t nTriggers = 0;     /// number of triggers
+  uint32_t firstOrbit = 0;    /// orbit of 1st trigger
+  uint16_t firstBC = 0;       /// bc of 1st trigger
+  uint16_t inp1 = 0;          /// lumiCounts input ID
+  uint16_t inp2 = 0;          /// lumiCountsFV0 input ID
+
+  ClassDefNV(CTFHeader, 5);
 };
 
 /// wrapper for the Entropy-encoded trigger inputs and classes of the TF

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

@@ -32,8 +32,10 @@ struct LumiInfo {
   int inp2 = 6;             // VBA
   float getLumi() const { return nHBFCounted > 0 ? float(counts / (nHBFCounted * o2::constants::lhc::LHCOrbitMUS * 1e-6)) : 0.f; }
   float getLumiFV0() const { return nHBFCountedFV0 > 0 ? float(countsFV0 / (nHBFCountedFV0 * o2::constants::lhc::LHCOrbitMUS * 1e-6)) : 0.f; }
+  float getLumiAlt() const { return getLumiFV0(); }
   float getLumiError() const { return nHBFCounted > 0 ? float(std::sqrt(counts) / (nHBFCounted * o2::constants::lhc::LHCOrbitMUS * 1e-6)) : 0.f; }
   float getLumiFV0Error() const { return nHBFCountedFV0 > 0 ? float(std::sqrt(countsFV0) / (nHBFCountedFV0 * o2::constants::lhc::LHCOrbitMUS * 1e-6)) : 0.f; }
+  float getLumiAltError() const { return getLumiFV0Error(); }
   void printInputs() const;
   ClassDefNV(LumiInfo, 3);
 };

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

@@ -67,19 +67,21 @@ struct CTPScalerRecordRaw {
   o2::InteractionRecord intRecord;
   double_t epochTime;
   std::vector<CTPScalerRaw> scalers;
-  std::vector<uint32_t> scalersDets;
+  // std::vector<uint32_t> scalersDets;
+  std::vector<uint32_t> scalersInps;
   void printStream(std::ostream& stream) const;
-  ClassDefNV(CTPScalerRecordRaw, 3);
+  ClassDefNV(CTPScalerRecordRaw, 4);
 };
 struct CTPScalerRecordO2 {
   CTPScalerRecordO2() = default;
   o2::InteractionRecord intRecord;
   double_t epochTime;
   std::vector<CTPScalerO2> scalers;
-  std::vector<uint64_t> scalersDets;
+  // std::vector<uint64_t> scalersDets;
+  std::vector<uint64_t> scalersInps;
   void printStream(std::ostream& stream) const;
   void printFromZero(std::ostream& stream, CTPScalerRecordO2& record0) const;
-  ClassDefNV(CTPScalerRecordO2, 3);
+  ClassDefNV(CTPScalerRecordO2, 4);
 };
 class CTPRunScalers
 {
@@ -103,6 +105,8 @@ class CTPRunScalers
   uint32_t getRunNUmber() { return mRunNumber; };
   int printRates();
   int printIntegrals();
+  int printInputRateAndIntegral(int inp);
+  int printClassBRateAndIntegral(int icls);
   //
   // static constexpr uint32_t NCOUNTERS = 1052;
   // v1
@@ -144,10 +148,10 @@ class CTPRunScalers
   std::vector<CTPScalerRecordRaw> mScalerRecordRaw;
   std::vector<CTPScalerRecordO2> mScalerRecordO2;
   int processScalerLine(const std::string& line, int& level, int& nclasses);
-  int copyRawToO2ScalerRecord(const CTPScalerRecordRaw& rawrec, CTPScalerRecordO2& o2rec, overflows_t& classesoverflows);
+  int copyRawToO2ScalerRecord(const CTPScalerRecordRaw& rawrec, CTPScalerRecordO2& o2rec, overflows_t& classesoverflows, std::array<uint32_t, 48>& overflows);
   int updateOverflows(const CTPScalerRecordRaw& rec0, const CTPScalerRecordRaw& rec1, overflows_t& classesoverflows) const;
   int updateOverflows(const CTPScalerRaw& scal0, const CTPScalerRaw& scal1, std::array<uint32_t, 6>& overflow) const;
-
+  int updateOverflowsInps(const CTPScalerRecordRaw& rec0, const CTPScalerRecordRaw& rec1, std::array<uint32_t, 48>& overflow) const;
   ClassDefNV(CTPRunScalers, 2);
 };
 } // namespace ctp

DataFormats/Detectors/CTP/src/RunManager.cxx

@@ -122,6 +122,7 @@ int CTPRunManager::addScalers(uint32_t irun, std::time_t time)
   }
   // detectors
   // std::vector<std::string> detlist = mActiveRuns[irun]->cfg.getDetectorList();
+  /*
   o2::detectors::DetID::mask_t detmask = mActiveRuns[irun]->cfg.getDetectorMask();
   for (uint32_t i = 0; i < 32; i++) {
     o2::detectors::DetID::mask_t deti = 1ul << i;
@@ -134,6 +135,14 @@ int CTPRunManager::addScalers(uint32_t irun, std::time_t time)
       // LOG(info) << "Scaler for detector:" << countername << ":" << detcount;
     }
   }
+  */
+  int NINPS = 48;
+  int offset = 599;
+  for (uint32_t i = 0; i < NINPS; i++) {
+    uint32_t inpcount = mCounters[offset + i];
+    scalrec.scalersInps.push_back(inpcount);
+    // LOG(info) << "Scaler for input:" << CTPRunScalers::scalerNames[offset+i] << ":" << inpcount;
+  }
   //
   if (mNew == 0) {
     scalrec.intRecord.orbit = mCounters[mScalerName2Position[orb]];

DataFormats/Detectors/CTP/src/Scalers.cxx

@@ -65,7 +65,8 @@ void CTPScalerRecordRaw::printStream(std::ostream& stream) const
   for (auto const& cnts : scalers) {
     cnts.printStream(stream);
   }
-  for (auto const& dets : scalersDets) {
+  std::cout << "Inputs:" << scalersInps.size() << std::endl;
+  for (auto const& dets : scalersInps) {
     stream << dets << " ";
   }
   stream << std::endl;
@@ -77,7 +78,8 @@ void CTPScalerRecordO2::printStream(std::ostream& stream) const
   for (auto const& cnts : scalers) {
     cnts.printStream(stream);
   }
-  for (auto const& dets : scalersDets) {
+  std::cout << "Inputs:" << scalersInps.size() << std::endl;
+  for (auto const& dets : scalersInps) {
     stream << dets << " ";
   }
   stream << std::endl;
@@ -273,10 +275,12 @@ int CTPRunScalers::convertRawToO2()
       overflows[i] = {0, 0, 0, 0, 0, 0};
     }
   }
+  // Input overflows
+  std::array<uint32_t, 48> overflowsInputs = {48 * 0};
   errorCounters eCnts;
   // 1st o2 rec is just copy
   CTPScalerRecordO2 o2rec;
-  copyRawToO2ScalerRecord(mScalerRecordRaw[0], o2rec, overflows);
+  copyRawToO2ScalerRecord(mScalerRecordRaw[0], o2rec, overflows, overflowsInputs);
   mScalerRecordO2.push_back(o2rec);
   int j = 1;
   for (uint32_t i = 1; i < mScalerRecordRaw.size(); i++) {
@@ -285,7 +289,8 @@ int CTPRunScalers::convertRawToO2()
     //
     if (ret == 0) {
       CTPScalerRecordO2 o2rec;
-      copyRawToO2ScalerRecord(mScalerRecordRaw[i], o2rec, overflows);
+      ret = updateOverflowsInps(mScalerRecordRaw[i - 1], mScalerRecordRaw[i], overflowsInputs);
+      copyRawToO2ScalerRecord(mScalerRecordRaw[i], o2rec, overflows, overflowsInputs);
       mScalerRecordO2.push_back(o2rec);
       // Check consistency
       checkConsistency(mScalerRecordO2[j - 1], mScalerRecordO2[j], eCnts);
@@ -295,7 +300,7 @@ int CTPRunScalers::convertRawToO2()
   eCnts.printStream(std::cout);
   return 0;
 }
-int CTPRunScalers::copyRawToO2ScalerRecord(const CTPScalerRecordRaw& rawrec, CTPScalerRecordO2& o2rec, overflows_t& classesoverflows)
+int CTPRunScalers::copyRawToO2ScalerRecord(const CTPScalerRecordRaw& rawrec, CTPScalerRecordO2& o2rec, overflows_t& classesoverflows, std::array<uint32_t, 48>& overflows)
 {
   if (rawrec.scalers.size() != (mClassMask.count())) {
     LOG(error) << "Inconsistent scaler record size:" << rawrec.scalers.size() << " Expected:" << mClassMask.count();
@@ -313,6 +318,10 @@ int CTPRunScalers::copyRawToO2ScalerRecord(const CTPScalerRecordRaw& rawrec, CTP
     o2scal.createCTPScalerO2FromRaw(rawscal, classesoverflows[k]);
     o2rec.scalers.push_back(o2scal);
   }
+  for (int i = 0; i < rawrec.scalersInps.size(); i++) {
+    uint64_t inpo2 = (uint64_t)(rawrec.scalersInps[i]) + 0xffffffffull * (uint64_t)(overflows[i]);
+    o2rec.scalersInps.push_back(inpo2);
+  }
   return 0;
 }
 int CTPRunScalers::checkConsistency(const CTPScalerO2& scal0, const CTPScalerO2& scal1, errorCounters& eCnts) const
@@ -452,6 +461,26 @@ int CTPRunScalers::updateOverflows(const CTPScalerRaw& scal0, const CTPScalerRaw
   //std::cout << std::endl;
   return 0;
 }
+//
+int CTPRunScalers::updateOverflowsInps(const CTPScalerRecordRaw& rec0, const CTPScalerRecordRaw& rec1, std::array<uint32_t, 48>& overflow) const
+{
+  int NINPS = 48;
+  if (rec0.scalersInps.size() < NINPS) {
+    LOG(error) << "updateOverflowsInps.size < 48:" << rec0.scalersInps.size();
+    return 1;
+  }
+  if (rec1.scalersInps.size() < NINPS) {
+    LOG(error) << "updateOverflowsInps.size < 48:" << rec1.scalersInps.size();
+    return 2;
+  }
+  for (int i = 0; i < NINPS; i++) {
+    if (rec0.scalersInps[i] > rec1.scalersInps[i]) {
+      overflow[i] += 1;
+    }
+  }
+  return 0;
+}
+//
 int CTPRunScalers::printRates()
 {
   if (mScalerRecordO2.size() == 0) {
@@ -507,7 +536,42 @@ int CTPRunScalers::printIntegrals()
   }
   return 0;
 }
-
+//
+// Input counting 1..48
+int CTPRunScalers::printInputRateAndIntegral(int inp)
+{
+  if (mScalerRecordO2.size() == 0) {
+    LOG(info) << "ScalerRecord is empty, doing nothing";
+    return 1;
+  }
+  double_t time0 = mScalerRecordO2[0].epochTime;
+  double_t timeL = mScalerRecordO2[mScalerRecordO2.size() - 1].epochTime;
+  int integral = mScalerRecordO2[mScalerRecordO2.size() - 1].scalersInps[inp - 1] - mScalerRecordO2[0].scalersInps[inp - 1];
+  std::cout << "Scaler Integrals for run:" << mRunNumber << " duration:" << timeL - time0;
+  std::cout << " Input " << inp << " integral:" << integral << " rate:" << integral / (timeL - time0) << std::endl;
+  return 0;
+}
+// Prints class before counters for lumi
+// Class counting 1..64
+int CTPRunScalers::printClassBRateAndIntegral(int icls)
+{
+  if (mScalerRecordO2.size() == 0) {
+    LOG(info) << "ScalerRecord is empty, doing nothing";
+    return 1;
+  }
+  double_t time0 = mScalerRecordO2[0].epochTime;
+  double_t timeL = mScalerRecordO2[mScalerRecordO2.size() - 1].epochTime;
+  if (mScalerRecordO2[0].scalers.size() < icls) {
+    LOG(error) << "class number bigger than expected for this run:" << icls << "expexted smaller than:" << mScalerRecordO2[0].scalers.size();
+    return 1;
+  } else {
+    int integral = mScalerRecordO2[mScalerRecordO2.size() - 1].scalers[icls - 1].lmBefore - mScalerRecordO2[0].scalers[icls - 1].lmBefore;
+    std::cout << "Scaler Integrals for run:" << mRunNumber << " duration:" << timeL - time0;
+    std::cout << " Class " << icls << " integral:" << integral << " rate:" << integral / (timeL - time0) << std::endl;
+  }
+  return 0;
+}
+//
 void CTPRunScalers::printLMBRateVsT() const
 {
   for (int i = 1; i < mScalerRecordO2.size(); i++) { // loop over time