Merge branch 'AliceO2Group:master' into master

Author: wenyaCern

.github/workflows/labeler.yml

@@ -16,7 +16,7 @@ jobs:
     steps:
       - name: Label the PR
         id: labeler
-        uses: actions/labeler@v5
+        uses: actions/labeler@v6
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           sync-labels: true

.github/workflows/mega-linter.yml

@@ -38,7 +38,7 @@ jobs:
         id: ml
         # You can override MegaLinter flavor used to have faster performances
         # More info at https://megalinter.io/flavors/
-        uses: oxsecurity/megalinter@v8.8.0
+        uses: oxsecurity/megalinter@v9.0.1
         env:
           # All available variables are described in documentation:
           # https://megalinter.io/configuration/

.github/workflows/stale.yml

@@ -13,7 +13,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v10
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           stale-pr-message: 'This PR has not been updated in the last 30 days. Is it still needed? Unless further action is taken, it will be closed in 5 days.'

ALICE3/Core/FastTracker.cxx

@@ -17,7 +17,12 @@
 #include "TMatrixD.h"
 #include "TMatrixDSymEigen.h"
 #include "TRandom.h"
+#include <TEnv.h>
+#include <THashList.h>
+#include <TObject.h>
 
+#include <fstream>
+#include <map>
 #include <string>
 #include <vector>
 
@@ -30,6 +35,7 @@ namespace fastsim
 
 void FastTracker::AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi, float resZ, float eff, int type)
 {
+  LOG(debug) << "Adding layer " << name << " r=" << r << " z=" << z << " x0=" << x0 << " xrho=" << xrho << " resRPhi=" << resRPhi << " resZ=" << resZ << " eff=" << eff << " type=" << type;
   DetLayer newLayer(name, r, z, x0, xrho, resRPhi, resZ, eff, type);
   // Check that efficient layers are not inert layers
   if (newLayer.getEfficiency() > 0.0f && newLayer.isInert()) {
@@ -144,27 +150,42 @@ void FastTracker::AddSiliconALICE3v2(std::vector<float> pixelResolution)
   AddLayer("B10", 80., 250, x0OT, xrhoOT, resRPhiOT, resZOT, eff, 1);
 }
 
-void FastTracker::AddSiliconALICE3(std::vector<float> pixelResolution)
+void FastTracker::AddSiliconALICE3(float scaleX0VD, std::vector<float> pixelResolution)
 {
-  float x0IT = 0.001;        // 0.1%
+  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 xrhoIB = 2.3292e-02; // 100 mum Si
-  float xrhoOT = 2.3292e-01; // 1000 mum Si
-  float eff = 1.00;
+  float x0iTOF = x0OT * 3.;
 
-  float resRPhiIT = pixelResolution[0];
-  float resZIT = pixelResolution[1];
+  float resRPhiVD = pixelResolution[0];
+  float resZVD = 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
+  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, 0.0f, 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);
@@ -217,6 +238,76 @@ void FastTracker::AddTPC(float phiResMean, float zResMean)
   }
 }
 
