Created sigma0 builder and table producer and wrote a ppSigma0 task

Author: yakparo

PWGCF/Femto/Core/closePairRejection.h

@@ -750,6 +750,44 @@ class ClosePairRejectionTrackKink
   CloseTrackRejection<prefix> mCtr;
 };
 
+// photon legs are not in the Track table so Sigma0 pairs only need to cross-check aganist dau lambda
+template <auto& prefixV0Daughter>
+class ClosePairRejectionTrackSigma0
+{
+ public:
+  template <typename T1>
+  void init(o2::framework::HistogramRegistry* registry,
+            std::map<CprHist, std::vector<o2::framework::AxisSpec>> const& specsV0Daughter,
+            T1 const& confCprV0Daughter,
+            int absChargeTrack)
+  {
+    mCtrV0Daughter.init(registry, specsV0Daughter, confCprV0Daughter, absChargeTrack, 1);
+  }
+
+  void setMagField(float magField)
+  {
+    mCtrV0Daughter.setMagField(magField);
+  }
+
+  template <typename T1, typename T2, typename T3, typename T4>
+  [[nodiscard]] bool isClosePair(T1 const& track, T2 const& sigma0, T3 const& trackTable, T4 const& pairHistManager)
+  {
+    bool isCloseV0Daughter = false;
+    if (track.sign() > 0) {
+      auto posDau = trackTable.rawIteratorAt(sigma0.posDauId() - trackTable.offset());
+      isCloseV0Daughter = mCtrV0Daughter.isClosePair(track, posDau, pairHistManager);
+    } else {
+      auto negDau = trackTable.rawIteratorAt(sigma0.negDauId() - trackTable.offset());
+      isCloseV0Daughter = mCtrV0Daughter.isClosePair(track, negDau, pairHistManager);
+    }
+
+    return isCloseV0Daughter;
+  }
+
+ private:
+  CloseTrackRejection<prefixV0Daughter> mCtrV0Daughter;
+};
+
 // PCM photon daughters are, for now, not indexed into the track table (see photonBuilder.h):
 // they are TPC-only tracks, so they cannot be confused for a global track the way two V0
 // daughters or a track and a V0 daughter can -- there is no detector-overlap effect to correct

PWGCF/Femto/Core/closeTripletRejection.h

@@ -30,12 +30,14 @@ namespace o2::analysis::femto::closetripletrejection
 constexpr const char PrefixCtrTrackTrackTrack[] = "CtrTrackTrackTrack";
 constexpr const char PrefixCtrTrackTrackV0[] = "CtrTrackTrackV0";
 constexpr const char PrefixCtrTrackTrackCascade[] = "CtrTrackTrackCascade";
+constexpr const char PrefixCtrTrackTrackSigma0[] = "CtrTrackTrackSigma0";
 constexpr const char PrefixCtrMcParticleMcParticleMcParticle[] = "CtrMcParticleMcParticleMcParticle";
 
 // Q3 (not kstar) is the natural kinematic variable for triplets, so it is the default here
 using ConfCtrTrackTrackTrack = closepairrejection::ConfCpr<PrefixCtrTrackTrackTrack, true, modes::KinematicVariable::kQ3>;
 using ConfCtrTrackTrackV0 = closepairrejection::ConfCpr<PrefixCtrTrackTrackV0, true, modes::KinematicVariable::kQ3>;
 using ConfCtrTrackTrackCascade = closepairrejection::ConfCpr<PrefixCtrTrackTrackCascade, true, modes::KinematicVariable::kQ3>;
+using ConfCtrTrackTrackSigma0 = closepairrejection::ConfCpr<PrefixCtrTrackTrackSigma0>;
 // generated particles, no cut by default (close triplet rejection corrects a detector effect)
 using ConfCtrMcParticleMcParticleMcParticle = closepairrejection::ConfCpr<PrefixCtrMcParticleMcParticleMcParticle, false, modes::KinematicVariable::kQ3>;
 
