From 8e468ce5ed966185ebeaed9235a08bd5aa94aafc Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Thu, 18 Jan 2024 17:09:02 +0100 Subject: [PATCH 01/17] Added workflow of charged flattenicity --- PWGMM/Mult/Tasks/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/PWGMM/Mult/Tasks/CMakeLists.txt b/PWGMM/Mult/Tasks/CMakeLists.txt index a4268d96a5c..70d160fa18a 100644 --- a/PWGMM/Mult/Tasks/CMakeLists.txt +++ b/PWGMM/Mult/Tasks/CMakeLists.txt @@ -64,3 +64,8 @@ o2physics_add_dpl_workflow(multiplicity-pb-pb SOURCES multiplicityPbPb.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(flattenicty-chrg + SOURCES flattenicty-chrg.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) From 3f2a6f2ecc1b3c22a7302dd76199e903406806de Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 19 Jan 2024 15:02:54 +0100 Subject: [PATCH 02/17] Added workflow of charged-particle flattenicity --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 493 ++++++++++++++++++++++++++ 1 file changed, 493 insertions(+) create mode 100644 PWGMM/Mult/Tasks/flattenicty-chrg.cxx diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx new file mode 100644 index 00000000000..81737ab71b3 --- /dev/null +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -0,0 +1,493 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +/// \file flatenicty-chrg.cxx +/// \author Gyula Bencedi (gyula.bencedi@cern.ch), Antonio Ortiz (antonio.ortiz@cern.ch) +/// \brief Task to produce inclusive charged particle pT distributions as a function of charged-particle flattenicity +/// \since 2023 + +#include +#include +#include +#include + +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/StaticFor.h" +#include "Framework/runDataProcessing.h" +#include "EventFiltering/filterTables.h" + +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CcdbApi.h" +#include "DataFormatsFT0/Digit.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/TrackSelection.h" +#include "Common/Core/TrackSelectionDefaults.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/TrackSelectionTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::track; + +float meanMultT0A = 0.f; +float meanMultT0C = 0.f; +float meanMultV0A = 0.f; + +struct FlattenictyCharged { + + HistogramRegistry flatchrg{"flatchrg",{},OutputObjHandlingPolicy::AnalysisObject,true,true}; + + TrackSelection mTrackSelector; + + Configurable cutTrkEta{"cutTrkEta", 0.8f,"Eta range for tracks"}; + Configurable cutTrkPtMin{"cutTrkPtMin", 0.15f, "Minimum pT of tracks"}; +// Configurable cutTrkMult{"cutTrkMult", 200, "max measured multiplicity"}; + Configurable cutVtxzMin{"cutVtxzMin", -10.f, "Minimum value for z-vertex"}; + Configurable cutVtxzMax{"cutVtxzMax", 10.f, "Maximum value for z-vertex"}; + + ConfigurableAxis multBins{"multBins", {1001, -0.5, 1000.5}, ""}; + + Configurable sel8{"sel8", 1, "apply sel8 event selection"}; + Configurable selt0vtx{"selt0vtx", 0, "apply T0 vertext trigger"}; + Configurable selt0time{"selt0time", 0, "apply 1ns cut T0A and T0C"}; + +// // Configurable avPyT0A{"avPyT0A", 8.16, "nch from pythia T0A"}; + Configurable avPyT0C{"avPyT0C", 8.83, "nch from pythia T0C"}; + Configurable avPyFV0{"avPyFV0", 21.44, "nch from pythia FV0"}; + + Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch","URL of the CCDB database"}; + + o2::ccdb::CcdbApi ccdbApi; + Service ccdb; + + void init(InitContext&) + { + ccdbApi.init(o2::base::NameConf::getCCDBServer()); + ccdb->setURL(url.value); // + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + if (!ccdbApi.isHostReachable()) { + LOGF(fatal, "CCDB host %s is not reacheable, cannot go forward",url.value.data()); + } + + mTrackSelector.SetPtRange(0.15f, 1e10f); + mTrackSelector.SetEtaRange(-0.8f, 0.8f); + mTrackSelector.SetRequireITSRefit(true); + mTrackSelector.SetRequireTPCRefit(true); + mTrackSelector.SetRequireGoldenChi2(false); + mTrackSelector.SetMinNClustersTPC(60); + mTrackSelector.SetMinNCrossedRowsTPC(70); + mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); + mTrackSelector.SetMaxChi2PerClusterTPC(4.f); + mTrackSelector.SetRequireHitsInITSLayers(1, {0, 1}); // one hit in any SPD layer + mTrackSelector.SetMaxChi2PerClusterITS(36.f); + mTrackSelector.SetMaxDcaXY(1.f); + mTrackSelector.SetMaxDcaZ(1.f); + + std::vector ptBinEdges = { + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, + 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, + 1.1 , 1.2, 1.3, 1.4, 1.5 , 1.6, 1.7 , 1.8, 1.9 , 2.0, + 2.2 , 2.4, 2.6, 2.8, 3.0 , 3.2, 3.4 , 3.6, 3.8 , 4.0, + 4.5 , 5.0, 5.5, 6.0, 6.5 , 7.0, 8.0 , 9.0, 10.0,11.0, + 12.0,13.0,14.0, 15.0, 16.0, 18.0,20.0, 22.0,24.0,26.0, + 30.0}; + const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; + const AxisSpec ZAxis = {40, -20.0, 20.0}; + const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; + const AxisSpec EtaAxisGlobal = {50, -5.0, 5.0}; + const AxisSpec EtaAxis = {20, 2.2, 5.1}; // FV0 +// const AxisSpec FlatAxis = {102, -0.01, +1.01}; + const AxisSpec CombEstAxis = {500, -0.5, 499.5}; + AxisSpec MultAxis = {multBins, "N_{trk}"}; + + flatchrg.add("hMultFV0", "hMultFV0", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude"}}); + flatchrg.add("hMultFV01to4Ring", "hMultFV01to4Ring", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); + flatchrg.add("hMultFV05Ring", "hMultFV05Ring", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); + + flatchrg.add("hMultFV0sel", "hMultFV0sel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude"}}); + flatchrg.add("hMultFV01to4Ringsel", "hMultFV01to4Ringsel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); + flatchrg.add("hMultFV05Ringsel", "hMultFV05Ringsel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); + + flatchrg.add("hT0C_time", "T0C_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0A_time", "T0A_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0C_time_sel", "T0C_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0A_time_sel", "T0A_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); + + flatchrg.add("hAmpT0AVsCh", "", HistType::kTH2F, {{24, -0.5, 23.5, "ch"}, {600, -0.5, +5999.5, "FT0A amplitude vs channel"}}); + flatchrg.add("hFT0A", "FT0A", HistType::kTH1F, {{600, -0.5, 599.5, "FT0A amplitudes"}}); + + flatchrg.add("hAmpT0CVsCh", "", HistType::kTH2F, {{28, -0.5, 27.5, "ch"}, {600, -0.5, +5999.5, "FT0C amplitude vs channel"}}); + flatchrg.add("hFT0C", "FT0C", HistType::kTH1F, {{600, -0.5, 599.5, "FT0C amplitudes"}}); + + flatchrg.add("hMultFT0C", "hMultFT0C", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0C amplitude"}}); + flatchrg.add("hMultFT0Csel", "hMultFT0C", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0C amplitude"}}); + flatchrg.add("hMultFT0A", "hMultFT0A", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0A amplitude"}}); + flatchrg.add("hMultFT0Asel", "hMultFT0A", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0A amplitude"}}); + + flatchrg.add("h1flatencityFV0", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFV0"}}); + flatchrg.add("h1flatencityFT0A", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFT0A"}}); + flatchrg.add("h1flatencityFT0C", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFT0C"}}); + flatchrg.add("h1flatencityFV0FT0C", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFV0FT0C"}}); + flatchrg.add("hFV0FT0C", "", HistType::kTH1F, {{102, -0.5, 499.5, "FV0_FT0C"}}); + + flatchrg.add("hPtVsFV0FT0C", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", HistType::kTH2F, {{500, -0.5, 499.5, "fv0ft0c"}, {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); + flatchrg.add("hPtVs1flatencityFV0", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", HistType::kTH2F, {{102, -0.01, 1.01, "1flatFV0"}, {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); + + // event level histos + flatchrg.add({"Events/selection", ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); + auto hstat = flatchrg.get(HIST("Events/selection")); + auto* x = hstat->GetXaxis(); + x->SetBinLabel(1, "All"); + x->SetBinLabel(2, "Selected trigger"); + x->SetBinLabel(3, "Selected zvtx"); + x->SetBinLabel(4, "Selected INEL>0"); + + // track level histos + flatchrg.add({"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); + flatchrg.add({"Tracks/EtaGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH1F, {EtaAxisGlobal}}}); + flatchrg.add({"Tracks/PhiEtaGlobal", "; #varphi; #eta; tracks", {HistType::kTH2F, {PhiAxis, EtaAxisGlobal}}}); + flatchrg.add({"Tracks/PtEtaGlobal", " ; #it{p}_{T} (GeV/#it{c}); #eta", {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); + } + + int getT0ASector(int i_ch) + { + int i_sec_t0a = -1; + for (int i_sec = 0; i_sec < 24; ++i_sec) { + if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { + i_sec_t0a = i_sec; + break; + } + } + return i_sec_t0a; + } + + int getT0CSector(int i_ch) + { + int i_sec_t0c = -1; + for (int i_sec = 0; i_sec < 28; ++i_sec) { + if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { + i_sec_t0c = i_sec; + break; + } + } + return i_sec_t0c; + } + + float GetFlatenicity(float signals[], int entries) + { + float flat = 9999; + float mRho = 0; + for (int iCell = 0; iCell < entries; ++iCell) { + mRho += 1.0 * signals[iCell]; + } + // average activity per cell + mRho /= (1.0 * entries); + if (mRho <= 0) { + return 9999; + } + // get sigma + float sRho_tmp = 0; + for (int iCell = 0; iCell < entries; ++iCell) { + sRho_tmp += (1.0 * signals[iCell] - mRho) * (1.0 * signals[iCell] - mRho); + } + sRho_tmp /= (1.0 * entries * entries); + float sRho = sqrt(sRho_tmp); + if (mRho > 0) { + flat = sRho / mRho; + } + return flat; + } + + Filter trackFilter = (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + using TrackTableData = soa::Filtered>; + using CollisionTableData = soa::Join; + +void process(CollisionTableData::iterator const& collision, TrackTableData const& tracks, soa::Join const& bcs, /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s,aod::FV0As const& fv0s) +{ + LOGF(debug, " Collision %d", collision.globalIndex()); + + auto bc = collision.template bc_as(); + + meanMultT0C = 0.f; + auto vMeanMultT0C = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0C", bc.timestamp()); + meanMultT0C = (*vMeanMultT0C)[0]; + +// meanMultT0A = 0.f; +// auto vMeanMultT0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0A", bc.timestamp()); +// meanMultT0A = (*vMeanMultT0A)[0]; + + meanMultV0A = 0.f; + auto vMeanMultV0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanV0A", bc.timestamp()); + meanMultV0A = (*vMeanMultV0A)[0]; + +// float fac_FT0A_ebe = 1.; + float fac_FT0C_ebe = 1.; + float fac_FV0_ebe = 1.; + +// if (meanMultT0A > 0) { +// fac_FT0A_ebe = avPyT0A / meanMultT0A; +// } + if (meanMultT0C > 0) { + fac_FT0C_ebe = avPyT0C / meanMultT0C; + } + if (meanMultV0A > 0) { + fac_FV0_ebe = avPyFV0 / meanMultV0A; + } + + + bool isAcceptedEvent = false; + flatchrg.fill(HIST("Events/selection"), 1.); + + if (collision.sel8()) { + isAcceptedEvent = true; + } + + if (!isAcceptedEvent) { + return; + } + + flatchrg.fill(HIST("Events/selection"), 2.); + + auto vtxZ = collision.posZ(); + flatchrg.fill(HIST("Tracks/VtxZ"), vtxZ); + + bool isGoodEvent = false; + if (vtxZ > cutVtxzMin && vtxZ < cutVtxzMax) { + isGoodEvent = true; + } + + if (!isGoodEvent) { + return; + } + + flatchrg.fill(HIST("Events/selection"), 3.); + + //__________ FT0 mult. esimator + // + float sumAmpFT0A = 0.f; + float sumAmpFT0C = 0.f; + bool isOkTimeFT0 = false; + bool isOkvtxtrig = false; + bool isOkFV0OrA = false; + + if (collision.has_foundFT0()) { + auto ft0 = collision.foundFT0(); + std::bitset<8> triggers = ft0.triggerMask(); + isOkvtxtrig = triggers[o2::fit::Triggers::bitVertex]; + float t0_a = ft0.timeA(); + float t0_c = ft0.timeC(); + if (abs(t0_a) < 1. && abs(t0_c) < 1.) { + isOkTimeFT0 = true; + } + flatchrg.fill(HIST("hT0C_time"), t0_c); + flatchrg.fill(HIST("hT0A_time"), t0_a); + + for (std::size_t i_a = 0; i_a < ft0.amplitudeA().size(); i_a++) { + float amplitude = ft0.amplitudeA()[i_a]; + sumAmpFT0A += amplitude; + } + for (std::size_t i_c = 0; i_c < ft0.amplitudeC().size(); i_c++) { + float amplitude = ft0.amplitudeC()[i_c]; + sumAmpFT0C += amplitude; + } + flatchrg.fill(HIST("hMultFT0A"), sumAmpFT0A); + flatchrg.fill(HIST("hMultFT0C"), sumAmpFT0C); + } + + //__________ FLATTENICITY - FV0 mult. esimator + // + + double flatenicity_fv0 = 9999.; + float sumAmpFV0 = 0; + float sumAmpFV01to4Ring = 0; + float sumAmpFV05Ring = 0; + int innerFV0 = 32; + + const int nCells = 48; + float RhoLattice[nCells]; + for (Int_t iCh = 0; iCh < nCells; iCh++) { + RhoLattice[iCh] = 0; + } + + if (collision.has_foundFV0()) { + auto fv0 = collision.foundFV0(); + std::bitset<8> fV0Triggers = fv0.triggerMask(); + isOkFV0OrA = fV0Triggers[o2::fit::Triggers::bitA]; + // LOGP(info, "amplitude.size()={}", fv0.amplitude().size()); + for (std::size_t ich = 0; ich < fv0.amplitude().size(); ich++) { + int channelv0 = fv0.channel()[ich]; + float ampl_ch = fv0.amplitude()[ich]; + sumAmpFV0 += ampl_ch; + if (channelv0 < innerFV0) { + RhoLattice[channelv0] = ampl_ch; + sumAmpFV01to4Ring += ampl_ch; + } else { + RhoLattice[channelv0] = ampl_ch / 2.0; // two channels per bin + sumAmpFV05Ring += ampl_ch; + } + } + flatenicity_fv0 = GetFlatenicity(RhoLattice, nCells); + } + + flatchrg.fill(HIST("h1flatencityFV0"), 1.-flatenicity_fv0); + + flatchrg.fill(HIST("hMultFV0"), sumAmpFV0); + flatchrg.fill(HIST("hMultFV01to4Ring"), sumAmpFV01to4Ring); + flatchrg.fill(HIST("hMultFV05Ring"), sumAmpFV05Ring); + + if (selt0vtx && !isOkvtxtrig && !isOkFV0OrA) { + return; + } + if (selt0time && !isOkTimeFT0) {// to reduce beam-gas background + return; + } + if (sel8 && !collision.sel8()) { + return; + } + + flatchrg.fill(HIST("hMultFV0sel"), sumAmpFV0); + flatchrg.fill(HIST("hMultFV01to4Ringsel"), sumAmpFV01to4Ring); + flatchrg.fill(HIST("hMultFV05Ringsel"), sumAmpFV05Ring); + + //__________ FLATTENICITY - FT0 mult. esimator + // + + const int nCellsT0A = 24; + float RhoLatticeT0A[nCellsT0A]; + for (int iCh = 0; iCh < nCellsT0A; iCh++) { + RhoLatticeT0A[iCh] = 0.0; + } + const int nCellsT0C = 28; + float RhoLatticeT0C[nCellsT0C]; + for (int iCh = 0; iCh < nCellsT0C; iCh++) { + RhoLatticeT0C[iCh] = 0.0; + } + + float sumAmpFT0Asel = 0.f; + float sumAmpFT0Csel = 0.f; + if (collision.has_foundFT0()) { + auto ft0 = collision.foundFT0(); + float t0_a = ft0.timeA(); + float t0_c = ft0.timeC(); + flatchrg.fill(HIST("hT0C_time_sel"), t0_c); + flatchrg.fill(HIST("hT0A_time_sel"), t0_a); + + for (std::size_t i_a = 0; i_a < ft0.amplitudeA().size(); i_a++) { + float amplitude = ft0.amplitudeA()[i_a]; + uint8_t channel = ft0.channelA()[i_a]; + int sector = getT0ASector(channel); + if (sector >= 0 && sector < 24) { + RhoLatticeT0A[sector] += amplitude; + flatchrg.fill(HIST("hAmpT0AVsCh"), sector, amplitude); + } + sumAmpFT0Asel += amplitude; + flatchrg.fill(HIST("hFT0A"), amplitude); + } + flatchrg.fill(HIST("hMultFT0Asel"), sumAmpFT0Asel); + + for (std::size_t i_c = 0; i_c < ft0.amplitudeC().size(); i_c++) { + float amplitude = ft0.amplitudeC()[i_c]; + uint8_t channel = ft0.channelC()[i_c]; + int sector = getT0CSector(channel); + if (sector >= 0 && sector < 28) { + RhoLatticeT0C[sector] += amplitude; + flatchrg.fill(HIST("hAmpT0CVsCh"), sector, amplitude); + } + sumAmpFT0Csel += amplitude; + flatchrg.fill(HIST("hFT0C"), amplitude); + } + flatchrg.fill(HIST("hMultFT0Csel"), sumAmpFT0Csel); + + } + float flatenicity_t0a = GetFlatenicity(RhoLatticeT0A, nCellsT0A); + float flatenicity_t0c = GetFlatenicity(RhoLatticeT0C, nCellsT0C); + + flatchrg.fill(HIST("h1flatencityFT0A"), 1.-flatenicity_t0a); + flatchrg.fill(HIST("h1flatencityFT0C"), 1.-flatenicity_t0c); + + //__________ FLATTENICITY - combined + + float combest = 0.; + + // option 1 + flatchrg.fill(HIST("h1flatencityFV0FT0C"), (1.0 - (flatenicity_fv0 + flatenicity_t0c) / 2.0)); + + // option 2 + const int nEta = 2; // FT0C + FV0 + float weightsEta[nEta] = {0.0490638, 0.00353962}; + float factebye[nEta] = {0., 0.}; + float deltaEeta[nEta] = {1.1, 2.9}; + float ampl[nEta] = {0, 0}; + + if (collision.has_foundFV0() && collision.has_foundFT0()) { + + float all_weights = 0; + ampl[0] = sumAmpFT0C; + ampl[1] = sumAmpFV0; + factebye[0] = fac_FT0C_ebe; + factebye[1] = fac_FV0_ebe; + + if (sumAmpFT0C > 0 && sumAmpFV0 > 0) { + for (int ie = 0; ie < nEta; ++ie) { + if (meanMultV0A > 0 && meanMultT0C > 0) { + combest += ampl[ie] * weightsEta[ie] / deltaEeta[ie]; + } + else{ + combest += ampl[ie] * factebye[ie] / deltaEeta[ie]; + } + all_weights += weightsEta[ie]; + } + combest /= all_weights; + } + } + + flatchrg.fill(HIST("hFV0FT0C"), combest); + + for (auto& track : tracks) { + //if (!track.isGlobalTrack()) { + if (!mTrackSelector.IsSelected(track)) { + continue; + } + + if (!track.isPVContributor()) { + continue; + } + + flatchrg.fill(HIST("Tracks/EtaGlobal"), track.eta()); + flatchrg.fill(HIST("Tracks/EtaVtxZGlobal"), track.eta(), vtxZ); + flatchrg.fill(HIST("Tracks/PtEtaGlobal"), track.pt(), track.eta()); + + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + flatchrg.fill(HIST("Tracks/PhiEtaGlobal"), phi, track.eta()); + + flatchrg.fill(HIST("hPtVsFV0FT0C"), combest, track.pt()); + flatchrg.fill(HIST("hPtVs1flatencityFV0"), 1.-flatenicity_fv0, track.pt()); + } + +} + +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ +// adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc) + }; +} From 39776cb3cb54e4440af87ec80d18785d7a753376 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 19 Jan 2024 14:46:39 +0000 Subject: [PATCH 03/17] MegaLinter fixes --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 158 +++++++++++++------------- 1 file changed, 76 insertions(+), 82 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index 81737ab71b3..2eadb0297c9 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -48,15 +48,15 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { - HistogramRegistry flatchrg{"flatchrg",{},OutputObjHandlingPolicy::AnalysisObject,true,true}; + HistogramRegistry flatchrg{"flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; TrackSelection mTrackSelector; - Configurable cutTrkEta{"cutTrkEta", 0.8f,"Eta range for tracks"}; + Configurable cutTrkEta{"cutTrkEta", 0.8f, "Eta range for tracks"}; Configurable cutTrkPtMin{"cutTrkPtMin", 0.15f, "Minimum pT of tracks"}; -// Configurable cutTrkMult{"cutTrkMult", 200, "max measured multiplicity"}; + // Configurable cutTrkMult{"cutTrkMult", 200, "max measured multiplicity"}; Configurable cutVtxzMin{"cutVtxzMin", -10.f, "Minimum value for z-vertex"}; - Configurable cutVtxzMax{"cutVtxzMax", 10.f, "Maximum value for z-vertex"}; + Configurable cutVtxzMax{"cutVtxzMax", 10.f, "Maximum value for z-vertex"}; ConfigurableAxis multBins{"multBins", {1001, -0.5, 1000.5}, ""}; @@ -64,11 +64,11 @@ struct FlattenictyCharged { Configurable selt0vtx{"selt0vtx", 0, "apply T0 vertext trigger"}; Configurable selt0time{"selt0time", 0, "apply 1ns cut T0A and T0C"}; -// // Configurable avPyT0A{"avPyT0A", 8.16, "nch from pythia T0A"}; + // // Configurable avPyT0A{"avPyT0A", 8.16, "nch from pythia T0A"}; Configurable avPyT0C{"avPyT0C", 8.83, "nch from pythia T0C"}; Configurable avPyFV0{"avPyFV0", 21.44, "nch from pythia FV0"}; - Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch","URL of the CCDB database"}; + Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", "URL of the CCDB database"}; o2::ccdb::CcdbApi ccdbApi; Service ccdb; @@ -80,7 +80,7 @@ struct FlattenictyCharged { ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); if (!ccdbApi.isHostReachable()) { - LOGF(fatal, "CCDB host %s is not reacheable, cannot go forward",url.value.data()); + LOGF(fatal, "CCDB host %s is not reacheable, cannot go forward", url.value.data()); } mTrackSelector.SetPtRange(0.15f, 1e10f); @@ -98,19 +98,19 @@ struct FlattenictyCharged { mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, - 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, - 1.1 , 1.2, 1.3, 1.4, 1.5 , 1.6, 1.7 , 1.8, 1.9 , 2.0, - 2.2 , 2.4, 2.6, 2.8, 3.0 , 3.2, 3.4 , 3.6, 3.8 , 4.0, - 4.5 , 5.0, 5.5, 6.0, 6.5 , 7.0, 8.0 , 9.0, 10.0,11.0, - 12.0,13.0,14.0, 15.0, 16.0, 18.0,20.0, 22.0,24.0,26.0, - 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, + 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, + 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, + 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, + 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, + 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, + 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; const AxisSpec EtaAxisGlobal = {50, -5.0, 5.0}; - const AxisSpec EtaAxis = {20, 2.2, 5.1}; // FV0 -// const AxisSpec FlatAxis = {102, -0.01, +1.01}; + const AxisSpec EtaAxis = {20, 2.2, 5.1}; // FV0 + // const AxisSpec FlatAxis = {102, -0.01, +1.01}; const AxisSpec CombEstAxis = {500, -0.5, 499.5}; AxisSpec MultAxis = {multBins, "N_{trk}"}; @@ -215,67 +215,66 @@ struct FlattenictyCharged { Filter trackFilter = (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = soa::Filtered>; - using CollisionTableData = soa::Join; + using CollisionTableData = soa::Join; -void process(CollisionTableData::iterator const& collision, TrackTableData const& tracks, soa::Join const& bcs, /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s,aod::FV0As const& fv0s) -{ - LOGF(debug, " Collision %d", collision.globalIndex()); + void process(CollisionTableData::iterator const& collision, TrackTableData const& tracks, soa::Join const& bcs, /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, aod::FV0As const& fv0s) + { + LOGF(debug, " Collision %d", collision.globalIndex()); - auto bc = collision.template bc_as(); + auto bc = collision.template bc_as(); - meanMultT0C = 0.f; - auto vMeanMultT0C = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0C", bc.timestamp()); - meanMultT0C = (*vMeanMultT0C)[0]; + meanMultT0C = 0.f; + auto vMeanMultT0C = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0C", bc.timestamp()); + meanMultT0C = (*vMeanMultT0C)[0]; -// meanMultT0A = 0.f; -// auto vMeanMultT0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0A", bc.timestamp()); -// meanMultT0A = (*vMeanMultT0A)[0]; + // meanMultT0A = 0.f; + // auto vMeanMultT0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0A", bc.timestamp()); + // meanMultT0A = (*vMeanMultT0A)[0]; - meanMultV0A = 0.f; - auto vMeanMultV0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanV0A", bc.timestamp()); - meanMultV0A = (*vMeanMultV0A)[0]; + meanMultV0A = 0.f; + auto vMeanMultV0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanV0A", bc.timestamp()); + meanMultV0A = (*vMeanMultV0A)[0]; -// float fac_FT0A_ebe = 1.; - float fac_FT0C_ebe = 1.; - float fac_FV0_ebe = 1.; - -// if (meanMultT0A > 0) { -// fac_FT0A_ebe = avPyT0A / meanMultT0A; -// } - if (meanMultT0C > 0) { - fac_FT0C_ebe = avPyT0C / meanMultT0C; - } - if (meanMultV0A > 0) { - fac_FV0_ebe = avPyFV0 / meanMultV0A; - } + // float fac_FT0A_ebe = 1.; + float fac_FT0C_ebe = 1.; + float fac_FV0_ebe = 1.; + // if (meanMultT0A > 0) { + // fac_FT0A_ebe = avPyT0A / meanMultT0A; + // } + if (meanMultT0C > 0) { + fac_FT0C_ebe = avPyT0C / meanMultT0C; + } + if (meanMultV0A > 0) { + fac_FV0_ebe = avPyFV0 / meanMultV0A; + } - bool isAcceptedEvent = false; - flatchrg.fill(HIST("Events/selection"), 1.); + bool isAcceptedEvent = false; + flatchrg.fill(HIST("Events/selection"), 1.); - if (collision.sel8()) { - isAcceptedEvent = true; - } + if (collision.sel8()) { + isAcceptedEvent = true; + } - if (!isAcceptedEvent) { - return; - } + if (!isAcceptedEvent) { + return; + } - flatchrg.fill(HIST("Events/selection"), 2.); + flatchrg.fill(HIST("Events/selection"), 2.); - auto vtxZ = collision.posZ(); - flatchrg.fill(HIST("Tracks/VtxZ"), vtxZ); + auto vtxZ = collision.posZ(); + flatchrg.fill(HIST("Tracks/VtxZ"), vtxZ); - bool isGoodEvent = false; - if (vtxZ > cutVtxzMin && vtxZ < cutVtxzMax) { - isGoodEvent = true; - } + bool isGoodEvent = false; + if (vtxZ > cutVtxzMin && vtxZ < cutVtxzMax) { + isGoodEvent = true; + } - if (!isGoodEvent) { - return; - } + if (!isGoodEvent) { + return; + } - flatchrg.fill(HIST("Events/selection"), 3.); + flatchrg.fill(HIST("Events/selection"), 3.); //__________ FT0 mult. esimator // @@ -344,7 +343,7 @@ void process(CollisionTableData::iterator const& collision, TrackTableData const flatenicity_fv0 = GetFlatenicity(RhoLattice, nCells); } - flatchrg.fill(HIST("h1flatencityFV0"), 1.-flatenicity_fv0); + flatchrg.fill(HIST("h1flatencityFV0"), 1. - flatenicity_fv0); flatchrg.fill(HIST("hMultFV0"), sumAmpFV0); flatchrg.fill(HIST("hMultFV01to4Ring"), sumAmpFV01to4Ring); @@ -353,7 +352,7 @@ void process(CollisionTableData::iterator const& collision, TrackTableData const if (selt0vtx && !isOkvtxtrig && !isOkFV0OrA) { return; } - if (selt0time && !isOkTimeFT0) {// to reduce beam-gas background + if (selt0time && !isOkTimeFT0) { // to reduce beam-gas background return; } if (sel8 && !collision.sel8()) { @@ -412,13 +411,12 @@ void process(CollisionTableData::iterator const& collision, TrackTableData const flatchrg.fill(HIST("hFT0C"), amplitude); } flatchrg.fill(HIST("hMultFT0Csel"), sumAmpFT0Csel); - } float flatenicity_t0a = GetFlatenicity(RhoLatticeT0A, nCellsT0A); float flatenicity_t0c = GetFlatenicity(RhoLatticeT0C, nCellsT0C); - flatchrg.fill(HIST("h1flatencityFT0A"), 1.-flatenicity_t0a); - flatchrg.fill(HIST("h1flatencityFT0C"), 1.-flatenicity_t0c); + flatchrg.fill(HIST("h1flatencityFT0A"), 1. - flatenicity_t0a); + flatchrg.fill(HIST("h1flatencityFT0C"), 1. - flatenicity_t0c); //__________ FLATTENICITY - combined @@ -446,26 +444,25 @@ void process(CollisionTableData::iterator const& collision, TrackTableData const for (int ie = 0; ie < nEta; ++ie) { if (meanMultV0A > 0 && meanMultT0C > 0) { combest += ampl[ie] * weightsEta[ie] / deltaEeta[ie]; - } - else{ + } else { combest += ampl[ie] * factebye[ie] / deltaEeta[ie]; } - all_weights += weightsEta[ie]; - } - combest /= all_weights; + all_weights += weightsEta[ie]; + } + combest /= all_weights; } } flatchrg.fill(HIST("hFV0FT0C"), combest); for (auto& track : tracks) { - //if (!track.isGlobalTrack()) { + // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { - continue; + continue; } if (!track.isPVContributor()) { - continue; + continue; } flatchrg.fill(HIST("Tracks/EtaGlobal"), track.eta()); @@ -477,17 +474,14 @@ void process(CollisionTableData::iterator const& collision, TrackTableData const flatchrg.fill(HIST("Tracks/PhiEtaGlobal"), phi, track.eta()); flatchrg.fill(HIST("hPtVsFV0FT0C"), combest, track.pt()); - flatchrg.fill(HIST("hPtVs1flatencityFV0"), 1.-flatenicity_fv0, track.pt()); + flatchrg.fill(HIST("hPtVs1flatencityFV0"), 1. - flatenicity_fv0, track.pt()); } - -} - + } }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ -// adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc) - }; + // adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; } From dea893a2cbdcb378d84cf744574b43c1825459f6 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 19 Jan 2024 16:37:23 +0100 Subject: [PATCH 04/17] PWGMM: Added workflow of charged-particle flattenicity --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 227 ++++++++++++++++---------- 1 file changed, 140 insertions(+), 87 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index 2eadb0297c9..012ca33e225 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -1,6 +1,6 @@ // Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright +// holders. All rights not expressly granted are reserved. // // This software is distributed under the terms of the GNU General Public // License v3 (GPL Version 3), copied verbatim in the file "COPYING". @@ -10,32 +10,32 @@ // or submit itself to any jurisdiction. // /// \file flatenicty-chrg.cxx -/// \author Gyula Bencedi (gyula.bencedi@cern.ch), Antonio Ortiz (antonio.ortiz@cern.ch) -/// \brief Task to produce inclusive charged particle pT distributions as a function of charged-particle flattenicity -/// \since 2023 +/// \author Gyula Bencedi (gyula.bencedi@cern.ch), Antonio Ortiz +/// (antonio.ortiz@cern.ch) \brief Task to produce inclusive charged particle pT +/// distributions as a function of charged-particle flattenicity \since 2023 #include #include -#include #include +#include +#include "EventFiltering/filterTables.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" #include "Framework/StaticFor.h" #include "Framework/runDataProcessing.h" -#include "EventFiltering/filterTables.h" #include "CCDB/BasicCCDBManager.h" #include "CCDB/CcdbApi.h" -#include "DataFormatsFT0/Digit.h" -#include "ReconstructionDataFormats/Track.h" #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "DataFormatsFT0/Digit.h" +#include "ReconstructionDataFormats/Track.h" using namespace o2; using namespace o2::framework; @@ -48,15 +48,19 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { - HistogramRegistry flatchrg{"flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry flatchrg{ + "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; TrackSelection mTrackSelector; Configurable cutTrkEta{"cutTrkEta", 0.8f, "Eta range for tracks"}; Configurable cutTrkPtMin{"cutTrkPtMin", 0.15f, "Minimum pT of tracks"}; - // Configurable cutTrkMult{"cutTrkMult", 200, "max measured multiplicity"}; - Configurable cutVtxzMin{"cutVtxzMin", -10.f, "Minimum value for z-vertex"}; - Configurable cutVtxzMax{"cutVtxzMax", 10.f, "Maximum value for z-vertex"}; + // Configurable cutTrkMult{"cutTrkMult", 200, "max measured + // multiplicity"}; + Configurable cutVtxzMin{"cutVtxzMin", -10.f, + "Minimum value for z-vertex"}; + Configurable cutVtxzMax{"cutVtxzMax", 10.f, + "Maximum value for z-vertex"}; ConfigurableAxis multBins{"multBins", {1001, -0.5, 1000.5}, ""}; @@ -68,19 +72,20 @@ struct FlattenictyCharged { Configurable avPyT0C{"avPyT0C", 8.83, "nch from pythia T0C"}; Configurable avPyFV0{"avPyFV0", 21.44, "nch from pythia FV0"}; - Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", "URL of the CCDB database"}; + Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", + "URL of the CCDB database"}; o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext&) - { + void init(InitContext &) { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); ccdb->setLocalObjectValidityChecking(); if (!ccdbApi.isHostReachable()) { - LOGF(fatal, "CCDB host %s is not reacheable, cannot go forward", url.value.data()); + LOGF(fatal, "CCDB host %s is not reacheable, cannot go forward", + url.value.data()); } mTrackSelector.SetPtRange(0.15f, 1e10f); @@ -92,80 +97,121 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsTPC(70); mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); - mTrackSelector.SetRequireHitsInITSLayers(1, {0, 1}); // one hit in any SPD layer + mTrackSelector.SetRequireHitsInITSLayers( + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, - 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, - 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, - 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, - 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, - 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, - 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; const AxisSpec EtaAxisGlobal = {50, -5.0, 5.0}; const AxisSpec EtaAxis = {20, 2.2, 5.1}; // FV0 - // const AxisSpec FlatAxis = {102, -0.01, +1.01}; + // const AxisSpec FlatAxis = {102, -0.01, +1.01}; const AxisSpec CombEstAxis = {500, -0.5, 499.5}; AxisSpec MultAxis = {multBins, "N_{trk}"}; - flatchrg.add("hMultFV0", "hMultFV0", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude"}}); - flatchrg.add("hMultFV01to4Ring", "hMultFV01to4Ring", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); - flatchrg.add("hMultFV05Ring", "hMultFV05Ring", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); - - flatchrg.add("hMultFV0sel", "hMultFV0sel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude"}}); - flatchrg.add("hMultFV01to4Ringsel", "hMultFV01to4Ringsel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); - flatchrg.add("hMultFV05Ringsel", "hMultFV05Ringsel", HistType::kTH1F, {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); - - flatchrg.add("hT0C_time", "T0C_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); - flatchrg.add("hT0A_time", "T0A_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); - flatchrg.add("hT0C_time_sel", "T0C_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); - flatchrg.add("hT0A_time_sel", "T0A_time", HistType::kTH1F, {{160, -40., 40., "FT0C time"}}); - - flatchrg.add("hAmpT0AVsCh", "", HistType::kTH2F, {{24, -0.5, 23.5, "ch"}, {600, -0.5, +5999.5, "FT0A amplitude vs channel"}}); - flatchrg.add("hFT0A", "FT0A", HistType::kTH1F, {{600, -0.5, 599.5, "FT0A amplitudes"}}); - - flatchrg.add("hAmpT0CVsCh", "", HistType::kTH2F, {{28, -0.5, 27.5, "ch"}, {600, -0.5, +5999.5, "FT0C amplitude vs channel"}}); - flatchrg.add("hFT0C", "FT0C", HistType::kTH1F, {{600, -0.5, 599.5, "FT0C amplitudes"}}); - - flatchrg.add("hMultFT0C", "hMultFT0C", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0C amplitude"}}); - flatchrg.add("hMultFT0Csel", "hMultFT0C", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0C amplitude"}}); - flatchrg.add("hMultFT0A", "hMultFT0A", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0A amplitude"}}); - flatchrg.add("hMultFT0Asel", "hMultFT0A", HistType::kTH1F, {{600, -0.5, 5999.5, "FT0A amplitude"}}); - - flatchrg.add("h1flatencityFV0", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFV0"}}); - flatchrg.add("h1flatencityFT0A", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFT0A"}}); - flatchrg.add("h1flatencityFT0C", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFT0C"}}); - flatchrg.add("h1flatencityFV0FT0C", "", HistType::kTH1F, {{102, -0.01, 1.01, "1-flatencityFV0FT0C"}}); - flatchrg.add("hFV0FT0C", "", HistType::kTH1F, {{102, -0.5, 499.5, "FV0_FT0C"}}); - - flatchrg.add("hPtVsFV0FT0C", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", HistType::kTH2F, {{500, -0.5, 499.5, "fv0ft0c"}, {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); - flatchrg.add("hPtVs1flatencityFV0", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", HistType::kTH2F, {{102, -0.01, 1.01, "1flatFV0"}, {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); + flatchrg.add("hMultFV0", "hMultFV0", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude"}}); + flatchrg.add("hMultFV01to4Ring", "hMultFV01to4Ring", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); + flatchrg.add("hMultFV05Ring", "hMultFV05Ring", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); + + flatchrg.add("hMultFV0sel", "hMultFV0sel", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude"}}); + flatchrg.add("hMultFV01to4Ringsel", "hMultFV01to4Ringsel", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude (rings 1-4)"}}); + flatchrg.add("hMultFV05Ringsel", "hMultFV05Ringsel", HistType::kTH1F, + {{1000, -0.5, 99999.5, "FV0 amplitude (ring 5)"}}); + + flatchrg.add("hT0C_time", "T0C_time", HistType::kTH1F, + {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0A_time", "T0A_time", HistType::kTH1F, + {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0C_time_sel", "T0C_time", HistType::kTH1F, + {{160, -40., 40., "FT0C time"}}); + flatchrg.add("hT0A_time_sel", "T0A_time", HistType::kTH1F, + {{160, -40., 40., "FT0C time"}}); + + flatchrg.add("hAmpT0AVsCh", "", HistType::kTH2F, + {{24, -0.5, 23.5, "ch"}, + {600, -0.5, +5999.5, "FT0A amplitude vs channel"}}); + flatchrg.add("hFT0A", "FT0A", HistType::kTH1F, + {{600, -0.5, 599.5, "FT0A amplitudes"}}); + + flatchrg.add("hAmpT0CVsCh", "", HistType::kTH2F, + {{28, -0.5, 27.5, "ch"}, + {600, -0.5, +5999.5, "FT0C amplitude vs channel"}}); + flatchrg.add("hFT0C", "FT0C", HistType::kTH1F, + {{600, -0.5, 599.5, "FT0C amplitudes"}}); + + flatchrg.add("hMultFT0C", "hMultFT0C", HistType::kTH1F, + {{600, -0.5, 5999.5, "FT0C amplitude"}}); + flatchrg.add("hMultFT0Csel", "hMultFT0C", HistType::kTH1F, + {{600, -0.5, 5999.5, "FT0C amplitude"}}); + flatchrg.add("hMultFT0A", "hMultFT0A", HistType::kTH1F, + {{600, -0.5, 5999.5, "FT0A amplitude"}}); + flatchrg.add("hMultFT0Asel", "hMultFT0A", HistType::kTH1F, + {{600, -0.5, 5999.5, "FT0A amplitude"}}); + + flatchrg.add("h1flatencityFV0", "", HistType::kTH1F, + {{102, -0.01, 1.01, "1-flatencityFV0"}}); + flatchrg.add("h1flatencityFT0A", "", HistType::kTH1F, + {{102, -0.01, 1.01, "1-flatencityFT0A"}}); + flatchrg.add("h1flatencityFT0C", "", HistType::kTH1F, + {{102, -0.01, 1.01, "1-flatencityFT0C"}}); + flatchrg.add("h1flatencityFV0FT0C", "", HistType::kTH1F, + {{102, -0.01, 1.01, "1-flatencityFV0FT0C"}}); + flatchrg.add("hFV0FT0C", "", HistType::kTH1F, + {{102, -0.5, 499.5, "FV0_FT0C"}}); + + flatchrg.add("hPtVsFV0FT0C", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", + HistType::kTH2F, + {{500, -0.5, 499.5, "fv0ft0c"}, + {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); + flatchrg.add("hPtVs1flatencityFV0", " ; #it{p}_{T} (GeV/#it{c}); FV0_FT0C", + HistType::kTH2F, + {{102, -0.01, 1.01, "1flatFV0"}, + {100, -0.5, 99.5, "#it{p}_{T} (GeV/#it{c})"}}); // event level histos - flatchrg.add({"Events/selection", ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); + flatchrg.add({"Events/selection", + ";status;events", + {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); x->SetBinLabel(4, "Selected INEL>0"); // track level histos - flatchrg.add({"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); - flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); - flatchrg.add({"Tracks/EtaGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH1F, {EtaAxisGlobal}}}); - flatchrg.add({"Tracks/PhiEtaGlobal", "; #varphi; #eta; tracks", {HistType::kTH2F, {PhiAxis, EtaAxisGlobal}}}); - flatchrg.add({"Tracks/PtEtaGlobal", " ; #it{p}_{T} (GeV/#it{c}); #eta", {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); + flatchrg.add( + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + flatchrg.add({"Tracks/EtaVtxZGlobal", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); + flatchrg.add({"Tracks/EtaGlobal", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH1F, {EtaAxisGlobal}}}); + flatchrg.add({"Tracks/PhiEtaGlobal", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxisGlobal}}}); + flatchrg.add({"Tracks/PtEtaGlobal", + " ; #it{p}_{T} (GeV/#it{c}); #eta", + {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) - { + int getT0ASector(int i_ch) { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -176,8 +222,7 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) - { + int getT0CSector(int i_ch) { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -188,8 +233,7 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) - { + float GetFlatenicity(float signals[], int entries) { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -213,26 +257,35 @@ struct FlattenictyCharged { return flat; } - Filter trackFilter = (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); - using TrackTableData = soa::Filtered>; + Filter trackFilter = + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + using TrackTableData = + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const& collision, TrackTableData const& tracks, soa::Join const& bcs, /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, aod::FV0As const& fv0s) - { + void process(CollisionTableData::iterator const &collision, + TrackTableData const &tracks, + soa::Join const &bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, + aod::FV0As const &fv0s) { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; - auto vMeanMultT0C = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0C", bc.timestamp()); + auto vMeanMultT0C = ccdb->getForTimeStamp>( + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; - // auto vMeanMultT0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0A", bc.timestamp()); - // meanMultT0A = (*vMeanMultT0A)[0]; + // auto vMeanMultT0A = + // ccdb->getForTimeStamp>("Users/e/ekryshen/meanT0A", + // bc.timestamp()); meanMultT0A = (*vMeanMultT0A)[0]; meanMultV0A = 0.f; - auto vMeanMultV0A = ccdb->getForTimeStamp>("Users/e/ekryshen/meanV0A", bc.timestamp()); + auto vMeanMultV0A = ccdb->getForTimeStamp>( + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -423,7 +476,8 @@ struct FlattenictyCharged { float combest = 0.; // option 1 - flatchrg.fill(HIST("h1flatencityFV0FT0C"), (1.0 - (flatenicity_fv0 + flatenicity_t0c) / 2.0)); + flatchrg.fill(HIST("h1flatencityFV0FT0C"), + (1.0 - (flatenicity_fv0 + flatenicity_t0c) / 2.0)); // option 2 const int nEta = 2; // FT0C + FV0 @@ -455,7 +509,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto& track : tracks) { + for (auto &track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -474,14 +528,13 @@ struct FlattenictyCharged { flatchrg.fill(HIST("Tracks/PhiEtaGlobal"), phi, track.eta()); flatchrg.fill(HIST("hPtVsFV0FT0C"), combest, track.pt()); - flatchrg.fill(HIST("hPtVs1flatencityFV0"), 1. - flatenicity_fv0, track.pt()); + flatchrg.fill(HIST("hPtVs1flatencityFV0"), 1. - flatenicity_fv0, + track.pt()); } } }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - // adaptAnalysisTask(cfgc), - adaptAnalysisTask(cfgc)}; +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { + return WorkflowSpec{// adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; } From 1c64ffa8e1a8302ecf69d82b066cbf3f559f48e9 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 19 Jan 2024 15:41:41 +0000 Subject: [PATCH 05/17] MegaLinter fixes --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 62 ++++++++++++++++----------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index 012ca33e225..c71ea992614 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -49,7 +49,11 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { HistogramRegistry flatchrg{ - "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "flatchrg", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; TrackSelection mTrackSelector; @@ -78,7 +82,8 @@ struct FlattenictyCharged { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext &) { + void init(InitContext&) + { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); @@ -98,18 +103,18 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); mTrackSelector.SetRequireHitsInITSLayers( - 1, {0, 1}); // one hit in any SPD layer + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, - 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, - 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, - 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, - 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, - 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; @@ -188,7 +193,7 @@ struct FlattenictyCharged { ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); @@ -196,7 +201,7 @@ struct FlattenictyCharged { // track level histos flatchrg.add( - {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); @@ -211,7 +216,8 @@ struct FlattenictyCharged { {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) { + int getT0ASector(int i_ch) + { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -222,7 +228,8 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) { + int getT0CSector(int i_ch) + { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -233,7 +240,8 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) { + float GetFlatenicity(float signals[], int entries) + { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -258,24 +266,25 @@ struct FlattenictyCharged { } Filter trackFilter = - (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = - soa::Filtered>; + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const &collision, - TrackTableData const &tracks, - soa::Join const &bcs, - /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, - aod::FV0As const &fv0s) { + void process(CollisionTableData::iterator const& collision, + TrackTableData const& tracks, + soa::Join const& bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, + aod::FV0As const& fv0s) + { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; auto vMeanMultT0C = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanT0C", bc.timestamp()); + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; @@ -285,7 +294,7 @@ struct FlattenictyCharged { meanMultV0A = 0.f; auto vMeanMultV0A = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanV0A", bc.timestamp()); + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -509,7 +518,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto &track : tracks) { + for (auto& track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -534,7 +543,8 @@ struct FlattenictyCharged { } }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{// adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From 0ae2c83fb80b7845008d52c21077d4a815a67bf1 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Sat, 20 Jan 2024 10:37:16 +0100 Subject: [PATCH 06/17] PWGMM: Added workflow of charged-particle flattenicity --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 63 +++++++++++---------------- 1 file changed, 26 insertions(+), 37 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index c71ea992614..fb04b3bb71d 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -49,11 +49,7 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { HistogramRegistry flatchrg{ - "flatchrg", - {}, - OutputObjHandlingPolicy::AnalysisObject, - true, - true}; + "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; TrackSelection mTrackSelector; @@ -82,8 +78,7 @@ struct FlattenictyCharged { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext&) - { + void init(InitContext &) { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); @@ -103,24 +98,23 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); mTrackSelector.SetRequireHitsInITSLayers( - 1, {0, 1}); // one hit in any SPD layer + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, - 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, - 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, - 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, - 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, - 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; const AxisSpec EtaAxisGlobal = {50, -5.0, 5.0}; const AxisSpec EtaAxis = {20, 2.2, 5.1}; // FV0 - // const AxisSpec FlatAxis = {102, -0.01, +1.01}; const AxisSpec CombEstAxis = {500, -0.5, 499.5}; AxisSpec MultAxis = {multBins, "N_{trk}"}; @@ -193,7 +187,7 @@ struct FlattenictyCharged { ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); @@ -201,7 +195,7 @@ struct FlattenictyCharged { // track level histos flatchrg.add( - {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); @@ -216,8 +210,7 @@ struct FlattenictyCharged { {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) - { + int getT0ASector(int i_ch) { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -228,8 +221,7 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) - { + int getT0CSector(int i_ch) { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -240,8 +232,7 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) - { + float GetFlatenicity(float signals[], int entries) { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -266,25 +257,24 @@ struct FlattenictyCharged { } Filter trackFilter = - (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = - soa::Filtered>; + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const& collision, - TrackTableData const& tracks, - soa::Join const& bcs, - /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, - aod::FV0As const& fv0s) - { + void process(CollisionTableData::iterator const &collision, + TrackTableData const &tracks, + soa::Join const &bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, + aod::FV0As const &fv0s) { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; auto vMeanMultT0C = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanT0C", bc.timestamp()); + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; @@ -294,7 +284,7 @@ struct FlattenictyCharged { meanMultV0A = 0.f; auto vMeanMultV0A = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanV0A", bc.timestamp()); + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -518,7 +508,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto& track : tracks) { + for (auto &track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -543,8 +533,7 @@ struct FlattenictyCharged { } }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { return WorkflowSpec{// adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From f579c2809fc2f5d03af43d404730f4a9c4e5724f Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Sat, 20 Jan 2024 09:42:01 +0000 Subject: [PATCH 07/17] MegaLinter fixes --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 62 ++++++++++++++++----------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index fb04b3bb71d..fa50459aa90 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -49,7 +49,11 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { HistogramRegistry flatchrg{ - "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "flatchrg", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; TrackSelection mTrackSelector; @@ -78,7 +82,8 @@ struct FlattenictyCharged { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext &) { + void init(InitContext&) + { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); @@ -98,18 +103,18 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); mTrackSelector.SetRequireHitsInITSLayers( - 1, {0, 1}); // one hit in any SPD layer + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, - 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, - 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, - 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, - 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, - 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; @@ -187,7 +192,7 @@ struct FlattenictyCharged { ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); @@ -195,7 +200,7 @@ struct FlattenictyCharged { // track level histos flatchrg.add( - {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); @@ -210,7 +215,8 @@ struct FlattenictyCharged { {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) { + int getT0ASector(int i_ch) + { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -221,7 +227,8 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) { + int getT0CSector(int i_ch) + { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -232,7 +239,8 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) { + float GetFlatenicity(float signals[], int entries) + { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -257,24 +265,25 @@ struct FlattenictyCharged { } Filter trackFilter = - (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = - soa::Filtered>; + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const &collision, - TrackTableData const &tracks, - soa::Join const &bcs, - /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, - aod::FV0As const &fv0s) { + void process(CollisionTableData::iterator const& collision, + TrackTableData const& tracks, + soa::Join const& bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, + aod::FV0As const& fv0s) + { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; auto vMeanMultT0C = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanT0C", bc.timestamp()); + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; @@ -284,7 +293,7 @@ struct FlattenictyCharged { meanMultV0A = 0.f; auto vMeanMultV0A = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanV0A", bc.timestamp()); + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -508,7 +517,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto &track : tracks) { + for (auto& track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -533,7 +542,8 @@ struct FlattenictyCharged { } }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{// adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From cee5cc4a194c785712084bd43ea2017141109d87 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Sat, 20 Jan 2024 10:56:26 +0100 Subject: [PATCH 08/17] fixing copyright headers --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index fa50459aa90..271e1fc9bf1 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -1,6 +1,6 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright -// holders. All rights not expressly granted are reserved. +// Copyright 2020-2022 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. // // This software is distributed under the terms of the GNU General Public // License v3 (GPL Version 3), copied verbatim in the file "COPYING". @@ -8,11 +8,14 @@ // In applying this license CERN does not waive the privileges and immunities // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. + +// \file flatenicty-chrg.cxx +// \author Gyula Bencedi +// +// \brief Task to produce inclusive charged particle pT +// distributions as a function of charged-particle flattenicity // -/// \file flatenicty-chrg.cxx -/// \author Gyula Bencedi (gyula.bencedi@cern.ch), Antonio Ortiz -/// (antonio.ortiz@cern.ch) \brief Task to produce inclusive charged particle pT -/// distributions as a function of charged-particle flattenicity \since 2023 +// \since 2024 #include #include From 4e202d5f406f7b5fc3e1e05115ac8bcec71ed587 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Sat, 20 Jan 2024 11:07:37 +0100 Subject: [PATCH 09/17] fixing whitespace errors --- PWGMM/Mult/Tasks/CMakeLists.txt | 2 +- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 62 +++++++++++---------------- 2 files changed, 27 insertions(+), 37 deletions(-) diff --git a/PWGMM/Mult/Tasks/CMakeLists.txt b/PWGMM/Mult/Tasks/CMakeLists.txt index 70d160fa18a..fe4722abe80 100644 --- a/PWGMM/Mult/Tasks/CMakeLists.txt +++ b/PWGMM/Mult/Tasks/CMakeLists.txt @@ -68,4 +68,4 @@ o2physics_add_dpl_workflow(multiplicity-pb-pb o2physics_add_dpl_workflow(flattenicty-chrg SOURCES flattenicty-chrg.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore - COMPONENT_NAME Analysis) + COMPONENT_NAME Analysis) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index 271e1fc9bf1..0d4869e7372 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -52,11 +52,7 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { HistogramRegistry flatchrg{ - "flatchrg", - {}, - OutputObjHandlingPolicy::AnalysisObject, - true, - true}; + "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; TrackSelection mTrackSelector; @@ -85,8 +81,7 @@ struct FlattenictyCharged { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext&) - { + void init(InitContext &) { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); @@ -106,18 +101,18 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); mTrackSelector.SetRequireHitsInITSLayers( - 1, {0, 1}); // one hit in any SPD layer + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, - 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, - 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, - 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, - 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, - 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; @@ -195,7 +190,7 @@ struct FlattenictyCharged { ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); @@ -203,7 +198,7 @@ struct FlattenictyCharged { // track level histos flatchrg.add( - {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); @@ -218,8 +213,7 @@ struct FlattenictyCharged { {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) - { + int getT0ASector(int i_ch) { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -230,8 +224,7 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) - { + int getT0CSector(int i_ch) { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -242,8 +235,7 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) - { + float GetFlatenicity(float signals[], int entries) { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -268,25 +260,24 @@ struct FlattenictyCharged { } Filter trackFilter = - (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = - soa::Filtered>; + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const& collision, - TrackTableData const& tracks, - soa::Join const& bcs, - /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, - aod::FV0As const& fv0s) - { + void process(CollisionTableData::iterator const &collision, + TrackTableData const &tracks, + soa::Join const &bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, + aod::FV0As const &fv0s) { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; auto vMeanMultT0C = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanT0C", bc.timestamp()); + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; @@ -296,7 +287,7 @@ struct FlattenictyCharged { meanMultV0A = 0.f; auto vMeanMultV0A = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanV0A", bc.timestamp()); + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -520,7 +511,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto& track : tracks) { + for (auto &track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -545,8 +536,7 @@ struct FlattenictyCharged { } }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { return WorkflowSpec{// adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From 5846a7ece796dae230f4169a5008f8f47a43bc15 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Sat, 20 Jan 2024 10:11:29 +0000 Subject: [PATCH 10/17] MegaLinter fixes --- PWGMM/Mult/Tasks/flattenicty-chrg.cxx | 62 ++++++++++++++++----------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx index 0d4869e7372..271e1fc9bf1 100644 --- a/PWGMM/Mult/Tasks/flattenicty-chrg.cxx +++ b/PWGMM/Mult/Tasks/flattenicty-chrg.cxx @@ -52,7 +52,11 @@ float meanMultV0A = 0.f; struct FlattenictyCharged { HistogramRegistry flatchrg{ - "flatchrg", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + "flatchrg", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; TrackSelection mTrackSelector; @@ -81,7 +85,8 @@ struct FlattenictyCharged { o2::ccdb::CcdbApi ccdbApi; Service ccdb; - void init(InitContext &) { + void init(InitContext&) + { ccdbApi.init(o2::base::NameConf::getCCDBServer()); ccdb->setURL(url.value); // ccdb->setCaching(true); @@ -101,18 +106,18 @@ struct FlattenictyCharged { mTrackSelector.SetMinNCrossedRowsOverFindableClustersTPC(0.8f); mTrackSelector.SetMaxChi2PerClusterTPC(4.f); mTrackSelector.SetRequireHitsInITSLayers( - 1, {0, 1}); // one hit in any SPD layer + 1, {0, 1}); // one hit in any SPD layer mTrackSelector.SetMaxChi2PerClusterITS(36.f); mTrackSelector.SetMaxDcaXY(1.f); mTrackSelector.SetMaxDcaZ(1.f); std::vector ptBinEdges = { - 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, - 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, - 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, - 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, - 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, - 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; + 0.0, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, + 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, + 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, + 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, + 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, + 18.0, 20.0, 22.0, 24.0, 26.0, 30.0}; const AxisSpec PtAxis{ptBinEdges, "#it{p}_{T} (GeV/#it{c})", "pt"}; const AxisSpec ZAxis = {40, -20.0, 20.0}; const AxisSpec PhiAxis = {600, 0, 2 * M_PI}; @@ -190,7 +195,7 @@ struct FlattenictyCharged { ";status;events", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hstat = flatchrg.get(HIST("Events/selection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected trigger"); x->SetBinLabel(3, "Selected zvtx"); @@ -198,7 +203,7 @@ struct FlattenictyCharged { // track level histos flatchrg.add( - {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); + {"Tracks/VtxZ", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); flatchrg.add({"Tracks/EtaVtxZGlobal", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxisGlobal, ZAxis}}}); @@ -213,7 +218,8 @@ struct FlattenictyCharged { {HistType::kTH2F, {PtAxis, EtaAxisGlobal}}}); } - int getT0ASector(int i_ch) { + int getT0ASector(int i_ch) + { int i_sec_t0a = -1; for (int i_sec = 0; i_sec < 24; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -224,7 +230,8 @@ struct FlattenictyCharged { return i_sec_t0a; } - int getT0CSector(int i_ch) { + int getT0CSector(int i_ch) + { int i_sec_t0c = -1; for (int i_sec = 0; i_sec < 28; ++i_sec) { if (i_ch >= 4 * i_sec && i_ch <= 3 + 4 * i_sec) { @@ -235,7 +242,8 @@ struct FlattenictyCharged { return i_sec_t0c; } - float GetFlatenicity(float signals[], int entries) { + float GetFlatenicity(float signals[], int entries) + { float flat = 9999; float mRho = 0; for (int iCell = 0; iCell < entries; ++iCell) { @@ -260,24 +268,25 @@ struct FlattenictyCharged { } Filter trackFilter = - (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); + (nabs(aod::track::eta) < cutTrkEta) && (aod::track::pt > cutTrkPtMin); using TrackTableData = - soa::Filtered>; + soa::Filtered>; using CollisionTableData = soa::Join; - void process(CollisionTableData::iterator const &collision, - TrackTableData const &tracks, - soa::Join const &bcs, - /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const &ft0s, - aod::FV0As const &fv0s) { + void process(CollisionTableData::iterator const& collision, + TrackTableData const& tracks, + soa::Join const& bcs, + /*aod::MFTTracks const& mfttracks,*/ aod::FT0s const& ft0s, + aod::FV0As const& fv0s) + { LOGF(debug, " Collision %d", collision.globalIndex()); auto bc = collision.template bc_as(); meanMultT0C = 0.f; auto vMeanMultT0C = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanT0C", bc.timestamp()); + "Users/e/ekryshen/meanT0C", bc.timestamp()); meanMultT0C = (*vMeanMultT0C)[0]; // meanMultT0A = 0.f; @@ -287,7 +296,7 @@ struct FlattenictyCharged { meanMultV0A = 0.f; auto vMeanMultV0A = ccdb->getForTimeStamp>( - "Users/e/ekryshen/meanV0A", bc.timestamp()); + "Users/e/ekryshen/meanV0A", bc.timestamp()); meanMultV0A = (*vMeanMultV0A)[0]; // float fac_FT0A_ebe = 1.; @@ -511,7 +520,7 @@ struct FlattenictyCharged { flatchrg.fill(HIST("hFV0FT0C"), combest); - for (auto &track : tracks) { + for (auto& track : tracks) { // if (!track.isGlobalTrack()) { if (!mTrackSelector.IsSelected(track)) { continue; @@ -536,7 +545,8 @@ struct FlattenictyCharged { } }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{// adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } From 541786cd220d75a6358d2886e9accfae4f8e91f5 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 14 Feb 2024 20:47:52 +0100 Subject: [PATCH 11/17] PWGMM: Added process function for centrality in MC --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 100 ++++++++++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 5 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index f9ffe3aa270..32617201888 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -47,7 +47,7 @@ using namespace o2::aod::track; AxisSpec PtAxis = {1001, -0.005, 10.005}; AxisSpec DeltaZAxis = {61, -6.1, 6.1}; AxisSpec ZAxis = {301, -30.1, 30.1}; -AxisSpec PhiAxis = {600, 0, 2 * M_PI}; +AxisSpec PhiAxis = {629, 0, 2 * M_PI, "Rad", "phi axis"}; AxisSpec EtaAxis = {18, -4.6, -1.}; AxisSpec DCAxyAxis = {100, -1, 10}; AxisSpec CentAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; @@ -81,6 +81,9 @@ struct PseudorapidityDensityMFT { Configurable useZDiffCut{"useZDiffCut", true, "use Z difference cut"}; Configurable maxZDiff{"maxZDiff", 1.0f, "max allowed Z difference for reconstruced collisions (cm)"}; + + Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; + //-----need access to CCDB to get the reweighting histogram Service ccdb; Configurable path{"ccdb-path", "Users/s/sherrman/My/Object", "base path to the ccdb object"}; @@ -188,6 +191,22 @@ struct PseudorapidityDensityMFT { registry.add({"Tracks/Centrality/Control/ReassignedTracksPhiEta", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); registry.add({"Tracks/Centrality/Control/ReassignedVertexCorr", "; Z_{vtx}^{orig} (cm); Z_{vtx}^{re} (cm); centrality", {HistType::kTH3F, {ZAxis, ZAxis, CentAxis}}}); } + + if (doprocessGenCent) { + registry.add({"Events/Centrality/EventEfficiency", ";status;centrality;events", {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); + auto heff = registry.get(HIST("Events/Centrality/EventEfficiency")); + auto *x = heff->GetXaxis(); + x->SetBinLabel(1, "Generated"); + x->SetBinLabel(2, "Selected"); + + registry.add("Events/Centrality/CentPercentileMCGen", "CentPercentileMCGen", kTH1D, {CentAxis}, false); + registry.add({"Events/Centrality/NtrkZvtxGen", "; N_{trk}; Z_{vtx} (cm); centrality", {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + registry.add({"Events/Centrality/NtrkZvtxGen_t", "; N_{trk}; Z_{vtx} (cm); centrality", {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxRec", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen_t", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/PhiEtaGen", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + } } using FullBCs = soa::Join; @@ -264,13 +283,18 @@ struct PseudorapidityDensityMFT { if (tracks.size() > 0) { for (auto& track : tracks) { + + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + + if( (phiM_PI-cfgPhiCut) && (phi2.*M_PI-cfgPhiCut) || (phi>((M_PI/2.-0.1)*M_PI)-cfgPhiCut)&&(phi<((M_PI/2.-0.1)*M_PI)+cfgPhiCut) ) + continue; + registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); if (midtracks.size() > 0) // INEL>0 { registry.fill(HIST("Tracks/EtaZvtx_gt0"), track.eta(), z); } - float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); registry.fill(HIST("TracksPhiEta"), phi, track.eta()); registry.fill(HIST("TracksPtEta"), track.pt(), track.eta()); if ((track.eta() < -2.0f) && (track.eta() > -3.9f)) { @@ -364,8 +388,12 @@ struct PseudorapidityDensityMFT { for (auto& track : tracks) { - float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + + if( (phiM_PI-cfgPhiCut) && (phi2.*M_PI-cfgPhiCut) || (phi>((M_PI/2.-0.1)*M_PI)-cfgPhiCut)&&(phi<((M_PI/2.-0.1)*M_PI)+cfgPhiCut) ) + continue; + registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c); registry.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), c); } @@ -494,6 +522,68 @@ struct PseudorapidityDensityMFT { PROCESS_SWITCH(PseudorapidityDensityMFT, processGen, "Process generator-level info", false); + void processGenCent(aod::McCollisions::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + Particles const& particles, + MFTTracksLabeled const& tracks) + { + + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + + for (auto& collision : collisions) { + auto c = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EventEfficiency"), 1., c); + +// auto perCollisionMCSample = particles.sliceBy(perMcCol, mcCollision.globalIndex()); + auto perCollisionMCSample = mcSample->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + + auto nCharged = 0; + for (auto& particle : perCollisionMCSample) { + auto p = pdg->GetParticle(particle.pdgCode()); + auto charge = 0; + if (p != nullptr) { + charge = static_cast(p->Charge()); + } + if (std::abs(charge) < 3.) { + continue; + } + nCharged++; + } + registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), c); +// + bool atLeastOne = false; + if (!useEvSel || (useEvSel && collision.sel8())) { + registry.fill(HIST("Events/Centrality/EventEfficiency"), 2., c); + registry.fill(HIST("Events/Centrality/CentPercentileMCGen"), c); + atLeastOne = true; + + auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), perCollisionSample.size(), collision.posZ(), c); + } + + for (auto& particle : particles) { + auto p = pdg->GetParticle(particle.pdgCode()); + auto charge = 0; + if (p != nullptr) { + charge = static_cast(p->Charge()); + } + if (std::abs(charge) < 3.) { + continue; + } + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen_t"), particle.eta(), mcCollision.posZ(), c); + + if(atLeastOne){ + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), mcCollision.posZ(), c); + float phi = particle.phi(); + o2::math_utils::bringTo02Pi(phi); + registry.fill(HIST("Tracks/Centrality/PhiEtaGen"), phi, particle.eta(), c); + } + } + } + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processGenCent, "Process generator-level info in centrality bins", false); + void processGenPt(soa::Join::iterator const& collision, MFTTracksLabeled const& tracks, aod::McParticles const&) { // In the MFT the measurement of pT is not precise, so we access it by using the particle's pT instead From c3309035314be70b9d7edbe4555233e8d6367730 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Thu, 15 Feb 2024 09:35:23 +0100 Subject: [PATCH 12/17] PWGMM: Added process function for centrality in MC gen --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 578 +++++++++++++++++++++----------- 1 file changed, 380 insertions(+), 198 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index 32617201888..6d3afec5e86 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -1,6 +1,6 @@ // Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright +// holders. All rights not expressly granted are reserved. // // This software is distributed under the terms of the GNU General Public // License v3 (GPL Version 3), copied verbatim in the file "COPYING". @@ -17,25 +17,25 @@ #include // for CCDB access -#include #include "CCDB/BasicCCDBManager.h" +#include -#include "Framework/Configurable.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" #include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/O2DatabasePDGPlugin.h" #include "Framework/RuntimeError.h" #include "Framework/runDataProcessing.h" -#include "Framework/O2DatabasePDGPlugin.h" -#include "ReconstructionDataFormats/GlobalTrackID.h" -#include "Common/DataModel/Multiplicity.h" -#include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" #include "CommonConstants/MathConstants.h" -#include "TDatabasePDG.h" #include "MathUtils/Utils.h" +#include "ReconstructionDataFormats/GlobalTrackID.h" +#include "TDatabasePDG.h" #include "bestCollisionTable.h" @@ -53,16 +53,16 @@ AxisSpec DCAxyAxis = {100, -1, 10}; AxisSpec CentAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; static constexpr TrackSelectionFlags::flagtype trackSelectionITS = - TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | - TrackSelectionFlags::kITSHits; + TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | + TrackSelectionFlags::kITSHits; static constexpr TrackSelectionFlags::flagtype trackSelectionTPC = - TrackSelectionFlags::kTPCNCls | - TrackSelectionFlags::kTPCCrossedRowsOverNCls | - TrackSelectionFlags::kTPCChi2NDF; + TrackSelectionFlags::kTPCNCls | + TrackSelectionFlags::kTPCCrossedRowsOverNCls | + TrackSelectionFlags::kTPCChi2NDF; static constexpr TrackSelectionFlags::flagtype trackSelectionDCA = - TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; + TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; using MFTTracksLabeled = soa::Join; @@ -74,52 +74,79 @@ struct PseudorapidityDensityMFT { Service pdg; - Configurable estimatorEta{"estimatorEta", 1.0, "eta range for INEL>0 sample definition"}; + Configurable estimatorEta{"estimatorEta", 1.0, + "eta range for INEL>0 sample definition"}; Configurable useEvSel{"useEvSel", true, "use event selection"}; ConfigurableAxis multBinning{"multBinning", {701, -0.5, 700.5}, ""}; Configurable useZDiffCut{"useZDiffCut", true, "use Z difference cut"}; - Configurable maxZDiff{"maxZDiff", 1.0f, "max allowed Z difference for reconstruced collisions (cm)"}; + Configurable maxZDiff{ + "maxZDiff", 1.0f, + "max allowed Z difference for reconstruced collisions (cm)"}; - Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; + Configurable cfgPhiCut{"cfgPhiCut", 0.1f, + "Cut on azimuthal angle of MFT tracks"}; //-----need access to CCDB to get the reweighting histogram Service ccdb; - Configurable path{"ccdb-path", "Users/s/sherrman/My/Object", "base path to the ccdb object"}; - Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable nolaterthan{"ccdb-no-later-than", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; + Configurable path{"ccdb-path", "Users/s/sherrman/My/Object", + "base path to the ccdb object"}; + Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", + "url of the ccdb repository"}; + Configurable nolaterthan{ + "ccdb-no-later-than", + std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count(), + "latest acceptable timestamp of creation for the object"}; // the histogram has been previously stored in the CCDB - TH1D* histoReweight = nullptr; + TH1D *histoReweight = nullptr; int counter = 0; //------ HistogramRegistry registry{ - "registry", - { - - {"TracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"Tracks/EtaZvtx_gt0", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"TracksPhiEta", "; #varphi; #eta; tracks", {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // - {"TracksPhiZvtx", "; #varphi; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {PhiAxis, ZAxis}}}, // - {"TracksPtEta", " ; p_{T} (GeV/c); #eta", {HistType::kTH2F, {PtAxis, EtaAxis}}}, // - {"EventSelection", ";status;events", {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // + "registry", + { - } // + {"TracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"Tracks/EtaZvtx_gt0", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"TracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // + {"TracksPhiZvtx", + "; #varphi; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {PhiAxis, ZAxis}}}, // + {"TracksPtEta", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}, // + {"EventSelection", + ";status;events", + {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // + + } // }; - void init(InitContext&) - { + void init(InitContext &) { - if (static_cast(doprocessMult) + static_cast(doprocessMultReassoc) + static_cast(doprocessCountingCentrality) > 1) { - LOGP(fatal, "Exactly one process function between processMult, processMultReassoc and processCountingCentrality should be enabled!"); + if (static_cast(doprocessMult) + + static_cast(doprocessMultReassoc) + + static_cast(doprocessCountingCentrality) > + 1) { + LOGP(fatal, "Exactly one process function between processMult, " + "processMultReassoc and processCountingCentrality should be " + "enabled!"); } AxisSpec MultAxis = {multBinning, "N_{trk}"}; // for PbPb 3001,-0.5,3000.5 auto hstat = registry.get(HIST("EventSelection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Selected INEL>0"); @@ -128,27 +155,64 @@ struct PseudorapidityDensityMFT { x->SetBinLabel(6, "BCs with collisions"); x->SetBinLabel(7, "BCs with pile-up/splitting"); - registry.add({"EventsNtrkZvtx", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); - registry.add({"EventsNtrkZvtx_gt0", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"EventsNtrkZvtx", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"EventsNtrkZvtx_gt0", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); if (doprocessGen) { - registry.add({"EventsNtrkZvtxGen", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); - registry.add({"EventsNtrkZvtxGen_t", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); - registry.add({"EventsNtrkZvtxGen_gt0", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); - registry.add({"EventsNtrkZvtxGen_gt0t", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {MultAxis, ZAxis}}}); - registry.add({"TracksEtaZvtxGen", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}); - registry.add({"TracksEtaZvtxGen_t", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}); - registry.add({"TracksEtaZvtxGen_gt0", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}); - registry.add({"TracksEtaZvtxGen_gt0t", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}); - registry.add({"TracksPhiEtaGen", "; #varphi; #eta; tracks", {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - registry.add({"TracksPhiZvtxGen", "; #varphi; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {PhiAxis, ZAxis}}}); // - registry.add({"TracksToPartPtEta", " ; p_{T} (GeV/c); #eta", {HistType::kTH2F, {PtAxis, EtaAxis}}}); // - registry.add({"TracksPtEtaGen", " ; p_{T} (GeV/c); #eta", {HistType::kTH2F, {PtAxis, EtaAxis}}}); - registry.add({"TracksPtEtaGen_t", " ; p_{T} (GeV/c); #eta", {HistType::kTH2F, {PtAxis, EtaAxis}}}); - registry.add({"EventEfficiency", "; status; events", {HistType::kTH1F, {{5, 0.5, 5.5}}}}); - registry.add({"NotFoundEventZvtx", " ; #it{z}_{vtx} (cm)", {HistType::kTH1F, {ZAxis}}}); - registry.add({"EventsZposDiff", " ; Z_{rec} - Z_{gen} (cm)", {HistType::kTH1F, {DeltaZAxis}}}); - registry.add({"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + registry.add({"EventsNtrkZvtxGen", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"EventsNtrkZvtxGen_t", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"EventsNtrkZvtxGen_gt0", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"EventsNtrkZvtxGen_gt0t", + "; N_{trk}; #it{z}_{vtx} (cm); events", + {HistType::kTH2F, {MultAxis, ZAxis}}}); + registry.add({"TracksEtaZvtxGen", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}); + registry.add({"TracksEtaZvtxGen_t", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}); + registry.add({"TracksEtaZvtxGen_gt0", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}); + registry.add({"TracksEtaZvtxGen_gt0t", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}); + registry.add({"TracksPhiEtaGen", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}); + registry.add({"TracksPhiZvtxGen", + "; #varphi; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {PhiAxis, ZAxis}}}); // + registry.add({"TracksToPartPtEta", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}); // + registry.add({"TracksPtEtaGen", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}); + registry.add({"TracksPtEtaGen_t", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}); + registry.add({"EventEfficiency", + "; status; events", + {HistType::kTH1F, {{5, 0.5, 5.5}}}}); + registry.add({"NotFoundEventZvtx", + " ; #it{z}_{vtx} (cm)", + {HistType::kTH1F, {ZAxis}}}); + registry.add({"EventsZposDiff", + " ; Z_{rec} - Z_{gen} (cm)", + {HistType::kTH1F, {DeltaZAxis}}}); + registry.add( + {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); auto heff = registry.get(HIST("EventEfficiency")); x = heff->GetXaxis(); @@ -160,65 +224,123 @@ struct PseudorapidityDensityMFT { } if (doprocessMultReassoc) { - registry.add({"Tracks/Control/DeltaZ", " ; #it{z_{orig}}-#it{z_{reass}}", {HistType::kTH1F, {ZAxis}}}); - - registry.add({"Tracks/Control/TrackAmbDegree", " ; N_{coll}^{comp}", {HistType::kTH1F, {{51, -0.5, 50.5}}}}); - registry.add({"Tracks/Control/TrackIsAmb", " ; isAmbiguous", {HistType::kTH1I, {{2, -0.5, 1.5}}}}); - registry.add({"Tracks/Control/DCAXY", " ; DCA_{XY} (cm)", {HistType::kTH1F, {DCAxyAxis}}}); // - registry.add({"Tracks/Control/ReassignedTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {EtaAxis, ZAxis}}}); - registry.add({"Tracks/Control/ReassignedTracksPhiEta", "; #varphi; #eta; tracks", {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - registry.add({"Tracks/Control/ReassignedVertexCorr", "; #it{z}_{vtx}^{orig} (cm); #it{z}_{vtx}^{re} (cm)", {HistType::kTH2F, {ZAxis, ZAxis}}}); + registry.add({"Tracks/Control/DeltaZ", + " ; #it{z_{orig}}-#it{z_{reass}}", + {HistType::kTH1F, {ZAxis}}}); + + registry.add({"Tracks/Control/TrackAmbDegree", + " ; N_{coll}^{comp}", + {HistType::kTH1F, {{51, -0.5, 50.5}}}}); + registry.add({"Tracks/Control/TrackIsAmb", + " ; isAmbiguous", + {HistType::kTH1I, {{2, -0.5, 1.5}}}}); + registry.add({"Tracks/Control/DCAXY", + " ; DCA_{XY} (cm)", + {HistType::kTH1F, {DCAxyAxis}}}); // + registry.add({"Tracks/Control/ReassignedTracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}); + registry.add({"Tracks/Control/ReassignedTracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}); + registry.add({"Tracks/Control/ReassignedVertexCorr", + "; #it{z}_{vtx}^{orig} (cm); #it{z}_{vtx}^{re} (cm)", + {HistType::kTH2F, {ZAxis, ZAxis}}}); } if (doprocessCountingCentrality) { - registry.add({"Events/Centrality/Selection", ";status;centrality;events", {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); + registry.add({"Events/Centrality/Selection", + ";status;centrality;events", + {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Rejected"); - registry.add({"Events/Centrality/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm); centrality", {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtx", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/PhiEta", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/PtEta", " ; p_{T} (GeV/c); #eta; centrality", {HistType::kTH3F, {PtAxis, EtaAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/DCAXYPt", " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ReassignedDCAXYPt", " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ExtraDCAXYPt", " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ExtraTracksEtaZvtx", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ExtraTracksPhiEta", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ReassignedTracksEtaZvtx", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ReassignedTracksPhiEta", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/Control/ReassignedVertexCorr", "; Z_{vtx}^{orig} (cm); Z_{vtx}^{re} (cm); centrality", {HistType::kTH3F, {ZAxis, ZAxis, CentAxis}}}); + registry.add({"Events/Centrality/NtrkZvtx", + "; N_{trk}; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtx", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/PhiEta", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/PtEta", + " ; p_{T} (GeV/c); #eta; centrality", + {HistType::kTH3F, {PtAxis, EtaAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/DCAXYPt", + " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", + {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ReassignedDCAXYPt", + " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", + {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ExtraDCAXYPt", + " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", + {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ExtraTracksEtaZvtx", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ExtraTracksPhiEta", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ReassignedTracksEtaZvtx", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ReassignedTracksPhiEta", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/Control/ReassignedVertexCorr", + "; Z_{vtx}^{orig} (cm); Z_{vtx}^{re} (cm); centrality", + {HistType::kTH3F, {ZAxis, ZAxis, CentAxis}}}); } if (doprocessGenCent) { - registry.add({"Events/Centrality/EventEfficiency", ";status;centrality;events", {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); + registry.add({"Events/Centrality/EventEfficiency", + ";status;centrality;events", + {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); auto heff = registry.get(HIST("Events/Centrality/EventEfficiency")); auto *x = heff->GetXaxis(); x->SetBinLabel(1, "Generated"); x->SetBinLabel(2, "Selected"); - registry.add("Events/Centrality/CentPercentileMCGen", "CentPercentileMCGen", kTH1D, {CentAxis}, false); - registry.add({"Events/Centrality/NtrkZvtxGen", "; N_{trk}; Z_{vtx} (cm); centrality", {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); - registry.add({"Events/Centrality/NtrkZvtxGen_t", "; N_{trk}; Z_{vtx} (cm); centrality", {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxRec", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxGen_t", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxGen", "; #eta; Z_{vtx} (cm); centrality", {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - registry.add({"Tracks/Centrality/PhiEtaGen", "; #varphi; #eta; centrality", {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + registry.add("Events/Centrality/CentPercentileMCGen", + "CentPercentileMCGen", kTH1D, {CentAxis}, false); + registry.add({"Events/Centrality/NtrkZvtxGen", + "; N_{trk}; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + registry.add({"Events/Centrality/NtrkZvtxGen_t", + "; N_{trk}; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxRec", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen_t", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + registry.add({"Tracks/Centrality/PhiEtaGen", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); } } using FullBCs = soa::Join; - void processTagging(FullBCs const& bcs, soa::Join const& collisions) - { + void + processTagging(FullBCs const &bcs, + soa::Join const &collisions) { std::vector::iterator> cols; - for (auto& bc : bcs) { - if (!useEvSel || (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) & bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { + for (auto &bc : bcs) { + if (!useEvSel || + (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) & + bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { registry.fill(HIST("EventSelection"), 5.); cols.clear(); - for (auto& collision : collisions) { + for (auto &collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -238,39 +360,47 @@ struct PseudorapidityDensityMFT { } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processTagging, "Collect event sample stats", true); + PROCESS_SWITCH(PseudorapidityDensityMFT, processTagging, + "Collect event sample stats", true); - Partition sample = (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); + Partition sample = + (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); Partition sampleCentral = (nabs(aod::track::eta) < 1.1f); - expressions::Filter atrackFilter = (aod::fwdtrack::bestCollisionId >= 0) && - (aod::fwdtrack::eta < -2.0f) && - (aod::fwdtrack::eta > -3.9f) && - (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); + expressions::Filter atrackFilter = + (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && + (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); using CollwEv = soa::Join; - expressions::Filter trackSelectionCentral = ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && - ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == (uint8_t)o2::aod::track::TPC, - (aod::track::trackCutFlag & trackSelectionTPC) == trackSelectionTPC, - true) && - ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && - (nabs(aod::track::eta) < estimatorEta); + expressions::Filter trackSelectionCentral = + ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && + ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == + (uint8_t)o2::aod::track::TPC, + (aod::track::trackCutFlag & trackSelectionTPC) == + trackSelectionTPC, + true) && + ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && + (nabs(aod::track::eta) < estimatorEta); - using FiCentralTracks = soa::Filtered>; // central tracks for INEL>0 + using FiCentralTracks = soa::Filtered< + soa::Join>; // central tracks for INEL>0 - void processMult(CollwEv::iterator const& collision, - aod::MFTTracks const& tracks, - FiCentralTracks const& midtracks, aod::Tracks const&) - { + void processMult(CollwEv::iterator const &collision, + aod::MFTTracks const &tracks, + FiCentralTracks const &midtracks, aod::Tracks const &) { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); - auto perCollisionSample = sampleCentral->sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), cache); - // auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + auto perCollisionSample = sampleCentral->sliceByCached( + o2::aod::track::collisionId, collision.globalIndex(), cache); + // auto perCollisionSample = + // sample->sliceByCached(o2::aod::fwdtrack::collisionId, + // collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("EventsNtrkZvtx"), Ntrk, z); @@ -282,12 +412,16 @@ struct PseudorapidityDensityMFT { } if (tracks.size() > 0) { - for (auto& track : tracks) { + for (auto &track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); - if( (phiM_PI-cfgPhiCut) && (phi2.*M_PI-cfgPhiCut) || (phi>((M_PI/2.-0.1)*M_PI)-cfgPhiCut)&&(phi<((M_PI/2.-0.1)*M_PI)+cfgPhiCut) ) + if ((phi < cfgPhiCut) || + ((phi > M_PI - cfgPhiCut) && (phi < M_PI + cfgPhiCut)) || + (phi > 2. * M_PI - cfgPhiCut) || + ((phi > ((M_PI / 2. - 0.1) * M_PI) - cfgPhiCut) && + (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) continue; registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); @@ -307,19 +441,23 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventSelection"), 4.); } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processMult, "Process reco or data info", true); - - void processMultReassoc(CollwEv::iterator const& collision, - o2::aod::MFTTracks const&, - soa::SmallGroups const& retracks, - FiCentralTracks const& midtracks, aod::Tracks const&) - { + PROCESS_SWITCH(PseudorapidityDensityMFT, processMult, + "Process reco or data info", true); + + void + processMultReassoc(CollwEv::iterator const &collision, + o2::aod::MFTTracks const &, + soa::SmallGroups const &retracks, + FiCentralTracks const &midtracks, aod::Tracks const &) { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); - auto perCollisionSample = sampleCentral->sliceByCached(o2::aod::track::collisionId, collision.globalIndex(), cache); - // auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + auto perCollisionSample = sampleCentral->sliceByCached( + o2::aod::track::collisionId, collision.globalIndex(), cache); + // auto perCollisionSample = + // sample->sliceByCached(o2::aod::fwdtrack::collisionId, + // collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("EventsNtrkZvtx"), Ntrk, z); @@ -331,7 +469,7 @@ struct PseudorapidityDensityMFT { } if (retracks.size() > 0) { - for (auto& retrack : retracks) { + for (auto &retrack : retracks) { auto track = retrack.mfttrack(); registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); if (midtracks.size() > 0) // INEL>0 @@ -347,14 +485,20 @@ struct PseudorapidityDensityMFT { } if (track.collisionId() != retrack.bestCollisionId()) { - registry.fill(HIST("Tracks/Control/ReassignedTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Tracks/Control/ReassignedTracksPhiEta"), phi, track.eta()); - registry.fill(HIST("Tracks/Control/ReassignedVertexCorr"), track.collision_as().posZ(), z); - - registry.fill(HIST("Tracks/Control/DeltaZ"), track.collision_as().posZ() - collision.posZ()); + registry.fill(HIST("Tracks/Control/ReassignedTracksEtaZvtx"), + track.eta(), z); + registry.fill(HIST("Tracks/Control/ReassignedTracksPhiEta"), phi, + track.eta()); + registry.fill(HIST("Tracks/Control/ReassignedVertexCorr"), + track.collision_as().posZ(), z); + + registry.fill(HIST("Tracks/Control/DeltaZ"), + track.collision_as().posZ() - + collision.posZ()); } - registry.fill(HIST("Tracks/Control/TrackAmbDegree"), retrack.ambDegree()); + registry.fill(HIST("Tracks/Control/TrackAmbDegree"), + retrack.ambDegree()); registry.fill(HIST("Tracks/Control/DCAXY"), retrack.bestDCAXY()); int isAmbiguous = 0; if (retrack.ambDegree() > 1) { @@ -368,59 +512,71 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventSelection"), 4.); } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processMultReassoc, "Process reco or data info", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processMultReassoc, + "Process reco or data info", false); using ExColsCent = soa::Join; - void processCountingCentrality(ExColsCent::iterator const& collision, - aod::MFTTracks const& tracks) - { + void processCountingCentrality(ExColsCent::iterator const &collision, + aod::MFTTracks const &tracks) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/Selection"), 1., c); if (!useEvSel || collision.sel8()) { auto z = collision.posZ(); registry.fill(HIST("Events/Centrality/Selection"), 2., c); - auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + auto perCollisionSample = sample->sliceByCached( + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("Events/Centrality/NtrkZvtx"), Ntrk, z, c); - for (auto& track : tracks) { + for (auto &track : tracks) { - float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); - if( (phiM_PI-cfgPhiCut) && (phi2.*M_PI-cfgPhiCut) || (phi>((M_PI/2.-0.1)*M_PI)-cfgPhiCut)&&(phi<((M_PI/2.-0.1)*M_PI)+cfgPhiCut) ) - continue; + if ((phi < cfgPhiCut) || + ((phi > M_PI - cfgPhiCut) && (phi < M_PI + cfgPhiCut)) || + (phi > 2. * M_PI - cfgPhiCut) || + ((phi > ((M_PI / 2. - 0.1) * M_PI) - cfgPhiCut) && + (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) + continue; registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c); registry.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), c); } } else { - registry.fill(HIST("Events/Centrality/Selection"), 3., c); // rejected events + registry.fill(HIST("Events/Centrality/Selection"), 3., + c); // rejected events } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processCountingCentrality, "Count tracks in centrality bins", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processCountingCentrality, + "Count tracks in centrality bins", false); using Particles = soa::Filtered; - expressions::Filter primaries = (aod::mcparticle::flags & (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + expressions::Filter primaries = + (aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; Partition mcSample = nabs(aod::mcparticle::eta) < 1.1f; - Partition mcSampleCentral = nabs(aod::mcparticle::eta) < estimatorEta; - - void processGen(aod::McCollisions::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - Particles const& particles, - aod::MFTTracks const& tracks, - FiCentralTracks const& midtracks) - { + Partition mcSampleCentral = + nabs(aod::mcparticle::eta) < estimatorEta; + + void processGen( + aod::McCollisions::iterator const &mcCollision, + o2::soa::SmallGroups> const &collisions, + Particles const &particles, aod::MFTTracks const &tracks, + FiCentralTracks const &midtracks) { registry.fill(HIST("EventEfficiency"), 1.); - auto perCollisionMCSample = mcSample->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + auto perCollisionMCSample = mcSample->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto& particle : perCollisionMCSample) { + for (auto &particle : perCollisionMCSample) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -434,9 +590,10 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventsNtrkZvtxGen_t"), nCharged, mcCollision.posZ()); //--------for INEL>0 - auto perCollisionMCSampleCentral = mcSampleCentral->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + auto perCollisionMCSampleCentral = mcSampleCentral->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nChargedCentral = 0; - for (auto& particle : perCollisionMCSampleCentral) { + for (auto &particle : perCollisionMCSampleCentral) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -450,7 +607,8 @@ struct PseudorapidityDensityMFT { if (nChargedCentral > 0) { registry.fill(HIST("EventEfficiency"), 2.); - registry.fill(HIST("EventsNtrkZvtxGen_gt0t"), nCharged, mcCollision.posZ()); + registry.fill(HIST("EventsNtrkZvtxGen_gt0t"), nCharged, + mcCollision.posZ()); } //----------- @@ -458,30 +616,36 @@ struct PseudorapidityDensityMFT { bool atLeastOne_gt0 = false; int moreThanOne = 0; - LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto& collision : collisions) { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), + collisions.size()); + for (auto &collision : collisions) { registry.fill(HIST("EventEfficiency"), 3.); if (!useEvSel || (useEvSel && collision.sel8())) { atLeastOne = true; - auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + auto perCollisionSample = sample->sliceByCached( + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("EventEfficiency"), 4.); - auto perCollisionSampleCentral = midtracks.sliceBy(perColCentral, collision.globalIndex()); + auto perCollisionSampleCentral = + midtracks.sliceBy(perColCentral, collision.globalIndex()); if (perCollisionSampleCentral.size() > 0) { registry.fill(HIST("EventEfficiency"), 5.); atLeastOne_gt0 = true; - registry.fill(HIST("EventsNtrkZvtxGen_gt0"), perCollisionSample.size(), collision.posZ()); + registry.fill(HIST("EventsNtrkZvtxGen_gt0"), + perCollisionSample.size(), collision.posZ()); } - registry.fill(HIST("EventsZposDiff"), collision.posZ() - mcCollision.posZ()); + registry.fill(HIST("EventsZposDiff"), + collision.posZ() - mcCollision.posZ()); if (useZDiffCut) { if (std::abs(collision.posZ() - mcCollision.posZ()) > maxZDiff) { continue; } } - registry.fill(HIST("EventsNtrkZvtxGen"), perCollisionSample.size(), collision.posZ()); + registry.fill(HIST("EventsNtrkZvtxGen"), perCollisionSample.size(), + collision.posZ()); ++moreThanOne; } } @@ -492,7 +656,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventsSplitMult"), nCharged); } - for (auto& particle : particles) { + for (auto &particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -502,43 +666,53 @@ struct PseudorapidityDensityMFT { continue; } - registry.fill(HIST("TracksEtaZvtxGen_t"), particle.eta(), mcCollision.posZ()); + registry.fill(HIST("TracksEtaZvtxGen_t"), particle.eta(), + mcCollision.posZ()); if (perCollisionMCSampleCentral.size() > 0) { - registry.fill(HIST("TracksEtaZvtxGen_gt0t"), particle.eta(), mcCollision.posZ()); + registry.fill(HIST("TracksEtaZvtxGen_gt0t"), particle.eta(), + mcCollision.posZ()); } if (atLeastOne) { - registry.fill(HIST("TracksEtaZvtxGen"), particle.eta(), mcCollision.posZ()); + registry.fill(HIST("TracksEtaZvtxGen"), particle.eta(), + mcCollision.posZ()); registry.fill(HIST("TracksPtEtaGen"), particle.pt(), particle.eta()); if (atLeastOne_gt0) { - registry.fill(HIST("TracksEtaZvtxGen_gt0"), particle.eta(), mcCollision.posZ()); + registry.fill(HIST("TracksEtaZvtxGen_gt0"), particle.eta(), + mcCollision.posZ()); } } registry.fill(HIST("TracksPhiEtaGen"), particle.phi(), particle.eta()); - registry.fill(HIST("TracksPhiZvtxGen"), particle.phi(), mcCollision.posZ()); + registry.fill(HIST("TracksPhiZvtxGen"), particle.phi(), + mcCollision.posZ()); registry.fill(HIST("TracksPtEtaGen_t"), particle.pt(), particle.eta()); } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processGen, "Process generator-level info", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processGen, + "Process generator-level info", false); - void processGenCent(aod::McCollisions::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - Particles const& particles, - MFTTracksLabeled const& tracks) - { + void + processGenCent(aod::McCollisions::iterator const &mcCollision, + o2::soa::SmallGroups< + soa::Join> const &collisions, + Particles const &particles, MFTTracksLabeled const &tracks) { - LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), + collisions.size()); - for (auto& collision : collisions) { + for (auto &collision : collisions) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/EventEfficiency"), 1., c); -// auto perCollisionMCSample = particles.sliceBy(perMcCol, mcCollision.globalIndex()); - auto perCollisionMCSample = mcSample->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + // auto perCollisionMCSample = particles.sliceBy(perMcCol, + // mcCollision.globalIndex()); + auto perCollisionMCSample = mcSample->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto& particle : perCollisionMCSample) { + for (auto &particle : perCollisionMCSample) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -549,19 +723,22 @@ struct PseudorapidityDensityMFT { } nCharged++; } - registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), c); -// + registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, + mcCollision.posZ(), c); + // bool atLeastOne = false; if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("Events/Centrality/EventEfficiency"), 2., c); registry.fill(HIST("Events/Centrality/CentPercentileMCGen"), c); atLeastOne = true; - auto perCollisionSample = sample->sliceByCached(o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); - registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), perCollisionSample.size(), collision.posZ(), c); + auto perCollisionSample = sample->sliceByCached( + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), + perCollisionSample.size(), collision.posZ(), c); } - for (auto& particle : particles) { + for (auto &particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -570,25 +747,31 @@ struct PseudorapidityDensityMFT { if (std::abs(charge) < 3.) { continue; } - registry.fill(HIST("Tracks/Centrality/EtaZvtxGen_t"), particle.eta(), mcCollision.posZ(), c); + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen_t"), particle.eta(), + mcCollision.posZ(), c); - if(atLeastOne){ - registry.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), mcCollision.posZ(), c); + if (atLeastOne) { + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), + mcCollision.posZ(), c); float phi = particle.phi(); o2::math_utils::bringTo02Pi(phi); - registry.fill(HIST("Tracks/Centrality/PhiEtaGen"), phi, particle.eta(), c); + registry.fill(HIST("Tracks/Centrality/PhiEtaGen"), phi, + particle.eta(), c); } } } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processGenCent, "Process generator-level info in centrality bins", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processGenCent, + "Process generator-level info in centrality bins", false); - void processGenPt(soa::Join::iterator const& collision, MFTTracksLabeled const& tracks, aod::McParticles const&) - { - // In the MFT the measurement of pT is not precise, so we access it by using the particle's pT instead + void processGenPt( + soa::Join::iterator const &collision, + MFTTracksLabeled const &tracks, aod::McParticles const &) { + // In the MFT the measurement of pT is not precise, so we access it by using + // the particle's pT instead if (!useEvSel || (useEvSel && collision.sel8())) { - for (auto& track : tracks) { + for (auto &track : tracks) { if (!track.has_mcParticle()) { continue; } @@ -601,11 +784,10 @@ struct PseudorapidityDensityMFT { } } - PROCESS_SWITCH(PseudorapidityDensityMFT, processGenPt, "Process particle-level info of pt", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processGenPt, + "Process particle-level info of pt", false); }; -WorkflowSpec - defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From 5f25ff563c14438c8cdc414c0b31d727b0497dd4 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Thu, 15 Feb 2024 09:49:38 +0100 Subject: [PATCH 13/17] PWGMM: Removed CCDB-related configurables --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index 6d3afec5e86..582c75d1645 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -16,8 +16,6 @@ // useful to compute dNdeta #include -// for CCDB access -#include "CCDB/BasicCCDBManager.h" #include #include "Framework/ASoAHelpers.h" @@ -88,24 +86,6 @@ struct PseudorapidityDensityMFT { Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; - //-----need access to CCDB to get the reweighting histogram - Service ccdb; - Configurable path{"ccdb-path", "Users/s/sherrman/My/Object", - "base path to the ccdb object"}; - Configurable url{"ccdb-url", "http://alice-ccdb.cern.ch", - "url of the ccdb repository"}; - Configurable nolaterthan{ - "ccdb-no-later-than", - std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count(), - "latest acceptable timestamp of creation for the object"}; - - // the histogram has been previously stored in the CCDB - TH1D *histoReweight = nullptr; - int counter = 0; - //------ - HistogramRegistry registry{ "registry", { From c0f85316a025a4bc1b2ea1a4994684529b2cf68b Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 15 Feb 2024 08:53:43 +0000 Subject: [PATCH 14/17] MegaLinter fixes --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 222 +++++++++++++++++--------------- 1 file changed, 116 insertions(+), 106 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index 582c75d1645..80f861eb8fa 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -51,16 +51,16 @@ AxisSpec DCAxyAxis = {100, -1, 10}; AxisSpec CentAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; static constexpr TrackSelectionFlags::flagtype trackSelectionITS = - TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | - TrackSelectionFlags::kITSHits; + TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | + TrackSelectionFlags::kITSHits; static constexpr TrackSelectionFlags::flagtype trackSelectionTPC = - TrackSelectionFlags::kTPCNCls | - TrackSelectionFlags::kTPCCrossedRowsOverNCls | - TrackSelectionFlags::kTPCChi2NDF; + TrackSelectionFlags::kTPCNCls | + TrackSelectionFlags::kTPCCrossedRowsOverNCls | + TrackSelectionFlags::kTPCChi2NDF; static constexpr TrackSelectionFlags::flagtype trackSelectionDCA = - TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; + TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; using MFTTracksLabeled = soa::Join; @@ -80,53 +80,55 @@ struct PseudorapidityDensityMFT { Configurable useZDiffCut{"useZDiffCut", true, "use Z difference cut"}; Configurable maxZDiff{ - "maxZDiff", 1.0f, - "max allowed Z difference for reconstruced collisions (cm)"}; + "maxZDiff", 1.0f, + "max allowed Z difference for reconstruced collisions (cm)"}; Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; HistogramRegistry registry{ - "registry", - { - - {"TracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"Tracks/EtaZvtx_gt0", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"TracksPhiEta", - "; #varphi; #eta; tracks", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // - {"TracksPhiZvtx", - "; #varphi; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {PhiAxis, ZAxis}}}, // - {"TracksPtEta", - " ; p_{T} (GeV/c); #eta", - {HistType::kTH2F, {PtAxis, EtaAxis}}}, // - {"EventSelection", - ";status;events", - {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // - - } // + "registry", + { + + {"TracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"Tracks/EtaZvtx_gt0", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"TracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // + {"TracksPhiZvtx", + "; #varphi; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {PhiAxis, ZAxis}}}, // + {"TracksPtEta", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}, // + {"EventSelection", + ";status;events", + {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // + + } // }; - void init(InitContext &) { + void init(InitContext&) + { if (static_cast(doprocessMult) + - static_cast(doprocessMultReassoc) + - static_cast(doprocessCountingCentrality) > + static_cast(doprocessMultReassoc) + + static_cast(doprocessCountingCentrality) > 1) { - LOGP(fatal, "Exactly one process function between processMult, " - "processMultReassoc and processCountingCentrality should be " - "enabled!"); + LOGP(fatal, + "Exactly one process function between processMult, " + "processMultReassoc and processCountingCentrality should be " + "enabled!"); } AxisSpec MultAxis = {multBinning, "N_{trk}"}; // for PbPb 3001,-0.5,3000.5 auto hstat = registry.get(HIST("EventSelection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Selected INEL>0"); @@ -192,7 +194,7 @@ struct PseudorapidityDensityMFT { " ; Z_{rec} - Z_{gen} (cm)", {HistType::kTH1F, {DeltaZAxis}}}); registry.add( - {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); auto heff = registry.get(HIST("EventEfficiency")); x = heff->GetXaxis(); @@ -233,7 +235,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Rejected"); @@ -281,7 +283,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); auto heff = registry.get(HIST("Events/Centrality/EventEfficiency")); - auto *x = heff->GetXaxis(); + auto* x = heff->GetXaxis(); x->SetBinLabel(1, "Generated"); x->SetBinLabel(2, "Selected"); @@ -310,17 +312,18 @@ struct PseudorapidityDensityMFT { using FullBCs = soa::Join; void - processTagging(FullBCs const &bcs, - soa::Join const &collisions) { + processTagging(FullBCs const& bcs, + soa::Join const& collisions) + { std::vector::iterator> cols; - for (auto &bc : bcs) { + for (auto& bc : bcs) { if (!useEvSel || (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) & bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { registry.fill(HIST("EventSelection"), 5.); cols.clear(); - for (auto &collision : collisions) { + for (auto& collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -344,40 +347,41 @@ struct PseudorapidityDensityMFT { "Collect event sample stats", true); Partition sample = - (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); + (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); Partition sampleCentral = (nabs(aod::track::eta) < 1.1f); expressions::Filter atrackFilter = - (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && - (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); + (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && + (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); using CollwEv = soa::Join; expressions::Filter trackSelectionCentral = - ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && - ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == - (uint8_t)o2::aod::track::TPC, - (aod::track::trackCutFlag & trackSelectionTPC) == - trackSelectionTPC, - true) && - ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && - (nabs(aod::track::eta) < estimatorEta); + ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && + ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == + (uint8_t)o2::aod::track::TPC, + (aod::track::trackCutFlag & trackSelectionTPC) == + trackSelectionTPC, + true) && + ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && + (nabs(aod::track::eta) < estimatorEta); using FiCentralTracks = soa::Filtered< - soa::Join>; // central tracks for INEL>0 + soa::Join>; // central tracks for INEL>0 - void processMult(CollwEv::iterator const &collision, - aod::MFTTracks const &tracks, - FiCentralTracks const &midtracks, aod::Tracks const &) { + void processMult(CollwEv::iterator const& collision, + aod::MFTTracks const& tracks, + FiCentralTracks const& midtracks, aod::Tracks const&) + { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -392,7 +396,7 @@ struct PseudorapidityDensityMFT { } if (tracks.size() > 0) { - for (auto &track : tracks) { + for (auto& track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -401,7 +405,7 @@ struct PseudorapidityDensityMFT { ((phi > M_PI - cfgPhiCut) && (phi < M_PI + cfgPhiCut)) || (phi > 2. * M_PI - cfgPhiCut) || ((phi > ((M_PI / 2. - 0.1) * M_PI) - cfgPhiCut) && - (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) + (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) continue; registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); @@ -425,16 +429,17 @@ struct PseudorapidityDensityMFT { "Process reco or data info", true); void - processMultReassoc(CollwEv::iterator const &collision, - o2::aod::MFTTracks const &, - soa::SmallGroups const &retracks, - FiCentralTracks const &midtracks, aod::Tracks const &) { + processMultReassoc(CollwEv::iterator const& collision, + o2::aod::MFTTracks const&, + soa::SmallGroups const& retracks, + FiCentralTracks const& midtracks, aod::Tracks const&) + { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -449,7 +454,7 @@ struct PseudorapidityDensityMFT { } if (retracks.size() > 0) { - for (auto &retrack : retracks) { + for (auto& retrack : retracks) { auto track = retrack.mfttrack(); registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); if (midtracks.size() > 0) // INEL>0 @@ -474,7 +479,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("Tracks/Control/DeltaZ"), track.collision_as().posZ() - - collision.posZ()); + collision.posZ()); } registry.fill(HIST("Tracks/Control/TrackAmbDegree"), @@ -497,8 +502,9 @@ struct PseudorapidityDensityMFT { using ExColsCent = soa::Join; - void processCountingCentrality(ExColsCent::iterator const &collision, - aod::MFTTracks const &tracks) { + void processCountingCentrality(ExColsCent::iterator const& collision, + aod::MFTTracks const& tracks) + { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/Selection"), 1., c); @@ -506,12 +512,12 @@ struct PseudorapidityDensityMFT { auto z = collision.posZ(); registry.fill(HIST("Events/Centrality/Selection"), 2., c); auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("Events/Centrality/NtrkZvtx"), Ntrk, z, c); - for (auto &track : tracks) { + for (auto& track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -520,7 +526,7 @@ struct PseudorapidityDensityMFT { ((phi > M_PI - cfgPhiCut) && (phi < M_PI + cfgPhiCut)) || (phi > 2. * M_PI - cfgPhiCut) || ((phi > ((M_PI / 2. - 0.1) * M_PI) - cfgPhiCut) && - (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) + (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) continue; registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c); @@ -538,25 +544,26 @@ struct PseudorapidityDensityMFT { using Particles = soa::Filtered; expressions::Filter primaries = - (aod::mcparticle::flags & - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + (aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; Partition mcSample = nabs(aod::mcparticle::eta) < 1.1f; Partition mcSampleCentral = - nabs(aod::mcparticle::eta) < estimatorEta; + nabs(aod::mcparticle::eta) < estimatorEta; void processGen( - aod::McCollisions::iterator const &mcCollision, - o2::soa::SmallGroups> const &collisions, - Particles const &particles, aod::MFTTracks const &tracks, - FiCentralTracks const &midtracks) { + aod::McCollisions::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + Particles const& particles, aod::MFTTracks const& tracks, + FiCentralTracks const& midtracks) + { registry.fill(HIST("EventEfficiency"), 1.); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto &particle : perCollisionMCSample) { + for (auto& particle : perCollisionMCSample) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -571,9 +578,9 @@ struct PseudorapidityDensityMFT { //--------for INEL>0 auto perCollisionMCSampleCentral = mcSampleCentral->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nChargedCentral = 0; - for (auto &particle : perCollisionMCSampleCentral) { + for (auto& particle : perCollisionMCSampleCentral) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -598,17 +605,17 @@ struct PseudorapidityDensityMFT { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto &collision : collisions) { + for (auto& collision : collisions) { registry.fill(HIST("EventEfficiency"), 3.); if (!useEvSel || (useEvSel && collision.sel8())) { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("EventEfficiency"), 4.); auto perCollisionSampleCentral = - midtracks.sliceBy(perColCentral, collision.globalIndex()); + midtracks.sliceBy(perColCentral, collision.globalIndex()); if (perCollisionSampleCentral.size() > 0) { registry.fill(HIST("EventEfficiency"), 5.); @@ -636,7 +643,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventsSplitMult"), nCharged); } - for (auto &particle : particles) { + for (auto& particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -673,26 +680,27 @@ struct PseudorapidityDensityMFT { "Process generator-level info", false); void - processGenCent(aod::McCollisions::iterator const &mcCollision, - o2::soa::SmallGroups< + processGenCent(aod::McCollisions::iterator const& mcCollision, + o2::soa::SmallGroups< soa::Join> const &collisions, - Particles const &particles, MFTTracksLabeled const &tracks) { + aod::McCollisionLabels>> const& collisions, + Particles const& particles, MFTTracksLabeled const& tracks) + { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto &collision : collisions) { + for (auto& collision : collisions) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/EventEfficiency"), 1., c); // auto perCollisionMCSample = particles.sliceBy(perMcCol, // mcCollision.globalIndex()); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto &particle : perCollisionMCSample) { + for (auto& particle : perCollisionMCSample) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -713,12 +721,12 @@ struct PseudorapidityDensityMFT { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), perCollisionSample.size(), collision.posZ(), c); } - for (auto &particle : particles) { + for (auto& particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -746,12 +754,13 @@ struct PseudorapidityDensityMFT { "Process generator-level info in centrality bins", false); void processGenPt( - soa::Join::iterator const &collision, - MFTTracksLabeled const &tracks, aod::McParticles const &) { + soa::Join::iterator const& collision, + MFTTracksLabeled const& tracks, aod::McParticles const&) + { // In the MFT the measurement of pT is not precise, so we access it by using // the particle's pT instead if (!useEvSel || (useEvSel && collision.sel8())) { - for (auto &track : tracks) { + for (auto& track : tracks) { if (!track.has_mcParticle()) { continue; } @@ -768,6 +777,7 @@ struct PseudorapidityDensityMFT { "Process particle-level info of pt", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From 16c6a91ef7c4f6e300104a7c66d59bad060d5ab5 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Thu, 15 Feb 2024 10:19:22 +0100 Subject: [PATCH 15/17] PWGMM: Removed CCDB-related configurables --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index 80f861eb8fa..c7a6a5ddb17 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2020-2022 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright // holders. All rights not expressly granted are reserved. // @@ -15,8 +15,8 @@ // \brief This code loops over MFT tracks and collisions and fills histograms // useful to compute dNdeta -#include #include +#include #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" From e841c938199e57dab46c706828287d5ea22292ab Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Thu, 15 Feb 2024 10:36:36 +0100 Subject: [PATCH 16/17] PWGMM: Removed CCDB-related configurables --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 222 +++++++++++++++----------------- 1 file changed, 106 insertions(+), 116 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index c7a6a5ddb17..f394f62fb93 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -1,6 +1,6 @@ // Copyright 2020-2022 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright -// holders. All rights not expressly granted are reserved. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. // // This software is distributed under the terms of the GNU General Public // License v3 (GPL Version 3), copied verbatim in the file "COPYING". @@ -51,16 +51,16 @@ AxisSpec DCAxyAxis = {100, -1, 10}; AxisSpec CentAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; static constexpr TrackSelectionFlags::flagtype trackSelectionITS = - TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | - TrackSelectionFlags::kITSHits; + TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | + TrackSelectionFlags::kITSHits; static constexpr TrackSelectionFlags::flagtype trackSelectionTPC = - TrackSelectionFlags::kTPCNCls | - TrackSelectionFlags::kTPCCrossedRowsOverNCls | - TrackSelectionFlags::kTPCChi2NDF; + TrackSelectionFlags::kTPCNCls | + TrackSelectionFlags::kTPCCrossedRowsOverNCls | + TrackSelectionFlags::kTPCChi2NDF; static constexpr TrackSelectionFlags::flagtype trackSelectionDCA = - TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; + TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; using MFTTracksLabeled = soa::Join; @@ -80,55 +80,53 @@ struct PseudorapidityDensityMFT { Configurable useZDiffCut{"useZDiffCut", true, "use Z difference cut"}; Configurable maxZDiff{ - "maxZDiff", 1.0f, - "max allowed Z difference for reconstruced collisions (cm)"}; + "maxZDiff", 1.0f, + "max allowed Z difference for reconstruced collisions (cm)"}; Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; HistogramRegistry registry{ - "registry", - { - - {"TracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"Tracks/EtaZvtx_gt0", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"TracksPhiEta", - "; #varphi; #eta; tracks", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // - {"TracksPhiZvtx", - "; #varphi; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {PhiAxis, ZAxis}}}, // - {"TracksPtEta", - " ; p_{T} (GeV/c); #eta", - {HistType::kTH2F, {PtAxis, EtaAxis}}}, // - {"EventSelection", - ";status;events", - {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // - - } // + "registry", + { + + {"TracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"Tracks/EtaZvtx_gt0", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"TracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // + {"TracksPhiZvtx", + "; #varphi; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {PhiAxis, ZAxis}}}, // + {"TracksPtEta", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}, // + {"EventSelection", + ";status;events", + {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // + + } // }; - void init(InitContext&) - { + void init(InitContext &) { if (static_cast(doprocessMult) + - static_cast(doprocessMultReassoc) + - static_cast(doprocessCountingCentrality) > + static_cast(doprocessMultReassoc) + + static_cast(doprocessCountingCentrality) > 1) { - LOGP(fatal, - "Exactly one process function between processMult, " - "processMultReassoc and processCountingCentrality should be " - "enabled!"); + LOGP(fatal, "Exactly one process function between processMult, " + "processMultReassoc and processCountingCentrality should be " + "enabled!"); } AxisSpec MultAxis = {multBinning, "N_{trk}"}; // for PbPb 3001,-0.5,3000.5 auto hstat = registry.get(HIST("EventSelection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Selected INEL>0"); @@ -194,7 +192,7 @@ struct PseudorapidityDensityMFT { " ; Z_{rec} - Z_{gen} (cm)", {HistType::kTH1F, {DeltaZAxis}}}); registry.add( - {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); auto heff = registry.get(HIST("EventEfficiency")); x = heff->GetXaxis(); @@ -235,7 +233,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Rejected"); @@ -283,7 +281,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); auto heff = registry.get(HIST("Events/Centrality/EventEfficiency")); - auto* x = heff->GetXaxis(); + auto *x = heff->GetXaxis(); x->SetBinLabel(1, "Generated"); x->SetBinLabel(2, "Selected"); @@ -312,18 +310,17 @@ struct PseudorapidityDensityMFT { using FullBCs = soa::Join; void - processTagging(FullBCs const& bcs, - soa::Join const& collisions) - { + processTagging(FullBCs const &bcs, + soa::Join const &collisions) { std::vector::iterator> cols; - for (auto& bc : bcs) { + for (auto &bc : bcs) { if (!useEvSel || (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) & bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { registry.fill(HIST("EventSelection"), 5.); cols.clear(); - for (auto& collision : collisions) { + for (auto &collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -347,41 +344,40 @@ struct PseudorapidityDensityMFT { "Collect event sample stats", true); Partition sample = - (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); + (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); Partition sampleCentral = (nabs(aod::track::eta) < 1.1f); expressions::Filter atrackFilter = - (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && - (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); + (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && + (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); using CollwEv = soa::Join; expressions::Filter trackSelectionCentral = - ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && - ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == - (uint8_t)o2::aod::track::TPC, - (aod::track::trackCutFlag & trackSelectionTPC) == - trackSelectionTPC, - true) && - ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && - (nabs(aod::track::eta) < estimatorEta); + ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && + ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == + (uint8_t)o2::aod::track::TPC, + (aod::track::trackCutFlag & trackSelectionTPC) == + trackSelectionTPC, + true) && + ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && + (nabs(aod::track::eta) < estimatorEta); using FiCentralTracks = soa::Filtered< - soa::Join>; // central tracks for INEL>0 + soa::Join>; // central tracks for INEL>0 - void processMult(CollwEv::iterator const& collision, - aod::MFTTracks const& tracks, - FiCentralTracks const& midtracks, aod::Tracks const&) - { + void processMult(CollwEv::iterator const &collision, + aod::MFTTracks const &tracks, + FiCentralTracks const &midtracks, aod::Tracks const &) { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -396,7 +392,7 @@ struct PseudorapidityDensityMFT { } if (tracks.size() > 0) { - for (auto& track : tracks) { + for (auto &track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -429,17 +425,16 @@ struct PseudorapidityDensityMFT { "Process reco or data info", true); void - processMultReassoc(CollwEv::iterator const& collision, - o2::aod::MFTTracks const&, - soa::SmallGroups const& retracks, - FiCentralTracks const& midtracks, aod::Tracks const&) - { + processMultReassoc(CollwEv::iterator const &collision, + o2::aod::MFTTracks const &, + soa::SmallGroups const &retracks, + FiCentralTracks const &midtracks, aod::Tracks const &) { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -454,7 +449,7 @@ struct PseudorapidityDensityMFT { } if (retracks.size() > 0) { - for (auto& retrack : retracks) { + for (auto &retrack : retracks) { auto track = retrack.mfttrack(); registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); if (midtracks.size() > 0) // INEL>0 @@ -479,7 +474,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("Tracks/Control/DeltaZ"), track.collision_as().posZ() - - collision.posZ()); + collision.posZ()); } registry.fill(HIST("Tracks/Control/TrackAmbDegree"), @@ -502,9 +497,8 @@ struct PseudorapidityDensityMFT { using ExColsCent = soa::Join; - void processCountingCentrality(ExColsCent::iterator const& collision, - aod::MFTTracks const& tracks) - { + void processCountingCentrality(ExColsCent::iterator const &collision, + aod::MFTTracks const &tracks) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/Selection"), 1., c); @@ -512,12 +506,12 @@ struct PseudorapidityDensityMFT { auto z = collision.posZ(); registry.fill(HIST("Events/Centrality/Selection"), 2., c); auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("Events/Centrality/NtrkZvtx"), Ntrk, z, c); - for (auto& track : tracks) { + for (auto &track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -544,26 +538,25 @@ struct PseudorapidityDensityMFT { using Particles = soa::Filtered; expressions::Filter primaries = - (aod::mcparticle::flags & - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + (aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; Partition mcSample = nabs(aod::mcparticle::eta) < 1.1f; Partition mcSampleCentral = - nabs(aod::mcparticle::eta) < estimatorEta; + nabs(aod::mcparticle::eta) < estimatorEta; void processGen( - aod::McCollisions::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - Particles const& particles, aod::MFTTracks const& tracks, - FiCentralTracks const& midtracks) - { + aod::McCollisions::iterator const &mcCollision, + o2::soa::SmallGroups> const &collisions, + Particles const &particles, aod::MFTTracks const &tracks, + FiCentralTracks const &midtracks) { registry.fill(HIST("EventEfficiency"), 1.); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto& particle : perCollisionMCSample) { + for (auto &particle : perCollisionMCSample) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -578,9 +571,9 @@ struct PseudorapidityDensityMFT { //--------for INEL>0 auto perCollisionMCSampleCentral = mcSampleCentral->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nChargedCentral = 0; - for (auto& particle : perCollisionMCSampleCentral) { + for (auto &particle : perCollisionMCSampleCentral) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -605,17 +598,17 @@ struct PseudorapidityDensityMFT { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto& collision : collisions) { + for (auto &collision : collisions) { registry.fill(HIST("EventEfficiency"), 3.); if (!useEvSel || (useEvSel && collision.sel8())) { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("EventEfficiency"), 4.); auto perCollisionSampleCentral = - midtracks.sliceBy(perColCentral, collision.globalIndex()); + midtracks.sliceBy(perColCentral, collision.globalIndex()); if (perCollisionSampleCentral.size() > 0) { registry.fill(HIST("EventEfficiency"), 5.); @@ -643,7 +636,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventsSplitMult"), nCharged); } - for (auto& particle : particles) { + for (auto &particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -680,27 +673,26 @@ struct PseudorapidityDensityMFT { "Process generator-level info", false); void - processGenCent(aod::McCollisions::iterator const& mcCollision, - o2::soa::SmallGroups< + processGenCent(aod::McCollisions::iterator const &mcCollision, + o2::soa::SmallGroups< soa::Join> const& collisions, - Particles const& particles, MFTTracksLabeled const& tracks) - { + aod::McCollisionLabels>> const &collisions, + Particles const &particles, MFTTracksLabeled const &tracks) { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto& collision : collisions) { + for (auto &collision : collisions) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/EventEfficiency"), 1., c); // auto perCollisionMCSample = particles.sliceBy(perMcCol, // mcCollision.globalIndex()); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto& particle : perCollisionMCSample) { + for (auto &particle : perCollisionMCSample) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -721,12 +713,12 @@ struct PseudorapidityDensityMFT { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), perCollisionSample.size(), collision.posZ(), c); } - for (auto& particle : particles) { + for (auto &particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -754,13 +746,12 @@ struct PseudorapidityDensityMFT { "Process generator-level info in centrality bins", false); void processGenPt( - soa::Join::iterator const& collision, - MFTTracksLabeled const& tracks, aod::McParticles const&) - { + soa::Join::iterator const &collision, + MFTTracksLabeled const &tracks, aod::McParticles const &) { // In the MFT the measurement of pT is not precise, so we access it by using // the particle's pT instead if (!useEvSel || (useEvSel && collision.sel8())) { - for (auto& track : tracks) { + for (auto &track : tracks) { if (!track.has_mcParticle()) { continue; } @@ -777,7 +768,6 @@ struct PseudorapidityDensityMFT { "Process particle-level info of pt", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From 2a342243dc5252087826808a3d8d94c54c18473f Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 15 Feb 2024 09:40:16 +0000 Subject: [PATCH 17/17] MegaLinter fixes --- PWGMM/Mult/Tasks/dndeta-mft.cxx | 218 +++++++++++++++++--------------- 1 file changed, 114 insertions(+), 104 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft.cxx b/PWGMM/Mult/Tasks/dndeta-mft.cxx index f394f62fb93..b7ed2c6c9ca 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft.cxx @@ -51,16 +51,16 @@ AxisSpec DCAxyAxis = {100, -1, 10}; AxisSpec CentAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; static constexpr TrackSelectionFlags::flagtype trackSelectionITS = - TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | - TrackSelectionFlags::kITSHits; + TrackSelectionFlags::kITSNCls | TrackSelectionFlags::kITSChi2NDF | + TrackSelectionFlags::kITSHits; static constexpr TrackSelectionFlags::flagtype trackSelectionTPC = - TrackSelectionFlags::kTPCNCls | - TrackSelectionFlags::kTPCCrossedRowsOverNCls | - TrackSelectionFlags::kTPCChi2NDF; + TrackSelectionFlags::kTPCNCls | + TrackSelectionFlags::kTPCCrossedRowsOverNCls | + TrackSelectionFlags::kTPCChi2NDF; static constexpr TrackSelectionFlags::flagtype trackSelectionDCA = - TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; + TrackSelectionFlags::kDCAz | TrackSelectionFlags::kDCAxy; using MFTTracksLabeled = soa::Join; @@ -80,53 +80,55 @@ struct PseudorapidityDensityMFT { Configurable useZDiffCut{"useZDiffCut", true, "use Z difference cut"}; Configurable maxZDiff{ - "maxZDiff", 1.0f, - "max allowed Z difference for reconstruced collisions (cm)"}; + "maxZDiff", 1.0f, + "max allowed Z difference for reconstruced collisions (cm)"}; Configurable cfgPhiCut{"cfgPhiCut", 0.1f, "Cut on azimuthal angle of MFT tracks"}; HistogramRegistry registry{ - "registry", - { - - {"TracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"Tracks/EtaZvtx_gt0", - "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}, // - {"TracksPhiEta", - "; #varphi; #eta; tracks", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // - {"TracksPhiZvtx", - "; #varphi; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {PhiAxis, ZAxis}}}, // - {"TracksPtEta", - " ; p_{T} (GeV/c); #eta", - {HistType::kTH2F, {PtAxis, EtaAxis}}}, // - {"EventSelection", - ";status;events", - {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // - - } // + "registry", + { + + {"TracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"Tracks/EtaZvtx_gt0", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {EtaAxis, ZAxis}}}, // + {"TracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {PhiAxis, EtaAxis}}}, // + {"TracksPhiZvtx", + "; #varphi; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {PhiAxis, ZAxis}}}, // + {"TracksPtEta", + " ; p_{T} (GeV/c); #eta", + {HistType::kTH2F, {PtAxis, EtaAxis}}}, // + {"EventSelection", + ";status;events", + {HistType::kTH1F, {{7, 0.5, 7.5}}}}, // + + } // }; - void init(InitContext &) { + void init(InitContext&) + { if (static_cast(doprocessMult) + - static_cast(doprocessMultReassoc) + - static_cast(doprocessCountingCentrality) > + static_cast(doprocessMultReassoc) + + static_cast(doprocessCountingCentrality) > 1) { - LOGP(fatal, "Exactly one process function between processMult, " - "processMultReassoc and processCountingCentrality should be " - "enabled!"); + LOGP(fatal, + "Exactly one process function between processMult, " + "processMultReassoc and processCountingCentrality should be " + "enabled!"); } AxisSpec MultAxis = {multBinning, "N_{trk}"}; // for PbPb 3001,-0.5,3000.5 auto hstat = registry.get(HIST("EventSelection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Selected INEL>0"); @@ -192,7 +194,7 @@ struct PseudorapidityDensityMFT { " ; Z_{rec} - Z_{gen} (cm)", {HistType::kTH1F, {DeltaZAxis}}}); registry.add( - {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + {"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); auto heff = registry.get(HIST("EventEfficiency")); x = heff->GetXaxis(); @@ -233,7 +235,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); - auto *x = hstat->GetXaxis(); + auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); x->SetBinLabel(3, "Rejected"); @@ -281,7 +283,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); auto heff = registry.get(HIST("Events/Centrality/EventEfficiency")); - auto *x = heff->GetXaxis(); + auto* x = heff->GetXaxis(); x->SetBinLabel(1, "Generated"); x->SetBinLabel(2, "Selected"); @@ -310,17 +312,18 @@ struct PseudorapidityDensityMFT { using FullBCs = soa::Join; void - processTagging(FullBCs const &bcs, - soa::Join const &collisions) { + processTagging(FullBCs const& bcs, + soa::Join const& collisions) + { std::vector::iterator> cols; - for (auto &bc : bcs) { + for (auto& bc : bcs) { if (!useEvSel || (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) & bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { registry.fill(HIST("EventSelection"), 5.); cols.clear(); - for (auto &collision : collisions) { + for (auto& collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -344,40 +347,41 @@ struct PseudorapidityDensityMFT { "Collect event sample stats", true); Partition sample = - (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); + (aod::fwdtrack::eta < -2.8f) && (aod::fwdtrack::eta > -3.2f); Partition sampleCentral = (nabs(aod::track::eta) < 1.1f); expressions::Filter atrackFilter = - (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && - (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); + (aod::fwdtrack::bestCollisionId >= 0) && (aod::fwdtrack::eta < -2.0f) && + (aod::fwdtrack::eta > -3.9f) && (nabs(aod::fwdtrack::bestDCAXY) <= 2.f); using CollwEv = soa::Join; expressions::Filter trackSelectionCentral = - ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && - ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == - (uint8_t)o2::aod::track::TPC, - (aod::track::trackCutFlag & trackSelectionTPC) == - trackSelectionTPC, - true) && - ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && - (nabs(aod::track::eta) < estimatorEta); + ((aod::track::trackCutFlag & trackSelectionITS) == trackSelectionITS) && + ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == + (uint8_t)o2::aod::track::TPC, + (aod::track::trackCutFlag & trackSelectionTPC) == + trackSelectionTPC, + true) && + ((aod::track::trackCutFlag & trackSelectionDCA) == trackSelectionDCA) && + (nabs(aod::track::eta) < estimatorEta); using FiCentralTracks = soa::Filtered< - soa::Join>; // central tracks for INEL>0 + soa::Join>; // central tracks for INEL>0 - void processMult(CollwEv::iterator const &collision, - aod::MFTTracks const &tracks, - FiCentralTracks const &midtracks, aod::Tracks const &) { + void processMult(CollwEv::iterator const& collision, + aod::MFTTracks const& tracks, + FiCentralTracks const& midtracks, aod::Tracks const&) + { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -392,7 +396,7 @@ struct PseudorapidityDensityMFT { } if (tracks.size() > 0) { - for (auto &track : tracks) { + for (auto& track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -425,16 +429,17 @@ struct PseudorapidityDensityMFT { "Process reco or data info", true); void - processMultReassoc(CollwEv::iterator const &collision, - o2::aod::MFTTracks const &, - soa::SmallGroups const &retracks, - FiCentralTracks const &midtracks, aod::Tracks const &) { + processMultReassoc(CollwEv::iterator const& collision, + o2::aod::MFTTracks const&, + soa::SmallGroups const& retracks, + FiCentralTracks const& midtracks, aod::Tracks const&) + { registry.fill(HIST("EventSelection"), 1.); if (!useEvSel || (useEvSel && collision.sel8())) { registry.fill(HIST("EventSelection"), 2.); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( - o2::aod::track::collisionId, collision.globalIndex(), cache); + o2::aod::track::collisionId, collision.globalIndex(), cache); // auto perCollisionSample = // sample->sliceByCached(o2::aod::fwdtrack::collisionId, // collision.globalIndex(), cache); @@ -449,7 +454,7 @@ struct PseudorapidityDensityMFT { } if (retracks.size() > 0) { - for (auto &retrack : retracks) { + for (auto& retrack : retracks) { auto track = retrack.mfttrack(); registry.fill(HIST("TracksEtaZvtx"), track.eta(), z); if (midtracks.size() > 0) // INEL>0 @@ -474,7 +479,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("Tracks/Control/DeltaZ"), track.collision_as().posZ() - - collision.posZ()); + collision.posZ()); } registry.fill(HIST("Tracks/Control/TrackAmbDegree"), @@ -497,8 +502,9 @@ struct PseudorapidityDensityMFT { using ExColsCent = soa::Join; - void processCountingCentrality(ExColsCent::iterator const &collision, - aod::MFTTracks const &tracks) { + void processCountingCentrality(ExColsCent::iterator const& collision, + aod::MFTTracks const& tracks) + { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/Selection"), 1., c); @@ -506,12 +512,12 @@ struct PseudorapidityDensityMFT { auto z = collision.posZ(); registry.fill(HIST("Events/Centrality/Selection"), 2., c); auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); auto Ntrk = perCollisionSample.size(); registry.fill(HIST("Events/Centrality/NtrkZvtx"), Ntrk, z, c); - for (auto &track : tracks) { + for (auto& track : tracks) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -538,25 +544,26 @@ struct PseudorapidityDensityMFT { using Particles = soa::Filtered; expressions::Filter primaries = - (aod::mcparticle::flags & - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + (aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; Partition mcSample = nabs(aod::mcparticle::eta) < 1.1f; Partition mcSampleCentral = - nabs(aod::mcparticle::eta) < estimatorEta; + nabs(aod::mcparticle::eta) < estimatorEta; void processGen( - aod::McCollisions::iterator const &mcCollision, - o2::soa::SmallGroups> const &collisions, - Particles const &particles, aod::MFTTracks const &tracks, - FiCentralTracks const &midtracks) { + aod::McCollisions::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + Particles const& particles, aod::MFTTracks const& tracks, + FiCentralTracks const& midtracks) + { registry.fill(HIST("EventEfficiency"), 1.); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto &particle : perCollisionMCSample) { + for (auto& particle : perCollisionMCSample) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -571,9 +578,9 @@ struct PseudorapidityDensityMFT { //--------for INEL>0 auto perCollisionMCSampleCentral = mcSampleCentral->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nChargedCentral = 0; - for (auto &particle : perCollisionMCSampleCentral) { + for (auto& particle : perCollisionMCSampleCentral) { auto charge = 0.; auto p = pdg->GetParticle(particle.pdgCode()); if (p != nullptr) { @@ -598,17 +605,17 @@ struct PseudorapidityDensityMFT { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto &collision : collisions) { + for (auto& collision : collisions) { registry.fill(HIST("EventEfficiency"), 3.); if (!useEvSel || (useEvSel && collision.sel8())) { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("EventEfficiency"), 4.); auto perCollisionSampleCentral = - midtracks.sliceBy(perColCentral, collision.globalIndex()); + midtracks.sliceBy(perColCentral, collision.globalIndex()); if (perCollisionSampleCentral.size() > 0) { registry.fill(HIST("EventEfficiency"), 5.); @@ -636,7 +643,7 @@ struct PseudorapidityDensityMFT { registry.fill(HIST("EventsSplitMult"), nCharged); } - for (auto &particle : particles) { + for (auto& particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -673,26 +680,27 @@ struct PseudorapidityDensityMFT { "Process generator-level info", false); void - processGenCent(aod::McCollisions::iterator const &mcCollision, - o2::soa::SmallGroups< + processGenCent(aod::McCollisions::iterator const& mcCollision, + o2::soa::SmallGroups< soa::Join> const &collisions, - Particles const &particles, MFTTracksLabeled const &tracks) { + aod::McCollisionLabels>> const& collisions, + Particles const& particles, MFTTracksLabeled const& tracks) + { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - for (auto &collision : collisions) { + for (auto& collision : collisions) { auto c = collision.centFT0C(); registry.fill(HIST("Events/Centrality/EventEfficiency"), 1., c); // auto perCollisionMCSample = particles.sliceBy(perMcCol, // mcCollision.globalIndex()); auto perCollisionMCSample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto nCharged = 0; - for (auto &particle : perCollisionMCSample) { + for (auto& particle : perCollisionMCSample) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -713,12 +721,12 @@ struct PseudorapidityDensityMFT { atLeastOne = true; auto perCollisionSample = sample->sliceByCached( - o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); + o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), perCollisionSample.size(), collision.posZ(), c); } - for (auto &particle : particles) { + for (auto& particle : particles) { auto p = pdg->GetParticle(particle.pdgCode()); auto charge = 0; if (p != nullptr) { @@ -746,12 +754,13 @@ struct PseudorapidityDensityMFT { "Process generator-level info in centrality bins", false); void processGenPt( - soa::Join::iterator const &collision, - MFTTracksLabeled const &tracks, aod::McParticles const &) { + soa::Join::iterator const& collision, + MFTTracksLabeled const& tracks, aod::McParticles const&) + { // In the MFT the measurement of pT is not precise, so we access it by using // the particle's pT instead if (!useEvSel || (useEvSel && collision.sel8())) { - for (auto &track : tracks) { + for (auto& track : tracks) { if (!track.has_mcParticle()) { continue; } @@ -768,6 +777,7 @@ struct PseudorapidityDensityMFT { "Process particle-level info of pt", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; }