Merge remote-tracking branch 'upstream/master' into track-rotation-ep-preserving-mepm-rotated-legs

Author: ayatsuji

.clang-tidy

@@ -113,6 +113,56 @@ WarningsAsErrors: >-
   -readability-suspicious-call-argument,
   -modernize-*,
   -readability-*,
+  -bugprone-assignment-in-if-condition,
+  -bugprone-branch-clone,
+  -bugprone-copy-constructor-init,
+  -bugprone-empty-catch,
+  -bugprone-exception-escape,
+  -bugprone-fold-init-type,
+  -bugprone-incorrect-roundings,
+  -bugprone-integer-division,
+  -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
+  -bugprone-non-zero-enum-to-bool-conversion,
+  -bugprone-redundant-branch-condition,
+  -bugprone-reserved-identifier,
+  -bugprone-suspicious-include,
+  -bugprone-suspicious-missing-comma,
+  -bugprone-switch-missing-default-case,
+  -bugprone-too-small-loop-variable,
+  -bugprone-unchecked-optional-access,
+  -bugprone-unsafe-functions,
+  -bugprone-unused-local-non-trivial-variable,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-macro-usage,
+  -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-slicing,
+  -cppcoreguidelines-virtual-class-destructor,
+# Positives for the following checks are currently being fixed and should be reported as errors.
+# clang-analyzer-*
+# clang-diagnostic-*
+# google-default-arguments
+# misc-include-cleaner
+# misc-redundant-expression
+# misc-unused-parameters
+# performance-for-range-copy
+# performance-inefficient-string-concatenation
+# performance-inefficient-vector-operation
+# performance-move-const-arg
+# performance-no-automatic-move
+# performance-type-promotion-in-math-fn
+# performance-unnecessary-copy-initialization
+# performance-unnecessary-value-param
 CheckOptions:
   modernize-avoid-c-arrays.AllowStringArrays: true
   # Common tolerated conversions

ALICE3/Core/CMakeLists.txt

