Merge branch 'AliceO2Group:master' into master

Author: PaolaVT

Common/Tasks/centralityQa.cxx

@@ -88,6 +88,8 @@ constexpr const char PrefixCprTrackResonanceDaughter[] = "CprTrackResonanceDaugh
 constexpr const char PrefixCprTrackKinkDaughter[] = "CprTrackKinkDaughter";
 constexpr const char PrefixCprV0DaughterV0DaughterPos[] = "CprV0DaughterV0DaughterPos";
 constexpr const char PrefixCprV0DaughterV0DaughterNeg[] = "CprV0DaughterV0DaughterNeg";
+constexpr const char PrefixCprV0DaughterResoDaughterPos[] = "CprV0DaughterResoDaughterPos";
+constexpr const char PrefixCprV0DaughterResoDaughterNeg[] = "CprV0DaughterResoDaughterNeg";
 constexpr const char PrefixCprTrackCascadeBachelor[] = "CprTrackCascadeBachelor";
 
 // pairs
@@ -97,6 +99,8 @@ using ConfCprTrackResonanceDaughter = ConfCpr<PrefixCprTrackResonanceDaughter>;
 using ConfCprTrackKinkDaughter = ConfCpr<PrefixCprTrackKinkDaughter>;
 using ConfCprV0DaugherV0DaughterPos = ConfCpr<PrefixCprV0DaughterV0DaughterPos>;
 using ConfCprV0DaugherV0DaughterNeg = ConfCpr<PrefixCprV0DaughterV0DaughterNeg>;
+using ConfCprV0DaughterResoDaughterPos = ConfCpr<PrefixCprV0DaughterResoDaughterPos>;
+using ConfCprV0DaughterResoDaughterNeg = ConfCpr<PrefixCprV0DaughterResoDaughterNeg>;
 using ConfCprTrackCascadeBachelor = ConfCpr<PrefixCprTrackCascadeBachelor>;
 
 // tpc radii for computing phistar
@@ -112,6 +116,10 @@ constexpr char PrefixV0V0PosSe[] = "CPR_V0V0_PosDau/SE/";
 constexpr char PrefixV0V0NegSe[] = "CPR_V0V0_NegDau/SE/";
 constexpr char PrefixV0V0PosMe[] = "CPR_V0V0_PosDau/ME/";
 constexpr char PrefixV0V0NegMe[] = "CPR_V0V0_NegDau/ME/";
+constexpr char PrefixV0TwoTrackResonancePosSe[] = "CPR_V0Resonance_PosDau/SE/";
+constexpr char PrefixV0TwoTrackResonanceNegSe[] = "CPR_V0Resonance_NegDau/SE/";
+constexpr char PrefixV0TwoTrackResonancePosMe[] = "CPR_V0Resonance_PosDau/ME/";
+constexpr char PrefixV0TwoTrackResonanceNegMe[] = "CPR_V0Resonance_NegDau/ME/";
 constexpr char PrefixTrackTwoTrackResonanceSe[] = "CPR_TrackResonanceDau/SE/";
 constexpr char PrefixTrackTwoTrackResonanceMe[] = "CPR_TrackResonanceDau/ME/";
 constexpr char PrefixTrackCascadeBachelorSe[] = "CPR_TrackCascadeBachelor/SE/";

Common/Tasks/centralityStudy.cxx

@@ -820,6 +820,130 @@ class PairTrackTwoTrackResonanceBuilder
   int mMixingDepth = 5;
 };
 
