Merge branch 'master' into master

Author: Rrantu

.github/workflows/mega-linter.yml

@@ -49,7 +49,7 @@ jobs:
 
       # Upload MegaLinter artifacts
       - name: Archive production artifacts
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         if: success() || failure()
         with:
           name: MegaLinter reports

.github/workflows/o2-linter.yml

@@ -2,7 +2,7 @@
 # Find issues in O2 code
 name: O2 linter
 
-# "on": [pull_request_target, push]
+#"on": [pull_request_target, push]
 permissions: {}
 env:
   BRANCH_MAIN: master
@@ -47,6 +47,8 @@ jobs:
           fi
           echo "linter_ran=1" >> "$GITHUB_OUTPUT"
           [[ "${{ github.event_name }}" == "pull_request_target" ]] && options="-g"
+          # Checkout the script from the base branch to prevent execution of arbitrary code in the head branch.
+          git checkout ${{ env.BRANCH_BASE }} -- Scripts/o2_linter.py
           # shellcheck disable=SC2086 # Ignore unquoted options.
           python3 Scripts/o2_linter.py $options "${files[@]}"
           echo "Tip: If you allow actions in your fork repository, O2 linter will run when you push commits."

ALICE3/Core/DelphesO2TrackSmearer.cxx

@@ -64,8 +64,7 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
   if (strncmp(filename, "ccdb:", 5) == 0) { // Check if filename starts with "ccdb:"
     LOG(info) << " --- LUT file source identified as CCDB.";
     std::string path = std::string(filename).substr(5); // Remove "ccdb:" prefix
-    const std::string outPath = "/tmp/LUTs/";
-    filename = Form("%s/%s/snapshot.root", outPath.c_str(), path.c_str());
+    filename = Form("%s/%s/snapshot.root", mOutPath.c_str(), path.c_str());
     LOG(info) << " --- Local LUT filename will be: " << filename;
     std::ifstream checkFile(filename); // Check if file already exists
     if (!checkFile.is_open()) {        // File does not exist, retrieve from CCDB
@@ -74,7 +73,7 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
         LOG(fatal) << " --- CCDB manager not set. Please set it before loading LUT from CCDB.";
       }
       std::map<std::string, std::string> metadata;
-      mCcdbManager->getCCDBAccessor().retrieveBlob(path, outPath, metadata, 1);
+      mCcdbManager->getCCDBAccessor().retrieveBlob(path, mOutPath, metadata, 1);
       // Add CCDB handling logic here if needed
       LOG(info) << " --- Now retrieving LUT file from CCDB to: " << filename;
       if (mCleanupDownloadedFile) { // Clean up the downloaded file if needed
@@ -105,6 +104,7 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
   lutFile.read(reinterpret_cast<char*>(mLUTHeader[ipdg]), sizeof(lutHeader_t));
   if (lutFile.gcount() != sizeof(lutHeader_t)) {
     LOG(info) << " --- troubles reading covariance matrix header for PDG " << pdg << ": " << filename << std::endl;
+    LOG(info) << " --- expected/detected " << sizeof(lutHeader_t) << "/" << lutFile.gcount() << std::endl;
     delete mLUTHeader[ipdg];
     mLUTHeader[ipdg] = nullptr;
     return false;
@@ -148,6 +148,7 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
           lutFile.read(reinterpret_cast<char*>(mLUTEntry[ipdg][inch][irad][ieta][ipt]), sizeof(lutEntry_t));
           if (lutFile.gcount() != sizeof(lutEntry_t)) {
             LOG(info) << " --- troubles reading covariance matrix entry for PDG " << pdg << ": " << filename << std::endl;
+            LOG(info) << " --- expected/detected " << sizeof(lutHeader_t) << "/" << lutFile.gcount() << std::endl;
             return false;
           }
         }

ALICE3/Core/DelphesO2TrackSmearer.h

@@ -33,6 +33,7 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <string>
 
 ///////////////////////////////
 /// DelphesO2/src/lutCovm.hh //
@@ -251,6 +252,7 @@ class TrackSmearer
   void setdNdEta(float val) { mdNdEta = val; }                                 //;
   void setCcdbManager(o2::ccdb::BasicCCDBManager* mgr) { mCcdbManager = mgr; } //;
   void setCleanupDownloadedFile(bool val) { mCleanupDownloadedFile = val; }    //;
+  void setDownloadPath(const std::string& path) { mOutPath = path; }           //;
 
  protected:
   static constexpr unsigned int nLUTs = 9; // Number of LUT available
@@ -264,7 +266,8 @@ class TrackSmearer
 
  private:
   o2::ccdb::BasicCCDBManager* mCcdbManager = nullptr;
-  bool mCleanupDownloadedFile = true;
+  bool mCleanupDownloadedFile = true;       // Flag to cleanup the LUT after it's used
+  std::string mOutPath = "./.ALICE3/LUTs/"; // Path where to download LUTs from CCDB
 };
 
 } // namespace delphes

