Skip to content

Commit c7eb32f

Browse files
author
Nicolas Strangmann
committed
Add PCM to omega trigger task
1 parent 1d86b98 commit c7eb32f

File tree

5 files changed

+320
-208
lines changed

5 files changed

+320
-208
lines changed

‎EventFiltering/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -104,7 +104,7 @@ o2physics_add_dpl_workflow(em-photon-filter-qc
104104

105105
o2physics_add_dpl_workflow(heavy-neutral-meson-filter
106106
SOURCES PWGEM/HeavyNeutralMesonFilter.cxx
107-
PUBLIC_LINK_LIBRARIES O2::Framework O2::EMCALBase O2::EMCALCalib O2Physics::AnalysisCore
107+
PUBLIC_LINK_LIBRARIES O2::Framework O2::EMCALBase O2::EMCALCalib O2Physics::AnalysisCore O2Physics::PWGEMPhotonMesonCore
108108
COMPONENT_NAME Analysis)
109109

110110
o2physics_add_dpl_workflow(lf-f1proton-filter

‎EventFiltering/PWGEM/HeavyNeutralMesonFilter.cxx‎

Lines changed: 96 additions & 185 deletions
Original file line numberDiff line numberDiff line change
@@ -16,110 +16,35 @@
1616
/// \author Nicolas Strangmann ([email protected]) - Goethe University Frankfurt
1717
///
1818

19-
#include <CommonConstants/MathConstants.h>
20-
#include <CommonConstants/PhysicsConstants.h>
21-
#include <vector>
22-
#include "TVector3.h"
23-
24-
#include "Framework/runDataProcessing.h"
25-
#include "Framework/AnalysisTask.h"
26-
#include "Framework/HistogramRegistry.h"
27-
#include "Common/DataModel/EventSelection.h"
28-
#include "EMCALBase/Geometry.h"
29-
#include "PWGJE/DataModel/EMCALClusters.h"
30-
#include "Common/Core/trackUtilities.h"
31-
#include "Common/DataModel/TrackSelectionTables.h"
32-
#include "EventFiltering/filterTables.h"
19+
#include "PWGEM/PhotonMeson/Utils/HNMUtilities.h"
3320

3421
using namespace o2;
3522
using namespace o2::framework;
3623
using namespace o2::framework::expressions;
24+
using namespace o2::aod::pwgem::photonmeson::utils::hnmutilities;
3725

3826
using MyBCs = soa::Join<aod::BCs, aod::BcSels, aod::Timestamps>;
3927
using MyCollisions = soa::Join<aod::Collisions, aod::EvSels>;
4028

4129
using SelectedTracks = soa::Filtered<soa::Join<aod::FullTracks, aod::TrackSelection>>;
42-
using SelectedClusters = soa::Filtered<aod::EMCALClusters>; // Clusters from collisions with only one collision in the BC
43-
44-
struct Photon { // Struct to store photons (unique and ambiguous clusters that passed the cuts)
45-
Photon(float eta, float phi, float energy) : eta(eta), phi(phi), e(energy), theta(2 * std::atan2(std::exp(-eta), 1)), px(e * std::sin(theta) * std::cos(phi)), py(e * std::sin(theta) * std::sin(phi)), pz(e * std::cos(theta)), pt(std::sqrt(px * px + py * py))
46-
{
47-
photon.SetPxPyPzE(px, py, pz, e);
48-
}
49-
50-
ROOT::Math::PxPyPzEVector photon;
51-
float eta, phi, e;
52-
float theta;
53-
float px, py, pz, pt;
54-
};
55-
56-
namespace HeavyNeutralMeson
57-
{
58-
enum MesonType {
59-
kPi0 = 1 << 0, // 0001
60-
kEta = 1 << 1, // 0010
61-
kOmega = 1 << 2, // 0100
62-
kEtaPrime = 1 << 3 // 1000
63-
};
64-
}
65-
66-
struct Meson {
67-
Meson(Photon p1, Photon p2) : p1(p1), p2(p2), mesonType(0)
68-
{
69-
pMeson = p1.photon + p2.photon;
70-
}
71-
Meson(Meson gg, float eTracks, float pxTracks, float pyTracks, float pzTracks) : p1(gg.p1), p2(gg.p2), mesonType(0)
72-
{
73-
pMeson.SetPxPyPzE(gg.pMeson.Px() + pxTracks, gg.pMeson.Py() + pyTracks, gg.pMeson.Pz() + pzTracks, gg.pMeson.e() + eTracks);
74-
}
75-
Photon p1, p2;
76-
ROOT::Math::PxPyPzEVector pMeson;
77-
78-
uint32_t mesonType;
79-
80-
void addMesonType(uint32_t type) { mesonType |= type; }
81-
bool hasMesonType(uint32_t type) const { return mesonType & type; }
82-
83-
float m() const { return pMeson.M(); }
84-
float pT() const { return pMeson.Pt(); }
85-
};
8630

8731
struct HeavyNeutralMesonFilter {
88-
8932
Produces<aod::HeavyNeutralMesonFilters> tags;
9033

9134
HistogramRegistry mHistManager{"HeavyNeutralMesonFilterHistograms", {}, OutputObjHandlingPolicy::QAObject};
9235

93-
Configurable<int> cfgClusterDefinition{"cfgClusterDefinition", 13, "Clusterizer to be selected, e.g. 13 for kV3MostSplitLowSeed"};
94-
Configurable<float> cfgMinClusterEnergy{"cfgMinClusterEnergy", 0.5, "Minimum energy of selected clusters (GeV)"};
95-
Configurable<float> cfgMinM02{"cfgMinM02", 0., "Minimum M02 of selected clusters"};
96-
Configurable<float> cfgMaxM02{"cfgMaxM02", 1, "Maximum M02 of selected clusters"};
97-
Configurable<float> cfgMinTime{"cfgMinTime", -25, "Minimum time of selected clusters (ns)"};
98-
Configurable<float> cfgMaxTime{"cfgMaxTime", 25, "Maximum time of selected clusters (ns)"};
99-
10036
Configurable<float> cfgTrackMinPt{"cfgTrackMinPt", 0.1, "Minimum momentum of tracks (GeV/c)"};
101-
37+
Configurable<int> cfgHNMMassCorrection{"cfgHNMMassCorrection", 1, "Use GG PDG mass to correct HNM mass (0 = off, 1 = subDeltaPi0, 2 = subLambda)"};
10238
static constexpr float defaultMassWindows[2][4] = {{0., 0.4, 0.6, 1.}, {0.4, 0.8, 0.8, 1.2}};
10339
Configurable<LabeledArray<float>> massWindowOmega{"massWindowOmega", {defaultMassWindows[0], 4, {"pi0_min", "pi0_max", "omega_min", "omega_max"}}, "Mass window for selected omegas and their decay pi0"};
10440
Configurable<LabeledArray<float>> massWindowEtaPrime{"massWindowEtaPrime", {defaultMassWindows[1], 4, {"eta_min", "eta_max", "etaprime_min", "etaprime_max"}}, "Mass window for selected eta' and their decay eta"};
10541

106-
static constexpr float defaultMinPts[4] = {0., 5., 0., 5.}; // LowPtOmega, HighPtOmega, LowPtEtaPrime, HighPtEtaPrime
107-
Configurable<LabeledArray<float>> minHNMPt{"minHNMPt", {defaultMinPts, 4, {"omega_lowPt", "omega_highPt", "etaPrime_lowPt", "etaPrime_highPt"}}, "Minimum pT values for the heavy neutral mesons of the low and high pT trigger"};
108-
109-
Filter clusterDefinitionFilter = aod::emcalcluster::definition == cfgClusterDefinition;
110-
Filter energyFilter = aod::emcalcluster::energy > cfgMinClusterEnergy;
111-
Filter m02Filter = (aod::emcalcluster::nCells == 1 || (aod::emcalcluster::m02 > cfgMinM02 && aod::emcalcluster::m02 < cfgMaxM02));
112-
Filter timeFilter = (aod::emcalcluster::time > cfgMinTime && aod::emcalcluster::time < cfgMaxTime);
113-
11442
Filter trackPtFilter = aod::track::pt > cfgTrackMinPt;
11543

116-
std::vector<Photon> mPhotons;
117-
std::vector<Meson> mGGs;
44+
std::vector<GammaGammaPair> vGGs;
45+
std::vector<HeavyNeutralMeson> vHNMs;
11846

119-
bool colContainsLowPtOmega = false;
120-
bool colContainsHighPtOmega = false;
121-
bool colContainsLowPtEtaPrime = false;
122-
bool colContainsHighPtEtaPrime = false;
47+
bool colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime = false;
12348

12449
emcal::Geometry* emcalGeom;
12550

@@ -131,131 +56,117 @@ struct HeavyNeutralMesonFilter {
13156
hCollisionCounter->GetXaxis()->SetBinLabel(2, "kTVXinEMC");
13257
hCollisionCounter->GetXaxis()->SetBinLabel(3, "L0Triggered");
13358
hCollisionCounter->GetXaxis()->SetBinLabel(4, "2+ tracks&clusters");
134-
hCollisionCounter->GetXaxis()->SetBinLabel(5, "Low #it{p}_{T} #omega");
135-
hCollisionCounter->GetXaxis()->SetBinLabel(6, "High #it{p}_{T} #omega");
136-
hCollisionCounter->GetXaxis()->SetBinLabel(7, "Low #it{p}_{T} #eta'");
137-
hCollisionCounter->GetXaxis()->SetBinLabel(8, "High #it{p}_{T} #eta'");
138-
139-
mHistManager.add("Event/nClusters", "Number of BCs (with (k)TVX);#bf{TVX triggered};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{51, -0.5, 50.5}});
140-
mHistManager.add("Event/nGGs", "Number of BCs (with (k)TVX);#bf{TVX triggered};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{51, -0.5, 50.5}});
141-
mHistManager.add("Event/nTracks", "Number of BCs (with (k)TVX);#bf{TVX triggered};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{51, -0.5, 50.5}});
142-
mHistManager.add("Event/nHeavyNeutralMesons", "Number of BCs (with (k)TVX);#bf{TVX triggered};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{51, -0.5, 50.5}});
143-
144-
mHistManager.add("nCollisionsVsClusters", "Number of collisions vs number of clusters;N_{Collisions};N_{Clusters}", HistType::kTH2F, {{4, -0.5, 3.5}, {21, -0.5, 20.5}});
145-
146-
mHistManager.add("Track/trackP", "Momentum of tracks;#bf{#it{p} (GeV/#it{c})};#bf{#it{N}_{tracks}}", HistType::kTH1F, {{200, 0, 20}});
147-
148-
mHistManager.add("Cluster/clusterE", "Energy of cluster;#bf{#it{E} (GeV)};#bf{#it{N}_{clusters}}", HistType::kTH1F, {{200, 0, 20}});
149-
mHistManager.add("Cluster/clusterM02", "Shape of cluster;#bf{#it{M}_{02}};#bf{#it{N}_{clusters}}", HistType::kTH1F, {{200, 0, 2}});
150-
mHistManager.add("Cluster/clusterTime", "Time of cluster;#bf{#it{t} (ns)};#bf{#it{N}_{clusters}}", HistType::kTH1F, {{200, -100, 100}});
151-
152-
mHistManager.add("GG/invMassVsPt", "Invariant mass and pT of meson candidates", HistType::kTH2F, {{400, massWindowOmega->get("pi0_min"), massWindowEtaPrime->get("eta_max")}, {250, 0., 25.}});
153-
154-
mHistManager.add("HeavyNeutralMeson/invMassVsPt", "Invariant mass and pT of meson candidates", HistType::kTH2F, {{600, massWindowOmega->get("omega_min"), massWindowEtaPrime->get("etaprime_max")}, {250, 0., 25.}});
59+
hCollisionCounter->GetXaxis()->SetBinLabel(5, "PCM #omega");
60+
hCollisionCounter->GetXaxis()->SetBinLabel(6, "EMC #omega");
61+
hCollisionCounter->GetXaxis()->SetBinLabel(7, "PCM #eta'");
62+
hCollisionCounter->GetXaxis()->SetBinLabel(8, "EMC #eta'");
63+
64+
mHistManager.add("Event/nGGs", "Number of (selected) #gamma#gamma paris;#bf{#it{N}_{#gamma#gamma}};#bf{#it{N}_{#gamma#gamma}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}});
65+
mHistManager.add("Event/nTracks", "Number of tracks;#bf{N_{tracks}};#bf{#it{N}_{Coll}}", HistType::kTH1F, {{51, -0.5, 50.5}});
66+
mHistManager.add("Event/nHeavyNeutralMesons", "Number of (selected) HNM candidates;#bf{#it{N}_{HNM}};#bf{#it{N}_{HNM}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}});
67+
mHistManager.add("Event/nClustersVsV0s", "Number of clusters and V0s in the collision;#bf{#it{N}_{clusters}};#bf{#it{N}_{V0s}}", HistType::kTH2F, {{26, -0.5, 25.5}, {26, -0.5, 25.5}});
68+
69+
mHistManager.add("GG/invMassVsPt_PCM", "Invariant mass and pT of gg candidates", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}});
70+
mHistManager.add("GG/invMassVsPt_PCMEMC", "Invariant mass and pT of gg candidates", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}});
71+
mHistManager.add("GG/invMassVsPt_EMC", "Invariant mass and pT of gg candidates", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}});
72+
73+
mHistManager.add("HeavyNeutralMeson/invMassVsPt_PCM", "Invariant mass and pT of HNM candidates", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}});
74+
mHistManager.add("HeavyNeutralMeson/invMassVsPt_PCMEMC", "Invariant mass and pT of HNM candidates", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}});
75+
mHistManager.add("HeavyNeutralMeson/invMassVsPt_EMC", "Invariant mass and pT of HNM candidates", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}});
15576
}
15677

