Implementation of macros for fetching and conversion of FIT LUT [AFIT-126]

Detectors/FIT/macros/CMakeLists.txt

@@ -49,5 +49,27 @@ o2_add_test_root_macro(readAlignParam.C
                        PUBLIC_LINK_LIBRARIES O2::CCDB
                        LABELS fit)
 
+o2_add_test_root_macro(compareLut.C
+                        PUBLIC_LINK_LIBRARIES O2::DataFormatsFIT
+                        LABELS fit)
+
+o2_add_test_root_macro(createLutFromCsv.C
+                        PUBLIC_LINK_LIBRARIES O2::DataFormatsFIT
+                                                O2::CommonUtils
+                        LABELS fit)
+
+o2_add_test_root_macro(fetchLut.C
+                        PUBLIC_LINK_LIBRARIES O2::DataFormatsFIT
+                                                O2::CCDB
+                        LABELS fit)
+
+o2_add_test_root_macro(convertLutToCsv.C
+                        PUBLIC_LINK_LIBRARIES O2::DataFormatsFIT
+                        LABELS fit)
+
+o2_add_test_root_macro(printLut.C
+                        PUBLIC_LINK_LIBRARIES O2::DataFormatsFIT
+                        LABELS fit)
+
 o2_data_file(COPY readFITDCSdata.C DESTINATION Detectors/FIT/macros/)
 o2_data_file(COPY readFITDeadChannelMap.C DESTINATION Detectors/FIT/macros/)

Detectors/FIT/macros/compareLut.C

@@ -0,0 +1,110 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <array>
+
+R__LOAD_LIBRARY(libO2CommonUtils)
+R__LOAD_LIBRARY(libO2DataFormatsFIT)
+
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsFIT/LookUpTable.h"
+#include "Framework/Logger.h"
+#include "CommonConstants/LHCConstants.h"
+#include "lut.h"
+
+#endif
+
+namespace compare_lut
+{
+std::vector<o2::fit::EntryFEE> readLutFromFile(const std::string filePath, const std::string objectName)
+{
+  TFile file(filePath.c_str(), "READ");
+  if (file.IsOpen() == false) {
+    std::cerr << "Failed to open " << filePath << std::endl;
+    return {};
+  }
+  std::cout << "Successfully opened " << std::endl
+            << filePath;
+
+  std::vector<o2::fit::EntryFEE>* lut = nullptr;
+  file.GetObject<std::vector<o2::fit::EntryFEE>>(objectName.c_str(), lut);
+
+  if (lut == nullptr) {
+    std::cerr << "Failed to read object " << objectName << std::endl;
+    return {};
+  }
+  std::cout << "Successfully get " << objectName << " object" << std::endl;
+
+  std::vector<o2::fit::EntryFEE> lutCopy = *lut;
+  file.Close();
+
+  return std::move(lutCopy);
+}
+} // namespace compare_lut
+
+inline bool operator==(const o2::fit::EntryFEE& lhs, const o2::fit::EntryFEE& rhs)
+{
+  auto comparer = [](const o2::fit::EntryFEE& e) {
+    return std::tie(
+      e.mEntryCRU.mLinkID, e.mEntryCRU.mEndPointID, e.mEntryCRU.mCRUID, e.mEntryCRU.mFEEID,
+      e.mChannelID, e.mLocalChannelID, e.mModuleType, e.mModuleName,
+      e.mBoardHV, e.mChannelHV, e.mSerialNumberMCP, e.mCableHV, e.mCableSignal);
+  };
+  return comparer(lhs) == comparer(rhs);
+}
+
+void compareLut(const std::string fileA, const std::string fileB, const bool compareEvenForDifferentSize = false, const std::string objectName = "ccdb_object")
+{
+  std::vector<o2::fit::EntryFEE> lutA = compare_lut::readLutFromFile(fileA, objectName);
+  std::vector<o2::fit::EntryFEE> lutB = compare_lut::readLutFromFile(fileB, objectName);
+  if (lutA.empty() || lutB.empty()) {
+    return;
+  }
+
+  bool lutAreSame = true;
+
+  if (lutA.size() != lutB.size()) {
+    std::cerr << "Different number of entries: " << lutA.size() << " for " << fileA << " vs " << lutB.size() << " for file " << fileB.c_str() << std::endl;
+    lutAreSame = false;
+    if (compareEvenForDifferentSize == false) {
+      return;
+    }
+  }
+
+  size_t size = (lutA.size() < lutB.size()) ? lutA.size() : lutB.size();
+
+  std::cout << "--- Comparision ---" << std::endl;
+
+  for (size_t idx = 0; idx < size; idx++) {
+    if (lutA[idx] == lutB[idx]) {
+      continue;
+    } else {
+      std::cout << "Entry " << idx << " in " << fileA << " entry: " << lutA[idx] << std::endl;
+      std::cout << "Entry " << idx << " in " << fileB << " entry: " << lutB[idx] << std::endl;
+      lutAreSame = false;
+    }
+  }
+
+  for (size_t idx = size; idx < lutA.size(); idx++) {
+    std::cout << "Extra entry " << idx << " in " << fileA << ": " << lutA[idx] << std::endl;
+  }
+
+  for (size_t idx = size; idx < lutB.size(); idx++) {
+    std::cout << "Extra entry " << idx << " in " << fileB << ": " << lutB[idx] << std::endl;
+  }
+
+  if (lutAreSame) {
+    std::cout << "LUTs are the same!" << std::endl;
+  } else {
+    std::cout << "LUTs are different!" << std::endl;
+  }
+}