+template <const char* prefixV0,
+          const char* prefixV0PosDau,
+          const char* prefixV0NegDau,
+          const char* prefixResonance,
+          const char* prefixResonancePosDau,
+          const char* prefixResonanceNegDau,
+          const char* prefixSe,
+          const char* prefixMe,
+          const char* prefixCprPosSe,
+          const char* prefixCprNegSe,
+          const char* prefixCprPosMe,
+          const char* prefixCprNegMe,
+          modes::V0 v0Type,
+          modes::TwoTrackResonance resonanceType>
+class PairV0TwoTrackResonanceBuilder
+{
+ public:
+  PairV0TwoTrackResonanceBuilder() = default;
+  ~PairV0TwoTrackResonanceBuilder() = default;
+
+  template <modes::Mode modeSe,
+            modes::Mode modeMe,
+            typename T1,
+            typename T2,
+            typename T3,
+            typename T4,
+            typename T5,
+            typename T6,
+            typename T7,
+            typename T8,
+            typename T9,
+            typename T10,
+            typename T11,
+            typename T12,
+            typename T13,
+            typename T14,
+            typename T15,
+            typename T16,
+            typename T17,
+            typename T18>
+  void init(o2::framework::HistogramRegistry* registry,
+            T1 const& confCollisionBinning,
+            T2 const& confV0Selection,
+            T3 const& confResonanceSelection,
+            T4 const& confCprPos,
+            T5 const& confCprNeg,
+            T6 const& confMixing,
+            T7 const& confPairBinning,
+            T8 const& confPairCuts,
+            std::map<T9, std::vector<o2::framework::AxisSpec>> const& colHistSpec,
+            std::map<T10, std::vector<o2::framework::AxisSpec>> const& v0HistSpec,
+            std::map<T11, std::vector<o2::framework::AxisSpec>> const& V0posDauHistSpec,
+            std::map<T12, std::vector<o2::framework::AxisSpec>> const& V0negDauHistSpec,
+            std::map<T13, std::vector<o2::framework::AxisSpec>> const& resonanceHistSpec,
+            std::map<T14, std::vector<o2::framework::AxisSpec>> const& ResonancePosDauHistSpec,
+            std::map<T15, std::vector<o2::framework::AxisSpec>> const& ResonanceNegDauHistSpec,
+            std::map<T16, std::vector<o2::framework::AxisSpec>> const& pairHistSpec,
+            std::map<T17, std::vector<o2::framework::AxisSpec>> const& cprHistSpecPos,
+            std::map<T18, std::vector<o2::framework::AxisSpec>> const& cprHistSpecNeg)
+  {
+    mColHistManager.template init<modeSe>(registry, colHistSpec, confCollisionBinning);
+
+    mV0HistManager.template init<modeSe>(registry, v0HistSpec, confV0Selection, V0posDauHistSpec, V0negDauHistSpec);
+    mResonanceHistManager.template init<modeSe>(registry, resonanceHistSpec, confResonanceSelection, ResonancePosDauHistSpec, ResonanceNegDauHistSpec);
+
+    mPairHistManagerSe.template init<modeSe>(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing);
+    mPairHistManagerSe.setMass(confV0Selection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value);
+    mPairHistManagerSe.setCharge(1, 1); // set charge to 1
+    mCprSe.init(registry, cprHistSpecPos, cprHistSpecNeg, confCprPos, confCprNeg);
+
+    mPairHistManagerMe.template init<modeMe>(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing);
+    mPairHistManagerMe.setMass(confV0Selection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value);
+    mPairHistManagerMe.setCharge(1, 1); // set charge to 1
+    mCprMe.init(registry, cprHistSpecPos, cprHistSpecNeg, confCprPos, confCprNeg);
+
+    // setup mixing
+    mMixingPolicy = static_cast<pairhistmanager::MixingPolicy>(confMixing.policy.value);
+    mMixingDepth = confMixing.depth.value;
+  }
+
+  template <modes::Mode mode, typename T1, typename T2, typename T3, typename T4, typename T5>
+  void processSameEvent(T1 const& col, T2& trackTable, T3& v0Partition, T4& resonancePartition, T5& cache)
+  {
+    auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    auto resonanaceSlice = resonancePartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache);
+    if (v0Slice.size() < nLimitPartitionParticles || resonanaceSlice.size() < nLimitPartitionParticles) {
+      return;
+    }
+    mColHistManager.template fill<mode>(col);
+    mCprSe.setMagField(col.magField());
+    pairprocesshelpers::processSameEvent<mode>(v0Slice, resonanaceSlice, trackTable, col, mV0HistManager, mResonanceHistManager, mPairHistManagerSe, mCprSe, mPc);
+  }
+
+  template <modes::Mode mode, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+  void processMixedEvent(T1 const& cols, T2& trackTable, T3& v0Partition, T4& resonancePartition, T5& cache, T6& binsVtxMult, T7& binsVtxCent, T8& binsVtxMultCent)
+  {
+    switch (mMixingPolicy) {
+      case static_cast<int>(pairhistmanager::kVtxMult):
+        pairprocesshelpers::processMixedEvent<mode>(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxMult, mMixingDepth, mPairHistManagerMe, mCprMe, mPc);
+        break;
+      case static_cast<int>(pairhistmanager::kVtxCent):
+        pairprocesshelpers::processMixedEvent<mode>(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc);
+        break;
+      case static_cast<int>(pairhistmanager::kVtxMultCent):
+        pairprocesshelpers::processMixedEvent<mode>(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxMultCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc);
+        break;
+      default:
+        LOG(fatal) << "Invalid binning policiy specifed. Breaking...";
+    }
+  }
+
+ private:
+  colhistmanager::CollisionHistManager mColHistManager;
+  v0histmanager::V0HistManager<prefixV0, prefixV0PosDau, prefixV0NegDau, v0Type> mV0HistManager;
+  twotrackresonancehistmanager::TwoTrackResonanceHistManager<prefixResonance, prefixResonancePosDau, prefixResonanceNegDau, resonanceType> mResonanceHistManager;
+  pairhistmanager::PairHistManager<prefixSe, modes::Particle::kV0, modes::Particle::kTwoTrackResonance> mPairHistManagerSe;
+  pairhistmanager::PairHistManager<prefixMe, modes::Particle::kV0, modes::Particle::kTwoTrackResonance> mPairHistManagerMe;
+  closepairrejection::ClosePairRejectionV0V0<prefixCprPosSe, prefixCprNegSe> mCprSe; // cpr for twotrackresonances and v0 work the same way
+  closepairrejection::ClosePairRejectionV0V0<prefixCprPosMe, prefixCprNegMe> mCprMe; // cpr for twotrackresonances and v0 work the same way
+  paircleaner::V0V0PairCleaner mPc;                                                  // pc for twotrackresonances and v0 work the same way
+  pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult;
+  int mMixingDepth = 5;
+};
+
 template <const char* prefixTrack,
           const char* prefixKink,
           const char* prefixChaDau,

