Merge remote-tracking branch 'upstream/master' into ds-jet-mc-efficiency

Author: monamelop

.clang-tidy

@@ -1,21 +1,144 @@
+---
+Checks:
+  # - clang-analyzer-* # enabled by default
+  # - clang-diagnostic-* # enabled by default
+  - -clang-diagnostic-unknown-pragmas
+  - bugprone-*
+  - -bugprone-assert-side-effect
+  - -bugprone-bad-signal-to-kill-thread
+  - -bugprone-bitwise-pointer-cast
+  - -bugprone-bool-pointer-implicit-conversion
+  - -bugprone-compare-pointer-to-member-virtual-function
+  - -bugprone-crtp-constructor-accessibility
+  - -bugprone-easily-swappable-parameters # Too sensitive
+  - -bugprone-forwarding-reference-overload
+  - -bugprone-implicit-widening-of-multiplication-result # Specific cases irrelevant in this repo
+  - -bugprone-lambda-function-name
+  - -bugprone-no-escape
+  - -bugprone-posix-return
+  - -bugprone-signal-handler
+  - -bugprone-signed-char-misuse # Specific use cases. Probably very rare.
+  - -bugprone-spuriously-wake-up-functions
+  - -bugprone-suspicious-stringview-data-usage # Probably harmless in this repo
+  - -bugprone-unused-raii
+  - cppcoreguidelines-avoid-const-or-ref-data-members
+  - cppcoreguidelines-avoid-goto
+  - cppcoreguidelines-avoid-non-const-global-variables
+  - cppcoreguidelines-init-variables
+  - cppcoreguidelines-macro-usage
+  - cppcoreguidelines-misleading-capture-default-by-value
+  - cppcoreguidelines-missing-std-forward
+  - cppcoreguidelines-prefer-member-initializer
+  - cppcoreguidelines-pro-bounds-array-to-pointer-decay
+  - cppcoreguidelines-pro-type-const-cast
+  - cppcoreguidelines-pro-type-cstyle-cast
+  - cppcoreguidelines-pro-type-member-init
+  - cppcoreguidelines-pro-type-reinterpret-cast
+  - cppcoreguidelines-pro-type-static-cast-downcast
+  - cppcoreguidelines-pro-type-union-access
+  - cppcoreguidelines-rvalue-reference-param-not-moved
+  - cppcoreguidelines-slicing
+  - cppcoreguidelines-virtual-class-destructor
+  - google-default-arguments
+  # - google-explicit-constructor # triggered for O2 columns
+  - google-global-names-in-headers
+  # - misc-const-correctness # to be checked
+  - misc-header-include-cycle
+  - misc-include-cleaner
+  - misc-misplaced-const
+  - misc-redundant-expression
+  - misc-unconventional-assign-operator
+  - misc-unused-alias-decls
+  - misc-unused-parameters
+  - misc-unused-using-decls
+  - modernize-avoid-bind
+  - modernize-avoid-c-arrays
+  - modernize-concat-nested-namespaces
+  - modernize-deprecated-headers
+  - modernize-make-shared
+  - modernize-make-unique
+  - modernize-redundant-void-arg
+  - modernize-return-braced-init-list
+  - modernize-use-auto
+  - modernize-use-default-member-init
+  - modernize-use-designated-initializers
+  - modernize-use-equals-default
+  - modernize-use-equals-delete
+  - modernize-use-nodiscard
+  - modernize-use-nullptr
+  - modernize-use-override
+  - modernize-use-starts-ends-with
+  - performance-for-range-copy
+  - performance-implicit-conversion-in-loop
+  - performance-inefficient-algorithm
+  - performance-inefficient-string-concatenation
+  - performance-inefficient-vector-operation
+  - performance-move-const-arg
+  - performance-no-automatic-move
+  - performance-trivially-destructible
+  - performance-type-promotion-in-math-fn
+  - performance-unnecessary-copy-initialization
+  - performance-unnecessary-value-param # slow
+  - readability-avoid-unconditional-preprocessor-if
+  - readability-braces-around-statements
+  - readability-const-return-type
+  - readability-container-contains
+  - readability-container-data-pointer
+  - readability-container-size-empty
+  - readability-delete-null-pointer
+  - readability-duplicate-include
+  - readability-else-after-return
+  - readability-enum-initial-value
+  - readability-implicit-bool-conversion
+  - readability-inconsistent-declaration-parameter-name
+  - readability-misplaced-array-index
+  - readability-non-const-parameter
+  - readability-redundant-access-specifiers
+  - readability-redundant-casting
+  - readability-redundant-control-flow
+  - readability-redundant-declaration
+  - readability-redundant-member-init
+  - readability-redundant-preprocessor
+  - readability-redundant-string-cstr
+  - readability-redundant-string-init
+  - readability-reference-to-constructed-temporary
+  - readability-simplify-boolean-expr
+  - readability-static-definition-in-anonymous-namespace
+  - readability-string-compare
+  - readability-suspicious-call-argument
+# Select which of the enabled checks should be reported as errors instead of warnings.
+WarningsAsErrors: >-
+  *,
+  -readability-braces-around-statements,
+  -readability-suspicious-call-argument,
 CheckOptions:
