Skip to content

Commit 4156ca9

Browse files
abylinkinalibuild
abylinkin
and
alibuild
authored
[PWGUD] New Task for Inclusvie J/psi in SG events. (#6294)
* Add files via upload * Please consider the following formatting changes --------- Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
1 parent 61e1f0f commit 4156ca9

2 files changed

Lines changed: 307 additions & 0 deletions

File tree

‎PWGUD/Tasks/CMakeLists.txt‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,11 @@ o2physics_add_dpl_workflow(sg-pid-spectra
2424
PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::DetectorsBase
2525
COMPONENT_NAME Analysis)
2626

27+
o2physics_add_dpl_workflow(sg-incl-jpsi
28+
SOURCES sgInclJpsi.cxx
29+
PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::DetectorsBase
30+
COMPONENT_NAME Analysis)
31+
2732
o2physics_add_dpl_workflow(sg-excl-universe
2833
SOURCES sgExcUniverse.cxx
2934
PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::DetectorsBase

‎PWGUD/Tasks/sgInclJpsi.cxx‎

Lines changed: 302 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,302 @@
1+
// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2+
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3+
// All rights not expressly granted are reserved.
4+
//
5+
// This software is distributed under the terms of the GNU General Public
6+
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7+
//
8+
// In applying this license CERN does not waive the privileges and immunities
9+
// granted to it by virtue of its status as an Intergovernmental Organization
10+
// or submit itself to any jurisdiction.
11+
//
12+
// \Single Gap Event Analyzer
13+
// \author Sasha Bylinkin, alexander.bylinkin@gmail.com
14+
// \since April 2023
15+
16+
#include "Framework/runDataProcessing.h"
17+
#include "Framework/AnalysisTask.h"
18+
#include "Framework/AnalysisDataModel.h"
19+
#include "Framework/O2DatabasePDGPlugin.h"
20+
#include "iostream"
21+
#include "PWGUD/DataModel/UDTables.h"
22+
#include "PWGUD/Core/SGSelector.h"
23+
#include "Common/DataModel/PIDResponse.h"
24+
#include "PWGUD/Core/SGTrackSelector.h"
25+
#include <TString.h>
26+
#include "TLorentzVector.h"
27+
using namespace std;
28+
using namespace o2;
29+
using namespace o2::aod;
30+
using namespace o2::framework;
31+
using namespace o2::framework::expressions;
32+
struct SGInclJpsi {
33+
SGSelector sgSelector;
34+
Service<o2::framework::O2DatabasePDG> pdg;
35+
Configurable<float> FV0_cut{"FV0", 100., "FV0A threshold"};
36+
Configurable<float> FT0A_cut{"FT0A", 100., "FT0A threshold"};
37+
Configurable<float> FT0C_cut{"FT0C", 50., "FT0C threshold"};
38+
Configurable<float> FDDA_cut{"FDDA", 10000., "FDDA threshold"};
39+
Configurable<float> FDDC_cut{"FDDC", 10000., "FDDC threshold"};
40+
Configurable<float> ZDC_cut{"ZDC", 1., "ZDC threshold"};
41+
// Track Selections
42+
Configurable<float> PV_cut{"PV_cut", 1.0, "Use Only PV tracks"};
43+
Configurable<float> dcaZ_cut{"dcaZ_cut", 2.0, "dcaZ cut"};
44+
Configurable<float> dcaXY_cut{"dcaXY_cut", 0, "dcaXY cut (0 for Pt-function)"};
45+
Configurable<float> tpcChi2_cut{"tpcChi2_cut", 4, "Max tpcChi2NCl"};
46+
Configurable<float> tpcNClsFindable_cut{"tpcNClsFindable_cut", 70, "Min tpcNClsFindable"};
47+
Configurable<float> itsChi2_cut{"itsChi2_cut", 36, "Max itsChi2NCl"};
48+
Configurable<float> eta_cut{"eta_cut", 0.9, "Track Pseudorapidity"};
49+
Configurable<float> pt_cut{"pt_cut", 0.1, "Track Pt"};
50+
// D0 Specific Cuts
51+
HistogramRegistry registry{
52+
"registry",
53+
{
54+
55+
{"GapSide", "Gap Side; Entries", {HistType::kTH1F, {{4, -1.5, 2.5}}}},
56+
{"TrueGapSide", "Gap Side; Entries", {HistType::kTH1F, {{4, -1.5, 2.5}}}},
57+
{"Ntr", "Ntracks", {HistType::kTH1F, {{50, -.5, 49.5}}}},
58+
{"Ntr_0", "Ntracks", {HistType::kTH1F, {{50, -.5, 49.5}}}},
59+
{"Ntr_1", "Ntracks", {HistType::kTH1F, {{50, -.5, 49.5}}}},
60+
{"Ntr_2", "Ntracks", {HistType::kTH1F, {{50, -.5, 49.5}}}},
61+
{"Ntr_3", "Ntracks", {HistType::kTH1F, {{50, -.5, 49.5}}}},
62+
{"os_mm_pT", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
63+
{"os_mm_eTa", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
64+
{"os_mm_invm", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
65+
{"ss_mm_pT", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
66+
{"ss_mm_eTa", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
67+
{"ss_mm_invm", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
68+
{"os_mm_pT_0", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
69+
{"os_mm_eTa_0", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
70+
{"os_mm_invm_0", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
71+
{"ss_mm_pT_0", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
72+
{"ss_mm_eTa_0", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
73+
{"ss_mm_invm_0", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
74+
{"os_mm_pT_1", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
75+
{"os_mm_eTa_1", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
76+
{"os_mm_invm_1", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
77+
{"ss_mm_pT_1", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
78+
{"ss_mm_eTa_1", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
79+
{"ss_mm_invm_1", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
80+
{"os_mm_pT_2", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
81+
{"os_mm_eTa_2", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
82+
{"os_mm_invm_2", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
83+
{"ss_mm_pT_2", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
84+
{"ss_mm_eTa_2", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
85+
{"ss_mm_invm_2", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
86+
{"os_mm_pT_3", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
87+
{"os_mm_eTa_3", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
88+
{"os_mm_invm_3", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
89+
{"ss_mm_pT_3", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
90+
{"ss_mm_eTa_3", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
91+
{"ss_mm_invm_3", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
92+
{"os_Ntr_mm_invm_0", "N tracks vs #mu#mu Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
93+
{"os_Ntr_mm_invm_1", "N tracks vs #mu#mu Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
94+
{"os_Ntr_mm_invm_2", "N tracks vs #mu#mu Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
95+
{"os_Ntr_mm_invm_3", "N tracks vs #mu#mu Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
96+
{"os_ee_pT", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
97+
{"os_ee_eTa", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
98+
{"os_ee_invm", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
99+
{"ss_ee_pT", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
100+
{"ss_ee_eTa", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
101+
{"ss_ee_invm", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
102+
{"os_ee_pT_0", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
103+
{"os_ee_eTa_0", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
104+
{"os_ee_invm_0", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
105+
{"ss_ee_pT_0", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
106+
{"ss_ee_eTa_0", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
107+
{"ss_ee_invm_0", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
108+
{"os_ee_pT_1", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
109+
{"os_ee_eTa_1", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
110+
{"os_ee_invm_1", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
111+
{"ss_ee_pT_1", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
112+
{"ss_ee_eTa_1", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
113+
{"ss_ee_invm_1", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
114+
{"os_ee_pT_2", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
115+
{"os_ee_eTa_2", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
116+
{"os_ee_invm_2", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
117+
{"ss_ee_pT_2", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
118+
{"ss_ee_eTa_2", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
119+
{"ss_ee_invm_2", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
120+
{"os_ee_pT_3", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
121+
{"os_ee_eTa_3", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
122+
{"os_ee_invm_3", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
123+
{"ss_ee_pT_3", "pT (GeV/c); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
124+
{"ss_ee_eTa_3", "eTa (GeV/c); Entries", {HistType::kTH1F, {{100, -1., 1.}}}},
125+
{"ss_ee_invm_3", "Mass (GeV/c^2); Entries", {HistType::kTH1F, {{5000, 0, 10}}}},
126+
{"os_ee_pt_invm_0", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
127+
{"os_ee_pt_invm_1", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
128+
{"os_ee_pt_invm_2", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
129+
{"os_ee_pt_invm_3", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
130+
{"os_mm_pt_invm_0", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
131+
{"os_mm_pt_invm_1", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
132+
{"os_mm_pt_invm_2", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
133+
{"os_mm_pt_invm_3", "N tracks vs ee Mass", {HistType::kTH2F, {{500, 0, 10}, {600, 2., 5.}}}},
134+
{"os_Ntr_ee_invm_0", "N tracks vs ee Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
135+
{"os_Ntr_ee_invm_1", "N tracks vs ee Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
136+
{"os_Ntr_ee_invm_2", "N tracks vs ee Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
137+
{"os_Ntr_ee_invm_3", "N tracks vs ee Mass", {HistType::kTH2F, {{48, 1.5, 49.5}, {600, 2., 5.}}}},
138+
}};
139+
using udtracks = soa::Join<aod::UDTracks, aod::UDTracksExtra, aod::UDTracksPID>;
140+
using udtracksfull = soa::Join<aod::UDTracks, aod::UDTracksPID, aod::UDTracksExtra, aod::UDTracksFlags, aod::UDTracksDCA>;
141+
using UDCollisionsFull = soa::Join<aod::UDCollisions, aod::SGCollisions, aod::UDCollisionsSels, aod::UDZdcsReduced>; //
142+
using UDCollisionFull = UDCollisionsFull::iterator;
143+
144+
void process(UDCollisionFull const& collision, udtracksfull const& tracks)
145+
{
146+
TLorentzVector a;
147+
int gapSide = collision.gapSide();
148+
if (gapSide < 0 || gapSide > 2)
149+
return;
150+
// Single gap either side
151+
TLorentzVector v0;
152+
TLorentzVector v1;
153+
TLorentzVector v01;
154+
// int truegapSide = sgSelector.trueGap(collision);
155+
// int truegapSide = sgSelector.trueGap(collision, FV0_cut, ZDC_cut);
156+
float FIT_cut[5] = {FV0_cut, FT0A_cut, FT0C_cut, FDDA_cut, FDDC_cut};
157+
std::vector<float> parameters = {PV_cut, dcaZ_cut, dcaXY_cut, tpcChi2_cut, tpcNClsFindable_cut, itsChi2_cut, eta_cut, pt_cut};
158+
// int truegapSide = sgSelector.trueGap(collision, *FIT_cut, ZDC_cut);
159+
int truegapSide = sgSelector.trueGap(collision, FIT_cut[0], FIT_cut[1], FIT_cut[2], ZDC_cut);
160+
registry.fill(HIST("GapSide"), gapSide);
161+
registry.fill(HIST("TrueGapSide"), truegapSide);
162+
gapSide = truegapSide;
163+
int pvtracks = 0;
164+
for (auto& t0 : tracks) {
165+
if (trackselector(t0, parameters) && t0.isPVContributor())
166+
pvtracks++;
167+
}
168+
registry.fill(HIST("Ntr"), pvtracks);
169+
if (gapSide == 0)
170+
registry.fill(HIST("Ntr_0"), pvtracks);
171+
if (gapSide == 1)
172+
registry.fill(HIST("Ntr_1"), pvtracks);
173+
if (gapSide == 2)
174+
registry.fill(HIST("Ntr_2"), pvtracks);
175+
if (gapSide == -1)
176+
registry.fill(HIST("Ntr_3"), pvtracks);
177+
// Look for D0 and D0bar
178+
for (auto& [t0, t1] : combinations(tracks, tracks)) {
179+
// PID cut - t0=K, t1=pi
180+
if (!trackselector(t0, parameters) || !trackselector(t1, parameters))
181+
continue;
182+
if (std::abs(t0.tpcNSigmaMu()) < 3 && std::abs(t1.tpcNSigmaMu()) < 3) {
183+
// Apply pion hypothesis and create pairs
184+
v0.SetXYZM(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassMuon);
185+
v1.SetXYZM(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassMuon);
186+
v01 = v0 + v1;
187+
// Opposite sign pairs
188+
if (t0.sign() != t1.sign()) {
189+
registry.fill(HIST("os_mm_pT"), v01.Pt());
190+
registry.fill(HIST("os_mm_eTa"), v01.Eta());
191+
registry.fill(HIST("os_mm_invm"), v01.M());
192+
if (gapSide == 0) {
193+
registry.fill(HIST("os_mm_pT_0"), v01.Pt());
194+
registry.fill(HIST("os_mm_eTa_0"), v01.Eta());
195+
registry.fill(HIST("os_mm_invm_0"), v01.M());
196+
registry.fill(HIST("os_Ntr_mm_invm_0"), tracks.size(), v01.M());
197+
registry.fill(HIST("os_mm_pt_invm_0"), v01.Pt(), v01.M());
198+
} else if (gapSide == 1) {
199+
registry.fill(HIST("os_mm_pT_1"), v01.Pt());
200+
registry.fill(HIST("os_mm_eTa_1"), v01.Eta());
201+
registry.fill(HIST("os_mm_invm_1"), v01.M());
202+
registry.fill(HIST("os_Ntr_mm_invm_1"), tracks.size(), v01.M());
203+
registry.fill(HIST("os_mm_pt_invm_1"), v01.Pt(), v01.M());
204+
} else if (gapSide == 2) {
205+
registry.fill(HIST("os_mm_pT_2"), v01.Pt());
206+
registry.fill(HIST("os_mm_eTa_2"), v01.Eta());
207+
registry.fill(HIST("os_mm_invm_2"), v01.M());
208+
registry.fill(HIST("os_Ntr_mm_invm_2"), tracks.size(), v01.M());
209+
registry.fill(HIST("os_mm_pt_invm_2"), v01.Pt(), v01.M());
210+
} else {
211+
registry.fill(HIST("os_mm_pT_3"), v01.Pt());
212+
registry.fill(HIST("os_mm_eTa_3"), v01.Eta());
213+
registry.fill(HIST("os_mm_invm_3"), v01.M());
214+
registry.fill(HIST("os_Ntr_mm_invm_3"), tracks.size(), v01.M());
215+
registry.fill(HIST("os_mm_pt_invm_3"), v01.Pt(), v01.M());
216+
}
217+
} else if (t0.sign() == t1.sign()) {
218+
registry.fill(HIST("ss_mm_pT"), v01.Pt());
219+
registry.fill(HIST("ss_mm_eTa"), v01.Eta());
220+
registry.fill(HIST("ss_mm_invm"), v01.M());
221+
if (gapSide == 0) {
222+
registry.fill(HIST("ss_mm_pT_0"), v01.Pt());
223+
registry.fill(HIST("ss_mm_eTa_0"), v01.Eta());
224+
registry.fill(HIST("ss_mm_invm_0"), v01.M());
225+
}
226+
if (gapSide == 1) {
227+
registry.fill(HIST("ss_mm_pT_1"), v01.Pt());
228+
registry.fill(HIST("ss_mm_eTa_1"), v01.Eta());
229+
registry.fill(HIST("ss_mm_invm_1"), v01.M());
230+
}
231+
if (gapSide == 2) {
232+
registry.fill(HIST("ss_mm_pT_2"), v01.Pt());
233+
registry.fill(HIST("ss_mm_eTa_2"), v01.Eta());
234+
registry.fill(HIST("ss_mm_invm_2"), v01.M());
235+
}
236+
}
237+
}
238+
if (std::abs(t0.tpcNSigmaEl()) < 3 && std::abs(t1.tpcNSigmaEl()) < 3) {
239+
// Apply pion hypothesis and create pairs
240+
v0.SetXYZM(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassElectron);
241+
v1.SetXYZM(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassElectron);
242+
v01 = v0 + v1;
243+
// Opposite sign pairs
244+
if (t0.sign() != t1.sign()) {
245+
registry.fill(HIST("os_ee_pT"), v01.Pt());
246+
registry.fill(HIST("os_ee_eTa"), v01.Eta());
247+
registry.fill(HIST("os_ee_invm"), v01.M());
248+
if (gapSide == 0) {
249+
registry.fill(HIST("os_ee_pT_0"), v01.Pt());
250+
registry.fill(HIST("os_ee_eTa_0"), v01.Eta());
251+
registry.fill(HIST("os_ee_invm_0"), v01.M());
252+
registry.fill(HIST("os_Ntr_ee_invm_0"), tracks.size(), v01.M());
253+
registry.fill(HIST("os_ee_pt_invm_0"), v01.Pt(), v01.M());
254+
} else if (gapSide == 1) {
255+
registry.fill(HIST("os_ee_pT_1"), v01.Pt());
256+
registry.fill(HIST("os_ee_eTa_1"), v01.Eta());
257+
registry.fill(HIST("os_ee_invm_1"), v01.M());
258+
registry.fill(HIST("os_Ntr_ee_invm_1"), tracks.size(), v01.M());
259+
registry.fill(HIST("os_ee_pt_invm_1"), v01.Pt(), v01.M());
260+
} else if (gapSide == 2) {
261+
registry.fill(HIST("os_ee_pT_2"), v01.Pt());
262+
registry.fill(HIST("os_ee_eTa_2"), v01.Eta());
263+
registry.fill(HIST("os_ee_invm_2"), v01.M());
264+
registry.fill(HIST("os_Ntr_ee_invm_2"), tracks.size(), v01.M());
265+
registry.fill(HIST("os_ee_pt_invm_2"), v01.Pt(), v01.M());
266+
} else {
267+
registry.fill(HIST("os_ee_pT_3"), v01.Pt());
268+
registry.fill(HIST("os_ee_eTa_3"), v01.Eta());
269+
registry.fill(HIST("os_ee_invm_3"), v01.M());
270+
registry.fill(HIST("os_Ntr_ee_invm_3"), tracks.size(), v01.M());
271+
registry.fill(HIST("os_ee_pt_invm_3"), v01.Pt(), v01.M());
272+
}
273+
} else if (t0.sign() == t1.sign()) {
274+
registry.fill(HIST("ss_ee_pT"), v01.Pt());
275+
registry.fill(HIST("ss_ee_eTa"), v01.Eta());
276+
registry.fill(HIST("ss_ee_invm"), v01.M());
277+
if (gapSide == 0) {
278+
registry.fill(HIST("ss_ee_pT_0"), v01.Pt());
279+
registry.fill(HIST("ss_ee_eTa_0"), v01.Eta());
280+
registry.fill(HIST("ss_ee_invm_0"), v01.M());
281+
}
282+
if (gapSide == 1) {
283+
registry.fill(HIST("ss_ee_pT_1"), v01.Pt());
284+
registry.fill(HIST("ss_ee_eTa_1"), v01.Eta());
285+
registry.fill(HIST("ss_ee_invm_1"), v01.M());
286+
}
287+
if (gapSide == 2) {
288+
registry.fill(HIST("ss_ee_pT_2"), v01.Pt());
289+
registry.fill(HIST("ss_ee_eTa_2"), v01.Eta());
290+
registry.fill(HIST("ss_ee_invm_2"), v01.M());
291+
}
292+
}
293+
}
294+
}
295+
}
296+
};
297+
298+
WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
299+
{
300+
return WorkflowSpec{
301+
adaptAnalysisTask<SGInclJpsi>(cfgc)};
302+
}

0 commit comments

Comments
 (0)