PWGCF/EbyEFluctuations/Tasks/partNumFluc.cxx

@@ -111,7 +111,7 @@ class TrackTrackPairCleaner : public BasePairCleaner
   }
 };
 
-class V0V0PairCleaner : public BasePairCleaner
+class V0V0PairCleaner : public BasePairCleaner // also works for particles decaying into a positive and negative daughter, like resonances
 {
  public:
   V0V0PairCleaner() = default;
@@ -122,7 +122,9 @@ class V0V0PairCleaner : public BasePairCleaner
     auto negDaughter1 = trackTable.rawIteratorAt(v01.negDauId() - trackTable.offset());
     auto posDaughter2 = trackTable.rawIteratorAt(v02.posDauId() - trackTable.offset());
     auto negDaughter2 = trackTable.rawIteratorAt(v02.negDauId() - trackTable.offset());
-    return this->isCleanTrackPair(posDaughter1, posDaughter2) && this->isCleanTrackPair(negDaughter1, negDaughter2);
+    // check all charge combinations
+    return this->isCleanTrackPair(posDaughter1, posDaughter2) && this->isCleanTrackPair(negDaughter1, negDaughter2) &&
+           this->isCleanTrackPair(posDaughter1, negDaughter2) && this->isCleanTrackPair(negDaughter1, posDaughter2);
   }
 
   template <typename T1, typename T2, typename T3, typename T4>

