Merge branch 'AliceO2Group:master' into PID-Hadrons-in-Jets

Author: llorenc-11

ALICE3/Core/OTFParticle.h

@@ -23,6 +23,7 @@
 #include <array>
 #include <bitset>
 #include <cmath>
+#include <cstddef>
 #include <cstdint>
 #include <span>
 

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/TableProducer/OTF/onTheFlyDecayer.cxx

@@ -30,6 +30,7 @@
 #include <Framework/InitContext.h>
 #include <Framework/O2DatabasePDGPlugin.h>
 #include <Framework/OutputObjHeader.h>
+#include <Framework/StringHelpers.h>
 #include <Framework/runDataProcessing.h>
 #include <ReconstructionDataFormats/Track.h>
 
@@ -165,7 +166,7 @@ struct OnTheFlyDecayer {
         daughter.setCollisionId(particle.collisionId());
         daughter.setBitOn(o2::upgrade::DecayerBits::IsAlive);
         daughter.setBitOff(o2::upgrade::DecayerBits::IsPrimary);
-        daughter.setProductionTime(trackTimeNS);
+        daughter.setProductionTime(particle.vt() + trackTimeNS);
         allParticles.push_back(daughter);
       }
       ndau += decayStack.size();

ALICE3/TableProducer/alice3strangenessFinder.cxx

@@ -88,6 +88,7 @@ struct Alice3strangenessFinder {
   ConfigurableAxis axisXiMass{"axisXiMass", {200, 1.22f, 1.42f}, "Xi mass axis"};
   ConfigurableAxis axisOmegaMass{"axisOmegaMass", {200, 1.57f, 1.77f}, "Omega mass axis"};
 
+  ConfigurableAxis axisDCA{"axisDCA", {200, 0, 200}, "DCA axis"};
   ConfigurableAxis axisEta{"axisEta", {80, -4.f, 4.f}, "Eta axis"};
   ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.025f, 0.05f, 0.075f, 0.1f, 0.125f, 0.15f, 0.175f, 0.2f, 0.225f, 0.25f, 0.275f, 0.3f, 0.325f, 0.35f, 0.375f, 0.4f, 0.425f, 0.45f, 0.475f, 0.5f, 0.525f, 0.55f, 0.575f, 0.6f, 0.625f, 0.65f, 0.675f, 0.7f, 0.725f, 0.75f, 0.775f, 0.8f, 0.82f, 0.85f, 0.875f, 0.9f, 0.925f, 0.95f, 0.975f, 1.0f, 1.05f, 1.1f}, "pt axis for QA histograms"};
 
@@ -129,6 +130,7 @@ struct Alice3strangenessFinder {
 
     Configurable<float> v0MaxDauDCA{"v0MaxDauDCA", 0.005f, "DCA between v0 daughters (cm)"};
     Configurable<float> cascMaxDauDCA{"cascMaxDauDCA", 0.005f, "DCA between cascade daughters (cm)"};
+    Configurable<float> cascMaxEta{"cascMaxEta", 2.5f, "DCA between cascade daughters (cm)"};
   } presel;
 
   // Operation