157-
void process(MyCollisions::iterator const& collision, MyBCs const&, SelectedClusters const& clusters, SelectedTracks const& tracks)
78+
Preslice<aod::V0PhotonsKF> perCollision_pcm = aod::v0photonkf::collisionId;
79+
Preslice<aod::SkimEMCClusters> perCollision_emc = aod::skimmedcluster::collisionId;
80+
81+
void process(MyCollisions::iterator const& collision, MyBCs const&, aod::SkimEMCClusters const& clusters, aod::V0PhotonsKF const& v0s, SelectedTracks const& tracks)
15882
{
15983
mHistManager.fill(HIST("Event/hCollisionCounter"), 0.);
16084

161-
colContainsLowPtOmega = false;
162-
colContainsHighPtOmega = false;
163-
colContainsLowPtEtaPrime = false;
164-
colContainsHighPtEtaPrime = false;
85+
if (collision.foundBC_as<MyBCs>().alias_bit(kTVXinEMC))
86+
mHistManager.fill(HIST("Event/hCollisionCounter"), 1.);
16587

166-
if (isBCSelected(collision.foundBC_as<MyBCs>(), clusters.size(), tracks.size() > 2)) {
167-
processClusters(clusters);
88+
auto v0sInThisCollision = v0s.sliceBy(perCollision_pcm, collision.globalIndex());
89+
auto clustersInThisCollision = clusters.sliceBy(perCollision_emc, collision.globalIndex());
16890

169-
processGGs();
170-
processHeavyNeutralMesons(tracks);
91+
mHistManager.fill(HIST("Event/nClustersVsV0s"), clustersInThisCollision.size(), v0sInThisCollision.size());
92+
mHistManager.fill(HIST("Event/nTracks"), tracks.size());
17193

172-
mPhotons.clear();
173-
mGGs.clear();
174-
}
175-
176-
if (colContainsLowPtOmega)
177-
mHistManager.fill(HIST("Event/hCollisionCounter"), 4.);
178-
if (colContainsHighPtOmega)
179-
mHistManager.fill(HIST("Event/hCollisionCounter"), 5.);
180-
if (colContainsLowPtEtaPrime)
181-
mHistManager.fill(HIST("Event/hCollisionCounter"), 6.);
182-
if (colContainsHighPtEtaPrime)
183-
mHistManager.fill(HIST("Event/hCollisionCounter"), 7.);
184-
tags(colContainsLowPtOmega, colContainsHighPtOmega, colContainsLowPtEtaPrime, colContainsHighPtEtaPrime);
185-
}
94+
colContainsPCMOmega = colContainsEMCOmega = colContainsPCMEtaPrime = colContainsEMCEtaPrime = false;
18695