PWGCF/Femto/Core/closePairRejection.h

@@ -351,6 +351,9 @@ constexpr char PrefixV0V0Me[] = "V0V0/ME/";
 constexpr char PrefixTrackResonanceSe[] = "TrackResonance/SE/";
 constexpr char PrefixTrackResonanceMe[] = "TrackResonance/ME/";
 
+constexpr char PrefixV0ResonanceSe[] = "V0Resonance/SE/";
+constexpr char PrefixV0ResonanceMe[] = "V0Resonance/ME/";
+
 constexpr char PrefixTrackCascadeSe[] = "TrackCascade/SE/";
 constexpr char PrefixTrackCascadeMe[] = "TrackCascade/ME/";
 

PWGCF/Femto/Core/pairBuilder.h

@@ -209,17 +209,16 @@ class ParticleCleaner
 
     return hasRequiredPdgCode && !hasRejectedPdgCode &&
            hasMotherWithRequiredPdgCode && !hasMotherWithRejectedPdgCode &&
-           hasPartonicMotherWithRequiredPdgCode &&
-           !hasPartonicMotherWithRejectedPdgCode;
+           hasPartonicMotherWithRequiredPdgCode && !hasPartonicMotherWithRejectedPdgCode;
   }
 
  private:
   bool mActivate = false;
   bool mRejectParticleWithoutMcParticle = true;
   bool mRejectParticleWithoutMcMother = true;
   bool mRejectParticleWithoutMcPartonicMother = true;
-  std::vector<int> mRequiredPdgCodes = {};
-  std::vector<int> mRejectedPdgCodes = {};
+  std::vector<int> mRequiredPdgCodes{};
+  std::vector<int> mRejectedPdgCodes{};
   std::vector<int> mRequiredMotherPdgCodes{};
   std::vector<int> mRejectedMotherPdgCodes{};
   std::vector<int> mRequiredPartonicMotherPdgCodes{};

PWGCF/Femto/Core/pairCleaner.h

@@ -210,7 +210,7 @@ class TwoTrackResonanceBuilder
     return ((mMass > mMassMin && mMass < mMassMax) &&
             (mPt > mPtMin && mPt < mPtMax) &&
             (mEta > mEtaMin && mEta < mEtaMax) &&
-            (mPhi > mPhiMin && mPhi < mPhiMax));
+            (mPhi >= mPhiMin && mPhi < mPhiMax));
   }
 
   template <typename T1, typename T2, typename T3, typename T4>
@@ -278,7 +278,7 @@ class TwoTrackResonanceBuilder
     if constexpr (modes::isEqual(resoType, modes::TwoTrackResonance::kKstar0Bar)) {
       if (mProduceKstar0s) {
         resonanceProducts.producedKstars(col.globalIndex(),
-                                         mPt,
+                                         -1.f * mPt,
                                          mEta,
                                          mPhi,
                                          mMass,

PWGCF/Femto/Core/pairHistManager.h

@@ -161,11 +161,11 @@ class TwoTrackResonanceHistManager
         negDauPdgCodeAbs = std::abs(PDG_t::kPiMinus);
       } else {
         mPdgCode = -1 * mPdgCode;
-        posDauPdgCodeAbs = std::abs(PDG_t::kKMinus);
-        negDauPdgCodeAbs = std::abs(PDG_t::kPiPlus);
+        posDauPdgCodeAbs = std::abs(PDG_t::kPiPlus);
+        negDauPdgCodeAbs = std::abs(PDG_t::kKMinus);
       }
     } else {
-      LOG(fatal) << "PDG code for V0 has to be either Lambda or K0short";
+      LOG(fatal) << "PDG code for Resonance has to be either Phi, Rho or K*0";
     }
 
     mPosDauManager.template init<mode>(registry, PosDauSpecs, absCharge, signPlus, posDauPdgCodeAbs);