Skip to content

Commit 0fd05e4

Browse files
ddobrigkddobrigk
authored
Cascades, V0 finder, more stuff to LF folder (#4366)
1 parent 76b67ea commit 0fd05e4

File tree

8 files changed

+720
-18
lines changed

8 files changed

+720
-18
lines changed

‎Analysis/DataModel/include/Analysis/StrangenessTables.h‎

Lines changed: 115 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,10 @@ DECLARE_SOA_DYNAMIC_COLUMN(V0CosPA, v0cosPA, [](float X, float Y, float Z, float
4747
DECLARE_SOA_DYNAMIC_COLUMN(MLambda, mLambda, [](float pxpos, float pypos, float pzpos, float pxneg, float pyneg, float pzneg) { return RecoDecay::M(array{array{pxpos, pypos, pzpos}, array{pxneg, pyneg, pzneg}}, array{RecoDecay::getMassPDG(kProton), RecoDecay::getMassPDG(kPiPlus)}); });
4848
DECLARE_SOA_DYNAMIC_COLUMN(MAntiLambda, mAntiLambda, [](float pxpos, float pypos, float pzpos, float pxneg, float pyneg, float pzneg) { return RecoDecay::M(array{array{pxpos, pypos, pzpos}, array{pxneg, pyneg, pzneg}}, array{RecoDecay::getMassPDG(kPiPlus), RecoDecay::getMassPDG(kProton)}); });
4949
DECLARE_SOA_DYNAMIC_COLUMN(MK0Short, mK0Short, [](float pxpos, float pypos, float pzpos, float pxneg, float pyneg, float pzneg) { return RecoDecay::M(array{array{pxpos, pypos, pzpos}, array{pxneg, pyneg, pzneg}}, array{RecoDecay::getMassPDG(kPiPlus), RecoDecay::getMassPDG(kPiPlus)}); });
50+
51+
DECLARE_SOA_DYNAMIC_COLUMN(YK0Short, yK0Short, [](float Px, float Py, float Pz) { return RecoDecay::Y(array{Px, Py, Pz}, RecoDecay::getMassPDG(kK0)); });
52+
DECLARE_SOA_DYNAMIC_COLUMN(YLambda, yLambda, [](float Px, float Py, float Pz) { return RecoDecay::Y(array{Px, Py, Pz}, RecoDecay::getMassPDG(kLambda0)); });
53+
DECLARE_SOA_DYNAMIC_COLUMN(Eta, eta, [](float Px, float Py, float Pz) { return RecoDecay::Eta(array{Px, Py, Pz}); });
5054
} // namespace v0data
5155

5256
namespace v0dataext
@@ -70,7 +74,12 @@ DECLARE_SOA_TABLE(V0Data, "AOD", "V0DATA",
7074
//Invariant masses
7175
v0data::MLambda<v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg>,
7276
v0data::MAntiLambda<v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg>,
73-
v0data::MK0Short<v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg>);
77+
v0data::MK0Short<v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg>,
78+
79+
//Longitudinal
80+
v0data::YK0Short<v0dataext::Px, v0dataext::Py, v0dataext::Pz>,
81+
v0data::YLambda<v0dataext::Px, v0dataext::Py, v0dataext::Pz>,
82+
v0data::Eta<v0dataext::Px, v0dataext::Py, v0dataext::Pz>);
7483

7584
using V0DataOrigin = V0Data;
7685

@@ -80,6 +89,111 @@ DECLARE_SOA_EXTENDED_TABLE_USER(V0DataExt, V0DataOrigin, "V0DATAEXT",
8089

8190
using V0DataFull = V0DataExt;
8291

92+
namespace v0finderdata
93+
{
94+
DECLARE_SOA_INDEX_COLUMN(Collision, collision);
95+
}
96+
DECLARE_SOA_TABLE(V0FinderData, "AOD", "V0FINDERDATA", o2::soa::Index<>, v0finderdata::CollisionId);
97+
98+
namespace cascdata
99+
{
100+
//General V0 properties: position, momentum
101+
DECLARE_SOA_COLUMN(Charge, charge, int);
102+
DECLARE_SOA_COLUMN(PxPos, pxpos, float);
103+
DECLARE_SOA_COLUMN(PyPos, pypos, float);
104+
DECLARE_SOA_COLUMN(PzPos, pzpos, float);
105+
DECLARE_SOA_COLUMN(PxNeg, pxneg, float);
106+
DECLARE_SOA_COLUMN(PyNeg, pyneg, float);
107+
DECLARE_SOA_COLUMN(PzNeg, pzneg, float);
108+
DECLARE_SOA_COLUMN(PxBach, pxbach, float);
109+
DECLARE_SOA_COLUMN(PyBach, pybach, float);
110+
DECLARE_SOA_COLUMN(PzBach, pzbach, float);
111+
DECLARE_SOA_COLUMN(X, x, float);
112+
DECLARE_SOA_COLUMN(Y, y, float);
113+
DECLARE_SOA_COLUMN(Z, z, float);
114+
DECLARE_SOA_COLUMN(Xlambda, xlambda, float);
115+
DECLARE_SOA_COLUMN(Ylambda, ylambda, float);
116+
DECLARE_SOA_COLUMN(Zlambda, zlambda, float);
117+
118+
//Saved from finding: DCAs
119+
DECLARE_SOA_COLUMN(DCAV0Daughters, dcaV0daughters, float);
120+
DECLARE_SOA_COLUMN(DCACascDaughters, dcacascdaughters, float);
121+
DECLARE_SOA_COLUMN(DCAPosToPV, dcapostopv, float);
122+
DECLARE_SOA_COLUMN(DCANegToPV, dcanegtopv, float);
123+
DECLARE_SOA_COLUMN(DCABachToPV, dcabachtopv, float);
124+
125+
//Derived expressions
126+
//Momenta
127+
DECLARE_SOA_DYNAMIC_COLUMN(Pt, pt, [](float Px, float Py) { return RecoDecay::sqrtSumOfSquares(Px, Py); });
128+
129+
//Length quantities
130+
DECLARE_SOA_DYNAMIC_COLUMN(V0Radius, v0radius, [](float xlambda, float ylambda) { return RecoDecay::sqrtSumOfSquares(xlambda, ylambda); });
131+
DECLARE_SOA_DYNAMIC_COLUMN(CascRadius, cascradius, [](float x, float y) { return RecoDecay::sqrtSumOfSquares(x, y); });
132+
133+
//CosPAs
134+
DECLARE_SOA_DYNAMIC_COLUMN(V0CosPA, v0cosPA, [](float Xlambda, float Ylambda, float Zlambda, float PxLambda, float PyLambda, float PzLambda, float pvX, float pvY, float pvZ) { return RecoDecay::CPA(array{pvX, pvY, pvZ}, array{Xlambda, Ylambda, Zlambda}, array{PxLambda, PyLambda, PzLambda}); });
135+
DECLARE_SOA_DYNAMIC_COLUMN(CascCosPA, casccosPA, [](float X, float Y, float Z, float Px, float Py, float Pz, float pvX, float pvY, float pvZ) { return RecoDecay::CPA(array{pvX, pvY, pvZ}, array{X, Y, Z}, array{Px, Py, Pz}); });
136+
DECLARE_SOA_DYNAMIC_COLUMN(DCAV0ToPV, dcav0topv, [](float X, float Y, float Z, float Px, float Py, float Pz, float pvX, float pvY, float pvZ) { return TMath::Sqrt((TMath::Power((pvY - Y) * Pz - (pvZ - Z) * Py, 2) + TMath::Power((pvX - X) * Pz - (pvZ - Z) * Px, 2) + TMath::Power((pvX - X) * Py - (pvY - Y) * Px, 2)) / (Px * Px + Py * Py + Pz * Pz)); });
137+
DECLARE_SOA_DYNAMIC_COLUMN(DCACascToPV, dcacasctopv, [](float X, float Y, float Z, float Px, float Py, float Pz, float pvX, float pvY, float pvZ) { return TMath::Sqrt((TMath::Power((pvY - Y) * Pz - (pvZ - Z) * Py, 2) + TMath::Power((pvX - X) * Pz - (pvZ - Z) * Px, 2) + TMath::Power((pvX - X) * Py - (pvY - Y) * Px, 2)) / (Px * Px + Py * Py + Pz * Pz)); });
138+
139+
//Calculated on the fly with mass assumption + dynamic tables
140+
DECLARE_SOA_DYNAMIC_COLUMN(MLambda, mLambda, [](int charge, float pxpos, float pypos, float pzpos, float pxneg, float pyneg, float pzneg) { return RecoDecay::M(array{array{pxpos, pypos, pzpos}, array{pxneg, pyneg, pzneg}}, charge < 0 ? array{RecoDecay::getMassPDG(kProton), RecoDecay::getMassPDG(kPiPlus)} : array{RecoDecay::getMassPDG(kPiPlus), RecoDecay::getMassPDG(kProton)}); });
141+
//Calculated on the fly with mass assumption + dynamic tables
142+
143+
DECLARE_SOA_DYNAMIC_COLUMN(MXi, mXi, [](float pxbach, float pybach, float pzbach, float PxLambda, float PyLambda, float PzLambda) { return RecoDecay::M(array{array{pxbach, pybach, pzbach}, array{PxLambda, PyLambda, PzLambda}}, array{RecoDecay::getMassPDG(kPiPlus), RecoDecay::getMassPDG(kLambda0)}); });
144+
DECLARE_SOA_DYNAMIC_COLUMN(MOmega, mOmega, [](float pxbach, float pybach, float pzbach, float PxLambda, float PyLambda, float PzLambda) { return RecoDecay::M(array{array{pxbach, pybach, pzbach}, array{PxLambda, PyLambda, PzLambda}}, array{RecoDecay::getMassPDG(kKPlus), RecoDecay::getMassPDG(kLambda0)}); });
145+
146+
DECLARE_SOA_DYNAMIC_COLUMN(YXi, yXi, [](float Px, float Py, float Pz) { return RecoDecay::Y(array{Px, Py, Pz}, 1.32171); });
147+
DECLARE_SOA_DYNAMIC_COLUMN(YOmega, yOmega, [](float Px, float Py, float Pz) { return RecoDecay::Y(array{Px, Py, Pz}, 1.67245); });
148+
DECLARE_SOA_DYNAMIC_COLUMN(Eta, eta, [](float Px, float Py, float Pz) { return RecoDecay::Eta(array{Px, Py, Pz}); });
149+
} // namespace cascdata
150+
151+
namespace cascdataext
152+
{
153+
DECLARE_SOA_EXPRESSION_COLUMN(PxLambda, pxlambda, float, 1.f * aod::cascdata::pxpos + 1.f * aod::cascdata::pxneg);
154+
DECLARE_SOA_EXPRESSION_COLUMN(PyLambda, pylambda, float, 1.f * aod::cascdata::pypos + 1.f * aod::cascdata::pyneg);
155+
DECLARE_SOA_EXPRESSION_COLUMN(PzLambda, pzlambda, float, 1.f * aod::cascdata::pzpos + 1.f * aod::cascdata::pzneg);
156+
DECLARE_SOA_EXPRESSION_COLUMN(Px, px, float, 1.f * aod::cascdata::pxpos + 1.f * aod::cascdata::pxneg + 1.f * aod::cascdata::pxbach);
157+
DECLARE_SOA_EXPRESSION_COLUMN(Py, py, float, 1.f * aod::cascdata::pypos + 1.f * aod::cascdata::pyneg + 1.f * aod::cascdata::pybach);
158+
DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::cascdata::pzpos + 1.f * aod::cascdata::pzneg + 1.f * aod::cascdata::pzbach);
159+
} // namespace cascdataext
160+
161+
DECLARE_SOA_TABLE(CascData, "AOD", "CASCDATA",
162+
cascdata::Charge,
163+
cascdata::X, cascdata::Y, cascdata::Z,
164+
cascdata::Xlambda, cascdata::Ylambda, cascdata::Zlambda,
165+
cascdata::PxPos, cascdata::PyPos, cascdata::PzPos,
166+
cascdata::PxNeg, cascdata::PyNeg, cascdata::PzNeg,
167+
cascdata::PxBach, cascdata::PyBach, cascdata::PzBach,
168+
cascdata::DCAV0Daughters, cascdata::DCACascDaughters,
169+
cascdata::DCAPosToPV, cascdata::DCANegToPV, cascdata::DCABachToPV,
170+
171+
//Dynamic columns
172+
cascdata::Pt<cascdataext::Px, cascdataext::Py>,
173+
cascdata::V0Radius<cascdata::Xlambda, cascdata::Ylambda>,
174+
cascdata::CascRadius<cascdata::X, cascdata::Y>,
175+
cascdata::V0CosPA<cascdata::Xlambda, cascdata::Ylambda, cascdata::Zlambda, cascdataext::PxLambda, cascdataext::PyLambda, cascdataext::PzLambda>,
176+
cascdata::CascCosPA<cascdata::X, cascdata::Y, cascdata::Z, cascdataext::Px, cascdataext::Py, cascdataext::Pz>,
177+
cascdata::DCAV0ToPV<cascdata::Xlambda, cascdata::Ylambda, cascdata::Zlambda, cascdataext::PxLambda, cascdataext::PyLambda, cascdataext::PzLambda>,
178+
cascdata::DCACascToPV<cascdata::X, cascdata::Y, cascdata::Z, cascdataext::Px, cascdataext::Py, cascdataext::Pz>,
179+
180+
//Invariant masses
181+
cascdata::MLambda<cascdata::Charge, cascdata::PxPos, cascdata::PyPos, cascdata::PzPos, cascdata::PxNeg, cascdata::PyNeg, cascdata::PzNeg>,
182+
cascdata::MXi<cascdata::PxBach, cascdata::PyBach, cascdata::PzBach, cascdataext::PxLambda, cascdataext::PyLambda, cascdataext::PzLambda>,
183+
cascdata::MOmega<cascdata::PxBach, cascdata::PyBach, cascdata::PzBach, cascdataext::PxLambda, cascdataext::PyLambda, cascdataext::PzLambda>,
184+
//Longitudinal
185+
cascdata::YXi<cascdataext::Px, cascdataext::Py, cascdataext::Pz>,
186+
cascdata::YOmega<cascdataext::Px, cascdataext::Py, cascdataext::Pz>,
187+
cascdata::Eta<cascdataext::Px, cascdataext::Py, cascdataext::Pz>);
188+
189+
using CascDataOrigin = CascData;
190+
191+
// extended table with expression columns that can be used as arguments of dynamic columns
192+
DECLARE_SOA_EXTENDED_TABLE_USER(CascDataExt, CascDataOrigin, "CascDATAEXT",
193+
cascdataext::PxLambda, cascdataext::PyLambda, cascdataext::PzLambda,
194+
cascdataext::Px, cascdataext::Py, cascdataext::Pz);
195+
196+
using CascDataFull = CascDataExt;
83197
} // namespace o2::aod
84198