187-
bool isBCSelected(MyBCs::iterator const& bc, int nClusters, bool enoughTracks)
188-
{
189-
if (bc.alias_bit(kTVXinEMC))
190-
mHistManager.fill(HIST("Event/hCollisionCounter"), 1.);
191-
else if (bc.alias_bit(kEMC7) || bc.alias_bit(kEG1) || bc.alias_bit(kEG2) || bc.alias_bit(kDG1) || bc.alias_bit(kDG2) || bc.alias_bit(kEJ1) || bc.alias_bit(kEJ2) || bc.alias_bit(kDJ1) || bc.alias_bit(kDJ2))
192-
mHistManager.fill(HIST("Event/hCollisionCounter"), 2.);
193-
else
194-
return false;
195-
if (nClusters < 2 || !enoughTracks)
196-
return false;
197-
mHistManager.fill(HIST("Event/hCollisionCounter"), 3.);
96+
reconstructGGs(clustersInThisCollision, v0sInThisCollision, vGGs);
97+
processGGs(vGGs);
98+
reconstructHeavyNeutralMesons(tracks, vGGs, vHNMs);
99+
processHNMs(vHNMs);
198100

199-
return true;
101+
tags(colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime);
200102
}
201103

202-
void processClusters(SelectedClusters const& clusters)
104+
void processGGs(std::vector<GammaGammaPair>& vGGs)
203105
{
204-
for (const auto& cluster : clusters) {
205-
mHistManager.fill(HIST("Cluster/clusterE"), cluster.energy());
206-
mHistManager.fill(HIST("Cluster/clusterM02"), cluster.m02());
207-
mHistManager.fill(HIST("Cluster/clusterTime"), cluster.time());
208-
mPhotons.push_back(Photon(cluster.eta(), cluster.phi(), cluster.energy()));
209-
}
210-
mHistManager.fill(HIST("Event/nClusters"), clusters.size());
211-
}
106+
int nGGsBeforeMassCuts = vGGs.size();
107+
for (unsigned int iGG = 0; iGG < vGGs.size(); iGG++) {
108+
auto lightMeson = &vGGs.at(iGG);
109+
110+
if (lightMeson->reconstructionType == ReconstructionType::kPCM) {
111+
mHistManager.fill(HIST("GG/invMassVsPt_PCM"), lightMeson->m(), lightMeson->pT());
112+
} else if (lightMeson->reconstructionType == ReconstructionType::kEMC) {
113+
mHistManager.fill(HIST("GG/invMassVsPt_EMC"), lightMeson->m(), lightMeson->pT());
114+
} else {
115+
mHistManager.fill(HIST("GG/invMassVsPt_PCMEMC"), lightMeson->m(), lightMeson->pT());
116+
}
212117

213-
/// \brief Process light neutral meson candidates (pi0 or eta), calculate invariant mass and pT and fill histograms
214-
void processGGs()
215-
{
216-
// loop over all photon combinations and build meson candidates
217-
for (unsigned int ig1 = 0; ig1 < mPhotons.size(); ++ig1) {
218-
for (unsigned int ig2 = ig1 + 1; ig2 < mPhotons.size(); ++ig2) {
219-
Meson lightMeson(mPhotons[ig1], mPhotons[ig2]); // build lightMeson from photons
220-
mHistManager.fill(HIST("GG/invMassVsPt"), lightMeson.m(), lightMeson.pT());
221-
if (lightMeson.m() > massWindowOmega->get("pi0_min") && lightMeson.m() < massWindowOmega->get("pi0_max"))
222-
lightMeson.addMesonType(HeavyNeutralMeson::kPi0);
223-
else if (lightMeson.m() > massWindowEtaPrime->get("eta_min") && lightMeson.m() < massWindowEtaPrime->get("eta_max"))
224-
lightMeson.addMesonType(HeavyNeutralMeson::kEta);
225-
else
226-
continue;
227-
mGGs.push_back(lightMeson);
118+
if (lightMeson->m() > massWindowOmega->get("pi0_min") && lightMeson->m() < massWindowOmega->get("pi0_max")) {
119+
lightMeson->isPi0 = true;
120+
} else if (lightMeson->m() > massWindowEtaPrime->get("eta_min") && lightMeson->m() < massWindowEtaPrime->get("eta_max")) {
121+
lightMeson->isEta = true;
122+
} else {
123+
vGGs.erase(vGGs.begin() + iGG);
124+
iGG--;
228125
}
229126
}
230-
mHistManager.fill(HIST("Event/nGGs"), mGGs.size());
127+
mHistManager.fill(HIST("Event/nGGs"), nGGsBeforeMassCuts, vGGs.size());
231128
}
232129

233-
void processHeavyNeutralMesons(SelectedTracks const& tracks)
130+
void processHNMs(std::vector<HeavyNeutralMeson>& vHNMs)
234131
{
235-
for (const auto& posTrack : tracks) {
236-
if (!posTrack.isGlobalTrack() || posTrack.sign() < 0)
237-
continue;
238-
for (const auto& negTrack : tracks) {
239-
if (!negTrack.isGlobalTrack() || negTrack.sign() > 0)
240-
continue;
241-
for (unsigned long iGG = 0; iGG < mGGs.size(); iGG++) {
242-
Meson heavyNeutralMeson(mGGs.at(iGG), posTrack.energy(constants::physics::MassPiPlus) + negTrack.energy(constants::physics::MassPiPlus), posTrack.px() + negTrack.px(), posTrack.py() + negTrack.py(), posTrack.pz() + negTrack.pz());
243-
mHistManager.fill(HIST("HeavyNeutralMeson/invMassVsPt"), heavyNeutralMeson.m(), heavyNeutralMeson.pT());
244-
if (mGGs.at(iGG).hasMesonType(HeavyNeutralMeson::kPi0) && heavyNeutralMeson.m() > massWindowOmega->get("omega_min") && heavyNeutralMeson.m() < massWindowOmega->get("omega_max")) {
245-
if(minHNMPt->get("omega_lowPt") < heavyNeutralMeson.pT())
246-
colContainsLowPtOmega = true;
247-
if(minHNMPt->get("omega_highPt") < heavyNeutralMeson.pT())
248-
colContainsHighPtOmega = true;
249-
}
250-
if (mGGs.at(iGG).hasMesonType(HeavyNeutralMeson::kEta) && heavyNeutralMeson.m() > massWindowEtaPrime->get("etaprime_min") && heavyNeutralMeson.m() < massWindowEtaPrime->get("etaprime_max")) {
251-
if(minHNMPt->get("etaPrime_lowPt") < heavyNeutralMeson.pT())
252-
colContainsLowPtEtaPrime = true;
253-
if(minHNMPt->get("etaPrime_highPt") < heavyNeutralMeson.pT())
254-
colContainsHighPtEtaPrime = true;
255-
}
256-
}
132+
int nHNMsBeforeMassCuts = vHNMs.size();
133+
for (unsigned int iHNM = 0; iHNM < vHNMs.size(); iHNM++) {
134+
auto heavyNeutralMeson = vHNMs.at(iHNM);
135+
136+
float massHNM = heavyNeutralMeson.m(cfgHNMMassCorrection);
137+
if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kPCM) {
138+
mHistManager.fill(HIST("HeavyNeutralMeson/invMassVsPt_PCM"), massHNM, heavyNeutralMeson.pT());
139+
} else if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kEMC) {
140+
mHistManager.fill(HIST("HeavyNeutralMeson/invMassVsPt_EMC"), massHNM, heavyNeutralMeson.pT());
141+
} else {
142+
mHistManager.fill(HIST("HeavyNeutralMeson/invMassVsPt_PCMEMC"), massHNM, heavyNeutralMeson.pT());
143+
}
144+
145+
if (heavyNeutralMeson.gg->isPi0 && massHNM > massWindowOmega->get("omega_min") && massHNM < massWindowOmega->get("omega_max")) {
146+
if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kPCM)
147+
colContainsPCMOmega = true;
148+
else if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kEMC)
149+
colContainsEMCOmega = true;
150+
} else if (heavyNeutralMeson.gg->isEta && massHNM > massWindowEtaPrime->get("etaprime_min") && massHNM < massWindowEtaPrime->get("etaprime_max")) {
151+
if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kPCM)
152+
colContainsPCMEtaPrime = true;
153+
else if (heavyNeutralMeson.gg->reconstructionType == ReconstructionType::kEMC)
154+
colContainsEMCEtaPrime = true;
155+
} else {
156+
vHNMs.erase(vHNMs.begin() + iHNM);
157+
iHNM--;
257158
}
258159
}
160+
mHistManager.fill(HIST("Event/nHeavyNeutralMesons"), nHNMsBeforeMassCuts, vHNMs.size());
161+
162+
if (colContainsPCMOmega)
163+
mHistManager.fill(HIST("Event/hCollisionCounter"), 4.);
164+
if (colContainsEMCOmega)
165+
mHistManager.fill(HIST("Event/hCollisionCounter"), 5.);
166+
if (colContainsPCMEtaPrime)
167+
mHistManager.fill(HIST("Event/hCollisionCounter"), 6.);
168+
if (colContainsEMCEtaPrime)
169+
mHistManager.fill(HIST("Event/hCollisionCounter"), 7.);
259170
}
260171
};
261172

0 commit comments

Comments
 (0)