@@ -20,6 +20,7 @@ o2physics_add_library(ALICE3Core
 o2physics_target_root_dictionary(ALICE3Core
                       HEADERS TrackUtilities.h
                               FlatLutEntry.h
+                              OTFParticle.h
                               GeometryContainer.h
                       LINKDEF ALICE3CoreLinkDef.h)
 

ALICE3/Core/Decayer.h

@@ -31,13 +31,12 @@
 #include <TLorentzVector.h>
 #include <TRandom3.h>
 
+#include <array>
 #include <cmath>
 #include <cstddef>
 #include <vector>
 
-namespace o2
-{
-namespace upgrade
+namespace o2::upgrade
 {
 
 class Decayer
@@ -47,44 +46,27 @@ class Decayer
   Decayer() = default;
 
   template <typename TDatabase>
-  std::vector<o2::upgrade::OTFParticle> decayParticle(const TDatabase& pdgDB, const OTFParticle& particle)
+  std::vector<o2::upgrade::OTFParticle> decayParticle(const OTFParticle& particle, const TDatabase& pdgDB)
   {
-    const auto& particleInfo = pdgDB->GetParticle(particle.pdgCode());
+    auto particleInfo = pdgDB->GetParticle(particle.pdgCode());
     if (!particleInfo) {
       return {};
     }
 
     const int charge = particleInfo->Charge() / 3;
     const double mass = particleInfo->Mass();
-
-    const double u = mRand3.Uniform(0.001, 0.999);
-    const double ctau = o2::constants::physics::LightSpeedCm2S * particleInfo->Lifetime(); // cm
-    const double betaGamma = particle.p() / mass;
-    const double rxyz = -betaGamma * ctau * std::log(1 - u);
-    double px, py, e;
+    std::array<double, 3> decayVtx = generateDecayVertex<double>(particle, pdgDB);
+    mVx = decayVtx[0];
+    mVy = decayVtx[1];
+    mVz = decayVtx[2];
+    double px{}, py{}, e{};
 
     if (!charge) {
-      mVx = particle.vx() + rxyz * (particle.px() / particle.p());
-      mVy = particle.vy() + rxyz * (particle.py() / particle.p());
-      mVz = particle.vz() + rxyz * (particle.pz() / particle.p());
       px = particle.px();
       py = particle.py();
     } else {
-      o2::track::TrackParCov track;
-      o2::math_utils::CircleXYf_t circle;
-      o2::upgrade::convertOTFParticleToO2Track(particle, track, pdgDB);
-
-      float sna{}, csa{};
-      track.getCircleParams(mBz, circle, sna, csa);
-      const double rxy = rxyz / std::sqrt(1. + track.getTgl() * track.getTgl());
-      const double theta = rxy / circle.rC;
-
-      mVx = ((particle.vx() - circle.xC) * std::cos(theta) - (particle.vy() - circle.yC) * std::sin(theta)) + circle.xC;
-      mVy = ((particle.vy() - circle.yC) * std::cos(theta) + (particle.vx() - circle.xC) * std::sin(theta)) + circle.yC;
-      mVz = particle.vz() + rxyz * (particle.pz() / track.getP());
-
-      px = particle.px() * std::cos(theta) - particle.py() * std::sin(theta);
-      py = particle.py() * std::cos(theta) + particle.px() * std::sin(theta);
+      px = particle.px() * std::cos(mTheta) - particle.py() * std::sin(mTheta);
+      py = particle.py() * std::cos(mTheta) + particle.px() * std::sin(mTheta);
     }
 
     double brTotal = 0.;
@@ -133,6 +115,42 @@ class Decayer
     return decayProducts;
   }
 
+  template <typename T = float, typename TDatabase, typename TParticle>
+  std::array<T, 3> generateDecayVertex(const TParticle& particle, const TDatabase& pdgDB)
+  {
+    std::array<T, 3> decayVertex{};
+    auto particleInfo = pdgDB->GetParticle(particle.pdgCode());
+    if (!particleInfo) {
+      return {};
+    }
+
+    const int charge = particleInfo->Charge() / 3;
+    const double mass = particleInfo->Mass();
+    const double u = mRand3.Uniform(0.001, 0.999);
+    const double ctau = o2::constants::physics::LightSpeedCm2S * particleInfo->Lifetime(); // cm
+    const double betaGamma = particle.p() / mass;
+    const double rxyz = -betaGamma * ctau * std::log(1 - u);
+
+    if (!charge) {
+      decayVertex[0] = particle.vx() + rxyz * (particle.px() / particle.p());
+      decayVertex[1] = particle.vy() + rxyz * (particle.py() / particle.p());
+      decayVertex[2] = particle.vz() + rxyz * (particle.pz() / particle.p());
+    } else {
+      o2::math_utils::CircleXYf_t circle;
+      o2::track::TrackParCov track = o2::upgrade::convertMCParticleToO2Track(particle, pdgDB);
+
+      float sna{}, csa{};
+      track.getCircleParams(mBz, circle, sna, csa);
+      const double rxy = rxyz / std::sqrt(1. + track.getTgl() * track.getTgl());
+      mTheta = rxy / circle.rC;
+
+      decayVertex[0] = ((particle.vx() - circle.xC) * std::cos(mTheta) - (particle.vy() - circle.yC) * std::sin(mTheta)) + circle.xC;
+      decayVertex[1] = ((particle.vy() - circle.yC) * std::cos(mTheta) + (particle.vx() - circle.xC) * std::sin(mTheta)) + circle.yC;
+      decayVertex[2] = particle.vz() + rxyz * (particle.pz() / track.getP());
+    }
+    return decayVertex;
+  }
+
   // Setters
   void setBField(const double b) { mBz = b; }
   void setSeed(const int seed)
@@ -142,18 +160,18 @@ class Decayer
   }
 
   // Getters
-  float getSecondaryVertexX() const { return static_cast<float>(mVx); }
-  float getSecondaryVertexY() const { return static_cast<float>(mVy); }
-  float getSecondaryVertexZ() const { return static_cast<float>(mVz); }
-  float getDecayRadius() const { return static_cast<float>(std::hypot(mVx, mVy)); }
+  [[nodiscard]] float getSecondaryVertexX() const { return static_cast<float>(mVx); }
+  [[nodiscard]] float getSecondaryVertexY() const { return static_cast<float>(mVy); }
+  [[nodiscard]] float getSecondaryVertexZ() const { return static_cast<float>(mVz); }
+  [[nodiscard]] float getDecayRadius() const { return static_cast<float>(std::hypot(mVx, mVy)); }
 
  private:
   double mBz{20.}; // kG
   double mVx{-1.}, mVy{-1.}, mVz{-1.};
-  TRandom3 mRand3{};
+  double mTheta{};
+  TRandom3 mRand3;
 };
 
-} // namespace upgrade
-} // namespace o2
+} // namespace o2::upgrade
 
 #endif // ALICE3_CORE_DECAYER_H_

ALICE3/Core/DelphesO2LutWriter.cxx

@@ -376,7 +376,7 @@ void DelphesO2LutWriter::diagonalise(lutEntry_t& lutEntry)
   // m.Print();
   TMatrixDSymEigen eigen(m);
   // eigenvalues vector
-  TVectorD eigenVal = eigen.GetEigenValues();
+  const TVectorD& eigenVal = eigen.GetEigenValues();
   for (int i = 0; i < kEig; ++i)
     lutEntry.eigval[i] = eigenVal[i];
   // eigenvectors matrix