Skip to content

Commit c650902

Browse files
baasinghbaasingh
authored
[PWGCF/EbyE] Fixing process() and all the linters (#14491)
1 parent 44e31ff commit c650902

File tree

1 file changed

+154
-54
lines changed

1 file changed

+154
-54
lines changed

‎PWGCF/EbyEFluctuations/Tasks/FactorialMomentsTask.cxx‎

Lines changed: 154 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
/// \brief This task is for Normalized Factorial Moments Analysis: PRC 85, 044914 (2012), nucl-ex:1411.6083
1313
/// \author Salman Malik
1414
/// \author Balwan Singh
15+
1516
#include "TRandom.h"
1617
#include <TH1F.h>
1718

@@ -42,15 +43,15 @@ TH1D* tmpFqErr[6][5][52];
4243
struct FactorialMomentsTask {
4344
Configurable<bool> applyCheckPtForRec{"applyCheckPtForRec", false, "Apply checkpT for reconstructed tracks"};
4445
Configurable<bool> applyCheckPtForMC{"applyCheckPtForMC", true, "Apply checkpT for MC-generated tracks"};
45-
Configurable<Float_t> centralEta{"centralEta", 0.9, "eta limit for tracks"};
46-
Configurable<Int_t> numPt{"numPt", 5, "number of pT bins"};
47-
Configurable<Float_t> ptMin{"ptMin", 0.2f, "lower pT cut"};
48-
Configurable<Float_t> dcaXY{"dcaXY", 2.4f, "DCA xy cut"};
49-
Configurable<Float_t> dcaZ{"dcaZ", 2.0f, "DCA z cut"};
50-
Configurable<Float_t> minTPCCls{"minTPCCls", 70.0f, "minimum number of TPC clusters"};
51-
Configurable<std::vector<Int_t>> centLimits{"centLimits", {0, 5}, "centrality min and max"};
52-
Configurable<std::vector<Float_t>> vertexXYZ{"vertexXYZ", {0.3f, 0.4f, 10.0f}, "vertex cuts"};
53-
Configurable<std::vector<Float_t>> ptCuts{"ptCuts", {0.2f, 2.0f}, "pT cuts"};
46+
Configurable<float> centralEta{"centralEta", 0.9, "eta limit for tracks"};
47+
Configurable<int> numPt{"numPt", 5, "number of pT bins"};
48+
Configurable<float> ptMin{"ptMin", 0.2f, "lower pT cut"};
49+
Configurable<float> dcaXY{"dcaXY", 2.4f, "DCA xy cut"};
50+
Configurable<float> dcaZ{"dcaZ", 2.0f, "DCA z cut"};
51+
Configurable<float> mintPCCls{"mintPCCls", 70.0f, "minimum number of TPC clusters"};
52+
Configurable<std::vector<int>> centLimits{"centLimits", {0, 5}, "centrality min and max"};
53+
Configurable<std::vector<float>> vertexXYZ{"vertexXYZ", {0.3f, 0.4f, 10.0f}, "vertex cuts"};
54+
Configurable<std::vector<float>> ptCuts{"ptCuts", {0.2f, 2.0f}, "pT cuts"};
5455
Configurable<bool> isApplySameBunchPileup{"isApplySameBunchPileup", true, "Enable SameBunchPileup cut"};
5556
Configurable<bool> isApplyGoodZvtxFT0vsPV{"isApplyGoodZvtxFT0vsPV", true, "Enable GoodZvtxFT0vsPV cut"};
5657
Configurable<bool> isApplyVertexITSTPC{"isApplyVertexITSTPC", true, "Enable VertexITSTPC cut"};
@@ -112,7 +113,7 @@ struct FactorialMomentsTask {
112113
{"mVertexZ", "vertexZ", {HistType::kTH1F, {{100, -20, 20}}}},
113114
{"mEta", "#eta", {HistType::kTH1F, {{1000, -2, 2}}}},
114115
{"mPt", "#pt", {HistType::kTH1F, {{1000, -0.01, 50}}}},
115-
{"mPhi", "#phi", {HistType::kTH1F, {{100, 0, TMath::TwoPi()}}}},
116+
{"mPhi", "#phi", {HistType::kTH1F, {{100, 0, o2::constants::math::TwoPI}}}},
116117
{"mEvents", "events", {HistType::kTH1D, {{5, -0.5, 4.5}}}},
117118
{"mNFindableClsTPC", "findable TPC clusters;findable clusters", {HistType::kTH1F, {{100, 0, 200}}}},
118119
{"mNClsTPC", "number of clusters TPC; nClusters TPC", {HistType::kTH1F, {{100, 0, 200}}}},
@@ -135,18 +136,18 @@ struct FactorialMomentsTask {
135136
},
136137
OutputObjHandlingPolicy::AnalysisObject,
137138
true};
138-
static const Int_t nBins = 52;
139+
static const int nBins = 52;
139140
double kMinCharge = 1e-6;
140-
static const Int_t nfqOrder = 6;
141-
Int_t countSamples = 0;
142-
Int_t testc1 = 0, testc2 = 0, testc3 = 0;
143-
std::array<Int_t, nBins> binningM;
144-
std::array<Int_t, 5> countTracks{0, 0, 0, 0, 0};
145-
std::array<std::array<std::array<Double_t, nBins>, 5>, 6> fqEvent;
146-
std::array<std::array<std::array<Double_t, nBins>, 5>, 6> fqEventSampled;
147-
std::array<std::array<Double_t, nBins>, 5> binConEvent;
148-
std::array<std::array<std::array<Double_t, nBins>, 5>, 6> binConEventSampled;
149-
std::array<std::array<std::array<Double_t, nBins>, 5>, 6> errorFq = {{{{{0, 0, 0, 0, 0}}}}};
141+
static const int nfqOrder = 6;
142+
int countSamples = 0;
143+
int testc1 = 0, testc2 = 0, testc3 = 0;
144+
std::array<int, nBins> binningM;
145+
std::array<int, 5> countTracks{0, 0, 0, 0, 0};
146+
std::array<std::array<std::array<double, nBins>, 5>, 6> fqEvent;
147+
std::array<std::array<std::array<double, nBins>, 5>, 6> fqEventSampled;
148+
std::array<std::array<double, nBins>, 5> binConEvent;
149+
std::array<std::array<std::array<double, nBins>, 5>, 6> binConEventSampled;
150+
std::array<std::array<std::array<double, nBins>, 5>, 6> errorFq = {{{{{0, 0, 0, 0, 0}}}}};
150151
std::vector<std::shared_ptr<TH2>> mHistArrReset;
151152
std::vector<std::shared_ptr<TH1>> mHistArrQA;
152153
std::vector<std::shared_ptr<TH1>> mFqBinFinal;
@@ -185,22 +186,22 @@ struct FactorialMomentsTask {
185186
if (useMC) {
186187
auto mMcTrackSelected = std::get<std::shared_ptr<TH1>>(histos.add("mMcTrackSelected", "mcTrackSelection", HistType::kTH1D, {{5, 0.5, 5.5}}));
187188
}
188-
for (Int_t iM = 0; iM < nBins; ++iM) {
189+
for (int iM = 0; iM < nBins; ++iM) {
189190
binningM[iM] = 2 * (iM + 2);
190191
}
191-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
192+
for (int iPt = 0; iPt < numPt; ++iPt) {
192193
mHistArrQA.push_back(std::get<std::shared_ptr<TH1>>(histos.add(Form("bin%i/mEta", iPt + 1), Form("#eta for bin %.2f-%.2f;#eta", ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{1000, -2, 2}})));
193194
mHistArrQA.push_back(std::get<std::shared_ptr<TH1>>(histos.add(Form("bin%i/mPt", iPt + 1), Form("pT for bin %.2f-%.2f;pT", ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {axisPt[iPt]})));
194-
mHistArrQA.push_back(std::get<std::shared_ptr<TH1>>(histos.add(Form("bin%i/mPhi", iPt + 1), Form("#phi for bin %.2f-%.2f;#phi", ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{1000, 0, 2 * TMath::Pi()}})));
195+
mHistArrQA.push_back(std::get<std::shared_ptr<TH1>>(histos.add(Form("bin%i/mPhi", iPt + 1), Form("#phi for bin %.2f-%.2f;#phi", ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{1000, 0, o2::constants::math::TwoPI}})));
195196
mHistArrQA.push_back(std::get<std::shared_ptr<TH1>>(histos.add(Form("bin%i/mMultiplicity", iPt + 1), Form("Multiplicity for bin %.2f-%.2f;Multiplicity", ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{1000, 0, 15000}})));
196-
for (Int_t iM = 0; iM < nBins; ++iM) {
197-
auto mHistsR = std::get<std::shared_ptr<TH2>>(histos.add(Form("bin%i/Reset/mEtaPhi%i", iPt + 1, iM), Form("#eta#phi_%i for bin %.2f-%.2f;#eta;#phi", iM, ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH2F, {{binningM[iM], -0.8, 0.8}, {binningM[iM], 0, 2 * TMath::Pi()}}));
197+
for (int iM = 0; iM < nBins; ++iM) {
198+
auto mHistsR = std::get<std::shared_ptr<TH2>>(histos.add(Form("bin%i/Reset/mEtaPhi%i", iPt + 1, iM), Form("#eta#phi_%i for bin %.2f-%.2f;#eta;#phi", iM, ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH2F, {{binningM[iM], -0.8, 0.8}, {binningM[iM], 0, o2::constants::math::TwoPI}}));
198199
mHistArrReset.push_back(mHistsR);
199-
for (Int_t iq = 0; iq < nfqOrder; ++iq) {
200+
for (int iq = 0; iq < nfqOrder; ++iq) {
200201
tmpFqErr[iq][iPt][iM] = new TH1D(Form("tmpFqErr%i%i%i", iq, iPt, iM), Form("tmpFqErr%i%i%i", iq, iPt, iM), 100, 0, 10);
201202
}
202203
}
203-
for (Int_t i = 0; i < nfqOrder; ++i) {
204+
for (int i = 0; i < nfqOrder; ++i) {
204205
auto mHistFq = std::get<std::shared_ptr<TH1>>(histos.add(Form("mFinalFq%i_bin%i", i + 2, iPt + 1), Form("Final F_%i for bin %.2f-%.2f;M", i + 2, ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{nBins, -0.5, nBins - 0.5}}));
205206
mFqBinFinal.push_back(mHistFq);
206207
auto mHistAv = std::get<std::shared_ptr<TH1>>(histos.add(Form("mFinalAvBin%i_bin%i", i + 2, iPt + 1), Form("Final AvBin_%i for bin %.2f-%.2f;M", i + 2, ptCuts.value[2 * iPt], ptCuts.value[2 * iPt + 1]), HistType::kTH1F, {{nBins, -0.5, nBins - 0.5}}));
@@ -218,18 +219,18 @@ struct FactorialMomentsTask {
218219
template <typename T>
219220
void checkpT(const T& track)
220221
{
221-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
222+
for (int iPt = 0; iPt < numPt; ++iPt) {
222223
if (track.pt() > ptCuts.value[2 * iPt] && track.pt() < ptCuts.value[2 * iPt + 1]) {
223224
float iphi = track.phi();
224-
iphi = gRandom->Gaus(iphi, TMath::TwoPi());
225+
iphi = gRandom->Gaus(iphi, o2::constants::math::TwoPI);
225226
iphi = RecoDecay::constrainAngle(iphi);
226227

227228
mHistArrQA[iPt * 4]->Fill(track.eta());
228229
mHistArrQA[iPt * 4 + 1]->Fill(track.pt());
229230
mHistArrQA[iPt * 4 + 2]->Fill(track.phi());
230231
countTracks[iPt]++;
231232

232-
for (Int_t iM = 0; iM < nBins; ++iM) {
233+
for (int iM = 0; iM < nBins; ++iM) {
233234
mHistArrReset[iPt * nBins + iM]->Fill(track.eta(), track.phi());
234235
}
235236
}
@@ -238,26 +239,26 @@ struct FactorialMomentsTask {
238239

239240
void calculateMoments(std::vector<std::shared_ptr<TH2>> hist)
240241
{
241-
Double_t binContent = 0;
242+
double binContent = 0;
242243
countSamples++;
243-
Bool_t compSample = kFALSE;
244+
bool compSample = kFALSE;
244245
if (countSamples == samplesize) {
245246
compSample = kTRUE;
246247
countSamples = 0;
247248
}
248249
// Calculate the normalized factorial moments
249-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
250-
for (Int_t iM = 0; iM < nBins; ++iM) {
250+
for (int iPt = 0; iPt < numPt; ++iPt) {
251+
for (int iM = 0; iM < nBins; ++iM) {
251252
binContent = 0;
252-
Double_t sumfqBin[6] = {0};
253+
double sumfqBin[6] = {0};
253254

254-
for (Int_t iEta = 1; iEta <= hist[iPt * nBins + iM]->GetNbinsX(); ++iEta) {
255-
for (Int_t iPhi = 1; iPhi <= hist[iPt * nBins + iM]->GetNbinsY(); ++iPhi) {
255+
for (int iEta = 1; iEta <= hist[iPt * nBins + iM]->GetNbinsX(); ++iEta) {
256+
for (int iPhi = 1; iPhi <= hist[iPt * nBins + iM]->GetNbinsY(); ++iPhi) {
256257
double binconVal = 0;
257258
binconVal = hist[iPt * nBins + iM]->GetBinContent(iEta, iPhi);
258259
binContent += binconVal;
259-
for (Int_t iq = 0; iq < nfqOrder; ++iq) {
260-
Double_t fqBin = 0;
260+
for (int iq = 0; iq < nfqOrder; ++iq) {
261+
double fqBin = 0;
261262
if (binconVal >= iq + 2) {
262263
fqBin = TMath::Factorial(binconVal) / (TMath::Factorial(binconVal - (iq + 2)));
263264
}
@@ -268,10 +269,10 @@ struct FactorialMomentsTask {
268269
}
269270
}
270271
}
271-
binConEvent[iPt][iM] = binContent / (TMath::Power(binningM[iM], 2));
272-
for (Int_t iq = 0; iq < nfqOrder; ++iq) {
272+
binConEvent[iPt][iM] = binContent / (std::pow(binningM[iM], 2));
273+
for (int iq = 0; iq < nfqOrder; ++iq) {
273274
if (sumfqBin[iq] > 0) {
274-
fqEvent[iq][iPt][iM] = sumfqBin[iq] / (TMath::Power(binningM[iM], 2));
275+
fqEvent[iq][iPt][iM] = sumfqBin[iq] / (std::pow(binningM[iM], 2));
275276
fqEventSampled[iq][iPt][iM] += fqEvent[iq][iPt][iM];
276277
}
277278
binConEventSampled[iq][iPt][iM] += binConEvent[iPt][iM];
@@ -280,10 +281,10 @@ struct FactorialMomentsTask {
280281
if (compSample) {
281282
mBinConFinalSampled[iPt * 6 + iq]->Fill(iM, binConEventSampled[iq][iPt][iM] / samplesize);
282283

283-
double tmp = (fqEventSampled[iq][iPt][iM] / (samplesize)) / (TMath::Power(binConEventSampled[iq][iPt][iM] / (samplesize), (iq + 2)));
284+
double tmp = (fqEventSampled[iq][iPt][iM] / (samplesize)) / (std::pow(binConEventSampled[iq][iPt][iM] / (samplesize), (iq + 2)));
284285
mFqBinFinalSampled[iPt * 6 + iq]->Fill(iM, tmp);
285286
tmpFqErr[iq][iPt][iM]->Fill(tmp);
286-
errorFq[iq][iPt][iM] += TMath::Power(fqEventSampled[iq][iPt][iM] / (samplesize), 2);
287+
errorFq[iq][iPt][iM] += std::pow(fqEventSampled[iq][iPt][iM] / (samplesize), 2);
287288
mFqError[iPt * 6 + iq]->SetBinContent(iM + 1, 0);
288289
mFqError[iPt * 6 + iq]->Fill(iM, tmpFqErr[iq][iPt][iM]->GetStdDev());
289290

@@ -297,6 +298,7 @@ struct FactorialMomentsTask {
297298

298299
// write a template that takes coll and tracks from processRun3 and processMCRec
299300
using TracksFMs = soa::Filtered<soa::Join<aod::Tracks, aod::TracksExtra, aod::TrackSelection, aod::TracksDCA>>;
301+
Preslice<aod::McParticles> perMcCollision = aod::mcparticle::mcCollisionId;
300302
void processRun3(soa::Filtered<soa::Join<aod::Collisions, aod::EvSels, aod::Mults, aod::CentFV0As, aod::CentFT0Ms, aod::CentFT0As, aod::CentFT0Cs>>::iterator const& coll, TracksFMs const& tracks)
301303
{
302304
// selection of events
@@ -353,22 +355,120 @@ struct FactorialMomentsTask {
353355
checkpT(track);
354356
}
355357
}
356-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
358+
for (int iPt = 0; iPt < numPt; ++iPt) {
357359
if (countTracks[iPt] > 0) {
358360
mHistArrQA[iPt * 4 + 3]->Fill(countTracks[iPt]);
359361
}
360362
}
361363
calculateMoments(mHistArrReset);
362364
}
363365
PROCESS_SWITCH(FactorialMomentsTask, processRun3, "main process function", false);
364-
using EventSelection_Run2 = soa::Join<aod::EvSels, aod::Mults, aod::CentRun2V0Ms, aod::CentRun2SPDTrks>;
366+
using CollisionCandidateMCRec = soa::Join<aod::Collisions, aod::McCollisionLabels, aod::EvSels, aod::CentFT0Cs>;
367+
using TracksMc = soa::Filtered<soa::Join<aod::Tracks, aod::TracksExtra, aod::TracksDCA, aod::McTrackLabels, aod::TrackSelection>>;
368+
void processMCRec(soa::Filtered<CollisionCandidateMCRec>::iterator const& coll, TracksMc const& colltracks, aod::McParticles const& mcParticles, aod::McCollisions const&)
369+
{
370+
if (!coll.has_mcCollision()) {
371+
return;
372+
}
373+
histos.fill(HIST("mEventSelected"), 0);
374+
if (!coll.sel8()) {
375+
return;
376+
}
377+
histos.fill(HIST("mEventSelected"), 1);
378+
if (isApplySameBunchPileup && !coll.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) {
379+
return;
380+
}
381+
histos.fill(HIST("mEventSelected"), 2);
382+
if (isApplyGoodZvtxFT0vsPV && !coll.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) {
383+
return;
384+
}
385+
histos.fill(HIST("mEventSelected"), 3);
386+
if (isApplyVertexITSTPC && !coll.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) {
387+
return;
388+
}
389+
histos.fill(HIST("mEventSelected"), 4);
390+
if (coll.centFT0C() < centLimits.value[0] || coll.centFT0C() > centLimits.value[1]) {
391+
return;
392+
}
393+
histos.fill(HIST("mEventSelected"), 5);
394+
histos.fill(HIST("mVertexX"), coll.posX());
395+
histos.fill(HIST("mVertexY"), coll.posY());
396+
histos.fill(HIST("mVertexZ"), coll.posZ());
397+
histos.fill(HIST("mCentFT0C"), coll.centFT0C());
398+
for (auto const& h : mHistArrReset) {
399+
h->Reset();
400+
}
401+
countTracks = {0, 0, 0, 0, 0};
402+
fqEvent = {{{{{0, 0, 0, 0, 0, 0}}}}};
403+
binConEvent = {{{0, 0, 0, 0, 0}}};
404+
for (auto const& track : colltracks) {
405+
// if (track.hasITS())
406+
// if (track.hasTPC())
407+
// if (track.isGlobalTrack()) {
408+
histos.fill(HIST("mCollID"), track.collisionId());
409+
histos.fill(HIST("mEta"), track.eta());
410+
histos.fill(HIST("mPt"), track.pt());
411+
histos.fill(HIST("mPhi"), track.phi());
412+
histos.fill(HIST("mNFindableClsTPC"), track.tpcNClsFindable());
413+
histos.fill(HIST("mNClsTPC"), track.tpcNClsFound());
414+
histos.fill(HIST("mNClsITS"), track.itsNCls());
415+
histos.fill(HIST("mChi2TPC"), track.tpcChi2NCl());
416+
histos.fill(HIST("mChi2ITS"), track.itsChi2NCl());
417+
histos.fill(HIST("mChi2TRD"), track.trdChi2());
418+
histos.fill(HIST("mDCAxy"), track.dcaXY());
419+
histos.fill(HIST("mDCAx"), track.dcaZ());
420+
histos.fill(HIST("mDCAxyPt"), track.pt(), track.dcaXY());
421+
histos.fill(HIST("mDCAzPt"), track.pt(), track.dcaZ());
422+
histos.fill(HIST("mNSharedClsTPC"), track.tpcNClsShared());
423+
histos.fill(HIST("mCrossedRowsTPC"), track.tpcNClsCrossedRows());
424+
histos.fill(HIST("mNFinClsminusCRows"), track.tpcNClsFindableMinusCrossedRows());
425+
histos.fill(HIST("mNFractionShClsTPC"), track.tpcFractionSharedCls());
426+
histos.fill(HIST("mSharedClsvsPt"), track.pt(), track.tpcNClsShared());
427+
histos.fill(HIST("mSharedClsProbvsPt"), track.pt(), track.tpcFractionSharedCls() / track.tpcNClsCrossedRows());
428+
checkpT(track);
429+
//}
430+
}
431+
auto mcParts = mcParticles.sliceBy(perMcCollision, coll.mcCollision().globalIndex());
432+
for (auto const& mc : mcParts) {
433+
int pdgCode = mc.pdgCode();
434+
auto pdgInfo = pdg->GetParticle(pdgCode);
435+
if (!pdgInfo) {
436+
continue;
437+
}
438+
double charge = pdgInfo->Charge();
439+
double physCharge = charge / 3.0;
440+
histos.fill(HIST("mChargeBefore"), physCharge);
441+
if (mc.isPhysicalPrimary() && std::abs(mc.eta()) < centralEta && std::abs(physCharge) >= kMinCharge) {
442+
histos.fill(HIST("mChargeAfter"), physCharge);
443+
histos.fill(HIST("mEta"), mc.eta());
444+
histos.fill(HIST("mPt"), mc.pt());
445+
histos.fill(HIST("mPhi"), mc.phi());
446+
if (applyCheckPtForMC && !applyCheckPtForRec) {
447+
checkpT(mc);
448+
}
449+
}
450+
}
451+
for (auto iPt = 0; iPt < numPt; ++iPt) {
452+
// if (countTracks[iPt] > 0)countTracks = {0, 0, 0, 0, 0};
453+
if (countTracks[iPt] > 0) {
454+
mHistArrQA[iPt * 4 + 3]->Fill(countTracks[iPt]);
455+
}
456+
}
457+
histos.fill(HIST("mEventSelected"), 6);
458+
// Calculate the normalized factorial moments
459+
calculateMoments(mHistArrReset);
460+
}
461+
PROCESS_SWITCH(FactorialMomentsTask, processMCRec, "main process function", false);
462+
using EventSelectionrun2 = soa::Join<aod::EvSels, aod::Mults, aod::CentRun2V0Ms, aod::CentRun2SPDTrks>;
365463
using TracksRecSim = soa::Join<aod::Tracks, aod::TracksExtra, aod::TracksDCA, aod::TrackSelection, aod::McTrackLabels>;
366-
using CollisionRecSim_Run2 = soa::Filtered<soa::Join<aod::Collisions, aod::McCollisionLabels, EventSelection_Run2>>::iterator;
464+
using CollisionRecSimRun2 = soa::Filtered<soa::Join<aod::Collisions, aod::McCollisionLabels, EventSelectionrun2>>::iterator;
367465
using BCsWithRun2Info = soa::Join<aod::BCs, aod::Run2BCInfos, aod::Timestamps>;
368-
Preslice<aod::McParticles> perMcCollision = aod::mcparticle::mcCollisionId;
369-
void processMcRun2(CollisionRecSim_Run2 const& coll,
466+
void processMcRun2(CollisionRecSimRun2 const& coll,
467+
aod::BCs const&,
370468
TracksRecSim const& tracks,
371-
aod::McParticles const& mcParticles)
469+
aod::McParticles const& mcParticles,
470+
aod::McCollisions const&,
471+
BCsWithRun2Info const&)
372472
{
373473
auto bc = coll.bc_as<BCsWithRun2Info>();
374474
if (!(bc.eventCuts() & BIT(aod::Run2EventCuts::kAliEventCutsAccepted))) {
@@ -429,7 +529,7 @@ struct FactorialMomentsTask {
429529
}
430530
}
431531

432-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
532+
for (int iPt = 0; iPt < numPt; ++iPt) {
433533
if (countTracks[iPt] > 0) {
434534
mHistArrQA[iPt * 4 + 3]->Fill(countTracks[iPt]);
435535
} else {
@@ -461,7 +561,7 @@ struct FactorialMomentsTask {
461561
fqEvent = {{{{{0, 0, 0, 0, 0, 0}}}}};
462562
binConEvent = {{{0, 0, 0, 0, 0}}};
463563
for (auto const& track : tracks) {
464-
if ((track.pt() < ptMin) || (!track.isGlobalTrack()) || (track.tpcNClsFindable() < minTPCCls)) {
564+
if ((track.pt() < ptMin) || (!track.isGlobalTrack()) || (track.tpcNClsFindable() < mintPCCls)) {
465565
continue;
466566
}
467567
histos.fill(HIST("mCollID"), track.collisionId());
@@ -486,7 +586,7 @@ struct FactorialMomentsTask {
486586
histos.fill(HIST("mSharedClsProbvsPt"), track.pt(), track.tpcFractionSharedCls() / track.tpcNClsCrossedRows());
487587
checkpT(track);
488588
}
489-
for (Int_t iPt = 0; iPt < numPt; ++iPt) {
589+
for (int iPt = 0; iPt < numPt; ++iPt) {
490590
if (countTracks[iPt] > 0) {
491591
mHistArrQA[iPt * 4 + 3]->Fill(countTracks[iPt]);
492592
} else {

0 commit comments

Comments
 (0)