Detectors/FIT/macros/convertLutToCsv.C

@@ -0,0 +1,88 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <array>
+#include <ranges>
+
+R__LOAD_LIBRARY(libO2CommonUtils)
+R__LOAD_LIBRARY(libO2DataFormatsFIT)
+
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsFIT/LookUpTable.h"
+#include "Framework/Logger.h"
+#include "CommonConstants/LHCConstants.h"
+#include "lut.h"
+
+#endif
+
+namespace convert_lut_to_csv
+{
+std::vector<o2::fit::EntryFEE> readLutFromFile(const std::string filePath, const std::string objectName)
+{
+  TFile file(filePath.c_str(), "READ");
+  if (file.IsOpen() == false) {
+    std::cerr << "Failed to open " << filePath << std::endl;
+    return {};
+  }
+  std::cout << "Successfully opened " << std::endl
+            << filePath;
+
+  std::vector<o2::fit::EntryFEE>* lut = nullptr;
+  file.GetObject<std::vector<o2::fit::EntryFEE>>(objectName.c_str(), lut);
+
+  if (lut == nullptr) {
+    std::cerr << "Failed to read object " << objectName << std::endl;
+    return {};
+  }
+  std::cout << "Successfully get " << objectName << " object" << std::endl;
+
+  std::vector<o2::fit::EntryFEE> lutCopy = *lut;
+  file.Close();
+
+  return std::move(lutCopy);
+}
+} // namespace convert_lut_to_csv
+
+void saveToCSV(const std::vector<o2::fit::EntryFEE>& lut, const std::string& path)
+{
+  std::ofstream ofs(path.data());
+  if (!ofs.is_open()) {
+    std::cerr << "Cannot open file for writing: " << path << std::endl;
+    return;
+  }
+  ofs << "LinkID,EndPointID,CRUID,FEEID,ModuleType,LocalChannelID,channel #,Module,HV board,HV channel,MCP S/N,HV cable,signal cable\n";
+  for (const auto& entry : lut) {
+    ofs << entry.mEntryCRU.mLinkID << ","
+        << entry.mEntryCRU.mEndPointID << ","
+        << entry.mEntryCRU.mCRUID << ","
+        << entry.mEntryCRU.mFEEID << ","
+        << entry.mModuleType << ","
+        << entry.mLocalChannelID << ","
+        << entry.mChannelID << ","
+        << entry.mModuleName << ","
+        << entry.mBoardHV << ","
+        << entry.mChannelHV << ","
+        << entry.mSerialNumberMCP << ","
+        << entry.mCableHV << ","
+        << entry.mCableSignal << "\n";
+  }
+  ofs.close();
+}
+
+void convertLutToCsv(const std::string fileName, const std::string objectName, const std::string csvName)
+{
+  if (fileName.empty() || objectName.empty() || csvName.empty()) {
+    return;
+  }
+  std::vector<o2::fit::EntryFEE> lut = convert_lut_to_csv::readLutFromFile(fileName, objectName);
+  saveToCSV(lut, csvName);
+}

Detectors/FIT/macros/createLutFromCsv.C