@@ -143,6 +145,7 @@ struct Alice3strangenessFinder {
 
   o2::vertexing::DCAFitterN<2> fitter;
   Service<o2::framework::O2DatabasePDG> pdgDB;
+  static constexpr float ToMicrons = 1e+4;
 
   // partitions for v0/casc dau tracks
   Partition<Alice3TracksACTS> positiveSecondaryTracksACTS =
@@ -177,6 +180,7 @@ struct Alice3strangenessFinder {
 
   struct Candidate {
     int index{-1};
+
     // decay properties
     float dcaDau{};
     float eta{};
@@ -239,6 +243,7 @@ struct Alice3strangenessFinder {
     histos.add("hPtPosDauAfterV0Finding", "", kTH2D, {axisPt, axisPt});
     histos.add("hPtNegDauAfterV0Finding", "", kTH2D, {axisPt, axisPt});
     histos.add("hEventCounter", "", kTH1D, {{1, 0, 2}}); // counting processed events
+
     auto hV0Counter = histos.add<TH1>("hV0Counter", "hV0Counter", kTH1D, {{4, 0, 4}});
     hV0Counter->GetXaxis()->SetBinLabel(1, "K0S");
     hV0Counter->GetXaxis()->SetBinLabel(2, "Lambda");
@@ -248,9 +253,6 @@ struct Alice3strangenessFinder {
     histos.add("hRadiusVsHitsNeg", "", kTH2D, {{400, 0, 400}, {12, 0.5, 12.5}}); // radius vs hist for MC studies
     histos.add("hRadiusVsHitsPos", "", kTH2D, {{400, 0, 400}, {12, 0.5, 12.5}}); // radius vs hist for MC studies
 
-    histos.add("hXiMass", "", kTH1D, {axisXiMass});
-    histos.add("hOmegaMass", "", kTH1D, {axisOmegaMass});
-
     auto hV0Building = histos.add<TH1>("hV0Building", "hV0Building", kTH1D, {{10, 0.5, 10.5}});
     hV0Building->GetXaxis()->SetBinLabel(1, "Pair");
     hV0Building->GetXaxis()->SetBinLabel(2, "Pdg check");
@@ -272,6 +274,12 @@ struct Alice3strangenessFinder {
       histos.add("Generated/hGeneratedAntiOmega", "hGeneratedAntiOmega", kTH2D, {{axisPt}, {axisEta}});
     }
 
+    if (buildCascade) {
+      histos.add("CascadeBuilding/hDcaBetweenDaus", "hDcaBetweenDaus", kTH1D, {{axisDCA}});
+      histos.add("CascadeBuilding/hXiMass", "", kTH1D, {axisXiMass});
+      histos.add("CascadeBuilding/hOmegaMass", "", kTH1D, {axisOmegaMass});
+    }
+
     histos.print();
   }
 
@@ -585,6 +593,19 @@ struct Alice3strangenessFinder {
             continue; // failed at building candidate
           }
 
+          // Apply preselections
+          if (cascCand.dcaDau > presel.cascMaxDauDCA) {
+            continue; // combined tracks should be reasonanly close
+          }
+
+          if (cascCand.eta > presel.cascMaxEta) {
+            continue; // candidate outside of acceptance
+          }
+
+          if (std::hypot(v0Cand.posSV[0], v0Cand.posSV[1]) < std::hypot(cascCand.posSV[0], cascCand.posSV[1])) {
+            continue; // causality
+          }
+
           const float massXi = RecoDecay::m(std::array{std::array{cascCand.pDau0[0], cascCand.pDau0[1], cascCand.pDau0[2]},
                                                        std::array{cascCand.pDau1[0], cascCand.pDau1[1], cascCand.pDau1[2]}},
                                             std::array{o2::constants::physics::MassLambda, o2::constants::physics::MassPionCharged});
@@ -606,8 +627,9 @@ struct Alice3strangenessFinder {
                                                              vtx[0], vtx[1], vtx[2]);
 
           histos.fill(HIST("hCascadeBuilding"), 4.0);
-          histos.fill(HIST("hXiMass"), massXi);
-          histos.fill(HIST("hOmegaMass"), massOm);
+          histos.fill(HIST("CascadeBuilding/hDcaBetweenDaus"), cascCand.dcaDau * ToMicrons);
+          histos.fill(HIST("CascadeBuilding/hXiMass"), massXi);
+          histos.fill(HIST("CascadeBuilding/hOmegaMass"), massOm);
 
           tableA3CascadeMcLabels(cascCand.index);
           tableCascIndices(0, // cascade index, dummy value

ALICE3/Tasks/alice3-cdeuteron.cxx

@@ -26,14 +26,13 @@
 #include <Framework/OutputObjHeader.h>
 #include <Framework/SliceCache.h>
 #include <Framework/runDataProcessing.h>
+#include <GPU/GPUROOTCartesianFwd.h>
 
 #include <TH1.h>
 #include <TLorentzVector.h>
 #include <TMath.h>
 #include <TString.h>
 
-#include <GPUROOTCartesianFwd.h>
-
 #include <array>
 #include <cmath>
 

ALICE3/Tasks/alice3-dilepton.cxx

@@ -24,12 +24,20 @@
 #include <CommonConstants/PhysicsConstants.h>
 #include <Framework/ASoAHelpers.h>
 #include <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisHelpers.h>
 #include <Framework/AnalysisTask.h>
+#include <Framework/Configurable.h>
 #include <Framework/HistogramRegistry.h>
+#include <Framework/HistogramSpec.h>
+#include <Framework/InitContext.h>
 #include <Framework/O2DatabasePDGPlugin.h>
+#include <Framework/OutputObjHeader.h>
 #include <Framework/runDataProcessing.h>
 
-#include <Math/Vector4D.h>
+#include <Math/Vector4D.h> // IWYU pragma: keep (do not replace with Math/Vector4Dfwd.h)
+#include <Math/Vector4Dfwd.h>
+#include <THnSparse.h>
+#include <TMath.h>
 
 #include <vector>
 

ALICE3/Tasks/alice3-prefilterdilepton.cxx

@@ -14,25 +14,32 @@
 /// \author  s.scheid@cern.ch, daiki.sekihata@cern.ch
 ///
 
-#include "ALICE3/DataModel/OTFCollision.h"
 #include "ALICE3/DataModel/OTFRICH.h"
 #include "ALICE3/DataModel/OTFTOF.h"
 #include "ALICE3/DataModel/prefilterDilepton.h"
 #include "ALICE3/DataModel/tracksAlice3.h"
-#include "Common/DataModel/TrackSelectionTables.h"
 
 #include <CommonConstants/PhysicsConstants.h>
 #include <Framework/ASoAHelpers.h>
 #include <Framework/AnalysisDataModel.h>
+#include <Framework/AnalysisHelpers.h>
 #include <Framework/AnalysisTask.h>
+#include <Framework/Configurable.h>
 #include <Framework/HistogramRegistry.h>
+#include <Framework/HistogramSpec.h>
+#include <Framework/InitContext.h>
 #include <Framework/O2DatabasePDGPlugin.h>
+#include <Framework/OutputObjHeader.h>
 #include <Framework/runDataProcessing.h>
 #include <MathUtils/Utils.h>
 
 #include <Math/GenVector/VectorUtil.h>
-#include <Math/Vector4D.h>
+#include <Math/Vector4D.h> // IWYU pragma: keep (do not replace with Math/Vector4Dfwd.h)
+#include <Math/Vector4Dfwd.h>
+#include <TMath.h>
 
+#include <cstdint>
+#include <cstdlib>
 #include <unordered_map>
 #include <vector>