Skip to content

added pions in jet + histo with ITSclsSize*tgl #6386

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
alcaliva merged 4 commits into from
Jun 6, 2024
Merged

added pions in jet + histo with ITSclsSize*tgl #6386

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
371e8e6
fixed table name
alcaliva Jun 6, 2024
1ea1f7d
fixed func name
alcaliva Jun 6, 2024
ae1430b
fixed func name
alcaliva Jun 6, 2024
0093e46
fixed func name
alcaliva Jun 6, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
195 changes: 189 additions & 6 deletions PWGLF/Tasks/Strangeness/strangeness_in_jets.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -86,6 +86,7 @@ struct strangeness_in_jets {
Configurable<float> minTPCnClsFound{"minTPCnClsFound", 80.0f, "min number of found TPC clusters"};
Configurable<float> minNCrossedRowsTPC{"minNCrossedRowsTPC", 80.0f, "min number of TPC crossed rows"};
Configurable<float> maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"};
Configurable<float> maxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"};
Configurable<float> etaMin{"etaMin", -0.8f, "eta min"};
Configurable<float> etaMax{"etaMax", +0.8f, "eta max"};
Configurable<float> ptMin_V0_proton{"ptMin_V0_proton", 0.3f, "pt min of proton from V0"};
Expand All @@ -102,6 +103,8 @@ struct strangeness_in_jets {
Configurable<float> dcapostoPVmin{"dcapostoPVmin", 0.1f, "Minimum DCA Pos To PV"};
Configurable<bool> requireTOF{"requireTOF", false, "require TOF hit"};
Configurable<bool> requireITS{"requireITS", false, "require ITS hit"};
Configurable<float> dcaxyMax{"dcaxyMax", 0.1f, "Maximum DCAxy to primary vertex"};
Configurable<float> dcazMax{"dcazMax", 0.1f, "Maximum DCAz to primary vertex"};

// V0 Parameters
Configurable<float> yMin{"yMin", -0.5f, "minimum y"};
Expand All @@ -118,6 +121,8 @@ struct strangeness_in_jets {
Configurable<float> dcabachtopvMin{"dcabachtopvMin", 0.1f, "Minimum DCA bachelor to PV"};
Configurable<float> dcaV0topvMin{"dcaV0topvMin", 0.1f, "Minimum DCA V0 to PV"};
Configurable<float> dcaCascDaughtersMax{"dcaCascDaughtersMax", 0.5f, "Maximum DCA Daughters"};

// Debug
Configurable<std::vector<int>> debug{"debug", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, "debug"};

void init(InitContext const&)
Expand All @@ -130,6 +135,16 @@ struct strangeness_in_jets {
std::vector<double> multBinning = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
AxisSpec multAxis = {multBinning, "FT0C percentile"};

// Histograms (Pions)
registryData.add("piplus_tpc_in_jet", "piplus_tpc_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TPC}"}});
registryData.add("piplus_tof_in_jet", "piplus_tof_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TOF}"}});
registryData.add("piplus_tpc_in_ue", "piplus_tpc_in_ue", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TPC}"}});
registryData.add("piplus_tof_in_ue", "piplus_tof_in_ue", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TOF}"}});
registryData.add("piminus_tpc_in_jet", "piminus_tpc_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TPC}"}});
registryData.add("piminus_tof_in_jet", "piminus_tof_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TOF}"}});
registryData.add("piminus_tpc_in_ue", "piminus_tpc_in_ue", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TPC}"}});
registryData.add("piminus_tof_in_ue", "piminus_tof_in_ue", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10, 10, "n#sigma_{TOF}"}});