+  modernize-avoid-c-arrays.AllowStringArrays: true
+  # Common tolerated conversions
+  bugprone-narrowing-conversions.WarnOnFloatingPointNarrowingConversion: false
+  bugprone-narrowing-conversions.WarnOnIntegerNarrowingConversion: false
+  bugprone-narrowing-conversions.WarnOnIntegerToFloatingPointNarrowingConversion: false
+  readability-implicit-bool-conversion.AllowLogicalOperatorConversion: true
+  readability-implicit-bool-conversion.AllowPointerConditions: true
+  # Some data model structs are missing some special functions by design.
+  cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions: true
   # 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.EnumCase, value: CamelCase }
-  - { key: readability-identifier-naming.EnumConstantCase, value: CamelCase }
-  - { 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-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 }
-  - { key: readability-identifier-naming.StructCase, value: CamelCase }
-  - { key: readability-identifier-naming.TemplateParameterCase, value: CamelCase }
-  - { key: readability-identifier-naming.TypeAliasCase, value: CamelCase }
-  - { key: readability-identifier-naming.TypedefCase, value: CamelCase }
-  - { key: readability-identifier-naming.TypeTemplateParameterCase, value: CamelCase }
-  - { key: readability-identifier-naming.VariableCase, value: camelBack }
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.ClassMemberPrefix: m
+  readability-identifier-naming.ConceptCase: CamelCase
+  readability-identifier-naming.ConstexprVariableCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.EnumConstantIgnoredRegexp: "^k?[A-Z][a-zA-Z0-9_]*$" # Allow "k" prefix and non-trailing underscores in PDG names.
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.MacroDefinitionIgnoredRegexp: "^[A-Z][A-Z0-9_]*_$" # Allow the trailing underscore in header guards.
+  readability-identifier-naming.MemberCase: camelBack
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.ParameterCase: camelBack
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  readability-identifier-naming.TypeTemplateParameterCase: CamelCase
+  readability-identifier-naming.VariableCase: camelBack
+...

.github/workflows/mega-linter.yml

@@ -23,7 +23,7 @@ jobs:
     steps:
       # Git Checkout
       - name: Checkout Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
         with:
           # Checkout the HEAD of the PR instead of the merge commit.
           ref: ${{ github.event.pull_request.head.sha }}
@@ -32,13 +32,14 @@ jobs:
           fetch-depth: 0
           # So we can use secrets.ALIBUILD_GITHUB_TOKEN to push later.
           persist-credentials: false
+          allow-unsafe-pr-checkout: true # needed for pull_request_target
 
       # MegaLinter
       - name: MegaLinter
         id: ml
         # You can override MegaLinter flavor used to have faster performances
         # More info at https://megalinter.io/flavors/
-        uses: oxsecurity/megalinter@v9.5.0
+        uses: oxsecurity/megalinter@v9.6.0
         env:
           # All available variables are described in documentation:
           # https://megalinter.io/configuration/

.github/workflows/o2-linter.yml

@@ -30,10 +30,11 @@ jobs:
           echo BRANCH_HEAD="$branch_head" >> "$GITHUB_ENV"
           echo BRANCH_BASE="$branch_base" >> "$GITHUB_ENV"
       - name: Checkout Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
         with:
           ref: ${{ env.BRANCH_HEAD }}
           fetch-depth: 0 # needed to get the full history
+          allow-unsafe-pr-checkout: true # needed for pull_request_target
       - name: Run tests
         id: linter
         run: |

.mega-linter.yml

@@ -42,6 +42,6 @@ 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
+CPP_CPPCHECK_ARGUMENTS: --language=c++ --std=c++20 --enable=style --check-level=exhaustive --suppressions-list=cppcheck_suppressions --inline-suppr --force
 REPOSITORY_GITLEAKS_PR_COMMITS_SCAN: true
 ACTION_ZIZMOR_UNSECURED_ENV_VARIABLES: [GITHUB_TOKEN]

ALICE3/Core/OTFParticle.h

@@ -23,6 +23,7 @@
 #include <array>
 #include <bitset>
 #include <cmath>