+void FastTracker::AddGenericDetector(std::string filename, o2::ccdb::BasicCCDBManager* ccdbManager)
+{
+  LOG(info) << " Adding generic detector from file " << filename;
+  // If the filename starts with ccdb: then take the file from the ccdb
+  if (filename.rfind("ccdb:", 0) == 0) {
+    std::string ccdbPath = filename.substr(5); // remove "ccdb:" prefix
+    if (ccdbManager == nullptr) {
+      LOG(fatal) << "CCDB manager is null, cannot retrieve file " << ccdbPath;
+      return;
+    }
+    const std::string outPath = "/tmp/DetGeo/";
+    filename = Form("%s/%s/snapshot.root", outPath.c_str(), ccdbPath.c_str());
+    std::ifstream checkFile(filename); // Check if file already exists
+    if (!checkFile.is_open()) {        // File does not exist, retrieve from CCDB
+      LOG(info) << " --- CCDB source detected for detector geometry " << filename;
+      std::map<std::string, std::string> metadata;
+      ccdbManager->getCCDBAccessor().retrieveBlob(ccdbPath, outPath, metadata, 1);
+      // Add CCDB handling logic here if needed
+      LOG(info) << " --- Now retrieving geometry configuration from CCDB to: " << filename;
+    } else { // File exists, proceed to load
+      LOG(info) << " --- Geometry configuration file already exists: " << filename << ". Skipping download.";
+      checkFile.close();
+    }
+    AddGenericDetector(filename, nullptr);
+    return;
+  }
+
+  TEnv env(filename.c_str());
+  THashList* table = env.GetTable();
+  std::vector<std::string> layers;
+  for (int i = 0; i < table->GetEntries(); ++i) {
+    const std::string key = table->At(i)->GetName();
+    // key should contain exactly one dot
+    if (key.find('.') == std::string::npos || key.find('.') != key.rfind('.')) {
+      LOG(fatal) << "Key " << key << " does not contain exactly one dot";
+      continue;
+    }
+    const std::string firstPart = key.substr(0, key.find('.'));
+    if (std::find(layers.begin(), layers.end(), firstPart) == layers.end()) {
+      layers.push_back(firstPart);
+    }
+  }
+  // env.Print();
+  // Layers
+  for (const auto& layer : layers) {
+    LOG(info) << " Reading layer " << layer;
+
+    auto getKey = [&layer, &env](const std::string& name) {
+      std::string key = layer + "." + name;
+      if (!env.Defined(key.c_str())) {
+        LOG(warning) << "Key " << key << " not defined in configuration file, getting the default value";
+      }
+      LOG(info) << " Getting key " << key;
+      return key;
+    };
+    const float r = env.GetValue(getKey("r").c_str(), -1.0f);
+    LOG(info) << " Layer " << layer << " has radius " << r;
+    const float z = env.GetValue(getKey("z").c_str(), -1.0f);
+    const float x0 = env.GetValue(getKey("x0").c_str(), 0.0f);
+    const float xrho = env.GetValue(getKey("xrho").c_str(), 0.0f);
+    const float resRPhi = env.GetValue(getKey("resRPhi").c_str(), 0.0f);
+    const float resZ = env.GetValue(getKey("resZ").c_str(), 0.0f);
+    const float eff = env.GetValue(getKey("eff").c_str(), 0.0f);
+    const int type = env.GetValue(getKey("type").c_str(), 0);
+
+    // void AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0);
+    AddLayer(layer.c_str(), r, z, x0, xrho, resRPhi, resZ, eff, type);
+  }
+}
+
 float FastTracker::Dist(float z, float r)
 {
   // porting of DetektorK::Dist

ALICE3/Core/FastTracker.h

@@ -14,9 +14,10 @@
 
 #include "DetLayer.h"
 
-#include "ReconstructionDataFormats/Track.h"
+#include <CCDB/BasicCCDBManager.h>
+#include <ReconstructionDataFormats/Track.h>
 
-#include <fairlogger/Logger.h> // not a system header but megalinter thinks so
+#include <fairlogger/Logger.h>
 
 #include <string>
 #include <vector>
@@ -59,8 +60,19 @@ class FastTracker
 
   void AddSiliconALICE3v4(std::vector<float> pixelResolution);
   void AddSiliconALICE3v2(std::vector<float> pixelResolution);
-  void AddSiliconALICE3(std::vector<float> pixelResolution);
+  void AddSiliconALICE3(float scaleX0VD, std::vector<float> pixelResolution);
   void AddTPC(float phiResMean, float zResMean);
+  /**
+   * @brief Adds a generic detector configuration from the specified file.
+   *
+   * This function loads and integrates a detector configuration into the tracker
+   * using the provided filename. The file should contain the necessary parameters
+   * and settings for the detector to be added.
+   *
+   * @param filename Path to the configuration file describing the detector.
+   * @param ccdbManager Pointer to a BasicCCDBManager instance for database access (if needed).
+   */
+  void AddGenericDetector(std::string filename, o2::ccdb::BasicCCDBManager* ccdbManager = nullptr);
 
   void Print();
 

ALICE3/TableProducer/CMakeLists.txt

@@ -21,11 +21,6 @@ o2physics_add_dpl_workflow(alice3-trackextension
                     PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::ReconstructionDataFormats
                     COMPONENT_NAME Analysis)
 
-o2physics_add_dpl_workflow(alice3-pid-tof
-                    SOURCES alice3-pidTOF.cxx
-                    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::ALICE3Core
-                    COMPONENT_NAME Analysis)
-
 o2physics_add_dpl_workflow(alice3-centrality
                     SOURCES alice3-centrality.cxx
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore

ALICE3/TableProducer/OTF/onTheFlyRichPid.cxx

@@ -38,31 +38,31 @@
 #include "Common/Core/trackUtilities.h"
 #include "Common/DataModel/TrackSelectionTables.h"
 
-#include "CCDB/BasicCCDBManager.h"
-#include "CCDB/CcdbApi.h"
-#include "CommonConstants/GeomConstants.h"
-#include "CommonConstants/MathConstants.h"
-#include "CommonConstants/PhysicsConstants.h"
-#include "CommonUtils/NameConf.h"
-#include "DataFormatsCalibration/MeanVertexObject.h"
-#include "DataFormatsParameters/GRPMagField.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "DetectorsBase/Propagator.h"
-#include "DetectorsVertexing/HelixHelper.h"
-#include "Framework/ASoAHelpers.h"
-#include "Framework/AnalysisDataModel.h"
-#include "Framework/AnalysisTask.h"
-#include "Framework/HistogramRegistry.h"
-#include "Framework/O2DatabasePDGPlugin.h"
-#include "Framework/RunningWorkflowInfo.h"
-#include "Framework/runDataProcessing.h"
-#include "ReconstructionDataFormats/DCA.h"
-#include "ReconstructionDataFormats/PID.h"
-
-#include "TRandom3.h"
-#include "TString.h"
-#include "TVector3.h"
+#include <CCDB/BasicCCDBManager.h>
+#include <CCDB/CcdbApi.h>
+#include <CommonConstants/GeomConstants.h>
+#include <CommonConstants/MathConstants.h>
+#include <CommonConstants/PhysicsConstants.h>
+#include <CommonUtils/NameConf.h>
+#include <DataFormatsCalibration/MeanVertexObject.h>
+#include <DataFormatsParameters/GRPMagField.h>
+#include <DetectorsBase/GeometryManager.h>
+#include <DetectorsBase/Propagator.h>
+#include <DetectorsVertexing/HelixHelper.h>
+#include <Framework/ASoAHelpers.h>
+#include <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisTask.h>
+#include <Framework/HistogramRegistry.h>
+#include <Framework/O2DatabasePDGPlugin.h>
+#include <Framework/RunningWorkflowInfo.h>
+#include <Framework/runDataProcessing.h>
+#include <ReconstructionDataFormats/DCA.h>
+#include <ReconstructionDataFormats/PID.h>
+
 #include <TPDGCode.h>
+#include <TRandom3.h>
+#include <TString.h>
+#include <TVector3.h>
 
 #include <cmath>
 #include <map>
@@ -80,6 +80,8 @@ struct OnTheFlyRichPid {
 
   // necessary for particle charges
   Service<o2::framework::O2DatabasePDG> pdg;
+  // Necessary for LUTs
+  Service<o2::ccdb::BasicCCDBManager> ccdb;
 
   // master setting: magnetic field
   Configurable<float> magneticField{"magneticField", 0, "magnetic field (kilogauss) if 0, taken from the tracker task"};
@@ -131,14 +133,6 @@ struct OnTheFlyRichPid {
   Configurable<float> bRICHPixelSize{"bRICHPixelSize", 0.1, "barrel RICH pixel size (cm)"};
   Configurable<float> bRichGapRefractiveIndex{"bRichGapRefractiveIndex", 1.000283, "barrel RICH gap refractive index"};
 
-  struct : ConfigurableGroup {
-    Configurable<std::string> lutEl{"lutEl", "inherit", "LUT for electrons (if inherit, inherits from otf tracker task)"};
-    Configurable<std::string> lutMu{"lutMu", "inherit", "LUT for muons (if inherit, inherits from otf tracker task)"};
-    Configurable<std::string> lutPi{"lutPi", "inherit", "LUT for pions (if inherit, inherits from otf tracker task)"};
-    Configurable<std::string> lutKa{"lutKa", "inherit", "LUT for kaons (if inherit, inherits from otf tracker task)"};
-    Configurable<std::string> lutPr{"lutPr", "inherit", "LUT for protons (if inherit, inherits from otf tracker task)"};
-  } simConfig;
-
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE;
 
   // Track smearer (here used to get relative pt and eta uncertainties)
@@ -304,47 +298,27 @@ struct OnTheFlyRichPid {
       LOG(info) << "Bz = " << magneticField.value << " T";
     }
 
-    // Check if inheriting the LUT configuration
-    auto configLutPath = [&](Configurable<std::string>& lut) {
-      if (lut.value != "inherit") {
-        return;
-      }
-      if (!getTaskOptionValue(initContext, "on-the-fly-tracker", lut, false)) {
-        LOG(fatal) << "Could not get " << lut.name << " from on-the-fly-tracker task";
-      }
-    };
-    configLutPath(simConfig.lutEl);
-    configLutPath(simConfig.lutMu);
-    configLutPath(simConfig.lutPi);
-    configLutPath(simConfig.lutKa);
-    configLutPath(simConfig.lutPr);
-
     // Load LUT for pt and eta smearing
     if (flagIncludeTrackAngularRes && flagRICHLoadDelphesLUTs) {
-      std::map<int, const char*> mapPdgLut;
-      const char* lutElChar = simConfig.lutEl->c_str();
-      const char* lutMuChar = simConfig.lutMu->c_str();
-      const char* lutPiChar = simConfig.lutPi->c_str();
-      const char* lutKaChar = simConfig.lutKa->c_str();
-      const char* lutPrChar = simConfig.lutPr->c_str();
-
-      LOGF(info, "Will load electron lut file ..: %s for RICH PID", lutElChar);
-      LOGF(info, "Will load muon lut file ......: %s for RICH PID", lutMuChar);
-      LOGF(info, "Will load pion lut file ......: %s for RICH PID", lutPiChar);
-      LOGF(info, "Will load kaon lut file ......: %s for RICH PID", lutKaChar);
-      LOGF(info, "Will load proton lut file ....: %s for RICH PID", lutPrChar);
-
-      mapPdgLut.insert(std::make_pair(11, lutElChar));
-      mapPdgLut.insert(std::make_pair(13, lutMuChar));
-      mapPdgLut.insert(std::make_pair(211, lutPiChar));
-      mapPdgLut.insert(std::make_pair(321, lutKaChar));
-      mapPdgLut.insert(std::make_pair(2212, lutPrChar));
-
-      for (const auto& e : mapPdgLut) {
-        if (!mSmearer.loadTable(e.first, e.second)) {
-          LOG(fatal) << "Having issue with loading the LUT " << e.first << " " << e.second;
+      mSmearer.setCcdbManager(ccdb.operator->());
+      auto loadLUT = [&](int pdg, const std::string& cfgNameToInherit) {
+        std::string lut = "none";
+        if (!getTaskOptionValue(initContext, "on-the-fly-tracker", cfgNameToInherit, lut, false)) {
+          LOG(fatal) << "Could not get " << cfgNameToInherit << " from on-the-fly-tracker task";
         }
-      }
+        bool success = mSmearer.loadTable(pdg, lut.c_str());
+        if (!success && !lut.empty()) {
+          LOG(fatal) << "Having issue with loading the LUT " << pdg << " " << lut;
+        }
+      };
+      loadLUT(11, "lutEl");
+      loadLUT(13, "lutMu");
+      loadLUT(211, "lutPi");
+      loadLUT(321, "lutKa");
+      loadLUT(2212, "lutPr");
+      loadLUT(1000010020, "lutDe");
+      loadLUT(1000010030, "lutTr");
+      loadLUT(1000020030, "lutHe3");
     }
 
     if (doQAplots) {