@@ -74,6 +76,11 @@ constexpr char PrefixTrack2CascadeBachelorSe[] = "CPR_Track2CascadeBachelor/SE/"
 constexpr char PrefixTrack1CascadeBachelorMe[] = "CPR_Track1CascadeBachelor/ME/";
 constexpr char PrefixTrack2CascadeBachelorMe[] = "CPR_Track2CascadeBachelor/ME/";
 
+constexpr char PrefixTrack1Sigma0Se[] = "CPR_Track1Sigma0/SE/";
+constexpr char PrefixTrack2Sigma0Se[] = "CPR_Track2Sigma0/SE/";
+constexpr char PrefixTrack1Sigma0Me[] = "CPR_Track1Sigma0/ME/";
+constexpr char PrefixTrack2Sigma0Me[] = "CPR_Track2Sigma0/ME/";
+
 template <auto& prefixTrack1Track2,
           auto& prefixTrack2Track3,
           auto& prefixTrack1Track3>
@@ -217,6 +224,49 @@ class CloseTripletRejectionTrackTrackCascade
   closepairrejection::ClosePairRejectionTrackCascade<prefixTrack2Bachelor, prefixTrack2V0Daughter> mCtrTrack2Cascade;
 };
 
+template <auto& prefixTrack1Track2, auto& prefixTrack1Sigma0, auto& prefixTrack2Sigma0>
+class CloseTripletRejectionTrackTrackSigma0
+{
+ public:
+  CloseTripletRejectionTrackTrackSigma0() = default;
+  ~CloseTripletRejectionTrackTrackSigma0() = default;
+
+  template <typename T1>
+  void init(o2::framework::HistogramRegistry* registry,
+            std::map<closepairrejection::CprHist, std::vector<o2::framework::AxisSpec>> const& specs,
+            T1 const& confCpr,
+            int absChargeTrack1,
+            int absChargeTrack2)
+  {
+    mCtrTrack12.init(registry, specs, confCpr, absChargeTrack1, absChargeTrack2);
+    mCtrTrack1Sigma0.init(registry, specs, confCpr, absChargeTrack1);
+    mCtrTrack2Sigma0.init(registry, specs, confCpr, absChargeTrack2);
+  }
+
+  void setMagField(float magField)
+  {
+    mCtrTrack12.setMagField(magField);
+    mCtrTrack1Sigma0.setMagField(magField);
+    mCtrTrack2Sigma0.setMagField(magField);
+  }
+
+  // checks track1-track2, track1-v0 and track2-v0 (from sigma0); fills the deta-dphi/kinematic
+  // histograms of each pair internally and returns whether the triplet is rejected.
+  template <typename T1, typename T2, typename T3, typename T4, typename T5>
+  [[nodiscard]] bool isCloseTriplet(T1 const& track1, T2 const& track2, T3 const& sigma0, T4 const& trackTable, T5 const& tripletHistManager)
+  {
+    bool isClose12 = mCtrTrack12.isClosePair(track1, track2, trackTable, tripletHistManager);
+    bool isClose1Sigma0 = mCtrTrack1Sigma0.isClosePair(track1, sigma0, trackTable, tripletHistManager);
+    bool isClose2Sigma0 = mCtrTrack2Sigma0.isClosePair(track2, sigma0, trackTable, tripletHistManager);
+    return isClose12 || isClose1Sigma0|| isClose2Sigma0;
+  }
+
+ private:
+  closepairrejection::ClosePairRejectionTrackTrack<prefixTrack1Track2> mCtrTrack12;
+  closepairrejection::ClosePairRejectionTrackSigma0<prefixTrack1Sigma0> mCtrTrack1Sigma0;
+  closepairrejection::ClosePairRejectionTrackSigma0<prefixTrack2Sigma0> mCtrTrack2Sigma0;
+};
+
 // close triplet rejection for triplets of generated particles; checks all three constituent pairs
 template <auto& prefixMcParticle1McParticle2,
           auto& prefixMcParticle2McParticle3,