85199
#endif // O2_ANALYSIS_STRANGENESSTABLES_H_

‎Analysis/Tasks/CMakeLists.txt‎

Lines changed: 0 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -109,14 +109,4 @@ o2_add_dpl_workflow(run2-matcher
109109
o2_add_dpl_workflow(run3-matcher
110110
SOURCES run3Matcher.cxx
111111
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel
112-
COMPONENT_NAME Analysis)
113-
114-
o2_add_dpl_workflow(lambdakzeroproducer
115-
SOURCES lambdakzeroproducer
116-
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
117-
COMPONENT_NAME Analysis)
118-
119-
o2_add_dpl_workflow(lambdakzeroconsumer
120-
SOURCES lambdakzeroconsumer
121-
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
122112
COMPONENT_NAME Analysis)

‎Analysis/Tasks/PWGLF/CMakeLists.txt‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,3 +12,28 @@ o2_add_dpl_workflow(nuclei-spectra
1212
SOURCES NucleiSpectraTask.cxx
1313
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel
1414
COMPONENT_NAME Analysis)
15+
16+
o2_add_dpl_workflow(lambdakzeroproducer
17+
SOURCES lambdakzeroproducer
18+
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
19+
COMPONENT_NAME Analysis)
20+
21+
o2_add_dpl_workflow(lambdakzeroconsumer
22+
SOURCES lambdakzeroconsumer
23+
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
24+
COMPONENT_NAME Analysis)
25+
26+
o2_add_dpl_workflow(lambdakzerofinder
27+
SOURCES lambdakzerofinder
28+
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
29+
COMPONENT_NAME Analysis)
30+
31+
o2_add_dpl_workflow(cascadeproducer
32+
SOURCES cascadeproducer
33+
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
34+
COMPONENT_NAME Analysis)
35+
36+
o2_add_dpl_workflow(cascadeconsumer
37+
SOURCES cascadeconsumer
38+
PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing
39+
COMPONENT_NAME Analysis)

‎Analysis/Tasks/PWGLF/cascadeconsumer.cxx‎

Lines changed: 151 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,151 @@
1+
// Copyright CERN and copyright holders of ALICE O2. This software is
2+
// distributed under the terms of the GNU General Public License v3 (GPL
3+
// Version 3), copied verbatim in the file "COPYING".
4+
//
5+
// See http://alice-o2.web.cern.ch/license for full licensing information.
6+
//
7+
// In applying this license CERN does not waive the privileges and immunities
8+
// granted to it by virtue of its status as an Intergovernmental Organization
9+
// or submit itself to any jurisdiction.
10+
#include "Framework/runDataProcessing.h"
11+
#include "Framework/AnalysisTask.h"
12+
#include "Framework/AnalysisDataModel.h"
13+
#include "Framework/ASoAHelpers.h"
14+
#include "ReconstructionDataFormats/Track.h"
15+
#include "Analysis/RecoDecay.h"
16+
#include "Analysis/trackUtilities.h"
17+
#include "Analysis/StrangenessTables.h"
18+
#include "Analysis/TrackSelection.h"
19+
#include "Analysis/TrackSelectionTables.h"
20+
#include "Analysis/EventSelection.h"
21+
#include "Analysis/Centrality.h"
22+
23+
#include <TFile.h>
24+
#include <TH2F.h>
25+
#include <TProfile.h>
26+
#include <TLorentzVector.h>
27+
#include <Math/Vector4D.h>
28+
#include <TPDGCode.h>
29+
#include <TDatabasePDG.h>
30+
#include <cmath>
31+
#include <array>
32+
#include <cstdlib>
33+
#include "PID/PIDResponse.h"
34+
#include "Framework/ASoAHelpers.h"
35+
36+
using namespace o2;
37+
using namespace o2::framework;
38+
using namespace o2::framework::expressions;
39+
using std::array;
40+
41+
struct cascadeQA {
42+
//Basic checks
43+
OutputObj<TH1F> hMassXiMinus{TH1F("hMassXiMinus", "", 3000, 0.0, 3.0)};
44+
OutputObj<TH1F> hMassXiPlus{TH1F("hMassXiPlus", "", 3000, 0.0, 3.0)};
45+
OutputObj<TH1F> hMassOmegaMinus{TH1F("hMassOmegaMinus", "", 3000, 0.0, 3.0)};
46+
OutputObj<TH1F> hMassOmegaPlus{TH1F("hMassOmegaPlus", "", 3000, 0.0, 3.0)};
47+
48+
OutputObj<TH1F> hV0Radius{TH1F("hV0Radius", "", 1000, 0.0, 100)};
49+
OutputObj<TH1F> hCascRadius{TH1F("hCascRadius", "", 1000, 0.0, 100)};
50+
OutputObj<TH1F> hV0CosPA{TH1F("hV0CosPA", "", 1000, 0.95, 1.0)};
51+
OutputObj<TH1F> hCascCosPA{TH1F("hCascCosPA", "", 1000, 0.95, 1.0)};
52+
OutputObj<TH1F> hDCAPosToPV{TH1F("hDCAPosToPV", "", 1000, 0.0, 10.0)};
53+
OutputObj<TH1F> hDCANegToPV{TH1F("hDCANegToPV", "", 1000, 0.0, 10.0)};
54+
OutputObj<TH1F> hDCABachToPV{TH1F("hDCABachToPV", "", 1000, 0.0, 10.0)};
55+
OutputObj<TH1F> hDCAV0ToPV{TH1F("hDCAV0ToPV", "", 1000, 0.0, 10.0)};
56+
OutputObj<TH1F> hDCAV0Dau{TH1F("hDCAV0Dau", "", 1000, 0.0, 10.0)};
57+
OutputObj<TH1F> hDCACascDau{TH1F("hDCACascDau", "", 1000, 0.0, 10.0)};
58+
OutputObj<TH1F> hLambdaMass{TH1F("hLambdaMass", "", 1000, 0.0, 10.0)};
59+
60+
void process(aod::Collision const& collision, soa::Join<aod::Cascades, aod::CascDataExt> const& Cascades)
61+
{
62+
for (auto& casc : Cascades) {
63+
if (casc.charge() < 0) { //FIXME: could be done better...
64+
hMassXiMinus->Fill(casc.mXi());
65+
hMassOmegaMinus->Fill(casc.mOmega());
66+
} else {
67+
hMassXiPlus->Fill(casc.mXi());
68+
hMassOmegaPlus->Fill(casc.mOmega());
69+
}
70+
//The basic eleven!
71+
hV0Radius->Fill(casc.v0radius());
72+
hCascRadius->Fill(casc.cascradius());
73+
hV0CosPA->Fill(casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()));
74+
hCascCosPA->Fill(casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()));
75+
hDCAPosToPV->Fill(casc.dcapostopv());
76+
hDCANegToPV->Fill(casc.dcanegtopv());
77+
hDCABachToPV->Fill(casc.dcabachtopv());
78+
hDCAV0ToPV->Fill(casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()));
79+
hDCAV0Dau->Fill(casc.dcaV0daughters());
80+
hDCACascDau->Fill(casc.dcacascdaughters());
81+
hLambdaMass->Fill(casc.mLambda());
82+
}
83+
}
84+
};
85+
86+
struct cascadeconsumer {
87+
OutputObj<TH3F> h3dMassXiMinus{TH3F("h3dMassXiMinus", "", 20, 0, 100, 200, 0, 10, 200, 1.322 - 0.100, 1.322 + 0.100)};
88+
OutputObj<TH3F> h3dMassXiPlus{TH3F("h3dMassXiPlus", "", 20, 0, 100, 200, 0, 10, 200, 1.322 - 0.100, 1.322 + 0.100)};
89+
OutputObj<TH3F> h3dMassOmegaMinus{TH3F("h3dMassOmegaMinus", "", 20, 0, 100, 200, 0, 10, 200, 1.672 - 0.100, 1.672 + 0.100)};
90+
OutputObj<TH3F> h3dMassOmegaPlus{TH3F("h3dMassOmegaPlus", "", 20, 0, 100, 200, 0, 10, 200, 1.672 - 0.100, 1.672 + 0.100)};
91+
92+
//Selection criteria
93+
Configurable<double> v0cospa{"v0cospa", 0.999, "V0 CosPA"}; //double -> N.B. dcos(x)/dx = 0 at x=0)
94+
Configurable<double> casccospa{"casccospa", 0.999, "Casc CosPA"}; //double -> N.B. dcos(x)/dx = 0 at x=0)
95+
Configurable<float> dcav0dau{"dcav0dau", 1.0, "DCA V0 Daughters"};
96+
Configurable<float> dcacascdau{"dcacascdau", .3, "DCA Casc Daughters"};
97+
Configurable<float> dcanegtopv{"dcanegtopv", .1, "DCA Neg To PV"};
98+
Configurable<float> dcapostopv{"dcapostopv", .1, "DCA Pos To PV"};
99+
Configurable<float> dcabachtopv{"dcabachtopv", .1, "DCA Bach To PV"};
100+
Configurable<float> dcav0topv{"dcav0topv", .1, "DCA V0 To PV"};
101+
Configurable<float> v0radius{"v0radius", 2.0, "v0radius"};
102+
Configurable<float> cascradius{"cascradius", 1.0, "cascradius"};
103+
Configurable<float> v0masswindow{"v0masswindow", 0.008, "v0masswindow"};
104+
105+
Filter preFilterV0 =
106+
aod::cascdata::dcapostopv > dcapostopv&& aod::cascdata::dcanegtopv > dcanegtopv&&
107+
aod::cascdata::dcabachtopv > dcabachtopv&&
108+
aod::cascdata::dcaV0daughters < dcav0dau&& aod::cascdata::dcacascdaughters < dcacascdau;
109+
110+
void process(soa::Join<aod::Collisions, aod::EvSels, aod::Cents>::iterator const& collision, soa::Filtered<soa::Join<aod::Cascades, aod::CascDataExt>> const& Cascades)
111+
{
112+
if (!collision.alias()[kINT7])
113+
return;
114+
if (!collision.sel7())
115+
return;
116+
for (auto& casc : Cascades) {
117+
//FIXME: dynamic columns cannot be filtered on?
118+
if (casc.v0radius() > v0radius &&
119+
casc.cascradius() > cascradius &&
120+
casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) > v0cospa &&
121+
casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) > casccospa &&
122+
casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) > dcav0topv) {
123+
if (casc.charge() < 0) { //FIXME: could be done better...
124+
if (TMath::Abs(casc.yXi()) < 0.5)
125+
h3dMassXiMinus->Fill(collision.centV0M(), casc.pt(), casc.mXi());
126+
if (TMath::Abs(casc.yOmega()) < 0.5)
127+
h3dMassOmegaMinus->Fill(collision.centV0M(), casc.pt(), casc.mOmega());
128+
} else {
129+
if (TMath::Abs(casc.yXi()) < 0.5)
130+
h3dMassXiPlus->Fill(collision.centV0M(), casc.pt(), casc.mXi());
131+
if (TMath::Abs(casc.yOmega()) < 0.5)
132+
h3dMassOmegaPlus->Fill(collision.centV0M(), casc.pt(), casc.mOmega());
133+
}
134+
}
135+
}
136+
}
137+
};
138+
139+
/// Extends the v0data table with expression columns
140+
struct cascadeinitializer {
141+
Spawns<aod::CascDataExt> cascdataext;
142+
void init(InitContext const&) {}
143+
};
144+
145+
WorkflowSpec defineDataProcessing(ConfigContext const&)
146+
{
147+
return WorkflowSpec{
148+
adaptAnalysisTask<cascadeconsumer>("lf-cascadeconsumer"),
149+
adaptAnalysisTask<cascadeQA>("lf-cascadeQA"),
150+
adaptAnalysisTask<cascadeinitializer>("lf-cascadeinitializer")};
151+
}

0 commit comments

Comments
 (0)