@@ -0,0 +1,93 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <array>
+#include <ranges>
+
+R__LOAD_LIBRARY(libO2CommonUtils)
+R__LOAD_LIBRARY(libO2CCDB)
+R__LOAD_LIBRARY(libO2DataFormatsFIT)
+
+#include "DataFormatsFIT/LookUpTable.h"
+#include "Framework/Logger.h"
+#include "CommonConstants/LHCConstants.h"
+#endif
+
+namespace create_lut_from_csv
+{
+void saveToRoot(std::vector<o2::fit::EntryFEE>& lut, const std::string& path)
+{
+  TFile file(path.data(), "RECREATE");
+  if (file.IsOpen() == false) {
+    std::cerr << "Failed to open file " << path << std::endl;
+    return;
+  }
+
+  file.WriteObject(&lut, "ccdb_object");
+  file.Close();
+}
+} // namespace create_lut_from_csv
+
+void createLutFromCsv(const std::string csvFilePath, const std::string rootFilePath)
+{
+  std::vector<o2::fit::EntryFEE> lut;
+  std::ifstream lutCSV(csvFilePath);
+  if (lutCSV.is_open() == false) {
+    std::cerr << "Failed to open file " << csvFilePath << std::endl;
+    return;
+  }
+
+  std::string line;
+  std::getline(lutCSV, line);
+  std::map<std::string, int> headerMap;
+
+  auto headersView = std::string_view(line) | std::views::split(',');
+
+  int index = 0;
+  for (auto&& rng : headersView) {
+    std::string columnName(rng.begin(), rng.end());
+    headerMap[columnName] = index++;
+  }
+
+  while (std::getline(lutCSV, line)) {
+    if (line.size() == 0) {
+      return;
+    }
+    o2::fit::EntryFEE entry;
+    auto fieldViews = std::string_view(line) | std::views::split(',');
+    std::vector<std::string> parsedLine;
+    for (auto&& view : fieldViews) {
+      parsedLine.emplace_back(view.begin(), view.end());
+    }
+    if (parsedLine.size() < headerMap.size()) {
+      std::cerr << "Ill-formed line: " << line << std::endl;
+      return;
+    }
+
+    entry.mEntryCRU.mLinkID = std::stoi(parsedLine[headerMap.at("LinkID")]);
+    entry.mEntryCRU.mEndPointID = std::stoi(parsedLine[headerMap.at("EndPointID")]);
+    entry.mEntryCRU.mCRUID = std::stoi(parsedLine[headerMap.at("CRUID")]);
+    entry.mEntryCRU.mFEEID = std::stoi(parsedLine[headerMap.at("FEEID")]);
+
+    entry.mModuleType = parsedLine[headerMap.at("ModuleType")];
+    entry.mLocalChannelID = parsedLine[headerMap.at("LocalChannelID")];
+    entry.mChannelID = parsedLine[headerMap.at("channel #")];
+    entry.mModuleName = parsedLine[headerMap.at("Module")];
+    entry.mBoardHV = parsedLine[headerMap.at("HV board")];
+    entry.mChannelHV = parsedLine[headerMap.at("HV channel")];
+    entry.mSerialNumberMCP = parsedLine[headerMap.at("MCP S/N")];
+    entry.mCableHV = parsedLine[headerMap.at("HV cable")];
+    entry.mCableSignal = parsedLine[headerMap.at("signal cable")];
+    lut.emplace_back(entry);
+  }
+  create_lut_from_csv::saveToRoot(lut, rootFilePath);
+}

Detectors/FIT/macros/fetchLut.C

@@ -0,0 +1,73 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <array>
+#include <ranges>
+
+R__LOAD_LIBRARY(libO2CommonUtils)
+R__LOAD_LIBRARY(libO2CCDB)
+R__LOAD_LIBRARY(libO2DataFormatsFIT)
+
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsFIT/LookUpTable.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "Framework/Logger.h"
+#include "CommonConstants/LHCConstants.h"
+
+#endif
+
+namespace
+{
+void saveToRoot(std::shared_ptr<std::vector<o2::fit::EntryFEE>> lut, const std::string& path)
+{
+  TFile file(path.data(), "RECREATE");
+  if (file.IsOpen() == false) {
+    std::cerr << "Failed to open file " << path << std::endl;
+  }
+
+  file.WriteObject(lut.get(), "ccdb_object");
+  file.Close();
+}
+
+void _fetchLut(const std::string ccdbUrl = "alice-ccdb.cern.ch", const std::string detector = "FT0", long timestamp = -1, const std::string fileName = "o2_lut.root")
+{
+  o2::ccdb::CcdbApi ccdbApi;
+  ccdbApi.init(ccdbUrl);
+  const std::string ccdbPath = detector + "/Config/LookupTable";
+  std::map<std::string, std::string> metadata;
+
+  if (timestamp == -1) {
+    timestamp = o2::ccdb::getCurrentTimestamp();
+  }
+
+  std::shared_ptr<std::vector<o2::fit::EntryFEE>> lut(ccdbApi.retrieveFromTFileAny<std::vector<o2::fit::EntryFEE>>(ccdbPath, metadata, timestamp));
+
+  if (!lut) {
+    std::cerr << "LUT object not found in " << ccdbUrl << "/" << ccdbPath << " for timestamp " << timestamp << std::endl;
+    return;
+  } else {
+    std::cout << "Successfully fetched LUT for " << detector << " from " << ccdbUrl << std::endl;
+  }
+
+  if (fileName.empty()) {
+    return;
+  }
+
+  saveToRoot(lut, fileName);
+}
+} // namespace
+
+void fetchLut(const std::string ccdbUrl = "alice-ccdb.cern.ch", const std::string detector = "FT0", long timestamp = -1, const std::string fileName = "o2_lut.root")
+{
+  _fetchLut(ccdbUrl, detector, timestamp, fileName);
+}