From 5b55428df66d39985b95b233efa624380586525c Mon Sep 17 00:00:00 2001 From: suyoupeng <109774812+15071832337@users.noreply.github.com> Date: Wed, 28 May 2025 17:50:30 +0800 Subject: [PATCH 1/4] Add files via upload --- .../Strangeness/lambdaJetpolarization.cxx | 72 ++++++++++++++++++- 1 file changed, 69 insertions(+), 3 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx b/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx index 93c0b4381dc..cb9fd1e470f 100644 --- a/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx +++ b/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx @@ -27,6 +27,7 @@ #include #include #include +#include "TProfile2D.h" #include "PWGLF/DataModel/lambdaJetpolarization.h" #include @@ -59,7 +60,6 @@ struct LfMyV0s { Configurable etaMin{"etaMin", -0.9f, "eta min"}; Configurable etaMax{"etaMax", +0.9f, "eta max"}; Configurable deltaEtaEdge{"deltaEtaEdge", 0.00, "eta gap from the edge"}; - Configurable minJetPt{"minJetPt", 10.0, "Minimum pt of the jet"}; // track parameters Configurable minITSnCls{"minITSnCls", 4.0f, "min number of ITS clusters"}; Configurable minTPCnClsFound{"minTPCnClsFound", 80.0f, "min number of found TPC clusters"}; @@ -113,6 +113,8 @@ struct LfMyV0s { Configurable v0accLambda{"v0accLambda", 0.075, "V0 acc Lambda"}; Configurable ifinitpasslambda{"ifinitpasslambda", 1, "ifinitpasslambda"}; Configurable ifpasslambda{"passedLambdaSelection", 0, "passedLambdaSelection"}; + Configurable paramArmenterosCut{"paramArmenterosCut", 0.2, "parameter Armenteros Cut"}; + Configurable doArmenterosCut{"doArmenterosCut", 0, "do Armenteros Cut"}; // Jet background subtraction JetBkgSubUtils backgroundSub; @@ -131,6 +133,8 @@ struct LfMyV0s { const AxisSpec ptAxis{100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec invMassLambdaAxis{200, 1.09, 1.14, "m_{p#pi} (GeV/#it{c}^{2})"}; + ConfigurableAxis TProfile2DaxisPt{"#it{p}_{T} (GeV/#it{c})", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt axis for histograms"}; + registry.add("hMassLambda", "hMassLambda", {HistType::kTH1F, {{200, 0.9f, 1.2f}}}); registry.add("V0pTInLab", "V0pTInLab", kTH1F, {axisPT}); registry.add("hMassVsPtLambda", "hMassVsPtLambda", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {200, 1.016f, 1.216f}}}); @@ -245,6 +249,17 @@ struct LfMyV0s { registryData.add("hLambdaPhiandSinPhi", "hLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); registryData.add("V0LambdaprotonPhi", "V0LambdaprotonPhi", {HistType::kTH1F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}}}); + registryData.add("profileAntiLambda", "Invariant Mass vs sin(phi)", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registryData.add("hAntiLambdamassandSinPhi", "hAntiLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); + + registryData.add("TProfile2DLambdaPtMassSinPhi", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassSinPhi", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DLambdaPtMassSintheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassSintheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + + registryData.add("TProfile2DLambdaPtMassCosSquareTheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassCosSquareTheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("hNEvents", "hNEvents", {HistType::kTH1I, {{10, 0.f, 10.f}}}); registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(1, "all"); registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(2, "sel8"); @@ -655,6 +670,9 @@ struct LfMyV0s { if (TMath::Abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0accLambda) { return false; } + if (doArmenterosCut && v0.qtarm() > (paramArmenterosCut * std::abs(v0.alpha()))) + return false; + return true; } @@ -723,6 +741,8 @@ struct LfMyV0s { if (TMath::Abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0accLambda) { return false; } + if (doArmenterosCut && v0.qtarm() > (paramArmenterosCut * std::abs(v0.alpha()))) + return false; return true; } @@ -890,6 +910,7 @@ struct LfMyV0s { registryData.fill(HIST("number_of_events_vsmultiplicity"), multiplicity); // v0 loop int V0Numbers = 0; + int AntiV0Numbers = 0; for (const auto& v0 : fullV0s) { const auto& pos = v0.posTrack_as(); const auto& neg = v0.negTrack_as(); @@ -899,6 +920,7 @@ struct LfMyV0s { registryData.fill(HIST("LambdaPtMass"), v0.pt(), v0.mLambda()); } if (passedAntiLambdaSelection(v0, pos, neg)) { + AntiV0Numbers = AntiV0Numbers + 1; registryData.fill(HIST("AntiLambdaPtMass"), v0.pt(), v0.mAntiLambda()); } } @@ -913,6 +935,7 @@ struct LfMyV0s { return; } double protonsinPhiInJetV0frame = 0; + double AntiprotonsinPhiInJetV0frame = 0; cout << maxJetpx << endl; for (const auto& candidate : fullV0s) { const auto& pos = candidate.posTrack_as(); @@ -982,7 +1005,7 @@ struct LfMyV0s { double protonPinJetV0 = sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0) + protonInJetV0(3, 0) * protonInJetV0(3, 0)); double protonPtinJetV0 = sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); - double protonCosThetainJetV0 = protonInV0(3, 0) / protonPinJetV0; + double protonCosThetainJetV0 = protonInJetV0(3, 0) / protonPinJetV0; double protonSinThetainJetV0 = protonPtinJetV0 / protonPinJetV0; double protonthetainJetV0 = TMath::ASin(protonSinThetainJetV0); registryV0Data.fill(HIST("hprotoncosthetainJetV0"), protonCosThetainJetV0); @@ -997,6 +1020,46 @@ struct LfMyV0s { registryV0Data.fill(HIST("AverageSinthetainJetV0"), candidate.mLambda(), protonSinThetainJetV0); registryV0Data.fill(HIST("AverageCosSquarethetainJetV0"), candidate.mLambda(), protonCosThetainJetV0 * protonCosThetainJetV0); protonsinPhiInJetV0frame = protonsinPhiInJetV0frame + protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); + + registryData.fill(HIST("TProfile2DLambdaPtMassSinPhi"), candidate.mLambda(), candidate.pt(), protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0))); + registryData.fill(HIST("TProfile2DLambdaPtMassSintheta"), candidate.mLambda(), candidate.pt(), protonSinThetainJetV0); + registryData.fill(HIST("TProfile2DLambdaPtMassCosSquareTheta"), candidate.mLambda(), candidate.pt(), protonCosThetainJetV0 * protonCosThetainJetV0); + } + if (passedAntiLambdaSelection(candidate, pos, neg)) { + double PAntiLambda = sqrt(candidate.px() * candidate.px() + candidate.py() * candidate.py() + candidate.pz() * candidate.pz()); + double EAntiLambda = sqrt(candidate.mAntiLambda() * candidate.mAntiLambda() + PAntiLambda * PAntiLambda); + double AntiprotonE = sqrt(massPr * massPr + neg.px() * neg.px() + neg.py() * neg.py() + neg.pz() * neg.pz()); + TMatrixD pLabAntiV0(4, 1); + pLabAntiV0(0, 0) = EAntiLambda; + pLabAntiV0(1, 0) = candidate.px(); + pLabAntiV0(2, 0) = candidate.py(); + pLabAntiV0(3, 0) = candidate.pz(); + + TMatrixD AntilambdaInJet(4, 1); + AntilambdaInJet = MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiV0; + + TMatrixD pLabAntiproton(4, 1); + pLabAntiproton(0, 0) = AntiprotonE; + pLabAntiproton(1, 0) = neg.px(); + pLabAntiproton(2, 0) = neg.py(); + pLabAntiproton(3, 0) = neg.pz(); + TMatrixD AntiprotonInJetV0(4, 1); + AntiprotonInJetV0 = LorentzTransInV0frame(EAntiLambda, AntilambdaInJet(1, 0), AntilambdaInJet(2, 0), AntilambdaInJet(3, 0)) * MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiproton; + AntiprotonsinPhiInJetV0frame = AntiprotonsinPhiInJetV0frame + AntiprotonInJetV0(2, 0) / sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0)); + registryData.fill(HIST("TProfile2DAntiLambdaPtMassSinPhi"), candidate.mAntiLambda(), candidate.pt(), AntiprotonInJetV0(2, 0) / sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0))); + + TMatrixD AntiprotonInV0(4, 1); + AntiprotonInV0 = LorentzTransInV0frame(EAntiLambda, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiproton; + + double AntiprotonPinJetV0 = sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0) + AntiprotonInJetV0(3, 0) * AntiprotonInJetV0(3, 0)); + double AntiprotonPtinJetV0 = sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0)); + + double AntiprotonCosThetainJetV0 = AntiprotonInJetV0(3, 0) / AntiprotonPinJetV0; + double AntiprotonSinThetainJetV0 = AntiprotonPtinJetV0 / AntiprotonPinJetV0; + double AntiprotonthetainJetV0 = TMath::ASin(AntiprotonSinThetainJetV0); + + registryData.fill(HIST("TProfile2DAntiLambdaPtMassSintheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonSinThetainJetV0); + registryData.fill(HIST("TProfile2DAntiLambdaPtMassCosSquareTheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonCosThetainJetV0 * AntiprotonCosThetainJetV0); } } @@ -1009,6 +1072,10 @@ struct LfMyV0s { registryData.fill(HIST("V0LambdaprotonPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers)); registryData.fill(HIST("profileLambda"), candidate.mLambda(), protonsinPhiInJetV0frame / V0Numbers); } + if (passedAntiLambdaSelection(candidate, pos, neg)) { + registryData.fill(HIST("hAntiLambdamassandSinPhi"), candidate.mAntiLambda(), AntiprotonsinPhiInJetV0frame / AntiV0Numbers); + registryData.fill(HIST("profileAntiLambda"), candidate.mAntiLambda(), AntiprotonsinPhiInJetV0frame / AntiV0Numbers); + } } } PROCESS_SWITCH(LfMyV0s, processData, "processData", true); @@ -1019,7 +1086,6 @@ struct LfMyV0s { if (!AcceptEvent(collision)) { return; } - registryData.fill(HIST("hNEvents"), 8.5); int V0NumbersPerEvent = 0; int V0NumbersPerEventsel = 0; From cb239bc35bde63c5fba41aba57d5baca967a1d84 Mon Sep 17 00:00:00 2001 From: suyoupeng <109774812+15071832337@users.noreply.github.com> Date: Wed, 28 May 2025 20:46:53 +0800 Subject: [PATCH 2/4] Add files via upload --- PWGLF/Tasks/lambdaJetpolarization.cxx | 1162 +++++++++++++++++++++++++ 1 file changed, 1162 insertions(+) create mode 100644 PWGLF/Tasks/lambdaJetpolarization.cxx diff --git a/PWGLF/Tasks/lambdaJetpolarization.cxx b/PWGLF/Tasks/lambdaJetpolarization.cxx new file mode 100644 index 00000000000..88187c43ed5 --- /dev/null +++ b/PWGLF/Tasks/lambdaJetpolarization.cxx @@ -0,0 +1,1162 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// + +/// \author Youpeng Su (yousu@cern.ch) +#include +#include +#include +#include +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Common/DataModel/EventSelection.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" +#include "Common/DataModel/PIDResponse.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include +#include "Framework/ASoA.h" +#include "Framework/AnalysisDataModel.h" +#include +#include +#include +#include "TProfile2D.h" +#include "PWGLF/DataModel/lambdaJetpolarization.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include "PWGJE/Core/JetBkgSubUtils.h" +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/Jet.h" +#include "Common/Core/trackUtilities.h" + +using std::cout; +using std::endl; +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct LfMyV0s { + HistogramRegistry registry{"registry"}; + HistogramRegistry registryData{"registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryV0Data{"registryV0Data", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + Configurable zVtx{"zVtx", 10.0, "Maximum zVertex"}; + Configurable rJet{"rJet", 0.4, "Jet resolution parameter R"}; + Configurable etaMin{"etaMin", -0.9f, "eta min"}; + Configurable etaMax{"etaMax", +0.9f, "eta max"}; + Configurable deltaEtaEdge{"deltaEtaEdge", 0.00, "eta gap from the edge"}; + // track parameters + Configurable minITSnCls{"minITSnCls", 4.0f, "min number of ITS clusters"}; + Configurable minTPCnClsFound{"minTPCnClsFound", 80.0f, "min number of found TPC clusters"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, "min number of TPC crossed rows"}; + Configurable minTpcNcrossedRowsOverFindable{"minTpcNcrossedRowsOverFindable", 0.8, "crossed rows/findable"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable maxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable requireTOF{"requireTOF", false, "require TOF hit"}; + Configurable requireITS{"requireITS", false, "require ITS hit"}; + + Configurable ptMinV0Proton{"ptMinV0Proton", 0.3f, "pt min of proton from V0"}; + Configurable ptMaxV0Proton{"ptMaxV0Proton", 10.0f, "pt max of proton from V0"}; + Configurable ptMinV0Pion{"ptMinV0Pion", 0.1f, "pt min of pion from V0"}; + Configurable ptMaxV0Pion{"ptMaxV0Pion", 1.5f, "pt max of pion from V0"}; + + Configurable nsigmaTPCmin{"nsigmaTPCmin", -5.0f, "Minimum nsigma TPC"}; + Configurable nsigmaTPCmax{"nsigmaTPCmax", +5.0f, "Maximum nsigma TPC"}; + Configurable nsigmaTOFmin{"nsigmaTOFmin", -5.0f, "Minimum nsigma TOF"}; + Configurable nsigmaTOFmax{"nsigmaTOFmax", +5.0f, "Maximum nsigma TOF"}; + Configurable cfgtrkMinPt{"cfgtrkMinPt", 0.10, "set track min pT"}; + + // v0 parameters + Configurable v0cospaMin{"v0cospaMin", 0.995f, "Minimum V0 CosPA"}; + Configurable minimumV0Radius{"minimumV0Radius", 0.2f, "Minimum V0 Radius"}; + Configurable maximumV0Radius{"maximumV0Radius", 40.0f, "Maximum V0 Radius"}; + Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 1.0f, "Maximum DCA Daughters"}; + Configurable dcanegtoPVmin{"dcanegtoPVmin", 0.1f, "Minimum DCA Neg To PV"}; + Configurable dcapostoPVmin{"dcapostoPVmin", 0.1f, "Minimum DCA Pos To PV"}; + + // jet selection + Configurable cfgjetPtMin{"cfgjetPtMin", 8.0, "minimum jet pT cut"}; + Configurable ispassdTrackSelectionForJetReconstruction{"ispassdTrackSelectionForJetReconstruction", 1, "do track selection"}; + + // v0Event selection + Configurable sel8{"sel8", 0, "Apply sel8 event selection"}; + Configurable isTriggerTVX{"isTriggerTVX", 1, "TVX trigger"}; + Configurable iscutzvertex{"iscutzvertex", 1, "Accepted z-vertex range (cm)"}; + Configurable isNoTimeFrameBorder{"isNoTimeFrameBorder", 1, "TF border cut"}; + Configurable isNoITSROFrameBorder{"isNoITSROFrameBorder", 1, "ITS ROF border cut"}; + Configurable isVertexTOFmatched{"isVertexTOFmatched", 1, "Is Vertex TOF matched"}; + Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", 0, "isGoodZvtxFT0vsPV"}; + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + Configurable CtauLambda{"ctauLambda", 30, "C tau Lambda (cm)"}; + Configurable requirepassedSingleTrackSelection{"requirepassedSingleTrackSelection", false, "requirepassedSingleTrackSelection"}; + Configurable V0tracketaMin{"V0tracketaMin", -0.8f, "eta min track"}; + Configurable V0tracketaMax{"V0tracketaMax", +0.8f, "eta max track"}; + Configurable requireTPC{"requireTPC", true, "require TPC hit"}; + Configurable yMin{"V0yMin", -0.5f, "minimum y"}; + Configurable yMax{"V0yMax", +0.5f, "maximum y"}; + Configurable v0rejLambda{"v0rejLambda", 0.01, "V0 rej Lambda"}; + Configurable v0accLambda{"v0accLambda", 0.075, "V0 acc Lambda"}; + Configurable ifinitpasslambda{"ifinitpasslambda", 1, "ifinitpasslambda"}; + Configurable ifpasslambda{"passedLambdaSelection", 0, "passedLambdaSelection"}; + Configurable paramArmenterosCut{"paramArmenterosCut", 0.2, "parameter Armenteros Cut"}; + Configurable doArmenterosCut{"doArmenterosCut", 0, "do Armenteros Cut"}; + + // Jet background subtraction + JetBkgSubUtils backgroundSub; + void init(InitContext const&) + { + const AxisSpec axisPx{100, -10, 10, "#px (GeV/c)"}; + const AxisSpec axisPy{100, -10, 10, "#py (GeV/c)"}; + const AxisSpec axisPz{100, -10, 10, "#pz (GeV/c)"}; + const AxisSpec axisPT{200, 0, 50, "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec axisPhi{100, -3.14, 3.14, "#Phi"}; + const AxisSpec axisMass{100, 0, 2, "Mass(GeV/c^{2})"}; + + const AxisSpec JetaxisEta{30, -1.5, +1.5, "#eta"}; + const AxisSpec JetaxisPhi{200, -1, +7, "#phi"}; + const AxisSpec JetaxisPt{200, 0, +200, "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec ptAxis{100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec invMassLambdaAxis{200, 1.09, 1.14, "m_{p#pi} (GeV/#it{c}^{2})"}; + + ConfigurableAxis TProfile2DaxisPt{"#it{p}_{T} (GeV/#it{c})", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt axis for histograms"}; + + registry.add("hMassLambda", "hMassLambda", {HistType::kTH1F, {{200, 0.9f, 1.2f}}}); + registry.add("V0pTInLab", "V0pTInLab", kTH1F, {axisPT}); + registry.add("hMassVsPtLambda", "hMassVsPtLambda", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {200, 1.016f, 1.216f}}}); + registry.add("hMassVsPtAntiLambda", "hMassVsPtAntiLambda", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {200, 1.016f, 1.216f}}}); + + registry.add("V0pxInLab", "V0pxInLab", kTH1F, {axisPx}); + registry.add("V0pyInLab", "V0pyInLab", kTH1F, {axisPy}); + registry.add("V0pzInLab", "V0pzInLab", kTH1F, {axisPz}); + + registry.add("V0pxInRest_frame", "V0pxInRest_frame", kTH1F, {axisPx}); + registry.add("V0pyInRest_frame", "V0pyInRest_frame", kTH1F, {axisPy}); + registry.add("V0pzInRest_frame", "V0pzInRest_frame", kTH1F, {axisPz}); + + registry.add("JetpxInLab", "JetpxInLab", kTH1F, {axisPx}); + registry.add("JetpyInLab", "JetpyInLab", kTH1F, {axisPy}); + registry.add("JetpzInLab", "JetpzInLab", kTH1F, {axisPz}); + registry.add("JetpTInLab", "JetpTInLab", kTH1F, {axisPT}); + + registry.add("LeadingJetpx", "LeadingJetpx", kTH1F, {axisPx}); + registry.add("LeadingJetpy", "LeadingJetpy", kTH1F, {axisPy}); + registry.add("LeadingJetpz", "LeadingJetpz", kTH1F, {axisPz}); + registry.add("LeadingJetpT", "LeadingJetpT", kTH1F, {axisPT}); + + registry.add("V0protonpxInLab", "V0protonpxInLab", kTH1F, {axisPx}); + registry.add("V0protonpyInLab", "V0protonpyInLab", kTH1F, {axisPy}); + registry.add("V0protonpzInLab", "V0protonpzInLab", kTH1F, {axisPz}); + registry.add("V0protonphiInLab", "V0protonphiInLab", kTH1F, {axisPhi}); + + registry.add("V0protonpxInRest_frame", "V0protonpxInRest_frame", kTH1F, {axisPx}); + registry.add("V0protonpyInRest_frame", "V0protonpyInRest_frame", kTH1F, {axisPy}); + registry.add("V0protonpzInRest_frame", "V0protonpzInRest_frame", kTH1F, {axisPz}); + registry.add("V0protonMassInRest_frame", "V0protonMassInRest_frame", kTH1F, {axisMass}); + registry.add("V0protonphiInRest_frame", "V0protonphiInRest_frame", kTH1F, {axisPhi}); + + registry.add("V0protonpxInJetV0frame", "V0protonpxInJetV0frame", kTH1F, {axisPx}); + registry.add("V0protonpyInJetV0frame", "V0protonpyInJetV0frame", kTH1F, {axisPy}); + registry.add("V0protonpzInJetV0frame", "V0protonpzInJetV0frame", kTH1F, {axisPz}); + registry.add("V0protonphiInJetV0frame", "V0protonphiInJetV0frame", kTH1F, {axisPhi}); + registry.add("V0antiprotonphiInJetV0frame", "V0antiprotonphiInJetV0frame", kTH1F, {axisPhi}); + + registry.add("V0LambdapxInJetV0frame", "V0LambdapxInJetV0frame", kTH1F, {axisPx}); + registry.add("V0LambdapyInJetV0frame", "V0LambdapyInJetV0frame", kTH1F, {axisPy}); + registry.add("V0LambdapzInJetV0frame", "V0LambdapzInJetV0frame", kTH1F, {axisPz}); + + registry.add("hLambdamassandSinPhi", "hLambdamassandSinPhi", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registry.add("hAntiLambdamassandSinPhi", "hAntiLambdamassandSinPhi", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registry.add("profile", "Invariant Mass vs sin(phi)", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registry.add("profileAntiV0", "Invariant Mass vs sin(phi)", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registry.add("hLambdaPhiandSinPhi", "hLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); + registry.add("hAntiLambdaPhiandSinPhi", "hAntiLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); + + registry.add("V0LambdaprotonPhi", "V0LambdaprotonPhi", {HistType::kTH1F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}}}); + registry.add("V0AntiLambdaprotonPhi", "V0AntiLambdaprotonPhi", {HistType::kTH1F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}}}); + + registryData.add("number_of_events_data", "number of events in data", HistType::kTH1D, {{20, 0, 20, "Event Cuts"}}); + registryData.add("number_of_events_vsmultiplicity", "number of events in data vs multiplicity", HistType::kTH1D, {{101, 0, 101, "Multiplicity percentile"}}); + registryData.add("h_track_pt", "track pT;#it{p}_{T,track} (GeV/#it{c});entries", kTH1F, {{200, 0., 200.}}); + registryData.add("h_track_eta", "track #eta;#eta_{track};entries", kTH1F, {{100, -1.f, 1.f}}); + registryData.add("h_track_phi", "track #varphi;#varphi_{track};entries", kTH1F, {{80, -1.f, 7.f}}); + registryData.add("h_track_pt_sel", "track pT;#it{p}_{T,track} (GeV/#it{c});entries", kTH1F, {{200, 0., 200.}}); + registryData.add("h_track_eta_sel", "track #eta;#eta_{track};entries", kTH1F, {{100, -1.f, 1.f}}); + registryData.add("h_track_phi_sel", "track #varphi;#varphi_{track};entries", kTH1F, {{80, -1.f, 7.f}}); + + registryData.add("FJetaHistogram", "FJetaHistogram", kTH1F, {JetaxisEta}); + registryData.add("FJphiHistogram", "FJphiHistogram", kTH1F, {JetaxisPhi}); + registryData.add("FJptHistogram", "FJptHistogram", kTH1F, {JetaxisPt}); + registryData.add("nJetsPerEvent", "nJetsPerEvent", kTH1F, {{10, 0.0, 10.0}}); + registryData.add("nJetsPerEventsel", "nJetsPerEventsel", kTH1F, {{10, 0.0, 10.0}}); + registryData.add("nV0sPerEvent", "nV0sPerEvent", kTH1F, {{10, 0.0, 10.0}}); + registryData.add("FJetaHistogramsel", "FJetaHistogramsel", kTH1F, {JetaxisEta}); + registryData.add("FJphiHistogramsel", "FJphiHistogramsel", kTH1F, {JetaxisPhi}); + registryData.add("FJptHistogramsel", "FJptHistogramsel", kTH1F, {JetaxisPt}); + + registryData.add("FLeadingJetaHistogramsel", "FLeadingJetaHistogramsel", kTH1F, {JetaxisEta}); + registryData.add("FLeadingJphiHistogramsel", "FLeadingJphiHistogramsel", kTH1F, {JetaxisPhi}); + registryData.add("FLeadingJptHistogramsel", "FLeadingJptHistogramsel", kTH1F, {JetaxisPt}); + + registryData.add("LambdaPtMass", "LambdaPtMass", HistType::kTH2F, {ptAxis, invMassLambdaAxis}); + registryData.add("AntiLambdaPtMass", "AntiLambdaPtMass", HistType::kTH2F, {ptAxis, invMassLambdaAxis}); + + registryData.add("hMassLambda", "hMassLambda", {HistType::kTH1F, {{200, 0.9f, 1.2f}}}); + registryData.add("V0pTInLab", "V0pTInLab", kTH1F, {axisPT}); + + registryData.add("V0pxInLab", "V0pxInLab", kTH1F, {axisPx}); + registryData.add("V0pyInLab", "V0pyInLab", kTH1F, {axisPy}); + registryData.add("V0pzInLab", "V0pzInLab", kTH1F, {axisPz}); + + registryData.add("V0pxInRest_frame", "V0pxInRest_frame", kTH1F, {axisPx}); + registryData.add("V0pyInRest_frame", "V0pyInRest_frame", kTH1F, {axisPy}); + registryData.add("V0pzInRest_frame", "V0pzInRest_frame", kTH1F, {axisPz}); + + registryData.add("V0protonpxInLab", "V0protonpxInLab", kTH1F, {axisPx}); + registryData.add("V0protonpyInLab", "V0protonpyInLab", kTH1F, {axisPy}); + registryData.add("V0protonpzInLab", "V0protonpzInLab", kTH1F, {axisPz}); + registryData.add("V0protonphiInLab", "V0protonphiInLab", kTH1F, {axisPhi}); + + registryData.add("V0protonpxInRest_frame", "V0protonpxInRest_frame", kTH1F, {axisPx}); + registryData.add("V0protonpyInRest_frame", "V0protonpyInRest_frame", kTH1F, {axisPy}); + registryData.add("V0protonpzInRest_frame", "V0protonpzInRest_frame", kTH1F, {axisPz}); + registryData.add("V0protonMassInRest_frame", "V0protonMassInRest_frame", kTH1F, {axisMass}); + registryData.add("V0protonphiInRest_frame", "V0protonphiInRest_frame", kTH1F, {axisPhi}); + + registryData.add("V0protonpxInJetV0frame", "V0protonpxInJetV0frame", kTH1F, {axisPx}); + registryData.add("V0protonpyInJetV0frame", "V0protonpyInJetV0frame", kTH1F, {axisPy}); + registryData.add("V0protonpzInJetV0frame", "V0protonpzInJetV0frame", kTH1F, {axisPz}); + + registryData.add("V0LambdapxInJetV0frame", "V0LambdapxInJetV0frame", kTH1F, {axisPx}); + registryData.add("V0LambdapyInJetV0frame", "V0LambdapyInJetV0frame", kTH1F, {axisPy}); + registryData.add("V0LambdapzInJetV0frame", "V0LambdapzInJetV0frame", kTH1F, {axisPz}); + registryData.add("hLambdamassandSinPhi", "hLambdamassandSinPhi", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registryData.add("profileLambda", "Invariant Mass vs sin(phi)", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registryData.add("hLambdaPhiandSinPhi", "hLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); + registryData.add("V0LambdaprotonPhi", "V0LambdaprotonPhi", {HistType::kTH1F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}}}); + + registryData.add("profileAntiLambda", "Invariant Mass vs sin(phi)", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registryData.add("hAntiLambdamassandSinPhi", "hAntiLambdaPhiandSinPhi", kTH2F, {{200, -TMath::Pi() / 2, TMath::Pi() / 2}, {200, -1, 1}}); + + registryData.add("TProfile2DLambdaPtMassSinPhi", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassSinPhi", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DLambdaPtMassSintheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassSintheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + + registryData.add("TProfile2DLambdaPtMassCosSquareTheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + registryData.add("TProfile2DAntiLambdaPtMassCosSquareTheta", "", kTProfile2D, {invMassLambdaAxis, TProfile2DaxisPt}); + + registryData.add("hNEvents", "hNEvents", {HistType::kTH1I, {{10, 0.f, 10.f}}}); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(1, "all"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(2, "sel8"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(3, "TVX"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(4, "zvertex"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(5, "TFBorder"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(6, "ITSROFBorder"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(7, "isTOFVertexMatched"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(8, "isGoodZvtxFT0vsPV"); + registryData.get(HIST("hNEvents"))->GetXaxis()->SetBinLabel(9, "Applied selected"); + + registryV0Data.add("hLambdaPt", "hLambdaPt", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}); + registryV0Data.add("hAntiLambdaPt", "hAntiLambdaPt", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}); + + registryV0Data.add("hMassVsPtLambda", "hMassVsPtLambda", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {200, 1.016f, 1.216f}}}); + registryV0Data.add("hMassVsPtAntiLambda", "hMassVsPtAntiLambda", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {200, 1.016f, 1.216f}}}); + registryV0Data.add("hMassLambda", "hMassLambda", {HistType::kTH1F, {{200, 0.9f, 1.2f}}}); + registryV0Data.add("hMassAntiLambda", "hMassAntiLambda", {HistType::kTH1F, {{200, 0.9f, 1.2f}}}); + registryV0Data.add("nV0sPerEvent", "nV0sPerEvent", kTH1F, {{10, 0.0, 10.0}}); + registryV0Data.add("nV0sPerEventsel", "nV0sPerEventsel", kTH1F, {{10, 0.0, 10.0}}); + + registryV0Data.add("hprotoncosthetainLab", "hprotoncosthetainLab", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonsinthetainLab", "hprotonsinthetainLab", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonthetainLab", "hprotonthetainLab", kTH1F, {{200, 0.f, TMath::Pi()}}); + + registryV0Data.add("hprotoncosthetainV0", "hprotoncosthetainV0", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonsinthetainV0", "hprotonsinthetainV0", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonthetainV0", "hprotonthetainV0", kTH1F, {{200, 0.f, TMath::Pi()}}); + + registryV0Data.add("hprotoncosthetainJetV0", "hprotoncosthetainJetV0", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonsinthetainJetV0", "hprotonsinthetainJetV0", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotonthetainJetV0", "hprotonthetainJetV0", kTH1F, {{200, 0.f, TMath::Pi()}}); + + registryV0Data.add("hprotoncosSquarethetainLab", "hprotoncosSquarethetainLab", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotoncosSquarethetainV0", "hprotoncosSquarethetainV0", kTH1F, {{200, -1.f, 1.f}}); + registryV0Data.add("hprotoncosSquarethetainJetV0", "hprotoncosSquarethetainJetV0", kTH1F, {{200, -1.f, 1.f}}); + + registryV0Data.add("hLambdamassandSinthetainV0", "hLambdamassandSinthetainV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registryV0Data.add("hLambdamassandCosthetainV0", "hLambdamassandCosthetainV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registryV0Data.add("hLambdamassandCosSquarethetainV0", "hLambdamassandCosSquarethetainV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + + registryV0Data.add("hLambdamassandSinthetainJetV0", "hLambdamassandSinthetainJetV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registryV0Data.add("hLambdamassandCosthetainJetV0", "hLambdamassandCosthetainJetV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + registryV0Data.add("hLambdamassandCosSquarethetainJetV0", "hLambdamassandCosSquarethetainJetV0", kTH2F, {{200, 0.9, 1.2}, {200, -1, 1}}); + + registryV0Data.add("AverageSinthetainV0", "AverageSinthetainV0", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registryV0Data.add("AverageCosSquarethetainV0", "AverageCosSquarethetainV0", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + + registryV0Data.add("AverageSinthetainJetV0", "AverageSinthetainJetV0", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + registryV0Data.add("AverageCosSquarethetainJetV0", "AverageCosSquarethetainJetV0", {HistType::kTProfile, {{200, 0.9, 1.2}}}); + } + double massPr = o2::constants::physics::MassProton; + double massLambda = o2::constants::physics::MassLambda; + + TMatrixD LorentzTransInV0frame(double ELambda, double Lambdapx, double Lambdapy, double Lambdapz) + { + double PLambda = sqrt(Lambdapx * Lambdapx + Lambdapy * Lambdapy + Lambdapz * Lambdapz); + double LambdaMass = sqrt(ELambda * ELambda - PLambda * PLambda); + double Alpha = 1 / (LambdaMass * (ELambda + LambdaMass)); + TMatrixD matrixLabToLambda(4, 4); + matrixLabToLambda(0, 0) = ELambda / LambdaMass; + matrixLabToLambda(0, 1) = -Lambdapx / LambdaMass; + matrixLabToLambda(0, 2) = -Lambdapy / LambdaMass; + matrixLabToLambda(0, 3) = -Lambdapz / LambdaMass; + matrixLabToLambda(1, 0) = -Lambdapx / LambdaMass; + matrixLabToLambda(1, 1) = 1 + Alpha * Lambdapx * Lambdapx; + matrixLabToLambda(1, 2) = Alpha * Lambdapx * Lambdapy; + matrixLabToLambda(1, 3) = Alpha * Lambdapx * Lambdapz; + matrixLabToLambda(2, 0) = -Lambdapy / LambdaMass; + matrixLabToLambda(2, 1) = Alpha * Lambdapy * Lambdapx; + matrixLabToLambda(2, 2) = 1 + Alpha * Lambdapy * Lambdapy; + matrixLabToLambda(2, 3) = Alpha * Lambdapy * Lambdapz; + matrixLabToLambda(3, 0) = -Lambdapz / LambdaMass; + matrixLabToLambda(3, 1) = Alpha * Lambdapz * Lambdapx; + matrixLabToLambda(3, 2) = Alpha * Lambdapz * Lambdapy; + matrixLabToLambda(3, 3) = 1 + Alpha * Lambdapz * Lambdapz; + return matrixLabToLambda; + } + TMatrixD MyTMatrixTranslationToJet(double Jetpx, double Jetpy, double Jetpz, double Lambdapx, double Lambdapy, double Lambdapz) + { + TVector3 UnitX(1.0, 0.0, 0.0); + TVector3 UnitY(0.0, 1.0, 0.0); + TVector3 UnitZ(0.0, 0.0, 1.0); + TVector3 JetP(Jetpx, Jetpy, Jetpz); + TVector3 V0LambdaP(Lambdapx, Lambdapy, Lambdapz); + TVector3 vortex_y = (JetP.Cross(V0LambdaP)); + + TVector3 z_hat = JetP.Unit(); + TVector3 y_hat = vortex_y.Unit(); + TVector3 x_hat1 = y_hat.Cross(z_hat); + TVector3 x_hat = x_hat1.Unit(); + + TMatrixD matrixLabToJet(4, 4); + matrixLabToJet(0, 0) = 1; + matrixLabToJet(0, 1) = 0.0; + matrixLabToJet(0, 2) = 0.0; + matrixLabToJet(0, 3) = 0.0; + matrixLabToJet(1, 0) = 0.0; + matrixLabToJet(1, 1) = x_hat.X(); + matrixLabToJet(1, 2) = x_hat.Y(); + matrixLabToJet(1, 3) = x_hat.Z(); + matrixLabToJet(2, 0) = 0.0; + matrixLabToJet(2, 1) = y_hat.X(); + matrixLabToJet(2, 2) = y_hat.Y(); + matrixLabToJet(2, 3) = y_hat.Z(); + matrixLabToJet(3, 0) = 0.0; + matrixLabToJet(3, 1) = z_hat.X(); + matrixLabToJet(3, 2) = z_hat.Y(); + matrixLabToJet(3, 3) = z_hat.Z(); + return matrixLabToJet; + } + // aod::MyCollision const& collision + void processJetV0Analysis(aod::MyTable const& myv0s, aod::MyTableJet const& myJets) + { + for (auto& candidate : myv0s) { + registry.fill(HIST("hMassLambda"), candidate.v0Lambdamass()); + registry.fill(HIST("V0pTInLab"), candidate.v0pt()); + registry.fill(HIST("hMassVsPtLambda"), candidate.v0pt(), candidate.v0Lambdamass()); + registry.fill(HIST("V0pxInLab"), candidate.v0px()); + registry.fill(HIST("V0pyInLab"), candidate.v0py()); + registry.fill(HIST("V0pzInLab"), candidate.v0pz()); + registry.fill(HIST("V0protonpxInLab"), candidate.v0protonpx()); + registry.fill(HIST("V0protonpyInLab"), candidate.v0protonpy()); + registry.fill(HIST("V0protonpzInLab"), candidate.v0protonpz()); + double protonsinPhiInLab = candidate.v0protonpy() / sqrt(candidate.v0protonpx() * candidate.v0protonpx() + candidate.v0protonpy() * candidate.v0protonpy()); + registry.fill(HIST("V0protonphiInLab"), protonsinPhiInLab); + double PLambda = sqrt(candidate.v0px() * candidate.v0px() + candidate.v0py() * candidate.v0py() + candidate.v0pz() * candidate.v0pz()); + double ELambda = sqrt(candidate.v0Lambdamass() * candidate.v0Lambdamass() + PLambda * PLambda); + TMatrixD pLabV0(4, 1); + pLabV0(0, 0) = ELambda; + pLabV0(1, 0) = candidate.v0px(); + pLabV0(2, 0) = candidate.v0py(); + pLabV0(3, 0) = candidate.v0pz(); + TMatrixD V0InV0(4, 1); + V0InV0 = LorentzTransInV0frame(ELambda, candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabV0; + registry.fill(HIST("V0pxInRest_frame"), V0InV0(1, 0)); + registry.fill(HIST("V0pyInRest_frame"), V0InV0(2, 0)); + registry.fill(HIST("V0pzInRest_frame"), V0InV0(3, 0)); + } + for (auto& candidate : myv0s) { + double PLambda = sqrt(candidate.v0px() * candidate.v0px() + candidate.v0py() * candidate.v0py() + candidate.v0pz() * candidate.v0pz()); + double ELambda = sqrt(candidate.v0Lambdamass() * candidate.v0Lambdamass() + PLambda * PLambda); + TMatrixD pLabproton(4, 1); + double protonE = sqrt(massPr * massPr + candidate.v0protonpx() * candidate.v0protonpx() + candidate.v0protonpy() * candidate.v0protonpy() + candidate.v0protonpz() * candidate.v0protonpz()); + pLabproton(0, 0) = protonE; + pLabproton(1, 0) = candidate.v0protonpx(); + pLabproton(2, 0) = candidate.v0protonpy(); + pLabproton(3, 0) = candidate.v0protonpz(); + TMatrixD protonInV0(4, 1); + protonInV0 = LorentzTransInV0frame(ELambda, candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabproton; + double protonMassInV0 = sqrt(protonInV0(0, 0) * protonInV0(0, 0) - protonInV0(1, 0) * protonInV0(1, 0) - protonInV0(2, 0) * protonInV0(2, 0) - protonInV0(3, 0) * protonInV0(3, 0)); + registry.fill(HIST("V0protonMassInRest_frame"), protonMassInV0); + registry.fill(HIST("V0protonpxInRest_frame"), protonInV0(1, 0)); + registry.fill(HIST("V0protonpyInRest_frame"), protonInV0(2, 0)); + registry.fill(HIST("V0protonpzInRest_frame"), protonInV0(3, 0)); + double protonsinPhiInV0frame = protonInV0(2, 0) / sqrt(protonInV0(1, 0) * protonInV0(1, 0) + protonInV0(2, 0) * protonInV0(2, 0)); + registry.fill(HIST("V0protonphiInRest_frame"), protonsinPhiInV0frame); + } + + for (auto& Jet : myJets) { + registry.fill(HIST("JetpxInLab"), Jet.jetpx()); + registry.fill(HIST("JetpyInLab"), Jet.jetpy()); + registry.fill(HIST("JetpzInLab"), Jet.jetpz()); + registry.fill(HIST("JetpTInLab"), Jet.jetpt()); + } + } + PROCESS_SWITCH(LfMyV0s, processJetV0Analysis, "processJetV0Analysis", true); + void processLeadingJetV0Analysis(aod::MyTable const& myv0s, aod::MyTableLeadingJet const& myleadingJets) + { + for (auto& LeadingJet : myleadingJets) { + int V0Numbers = 0; + double protonsinPhiInJetV0frame = 0; + for (auto& candidate : myv0s) { + if (candidate.mycollisionv0() == LeadingJet.mycollisionleadingjet()) { + V0Numbers = V0Numbers + 1; + double PLambda = sqrt(candidate.v0px() * candidate.v0px() + candidate.v0py() * candidate.v0py() + candidate.v0pz() * candidate.v0pz()); + double ELambda = sqrt(candidate.v0Lambdamass() * candidate.v0Lambdamass() + PLambda * PLambda); + double protonE = sqrt(massPr * massPr + candidate.v0protonpx() * candidate.v0protonpx() + candidate.v0protonpy() * candidate.v0protonpy() + candidate.v0protonpz() * candidate.v0protonpz()); + + TMatrixD pLabV0(4, 1); + pLabV0(0, 0) = ELambda; + pLabV0(1, 0) = candidate.v0px(); + pLabV0(2, 0) = candidate.v0py(); + pLabV0(3, 0) = candidate.v0pz(); + + TMatrixD lambdaInJet(4, 1); + lambdaInJet = MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabV0; + + TMatrixD lambdaInJetV0(4, 1); + lambdaInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabV0; + registry.fill(HIST("V0LambdapxInJetV0frame"), lambdaInJetV0(1, 0)); + registry.fill(HIST("V0LambdapyInJetV0frame"), lambdaInJetV0(2, 0)); + registry.fill(HIST("V0LambdapzInJetV0frame"), lambdaInJetV0(3, 0)); + + TMatrixD pLabproton(4, 1); + pLabproton(0, 0) = protonE; + pLabproton(1, 0) = candidate.v0protonpx(); + pLabproton(2, 0) = candidate.v0protonpy(); + pLabproton(3, 0) = candidate.v0protonpz(); + TMatrixD protonInJetV0(4, 1); + protonInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabproton; + registry.fill(HIST("V0protonpxInJetV0frame"), protonInJetV0(1, 0)); + registry.fill(HIST("V0protonpyInJetV0frame"), protonInJetV0(2, 0)); + registry.fill(HIST("V0protonpzInJetV0frame"), protonInJetV0(3, 0)); + protonsinPhiInJetV0frame = protonsinPhiInJetV0frame + protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); + } + } + for (auto& candidate : myv0s) { + if (candidate.mycollisionv0() == LeadingJet.mycollisionleadingjet()) { + registry.fill(HIST("V0protonphiInJetV0frame"), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("hLambdamassandSinPhi"), candidate.v0Lambdamass(), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("hLambdaPhiandSinPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("V0LambdaprotonPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers)); + registry.fill(HIST("profile"), candidate.v0Lambdamass(), protonsinPhiInJetV0frame / V0Numbers); + } + } + } + for (auto& LeadingJet : myleadingJets) { + registry.fill(HIST("LeadingJetpx"), LeadingJet.leadingjetpx()); + registry.fill(HIST("LeadingJetpy"), LeadingJet.leadingjetpy()); + registry.fill(HIST("LeadingJetpz"), LeadingJet.leadingjetpz()); + registry.fill(HIST("LeadingJetpT"), LeadingJet.leadingjetpt()); + } + } + PROCESS_SWITCH(LfMyV0s, processLeadingJetV0Analysis, "processLeadingJetV0Analysis", true); + + void processLeadingJetAntiV0Analysis(aod::MyTableAnti const& myv0s, aod::MyTableLeadingJet const& myleadingJets) + { + for (auto& LeadingJet : myleadingJets) { + int V0Numbers = 0; + double protonsinPhiInJetV0frame = 0; + for (auto& candidate : myv0s) { + if (candidate.mycollisionv0() == LeadingJet.mycollisionleadingjet()) { + V0Numbers = V0Numbers + 1; + double PLambda = sqrt(candidate.v0px() * candidate.v0px() + candidate.v0py() * candidate.v0py() + candidate.v0pz() * candidate.v0pz()); + double ELambda = sqrt(candidate.v0Lambdamass() * candidate.v0Lambdamass() + PLambda * PLambda); + double protonE = sqrt(massPr * massPr + candidate.v0protonpx() * candidate.v0protonpx() + candidate.v0protonpy() * candidate.v0protonpy() + candidate.v0protonpz() * candidate.v0protonpz()); + + TMatrixD pLabV0(4, 1); + pLabV0(0, 0) = ELambda; + pLabV0(1, 0) = candidate.v0px(); + pLabV0(2, 0) = candidate.v0py(); + pLabV0(3, 0) = candidate.v0pz(); + + TMatrixD lambdaInJet(4, 1); + lambdaInJet = MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabV0; + + TMatrixD lambdaInJetV0(4, 1); + lambdaInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabV0; + + TMatrixD pLabproton(4, 1); + pLabproton(0, 0) = protonE; + pLabproton(1, 0) = candidate.v0protonpx(); + pLabproton(2, 0) = candidate.v0protonpy(); + pLabproton(3, 0) = candidate.v0protonpz(); + TMatrixD protonInJetV0(4, 1); + protonInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(LeadingJet.leadingjetpx(), LeadingJet.leadingjetpy(), LeadingJet.leadingjetpz(), candidate.v0px(), candidate.v0py(), candidate.v0pz()) * pLabproton; + protonsinPhiInJetV0frame = protonsinPhiInJetV0frame + protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); + } + } + for (auto& candidate : myv0s) { + if (candidate.mycollisionv0() == LeadingJet.mycollisionleadingjet()) { + registry.fill(HIST("V0antiprotonphiInJetV0frame"), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("hAntiLambdamassandSinPhi"), candidate.v0Lambdamass(), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("hAntiLambdaPhiandSinPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers), protonsinPhiInJetV0frame / V0Numbers); + registry.fill(HIST("V0AntiLambdaprotonPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers)); + registry.fill(HIST("profileAntiV0"), candidate.v0Lambdamass(), protonsinPhiInJetV0frame / V0Numbers); + } + } + } + for (auto& candidate : myv0s) { + registry.fill(HIST("hMassVsPtAntiLambda"), candidate.v0pt(), candidate.v0Lambdamass()); + } + } + PROCESS_SWITCH(LfMyV0s, processLeadingJetAntiV0Analysis, "processLeadingJetAntiV0Analysis", true); + + // ITS hit + template + bool hasITSHit(const TrackIts& track, int layer) + { + int ibit = layer - 1; + return (track.itsClusterMap() & (1 << ibit)); + } + + // Single-Track Selection for Particles inside Jets + template + bool passedTrackSelectionForJetReconstruction(const JetTrack& track) + { + const int minTpcCr = 70; + const double minCrFindable = 0.8; + const double maxChi2Tpc = 4.0; + const double maxChi2Its = 36.0; + const double maxPseudorapidity = 0.9; + const double minPtTrack = 0.1; + const double dcaxyMaxTrackPar0 = 0.0105; + const double dcaxyMaxTrackPar1 = 0.035; + const double dcaxyMaxTrackPar2 = 1.1; + const double dcazMaxTrack = 2.0; + + if (!track.hasITS()) + return false; + if ((!hasITSHit(track, 1)) && (!hasITSHit(track, 2)) && (!hasITSHit(track, 3))) + return false; + if (!track.hasTPC()) + return false; + if (track.tpcNClsCrossedRows() < minTpcCr) + return false; + if ((static_cast(track.tpcNClsCrossedRows()) / static_cast(track.tpcNClsFindable())) < minCrFindable) + return false; + if (track.tpcChi2NCl() > maxChi2Tpc) + return false; + if (track.itsChi2NCl() > maxChi2Its) + return false; + if (track.eta() < -maxPseudorapidity || track.eta() > maxPseudorapidity) + return false; + if (track.pt() < minPtTrack) + return false; + if (std::fabs(track.dcaXY()) > (dcaxyMaxTrackPar0 + dcaxyMaxTrackPar1 / std::pow(track.pt(), dcaxyMaxTrackPar2))) + return false; + if (std::fabs(track.dcaZ()) > dcazMaxTrack) + return false; + return true; + } + + // init Selection + template + bool passedInitLambdaSelection(const Lambda& v0, const TrackPos& ptrack, const TrackNeg& ntrack) + { + if (v0.v0radius() < minimumV0Radius || v0.v0cosPA() < v0cospaMin || + TMath::Abs(ptrack.eta()) > V0tracketaMax || + TMath::Abs(ntrack.eta()) > V0tracketaMax) { + return false; + } + if (v0.dcaV0daughters() > dcaV0DaughtersMax) { + return false; + } + if (TMath::Abs(v0.dcanegtopv()) < dcanegtoPVmin) { + return false; + } + if (TMath::Abs(v0.dcapostopv()) < dcapostoPVmin) { + return false; + } + return true; + } + + // Lambda Selections + template + bool passedLambdaSelection(const Lambda& v0, const TrackPos& ptrack, const TrackNeg& ntrack) + { + // Single-Track Selections + if (requirepassedSingleTrackSelection && !passedSingleTrackSelection(ptrack)) + return false; + if (requirepassedSingleTrackSelection && !passedSingleTrackSelection(ntrack)) + return false; + + // Momentum of Lambda Daughters + TVector3 proton(v0.pxpos(), v0.pypos(), v0.pzpos()); + TVector3 pion(v0.pxneg(), v0.pyneg(), v0.pzneg()); + + if (proton.Pt() < ptMinV0Proton) + return false; + if (proton.Pt() > ptMaxV0Proton) + return false; + if (pion.Pt() < ptMinV0Pion) + return false; + if (pion.Pt() > ptMaxV0Pion) + return false; + + // V0 Selections + if (v0.v0cosPA() < v0cospaMin) + return false; + if (v0.v0radius() < minimumV0Radius) + return false; + if (std::fabs(v0.dcaV0daughters()) > dcaV0DaughtersMax) + return false; + if (std::fabs(v0.dcapostopv()) < dcapostoPVmin) + return false; + if (std::fabs(v0.dcanegtopv()) < dcanegtoPVmin) + return false; + + if (TMath::Abs(ptrack.eta()) > V0tracketaMax || TMath::Abs(ntrack.eta()) > V0tracketaMax) { + return false; + } + + // PID Selections (TPC) + if (requireTPC) { + if (ptrack.tpcNSigmaPr() < nsigmaTPCmin || ptrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + if (ntrack.tpcNSigmaPi() < nsigmaTPCmin || ntrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + } + // PID Selections (TOF) + if (requireTOF) { + if (ptrack.tofNSigmaPr() < nsigmaTOFmin || ptrack.tofNSigmaPr() > nsigmaTOFmax) + return false; + if (ntrack.tofNSigmaPi() < nsigmaTOFmin || ntrack.tofNSigmaPi() > nsigmaTOFmax) + return false; + } + TLorentzVector lorentzVect; + lorentzVect.SetXYZM(v0.px(), v0.py(), v0.pz(), 1.115683); + if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax) { + return false; + } + + if (TMath::Abs(v0.mK0Short() - o2::constants::physics::MassK0Short) < v0rejLambda) { + return false; + } + if (TMath::Abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0accLambda) { + return false; + } + if (doArmenterosCut && v0.qtarm() > (paramArmenterosCut * std::abs(v0.alpha()))) + return false; + + return true; + } + + // AntiLambda Selections + template + bool passedAntiLambdaSelection(const AntiLambda& v0, const TrackPos& ptrack, const TrackNeg& ntrack) + { + // Single-Track Selections + if (requirepassedSingleTrackSelection && !passedSingleTrackSelection(ptrack)) + return false; + if (requirepassedSingleTrackSelection && !passedSingleTrackSelection(ntrack)) + return false; + + // Momentum AntiLambda Daughters + TVector3 pion(v0.pxpos(), v0.pypos(), v0.pzpos()); + TVector3 proton(v0.pxneg(), v0.pyneg(), v0.pzneg()); + + if (proton.Pt() < ptMinV0Proton) + return false; + if (proton.Pt() > ptMaxV0Proton) + return false; + if (pion.Pt() < ptMinV0Pion) + return false; + if (pion.Pt() > ptMaxV0Pion) + return false; + + // V0 Selections + if (v0.v0cosPA() < v0cospaMin) + return false; + if (v0.v0radius() < minimumV0Radius || v0.v0radius() > maximumV0Radius) + return false; + if (std::fabs(v0.dcaV0daughters()) > dcaV0DaughtersMax) + return false; + if (std::fabs(v0.dcapostopv()) < dcapostoPVmin) + return false; + if (std::fabs(v0.dcanegtopv()) < dcanegtoPVmin) + return false; + + if (TMath::Abs(ptrack.eta()) > V0tracketaMax || TMath::Abs(ntrack.eta()) > V0tracketaMax) { + return false; + } + + // PID Selections (TPC) + if (requireTPC) { + if (ptrack.tpcNSigmaPi() < nsigmaTPCmin || ptrack.tpcNSigmaPi() > nsigmaTPCmax) + return false; + if (ntrack.tpcNSigmaPr() < nsigmaTPCmin || ntrack.tpcNSigmaPr() > nsigmaTPCmax) + return false; + } + // PID Selections (TOF) + if (requireTOF) { + if (ptrack.tofNSigmaPi() < nsigmaTOFmin || ptrack.tofNSigmaPi() > nsigmaTOFmax) + return false; + if (ntrack.tofNSigmaPr() < nsigmaTOFmin || ntrack.tofNSigmaPr() > nsigmaTOFmax) + return false; + } + TLorentzVector lorentzVect; + lorentzVect.SetXYZM(v0.px(), v0.py(), v0.pz(), 1.115683); + if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax) { + return false; + } + + if (TMath::Abs(v0.mK0Short() - o2::constants::physics::MassK0Short) < v0rejLambda) { + return false; + } + if (TMath::Abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0accLambda) { + return false; + } + if (doArmenterosCut && v0.qtarm() > (paramArmenterosCut * std::abs(v0.alpha()))) + return false; + return true; + } + + // Single-Track Selection + template + bool passedSingleTrackSelection(const Track& track) + { + if (requireITS && (!track.hasITS())) + return false; + if (requireITS && track.itsNCls() < minITSnCls) + return false; + if (!track.hasTPC()) + return false; + if (track.tpcNClsFound() < minTPCnClsFound) + return false; + if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) + return false; + if ((static_cast(track.tpcNClsCrossedRows()) / static_cast(track.tpcNClsFindable())) < minTpcNcrossedRowsOverFindable) + return false; + if (track.tpcChi2NCl() > maxChi2TPC) + return false; + if (track.eta() < etaMin || track.eta() > etaMax) + return false; + if (requireTOF && (!track.hasTOF())) + return false; + return true; + } + + ///////Event selection + template + bool AcceptEvent(TCollision const& collision) + { + if (sel8 && !collision.sel8()) { + return false; + } + registryData.fill(HIST("hNEvents"), 1.5); + + if (isTriggerTVX && !collision.selection_bit(aod::evsel::kIsTriggerTVX)) { + return false; + } + registryData.fill(HIST("hNEvents"), 2.5); + + if (iscutzvertex && TMath::Abs(collision.posZ()) > cutzvertex) { + return false; + } + registryData.fill(HIST("hNEvents"), 3.5); + + if (isNoTimeFrameBorder && !collision.selection_bit(aod::evsel::kNoTimeFrameBorder)) { + return false; + } + + registryData.fill(HIST("hNEvents"), 4.5); + + if (isNoITSROFrameBorder && !collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) { + return false; + } + registryData.fill(HIST("hNEvents"), 5.5); + if (isVertexTOFmatched && !collision.selection_bit(aod::evsel::kIsVertexTOFmatched)) { + return false; + } + registryData.fill(HIST("hNEvents"), 6.5); + if (isGoodZvtxFT0vsPV && !collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { + return false; + } + registryData.fill(HIST("hNEvents"), 7.5); + + return true; + } + + using SelCollisions = soa::Join; + using StrHadronDaughterTracks = soa::Join; + void processData(SelCollisions::iterator const& collision, aod::V0Datas const& fullV0s, StrHadronDaughterTracks const& tracks) + { + registryData.fill(HIST("number_of_events_data"), 0.5); + // event selection + if (!collision.sel8() || std::fabs(collision.posZ()) > zVtx) { + return; + } + // event counter: after event selection + registryData.fill(HIST("number_of_events_data"), 1.5); + // loop over reconstructed tracks + std::vector fjParticles; + for (auto const& track : tracks) { + registryData.fill(HIST("h_track_pt"), track.pt()); + registryData.fill(HIST("h_track_eta"), track.eta()); + registryData.fill(HIST("h_track_phi"), track.phi()); + if (ispassdTrackSelectionForJetReconstruction && !passedTrackSelectionForJetReconstruction(track)) { + continue; + } + registryData.fill(HIST("h_track_pt_sel"), track.pt()); + registryData.fill(HIST("h_track_eta_sel"), track.eta()); + registryData.fill(HIST("h_track_phi_sel"), track.phi()); + + // 4-momentum representation of a particle + fastjet::PseudoJet fourMomentum(track.px(), track.py(), track.pz(), track.energy(o2::constants::physics::MassPionCharged)); + fjParticles.emplace_back(fourMomentum); + } + // reject empty events + if (fjParticles.size() < 1) + return; + registryData.fill(HIST("number_of_events_data"), 2.5); + + // cluster particles using the anti-kt algorithm + fastjet::RecombinationScheme recombScheme = fastjet::E_scheme; + fastjet::JetDefinition jetDef(fastjet::antikt_algorithm, rJet, recombScheme); + fastjet::AreaDefinition areaDef(fastjet::active_area, fastjet::GhostedAreaSpec(1.0)); + fastjet::ClusterSequenceArea cs(fjParticles, jetDef, areaDef); + std::vector jets = fastjet::sorted_by_pt(cs.inclusive_jets()); + auto [rhoPerp, rhoMPerp] = backgroundSub.estimateRhoPerpCone(fjParticles, jets); + + // jet selection + bool isAtLeastOneJetSelected = false; + int nJets = 0; + int nJetssel = 0; + // select most large momentum jet + float maxJetpx = 0; + float maxJetpy = 0; + float maxJetpz = 0; + float maxJeteta = 0; + float maxJetphi = 0; + float maxJetpT = 0; + float maxJetPt = -999; + for (auto& jet : jets) { + nJets++; + registryData.fill(HIST("FJetaHistogram"), jet.eta()); + registryData.fill(HIST("FJphiHistogram"), jet.phi()); + registryData.fill(HIST("FJptHistogram"), jet.pt()); + // jet must be fully contained in the acceptance + fastjet::PseudoJet jetMinusBkg = backgroundSub.doRhoAreaSub(jet, rhoPerp, rhoMPerp); + if ((std::fabs(jet.eta()) + rJet) > (etaMax - deltaEtaEdge)) { + continue; + } + + if (jet.pt() < cfgjetPtMin) + continue; + nJetssel++; + registryData.fill(HIST("FJetaHistogramsel"), jet.eta()); + registryData.fill(HIST("FJphiHistogramsel"), jet.phi()); + registryData.fill(HIST("FJptHistogramsel"), jet.pt()); + + if (jet.pt() > maxJetPt) { + maxJetpx = jet.px(); + maxJetpy = jet.py(); + maxJetpz = jet.pz(); + maxJeteta = jet.eta(); + maxJetphi = jet.phi(); + maxJetpT = jet.pt(); + maxJetPt = maxJetpT; + } + } + if (maxJetpT > 0) { + registryData.fill(HIST("FLeadingJetaHistogramsel"), maxJeteta); + registryData.fill(HIST("FLeadingJphiHistogramsel"), maxJetphi); + registryData.fill(HIST("FLeadingJptHistogramsel"), maxJetpT); + } + registryData.fill(HIST("nJetsPerEvent"), nJets); + registryData.fill(HIST("nJetsPerEventsel"), nJetssel); + isAtLeastOneJetSelected = true; + if (!isAtLeastOneJetSelected) { + return; + } + registryData.fill(HIST("number_of_events_data"), 3.5); + // Event multiplicity + const float multiplicity = collision.centFT0M(); + registryData.fill(HIST("number_of_events_vsmultiplicity"), multiplicity); + // v0 loop + int V0Numbers = 0; + int AntiV0Numbers = 0; + for (const auto& v0 : fullV0s) { + const auto& pos = v0.posTrack_as(); + const auto& neg = v0.negTrack_as(); + TVector3 v0dir(v0.px(), v0.py(), v0.pz()); + if (passedLambdaSelection(v0, pos, neg)) { + V0Numbers = V0Numbers + 1; + registryData.fill(HIST("LambdaPtMass"), v0.pt(), v0.mLambda()); + } + if (passedAntiLambdaSelection(v0, pos, neg)) { + AntiV0Numbers = AntiV0Numbers + 1; + registryData.fill(HIST("AntiLambdaPtMass"), v0.pt(), v0.mAntiLambda()); + } + } + registryData.fill(HIST("nV0sPerEvent"), V0Numbers); + + // calculate lambda polarization induced by jet + + if (V0Numbers == 0) { + return; + } + if (maxJetpx == 0) { + return; + } + double protonsinPhiInJetV0frame = 0; + double AntiprotonsinPhiInJetV0frame = 0; + cout << maxJetpx << endl; + for (const auto& candidate : fullV0s) { + const auto& pos = candidate.posTrack_as(); + const auto& neg = candidate.negTrack_as(); + TVector3 v0dir(candidate.px(), candidate.py(), candidate.pz()); + + if (passedLambdaSelection(candidate, pos, neg)) { + registryData.fill(HIST("hMassLambda"), candidate.mLambda()); + registryData.fill(HIST("V0pTInLab"), candidate.pt()); + registryData.fill(HIST("V0pxInLab"), candidate.px()); + registryData.fill(HIST("V0pyInLab"), candidate.py()); + registryData.fill(HIST("V0pzInLab"), candidate.pz()); + registryData.fill(HIST("V0protonpxInLab"), pos.px()); + registryData.fill(HIST("V0protonpyInLab"), pos.py()); + registryData.fill(HIST("V0protonpzInLab"), pos.pz()); + + double PLambda = sqrt(candidate.px() * candidate.px() + candidate.py() * candidate.py() + candidate.pz() * candidate.pz()); + double ELambda = sqrt(candidate.mLambda() * candidate.mLambda() + PLambda * PLambda); + double protonE = sqrt(massPr * massPr + pos.px() * pos.px() + pos.py() * pos.py() + pos.pz() * pos.pz()); + + TMatrixD pLabV0(4, 1); + pLabV0(0, 0) = ELambda; + pLabV0(1, 0) = candidate.px(); + pLabV0(2, 0) = candidate.py(); + pLabV0(3, 0) = candidate.pz(); + + TMatrixD V0InV0(4, 1); + V0InV0 = LorentzTransInV0frame(ELambda, candidate.px(), candidate.py(), candidate.pz()) * pLabV0; + registryData.fill(HIST("V0pxInRest_frame"), V0InV0(1, 0)); + registryData.fill(HIST("V0pyInRest_frame"), V0InV0(2, 0)); + registryData.fill(HIST("V0pzInRest_frame"), V0InV0(3, 0)); + + double protonsinPhiInLab = candidate.py() / sqrt(candidate.px() * candidate.px() + candidate.py() * candidate.py()); + registryData.fill(HIST("V0protonphiInLab"), protonsinPhiInLab); + + TMatrixD lambdaInJet(4, 1); + lambdaInJet = MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabV0; + + TMatrixD lambdaInJetV0(4, 1); + lambdaInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabV0; + registryData.fill(HIST("V0LambdapxInJetV0frame"), lambdaInJetV0(1, 0)); + registryData.fill(HIST("V0LambdapyInJetV0frame"), lambdaInJetV0(2, 0)); + registryData.fill(HIST("V0LambdapzInJetV0frame"), lambdaInJetV0(3, 0)); + + TMatrixD pLabproton(4, 1); + pLabproton(0, 0) = protonE; + pLabproton(1, 0) = pos.px(); + pLabproton(2, 0) = pos.py(); + pLabproton(3, 0) = pos.pz(); + + TMatrixD protonInV0(4, 1); + protonInV0 = LorentzTransInV0frame(ELambda, candidate.px(), candidate.py(), candidate.pz()) * pLabproton; + double protonMassInV0 = sqrt(protonInV0(0, 0) * protonInV0(0, 0) - protonInV0(1, 0) * protonInV0(1, 0) - protonInV0(2, 0) * protonInV0(2, 0) - protonInV0(3, 0) * protonInV0(3, 0)); + registryData.fill(HIST("V0protonMassInRest_frame"), protonMassInV0); + registryData.fill(HIST("V0protonpxInRest_frame"), protonInV0(1, 0)); + registryData.fill(HIST("V0protonpyInRest_frame"), protonInV0(2, 0)); + registryData.fill(HIST("V0protonpzInRest_frame"), protonInV0(3, 0)); + double protonsinPhiInV0frame = protonInV0(2, 0) / sqrt(protonInV0(1, 0) * protonInV0(1, 0) + protonInV0(2, 0) * protonInV0(2, 0)); + registryData.fill(HIST("V0protonphiInRest_frame"), protonsinPhiInV0frame); + + TMatrixD protonInJetV0(4, 1); + protonInJetV0 = LorentzTransInV0frame(ELambda, lambdaInJet(1, 0), lambdaInJet(2, 0), lambdaInJet(3, 0)) * MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabproton; + registryData.fill(HIST("V0protonpxInJetV0frame"), protonInJetV0(1, 0)); + registryData.fill(HIST("V0protonpyInJetV0frame"), protonInJetV0(2, 0)); + registryData.fill(HIST("V0protonpzInJetV0frame"), protonInJetV0(3, 0)); + + double protonPinJetV0 = sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0) + protonInJetV0(3, 0) * protonInJetV0(3, 0)); + double protonPtinJetV0 = sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); + + double protonCosThetainJetV0 = protonInJetV0(3, 0) / protonPinJetV0; + double protonSinThetainJetV0 = protonPtinJetV0 / protonPinJetV0; + double protonthetainJetV0 = TMath::ASin(protonSinThetainJetV0); + registryV0Data.fill(HIST("hprotoncosthetainJetV0"), protonCosThetainJetV0); + registryV0Data.fill(HIST("hprotonsinthetainJetV0"), protonSinThetainJetV0); + registryV0Data.fill(HIST("hprotonthetainJetV0"), protonthetainJetV0); + registryV0Data.fill(HIST("hprotoncosSquarethetainJetV0"), protonCosThetainJetV0 * protonCosThetainJetV0); + + registryV0Data.fill(HIST("hLambdamassandSinthetainJetV0"), candidate.mLambda(), protonSinThetainJetV0); + registryV0Data.fill(HIST("hLambdamassandCosthetainJetV0"), candidate.mLambda(), protonCosThetainJetV0); + registryV0Data.fill(HIST("hLambdamassandCosSquarethetainJetV0"), candidate.mLambda(), protonCosThetainJetV0 * protonCosThetainJetV0); + + registryV0Data.fill(HIST("AverageSinthetainJetV0"), candidate.mLambda(), protonSinThetainJetV0); + registryV0Data.fill(HIST("AverageCosSquarethetainJetV0"), candidate.mLambda(), protonCosThetainJetV0 * protonCosThetainJetV0); + protonsinPhiInJetV0frame = protonsinPhiInJetV0frame + protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0)); + + registryData.fill(HIST("TProfile2DLambdaPtMassSinPhi"), candidate.mLambda(), candidate.pt(), protonInJetV0(2, 0) / sqrt(protonInJetV0(1, 0) * protonInJetV0(1, 0) + protonInJetV0(2, 0) * protonInJetV0(2, 0))); + registryData.fill(HIST("TProfile2DLambdaPtMassSintheta"), candidate.mLambda(), candidate.pt(), protonSinThetainJetV0); + registryData.fill(HIST("TProfile2DLambdaPtMassCosSquareTheta"), candidate.mLambda(), candidate.pt(), protonCosThetainJetV0 * protonCosThetainJetV0); + } + if (passedAntiLambdaSelection(candidate, pos, neg)) { + double PAntiLambda = sqrt(candidate.px() * candidate.px() + candidate.py() * candidate.py() + candidate.pz() * candidate.pz()); + double EAntiLambda = sqrt(candidate.mAntiLambda() * candidate.mAntiLambda() + PAntiLambda * PAntiLambda); + double AntiprotonE = sqrt(massPr * massPr + neg.px() * neg.px() + neg.py() * neg.py() + neg.pz() * neg.pz()); + TMatrixD pLabAntiV0(4, 1); + pLabAntiV0(0, 0) = EAntiLambda; + pLabAntiV0(1, 0) = candidate.px(); + pLabAntiV0(2, 0) = candidate.py(); + pLabAntiV0(3, 0) = candidate.pz(); + + TMatrixD AntilambdaInJet(4, 1); + AntilambdaInJet = MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiV0; + + TMatrixD pLabAntiproton(4, 1); + pLabAntiproton(0, 0) = AntiprotonE; + pLabAntiproton(1, 0) = neg.px(); + pLabAntiproton(2, 0) = neg.py(); + pLabAntiproton(3, 0) = neg.pz(); + TMatrixD AntiprotonInJetV0(4, 1); + AntiprotonInJetV0 = LorentzTransInV0frame(EAntiLambda, AntilambdaInJet(1, 0), AntilambdaInJet(2, 0), AntilambdaInJet(3, 0)) * MyTMatrixTranslationToJet(maxJetpx, maxJetpy, maxJetpz, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiproton; + AntiprotonsinPhiInJetV0frame = AntiprotonsinPhiInJetV0frame + AntiprotonInJetV0(2, 0) / sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0)); + registryData.fill(HIST("TProfile2DAntiLambdaPtMassSinPhi"), candidate.mAntiLambda(), candidate.pt(), AntiprotonInJetV0(2, 0) / sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0))); + + TMatrixD AntiprotonInV0(4, 1); + AntiprotonInV0 = LorentzTransInV0frame(EAntiLambda, candidate.px(), candidate.py(), candidate.pz()) * pLabAntiproton; + + double AntiprotonPinJetV0 = sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0) + AntiprotonInJetV0(3, 0) * AntiprotonInJetV0(3, 0)); + double AntiprotonPtinJetV0 = sqrt(AntiprotonInJetV0(1, 0) * AntiprotonInJetV0(1, 0) + AntiprotonInJetV0(2, 0) * AntiprotonInJetV0(2, 0)); + + double AntiprotonCosThetainJetV0 = AntiprotonInJetV0(3, 0) / AntiprotonPinJetV0; + double AntiprotonSinThetainJetV0 = AntiprotonPtinJetV0 / AntiprotonPinJetV0; + + registryData.fill(HIST("TProfile2DAntiLambdaPtMassSintheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonSinThetainJetV0); + registryData.fill(HIST("TProfile2DAntiLambdaPtMassCosSquareTheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonCosThetainJetV0 * AntiprotonCosThetainJetV0); + } + } + + for (const auto& candidate : fullV0s) { + const auto& pos = candidate.posTrack_as(); + const auto& neg = candidate.negTrack_as(); + if (passedLambdaSelection(candidate, pos, neg)) { + registryData.fill(HIST("hLambdamassandSinPhi"), candidate.mLambda(), protonsinPhiInJetV0frame / V0Numbers); + registryData.fill(HIST("hLambdaPhiandSinPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers), protonsinPhiInJetV0frame / V0Numbers); + registryData.fill(HIST("V0LambdaprotonPhi"), TMath::ASin(protonsinPhiInJetV0frame / V0Numbers)); + registryData.fill(HIST("profileLambda"), candidate.mLambda(), protonsinPhiInJetV0frame / V0Numbers); + } + if (passedAntiLambdaSelection(candidate, pos, neg)) { + registryData.fill(HIST("hAntiLambdamassandSinPhi"), candidate.mAntiLambda(), AntiprotonsinPhiInJetV0frame / AntiV0Numbers); + registryData.fill(HIST("profileAntiLambda"), candidate.mAntiLambda(), AntiprotonsinPhiInJetV0frame / AntiV0Numbers); + } + } + } + PROCESS_SWITCH(LfMyV0s, processData, "processData", true); + + void processDataV0(SelCollisions::iterator const& collision, aod::V0Datas const& fullV0s, StrHadronDaughterTracks const&) + { + registryData.fill(HIST("hNEvents"), 0.5); + if (!AcceptEvent(collision)) { + return; + } + registryData.fill(HIST("hNEvents"), 8.5); + int V0NumbersPerEvent = 0; + int V0NumbersPerEventsel = 0; + for (const auto& v0 : fullV0s) { + V0NumbersPerEvent++; + float ctauLambda = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0; + float ctauAntiLambda = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0Bar; + const auto& pos = v0.posTrack_as(); + const auto& neg = v0.negTrack_as(); + if (passedLambdaSelection(v0, pos, neg) && ctauLambda < CtauLambda && ifpasslambda) { + V0NumbersPerEventsel++; + registryV0Data.fill(HIST("hLambdaPt"), v0.pt()); + registryV0Data.fill(HIST("hMassVsPtLambda"), v0.pt(), v0.mLambda()); + registryV0Data.fill(HIST("hMassLambda"), v0.mLambda()); + } else if (passedInitLambdaSelection(v0, pos, neg) && ifinitpasslambda) { + registryV0Data.fill(HIST("hLambdaPt"), v0.pt()); + registryV0Data.fill(HIST("hMassVsPtLambda"), v0.pt(), v0.mLambda()); + registryV0Data.fill(HIST("hMassLambda"), v0.mLambda()); + double PLambda = sqrt(v0.px() * v0.px() + v0.py() * v0.py() + v0.pz() * v0.pz()); + double ELambda = sqrt(v0.mLambda() * v0.mLambda() + PLambda * PLambda); + double protonE = sqrt(massPr * massPr + pos.px() * pos.px() + pos.py() * pos.py() + pos.pz() * pos.pz()); + TMatrixD pLabproton(4, 1); + pLabproton(0, 0) = protonE; + pLabproton(1, 0) = pos.px(); + pLabproton(2, 0) = pos.py(); + pLabproton(3, 0) = pos.pz(); + double protonCosThetainLab = pLabproton(3, 0) / pos.p(); + double protonSinThetainLab = pos.pt() / pos.p(); + double protonthetainLab = TMath::ASin(protonSinThetainLab); + registryV0Data.fill(HIST("hprotoncosthetainLab"), protonCosThetainLab); + registryV0Data.fill(HIST("hprotonsinthetainLab"), protonSinThetainLab); + registryV0Data.fill(HIST("hprotonthetainLab"), protonthetainLab); + registryV0Data.fill(HIST("hprotoncosSquarethetainLab"), protonCosThetainLab * protonCosThetainLab); + + TMatrixD protonInV0(4, 1); + protonInV0 = LorentzTransInV0frame(ELambda, v0.px(), v0.py(), v0.pz()) * pLabproton; + double protonPinV0 = sqrt(protonInV0(1, 0) * protonInV0(1, 0) + protonInV0(2, 0) * protonInV0(2, 0) + protonInV0(3, 0) * protonInV0(3, 0)); + double protonPtinV0 = sqrt(protonInV0(1, 0) * protonInV0(1, 0) + protonInV0(2, 0) * protonInV0(2, 0)); + double protonCosThetainV0 = protonInV0(3, 0) / protonPinV0; + double protonSinThetainV0 = protonPtinV0 / protonPinV0; + double protonthetainV0 = TMath::ASin(protonSinThetainV0); + registryV0Data.fill(HIST("hprotoncosthetainV0"), protonCosThetainV0); + registryV0Data.fill(HIST("hprotonsinthetainV0"), protonSinThetainV0); + registryV0Data.fill(HIST("hprotonthetainV0"), protonthetainV0); + registryV0Data.fill(HIST("hprotoncosSquarethetainV0"), protonCosThetainV0 * protonCosThetainV0); + + registryV0Data.fill(HIST("hLambdamassandSinthetainV0"), v0.mLambda(), protonSinThetainV0); + registryV0Data.fill(HIST("hLambdamassandCosthetainV0"), v0.mLambda(), protonCosThetainV0); + registryV0Data.fill(HIST("hLambdamassandCosSquarethetainV0"), v0.mLambda(), protonCosThetainV0 * protonCosThetainV0); + + registryV0Data.fill(HIST("AverageSinthetainV0"), v0.mLambda(), protonSinThetainV0); + registryV0Data.fill(HIST("AverageCosSquarethetainV0"), v0.mLambda(), protonCosThetainV0 * protonCosThetainV0); + } + if (passedAntiLambdaSelection(v0, pos, neg) && ctauAntiLambda < CtauLambda && ifpasslambda) { + registryV0Data.fill(HIST("hAntiLambdaPt"), v0.pt()); + registryV0Data.fill(HIST("hMassVsPtAntiLambda"), v0.pt(), v0.mAntiLambda()); + registryV0Data.fill(HIST("hMassAntiLambda"), v0.mAntiLambda()); + } else if (passedInitLambdaSelection(v0, pos, neg) && ifinitpasslambda) { + registryV0Data.fill(HIST("hAntiLambdaPt"), v0.pt()); + registryV0Data.fill(HIST("hMassVsPtAntiLambda"), v0.pt(), v0.mAntiLambda()); + registryV0Data.fill(HIST("hMassAntiLambda"), v0.mAntiLambda()); + } + } + registryV0Data.fill(HIST("nV0sPerEvent"), V0NumbersPerEvent); + registryV0Data.fill(HIST("nV0sPerEventsel"), V0NumbersPerEventsel); + } + PROCESS_SWITCH(LfMyV0s, processDataV0, "processDataV0", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc, TaskName{"lf-my-v0s"}), + }; +} From b1bd4b4f12ae3ad1eee35f50130bfab9e75b0bf4 Mon Sep 17 00:00:00 2001 From: suyoupeng <109774812+15071832337@users.noreply.github.com> Date: Wed, 28 May 2025 20:53:52 +0800 Subject: [PATCH 3/4] Add files via upload --- PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx | 2 -- 1 file changed, 2 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx b/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx index cb9fd1e470f..dd339d42c55 100644 --- a/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx +++ b/PWGLF/Tasks/Strangeness/lambdaJetpolarization.cxx @@ -1056,8 +1056,6 @@ struct LfMyV0s { double AntiprotonCosThetainJetV0 = AntiprotonInJetV0(3, 0) / AntiprotonPinJetV0; double AntiprotonSinThetainJetV0 = AntiprotonPtinJetV0 / AntiprotonPinJetV0; - double AntiprotonthetainJetV0 = TMath::ASin(AntiprotonSinThetainJetV0); - registryData.fill(HIST("TProfile2DAntiLambdaPtMassSintheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonSinThetainJetV0); registryData.fill(HIST("TProfile2DAntiLambdaPtMassCosSquareTheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonCosThetainJetV0 * AntiprotonCosThetainJetV0); } From 829011f4b14268b4e929fb4ad6e4576e13b63a00 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 28 May 2025 12:54:19 +0000 Subject: [PATCH 4/4] Please consider the following formatting changes --- PWGLF/Tasks/lambdaJetpolarization.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/lambdaJetpolarization.cxx b/PWGLF/Tasks/lambdaJetpolarization.cxx index 88187c43ed5..cdb76f466fb 100644 --- a/PWGLF/Tasks/lambdaJetpolarization.cxx +++ b/PWGLF/Tasks/lambdaJetpolarization.cxx @@ -1056,7 +1056,7 @@ struct LfMyV0s { double AntiprotonCosThetainJetV0 = AntiprotonInJetV0(3, 0) / AntiprotonPinJetV0; double AntiprotonSinThetainJetV0 = AntiprotonPtinJetV0 / AntiprotonPinJetV0; - + registryData.fill(HIST("TProfile2DAntiLambdaPtMassSintheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonSinThetainJetV0); registryData.fill(HIST("TProfile2DAntiLambdaPtMassCosSquareTheta"), candidate.mAntiLambda(), candidate.pt(), AntiprotonCosThetainJetV0 * AntiprotonCosThetainJetV0); }