Merge branch 'master' into hf-clang-tidy

Author: vkucera

PWGCF/DataModel/FemtoDerived.h

@@ -245,14 +245,14 @@ DECLARE_SOA_COLUMN(Prong2Eta, prong2Eta, float);                    //! Track et
 DECLARE_SOA_COLUMN(Prong0Phi, prong0Phi, float);                    //! Track phi of charm hadron prong0
 DECLARE_SOA_COLUMN(Prong1Phi, prong1Phi, float);                    //! Track phi of charm hadron prong1
 DECLARE_SOA_COLUMN(Prong2Phi, prong2Phi, float);                    //! Track phi of charm hadron prong2
-DECLARE_SOA_COLUMN(CandidateSelFlag, candidateSelFlag, int8_t);     //! Selection of mass hypothesis for charm hadron (1 for Lc -> pkpi, 2 for Lc -> pikp, 4 for D+ -> pikpi)
+DECLARE_SOA_COLUMN(CandidateSelFlag, candidateSelFlag, int);        //! Selection of mass hypothesis for charm hadron (1 for Lc -> pkpi, 2 for Lc -> pikp, 4 for D+ -> pikpi)
 DECLARE_SOA_COLUMN(BDTBkg, bdtBkg, float);                          //! Background score using Boosted Decision Tree for charm hadron
 DECLARE_SOA_COLUMN(BDTPrompt, bdtPrompt, float);                    //! Prompt signal score using Boosted Decision Tree for charm hadron
 DECLARE_SOA_COLUMN(BDTFD, bdtFD, float);                            //! Feed-down score using Boosted Decision Tree for charm hadron
-DECLARE_SOA_COLUMN(FlagMc, flagMc, int8_t);                         //! To select MC particle among charm hadrons, { DplusToPiKPi = 1, LcToPKPi = 2, DsToKKPi = 4, XicToPKP = 8, N3ProngD = 2ecays };
-DECLARE_SOA_COLUMN(OriginMcRec, originMcRec, int8_t);               //! flag for reconstruction level matching (1 for prompt, 2 for non-prompt)
-DECLARE_SOA_COLUMN(OriginMcGen, originMcGen, int8_t);               //! flag for generator level matching (1 for prompt, 2 for non-prompt)
-DECLARE_SOA_COLUMN(IsCandidateSwapped, isCandidateSwapped, int8_t); //! swapping of the prongs order (0 for Lc -> pkpi, 1 for Lc -> pikp)
+DECLARE_SOA_COLUMN(FlagMc, flagMc, int);                            //! To select MC particle among charm hadrons, { DplusToPiKPi = 1, LcToPKPi = 17, DsToKKPi = 6, XicToPKPi = 21, N3ProngD = 2ecays };
+DECLARE_SOA_COLUMN(OriginMcRec, originMcRec, int);                  //! flag for reconstruction level matching (1 for prompt, 2 for non-prompt)
+DECLARE_SOA_COLUMN(OriginMcGen, originMcGen, int);                  //! flag for generator level matching (1 for prompt, 2 for non-prompt)
+DECLARE_SOA_COLUMN(IsCandidateSwapped, isCandidateSwapped, int);    //! swapping of the prongs order (0 for Lc -> pkpi, 1 for Lc -> pikp)
 DECLARE_SOA_COLUMN(TrkPt, trkPt, float);                            //! Transverse momentum of associate femto particle
 DECLARE_SOA_COLUMN(TrkEta, trkEta, float);                          //! Eta of associate femto particle
 DECLARE_SOA_COLUMN(TrkPhi, trkPhi, float);                          //! Phi of associate femto particle

PWGCF/Femto/FemtoNuclei/TableProducer/PiNucleiFemto.cxx