ALICE3/Core/FastTracker.cxx

@@ -24,20 +24,23 @@
 #include <TRandom.h>
 #include <TSystem.h>
 
+#include <chrono>
 #include <fstream>
 #include <map>
 #include <string>
+#include <thread>
 #include <vector>
 
 namespace o2
 {
 namespace fastsim
 {
 
-std::map<std::string, std::map<std::string, std::string>> GeometryContainer::parseTEnvConfiguration(std::string filename, std::vector<std::string>& layers)
+std::map<std::string, std::map<std::string, std::string>> GeometryContainer::parseTEnvConfiguration(std::string& filename, std::vector<std::string>& layers)
 {
   std::map<std::string, std::map<std::string, std::string>> configMap;
   filename = gSystem->ExpandPathName(filename.c_str());
+  LOG(info) << "Parsing TEnv configuration file: " << filename;
   TEnv env(filename.c_str());
   THashList* table = env.GetTable();
   layers.clear();
@@ -72,15 +75,47 @@ std::map<std::string, std::map<std::string, std::string>> GeometryContainer::par
 void GeometryContainer::init(o2::framework::InitContext& initContext)
 {
   std::vector<std::string> detectorConfiguration;
-  const bool found = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "detectorConfiguration", detectorConfiguration, false);
-  if (!found) {
+  const bool foundDetectorConfiguration = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "detectorConfiguration", detectorConfiguration, false);
+  if (!foundDetectorConfiguration) {
     LOG(fatal) << "Could not retrieve detector configuration from OnTheFlyDetectorGeometryProvider task.";
     return;
   }
   LOG(info) << "Size of detector configuration: " << detectorConfiguration.size();
-  for (const auto& configFile : detectorConfiguration) {
+
+  bool cleanLutWhenLoaded;
+  const bool foundCleanLutWhenLoaded = common::core::getTaskOptionValue(initContext, "on-the-fly-detector-geometry-provider", "cleanLutWhenLoaded", cleanLutWhenLoaded, false);
+  if (!foundCleanLutWhenLoaded) {
+    LOG(fatal) << "Could not retrieve foundCleanLutWhenLoaded option from OnTheFlyDetectorGeometryProvider task.";
+    return;
+  }
+
+  for (std::string& configFile : detectorConfiguration) {
+    if (configFile.rfind("ccdb:", 0) == 0) {
+      LOG(info) << "ccdb source detected from on-the-fly-detector-geometry-provider";
+      const std::string ccdbPath = configFile.substr(5); // remove "ccdb:" prefix
+      const std::string outPath = "./.ALICE3/Configuration/";
+      configFile = Form("%s/%s/snapshot.root", outPath.c_str(), ccdbPath.c_str());
+
+      int timeout = 600; // Wait max 10 minutes
+      while (--timeout > 0) {
+        std::ifstream file(configFile);
+        if (file.good()) {
+          break;
+        }
+
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+      }
+
+      std::ifstream checkFile(configFile);
+      if (!checkFile.good()) {
+        LOG(fatal) << "Timed out waiting for geometry snapshot: " << configFile;
+        return;
+      }
+    }
+
     LOG(info) << "Detector geometry configuration file used: " << configFile;
     addEntry(configFile);
+    setLutCleanupSetting(cleanLutWhenLoaded);
   }
 }
 
@@ -95,6 +130,16 @@ std::map<std::string, std::string> GeometryContainer::GeometryEntry::getConfigur
   }
 }
 
+bool GeometryContainer::GeometryEntry::hasValue(const std::string& layerName, const std::string& key) const
+{
+  auto layerIt = mConfigurations.find(layerName);
+  if (layerIt != mConfigurations.end()) {
+    auto keyIt = layerIt->second.find(key);
+    return keyIt != layerIt->second.end();
+  }
+  return false;
+}
+
 std::string GeometryContainer::GeometryEntry::getValue(const std::string& layerName, const std::string& key, bool require) const
 {
   auto layer = getConfiguration(layerName);
@@ -109,6 +154,14 @@ std::string GeometryContainer::GeometryEntry::getValue(const std::string& layerN
   }
 }
 
+void GeometryContainer::GeometryEntry::replaceValue(const std::string& layerName, const std::string& key, const std::string& value)
+{
+  if (!hasValue(layerName, key)) { // check that the key exists
+    LOG(fatal) << "Key " << key << " does not exist in layer " << layerName << ". Cannot replace value.";
+  }
+  setValue(layerName, key, value);
+}
+
 // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+
 
 DetLayer* FastTracker::AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi, float resZ, float eff, int type)