+#include <cstddef>
 #include <cstdint>
 #include <span>
 
@@ -58,6 +59,9 @@ class OTFParticle
     if (particle.has_mothers()) {
       mIndicesMother = {particle.mothersIds().front(), particle.mothersIds().back()};
     }
+    if (particle.has_daughters()) {
+      mIndicesDaughter = {particle.daughtersIds().front(), particle.daughtersIds().back()};
+    }
     if constexpr (requires { particle.decayerBits(); }) {
       mBits = particle.decayerBits();
     } else {
@@ -88,6 +92,14 @@ class OTFParticle
     mPz = pz;
     mE = e;
   }
+  void setIndexOffset(const std::size_t offset)
+  {
+    static constexpr int NotFound = -1;
+    mIndicesMother[0] = (mIndicesMother[0] >= 0) ? mIndicesMother[0] + static_cast<int>(offset) : NotFound;
+    mIndicesMother[1] = (mIndicesMother[1] >= 0) ? mIndicesMother[1] + static_cast<int>(offset) : NotFound;
+    mIndicesDaughter[0] = (mIndicesDaughter[0] >= 0) ? mIndicesDaughter[0] + static_cast<int>(offset) : NotFound;
+    mIndicesDaughter[1] = (mIndicesDaughter[1] >= 0) ? mIndicesDaughter[1] + static_cast<int>(offset) : NotFound;
+  }
 
   // Getters
   int pdgCode() const { return mPdgCode; }
@@ -147,8 +159,8 @@ class OTFParticle
   std::span<const int> getMotherSpan() const { return hasMothers() ? std::span<const int>(mIndicesMother.data(), 2) : std::span<const int>(); }
 
   // Checks