@@ -164,13 +164,16 @@ struct PiNucleiFemto {
   Configurable<float> settingCutEta{"settingCutEta", 0.8f, "Eta cut on daughter track"};
   Configurable<float> settingCutChi2tpcLow{"settingCutChi2tpcLow", 0.0f, "Low cut on TPC chi2"};
   Configurable<float> settingCutChi2tpcHigh{"settingCutChi2tpcHigh", 999.f, "High cut on TPC chi2"};
+  Configurable<float> settingCutChi2tpcLowPion{"settingCutChi2tpcLowPion", 0.5f, "Low cut on TPC chi2 only for pion"};
+  Configurable<float> settingCutChi2tpcHighPion{"settingCutChi2tpcHighPion", 4.f, "High cut on TPC chi2 only for pion"};
   Configurable<float> settingCutInvMass{"settingCutInvMass", 0.0f, "Invariant mass upper limit"};
   Configurable<float> settingCutPtMinDePi{"settingCutPtMinDePi", 0.0f, "Minimum PT cut on DePi4"};
   Configurable<float> settingCutClSizeItsDe{"settingCutClSizeItsDe", 4.0f, "Minimum ITS cluster size for De"};
   Configurable<float> settingCutNCls{"settingCutNCls", 5.0f, "Minimum ITS Ncluster for tracks"};
   Configurable<float> settingCutTPCChi2He{"settingCutTPCChi2He", 0.0f, "Minimum tpcChi2He for Hyper He3"};
   Configurable<float> settingCutAverClsSizeHe{"settingCutAverClsSizeHe", 0.0f, "Minimum averClusSizeHe for Hyper He3"};
   Configurable<float> settingCutChi2NClITS{"settingCutChi2NClITS", 999.f, "Maximum ITS Chi2 for tracks"};
+  Configurable<float> settingCutChi2NClITSPion{"settingCutChi2NClITSPion", 36.f, "Maximum ITS Chi2 for tracks only for pion"};
   Configurable<float> settingCutNsigmaTPCPi{"settingCutNsigmaTPCPi", 3.0f, "Value of the TPC Nsigma cut on Pi"};
   Configurable<float> settingCutNsigmaTPCDe{"settingCutNsigmaTPCDe", 2.5f, "Value of the TPC Nsigma cut on De"};
   Configurable<float> settingCutNsigmaITSDe{"settingCutNsigmaITSDe", 2.5f, "Value of the ITD Nsigma cut on De"};
@@ -180,6 +183,7 @@ struct PiNucleiFemto {
   Configurable<float> settingCutNsigmaTOFTPCPi{"settingCutNsigmaTOFTPCPi", 3.0f, "Value of the Pion TOF TPC Nsigma cut"};
   Configurable<int> settingNoMixedEvents{"settingNoMixedEvents", 5, "Number of mixed events per event"};
   Configurable<bool> settingEnableBkgUS{"settingEnableBkgUS", false, "Enable US background"};
+  Configurable<bool> settingSaferME{"settingSaferME", false, "For Safer ME"};
 
   Configurable<bool> settingFillTable{"settingFillTable", false, "Enable table filling"};
   Configurable<float> settingCutPiptMin{"settingCutPiptMin", 0.14f, "Minimum PT cut on Pi"};
@@ -283,6 +287,7 @@ struct PiNucleiFemto {
      {"hkStaVsmTVsCent_US_M", ";kStar (GeV/c);mT (GeV/#it{c}^{2});Centrality", {HistType::kTH3F, {{300, 0.0f, 3.0f}, {100, 0.2f, 3.2f}, {100, 0.0f, 100.0f}}}},
      {"hkStaVsmTVsCent_US_A", ";kStar (GeV/c);mT (GeV/#it{c}^{2});Centrality", {HistType::kTH3F, {{300, 0.0f, 3.0f}, {100, 0.2f, 3.2f}, {100, 0.0f, 100.0f}}}},
      {"hCollIDVsCentEachPion", ";CollisionID;Centrality", {HistType::kTH2F, {{4000, 0.0f, 4000.0f}, {100, 0.0f, 100.0f}}}},
+     {"hCollIDVsCentEachDe", ";CollisionID;Centrality", {HistType::kTH2F, {{4000, 0.0f, 4000.0f}, {100, 0.0f, 100.0f}}}},
      {"hNHypsPerPrevColl", "Number of V0Hypers in previous collision used for mixing;N_{V0Hypers};Entries", {HistType::kTH2F, {{4000, 0.0f, 4000.0f}, {50, -0.5, 49.5}}}},
      {"hkStar_LS_M", ";kStar (GeV/c)", {HistType::kTH1F, {{300, 0.0f, 3.0f}}}},
      {"hkStar_LS_A", ";kStar (GeV/c)", {HistType::kTH1F, {{300, 0.0f, 3.0f}}}},
@@ -302,7 +307,7 @@ struct PiNucleiFemto {
   float Vz_step = (Vz_high - Vz_low) / numOfVertexZBins;
 
   struct EventRef {
-    int64_t collisionId;
+    uint64_t collisionId;
   };
 
   struct PoolBin {
@@ -477,6 +482,8 @@ struct PiNucleiFemto {
   template <typename Ttrack>
   bool selectionPIDPion(const Ttrack& candidate)
   {
+    if (candidate.tpcChi2NCl() > settingCutChi2tpcHighPion || candidate.tpcChi2NCl() < settingCutChi2tpcLowPion || candidate.itsChi2NCl() > settingCutChi2NClITSPion)
+      return false;
     if (abs(candidate.dcaXY()) > settingCutPiDCAxyMin || abs(candidate.dcaZ()) > settingCutPiDCAzMin)
       return false;
 
@@ -625,9 +632,11 @@ struct PiNucleiFemto {
         nCand = mFitter.process(trackCovDe, trackCovPi);
       } catch (...) {
         LOG(error) << "Exception caught in DCA fitter process call!";
+        mQaRegistry.fill(HIST("hSkipReasons"), 0);
         return false;
       }
       if (nCand == 0) {
+        mQaRegistry.fill(HIST("hSkipReasons"), 1);
         return false;
       }
 
@@ -650,6 +659,7 @@ struct PiNucleiFemto {
       }
 
       if (!mGoodCollisions[collIdxMin]) {
+        mQaRegistry.fill(HIST("hSkipReasons"), 2);
         return false;
       }
       piNucand.collisionID = collIdxMin;
@@ -662,10 +672,12 @@ struct PiNucleiFemto {
     float invMass = 0;
     invMass = RecoDecay::m(std::array{piNucand.momNu, piNucand.momPi}, std::array{o2::constants::physics::MassDeuteron, o2::constants::physics::MassPiPlus});
     if (settingCutInvMass > 0 && invMass > settingCutInvMass) {
+      mQaRegistry.fill(HIST("hSkipReasons"), 3);
       return false;
     }
     float ptDePi = std::hypot(piNucand.momNu[0] + piNucand.momPi[0], piNucand.momNu[1] + piNucand.momPi[1]);
     if (ptDePi < settingCutPtMinDePi) {
+      mQaRegistry.fill(HIST("hSkipReasons"), 4);
       return false;
     }
 
@@ -816,6 +828,7 @@ struct PiNucleiFemto {
       }
       mQaRegistry.fill(HIST("hTrackSel"), Selections::kPID);
       mQaRegistry.fill(HIST("hSingleNuPt"), track0.pt() * track0.sign());
+      mQaRegistry.fill(HIST("hCollIDVsCentEachDe"), track0.collisionId(), cent);
 
       for (const auto& track1 : tracks) {
         if (track0 == track1) {
@@ -1220,50 +1233,55 @@ PROCESS_SWITCH(PiNucleiFemto, processMixedEventHyper, "Process Mixed event", fal
       LOG(info) << "Initialized event pool with size = " << All_Event_pool.size();
     }
     for (auto const& collision : collisions) {
+      if (!collision.sel8()) {
+        mQaRegistry.fill(HIST("hSkipReasons"), 0);
+        continue;
+      }
       mQaRegistry.fill(HIST("hNcontributor"), collision.numContrib());
       mQaRegistry.fill(HIST("hCentrality"), collision.centFT0C());
       mQaRegistry.fill(HIST("hVtxZ"), collision.posZ());
-      int poolIndexPi = where_pool(collision.posZ(), collision.centFT0C());
 
+      int poolIndexPi = where_pool(collision.posZ(), collision.centFT0C());
       if (poolIndexPi < 0 || static_cast<size_t>(poolIndexPi) >= All_Event_pool.size()) {
         continue;
       }
       auto& pool = All_Event_pool[poolIndexPi];
 
+      const uint64_t collIdxPi = collision.globalIndex();
+      auto trackTableThisCollision = pitracks.sliceBy(mPerCol, collIdxPi);
+      trackTableThisCollision.bindExternalIndices(&pitracks);
+
       for (auto const& storedEvent : pool.events) {
-        const auto& c2 = collisions.iteratorAt(storedEvent.collisionId);
-        if (!collision.sel8() || !c2.sel8()) {
-          mQaRegistry.fill(HIST("hSkipReasons"), 0);
-          continue;
+        const uint64_t collIdxHyp = storedEvent.collisionId;
+        if (settingSaferME) {
+          if (static_cast<int64_t>(collIdxHyp) > collisions.size()) {
+            mQaRegistry.fill(HIST("hSkipReasons"), 4);
+            continue;
+          }
         }
 
-        auto hypdTablepreviousCollision = V0Hypers.sliceBy(hypPerCol, c2.globalIndex());
+        auto hypdTablepreviousCollision = V0Hypers.sliceBy(hypPerCol, collIdxHyp);
         hypdTablepreviousCollision.bindExternalIndices(&V0Hypers);
-
         if (hypdTablepreviousCollision.size() == 0) {
           mQaRegistry.fill(HIST("hSkipReasons"), 1);
           continue;
         }
 
         auto firstHyp = hypdTablepreviousCollision.iteratorAt(0);
         int poolIndexHyp = where_pool(firstHyp.zPrimVtx(), firstHyp.centralityFT0C());
-
         if (poolIndexHyp != poolIndexPi) {
           mQaRegistry.fill(HIST("hSkipReasons"), 2);
           continue;
         }
+        mQaRegistry.fill(HIST("hNHypsPerPrevColl"), collIdxHyp, hypdTablepreviousCollision.size());
 
-        auto trackTableThisCollision = pitracks.sliceBy(mPerCol, collision.globalIndex());
-        trackTableThisCollision.bindExternalIndices(&pitracks);
-
-        mQaRegistry.fill(HIST("hNHypsPerPrevColl"), c2.globalIndex(), hypdTablepreviousCollision.size());
         pairHyperEventMixing(trackTableThisCollision, hypdTablepreviousCollision);
       }
 
       if (static_cast<int>(pool.events.size()) >= settingNoMixedEvents) {
         pool.events.pop_front();
       }
-      pool.events.push_back({collision.globalIndex()});
+      pool.events.push_back({collIdxPi});
     }
     fillPairsHyper(collisions, pitracks, V0Hypers, /*isMixedEvent*/ true);
   }

PWGCF/TwoParticleCorrelations/Tasks/longRangeDihadronCor.cxx

@@ -279,7 +279,8 @@ struct LongRangeDihadronCor {
       registry.add("Centrality_used", hCentTitle.c_str(), {HistType::kTH1D, {{100, 0, 100}}}); // histogram to see how many events are in the same and mixed event
       registry.add("zVtx", "zVtx", {HistType::kTH1D, {axisVertex}});
       registry.add("zVtx_used", "zVtx_used", {HistType::kTH1D, {axisVertex}});
-      registry.add("Trig_hist", "", {HistType::kTHnSparseF, {{axisSample, axisVertex, axisPtTrigger}}});
+      registry.add("Trig_hist_TPC_FT0A", "", {HistType::kTHnSparseF, {{axisSample, axisVertex, axisPtTrigger}}});
+      registry.add("Trig_hist_TPC_FT0C", "", {HistType::kTHnSparseF, {{axisSample, axisVertex, axisPtTrigger}}});
       registry.add("FT0Amp", "", {HistType::kTH2F, {axisChID, axisFit}});
       registry.add("FT0AmpCorrect", "", {HistType::kTH2F, {axisChID, axisFit}});
       registry.add("FT0Cmp", "", {HistType::kTH2F, {axisChID, axisFit}});
@@ -558,7 +559,11 @@ struct LongRangeDihadronCor {
       if (!getEfficiencyCorrection(triggerWeight, track1.eta(), track1.pt(), posZ))
         continue;
       if (system == SameEvent) {
-        registry.fill(HIST("Trig_hist"), fSampleIndex, posZ, track1.pt(), eventWeight * triggerWeight);
+        if (corType == kFT0C) {
+          registry.fill(HIST("Trig_hist_TPC_FT0C"), fSampleIndex, posZ, track1.pt(), eventWeight * triggerWeight);
+        } else if (corType == kFT0A) {
+          registry.fill(HIST("Trig_hist_TPC_FT0A"), fSampleIndex, posZ, track1.pt(), eventWeight * triggerWeight);
+        }
       }
 
       std::size_t channelSize = 0;
@@ -630,10 +635,10 @@ struct LongRangeDihadronCor {
         float deltaEta = etaA - etaC;
         // fill the right sparse and histograms
         if (system == SameEvent) {
-          sameFt0aFt0c->getPairHist()->Fill(step, fSampleIndex, posZ, 0., 0., deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
+          sameFt0aFt0c->getPairHist()->Fill(step, fSampleIndex, posZ, 0.5, 0.5, deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
           registry.fill(HIST("deltaEta_deltaPhi_same_FT0A_FT0C"), deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
         } else if (system == MixedEvent) {
-          mixedFt0aFt0c->getPairHist()->Fill(step, fSampleIndex, posZ, 0., 0., deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
+          mixedFt0aFt0c->getPairHist()->Fill(step, fSampleIndex, posZ, 0.5, 0.5, deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
           registry.fill(HIST("deltaEta_deltaPhi_mixed_FT0A_FT0C"), deltaPhi, deltaEta, amplA * amplC * eventWeight * triggerWeight);
         }
       }

PWGHF/HFC/Tasks/taskCharmHadronsFemtoDream.cxx

@@ -159,8 +159,8 @@ struct HfTaskCharmHadronsFemtoDream {
 
   Filter eventMultiplicity = aod::femtodreamcollision::multNtr >= eventSel.multMin && aod::femtodreamcollision::multNtr <= eventSel.multMax;
   Filter eventMultiplicityPercentile = aod::femtodreamcollision::multV0M >= eventSel.multPercentileMin && aod::femtodreamcollision::multV0M <= eventSel.multPercentileMax;
-  Filter hfCandSelFilter = aod::fdhf::candidateSelFlag >= static_cast<int8_t>(charmHadCandSel.value);
-  Filter hfMcSelFilter = nabs(aod::fdhf::flagMc) == static_cast<int8_t>(charmHadMcSel.value);
+  Filter hfCandSelFilter = aod::fdhf::candidateSelFlag >= charmHadCandSel;
+  Filter hfMcSelFilter = (nabs(aod::fdhf::flagMc) == charmHadMcSel);
   Filter trackEtaFilterLow = ifnode(aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack), aod::femtodreamparticle::eta < etaTrack1Max, true);
   Filter trackEtaFilterUp = ifnode(aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack), aod::femtodreamparticle::eta > etaTrack1Min, true);
   Filter trackPtFilterLow = ifnode(aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack), aod::femtodreamparticle::pt < ptTrack1Max, true);
@@ -582,7 +582,7 @@ struct HfTaskCharmHadronsFemtoDream {
         part.tpcNSigmaPr(),
         part.tofNSigmaPr());
     }
-    if ((sliceCharmHad.size() != 0) || (sliceTrk1.size() != 0)) {
+    if (sliceCharmHad.size() > 0 || sliceTrk1.size() > 0) {
       rowFemtoResultColl(
         col.globalIndex(),
         timeStamp,
@@ -591,6 +591,7 @@ struct HfTaskCharmHadronsFemtoDream {
     } else {
       return;
     }
+
     doSameEvent<false>(sliceTrk1, sliceCharmHad, parts, col);
   }
   PROCESS_SWITCH(HfTaskCharmHadronsFemtoDream, processSameEvent, "Enable processing same event", false);
@@ -630,6 +631,11 @@ struct HfTaskCharmHadronsFemtoDream {
     auto sliceMcTrk1 = partitionMcTrk1->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache);
     auto sliceMcCharmHad = partitionMcCharmHadron->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache);
 
+    if (sliceMcCharmHad.size() > 0) {
+      for (auto const& part : sliceMcCharmHad) {
+        registryCharmHadronQa.fill(HIST("CharmHadronQA/hPtVsMass"), part.pt(), getCharmHadronMass(part));
+      }
+    }
     if (sliceMcTrk1.size() == 0 && sliceMcCharmHad.size() == 0) {
       return;
     }

PWGLF/DataModel/LFSlimNucleiTables.h

@@ -185,6 +185,21 @@ DECLARE_SOA_TABLE(NucleiPairTable, "AOD", "NUCLEIPAIRTABLE",
                   NucleiPairTableNS::ClusterSizesITS2,
                   NucleiPairTableNS::Flags2);
 
+// Reduced table
+DECLARE_SOA_TABLE(NucleiTableRed, "AOD", "NUCLEITABLERED",
+                  NucleiTableNS::Pt,
+                  NucleiTableNS::Eta,
+                  NucleiTableNS::Phi,
+                  NucleiTableNS::TPCInnerParam,
+                  NucleiTableNS::ITSclusterSizes,
+                  NucleiTableNS::TPCsignal,
+                  NucleiTableNS::Beta,
+                  NucleiTableNS::DCAxy,
+                  NucleiTableNS::DCAz,
+                  NucleiTableNS::Flags,
+                  NucleiTableNS::PDGcode,
+                  NucleiTableNS::MotherPDGcode);
+
 } // namespace o2::aod
 
 #endif // PWGLF_DATAMODEL_LFSLIMNUCLEITABLES_H_