Merge branch 'master' into tpccdbfix

Author: jezwilkinson

.clang-tidy

@@ -1,17 +1,15 @@
 CheckOptions:
-  - { key: CheckPathRegex, value: ".*/O2/.*" }
   # Naming conventions
   - { key: readability-identifier-naming.ClassCase, value: CamelCase }
   - { key: readability-identifier-naming.ClassMemberPrefix, value: m }
   - { key: readability-identifier-naming.ConceptCase, value: CamelCase }
   - { key: readability-identifier-naming.ConstexprVariableCase, value: CamelCase }
-  - { key: readability-identifier-naming.ConstexprVariableIgnoredRegexp, value: "^k[A-Z].*$" }  # Allow "k" prefix.
   - { key: readability-identifier-naming.EnumCase, value: CamelCase }
   - { key: readability-identifier-naming.EnumConstantCase, value: CamelCase }
-  - { key: readability-identifier-naming.EnumConstantIgnoredRegexp, value: "^k[A-Z].*$" }  # Allow "k" prefix.
+  - { key: readability-identifier-naming.EnumConstantIgnoredRegexp, value: "^k?[A-Z][a-zA-Z0-9_]*$" }  # Allow "k" prefix and non-trailing underscores in PDG names.
   - { key: readability-identifier-naming.FunctionCase, value: camelBack }
   - { key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }
-  - { key: readability-identifier-naming.MacroDefinitionIgnoredRegexp, value: "^[A-Z]+(_[A-Z]+)*_$" }  # Allow the trailing underscore in header guards.
+  - { key: readability-identifier-naming.MacroDefinitionIgnoredRegexp, value: "^[A-Z][A-Z0-9_]*_$" }  # Allow the trailing underscore in header guards.
   - { key: readability-identifier-naming.MemberCase, value: camelBack }
   - { key: readability-identifier-naming.NamespaceCase, value: lower_case }
   - { key: readability-identifier-naming.ParameterCase, value: camelBack }

.github/workflows/mega-linter.yml

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

.mega-linter.yml

@@ -39,5 +39,6 @@ PYTHON_PYRIGHT_CONFIG_FILE: pyproject.toml
 PYTHON_RUFF_CONFIG_FILE: pyproject.toml
 CPP_CPPLINT_FILE_EXTENSIONS: [".C", ".c", ".c++", ".cc", ".cl", ".cpp", ".cu", ".cuh", ".cxx", ".cxx.in", ".h", ".h++", ".hh", ".h.in", ".hpp", ".hxx", ".inc", ".inl", ".macro"]
 CPP_CLANG_FORMAT_FILE_EXTENSIONS: [".C", ".c", ".c++", ".cc", ".cl", ".cpp", ".cu", ".cuh", ".cxx", ".cxx.in", ".h", ".h++", ".hh", ".h.in", ".hpp", ".hxx", ".inc", ".inl", ".macro"]
+CPP_CPPCHECK_FILE_EXTENSIONS: [".C", ".c", ".c++", ".cc", ".cl", ".cpp", ".cu", ".cuh", ".cxx", ".cxx.in", ".h", ".h++", ".hh", ".h.in", ".hpp", ".hxx", ".inc", ".inl", ".macro"]
 CPP_CPPCHECK_ARGUMENTS: --language=c++ --std=c++20 --check-level=exhaustive --suppressions-list=cppcheck_config
 REPOSITORY_GITLEAKS_PR_COMMITS_SCAN: true

ALICE3/Core/DelphesO2TrackSmearer.cxx

@@ -105,7 +105,18 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
     mLUTHeader[ipdg] = nullptr;
     return false;
   }