-  bool hasDaughters() const { return (mIndicesDaughter[0] > 0); }
-  bool hasMothers() const { return (mIndicesMother[0] > 0); }
+  bool hasDaughters() const { return (mIndicesDaughter[0] >= 0); }
+  bool hasMothers() const { return (mIndicesMother[0] >= 0); }
   bool hasNaN() const
   {
     return std::isnan(mPx) || std::isnan(mPy) || std::isnan(mPz) || std::isnan(mE) ||
@@ -171,7 +183,7 @@ class OTFParticle
 
  private:
   int mPdgCode{}, mGlobalIndex{-1};
-  int mCollisionId{};
+  int mCollisionId{-1};
   float mVx{}, mVy{}, mVz{}, mVt{};
   float mPx{}, mPy{}, mPz{}, mE{};
   bool mIsAlive{}, mIsFromMcParticles{false};

ALICE3/Core/TrackUtilities.cxx

@@ -29,13 +29,13 @@
 #include <vector>
 
 void o2::upgrade::convertTLorentzVectorToO2Track(const int charge,
-                                                 const TLorentzVector particle,
-                                                 const std::vector<double> productionVertex,
+                                                 const TLorentzVector& particle,
+                                                 const std::vector<double>& productionVertex,
                                                  o2::track::TrackParCov& o2track)
 {
-  std::array<float, 5> params;
+  std::array<float, 5> params = {0.};
   std::array<float, 15> covm = {0.};
-  float s, c, x;
+  float s{}, c{}, x{};
   o2::math_utils::sincos(static_cast<float>(particle.Phi()), s, c);
   o2::math_utils::rotateZInv(static_cast<float>(productionVertex[0]), static_cast<float>(productionVertex[1]), x, params[0], s, c);
   params[1] = static_cast<float>(productionVertex[2]);
@@ -48,29 +48,27 @@ void o2::upgrade::convertTLorentzVectorToO2Track(const int charge,
   new (&o2track)(o2::track::TrackParCov)(x, particle.Phi(), params, covm);
 }
 
-float o2::upgrade::computeParticleVelocity(float momentum, float mass)
+float o2::upgrade::computeParticleVelocity(const float momentum, const float mass)
 {
   const float a = momentum / mass;
   // uses light speed in cm/ps so output is in those units
   return o2::constants::physics::LightSpeedCm2PS * a / std::sqrt((1.f + a * a));
 }
 
-float o2::upgrade::computeTrackLength(o2::track::TrackParCov track, float radius, float magneticField)
+float o2::upgrade::computeTrackLength(const o2::track::TrackParCov& track, const float radius, const float magneticField)
 {
   // don't make use of the track parametrization
   float length = -100;
 
   o2::math_utils::CircleXYf_t trcCircle;
-  float sna, csa;
+  float sna{}, csa{};
   track.getCircleParams(magneticField, trcCircle, sna, csa);
 
   // distance between circle centers (one circle is at origin -> easy)
   const float centerDistance = std::hypot(trcCircle.xC, trcCircle.yC);
 
   // condition of circles touching - if not satisfied returned length will be -100
   if (centerDistance < trcCircle.rC + radius && centerDistance > std::fabs(trcCircle.rC - radius)) {
-    length = 0.0f;
-
     // base radical direction
     const float ux = trcCircle.xC / centerDistance;
     const float uy = trcCircle.yC / centerDistance;
@@ -87,17 +85,17 @@ float o2::upgrade::computeTrackLength(o2::track::TrackParCov track, float radius
                                                        (centerDistance + trcCircle.rC + radius));
 
     // possible intercept points of track and TOF layer in 2D plane
-    const float point1[2] = {radical * ux + displace * vx, radical * uy + displace * vy};
-    const float point2[2] = {radical * ux - displace * vx, radical * uy - displace * vy};
+    const std::array<float, 2> point1 = {radical * ux + displace * vx, radical * uy + displace * vy};
+    const std::array<float, 2> point2 = {radical * ux - displace * vx, radical * uy - displace * vy};
 
     // decide on correct intercept point
-    std::array<float, 3> mom;
+    std::array<float, 3> mom{};
     track.getPxPyPzGlo(mom);
     const float scalarProduct1 = point1[0] * mom[0] + point1[1] * mom[1];
     const float scalarProduct2 = point2[0] * mom[0] + point2[1] * mom[1];
 
     // get start point
-    std::array<float, 3> startPoint;
+    std::array<float, 3> startPoint{};
     track.getXYZGlo(startPoint);
 
     float cosAngle = -1000, modulus = -1000;

ALICE3/Core/TrackUtilities.h

@@ -36,8 +36,8 @@ namespace o2::upgrade
 /// \param productionVertex where the particle was produced
 /// \param o2track the address of the resulting TrackParCov
 void convertTLorentzVectorToO2Track(const int charge,
-                                    const TLorentzVector particle,
-                                    const std::vector<double> productionVertex,
+                                    const TLorentzVector& particle,
+                                    const std::vector<double>& productionVertex,
                                     o2::track::TrackParCov& o2track);
 
 /// Function to convert a TLorentzVector into a perfect Track
@@ -47,9 +47,9 @@ void convertTLorentzVectorToO2Track(const int charge,
 /// \param o2track the address of the resulting TrackParCov
 /// \param pdg the pdg service
 template <typename PdgService>
-void convertTLorentzVectorToO2Track(int pdgCode,
-                                    TLorentzVector particle,
-                                    std::vector<double> productionVertex,
+void convertTLorentzVectorToO2Track(const int pdgCode,
+                                    const TLorentzVector& particle,
+                                    const std::vector<double>& productionVertex,
                                     o2::track::TrackParCov& o2track,
                                     const PdgService& pdg)
 {
@@ -80,7 +80,7 @@ void convertOTFParticleToO2Track(const OTFParticle& particle,
 /// \param o2track the address of the resulting TrackParCov
 /// \param pdg the pdg service
 template <typename McParticleType, typename PdgService>
-void convertMCParticleToO2Track(McParticleType& particle,
+void convertMCParticleToO2Track(const McParticleType& particle,
                                 o2::track::TrackParCov& o2track,
                                 const PdgService& pdg)
 {
@@ -94,7 +94,7 @@ void convertMCParticleToO2Track(McParticleType& particle,
 /// \param o2track the address of the resulting TrackParCov
 /// \param pdg the pdg service
 template <typename McParticleType, typename PdgService>
-o2::track::TrackParCov convertMCParticleToO2Track(McParticleType& particle,
+o2::track::TrackParCov convertMCParticleToO2Track(const McParticleType& particle,
                                                   const PdgService& pdg)
 {
   o2::track::TrackParCov o2track;
@@ -105,13 +105,13 @@ o2::track::TrackParCov convertMCParticleToO2Track(McParticleType& particle,
 /// returns velocity in centimeters per picoseconds
 /// \param momentum the momentum of the track
 /// \param mass the mass of the particle
-float computeParticleVelocity(float momentum, float mass);
+float computeParticleVelocity(const float momentum, const float mass);
 
 /// function to calculate track length of this track up to a certain radius
 /// \param track the input track (TrackParCov)
 /// \param radius the radius of the layer you're calculating the length to
 /// \param magneticField the magnetic field to use when propagating
-float computeTrackLength(o2::track::TrackParCov track, float radius, float magneticField);
+float computeTrackLength(const o2::track::TrackParCov& track, const float radius, const float magneticField);
 
 } // namespace o2::upgrade