// Histograms (Lambda)
registryData.add("Lambda_in_jet", "Lambda_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, 1.09, 1.14, "m_{p#pi} (GeV/#it{c}^{2})"}});
registryData.add("AntiLambda_in_jet", "AntiLambda_in_jet", HistType::kTH3F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {200, 1.09, 1.14, "m_{p#pi} (GeV/#it{c}^{2})"}});
Expand All @@ -156,12 +171,20 @@ struct strangeness_in_jets {
registryMC.add("K0s_generated", "K0s_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("Lambda_generated", "Lambda_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("AntiLambda_generated", "AntiLambda_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("XiPos_generated", "XiPos_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("XiNeg_generated", "XiNeg_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("OmegaPos_generated", "OmegaPos_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("OmegaNeg_generated", "OmegaNeg_generated", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("K0s_reconstructed", "K0s_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("Lambda_reconstructed", "Lambda_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("AntiLambda_reconstructed", "AntiLambda_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("K0s_reconstructed_incl", "K0s_reconstructed_incl", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("Lambda_reconstructed_incl", "Lambda_reconstructed_incl", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("AntiLambda_reconstructed_incl", "AntiLambda_reconstructed_incl", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("XiPos_reconstructed", "XiPos_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("XiNeg_reconstructed", "XiNeg_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("OmegaPos_reconstructed", "OmegaPos_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});
registryMC.add("OmegaNeg_reconstructed", "OmegaNeg_reconstructed", HistType::kTH2F, {multBinning, {100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}});

// Histograms for reweighting
registryMC.add("K0s_eta_pt_jet", "K0s_eta_pt_jet", HistType::kTH2F, {{100, 0.0, 10.0, "#it{p}_{T} (GeV/#it{c})"}, {18, -0.9, 0.9, "#eta"}});
Expand Down Expand Up @@ -203,6 +226,39 @@ struct strangeness_in_jets {
return true;
}

template <typename pionTrack>
bool passedTrackSelectionForPions(const pionTrack& track)
{
if (!track.hasITS())
return false;
if (track.itsNCls() < minITSnCls)
return false;
if (!track.hasTPC())
return false;
if (track.tpcNClsFound() < minTPCnClsFound)
return false;
if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC)
return false;
if (track.tpcChi2NCl() > maxChi2TPC)
return false;
if (track.itsChi2NCl() > maxChi2ITS)
return false;
if (track.eta() < etaMin || track.eta() > etaMax)
return false;
if (TMath::Abs(track.dcaXY()) > dcaxyMax)
return false;
if (TMath::Abs(track.dcaZ()) > dcazMax)
return false;

// Rapidity Selection
TLorentzVector lorentzVect;
lorentzVect.SetXYZM(track.px(), track.py(), track.pz(), 0.13957021);
if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax)
return false;

return true;
}

// Lambda Selections
template <typename V, typename T1, typename T2>
bool passedLambdaSelection(const V& v0, const T1& ptrack, const T2& ntrack)
Expand Down Expand Up @@ -254,7 +310,7 @@ struct strangeness_in_jets {

// Rapidity Selection
TLorentzVector lorentzVect;
lorentzVect.SetXYZM(ptrack.px() + ntrack.px(), ptrack.py() + ntrack.py(), ptrack.pz() + ntrack.pz(), 1.115683);
lorentzVect.SetXYZM(v0.px(), v0.py(), v0.pz(), 1.115683);
if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax)
return false;
return true;
Expand Down Expand Up @@ -311,7 +367,7 @@ struct strangeness_in_jets {

// Rapidity Selection
TLorentzVector lorentzVect;
lorentzVect.SetXYZM(ptrack.px() + ntrack.px(), ptrack.py() + ntrack.py(), ptrack.pz() + ntrack.pz(), 1.115683);
lorentzVect.SetXYZM(v0.px(), v0.py(), v0.pz(), 1.115683);
if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax)
return false;
return true;
Expand Down Expand Up @@ -368,7 +424,7 @@ struct strangeness_in_jets {

// Rapidity Selection
TLorentzVector lorentzVect;
lorentzVect.SetXYZM(ptrack.px() + ntrack.px(), ptrack.py() + ntrack.py(), ptrack.pz() + ntrack.pz(), 0.497614);
lorentzVect.SetXYZM(v0.px(), v0.py(), v0.pz(), 0.497614);
if (lorentzVect.Rapidity() < yMin || lorentzVect.Rapidity() > yMax)
return false;
return true;
Expand Down Expand Up @@ -966,13 +1022,65 @@ struct strangeness_in_jets {
}
}
}

for (auto track : tracks) {

if (!passedTrackSelectionForPions(track))
continue;

TVector3 track_dir(track.px(), track.py(), track.pz());
float deltaEta_jet = track_dir.Eta() - jet_axis.Eta();
float deltaPhi_jet = GetDeltaPhi(track_dir.Phi(), jet_axis.Phi());
float deltaR_jet = sqrt(deltaEta_jet * deltaEta_jet + deltaPhi_jet * deltaPhi_jet);
float deltaEta_ue1 = track_dir.Eta() - ue_axis1.Eta();
float deltaPhi_ue1 = GetDeltaPhi(track_dir.Phi(), ue_axis1.Phi());
float deltaR_ue1 = sqrt(deltaEta_ue1 * deltaEta_ue1 + deltaPhi_ue1 * deltaPhi_ue1);
float deltaEta_ue2 = track_dir.Eta() - ue_axis2.Eta();
float deltaPhi_ue2 = GetDeltaPhi(track_dir.Phi(), ue_axis2.Phi());
float deltaR_ue2 = sqrt(deltaEta_ue2 * deltaEta_ue2 + deltaPhi_ue2 * deltaPhi_ue2);

// TPC
if (deltaR_jet < Rmax && track.sign() > 0) {
registryData.fill(HIST("piplus_tpc_in_jet"), multiplicity, track.pt(), track.tpcNSigmaPi());
}
if ((deltaR_ue1 < Rmax || deltaR_ue2) < Rmax && track.sign() > 0) {
registryData.fill(HIST("piplus_tpc_in_ue"), multiplicity, track.pt(), track.tpcNSigmaPi());
}
if (deltaR_jet < Rmax && track.sign() < 0) {
registryData.fill(HIST("piminus_tpc_in_jet"), multiplicity, track.pt(), track.tpcNSigmaPi());
}
if ((deltaR_ue1 < Rmax || deltaR_ue2) < Rmax && track.sign() < 0) {
registryData.fill(HIST("piminus_tpc_in_ue"), multiplicity, track.pt(), track.tpcNSigmaPi());
}

if (track.tpcNSigmaPi() < nsigmaTPCmin || track.tpcNSigmaPi() > nsigmaTPCmax)
continue;

if (!track.hasTOF())
continue;

// TOF
if (deltaR_jet < Rmax && track.sign() > 0) {
registryData.fill(HIST("piplus_tof_in_jet"), multiplicity, track.pt(), track.tofNSigmaPi());
}
if ((deltaR_ue1 < Rmax || deltaR_ue2) < Rmax && track.sign() > 0) {
registryData.fill(HIST("piplus_tof_in_ue"), multiplicity, track.pt(), track.tofNSigmaPi());
}
if (deltaR_jet < Rmax && track.sign() < 0) {
registryData.fill(HIST("piminus_tof_in_jet"), multiplicity, track.pt(), track.tofNSigmaPi());
}
if ((deltaR_ue1 < Rmax || deltaR_ue2) < Rmax && track.sign() < 0) {
registryData.fill(HIST("piminus_tof_in_ue"), multiplicity, track.pt(), track.tofNSigmaPi());
}
}
}
PROCESS_SWITCH(strangeness_in_jets, processData, "Process data", true);

Preslice<aod::V0Datas> perCollision = o2::aod::v0data::collisionId;
Preslice<aod::V0Datas> perCollisionV0 = o2::aod::v0data::collisionId;
Preslice<aod::CascDataExt> perCollisionCasc = o2::aod::cascade::collisionId;
Preslice<aod::McParticles> perMCCollision = o2::aod::mcparticle::mcCollisionId;

void processMCefficiency(SimCollisions const& collisions, MCTracks const& mcTracks, aod::V0Datas const& fullV0s, aod::McCollisions const& mcCollisions, const aod::McParticles& mcParticles)
void processMCefficiency(SimCollisions const& collisions, MCTracks const& mcTracks, aod::V0Datas const& fullV0s, aod::CascDataExt const& Cascades, aod::McCollisions const& mcCollisions, const aod::McParticles& mcParticles)
{
for (const auto& collision : collisions) {
registryQC.fill(HIST("number_of_events_mc"), 0.5);
Expand All @@ -986,7 +1094,8 @@ struct strangeness_in_jets {
registryQC.fill(HIST("number_of_events_mc"), 2.5);
float multiplicity = collision.centFT0M();

auto v0s_per_coll = fullV0s.sliceBy(perCollision, collision.globalIndex());
auto v0s_per_coll = fullV0s.sliceBy(perCollisionV0, collision.globalIndex());
auto casc_per_coll = Cascades.sliceBy(perCollisionCasc, collision.globalIndex());
auto mcParticles_per_coll = mcParticles.sliceBy(perMCCollision, collision.globalIndex());

for (auto& v0 : v0s_per_coll) {
Expand Down Expand Up @@ -1043,6 +1152,64 @@ struct strangeness_in_jets {
}
}

// Cascades
for (auto& casc : casc_per_coll) {
auto bach = casc.template bachelor_as<MCTracks>();
auto neg = casc.template negTrack_as<MCTracks>();
auto pos = casc.template posTrack_as<MCTracks>();

if (!bach.has_mcParticle())
continue;
if (!pos.has_mcParticle())
continue;
if (!neg.has_mcParticle())
continue;

auto posParticle = pos.mcParticle_as<aod::McParticles>();
auto negParticle = neg.mcParticle_as<aod::McParticles>();
auto bachParticle = bach.mcParticle_as<aod::McParticles>();
if (!posParticle.has_mothers())
continue;
if (!negParticle.has_mothers())
continue;
if (!bachParticle.has_mothers())
continue;

int pdg_parent(0);
for (auto& particleMotherOfNeg : negParticle.mothers_as<aod::McParticles>()) {
for (auto& particleMotherOfPos : posParticle.mothers_as<aod::McParticles>()) {
for (auto& particleMotherOfBach : bachParticle.mothers_as<aod::McParticles>()) {
if (particleMotherOfNeg.globalIndex() != particleMotherOfPos.globalIndex())
continue;
if (abs(particleMotherOfNeg.pdgCode()) != 3122)
continue;
if (!particleMotherOfBach.isPhysicalPrimary())
continue;
pdg_parent = particleMotherOfBach.pdgCode();
}
}
}
if (pdg_parent == 0)
continue;

// Xi+
if (passedXiSelection(casc, pos, neg, bach, collision) && pdg_parent == -3312) {
registryMC.fill(HIST("XiPos_reconstructed"), multiplicity, casc.pt());
}
// Xi-
if (passedXiSelection(casc, pos, neg, bach, collision) && pdg_parent == 3312) {
registryMC.fill(HIST("XiNeg_reconstructed"), multiplicity, casc.pt());
}
// Omega+
if (passedOmegaSelection(casc, pos, neg, bach, collision) && pdg_parent == -3334) {
registryMC.fill(HIST("OmegaPos_reconstructed"), multiplicity, casc.pt());
}
// Omega-
if (passedOmegaSelection(casc, pos, neg, bach, collision) && pdg_parent == 3334) {
registryMC.fill(HIST("OmegaNeg_reconstructed"), multiplicity, casc.pt());
}
}

for (auto& mcParticle : mcParticles_per_coll) {

if (mcParticle.y() < yMin || mcParticle.y() > yMax)
Expand All @@ -1065,6 +1232,22 @@ struct strangeness_in_jets {
registryMC.fill(HIST("AntiLambda_generated"), multiplicity, mcParticle.pt());
registryMC.fill(HIST("AntiLambda_eta_pt_pythia"), mcParticle.pt(), mcParticle.eta());
}
// Xi Pos
if (mcParticle.pdgCode() == -3312) {
registryMC.fill(HIST("XiPos_generated"), multiplicity, mcParticle.pt());
}
// Xi Neg
if (mcParticle.pdgCode() == 3312) {
registryMC.fill(HIST("XiNeg_generated"), multiplicity, mcParticle.pt());
}
// Omega Pos
if (mcParticle.pdgCode() == -3334) {
registryMC.fill(HIST("OmegaPos_generated"), multiplicity, mcParticle.pt());
}
// Omega Neg
if (mcParticle.pdgCode() == 3334) {
registryMC.fill(HIST("OmegaNeg_generated"), multiplicity, mcParticle.pt());
}
}
}
}
Expand Down