-  if (mLUTHeader[ipdg]->pdg != pdg) {
+  bool specialPdgCase = false;
+  switch (pdg) {                         // Handle special cases
+    case o2::constants::physics::kAlpha: // Special case: Allow Alpha particles to use He3 LUT
+      specialPdgCase = (mLUTHeader[ipdg]->pdg == o2::constants::physics::kHelium3);
+      if (specialPdgCase)
+        LOG(info)
+          << " --- Alpha particles (PDG " << pdg << ") will use He3 LUT data (PDG " << mLUTHeader[ipdg]->pdg << ")" << std::endl;
+      break;
+    default:
+      break;
+  }
+  if (mLUTHeader[ipdg]->pdg != pdg && !specialPdgCase) {
     LOG(info) << " --- LUT header PDG mismatch: expected/detected = " << pdg << "/" << mLUTHeader[ipdg]->pdg << std::endl;
     delete mLUTHeader[ipdg];
     mLUTHeader[ipdg] = nullptr;
@@ -142,12 +153,13 @@ bool TrackSmearer::loadTable(int pdg, const char* filename, bool forceReload)
 
 /*****************************************************************/
 
-lutEntry_t*
-  TrackSmearer::getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff)
+lutEntry_t* TrackSmearer::getLUTEntry(const int pdg, const float nch, const float radius, const float eta, const float pt, float& interpolatedEff)
 {
-  auto ipdg = getIndexPDG(pdg);
-  if (!mLUTHeader[ipdg])
+  const int ipdg = getIndexPDG(pdg);
+  if (!mLUTHeader[ipdg]) {
+    LOG(error) << " --- getLUTEntry: LUT header not loaded for pdg=" << pdg << ". Returning nullptr.";
     return nullptr;
+  }
   auto inch = mLUTHeader[ipdg]->nchmap.find(nch);
   auto irad = mLUTHeader[ipdg]->radmap.find(radius);
   auto ieta = mLUTHeader[ipdg]->etamap.find(eta);
@@ -279,56 +291,56 @@ bool TrackSmearer::smearTrack(O2Track& o2track, int pdg, float nch)
   }
   auto eta = o2track.getEta();
   float interpolatedEff = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, interpolatedEff);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, interpolatedEff);
   if (!lutEntry || !lutEntry->valid)
     return false;
   return smearTrack(o2track, lutEntry, interpolatedEff);
 }
 
 /*****************************************************************/
 // relative uncertainty on pt
-double TrackSmearer::getPtRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getPtRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto val = std::sqrt(lutEntry->covm[14]) * lutEntry->pt;
   return val;
 }
 
 /*****************************************************************/
 // relative uncertainty on eta
-double TrackSmearer::getEtaRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getEtaRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto sigmatgl = std::sqrt(lutEntry->covm[9]);                                  // sigmatgl2
   auto etaRes = std::fabs(std::sin(2.0 * std::atan(std::exp(-eta)))) * sigmatgl; // propagate tgl to eta uncertainty
   etaRes /= lutEntry->eta;                                                       // relative uncertainty
   return etaRes;
 }
 /*****************************************************************/
 // absolute uncertainty on pt
-double TrackSmearer::getAbsPtRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getAbsPtRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto val = std::sqrt(lutEntry->covm[14]) * lutEntry->pt * lutEntry->pt;
   return val;
 }
 
 /*****************************************************************/
 // absolute uncertainty on eta
