Merge pull request AliceO2Group#1 from ktf/remote-gui

Remote gui

Author: Zowlyfon

CCDB/src/BasicCCDBManager.cxx

@@ -34,9 +34,9 @@ void CCDBManagerInstance::reportFatal(std::string_view err)
 
 std::pair<uint64_t, uint64_t> CCDBManagerInstance::getRunDuration(int runnumber) const
 {
-  auto response = mCCDBAccessor.retrieveHeaders("RCT/RunInformation", std::map<std::string, std::string>(), runnumber);
+  auto response = mCCDBAccessor.retrieveHeaders("RCT/Info/RunInformation", std::map<std::string, std::string>(), runnumber);
   if (response.size() == 0 || response.find("SOR") == response.end() || response.find("EOR") == response.end()) {
-    LOG(fatal) << "Empty or missing response from query to RCT/RunInformation for run " << runnumber;
+    LOG(fatal) << "Empty or missing response from query to RCT/Info/RunInformation for run " << runnumber;
   }
   auto sor = boost::lexical_cast<uint64_t>(response["SOR"]);
   auto eor = boost::lexical_cast<uint64_t>(response["EOR"]);

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

@@ -29,7 +29,6 @@ namespace ctp
 {
 /// Database constants
 const std::string CCDBPathCTPConfig = "CTP/Config/Config";
-const std::string CCDBPathCTPScalers = "CTP/Scalers";
 ///
 /// CTP Config items
 struct BCMask {
@@ -69,6 +68,7 @@ struct CTPDescriptor {
 struct CTPDetector {
   CTPDetector() = default;
   o2::detectors::DetID::ID detID;
+  o2::detectors::DetID::mask_t getMask() const { return o2::detectors::DetID(detID).getMask(); }
   const char* getName() const { return o2::detectors::DetID::getName(detID); }
   uint32_t HBaccepted; /// Number of HB frames in TF to be accepted
   std::string mode = "";
@@ -92,13 +92,14 @@ struct CTPClass {
   CTPDescriptor const* descriptor = nullptr;
   CTPCluster const* cluster = nullptr;
   int clusterIndex = 0;
-  ;
+  int descriptorIndex = 0;
   void printStream(std::ostream& strem) const;
-  ClassDefNV(CTPClass, 2);
+  ClassDefNV(CTPClass, 3);
 };
 class CTPConfiguration
 {
  public:
+  const static std::map<std::string, std::string> detName2LTG;
   CTPConfiguration() = default;
   bool isDetector(const o2::detectors::DetID& det);
   void capitaliseString(std::string& str);
@@ -112,13 +113,6 @@ class CTPConfiguration
                     CLASS,
                     UNKNOWN };
   int loadConfigurationRun3(const std::string& ctpconfiguartion);
-  int loadConfiguration(const std::string& ctpconfiguartion);
-  void addBCMask(const BCMask& bcmask);
-  void addCTPInput(const CTPInput& input);
-  void addCTPDescriptor(const CTPDescriptor& descriptor);
-  void addCTPDetector(const CTPDetector& detector);
-  void addCTPCluster(const CTPCluster& cluster);
-  void addCTPClass(const CTPClass& ctpclass);
   void printStream(std::ostream& stream) const;
   std::vector<CTPInput>& getCTPInputs() { return mInputs; }
   std::vector<CTPClass>& getCTPClasses() { return mCTPClasses; }
@@ -131,6 +125,8 @@ class CTPConfiguration
   uint64_t getTriggerClassMask() const;
   std::vector<int> getTriggerClassList() const;
   uint32_t getRunNumber() { return mRunNumber; };
+  std::vector<std::string> getDetectorList() const;
+  o2::detectors::DetID::mask_t getDetectorMask() const;
 
  private:
   std::string mConfigString = "";
@@ -145,8 +141,7 @@ class CTPConfiguration
   std::vector<CTPCluster> mClusters;
   std::vector<CTPClass> mCTPClasses;
   int processConfigurationLineRun3(std::string& line, int& level);
-  int processConfigurationLine(std::string& line, int& level);
-  ClassDefNV(CTPConfiguration, 4);
+  ClassDefNV(CTPConfiguration, 5);
 };
 // Run Manager
 struct CTPActiveRun {
@@ -168,21 +163,29 @@ class CTPRunManager
   void printActiveRuns() const;
   int saveRunScalersToCCDB(int i);
   int saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart);
-  int getConfigFromCCDB();
-  int getScalersFromCCDB();
+  CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
+  CTPRunScalers getScalersFromCCDB(long timestamp, std::string);
   int loadScalerNames();
-  void setCcdbHost(std::string host) { mCcdbHost = host; };
+  // void setCCDBPathConfig(std::string path) { mCCDBPathCTPConfig = path;};
+  void setCCDBPathScalers(std::string path) { mCCDBPathCTPScalers = path; };
+  void setCCDBHost(std::string host) { mCCDBHost = host; };
+  void setCTPQC(int qc) { mQC = qc; };
+  void printCounters();
 
  private:
-  std::string mCcdbHost = "http://ccdb-test.cern.ch:8080";
+  /// Database constants
+  // std::string mCCDBHost = "http://ccdb-test.cern.ch:8080";
+  std::string mCCDBHost = "http://o2-ccdb.internal:8080";
+  std::string mCCDBPathCTPScalers = "CTP/Calib/Scalers";
   std::array<CTPActiveRun*, NRUNS> mActiveRuns;
   std::array<std::uint32_t, NRUNS> mActiveRunNumbers;
   std::array<uint32_t, CTPRunScalers::NCOUNTERS> mCounters;
   std::map<std::string, uint32_t> mScalerName2Position;
   CTPActiveRun* mRunInStart = nullptr;
   int mEOX = 0; // redundancy check
   int mCtpcfg = 0;
-  ClassDefNV(CTPRunManager, 2);
+  int mQC = 0; // 1 - no CCDB: used for QC
+  ClassDefNV(CTPRunManager, 4);
 };
 } // namespace ctp
 } // namespace o2

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

@@ -57,18 +57,20 @@ struct CTPScalerO2 {
 struct CTPScalerRecordRaw {
   CTPScalerRecordRaw() = default;
   o2::InteractionRecord intRecord;
-  uint64_t epochTime;
+  double_t epochTime;
   std::vector<CTPScalerRaw> scalers;
+  std::vector<uint32_t> scalersDets;
   void printStream(std::ostream& stream) const;
-  ClassDefNV(CTPScalerRecordRaw, 1);
+  ClassDefNV(CTPScalerRecordRaw, 3);
 };
 struct CTPScalerRecordO2 {
   CTPScalerRecordO2() = default;
   o2::InteractionRecord intRecord;
-  uint64_t epochTime;
+  double_t epochTime;
   std::vector<CTPScalerO2> scalers;
+  std::vector<uint64_t> scalersDets;
   void printStream(std::ostream& stream) const;
-  ClassDefNV(CTPScalerRecordO2, 1);
+  ClassDefNV(CTPScalerRecordO2, 3);
 };
 class CTPRunScalers
 {
@@ -82,27 +84,32 @@ class CTPRunScalers
   int checkConsistency(const CTPScalerO2& scal0, const CTPScalerO2& scal1) const;
   int checkConsistency(const CTPScalerRecordO2& rec0, const CTPScalerRecordO2& rec1) const;
   void setClassMask(std::bitset<CTP_NCLASSES> classMask) { mClassMask = classMask; };
+  void setDetectorMask(o2::detectors::DetID::mask_t mask) { mDetectorMask = mask; };
   void setRunNumber(uint32_t rnumber) { mRunNumber = rnumber; };
+  void addScalerRacordRaw(CTPScalerRecordRaw& scalerrecordraw) { mScalerRecordRaw.push_back(scalerrecordraw); };
+  int printRates();
+  int printIntegrals();
   //
-  int parseZMQScalers(std::string zmqscalers);
-  static constexpr uint32_t NCOUNTERS = 1052;
+  // static constexpr uint32_t NCOUNTERS = 1052;
+  static constexpr uint32_t NCOUNTERS = 1070;
   static std::vector<std::string> scalerNames;
 
  private:
   // map from class index to overflow
   // overflow counts how many time class scalerers overflowed
   typedef std::map<uint32_t, std::array<uint32_t, 6>> overflows_t;
-  int mVersion;
-  uint32_t mRunNumber;
+  int mVersion = 0;
+  uint32_t mRunNumber = 0;
   // using class mask for all class index related stuff
   std::bitset<CTP_NCLASSES> mClassMask;
+  o2::detectors::DetID::mask_t mDetectorMask;
   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 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;
-  ClassDefNV(CTPRunScalers, 1);
+  ClassDefNV(CTPRunScalers, 2);
 };
 } // namespace ctp
 } // namespace o2