PWGCF/Femto/Core/dataTypes.h

@@ -58,6 +58,10 @@ using CascadeMaskType = uint32_t;
 using CascadeMaskType001 = uint16_t; // old data type, was too narrow
 using CascadeType = uint16_t;
 
+// datatypes for sigma0
+using Sigma0MaskType = uint32_t;
+using Sigma0Type = uint16_t;
+
 // datatype for origin of mc particle
 using McOriginType = uint8_t;
 

PWGCF/Femto/Core/femtoUtils.h

@@ -135,6 +135,9 @@ inline double getPdgMass(int pdgCode)
     case kSigmaPlus:
       mass = o2::constants::physics::MassSigmaPlus;
       break;
+    case kSigma0:
+      mass = o2::constants::physics::MassSigma0;
+      break;
     case kXiMinus:
       mass = o2::constants::physics::MassXiMinus;
       break;

PWGCF/Femto/Core/modes.h

@@ -121,6 +121,7 @@ enum class Particle : o2::analysis::femto::datatypes::ParticleType {
   kCascade = 5,
   kCharmHadron = 6,
   kTwoPhotonResonance = 7,
+  kSigma0 = 8
 };
 
 enum class McOrigin : o2::analysis::femto::datatypes::McOriginType {

PWGCF/Femto/Core/particleCleaner.h

@@ -78,6 +78,9 @@ constexpr const char PrefixSigmaPlusPcmCleaner2[] = "SigmaPlusPcmCleaner2";
 using ConfSigmaPlusPcmCleaner1 = ConfParticleCleaner<PrefixSigmaPlusPcmCleaner1>;
 using ConfSigmaPlusPcmCleaner2 = ConfParticleCleaner<PrefixSigmaPlusPcmCleaner2>;
 
+constexpr const char PrefixSigma0Cleaner[] = "Sigma0Cleaner";
+using ConfSigma0Cleaner = ConfParticleCleaner<PrefixSigma0Cleaner>;
+
 constexpr const char PrefixXiCleaner1[] = "XiCleaner1";
 constexpr const char PrefixXiCleaner2[] = "XiCleaner2";
 using ConfXiCleaner1 = ConfParticleCleaner<PrefixXiCleaner1>;

PWGCF/Femto/Core/partitions.h

@@ -259,6 +259,20 @@
     (o2::aod::femtokinks::mlScore >= (selection).mlScoreMin) &&                                                                                \
     ncheckbit(o2::aod::femtokinks::mask, (selection).mask)
 
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define MAKE_SIGMA0_PARTITION(selection)                                                                                                       \
+  ifnode((selection).sign.node() != 0,                                                                                                         \
+         ifnode((selection).sign.node() > 0, o2::aod::femtobase::stored::signedPt > 0.f, o2::aod::femtobase::stored::signedPt < 0.f), true) && \
+    (nabs(o2::aod::femtobase::stored::signedPt) > (selection).ptMin) &&                                                                        \
+    (nabs(o2::aod::femtobase::stored::signedPt) < (selection).ptMax) &&                                                                        \
+    (o2::aod::femtobase::stored::eta > (selection).etaMin) &&                                                                                  \
+    (o2::aod::femtobase::stored::eta < (selection).etaMax) &&                                                                                  \
+    (o2::aod::femtobase::stored::phi > (selection).phiMin) &&                                                                                  \
+    (o2::aod::femtobase::stored::phi < (selection).phiMax) &&                                                                                  \
+    (o2::aod::femtobase::stored::mass > (selection).massMin) &&                                                                                \
+    (o2::aod::femtobase::stored::mass < (selection).massMax) &&                                                                                \
+    ncheckbit(o2::aod::femtosigma0s::mask, (selection).mask)
+
 // partition for D0
 // sign of signedPt encodes the hypothesis: D0 (+) / D0bar (-)
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)