-double TrackSmearer::getAbsEtaRes(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getAbsEtaRes(const int pdg, const float nch, const float eta, const float pt)
 {
   float dummy = 0.0f;
-  auto lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
+  lutEntry_t* lutEntry = getLUTEntry(pdg, nch, 0., eta, pt, dummy);
   auto sigmatgl = std::sqrt(lutEntry->covm[9]);                                  // sigmatgl2
   auto etaRes = std::fabs(std::sin(2.0 * std::atan(std::exp(-eta)))) * sigmatgl; // propagate tgl to eta uncertainty
   return etaRes;
 }
 /*****************************************************************/
 // efficiency
-double TrackSmearer::getEfficiency(int pdg, float nch, float eta, float pt)
+double TrackSmearer::getEfficiency(const int pdg, const float nch, const float eta, const float pt)
 {
   float efficiency = 0.0f;
   getLUTEntry(pdg, nch, 0., eta, pt, efficiency);
@@ -349,7 +361,7 @@ double TrackSmearer::getEfficiency(int pdg, float nch, float eta, float pt)
 //   return true;
 
 // #if 0
-//   auto lutEntry = getLUTEntry(track.PID, 0., 0., track.Eta, track.PT);
+//   lutEntry_t* lutEntry = getLUTEntry(track.PID, 0., 0., track.Eta, track.PT);
 //   if (!lutEntry)
 //     return;
 

ALICE3/Core/DelphesO2TrackSmearer.h

@@ -29,6 +29,7 @@
 
 #include <TRandom.h>
 
+#include <cstdio>
 #include <fstream>
 #include <iostream>
 #include <map>
@@ -179,23 +180,24 @@ class TrackSmearer
 
   /** LUT methods **/
   bool loadTable(int pdg, const char* filename, bool forceReload = false);
-  void useEfficiency(bool val) { mUseEfficiency = val; }                      //;
-  void interpolateEfficiency(bool val) { mInterpolateEfficiency = val; }      //;
-  void skipUnreconstructed(bool val) { mSkipUnreconstructed = val; }          //;
-  void setWhatEfficiency(int val) { mWhatEfficiency = val; }                  //;
-  lutHeader_t* getLUTHeader(int pdg) { return mLUTHeader[getIndexPDG(pdg)]; } //;
-  lutEntry_t* getLUTEntry(int pdg, float nch, float radius, float eta, float pt, float& interpolatedEff);
+  bool hasTable(int pdg) { return (mLUTHeader[getIndexPDG(pdg)] != nullptr); } //;
+  void useEfficiency(bool val) { mUseEfficiency = val; }                       //;
+  void interpolateEfficiency(bool val) { mInterpolateEfficiency = val; }       //;
+  void skipUnreconstructed(bool val) { mSkipUnreconstructed = val; }           //;
+  void setWhatEfficiency(int val) { mWhatEfficiency = val; }                   //;
+  lutHeader_t* getLUTHeader(int pdg) { return mLUTHeader[getIndexPDG(pdg)]; }  //;
+  lutEntry_t* getLUTEntry(const int pdg, const float nch, const float radius, const float eta, const float pt, float& interpolatedEff);
 
   bool smearTrack(O2Track& o2track, lutEntry_t* lutEntry, float interpolatedEff);
   bool smearTrack(O2Track& o2track, int pdg, float nch);
   // bool smearTrack(Track& track, bool atDCA = true); // Only in DelphesO2
-  double getPtRes(int pdg, float nch, float eta, float pt);
-  double getEtaRes(int pdg, float nch, float eta, float pt);
-  double getAbsPtRes(int pdg, float nch, float eta, float pt);
-  double getAbsEtaRes(int pdg, float nch, float eta, float pt);
-  double getEfficiency(int pdg, float nch, float eta, float pt);
+  double getPtRes(const int pdg, const float nch, const float eta, const float pt);
+  double getEtaRes(const int pdg, const float nch, const float eta, const float pt);
+  double getAbsPtRes(const int pdg, const float nch, const float eta, const float pt);
+  double getAbsEtaRes(const int pdg, const float nch, const float eta, const float pt);
+  double getEfficiency(const int pdg, const float nch, const float eta, const float pt);
 
-  int getIndexPDG(int pdg)
+  int getIndexPDG(const int pdg)
   {
     switch (abs(pdg)) {
       case 11:
@@ -214,6 +216,8 @@ class TrackSmearer
         return 6; // Triton
       case 1000020030:
         return 7; // Helium3
+      case 1000020040:
+        return 8; // Alphas
       default:
         return 2; // Default: pion
     }
@@ -238,6 +242,8 @@ class TrackSmearer
         return "triton";
       case 1000020030:
         return "helium3";
+      case 1000020040:
+        return "alpha";
       default:
         return "pion"; // Default: pion
     }
@@ -246,7 +252,7 @@ class TrackSmearer
   void setCcdbManager(o2::ccdb::BasicCCDBManager* mgr) { mCcdbManager = mgr; } //;
 
  protected:
-  static constexpr unsigned int nLUTs = 8; // Number of LUT available
+  static constexpr unsigned int nLUTs = 9; // Number of LUT available
   lutHeader_t* mLUTHeader[nLUTs] = {nullptr};
   lutEntry_t***** mLUTEntry[nLUTs] = {nullptr};
   bool mUseEfficiency = true;

ALICE3/Core/DetLayer.cxx

@@ -16,11 +16,14 @@
 /// \brief  Basic struct to hold information regarding a detector layer to be used in fast simulation
 ///
 
-#include <vector>
-#include <string>
-
 #include "DetLayer.h"
 
+#include <CommonConstants/MathConstants.h>
+#include <Framework/Logger.h>
+
+#include <string>
+#include <vector>
+
 namespace o2::fastsim
 {
 
@@ -51,6 +54,62 @@ DetLayer::DetLayer(const DetLayer& other)
 {
 }
 
+void DetLayer::addDeadPhiRegion(float phiStart, float phiEnd)
+{
+  static constexpr float kDefaultValue = 2.f;
+  static constexpr float kPhiTolerance = 1e-4f;
+  if (mDeadPhiRegions == nullptr) {
+    mDeadPhiRegions = new TGraph();
+    mDeadPhiRegions->SetNameTitle(Form("deadPhiRegions_%s", name.Data()), Form("Dead phi regions for layer %s", name.Data()));
+    mDeadPhiRegions->AddPoint(0, kDefaultValue);
+    mDeadPhiRegions->AddPoint(o2::constants::math::TwoPI, kDefaultValue);
+  }
+  if (phiStart < 0 || phiStart >= o2::constants::math::TwoPI || phiEnd < 0 || phiEnd >= o2::constants::math::TwoPI) {
+    LOG(fatal) << "Cannot add dead phi region with invalid range [" << phiStart << ", " << phiEnd << "] to layer " << name;
+    return;
+  }
+  mDeadPhiRegions->AddPoint(phiStart, kDefaultValue);
+  mDeadPhiRegions->AddPoint(phiEnd, kDefaultValue);
+  mDeadPhiRegions->AddPoint(phiStart + kPhiTolerance, 0.f);
+  mDeadPhiRegions->AddPoint(phiEnd - kPhiTolerance, 0.f);
+  mDeadPhiRegions->Sort();
+}
+
+void DetLayer::setDeadPhiRegions(TGraph* graph)
+{
+  LOG(debug) << "Setting dead phi regions for layer " << name << " with graph " << (graph ? graph->GetName() : "nullptr");
+  if (mDeadPhiRegions != nullptr) {
+    LOG(warning) << "Overriding existing dead phi regions for layer " << name;
+    delete mDeadPhiRegions;
+  }
+  mDeadPhiRegions = graph;
+  if (mDeadPhiRegions->GetN() == 0) {
+    LOG(warning) << "Dead phi regions graph for layer " << name << " is empty, clearing dead regions";
+    mDeadPhiRegions = nullptr;
+    return; // cleared the dead regions
+  }
+  // Check sanity of the graph
+  if (mDeadPhiRegions != nullptr) {
+    for (int i = 0; i < mDeadPhiRegions->GetN(); i++) {
+      const float x = mDeadPhiRegions->GetX()[i];
+      const float y = mDeadPhiRegions->GetY()[i];
+      // First point has to be at 0, last point has to be at 2PI
+      if ((i == 0 && x != 0.f) || (i == mDeadPhiRegions->GetN() - 1 && x != o2::constants::math::TwoPI)) {
+        LOG(fatal) << "Dead phi regions graph for layer " << name << " has invalid x value " << x << " at point " << i << ", first point should be 0 and last point should be 2PI";
+      }
+      LOG(debug) << "Point " << i << ": (" << x << ", " << y << ")";
+      if (x < 0 || x > o2::constants::math::TwoPI) {
+        LOG(fatal) << "Dead phi regions graph for layer " << name << " has invalid x value " << x << " at point " << i;
+      }
+      if (y != 0.f && y != 2.f) {
+        LOG(fatal) << "Dead phi regions graph for layer " << name << " has invalid y value " << y << " at point " << i << ", should be 0 or 2";
+      }
+    }
+  } else {
+    LOG(info) << "Cleared dead phi regions for layer " << name;
+  }
+}
+
 std::string DetLayer::toString() const
 {
   std::string out = "";

ALICE3/Core/DetLayer.h

@@ -19,9 +19,10 @@
 #ifndef ALICE3_CORE_DETLAYER_H_
 #define ALICE3_CORE_DETLAYER_H_
 
-#include <string>
+#include <TGraph.h>
+#include <TString.h>
 
-#include "TString.h"
+#include <string>
 
 namespace o2::fastsim
 {
@@ -47,6 +48,17 @@ struct DetLayer {
   void setEfficiency(float eff_) { eff = eff_; }
   void setType(int type_) { type = type_; }
 
+  // Dead areas
+
+  /// @brief Add a dead region in phi for this layer
+  /// @param phiStart starting angle in radians of the dead region
+  /// @param phiEnd ending angle in radians of the dead region
+  void addDeadPhiRegion(float phiStart, float phiEnd);
+
+  /// @brief Set the dead regions in phi for this layer with a TGraph containing all regions. The graph should have y=2 for dead regions and y=0 for alive regions.
+  /// @param graph graph of the dead regions. Can be nullptr to clear the dead regions.
+  void setDeadPhiRegions(TGraph* graph);
+
   // Getters
   float getRadius() const { return r; }
   float getZ() const { return z; }
@@ -57,6 +69,7 @@ struct DetLayer {
   float getEfficiency() const { return eff; }
   int getType() const { return type; }
   const TString& getName() const { return name; }
+  const TGraph* getDeadPhiRegions() const { return mDeadPhiRegions; }
 
   // Check layer type
   bool isInert() const { return type == layerInert; }
@@ -70,6 +83,15 @@ struct DetLayer {
     os << layer.toString();
     return os;
   }
+  /// @brief Check if a given phi angle is in a dead region
+  /// @param phi The phi angle to check
+  /// @return True if the phi angle is in a dead region, false otherwise
+  bool isInDeadPhiRegion(float phi) const
+  {
+    if (mDeadPhiRegions == nullptr)
+      return false;
+    return mDeadPhiRegions->Eval(phi) > 1.f;
+  };
 
  private:
   // TString for holding name
@@ -90,6 +112,9 @@ struct DetLayer {
   // efficiency
   float eff; // detection efficiency
 
+  // dead regions in phi (in radians)
+  TGraph* mDeadPhiRegions = nullptr;
+
   // layer type
   int type;                              // 0: undefined/inert, 1: silicon, 2: gas/tpc
   static constexpr int layerInert = 0;   // inert/undefined layer