Merge branch 'master' into modify_taskFlow

Author: AlexianL

ALICE3/CMakeLists.txt

@@ -12,6 +12,7 @@
 
 add_subdirectory(Core)
 # add_subdirectory(DataModel)
+add_subdirectory(ML)
 add_subdirectory(Tasks)
 add_subdirectory(TableProducer)
 add_subdirectory(Macros)

ALICE3/Core/OTFParticle.h

@@ -23,6 +23,7 @@
 #include <array>
 #include <bitset>
 #include <cmath>
+#include <cstddef>
 #include <cstdint>
 #include <span>
 
@@ -54,7 +55,7 @@ class OTFParticle
     mVt = particle.vt();
     mFlag = particle.flags();
     mStatusCode = particle.statusCode();
-    mIsFromMcParticles = true;
+    setBitOff(DecayerBits::ProducedByDecayer);
     if (particle.has_mothers()) {
       mIndicesMother = {particle.mothersIds().front(), particle.mothersIds().back()};
     }
@@ -71,7 +72,6 @@ class OTFParticle
   }
 
   // Setters
-  void setIsPrimary(const bool isPrimary) { mIsPrimary = isPrimary; }
   void setCollisionId(const int collisionId) { mCollisionId = collisionId; }
   void setPDG(const int pdg) { mPdgCode = pdg; }
   void setIndicesMother(const int start, const int stop) { mIndicesMother = {start, stop}; }
@@ -104,9 +104,9 @@ class OTFParticle
   int pdgCode() const { return mPdgCode; }
   int globalIndex() const { return mGlobalIndex; }
   int collisionId() const { return mCollisionId; }
-  bool isAlive() const { return mIsAlive; }
-  bool isPrimary() const { return mIsPrimary; }
-  bool isFromMcParticles() const { return mIsFromMcParticles; }
+  bool isAlive() const { return checkBit(DecayerBits::IsAlive); }
+  bool isPrimary() const { return checkBit(DecayerBits::IsPrimary); }
+  bool isFromMcParticles() const { return !checkBit(DecayerBits::ProducedByDecayer); }
   float weight() const
   {
     static constexpr float Weight = 1.f;
@@ -153,8 +153,8 @@ class OTFParticle
   int getMotherIndexStop() const { return mIndicesMother[1]; }
   int getDaughterIndexStart() const { return mIndicesDaughter[0]; }
   int getDaughterIndexStop() const { return mIndicesDaughter[1]; }
-  std::array<int, 2> getMothers() const { return mIndicesMother; }
-  std::array<int, 2> getDaughters() const { return mIndicesDaughter; }
+  const std::array<int, 2>& getMothers() const { return mIndicesMother; }
+  const std::array<int, 2>& getDaughters() const { return mIndicesDaughter; }
   std::span<const int> getMotherSpan() const { return hasMothers() ? std::span<const int>(mIndicesMother.data(), 2) : std::span<const int>(); }
 
   // Checks
@@ -176,7 +176,7 @@ class OTFParticle
   void setBitOn(DecayerBits bit) { mBits.set(static_cast<size_t>(bit), true); }
   void setBitOff(DecayerBits bit) { mBits.set(static_cast<size_t>(bit), false); }
 
-  std::bitset<8> getBits() const { return mBits; }
+  const std::bitset<8>& getBits() const { return mBits; }
   uint8_t getBitsValue() const { return static_cast<uint8_t>(mBits.to_ulong()); }
   void setBits(std::bitset<8> bits) { mBits = bits; }
 
@@ -185,8 +185,6 @@ class OTFParticle
   int mCollisionId{-1};
   float mVx{}, mVy{}, mVz{}, mVt{};
   float mPx{}, mPy{}, mPz{}, mE{};
-  bool mIsAlive{}, mIsFromMcParticles{false};
-  bool mIsPrimary{};
 
   int mStatusCode{};
   uint8_t mFlag{};

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
 

ALICE3/DataModel/OTFMulticharm.h

@@ -53,13 +53,6 @@ DECLARE_SOA_COLUMN(XiccDauDCA, xiccDauDCA, float);
 DECLARE_SOA_COLUMN(XiccDCAxy, xiccDCAxy, float);
 DECLARE_SOA_COLUMN(XiccDCAz, xiccDCAz, float);
 
-DECLARE_SOA_COLUMN(BachDCAxy, bachDCAxy, float);
-DECLARE_SOA_COLUMN(BachDCAz, bachDCAz, float);
-DECLARE_SOA_COLUMN(PosDCAxy, posDCAxy, float);
-DECLARE_SOA_COLUMN(PosDCAz, posDCAz, float);
-DECLARE_SOA_COLUMN(NegDCAxy, negDCAxy, float);
-DECLARE_SOA_COLUMN(NegDCAz, negDCAz, float);
-
 DECLARE_SOA_COLUMN(Pi1cDCAxy, pi1cDCAxy, float);
 DECLARE_SOA_COLUMN(Pi1cDCAz, pi1cDCAz, float);
 DECLARE_SOA_COLUMN(Pi2cDCAxy, pi2cDCAxy, float);
@@ -75,19 +68,9 @@ DECLARE_SOA_COLUMN(XicDistanceFromPV, xicDistanceFromPV, float);
 DECLARE_SOA_COLUMN(XiccProperLength, xiccProperLength, float);
 
 // Daughter info
-DECLARE_SOA_COLUMN(PosPt, posPt, float);
-DECLARE_SOA_COLUMN(PosEta, posEta, float);
-DECLARE_SOA_COLUMN(NegPt, negPt, float);
-DECLARE_SOA_COLUMN(NegEta, negEta, float);
-DECLARE_SOA_COLUMN(BachPt, bachPt, float);
-DECLARE_SOA_COLUMN(BachEta, bachEta, float);
-DECLARE_SOA_COLUMN(BachPhi, bachPhi, float);
 DECLARE_SOA_COLUMN(Pi1cPt, pi1cPt, float);
-DECLARE_SOA_COLUMN(Pi1cEta, pi1cEta, float);
 DECLARE_SOA_COLUMN(Pi2cPt, pi2cPt, float);
-DECLARE_SOA_COLUMN(Pi2cEta, pi2cEta, float);
 DECLARE_SOA_COLUMN(PiccPt, piccPt, float);
-DECLARE_SOA_COLUMN(PiccEta, piccEta, float);
 
 } // namespace otfmulticharm
 
@@ -133,26 +116,6 @@ DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores",
                   otfmulticharm::PiccPt,
                   otfmulticharm::LUTConfigId);
 
-DECLARE_SOA_TABLE(MCharmExtra, "AOD", "MCharmExtra",
-                  otfmulticharm::BachPt,
-                  otfmulticharm::BachEta,
-                  otfmulticharm::BachDCAxy,
-                  otfmulticharm::BachDCAz,
-
-                  otfmulticharm::PosPt,
-                  otfmulticharm::PosEta,
-                  otfmulticharm::PosDCAxy,
-                  otfmulticharm::PosDCAz,
-
-                  otfmulticharm::NegPt,
-                  otfmulticharm::NegEta,
-                  otfmulticharm::NegDCAxy,
-                  otfmulticharm::NegDCAz,
-
-                  otfmulticharm::Pi1cEta,
-                  otfmulticharm::Pi2cEta,
-                  otfmulticharm::PiccEta);
-
 } // namespace o2::aod
 
 #endif // ALICE3_DATAMODEL_OTFMULTICHARM_H_