diff --git a/EventFiltering/PWGLF/strangenessFilter.cxx b/EventFiltering/PWGLF/strangenessFilter.cxx index 33d83d92d6f..2aa8f73fbfc 100644 --- a/EventFiltering/PWGLF/strangenessFilter.cxx +++ b/EventFiltering/PWGLF/strangenessFilter.cxx @@ -79,7 +79,7 @@ struct strangenessFilter { HistogramRegistry QAHistosTriggerParticles{"QAHistosTriggerParticles", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; HistogramRegistry QAHistosStrangenessTracking{"QAHistosStrangenessTracking", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; HistogramRegistry EventsvsMultiplicity{"EventsvsMultiplicity", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - OutputObj hProcessedEvents{TH1D("hProcessedEvents", "Strangeness - event filtered;; Number of events", 17, -1., 16.)}; + OutputObj hProcessedEvents{TH1D("hProcessedEvents", "Strangeness - event filtered;; Number of events", 20, -1., 19.)}; OutputObj hCandidate{TH1F("hCandidate", "; Candidate pass selection; Number of events", 30, 0., 30.)}; OutputObj hEvtvshMinPt{TH1F("hEvtvshMinPt", " Number of h-Omega events with pT_h higher than thrd; min p_{T, trigg} (GeV/c); Number of events", 11, 0., 11.)}; @@ -146,9 +146,12 @@ struct strangenessFilter { Configurable hastof{"hastof", 1, "Has TOF (OOB condition)"}; Configurable ptthrtof{"ptthrtof", 1.0, "Pt threshold to apply TOF condition"}; Configurable sel8{"sel8", 0, "Apply sel8 event selection"}; - Configurable LowLimitFT0MMult{"LowLimitFT0MMult", 3100, "FT0M selection for omega + high multiplicity trigger"}; - Configurable LowLimitFT0MMultNorm{"LowLimitFT0MMultNorm", 70, "FT0M selection for omega + high multiplicity trigger with Normalised FT0M"}; - Configurable useNormalisedMult{"useNormalisedMult", 1, "Use avarage multiplicity for HM omega like in multFilter.cxx"}; + // Selection mask: bit 1 = 0 of multFilter - Tracks, bit 2 = FT0M used in 2024, bit 2 (4) = 4 of multFilter normalised FT0M used in 2025 + Configurable HMTriggerSelectionForOmega{"HMTriggerSelectionForOmega", 5, "0 = HM trigger selection for omega"}; + Configurable LowLimitHMTriggerOmegaTracks{"LowLimitHMTriggerOmegaTracks", 90, "tracks as defined in multFilter selection [0]"}; + Configurable LowLimitHMTriggerOmegaT0M{"LowLimitHMTriggerOmegaT0M", 3100, "T0M"}; + Configurable LowLimitHMTriggerOmegaT0MNorm{"LowLimitHMTriggerOmegaT0MNorm", 70, "normalised T0M selection [2] of multFiler"}; + Configurable avPyT0C{"avPyT0C", 8.83, "nch from pythia T0C"}; Configurable avPyT0A{"avPyT0A", 8.16, "nch from pythia T0A"}; Configurable isTimeFrameBorderCut{"isTimeFrameBorderCut", 1, "Apply timeframe border cut"}; @@ -211,6 +214,10 @@ struct strangenessFilter { { return track.pt() > hMinPt && std::abs(track.eta()) < hEta && track.tpcNClsCrossedRows() >= tpcmincrossedrows && track.tpcCrossedRowsOverFindableCls() >= 0.8f && track.tpcChi2NCl() <= 4.f && track.itsChi2NCl() <= 36.f && (track.itsClusterMap() & 0x7) != 0; } + bool selectTrackOHM(const auto& track) + { + return track.pt() > 0.15 && track.tpcNClsCrossedRows() >= tpcmincrossedrows && track.tpcCrossedRowsOverFindableCls() >= 0.8f && track.tpcChi2NCl() <= 4.f && track.itsChi2NCl() <= 36.f && (track.itsClusterMap() & 0x7) != 0; + } float getV0V0DCA(TVector3 v01pos, TVector3 v01mom, TVector3 v02pos, TVector3 v02mom) { @@ -332,7 +339,11 @@ struct strangenessFilter { hProcessedEvents->GetXaxis()->SetBinLabel(14, aod::filtering::OmegaHighMult::columnLabel()); hProcessedEvents->GetXaxis()->SetBinLabel(15, aod::filtering::DoubleOmega::columnLabel()); hProcessedEvents->GetXaxis()->SetBinLabel(16, aod::filtering::OmegaXi::columnLabel()); + // hProcessedEvents->GetXaxis()->SetBinLabel(17, aod::filtering::LambdaLambda::columnLabel()); hProcessedEvents->GetXaxis()->SetBinLabel(17, "LL"); + hProcessedEvents->GetXaxis()->SetBinLabel(18, aod::filtering::OmegaHighMultTrk::columnLabel()); + hProcessedEvents->GetXaxis()->SetBinLabel(19, aod::filtering::HighMultFT0M::columnLabel()); + hProcessedEvents->GetXaxis()->SetBinLabel(20, aod::filtering::HighMultTrk::columnLabel()); hCandidate->GetXaxis()->SetBinLabel(1, "All"); hCandidate->GetXaxis()->SetBinLabel(2, "PassBuilderSel"); @@ -359,6 +370,7 @@ struct strangenessFilter { AxisSpec multAxisNTPV = {100, 0.0f, 100.0f, "N. tracks PV estimator"}; AxisSpec multAxisT0M = {600, 0.0f, 6000.0f, "T0M multiplicity estimator"}; AxisSpec multAxisT0MNorm = {150, 0.0f, 150.0f, "Normalised T0M multiplicity estimator"}; + AxisSpec multAxisTrack = {120, 0.0f, 120.0f, "Tracks"}; AxisSpec multAxisV0A = {500, 0.0f, 25000.0f, "V0A multiplicity estimator"}; AxisSpec ximassAxis = {200, 1.28f, 1.36f}; AxisSpec omegamassAxis = {200, 1.59f, 1.75f}; @@ -416,11 +428,14 @@ struct strangenessFilter { QAHistosTriggerParticles.add("hEtaTriggerAllEv", "hEtaTriggerAllEv", HistType::kTH2F, {{180, -1.4, 1.4, "Eta of trigger particles"}, {ptTriggAxis}}); QAHistosTriggerParticles.add("hPhiTriggerAllEv", "hPhiTriggerAllEv", HistType::kTH2F, {{100, 0, 2 * TMath::Pi(), "Phi of trigger particles"}, {ptTriggAxis}}); + EventsvsMultiplicity.add("AllEventsvsEta", "eta ditribution", HistType::kTH1F, {{100, -2, 2}}); EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0M", "T0M distribution of all events", HistType::kTH1F, {multAxisT0M}); EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0MwOmega", "T0M distribution of events w/ Omega candidate", HistType::kTH1F, {multAxisT0M}); EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0MNorm", "T0M Normalised of all events", HistType::kTH1F, {multAxisT0MNorm}); - EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0MwOmegaNorm", "T0M distribution of events w/ Omega candidate - Normalised FT0M", HistType::kTH1F, {multAxisT0MNorm}); + EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0MNormwOmega", "T0M distribution of events w/ Omega candidate - Normalised FT0M", HistType::kTH1F, {multAxisT0MNorm}); EventsvsMultiplicity.add("AllEventsvsMultiplicityFT0MNoFT0", "T0M distribution of events without FT0", HistType::kTH1F, {multAxisT0M}); + EventsvsMultiplicity.add("AllEventsvsMultiplicityTracks", "Track distribution of all events", HistType::kTH1F, {multAxisTrack}); + EventsvsMultiplicity.add("AllEventsvsMultiplicityTrackswOmega", "Track distribution of events w/ Omega candidate", HistType::kTH1F, {multAxisTrack}); if (doextraQA) { EventsvsMultiplicity.add("AllEventsvsMultiplicityZeqV0A", "ZeqV0A distribution of all events", HistType::kTH1F, {multAxisV0A}); @@ -511,6 +526,7 @@ struct strangenessFilter { QAHistosStrangenessTracking.add("hPtVsMassTrkXiSelected", "cascades;p_{T} (GeV/#it{c});m (GeV/#it{c}^2)", HistType::kTH2D, {{200, 0., 10.}, {1000, 1.2, 1.7}}); QAHistosStrangenessTracking.add("hPtVsMassTrkOmegaSelected", "cascades;p_{T} (GeV/#it{c});m (GeV/#it{c}^2)", HistType::kTH2D, {{200, 0., 10.}, {1000, 1.6, 2.1}}); } + LOG(info) << "HM Omega track trigger:" << LowLimitHMTriggerOmegaTracks; } void initCCDB(int run) @@ -520,10 +536,12 @@ struct strangenessFilter { o2::parameters::GRPMagField* grpmag = ccdb->getForRun("GLO/Config/GRPMagField", run); o2::base::Propagator::initFieldFromGRP(grpmag); mBz = static_cast(grpmag->getNominalL3Field()); - if (useNormalisedMult) + if (HMTriggerSelectionForOmega & 4) { mMeanMultT0C = ccdb->getForRun>("Users/e/ekryshen/meanT0C", run); - if (useNormalisedMult) + } + if (HMTriggerSelectionForOmega & 4) { mMeanMultT0A = ccdb->getForRun>("Users/e/ekryshen/meanT0A", run); + } mDCAFitter.setBz(mBz); mDCAFitter.setPropagateToPCA(propToDCA); @@ -561,14 +579,14 @@ struct strangenessFilter { void fillTriggerTable(bool keepEvent[]) { - strgtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4], keepEvent[5], keepEvent[6], keepEvent[7], keepEvent[8], keepEvent[9], keepEvent[10], keepEvent[11], keepEvent[12]); + strgtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4], keepEvent[5], keepEvent[6], keepEvent[7], keepEvent[8], keepEvent[9], keepEvent[10], keepEvent[11], keepEvent[12], keepEvent[13], keepEvent[14], keepEvent[15]); } void process(CollisionCandidates const& collision, TrackCandidates const& tracks, aod::Cascades const& cascadesBase, aod::AssignedTrackedCascades const& trackedCascades, aod::AssignedTrackedV0s const& /*trackedV0s*/, aod::AssignedTracked3Bodys const& /*tracked3Bodys*/, aod::V0s const& v0Base, aod::BCs const&, aod::FT0s const& /*ft0s*/) { // Is event good? [0] = Omega, [1] = high-pT hadron + Omega, [2] = 2Xi, [3] = 3Xi, [4] = 4Xi, [5] single-Xi, [6] Omega with high radius // [7] tracked Xi, [8] tracked Omega, [9] Omega + high mult event - bool keepEvent[13]{}; // explicitly zero-initialised + bool keepEvent[16]{}; // explicitly zero-initialised std::vector> v0sFromOmegaID; std::vector> v0sFromXiID; @@ -599,13 +617,30 @@ struct strangenessFilter { } Bool_t isHighMultEvent = 0; + Bool_t isHighMultEventTrk = 0; + float multFT0MNorm = 0.f; - EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0M"), collision.multFT0M()); - if (!useNormalisedMult) { - if (collision.multFT0M() > LowLimitFT0MMult) { + float multTrack = 0; + if (HMTriggerSelectionForOmega & 1) { //===================================== + for (auto& track : tracks) { + if (selectTrackOHM(track)) { + multTrack++; + EventsvsMultiplicity.fill(HIST("AllEventsvsEta"), track.eta()); + } + } + // std::cout << multTrack << std::endl; + EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityTracks"), multTrack); + if (multTrack > LowLimitHMTriggerOmegaTracks) { + isHighMultEventTrk = 1; + } + } + if (HMTriggerSelectionForOmega & 2) { //===================================== + EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0M"), collision.multFT0M()); + if (collision.multFT0M() > LowLimitHMTriggerOmegaT0M) { isHighMultEvent = 1; } - } else { + } + if (HMTriggerSelectionForOmega & 4) { //===================================== float meanMultT0C = 0.f; float fac_FT0C_ebe = 1.; meanMultT0C = (*mMeanMultT0C)[0]; @@ -646,7 +681,7 @@ struct strangenessFilter { ampneg++; } EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MNorm"), multFT0MNorm); - if (multFT0MNorm > LowLimitFT0MMultNorm) { + if (multFT0MNorm > LowLimitHMTriggerOmegaT0MNorm) { isHighMultEvent = 1; LOG(debug) << "Found FT0 using norm mult"; } @@ -660,11 +695,10 @@ struct strangenessFilter { } } else { LOG(debug) << "FT0 not Found, using FT0M"; - EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MNorm"), 149); + // EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MNorm"), 149); EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MNoFT0"), collision.multFT0M()); } } - // constants const float ctauxi = 4.91; // from PDG const float ctauomega = 2.461; // from PDG @@ -1164,12 +1198,21 @@ struct strangenessFilter { // Omega in high multiplicity events if (omegacounter > 0) { EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MwOmega"), collision.multFT0M()); - EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MwOmegaNorm"), multFT0MNorm); + EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityFT0MNormwOmega"), multFT0MNorm); + EventsvsMultiplicity.fill(HIST("AllEventsvsMultiplicityTrackswOmega"), multTrack); } if (omegacounter > 0 && isHighMultEvent) { keepEvent[9] = true; } - + if (omegacounter > 0 && isHighMultEventTrk) { + keepEvent[13] = true; + } + if (isHighMultEvent) { + keepEvent[14] = true; + } + if (isHighMultEventTrk) { + keepEvent[15] = true; + } for (const auto& trackedCascade : trackedCascades) { const auto trackCasc = trackedCascade.track_as(); QAHistosStrangenessTracking.fill(HIST("hPtCascTracked"), trackCasc.pt()); @@ -1360,6 +1403,15 @@ struct strangenessFilter { if (keepEvent[12]) { hProcessedEvents->Fill(15.5); } + if (keepEvent[13]) { + hProcessedEvents->Fill(16.5); + } + if (keepEvent[14]) { + hProcessedEvents->Fill(17.5); + } + if (keepEvent[15]) { + hProcessedEvents->Fill(18.5); + } // Filling the table fillTriggerTable(keepEvent); } diff --git a/EventFiltering/filterTables.h b/EventFiltering/filterTables.h index 1371d152e75..21dfa28d1d3 100644 --- a/EventFiltering/filterTables.h +++ b/EventFiltering/filterTables.h @@ -166,8 +166,11 @@ DECLARE_SOA_COLUMN(TrackedCascade, hasTrackedCascade, bool); //! at least 1 DECLARE_SOA_COLUMN(TrackedXi, hasTrackedXi, bool); //! at least 1 tracked Xi DECLARE_SOA_COLUMN(TrackedOmega, hasTrackedOmega, bool); //! at least 1 tracked Omega DECLARE_SOA_COLUMN(Tracked3Body, hasTracked3Body, bool); //! at least 1 tracked 3Body -DECLARE_SOA_COLUMN(OmegaHighMult, hasOmegaHighMult, bool); //! at least 1 Omega + high-mult event +DECLARE_SOA_COLUMN(OmegaHighMult, hasOmegaHighMult, bool); //! at least 1 Omega + high-mult FT0M event DECLARE_SOA_COLUMN(LambdaLambda, lambdaLambda, bool); //! at least 2 lambda satisfying selection +DECLARE_SOA_COLUMN(OmegaHighMultTrk, hasOmegaHighMultTrk, bool); //! at least 1 Omega + high-mult track event +DECLARE_SOA_COLUMN(HighMultFT0M, hasHighMultFT0M, bool); //! at least 1 Omega + high-mult track event +DECLARE_SOA_COLUMN(HighMultTrk, hasHighMultTrk, bool); //! at least 1 Omega + high-mult track event // F1-proton DECLARE_SOA_COLUMN(TriggerEventF1Proton, triggereventf1proton, bool); //! F1 - proton femto trigger event @@ -321,7 +324,7 @@ using FullJetFilter = FullJetFilters::iterator; // strangeness (lf) DECLARE_SOA_TABLE(StrangenessFilters, "AOD", "LFStrgFilters", //! - filtering::Omega, filtering::hadronOmega, filtering::DoubleXi, filtering::TripleXi, filtering::QuadrupleXi, filtering::SingleXiYN, filtering::OmegaLargeRadius, filtering::TrackedXi, filtering::TrackedOmega, filtering::OmegaHighMult, filtering::DoubleOmega, filtering::OmegaXi, filtering::LambdaLambda); + filtering::Omega, filtering::hadronOmega, filtering::DoubleXi, filtering::TripleXi, filtering::QuadrupleXi, filtering::SingleXiYN, filtering::OmegaLargeRadius, filtering::TrackedXi, filtering::TrackedOmega, filtering::OmegaHighMult, filtering::DoubleOmega, filtering::OmegaXi, filtering::LambdaLambda, filtering::OmegaHighMultTrk, filtering::HighMultFT0M, filtering::HighMultTrk); using StrangenessFilter = StrangenessFilters::iterator;