@@ -169,106 +222,6 @@ void FastTracker::Print()
   LOG(info) << "+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+";
 }
 
-void FastTracker::AddSiliconALICE3v4(std::vector<float> pixelResolution)
-{
-  LOG(info) << " ALICE 3: Adding v4 tracking layers";
-  float x0IT = 0.001;        // 0.1%
-  float x0OT = 0.005;        // 0.5%
-  float xrhoIB = 1.1646e-02; // 50 mum Si
-  float xrhoOT = 1.1646e-01; // 500 mum Si
-  float eff = 1.00;
-
-  float resRPhiIT = pixelResolution[0];
-  float resZIT = pixelResolution[1];
-  float resRPhiOT = pixelResolution[2];
-  float resZOT = pixelResolution[3];
-
-  AddLayer("bpipe0", 0.48, 250, 0.00042, 2.772e-02, 0.0f, 0.0f, 0.0f, 0); // 150 mum Be
-  AddLayer("ddd0", 0.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("ddd1", 1.2, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("ddd2", 2.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("bpipe1", 5.7, 250, 0.0014, 9.24e-02, 0.0f, 0.0f, 0.0f, 0); // 500 mum Be
-  AddLayer("ddd3", 7., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd4", 10., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd5", 13., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd6", 16., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd7", 25., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd8", 40., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("ddd9", 45., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-}
-
-void FastTracker::AddSiliconALICE3v2(std::vector<float> pixelResolution)
-{
-  LOG(info) << "ALICE 3: Adding v2 tracking layers;";
-  float x0IT = 0.001;        // 0.1%
-  float x0OT = 0.01;         // 1.0%
-  float xrhoIB = 2.3292e-02; // 100 mum Si
-  float xrhoOT = 2.3292e-01; // 1000 mum Si
-  float eff = 1.00;
-
-  float resRPhiIT = pixelResolution[0];
-  float resZIT = pixelResolution[1];
-  float resRPhiOT = pixelResolution[2];
-  float resZOT = pixelResolution[3];
-
-  AddLayer("bpipe0", 0.48, 250, 0.00042, 2.772e-02, 0.0f, 0.0f, 0.0f, 0); // 150 mum Be
-  AddLayer("B00", 0.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("B01", 1.2, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("B02", 2.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff, 1);
-  AddLayer("bpipe1", 3.7, 250, 0.0014, 9.24e-02, 0.0f, 0.0f, 0.0f, 0); // 500 mum Be
-  AddLayer("B03", 3.75, 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B04", 7., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B05", 12., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B06", 20., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B07", 30., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B08", 45., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B09", 60., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B10", 80., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-}
-
-void FastTracker::AddSiliconALICE3(float scaleX0VD, std::vector<float> pixelResolution)
-{
-  float x0Pipe0 = 0.001592;  // 200 um AlBe
-  float x0VDL0 = 0.00076;    // 30 um Si + 50 um glue + carbon foam 0.03%
-  float x0VDL1 = 0.00096;    // 30 um Si + 50 um glue + carbon foam 0.05%
-  float x0VDL2 = 0.00167;    // 30 um Si + 50 um glue + carbon foam 0.05% + 0.07% Be case
-  float x0Coldplate = 0.02f; // (1.5 mm Al2O3 2%)
-  float x0Pipe1 = 0.0023f;   // 800 um Be
-  float x0OT = 0.01;         // 1.0%
-  float x0iTOF = x0OT * 3.;
-
-  float resRPhiVD = pixelResolution[0];
-  float resZVD = pixelResolution[1];
-  float resRPhiOT = pixelResolution[2];
-  float resZOT = pixelResolution[3];
-
-  float xrhoPipe0 = 0;
-  float xrhoVDL0 = 0;
-  float xrhoVDL1 = 0;
-  float xrhoVDL2 = 0;
-  float xrhoColdplate = 0;
-  float xrhoPipe1 = 0;
-  float xrhoOT = 2.3292e-01;
-  float xrhoiTOF = 0.03;
-  float eff = 1.00;
-
-  AddLayer("bpipe0", 0.48, 250, x0Pipe0, xrhoPipe0, 0.0f, 0.0f, 0.0f, 0);
-  AddLayer("B00", 0.5, 250, x0VDL0 * scaleX0VD, xrhoVDL0, resRPhiVD, resZVD, eff, 1);
-  AddLayer("B01", 1.2, 250, x0VDL1 * scaleX0VD, xrhoVDL1, resRPhiVD, resZVD, eff, 1);
-  AddLayer("B02", 2.5, 250, x0VDL2 * scaleX0VD, xrhoVDL2, resRPhiVD, resZVD, eff, 1);
-  AddLayer("coldplate", 2.6, 250, x0Coldplate, xrhoColdplate, 0.0f, 0.0f, 0.0f, 0);
-  AddLayer("bpipe1", 5.7, 250, x0Pipe1, xrhoPipe1, 0.0f, 0.0f, 0.0f, 0);
-  AddLayer("B03", 7., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B04", 9., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B05", 12., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("iTOF", 19, 250, x0iTOF, xrhoiTOF, resRPhiOT, resZOT, eff, 0);
-  AddLayer("B06", 20., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B07", 30., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B08", 45., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B09", 60., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-  AddLayer("B10", 80., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
-}
-
 void FastTracker::AddTPC(float phiResMean, float zResMean)
 {
   LOG(info) << " Adding standard time projection chamber";

ALICE3/Core/FastTracker.h

@@ -42,47 +42,59 @@ class GeometryContainer
    * @param layers Vector to store the order of the layers as they appear in the file
    * @return A map where each key is a layer name and the value is another map of key-value pairs for that layer
    */
-  static std::map<std::string, std::map<std::string, std::string>> parseTEnvConfiguration(std::string filename, std::vector<std::string>& layers);
+  static std::map<std::string, std::map<std::string, std::string>> parseTEnvConfiguration(std::string& filename, std::vector<std::string>& layers);
 
   // A container for the geometry info
   struct GeometryEntry {
     // Default constructor
     GeometryEntry() = default;
-    explicit GeometryEntry(std::string filename) : name(filename)
+    explicit GeometryEntry(std::string filename)
     {
-      mConfigurations = GeometryContainer::parseTEnvConfiguration(filename, layerNames);
+      mFileName = filename;
+      mConfigurations = GeometryContainer::parseTEnvConfiguration(mFileName, mLayerNames);
+      LOG(info) << "Loaded geometry configuration from file: " << filename << " with " << mLayerNames.size() << " layers.";
+      if (mLayerNames.empty()) {
+        LOG(warning) << "No layers found in geometry configuration file: " << filename;
+      }
     }
     std::map<std::string, std::map<std::string, std::string>> getConfigurations() const { return mConfigurations; }
     std::map<std::string, std::string> getConfiguration(const std::string& layerName) const;
-    std::vector<std::string> getLayerNames() const { return layerNames; }
+    std::vector<std::string> getLayerNames() const { return mLayerNames; }
+    bool hasValue(const std::string& layerName, const std::string& key) const;
     std::string getValue(const std::string& layerName, const std::string& key, bool require = true) const;
+    void setValue(const std::string& layerName, const std::string& key, const std::string& value) { mConfigurations[layerName][key] = value; }
+    void replaceValue(const std::string& layerName, const std::string& key, const std::string& value);
     float getFloatValue(const std::string& layerName, const std::string& key) const { return std::stof(getValue(layerName, key)); }
     int getIntValue(const std::string& layerName, const std::string& key) const { return std::stoi(getValue(layerName, key)); }
 
    private:
-    std::string name; // Filename of the geometry
-    std::map<std::string, std::map<std::string, std::string>> mConfigurations;
-    std::vector<std::string> layerNames; // Ordered names of the layers
+    std::string mFileName;                                                     // Filename of the geometry
+    std::map<std::string, std::map<std::string, std::string>> mConfigurations; // Layer configurations
+    std::vector<std::string> mLayerNames;                                      // Ordered names of the layers
   };
 
   // Add a geometry entry from a configuration file
   void addEntry(const std::string& filename) { entries.emplace_back(filename); }
+  void setLutCleanupSetting(const bool cleanLutWhenLoaded) { mCleanLutWhenLoaded = cleanLutWhenLoaded; }
 
   // Getters
   int getNumberOfConfigurations() const { return entries.size(); }
   const std::vector<GeometryEntry>& getEntries() const { return entries; }
   const GeometryEntry& getEntry(const int id) const { return entries.at(id); }
   GeometryEntry getGeometryEntry(const int id) const { return entries.at(id); }
+  bool cleanLutWhenLoaded() const { return mCleanLutWhenLoaded; }
 
   // Get configuration maps
   std::map<std::string, std::map<std::string, std::string>> getConfigurations(const int id) const { return entries.at(id).getConfigurations(); }
   std::map<std::string, std::string> getConfiguration(const int id, const std::string& layerName) const { return entries.at(id).getConfiguration(layerName); }
 
   // Get specific values
+  std::string getValue(const int id, const std::string& layerName, const std::string& key, bool require = true) const { return entries.at(id).getValue(layerName, key, require); }
   float getFloatValue(const int id, const std::string& layerName, const std::string& key) const { return entries.at(id).getFloatValue(layerName, key); }
 
  private:
   std::vector<GeometryEntry> entries;
+  bool mCleanLutWhenLoaded = true;
 };
 
 // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+
@@ -122,9 +134,6 @@ class FastTracker
     SetResolutionZ(layerName, resZ);
   }
 
-  void AddSiliconALICE3v4(std::vector<float> pixelResolution);
-  void AddSiliconALICE3v2(std::vector<float> pixelResolution);
-  void AddSiliconALICE3(float scaleX0VD, std::vector<float> pixelResolution);
   void AddTPC(float phiResMean, float zResMean);
 
   /**

ALICE3/Core/TrackUtilities.h

@@ -54,7 +54,7 @@ struct OTFParticle {
 
   // Getters
   int pdgCode() const { return mPdgCode; }
-  int isAlive() const { return mIsAlive; }
+  bool isAlive() const { return mIsAlive; }
   float vx() const { return mVx; }
   float vy() const { return mVy; }
   float vz() const { return mVz; }

ALICE3/Macros/CMakeLists.txt

@@ -13,6 +13,7 @@ install(FILES Configuration/a3geo.ini
               Configuration/a3geometry_v2_10kG.ini
               Configuration/a3geometry_v2_20kG_dipole.ini
               Configuration/a3geometry_v2_20kG.ini
+              Configuration/a3geometry_v3_extra_ml.ini
               Configuration/a3geometry_v3.ini
               Configuration/a3geometry_v4.ini
         PERMISSIONS GROUP_READ GROUP_EXECUTE OWNER_EXECUTE OWNER_WRITE OWNER_READ WORLD_EXECUTE WORLD_READ