From 37910b530ee57714478aec5ef0b22d1fee1dd808 Mon Sep 17 00:00:00 2001 From: Chiara Oppedisano Date: Mon, 31 Aug 2026 11:58:40 +0200 Subject: [PATCH 01/10] Updated reader --- Common/Tasks/zdcTableReader.cxx | 461 +++++++++++++++++++++++++------- 1 file changed, 367 insertions(+), 94 deletions(-) diff --git a/Common/Tasks/zdcTableReader.cxx b/Common/Tasks/zdcTableReader.cxx index 07a581564cd..2993bb8fef4 100644 --- a/Common/Tasks/zdcTableReader.cxx +++ b/Common/Tasks/zdcTableReader.cxx @@ -17,31 +17,35 @@ #include #include -#include #include -#include -#include -#include #include -#include -#include +#include +#include using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; using namespace o2::aod; +#define CHECK_BIT(var, pos) (((var) >> (pos)) & 1) + struct ZDCLIAnalysis { - // Configurable number of bins - Configurable useZvtx{"useZvtx", false, "If true uses Z_vertex"}; - Configurable zVval{"zVval", 10., "Z_vertex cut value"}; - Configurable tStampMin{"tStampMin", 100000., "minimum value for timestamp"}; - Configurable tStampMax{"tStampMax", 100000., ",maximum value for timestamp"}; + // Configurable + Configurable tStampOffset{"tStampOffset", 0, "offset value for timestamp"}; + Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; + Configurable tStampMax{"tStampMax", 1000, ",maximum value for timestamp"}; + // + Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; + Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; + Configurable tdcZPmincut{"tdcZPmincut", -1.5, "Min. ZP TDC cut value"}; + Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; // Configurable nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; - Configurable nBinsAmp{"nBinsAmp", 1025, "n bins 4 ZDC amplitudes"}; + Configurable nBinsAmpZN{"nBinsAmpZN", 1025, "n bins 4 ZN amplitudes"}; + Configurable nBinsAmpZP{"nBinsAmpZP", 1025, "n bins 4 ZP amplitudes"}; Configurable nBinsTDC{"nBinsTDC", 480, "n bins 4 TDCs"}; Configurable nBinsFit{"nBinsFit", 1000, "n bins 4 FIT"}; Configurable MaxZN{"MaxZN", 4099.5, "Max 4 ZN histos"}; @@ -51,54 +55,99 @@ struct ZDCLIAnalysis { Configurable MaxMultFV0{"MaxMultFV0", 3000, "Max 4 FV0 histos"}; Configurable MaxMultFT0{"MaxMultFT0", 3000, "Max 4 FT0 histos"}; // + Configurable enCalibZNA{"enCalibZNA", 1.0, "Energy calibration ZNA"}; + Configurable enCalibZNC{"enCalibZNC", 1.0, "Energy calibration ZNC"}; + Configurable enCalibZPA{"enCalibZPA", 1.0, "Energy calibration ZPA"}; + Configurable enCalibZPC{"enCalibZPC", 1.0, "Energy calibration ZPC"}; + // + Configurable applyZDCcut{"applyZDCcut", false, "Apply ZDC cut for light ion analysis"}; + Configurable zdcaCutLow{"zdcaCutLow", 12., "ZDCA cut for light ion analysis"}; + Configurable zdccCutLow{"zdccCutLow", 12., "ZDCC cut for light ion analysis"}; + // + Configurable selectZvtx{"selectZvtx", true, "Activate Z vertex selection"}; + Configurable sel8{"sel8", true, "Activate sel8 selection"}; + Configurable triggetTVX{"triggerTVX", true, "Activate trigger TVX selection"}; + Configurable doOccupancySel{"doOccupancySel", false, "Activate occupancy selection"}; + Configurable noSameBunchPileupCut{"noSameBunchPileupCut", true, "Activate no same bunch pileup selection"}; + Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", true, "Activate is good Z vertex FT0 vs PV selection"}; + Configurable noCollInTimeRangeStandard{"noCollInTimeRangeStandard", true, "Activate no collision in time range standard selection"}; + Configurable noTimeFrameBorder{"noTimeFrameBorder", true, "Activate no time frame border selection"}; + Configurable noITSROFFrameBorder{"noITSROFFrameBorder", true, "Activate no ITS ROF frame border selection"}; + Configurable isGoodITSLayersAll{"isGoodITSLayersAll", false, "Activate is good ITS layers all selection"}; + // HistogramRegistry registry{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; void init(InitContext const&) { - registry.add("hZNApmc", "ZNApmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, MaxZN}}}); - registry.add("hZPApmc", "ZPApmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, MaxZP}}}); - registry.add("hZNCpmc", "ZNCpmc; ZNC amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, MaxZN}}}); - registry.add("hZPCpmc", "ZPCpmc; ZPC amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, MaxZP}}}); - registry.add("hZEM", "ZEM; ZEM1+ZEM2 amplitude; Entries", {HistType::kTH1F, {{nBinsAmp, -0.5, MaxZEM}}}); - registry.add("hZNAamplvsADC", "ZNA amplitude vs. ADC; ZNA ADC; ZNA amplitude", {HistType::kTH2F, {{{nBinsAmp, -0.5, 3. * MaxZN}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCamplvsADC", "ZNC amplitude vs. ADC; ZNC ADC; ZNC amplitude", {HistType::kTH2F, {{{nBinsAmp, -0.5, 3. * MaxZN}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPAamplvsADC", "ZPA amplitude vs. ADC; ZPA ADC; ZPA amplitude", {HistType::kTH2F, {{{nBinsAmp, -0.5, 3. * MaxZP}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmp, -0.5, 3. * MaxZP}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, MaxZEM}, {nBinsAmp, -0.5, 2. * MaxZN}}}}); - registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmp, -0.5, MaxZN}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmp, -0.5, MaxZP}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZNAvsZPA", "ZNA vs ZPA; ZPA; ZNA", {HistType::kTH2F, {{{nBinsAmp, -0.5, MaxZP}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCvsZPC", "ZNC vs ZPC; ZPC; ZNC", {HistType::kTH2F, {{{nBinsAmp, -0.5, MaxZP}, {nBinsAmp, -0.5, MaxZN}}}}); + registry.add("hzvertex", "z vertex; z_vertex (cm); Entries", {HistType::kTH1F, {{200, -20., 20.}}}); + registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{10, 0., 10.}}}); + // + registry.add("hZNApmc", "ZNA pmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPApmc", "ZPA pmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZNCpmc", "ZNC pmc; ZNC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPCpmc", "ZPC pmc; ZPC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZEM", "ZEM; ZEM1+ZEM2 amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZEM}}}); + registry.add("hZDCA", "ZNA+ZPA; ZNA+ZPA; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCC", "ZNC+ZPC; ZNC+ZPC; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZDCApmcwZDCCcut", "ZDCA w. ZDCC cut; ZDCA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCCpmcwZDCAcut", "ZDCC w. ZDCA cut; ZDCC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZNAtdc", "ZNA tdc; ZNA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPAtdc", "ZPA tdc; ZPA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZNCtdc", "ZNC tdc; ZNC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPCtdc", "ZPC tdc; ZPC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + // + registry.add("hZDCCvsA", "ZDC side C vs. side A; ZDCA; ZDCC", {HistType::kTH2F, {{{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}, {nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}}); + // + registry.add("hZNAamplvsADC", "ZNA amplitude vs. ADC; ZNA ADC; ZNA amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCamplvsADC", "ZNC amplitude vs. ADC; ZNC ADC; ZNC amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAamplvsADC", "ZPA amplitude vs. ADC; ZPA ADC; ZPA amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNAvsZPA", "ZNA vs ZPA; ZPA; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZPC", "ZNC vs ZPC; ZPC; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); // registry.add("hZNCcvsZNCsum", "ZNC PMC vs PMsum; ZNCC ADC; ZNCsum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); registry.add("hZNAcvsZNAsum", "ZNA PMC vs PMsum; ZNAsum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); // - registry.add("hZNCvstdc", "ZNC vs tdc; ZNC amplitude; ZNC TDC", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNAvstdc", "ZNA vs tdc; ZNA amplitude; ZNA TDC", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPCvstdc", "ZPC vs tdc; ZPC amplitude; ZPC TDC", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPAvstdc", "ZPA vs tdc; ZPA amplitude; ZPA TDC", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmp, -0.5, MaxZP}}}}); + registry.add("hZNCvstdc", "ZNC vs tdc; ZNC TDC (ns); ZNC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvstdc", "ZNA vs tdc; ZNA TDC (ns); ZNA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvstdc", "ZPC vs tdc; ZPC TDC (ns); ZPC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvstdc", "ZPA vs tdc; ZPA TDC (ns); ZPA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNvsV0A", "ZN vs V0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFV0}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZNAvsFT0A", "ZNA vs FT0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsFT0C", "ZNC vs FT0C", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); // - registry.add("hZNvsV0A", "ZN vs V0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFV0}, {nBinsAmp, -0.5, 2. * MaxZN}}}}); - registry.add("hZNAvsFT0A", "ZNA vs FT0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCvsFT0C", "ZNC vs FT0C", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmp, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0A", "ZNA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0C", "ZNA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0M", "ZNA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvscentrFT0A", "ZPA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0C", "ZPA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0M", "ZPA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNCvscentrFT0A", "ZNC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0C", "ZNC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0M", "ZNC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvscentrFT0A", "ZPC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0C", "ZPC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0M", "ZPC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); // - registry.add("hZNAvscentrFT0A", "ZNA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNAvscentrFT0C", "ZNA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNAvscentrFT0M", "ZNA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPAvscentrFT0A", "ZPA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPAvscentrFT0C", "ZPA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPAvscentrFT0M", "ZPA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZNCvscentrFT0A", "ZNC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCvscentrFT0C", "ZNC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCvscentrFT0M", "ZNC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPCvscentrFT0A", "ZPC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPCvscentrFT0C", "ZPC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPCvscentrFT0M", "ZPC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmp, -0.5, MaxZP}}}}); + registry.add("hNnZNAvscentrFT0C", "N_{neutrons} in ZNA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0C", "N_{neutrons} in ZNC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0C", "N_{protons} in ZPA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0C", "N_{protons} in ZPC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNAvscentrFT0M", "N_{neutrons} in ZNA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0M", "N_{neutrons} in ZNC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0M", "N_{protons} in ZPA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0M", "N_{protons} in ZPC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); // - registry.add("hZNAvstimestamp", "ZNA vs timestamp", {HistType::kTH2F, {{{100, tStampMin, tStampMax}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZNCvstimestamp", "ZNC vs timestamp", {HistType::kTH2F, {{{100, tStampMin, tStampMax}, {nBinsAmp, -0.5, MaxZN}}}}); - registry.add("hZPAvstimestamp", "ZPA vs timestamp", {HistType::kTH2F, {{{100, tStampMin, tStampMax}, {nBinsAmp, -0.5, MaxZP}}}}); - registry.add("hZPCvstimestamp", "ZPC vs timestamp", {HistType::kTH2F, {{{100, tStampMin, tStampMax}, {nBinsAmp, -0.5, MaxZP}}}}); + registry.add("hZNAvstimestamp", "ZNA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvstimestamp", "ZNC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvstimestamp", "ZPA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvstimestamp", "ZPC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); } void process(aod::ZDCLightIons const& zdclightions) @@ -134,55 +183,279 @@ struct ZDCLIAnalysis { auto centrFT0A = zdc.centralityFt0a(); auto centrFT0M = zdc.centralityFt0m(); auto timestamp = zdc.timestamp(); - // auto selectionBits = zdc.selectionBits(); + auto selectionBits = zdc.selectionBits(); - if ((useZvtx && (zvtx < zVval)) || !useZvtx) { - registry.get(HIST("hZNApmc"))->Fill(zna); - registry.get(HIST("hZNCpmc"))->Fill(znc); - registry.get(HIST("hZPApmc"))->Fill(zpa); - registry.get(HIST("hZPCpmc"))->Fill(zpc); - registry.get(HIST("hZEM"))->Fill(zem1 + zem2); - // - registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); - registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); - registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); - registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); - // - registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); - registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); - registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); - registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); - registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); - // - registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); - registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); - registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); - registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); - // - registry.get(HIST("hZNAcvsZNAsum"))->Fill(znapm1 + znapm2 + znapm3 + znapm4, zna); - registry.get(HIST("hZNCcvsZNCsum"))->Fill(zncpm1 + zncpm2 + zncpm3 + zncpm4, znc); + bool isZNAtdc = false; + bool isZNCtdc = false; + bool isZPAtdc = false; + bool isZPCtdc = false; + + if (tdczna > -99999.0) + isZNAtdc = true; + if (tdcznc > -99999.0) + isZNCtdc = true; + if (tdczpa > -99999.0) + isZPAtdc = true; + if (tdczpc > -99999.0) + isZPCtdc = true; + + if (tdcCut) { // TDC cuts applied + if ((tdczna < tdcZNmincut) || (tdczna > tdcZNmaxcut)) + isZNAtdc = false; + if ((tdcznc < tdcZNmincut) || (tdcznc > tdcZNmaxcut)) + isZNCtdc = false; + if ((tdczpa < tdcZPmincut) || (tdczpa > tdcZPmaxcut)) + isZPAtdc = false; + if ((tdczpc < tdcZPmincut) || (tdczpc > tdcZPmaxcut)) + isZPCtdc = false; + } + + bool zvtxSel = false; + if (selectZvtx && CHECK_BIT(selectionBits, 0)) + zvtxSel = true; + else if (!selectZvtx) + zvtxSel = true; + // + bool ottoSel = false; + if (sel8 && CHECK_BIT(selectionBits, 1)) + ottoSel = true; + else if (!sel8) + ottoSel = true; + // + bool isdoOccupancySel = false; + if (doOccupancySel && CHECK_BIT(selectionBits, 2)) + isdoOccupancySel = true; + else if (!doOccupancySel) + isdoOccupancySel = true; + // + bool isnoSameBunchPileupCut = false; + if (noSameBunchPileupCut && CHECK_BIT(selectionBits, 3)) + isnoSameBunchPileupCut = true; + else if (!noSameBunchPileupCut) + isnoSameBunchPileupCut = true; + // + bool isGoodZvtxFT0vsPVsel = false; + if (isGoodZvtxFT0vsPV && CHECK_BIT(selectionBits, 4)) + isGoodZvtxFT0vsPVsel = true; + else if (!isGoodZvtxFT0vsPV) + isGoodZvtxFT0vsPVsel = true; + // + bool isnoCollInTimeRangeStandard = false; + if (noCollInTimeRangeStandard && CHECK_BIT(selectionBits, 5)) + isnoCollInTimeRangeStandard = true; + else if (!noCollInTimeRangeStandard) + isnoCollInTimeRangeStandard = true; + // + bool isnoTimeFrameBorder = false; + if (noTimeFrameBorder && CHECK_BIT(selectionBits, 6)) + isnoTimeFrameBorder = true; + else if (!noTimeFrameBorder) + isnoTimeFrameBorder = true; + // + bool isnoITSROFFrameBorder = false; + if (noITSROFFrameBorder && CHECK_BIT(selectionBits, 7)) + isnoITSROFFrameBorder = true; + else if (!noITSROFFrameBorder) + isnoITSROFFrameBorder = true; + // + bool isGoodITSLayersAllsel = false; + if (isGoodITSLayersAll && CHECK_BIT(selectionBits, 8)) + isGoodITSLayersAllsel = true; + else if (!isGoodITSLayersAll) + isGoodITSLayersAllsel = true; + // + bool istriggerTVX = false; + if (!triggetTVX) + istriggerTVX = true; + else if (triggetTVX && CHECK_BIT(selectionBits, 9)) + istriggerTVX = true; + + // comment the if when you want the output for BC selection!!! + //if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) { + if (zvtxSel && ottoSel && isnoSameBunchPileupCut) { + + registry.get(HIST("hcounts"))->Fill(0., 1.); + if(isZNAtdc) registry.get(HIST("hcounts"))->Fill(1., 1.); + if(isZPAtdc) registry.get(HIST("hcounts"))->Fill(2., 1.); + if(isZNCtdc) registry.get(HIST("hcounts"))->Fill(3., 1.); + if(isZPCtdc) registry.get(HIST("hcounts"))->Fill(4., 1.); + if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); + if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); + if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); + if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); + + if (enCalibZNA > 0.) { + zna *= enCalibZNA; + znaADC *= enCalibZNA; + znapm1 *= enCalibZNA; + znapm2 *= enCalibZNA; + znapm3 *= enCalibZNA; + znapm4 *= enCalibZNA; + } + if (enCalibZNC > 0.) { + znc *= enCalibZNC; + zncADC *= enCalibZNC; + zncpm1 *= enCalibZNC; + zncpm2 *= enCalibZNC; + zncpm3 *= enCalibZNC; + zncpm4 *= enCalibZNC; + } + if (enCalibZPA > 0.) { + zpa *= enCalibZPA; + zpaADC *= enCalibZPA; + } + if (enCalibZPC > 0.) { + zpc *= enCalibZPC; + zpcADC *= enCalibZPC; + } + + registry.get(HIST("hzvertex"))->Fill(zvtx); + + + if (!applyZDCcut) { + + if (isZNAtdc) registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc) registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc) registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc) registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if (isZNAtdc || isZPAtdc) registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if (isZNCtdc || isZPCtdc) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); + if (isZPAtdc || isZPCtdc) registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); + if (isZNAtdc || isZPAtdc) registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); + if (isZNCtdc || isZPCtdc) registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); + // + if (isZNAtdc) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); + if (isZNAtdc) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } + else { + bool isZNChigh = false; + if (znc >= zdccCutLow) + isZNChigh = true; + bool isZNAhigh = false; + if (zna >= zdcaCutLow) + isZNAhigh = true; + bool isZPAhigh = false; + if (zpa >= zdcaCutLow) + isZPAhigh = true; + bool isZPChigh = false; + if (zpc >= zdccCutLow) + isZPChigh = true; + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } + + // Timestamp + if (tStampOffset > timestamp) { + printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %llu \n\n", timestamp); + return; + } + float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours + if (tsh > tStampMax) { + printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", tsh); + return; + } + + if (!applyZDCcut) { + if (isZNAtdc) registry.get(HIST("hZNAvstimestamp"))->Fill(tsh, zna); + if (isZNCtdc) registry.get(HIST("hZNCvstimestamp"))->Fill(tsh, znc); + if (isZPAtdc) registry.get(HIST("hZPAvstimestamp"))->Fill(tsh, zpa); + if (isZPCtdc) registry.get(HIST("hZPCvstimestamp"))->Fill(tsh, zpc); + } else { + if (isZNAtdc && znc >= zdccCutLow) { + registry.get(HIST("hZNAvstimestamp"))->Fill(tsh, zna); + } + if (isZPAtdc && zpc >= zdccCutLow) { + registry.get(HIST("hZPAvstimestamp"))->Fill(tsh, zpa); + } + if ((isZNAtdc || isZPAtdc) && (znc >= zdccCutLow && zpc >= zdccCutLow)) { + registry.get(HIST("hZDCApmcwZDCCcut"))->Fill(zna + zpa); + } + if (isZNCtdc && zna >= zdcaCutLow) { + registry.get(HIST("hZNCvstimestamp"))->Fill(tsh, znc); + } + if (isZPCtdc && zpa >= zdcaCutLow) { + registry.get(HIST("hZPCvstimestamp"))->Fill(tsh, zpc); + } + if ((isZNCtdc || isZPCtdc) && (zna >= zdcaCutLow && zpa >= zdcaCutLow)) { + registry.get(HIST("hZDCCpmcwZDCAcut"))->Fill(znc + zpc); + } + } + // TDCs + if (isZNAtdc) registry.get(HIST("hZNAtdc"))->Fill(tdczna); + if (isZNCtdc) registry.get(HIST("hZNCtdc"))->Fill(tdcznc); + if (isZPAtdc) registry.get(HIST("hZPAtdc"))->Fill(tdczpa); + if (isZPCtdc) registry.get(HIST("hZPCtdc"))->Fill(tdczpc); // - registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); - registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); - registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + registry.get(HIST("hZEM"))->Fill(zem1 + zem2); + if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); // - registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); - registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); - registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); - registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); - registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); - registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); - registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); - registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); - registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); - registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); - registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); - registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); // - registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); - registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); - registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); - registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + if(centrFT0C > -1. && centrFT0C < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); + registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna/2.680); + registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc/2.680); + registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa/2.680); + registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc/2.680); + } + if(centrFT0A > -1. && centrFT0A < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); + } + if(centrFT0M > -1. && centrFT0M < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna/2.680); + registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc/2.680); + registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa/2.680); + registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc/2.680); + } } } } From e40df93cf3916449f548453df8b73da312f8e7fc Mon Sep 17 00:00:00 2001 From: Chiara Oppedisano Date: Fri, 4 Sep 2026 15:29:09 +0200 Subject: [PATCH 02/10] Updated task to read ZDC table for light ions --- Common/Tasks/zdcTableReader.cxx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Common/Tasks/zdcTableReader.cxx b/Common/Tasks/zdcTableReader.cxx index 2993bb8fef4..3a6eaaf6c41 100644 --- a/Common/Tasks/zdcTableReader.cxx +++ b/Common/Tasks/zdcTableReader.cxx @@ -144,6 +144,9 @@ struct ZDCLIAnalysis { registry.add("hNpZPAvscentrFT0M", "N_{protons} in ZPA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); registry.add("hNpZPCvscentrFT0M", "N_{protons} in ZPC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); // + registry.add("hNpvsNnZNA", "N_{protons} vs N_{neutrons} in ZNA", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + registry.add("hNpvsNnZNC", "N_{protons} vs N_{neutrons} in ZNC", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + // registry.add("hZNAvstimestamp", "ZNA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZNCvstimestamp", "ZNC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZPAvstimestamp", "ZPA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); @@ -455,6 +458,8 @@ struct ZDCLIAnalysis { registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc/2.680); registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa/2.680); registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc/2.680); + registry.get(HIST("hNpvsNnZNA"))->Fill(zna/2.680, zpa/2.680); + registry.get(HIST("hNpvsNnZNC"))->Fill(znc/2.680, zpc/2.680); } } } From 4272848ab249b17371476e5bbd061b16ab5b4e38 Mon Sep 17 00:00:00 2001 From: Chiara Oppedisano Date: Tue, 8 Sep 2026 11:08:36 +0200 Subject: [PATCH 03/10] Updated task for light ions --- Common/Tasks/zdcTableReader.cxx | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/Common/Tasks/zdcTableReader.cxx b/Common/Tasks/zdcTableReader.cxx index 3a6eaaf6c41..122f997e709 100644 --- a/Common/Tasks/zdcTableReader.cxx +++ b/Common/Tasks/zdcTableReader.cxx @@ -80,7 +80,7 @@ struct ZDCLIAnalysis { void init(InitContext const&) { registry.add("hzvertex", "z vertex; z_vertex (cm); Entries", {HistType::kTH1F, {{200, -20., 20.}}}); - registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{10, 0., 10.}}}); + registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{12, 0., 12.}}}); // registry.add("hZNApmc", "ZNA pmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); registry.add("hZPApmc", "ZPA pmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); @@ -104,14 +104,18 @@ struct ZDCLIAnalysis { registry.add("hZNCamplvsADC", "ZNC amplitude vs. ADC; ZNC ADC; ZNC amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZPAamplvsADC", "ZPA amplitude vs. ADC; ZPA ADC; ZPA amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZNAvsZEM", "ZNA vs ZEM; ZEM; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZEM", "ZNC vs ZEM; ZEM; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + // registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); registry.add("hZNAvsZPA", "ZNA vs ZPA; ZPA; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZNCvsZPC", "ZNC vs ZPC; ZPC; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); // - registry.add("hZNCcvsZNCsum", "ZNC PMC vs PMsum; ZNCC ADC; ZNCsum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); - registry.add("hZNAcvsZNAsum", "ZNA PMC vs PMsum; ZNAsum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + registry.add("hZNCcvsZNCsum", "ZNC PMC vs PMsum; ZNCC ADC; ZNC sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + registry.add("hZNAcvsZNAsum", "ZNA PMC vs PMsum; ZNAC ADC; ZNA sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); // registry.add("hZNCvstdc", "ZNC vs tdc; ZNC TDC (ns); ZNC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZNAvstdc", "ZNA vs tdc; ZNA TDC (ns); ZNA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); @@ -282,10 +286,13 @@ struct ZDCLIAnalysis { if(isZPAtdc) registry.get(HIST("hcounts"))->Fill(2., 1.); if(isZNCtdc) registry.get(HIST("hcounts"))->Fill(3., 1.); if(isZPCtdc) registry.get(HIST("hcounts"))->Fill(4., 1.); - if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); - if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); - if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); - if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); + if(isZNAtdc || isZNCtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); + if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); + if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); + if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); + if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(9., 1.); + if(isZNAtdc && isZPAtdc) registry.get(HIST("hcounts"))->Fill(10., 1.); + if(isZNCtdc && isZPCtdc) registry.get(HIST("hcounts"))->Fill(11., 1.); if (enCalibZNA > 0.) { zna *= enCalibZNA; @@ -430,6 +437,8 @@ struct ZDCLIAnalysis { // registry.get(HIST("hZEM"))->Fill(zem1 + zem2); if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); + if (isZNAtdc) registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); + if (isZNCtdc) registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); // if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); // From 13c94dec00b43eb057ee3da6a13b20d6fda0efcb Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 11:11:17 +0200 Subject: [PATCH 04/10] Updating ZDC task for light ions for new analysis Refine task to perform analysis of light ion data for cross section evaluation from ZDC data. --- Common/DataModel/ZDCLightIons.h | 6 +- Common/DataModel/zdcTableReader.cxx | 531 ++++++++++++++++++++++++++ Common/DataModel/zdcTaskLightIons.cxx | 406 ++++++++++++++++++++ 3 files changed, 941 insertions(+), 2 deletions(-) create mode 100644 Common/DataModel/zdcTableReader.cxx create mode 100644 Common/DataModel/zdcTaskLightIons.cxx diff --git a/Common/DataModel/ZDCLightIons.h b/Common/DataModel/ZDCLightIons.h index b0e8e247622..a3d6db2b207 100644 --- a/Common/DataModel/ZDCLightIons.h +++ b/Common/DataModel/ZDCLightIons.h @@ -56,7 +56,8 @@ DECLARE_SOA_COLUMN(CentralityFt0c, centralityFt0c, float); //! Centrality DECLARE_SOA_COLUMN(CentralityFt0a, centralityFt0a, float); //! Centrality DECLARE_SOA_COLUMN(CentralityFt0m, centralityFt0m, float); //! Centrality DECLARE_SOA_COLUMN(Timestamp, timestamp, uint64_t); //! Timestamp -DECLARE_SOA_COLUMN(SelectionBits, selectionBits, uint8_t); //! Selection Flags +DECLARE_SOA_COLUMN(SelectionBits, selectionBits, uint8_t); //! Selection flags x collisions +DECLARE_SOA_COLUMN(BcMask, bcMask, uint8_t); //! Selection flags x BC } // namespace zdclightions DECLARE_SOA_TABLE(ZDCLightIons, "AOD", "ZDCTABLELIGHTIONS", @@ -92,7 +93,8 @@ DECLARE_SOA_TABLE(ZDCLightIons, "AOD", "ZDCTABLELIGHTIONS", zdclightions::CentralityFt0a, zdclightions::CentralityFt0m, zdclightions::Timestamp, - zdclightions::SelectionBits); + zdclightions::SelectionBits, + zdclightions::BcMask); } // namespace o2::aod #endif // COMMON_DATAMODEL_ZDCLIGHTIONS_H_ diff --git a/Common/DataModel/zdcTableReader.cxx b/Common/DataModel/zdcTableReader.cxx new file mode 100644 index 00000000000..1cd05bda4dd --- /dev/null +++ b/Common/DataModel/zdcTableReader.cxx @@ -0,0 +1,531 @@ +// 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. +/// +/// \brief Read output table from ZDC light ion task +/// \author chiara.oppedisano@cern.ch +// + +#include "Common/DataModel/ZDCLightIons.h" + +#include +#include +#include +#include + +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod; + +#define CHECK_BIT(var, pos) (((var) >> (pos)) & 1) + +struct ZDCLIAnalysis { + + // Configurable + Configurable selectBC{"selectBC", 0, "Select BC events"}; + Configurable selectOnlyB{"selectOnlyB", 0, "Select BC with A && C"}; + Configurable selectColl{"selectColl", 0, "Select ALICE collision events"}; + // + Configurable tStampOffset{"tStampOffset", 0, "offset value for timestamp"}; + Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; + Configurable tStampMax{"tStampMax", 1000, ",maximum value for timestamp"}; + // + Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; + Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; + Configurable tdcZPmincut{"tdcZPmincut", -1.5, "Min. ZP TDC cut value"}; + Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; + // + Configurable nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; + Configurable nBinsAmpZN{"nBinsAmpZN", 1025, "n bins 4 ZN amplitudes"}; + Configurable nBinsAmpZP{"nBinsAmpZP", 1025, "n bins 4 ZP amplitudes"}; + Configurable nBinsTDC{"nBinsTDC", 480, "n bins 4 TDCs"}; + Configurable nBinsFit{"nBinsFit", 1000, "n bins 4 FIT"}; + Configurable MaxZN{"MaxZN", 4099.5, "Max 4 ZN histos"}; + Configurable MaxZP{"MaxZP", 3099.5, "Max 4 ZP histos"}; + Configurable MaxZEM{"MaxZEM", 3099.5, "Max 4 ZEM histos"}; + // + Configurable MaxMultFV0{"MaxMultFV0", 3000, "Max 4 FV0 histos"}; + Configurable MaxMultFT0{"MaxMultFT0", 3000, "Max 4 FT0 histos"}; + // + Configurable enCalibZNA{"enCalibZNA", 1.0, "Energy calibration ZNA"}; + Configurable enCalibZNC{"enCalibZNC", 1.0, "Energy calibration ZNC"}; + Configurable enCalibZPA{"enCalibZPA", 1.0, "Energy calibration ZPA"}; + Configurable enCalibZPC{"enCalibZPC", 1.0, "Energy calibration ZPC"}; + // + Configurable applyZDCcut{"applyZDCcut", false, "Apply ZDC cut for light ion analysis"}; + Configurable zdcaCutLow{"zdcaCutLow", 12., "ZDCA cut for light ion analysis"}; + Configurable zdccCutLow{"zdccCutLow", 12., "ZDCC cut for light ion analysis"}; + // + Configurable selectZvtx{"selectZvtx", true, "Activate Z vertex selection"}; + Configurable sel8{"sel8", true, "Activate sel8 selection"}; + Configurable triggetTVX{"triggerTVX", true, "Activate trigger TVX selection"}; + Configurable doOccupancySel{"doOccupancySel", false, "Activate occupancy selection"}; + Configurable noSameBunchPileupCut{"noSameBunchPileupCut", true, "Activate no same bunch pileup selection"}; + Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", true, "Activate is good Z vertex FT0 vs PV selection"}; + Configurable noCollInTimeRangeStandard{"noCollInTimeRangeStandard", true, "Activate no collision in time range standard selection"}; + Configurable noTimeFrameBorder{"noTimeFrameBorder", true, "Activate no time frame border selection"}; + Configurable noITSROFFrameBorder{"noITSROFFrameBorder", true, "Activate no ITS ROF frame border selection"}; + Configurable isGoodITSLayersAll{"isGoodITSLayersAll", false, "Activate is good ITS layers all selection"}; + // + HistogramRegistry registry{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + void init(InitContext const&) + { + registry.add("hBCmask", "mask; BC; counts", {HistType::kTH1F, {{5, 0., 5.}}}); + registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{14, 0., 14.}}}); + registry.add("hzvertex", "z vertex; z_vertex (cm); Entries", {HistType::kTH1F, {{200, -20., 20.}}}); + // + registry.add("hZNApmc", "ZNA pmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPApmc", "ZPA pmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZNCpmc", "ZNC pmc; ZNC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPCpmc", "ZPC pmc; ZPC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZEM", "ZEM; ZEM1+ZEM2 amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZEM}}}); + registry.add("hZDCA", "ZNA+ZPA; ZNA+ZPA; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCC", "ZNC+ZPC; ZNC+ZPC; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZDCApmcwZDCCcut", "ZDCA w. ZDCC cut; ZDCA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCCpmcwZDCAcut", "ZDCC w. ZDCA cut; ZDCC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZNAtdc", "ZNA tdc; ZNA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPAtdc", "ZPA tdc; ZPA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZNCtdc", "ZNC tdc; ZNC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPCtdc", "ZPC tdc; ZPC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + // + registry.add("hZDCCvsA", "ZDC side C vs. side A; ZDCA; ZDCC", {HistType::kTH2F, {{{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}, {nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}}); + // + registry.add("hZNAamplvsADC", "ZNA amplitude vs. ADC; ZNA ADC; ZNA amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCamplvsADC", "ZNC amplitude vs. ADC; ZNC ADC; ZNC amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAamplvsADC", "ZPA amplitude vs. ADC; ZPA ADC; ZPA amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZPvsZEM", "ZP vs ZEM; ZEM; ZPA+ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, 2. * MaxZP}}}}); + registry.add("hZNAvsZEM", "ZNA vs ZEM; ZEM; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZEM", "ZNC vs ZEM; ZEM; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZEM", "ZPA vs ZEM; ZEM; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvsZEM", "ZPC vs ZEM; ZEM; ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNAvsZPA", "ZNA vs ZPA; ZPA; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZPC", "ZNC vs ZPC; ZPC; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); + // + registry.add("hZNCcvsZNCsum", "ZNC PMC vs PMsum; ZNCC ADC; ZNC sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + registry.add("hZNAcvsZNAsum", "ZNA PMC vs PMsum; ZNAC ADC; ZNA sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + // + registry.add("hZNCvstdc", "ZNC vs tdc; ZNC TDC (ns); ZNC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvstdc", "ZNA vs tdc; ZNA TDC (ns); ZNA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvstdc", "ZPC vs tdc; ZPC TDC (ns); ZPC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvstdc", "ZPA vs tdc; ZPA TDC (ns); ZPA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNvsV0A", "ZN vs V0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFV0}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZNAvsFT0A", "ZNA vs FT0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsFT0C", "ZNC vs FT0C", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); + // + registry.add("hZNAvscentrFT0A", "ZNA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0C", "ZNA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0M", "ZNA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvscentrFT0A", "ZPA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0C", "ZPA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0M", "ZPA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNCvscentrFT0A", "ZNC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0C", "ZNC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0M", "ZNC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvscentrFT0A", "ZPC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0C", "ZPC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0M", "ZPC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hNnZNAvscentrFT0C", "N_{neutrons} in ZNA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0C", "N_{neutrons} in ZNC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0C", "N_{protons} in ZPA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0C", "N_{protons} in ZPC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNAvscentrFT0M", "N_{neutrons} in ZNA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0M", "N_{neutrons} in ZNC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0M", "N_{protons} in ZPA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0M", "N_{protons} in ZPC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + // + registry.add("hNpvsNnZNA", "N_{protons} vs N_{neutrons} in ZNA", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + registry.add("hNpvsNnZNC", "N_{protons} vs N_{neutrons} in ZNC", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + // + registry.add("hZNAvstimestamp", "ZNA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvstimestamp", "ZNC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvstimestamp", "ZPA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvstimestamp", "ZPC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); + } + + void process(aod::ZDCLightIons const& zdclightions) + { + for (auto const& zdc : zdclightions) { + auto tdczna = zdc.znaTdc(); + auto tdcznc = zdc.zncTdc(); + auto tdczpa = zdc.zpaTdc(); + auto tdczpc = zdc.zpcTdc(); + auto tdczem1 = zdc.zem1Tdc(); + auto tdczem2 = zdc.zem2Tdc(); + auto zna = zdc.znaAmpl(); + auto znaADC = zdc.znaPmc(); + auto znapm1 = zdc.znaPm1(); + auto znapm2 = zdc.znaPm2(); + auto znapm3 = zdc.znaPm3(); + auto znapm4 = zdc.znaPm4(); + auto znc = zdc.zncAmpl(); + auto zncADC = zdc.zncPmc(); + auto zncpm1 = zdc.zncPm1(); + auto zncpm2 = zdc.zncPm2(); + auto zncpm3 = zdc.zncPm3(); + auto zncpm4 = zdc.zncPm4(); + auto zpa = zdc.zpaAmpl(); + auto zpaADC = zdc.zpaPmc(); + auto zpc = zdc.zpcAmpl(); + auto zpcADC = zdc.zpcPmc(); + auto zem1 = zdc.zem1Ampl(); + auto zem2 = zdc.zem2Ampl(); + auto multFT0A = zdc.multFt0a(); + auto multFT0C = zdc.multFt0c(); + auto multV0A = zdc.multV0a(); + auto zvtx = zdc.vertexZ(); + auto centrFT0C = zdc.centralityFt0c(); + auto centrFT0A = zdc.centralityFt0a(); + auto centrFT0M = zdc.centralityFt0m(); + auto timestamp = zdc.timestamp(); + auto selectionBits = zdc.selectionBits(); + auto bcMask = zdc.bcMask(); + + bool isZNAtdc = false; + bool isZNCtdc = false; + bool isZPAtdc = false; + bool isZPCtdc = false; + bool isZEMtdc = false; + + if (tdczna > -99999.0) { + isZNAtdc = true; + } + if (tdcznc > -99999.0) { + isZNCtdc = true; + } + if (tdczpa > -99999.0) { + isZPAtdc = true; + } + if (tdczpc > -99999.0) { + isZPCtdc = true; + } + if (tdczem1 > -99999.0 || tdczem2 > -99999.0) { + isZEMtdc = true; + } + + if (tdcCut) { // TDC cuts applied + if ((tdczna < tdcZNmincut) || (tdczna > tdcZNmaxcut)) + isZNAtdc = false; + if ((tdcznc < tdcZNmincut) || (tdcznc > tdcZNmaxcut)) + isZNCtdc = false; + if ((tdczpa < tdcZPmincut) || (tdczpa > tdcZPmaxcut)) + isZPAtdc = false; + if ((tdczpc < tdcZPmincut) || (tdczpc > tdcZPmaxcut)) + isZPCtdc = false; + } + + bool eventSelected = false; + + // for BC events ------- + if (selectBC) { + //printf("BCmask: %x \n", bcMask); + + registry.get(HIST("hBCmask"))->Fill(0., 1.); + auto isB = CHECK_BIT(bcMask, 0); + if (isB) registry.get(HIST("hBCmask"))->Fill(1., 1.); + if (CHECK_BIT(bcMask, 1)) registry.get(HIST("hBCmask"))->Fill(2., 1.); + if (CHECK_BIT(bcMask, 2)) registry.get(HIST("hBCmask"))->Fill(3., 1.); + if (CHECK_BIT(bcMask, 3)) registry.get(HIST("hBCmask"))->Fill(4., 1.); + // + if(selectOnlyB && isB) eventSelected = true; + else if(!selectOnlyB) eventSelected = true; + } + + // for collision events ------- + if (selectColl) { + bool zvtxSel = false; + if (selectZvtx && CHECK_BIT(selectionBits, 0)) + zvtxSel = true; + else if (!selectZvtx) + zvtxSel = true; + // + bool ottoSel = false; + if (sel8 && CHECK_BIT(selectionBits, 1)) + ottoSel = true; + else if (!sel8) + ottoSel = true; + // + bool isdoOccupancySel = false; + if (doOccupancySel && CHECK_BIT(selectionBits, 2)) + isdoOccupancySel = true; + else if (!doOccupancySel) + isdoOccupancySel = true; + // + bool isnoSameBunchPileupCut = false; + if (noSameBunchPileupCut && CHECK_BIT(selectionBits, 3)) + isnoSameBunchPileupCut = true; + else if (!noSameBunchPileupCut) + isnoSameBunchPileupCut = true; + // + bool isGoodZvtxFT0vsPVsel = false; + if (isGoodZvtxFT0vsPV && CHECK_BIT(selectionBits, 4)) + isGoodZvtxFT0vsPVsel = true; + else if (!isGoodZvtxFT0vsPV) + isGoodZvtxFT0vsPVsel = true; + // + bool isnoCollInTimeRangeStandard = false; + if (noCollInTimeRangeStandard && CHECK_BIT(selectionBits, 5)) + isnoCollInTimeRangeStandard = true; + else if (!noCollInTimeRangeStandard) + isnoCollInTimeRangeStandard = true; + // + bool isnoTimeFrameBorder = false; + if (noTimeFrameBorder && CHECK_BIT(selectionBits, 6)) + isnoTimeFrameBorder = true; + else if (!noTimeFrameBorder) + isnoTimeFrameBorder = true; + // + bool isnoITSROFFrameBorder = false; + if (noITSROFFrameBorder && CHECK_BIT(selectionBits, 7)) + isnoITSROFFrameBorder = true; + else if (!noITSROFFrameBorder) + isnoITSROFFrameBorder = true; + // + bool isGoodITSLayersAllsel = false; + if (isGoodITSLayersAll && CHECK_BIT(selectionBits, 8)) + isGoodITSLayersAllsel = true; + else if (!isGoodITSLayersAll) + isGoodITSLayersAllsel = true; + // + bool istriggerTVX = false; + if (!triggetTVX) + istriggerTVX = true; + else if (triggetTVX && CHECK_BIT(selectionBits, 9)) + istriggerTVX = true; + + if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) eventSelected = true; + //if (zvtxSel && ottoSel && isnoSameBunchPileupCut) eventSelected = true; + + if(eventSelected){ + registry.get(HIST("hcounts"))->Fill(0., 1.); + if(isZNAtdc) registry.get(HIST("hcounts"))->Fill(1., 1.); + if(isZPAtdc) registry.get(HIST("hcounts"))->Fill(2., 1.); + if(isZNCtdc) registry.get(HIST("hcounts"))->Fill(3., 1.); + if(isZPCtdc) registry.get(HIST("hcounts"))->Fill(4., 1.); + if(isZNAtdc || isZNCtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); + if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); + if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); + if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); + if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(9., 1.); + if(isZNAtdc && isZPAtdc) registry.get(HIST("hcounts"))->Fill(10., 1.); + if(isZNCtdc && isZPCtdc) registry.get(HIST("hcounts"))->Fill(11., 1.); + if(isZEMtdc) registry.get(HIST("hcounts"))->Fill(12., 1.); + } + } + + if(eventSelected) { + + if (enCalibZNA > 0.) { + zna *= enCalibZNA; + znaADC *= enCalibZNA; + znapm1 *= enCalibZNA; + znapm2 *= enCalibZNA; + znapm3 *= enCalibZNA; + znapm4 *= enCalibZNA; + } + if (enCalibZNC > 0.) { + znc *= enCalibZNC; + zncADC *= enCalibZNC; + zncpm1 *= enCalibZNC; + zncpm2 *= enCalibZNC; + zncpm3 *= enCalibZNC; + zncpm4 *= enCalibZNC; + } + if (enCalibZPA > 0.) { + zpa *= enCalibZPA; + zpaADC *= enCalibZPA; + } + if (enCalibZPC > 0.) { + zpc *= enCalibZPC; + zpcADC *= enCalibZPC; + } + + registry.get(HIST("hzvertex"))->Fill(zvtx); + + + if (!applyZDCcut) { + + if (isZNAtdc) registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc) registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc) registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc) registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if (isZNAtdc || isZPAtdc) registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if (isZNCtdc || isZPCtdc) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); + if (isZPAtdc || isZPCtdc) registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); + if (isZNAtdc || isZPAtdc) registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); + if (isZNCtdc || isZPCtdc) registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); + // + if (isZNAtdc) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); + if (isZNAtdc) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } + else { + bool isZNChigh = false; + if (znc >= zdccCutLow) + isZNChigh = true; + bool isZNAhigh = false; + if (zna >= zdcaCutLow) + isZNAhigh = true; + bool isZPAhigh = false; + if (zpa >= zdcaCutLow) + isZPAhigh = true; + bool isZPChigh = false; + if (zpc >= zdccCutLow) + isZPChigh = true; + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } + + // Timestamp + if (tStampOffset > timestamp) { + printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %lu \n\n", timestamp); + return; + } + //float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours + if (timestamp > tStampMax) { + printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", timestamp); + return; + } + + if (!applyZDCcut) { + if (isZNAtdc) registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + if (isZNCtdc) registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + if (isZPAtdc) registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + if (isZPCtdc) registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + } else { + if (isZNAtdc && znc >= zdccCutLow) { + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + } + if (isZPAtdc && zpc >= zdccCutLow) { + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + } + if ((isZNAtdc || isZPAtdc) && (znc >= zdccCutLow && zpc >= zdccCutLow)) { + registry.get(HIST("hZDCApmcwZDCCcut"))->Fill(zna + zpa); + } + if (isZNCtdc && zna >= zdcaCutLow) { + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + } + if (isZPCtdc && zpa >= zdcaCutLow) { + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + } + if ((isZNCtdc || isZPCtdc) && (zna >= zdcaCutLow && zpa >= zdcaCutLow)) { + registry.get(HIST("hZDCCpmcwZDCAcut"))->Fill(znc + zpc); + } + } + // TDCs + if (isZNAtdc) registry.get(HIST("hZNAtdc"))->Fill(tdczna); + if (isZNCtdc) registry.get(HIST("hZNCtdc"))->Fill(tdcznc); + if (isZPAtdc) registry.get(HIST("hZPAtdc"))->Fill(tdczpa); + if (isZPCtdc) registry.get(HIST("hZPCtdc"))->Fill(tdczpc); + // + if(isZEMtdc) { + registry.get(HIST("hZEM"))->Fill(zem1 + zem2); + registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); + registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); + registry.get(HIST("hZPAvsZEM"))->Fill(zem1 + zem2, zpa); + registry.get(HIST("hZPCvsZEM"))->Fill(zem1 + zem2, zpc); + } + if(isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); + if(isZPAtdc || isZPCtdc) registry.get(HIST("hZPvsZEM"))->Fill(zem1 + zem2, zpa + zpc); + // + if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); + // + if(centrFT0C > -1. && centrFT0C < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); + registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna/2.680); + registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc/2.680); + registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa/2.680); + registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc/2.680); + } + if(centrFT0A > -1. && centrFT0A < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); + } + if(centrFT0M > -1. && centrFT0M < 101.) { + if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); + if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); + if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); + if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna/2.680); + registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc/2.680); + registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa/2.680); + registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc/2.680); + registry.get(HIST("hNpvsNnZNA"))->Fill(zna/2.680, zpa/2.680); + registry.get(HIST("hNpvsNnZNC"))->Fill(znc/2.680, zpc/2.680); + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc) // + }; +} diff --git a/Common/DataModel/zdcTaskLightIons.cxx b/Common/DataModel/zdcTaskLightIons.cxx new file mode 100644 index 00000000000..53e906008b0 --- /dev/null +++ b/Common/DataModel/zdcTaskLightIons.cxx @@ -0,0 +1,406 @@ +// 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 zdcTaskLightIons.cxx +/// \brief Task for ZDC in light ions +/// \author chiara.oppedisano@cern.ch + +#include +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/ZDCLightIons.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +using namespace o2; +using namespace o2::aod; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::evsel; + +using BCsRun3 = soa::Join; +using ColEvSels = soa::Join; + +struct ZdcTaskLightIons { + + Produces zdcTableLI; + Service ccdb; + static const int nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches; + std::bitset beamPatternA; + std::bitset beamPatternC; + std::bitset bcPatternB; + std::bitset bcPatternA; + std::bitset bcPatternC; + std::bitset bcPatternE; + + // Configurable parameters + Configurable nBinsTiming{"nBinsTiming", 200, "n bins for debunching histo"}; + Configurable tdcCut{"tdcCut", true, "Flag for TDC cut"}; + Configurable tdcZNmincut{"tdcZNmincut", -2.5, "Min. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 2.5, "Max. ZN TDC cut value"}; + // + // Event selections + Configurable cfgEvSelVtxZ{"cfgEvSelVtxZ", 10, "Event selection: zVtx"}; + Configurable cfgEvSelSel8{"cfgEvSelSel8", true, "Event selection: sel8"}; + Configurable cfgEvSelsDoOccupancySel{"cfgEvSelsDoOccupancySel", true, "Event selection: do occupancy selection"}; + Configurable cfgEvSelsMaxOccupancy{"cfgEvSelsMaxOccupancy", 10000, "Event selection: set max occupancy"}; + Configurable cfgEvSelsNoSameBunchPileupCut{"cfgEvSelsNoSameBunchPileupCut", true, "Event selection: no same bunch pileup cut"}; + Configurable cfgEvSelsIsGoodZvtxFT0vsPV{"cfgEvSelsIsGoodZvtxFT0vsPV", true, "Event selection: is good ZVTX FT0 vs PV"}; + Configurable cfgEvSelsNoCollInTimeRangeStandard{"cfgEvSelsNoCollInTimeRangeStandard", true, "Event selection: no collision in time range standard"}; + Configurable cfgEvSelsIsVertexITSTPC{"cfgEvSelsIsVertexITSTPC", true, "Event selection: is vertex ITSTPC"}; + Configurable cfgEvSelsIsGoodITSLayersAll{"cfgEvSelsIsGoodITSLayersAll", true, "Event selection: is good ITS layers all"}; + // + HistogramRegistry registry{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + enum SelectionCriteria { + evSel_zvtx, + evSel_sel8, + evSel_occupancy, + evSel_kNoSameBunchPileup, + evSel_kIsGoodZvtxFT0vsPV, + evSel_kNoCollInTimeRangeStandard, + evSel_kNoITSROFrameBorder, + evSel_kIsGoodITSLayersAll, + evSel_allEvents, + nEventSelections + }; + + enum bcMaskBits { + bcMask_beamB, + bcMask_beamA, + bcMask_beamC, + bcMask_beamE, + nBits + }; + + void init(InitContext const&) + { + registry.add("zdcDebunchHist", "ZN sum vs. diff; ZNA-ZNC (ns); ZNA+ZNC (ns)", {HistType::kTH2D, {{nBinsTiming, -20., 20.}, {nBinsTiming, -20., 20.}}}); + + if (doprocessALICEcoll) { + registry.add("hEventCount", "Number of Event; Cut; #Events Passed Cut", {HistType::kTH1D, {{nEventSelections, 0, nEventSelections}}}); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_allEvents + 1, "All events"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_zvtx + 1, "vtxZ"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_sel8 + 1, "Sel8"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_occupancy + 1, "kOccupancy"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoSameBunchPileup + 1, "kNoSameBunchPileup"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kIsGoodZvtxFT0vsPV + 1, "kIsGoodZvtxFT0vsPV"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoCollInTimeRangeStandard + 1, "kNoCollInTimeRangeStandard"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoITSROFrameBorder + 1, "kNoITSROFrameBorder"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kIsGoodITSLayersAll + 1, "kkIsGoodITSLayersAll"); + } + } + + template + uint8_t eventSelected(const TCollision& collision) + { + uint8_t selectionBits = 0; + bool selected; + + registry.fill(HIST("hEventCount"), evSel_allEvents); + + selected = std::fabs(collision.posZ()) < cfgEvSelVtxZ; + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_zvtx); + registry.fill(HIST("hEventCount"), evSel_zvtx); + } + + selected = collision.sel8(); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_sel8); + registry.fill(HIST("hEventCount"), evSel_sel8); + } + + auto occupancy = collision.trackOccupancyInTimeRange(); + selected = occupancy <= cfgEvSelsMaxOccupancy; + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_occupancy); + registry.fill(HIST("hEventCount"), evSel_occupancy); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoSameBunchPileup); + registry.fill(HIST("hEventCount"), evSel_kNoSameBunchPileup); + } + + selected = collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kIsGoodZvtxFT0vsPV); + registry.fill(HIST("hEventCount"), evSel_kIsGoodZvtxFT0vsPV); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoCollInTimeRangeStandard); + registry.fill(HIST("hEventCount"), evSel_kNoCollInTimeRangeStandard); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoITSROFrameBorder); + registry.fill(HIST("hEventCount"), evSel_kNoITSROFrameBorder); + } + + selected = collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kIsGoodITSLayersAll); + registry.fill(HIST("hEventCount"), evSel_kIsGoodITSLayersAll); + } + + return selectionBits; + } + + void processZDCBC(BCsRun3 const& bcs, aod::Zdcs const& /*zdcs*/) + { + auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance(); + uint64_t timeStamp = bcs.iteratorAt(0).timestamp(); + std::map metadata; + // use getSpecific to set metadata to avoid crashes related to specific run number + auto grplhcif = ccdbMgr.getSpecific("GLO/Config/GRPLHCIF", timeStamp, metadata); + //auto grplhcif = ccdb->getForTimeStamp("GLO/Config/GRPLHCIF", timeStamp); + if (grplhcif == nullptr) { + LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp; + } + + beamPatternA = grplhcif->getBunchFilling().getBeamPattern(0); + beamPatternC = grplhcif->getBunchFilling().getBeamPattern(1); + bcPatternB = grplhcif->getBunchFilling().getBCPattern(); + bcPatternA = beamPatternA & ~beamPatternC; + bcPatternC = ~beamPatternA & beamPatternC; + bcPatternE = ~beamPatternA & ~beamPatternC; + + for (const auto& bc : bcs) { + + if (bc.has_zdc()) { + + //int64_t timestamp = bc.timestamp(); + auto timestampFromSOR = (bc.timestamp() - grplhcif->getFillNumberTime()) / 1e3; // Convert to seconds + + int bcInOrbit = bc.globalBC() % nBCsPerOrbit; + + uint8_t maskSel = 0; + if(bcPatternB[bcInOrbit]){ + maskSel |= (uint8_t)(0x1u << bcMask_beamB); + } + if(bcPatternA[bcInOrbit]){ + maskSel |= (uint8_t)(0x1u << bcMask_beamA); + } + if(bcPatternC[bcInOrbit]){ + maskSel |= (uint8_t)(0x1u << bcMask_beamC); + } + if(bcPatternE[bcInOrbit]){ + maskSel |= (uint8_t)(0x1u << bcMask_beamE); + } + + + auto tdcZNA = bc.zdc().timeZNA(); + auto tdcZNC = bc.zdc().timeZNC(); + auto tdcZPA = bc.zdc().timeZPA(); + auto tdcZPC = bc.zdc().timeZPC(); + auto tdcZEM1 = bc.zdc().timeZEM1(); + auto tdcZEM2 = bc.zdc().timeZEM2(); + // + double zna = bc.zdc().amplitudeZNA(); + double znc = bc.zdc().amplitudeZNC(); + double zpa = bc.zdc().amplitudeZPA(); + double zpc = bc.zdc().amplitudeZPC(); + double zem1 = bc.zdc().amplitudeZEM1(); + double zem2 = bc.zdc().amplitudeZEM2(); + // + double pmcZNA = bc.zdc().energyCommonZNA(); + double pmcZNC = bc.zdc().energyCommonZNC(); + double pmcZPA = bc.zdc().energyCommonZPA(); + double pmcZPC = bc.zdc().energyCommonZPC(); + double pmqZNC[4] = { + 0, + 0, + 0, + 0, + }; + double pmqZNA[4] = { + 0, + 0, + 0, + 0, + }; + const int noofZNsectors = 4; + for (int itow = 0; itow < noofZNsectors; itow++) { + pmqZNA[itow] = (bc.zdc().energySectorZNA())[itow]; + pmqZNC[itow] = (bc.zdc().energySectorZNC())[itow]; + } + + bool isZNChit = false, isZNAhit = false; + if (tdcCut) { // a narrow TDC window is set + if ((tdcZNC >= tdcZNmincut) && (tdcZNC <= tdcZNmaxcut)) { + isZNChit = true; + } + if ((tdcZNA >= tdcZNmincut) && (tdcZNA <= tdcZNmaxcut)) { + isZNAhit = true; + } + } else { // if no window on TDC is set + if (pmcZNC > 0.) { + isZNChit = true; + } + if (pmcZNA > 0.) { + isZNAhit = true; + } + } + if (isZNChit && isZNAhit) { + registry.get(HIST("zdcDebunchHist"))->Fill(zna - znc, zna + znc); + } + + zdcTableLI(tdcZNA, zna, pmcZNA, pmqZNA[0], pmqZNA[1], pmqZNA[2], pmqZNA[3], + tdcZNC, znc, pmcZNC, pmqZNC[0], pmqZNC[1], pmqZNC[2], pmqZNC[3], + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, + -1, -1, -1, + -1., + -1, -1, -1, + timestampFromSOR, + 0, + maskSel); + } + } + } + /// name, description, function pointer, default value + /// note that it has to be declared after the function, so that the pointer is known + PROCESS_SWITCH(ZdcTaskLightIons, processZDCBC, "Processing ZDC 4 auto-triggered events", true); + + void processALICEcoll(ColEvSels const& cols, BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/, aod::FT0s const& /*ft0s*/, aod::FV0As const& /*fv0*/) + { + // collision-based event selection + for (auto const& collision : cols) { + + const auto& foundBC = collision.foundBC_as(); + uint8_t evSelection = eventSelected(collision); + auto zv = collision.posZ(); + auto centralityFT0C = collision.centFT0C(); + auto centralityFT0A = collision.centFT0A(); + auto centralityFT0M = collision.centFT0M(); + + // FT0 + float multFT0A = 0.; + float multFT0C = 0.; + if (foundBC.has_ft0()) { + for (auto const& amplitude : foundBC.ft0().amplitudeA()) { + multFT0A += amplitude; + } + for (auto const& amplitude : foundBC.ft0().amplitudeC()) { + multFT0C += amplitude; + } + } + // FV0 + float multV0A = 0; + if (foundBC.has_fv0a()) { + for (auto const& amplitude : foundBC.fv0a().amplitude()) { + multV0A += amplitude; + } + } + + if (foundBC.has_zdc()) { + const auto& zdc = foundBC.zdc(); + + auto tdcZNA = zdc.timeZNA(); + auto tdcZNC = zdc.timeZNC(); + auto tdcZPA = zdc.timeZPA(); + auto tdcZPC = zdc.timeZPC(); + auto tdcZEM1 = zdc.timeZEM1(); + auto tdcZEM2 = zdc.timeZEM2(); + // + double zna = zdc.amplitudeZNA(); + double znc = zdc.amplitudeZNC(); + double zpa = zdc.amplitudeZPA(); + double zpc = zdc.amplitudeZPC(); + double zem1 = zdc.amplitudeZEM1(); + double zem2 = zdc.amplitudeZEM2(); + // + double pmcZNA = zdc.energyCommonZNA(); + double pmcZNC = zdc.energyCommonZNC(); + double pmcZPA = zdc.energyCommonZPA(); + double pmcZPC = zdc.energyCommonZPC(); + double pmqZNC[4] = { + 0, + 0, + 0, + 0, + }; + double pmqZNA[4] = { + 0, + 0, + 0, + 0, + }; + const int noofZNsectors = 4; + for (int itow = 0; itow < noofZNsectors; itow++) { + pmqZNA[itow] = (zdc.energySectorZNA())[itow]; + pmqZNC[itow] = (zdc.energySectorZNC())[itow]; + } + + bool isZNChit = false, isZNAhit = false; + if (tdcCut) { // a narrow TDC window is set + if ((tdcZNC >= tdcZNmincut) && (tdcZNC <= tdcZNmaxcut)) { + isZNChit = true; + } + if ((tdcZNA >= tdcZNmincut) && (tdcZNA <= tdcZNmaxcut)) { + isZNAhit = true; + } + } else { // if no window on TDC is set + if (pmcZNC > 0.) { + isZNChit = true; + } + if (pmcZNA > 0.) { + isZNAhit = true; + } + } + if (isZNChit && isZNAhit) { + registry.get(HIST("zdcDebunchHist"))->Fill(zna - znc, zna + znc); + } + + zdcTableLI(tdcZNA, zna, pmcZNA, pmqZNA[0], pmqZNA[1], pmqZNA[2], pmqZNA[3], + tdcZNC, znc, pmcZNC, pmqZNC[0], pmqZNC[1], pmqZNC[2], pmqZNC[3], + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, + multFT0A, multFT0C, multV0A, + zv, + centralityFT0C, centralityFT0A, centralityFT0M, + foundBC.timestamp(), + evSelection, + 0); + } + } + } + /// name, description, function pointer, default value + /// note that it has to be declared after the function, so that the pointer is known + PROCESS_SWITCH(ZdcTaskLightIons, processALICEcoll, "Processing ZDC for ALICE collisions", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) // o2-linter: disable=name/file-cpp +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +}Common/Tasks/zdcTableReader.cxx \ No newline at end of file From 25b67136a43eebd4fc49262a5847996482996076 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 11:23:59 +0200 Subject: [PATCH 05/10] Fix include order and clean up commented code --- Common/DataModel/zdcTaskLightIons.cxx | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/Common/DataModel/zdcTaskLightIons.cxx b/Common/DataModel/zdcTaskLightIons.cxx index 53e906008b0..6f7a573cc6d 100644 --- a/Common/DataModel/zdcTaskLightIons.cxx +++ b/Common/DataModel/zdcTaskLightIons.cxx @@ -13,11 +13,12 @@ /// \brief Task for ZDC in light ions /// \author chiara.oppedisano@cern.ch -#include #include "Common/CCDB/EventSelectionParams.h" #include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/ZDCLightIons.h" + +#include #include #include #include @@ -180,11 +181,11 @@ struct ZdcTaskLightIons { std::map metadata; // use getSpecific to set metadata to avoid crashes related to specific run number auto grplhcif = ccdbMgr.getSpecific("GLO/Config/GRPLHCIF", timeStamp, metadata); - //auto grplhcif = ccdb->getForTimeStamp("GLO/Config/GRPLHCIF", timeStamp); + // auto grplhcif = ccdb->getForTimeStamp("GLO/Config/GRPLHCIF", timeStamp); if (grplhcif == nullptr) { LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp; } - + beamPatternA = grplhcif->getBunchFilling().getBeamPattern(0); beamPatternC = grplhcif->getBunchFilling().getBeamPattern(1); bcPatternB = grplhcif->getBunchFilling().getBCPattern(); @@ -195,27 +196,26 @@ struct ZdcTaskLightIons { for (const auto& bc : bcs) { if (bc.has_zdc()) { - - //int64_t timestamp = bc.timestamp(); + + // int64_t timestamp = bc.timestamp(); auto timestampFromSOR = (bc.timestamp() - grplhcif->getFillNumberTime()) / 1e3; // Convert to seconds int bcInOrbit = bc.globalBC() % nBCsPerOrbit; - + uint8_t maskSel = 0; - if(bcPatternB[bcInOrbit]){ + if (bcPatternB[bcInOrbit]) { maskSel |= (uint8_t)(0x1u << bcMask_beamB); } - if(bcPatternA[bcInOrbit]){ + if (bcPatternA[bcInOrbit]) { maskSel |= (uint8_t)(0x1u << bcMask_beamA); } - if(bcPatternC[bcInOrbit]){ + if (bcPatternC[bcInOrbit]) { maskSel |= (uint8_t)(0x1u << bcMask_beamC); } - if(bcPatternE[bcInOrbit]){ + if (bcPatternE[bcInOrbit]) { maskSel |= (uint8_t)(0x1u << bcMask_beamE); } - auto tdcZNA = bc.zdc().timeZNA(); auto tdcZNC = bc.zdc().timeZNC(); auto tdcZPA = bc.zdc().timeZPA(); @@ -403,4 +403,5 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) // o2-linter: disab { return WorkflowSpec{ adaptAnalysisTask(cfgc)}; -}Common/Tasks/zdcTableReader.cxx \ No newline at end of file +} +Common / Tasks / zdcTableReader.cxx From 08de68a0550321b5cea302cb7b08c2e841c24df8 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 11:24:22 +0200 Subject: [PATCH 06/10] Refactor and clean up zdcTableReader.cxx code --- Common/DataModel/zdcTableReader.cxx | 309 ++++++++++++++++++---------- 1 file changed, 195 insertions(+), 114 deletions(-) diff --git a/Common/DataModel/zdcTableReader.cxx b/Common/DataModel/zdcTableReader.cxx index 1cd05bda4dd..1e1137d8cfa 100644 --- a/Common/DataModel/zdcTableReader.cxx +++ b/Common/DataModel/zdcTableReader.cxx @@ -41,11 +41,11 @@ struct ZDCLIAnalysis { Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; Configurable tStampMax{"tStampMax", 1000, ",maximum value for timestamp"}; // - Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; + Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; - Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; Configurable tdcZPmincut{"tdcZPmincut", -1.5, "Min. ZP TDC cut value"}; - Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; + Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; // Configurable nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; Configurable nBinsAmpZN{"nBinsAmpZN", 1025, "n bins 4 ZN amplitudes"}; @@ -235,22 +235,28 @@ struct ZDCLIAnalysis { if ((tdczpc < tdcZPmincut) || (tdczpc > tdcZPmaxcut)) isZPCtdc = false; } - + bool eventSelected = false; // for BC events ------- if (selectBC) { - //printf("BCmask: %x \n", bcMask); + // printf("BCmask: %x \n", bcMask); registry.get(HIST("hBCmask"))->Fill(0., 1.); auto isB = CHECK_BIT(bcMask, 0); - if (isB) registry.get(HIST("hBCmask"))->Fill(1., 1.); - if (CHECK_BIT(bcMask, 1)) registry.get(HIST("hBCmask"))->Fill(2., 1.); - if (CHECK_BIT(bcMask, 2)) registry.get(HIST("hBCmask"))->Fill(3., 1.); - if (CHECK_BIT(bcMask, 3)) registry.get(HIST("hBCmask"))->Fill(4., 1.); + if (isB) + registry.get(HIST("hBCmask"))->Fill(1., 1.); + if (CHECK_BIT(bcMask, 1)) + registry.get(HIST("hBCmask"))->Fill(2., 1.); + if (CHECK_BIT(bcMask, 2)) + registry.get(HIST("hBCmask"))->Fill(3., 1.); + if (CHECK_BIT(bcMask, 3)) + registry.get(HIST("hBCmask"))->Fill(4., 1.); // - if(selectOnlyB && isB) eventSelected = true; - else if(!selectOnlyB) eventSelected = true; + if (selectOnlyB && isB) + eventSelected = true; + else if (!selectOnlyB) + eventSelected = true; } // for collision events ------- @@ -315,27 +321,40 @@ struct ZDCLIAnalysis { else if (triggetTVX && CHECK_BIT(selectionBits, 9)) istriggerTVX = true; - if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) eventSelected = true; - //if (zvtxSel && ottoSel && isnoSameBunchPileupCut) eventSelected = true; - - if(eventSelected){ + if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) + eventSelected = true; + // if (zvtxSel && ottoSel && isnoSameBunchPileupCut) eventSelected = true; + + if (eventSelected) { registry.get(HIST("hcounts"))->Fill(0., 1.); - if(isZNAtdc) registry.get(HIST("hcounts"))->Fill(1., 1.); - if(isZPAtdc) registry.get(HIST("hcounts"))->Fill(2., 1.); - if(isZNCtdc) registry.get(HIST("hcounts"))->Fill(3., 1.); - if(isZPCtdc) registry.get(HIST("hcounts"))->Fill(4., 1.); - if(isZNAtdc || isZNCtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); - if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); - if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); - if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); - if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(9., 1.); - if(isZNAtdc && isZPAtdc) registry.get(HIST("hcounts"))->Fill(10., 1.); - if(isZNCtdc && isZPCtdc) registry.get(HIST("hcounts"))->Fill(11., 1.); - if(isZEMtdc) registry.get(HIST("hcounts"))->Fill(12., 1.); + if (isZNAtdc) + registry.get(HIST("hcounts"))->Fill(1., 1.); + if (isZPAtdc) + registry.get(HIST("hcounts"))->Fill(2., 1.); + if (isZNCtdc) + registry.get(HIST("hcounts"))->Fill(3., 1.); + if (isZPCtdc) + registry.get(HIST("hcounts"))->Fill(4., 1.); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hcounts"))->Fill(5., 1.); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hcounts"))->Fill(6., 1.); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(7., 1.); + if (isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(8., 1.); + if (isZNAtdc && isZNCtdc) + registry.get(HIST("hcounts"))->Fill(9., 1.); + if (isZNAtdc && isZPAtdc) + registry.get(HIST("hcounts"))->Fill(10., 1.); + if (isZNCtdc && isZPCtdc) + registry.get(HIST("hcounts"))->Fill(11., 1.); + if (isZEMtdc) + registry.get(HIST("hcounts"))->Fill(12., 1.); } } - - if(eventSelected) { + + if (eventSelected) { if (enCalibZNA > 0.) { zna *= enCalibZNA; @@ -364,40 +383,61 @@ struct ZDCLIAnalysis { registry.get(HIST("hzvertex"))->Fill(zvtx); - if (!applyZDCcut) { - if (isZNAtdc) registry.get(HIST("hZNApmc"))->Fill(zna); - if (isZNCtdc) registry.get(HIST("hZNCpmc"))->Fill(znc); - if (isZPAtdc) registry.get(HIST("hZPApmc"))->Fill(zpa); - if (isZPCtdc) registry.get(HIST("hZPCpmc"))->Fill(zpc); + if (isZNAtdc) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc) + registry.get(HIST("hZPCpmc"))->Fill(zpc); // - if (isZNAtdc || isZPAtdc) registry.get(HIST("hZDCA"))->Fill(zna + zpa); - if (isZNCtdc || isZPCtdc) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); // - if (isZNAtdc) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); - if (isZNCtdc) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); - if (isZPAtdc) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); - if (isZPCtdc) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + if (isZNAtdc) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); // - if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); - if (isZPAtdc || isZPCtdc) registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); - if (isZNAtdc || isZPAtdc) registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); - if (isZNCtdc || isZPCtdc) registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); // - if (isZNAtdc) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); - if (isZNCtdc) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); - if (isZPAtdc) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); - if (isZPCtdc) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + if (isZNAtdc) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); // - if (isZNAtdc) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); - if (isZNCtdc) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + if (isZNAtdc) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); // - if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); - if (isZNAtdc) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); - if (isZNCtdc) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); - } - else { + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); + if (isZNAtdc) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } else { bool isZNChigh = false; if (znc >= zdccCutLow) isZNChigh = true; @@ -411,47 +451,69 @@ struct ZDCLIAnalysis { if (zpc >= zdccCutLow) isZPChigh = true; // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNApmc"))->Fill(zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCpmc"))->Fill(znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPApmc"))->Fill(zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCpmc"))->Fill(zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCpmc"))->Fill(zpc); // - if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) registry.get(HIST("hZDCA"))->Fill(zna + zpa); - if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); } - - // Timestamp + + // Timestamp if (tStampOffset > timestamp) { printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %lu \n\n", timestamp); return; } - //float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours + // float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours if (timestamp > tStampMax) { printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", timestamp); return; } - if (!applyZDCcut) { - if (isZNAtdc) registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); - if (isZNCtdc) registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); - if (isZPAtdc) registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); - if (isZPCtdc) registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + if (!applyZDCcut) { + if (isZNAtdc) + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); } else { if (isZNAtdc && znc >= zdccCutLow) { registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); @@ -473,50 +535,69 @@ struct ZDCLIAnalysis { } } // TDCs - if (isZNAtdc) registry.get(HIST("hZNAtdc"))->Fill(tdczna); - if (isZNCtdc) registry.get(HIST("hZNCtdc"))->Fill(tdcznc); - if (isZPAtdc) registry.get(HIST("hZPAtdc"))->Fill(tdczpa); - if (isZPCtdc) registry.get(HIST("hZPCtdc"))->Fill(tdczpc); + if (isZNAtdc) + registry.get(HIST("hZNAtdc"))->Fill(tdczna); + if (isZNCtdc) + registry.get(HIST("hZNCtdc"))->Fill(tdcznc); + if (isZPAtdc) + registry.get(HIST("hZPAtdc"))->Fill(tdczpa); + if (isZPCtdc) + registry.get(HIST("hZPCtdc"))->Fill(tdczpc); // - if(isZEMtdc) { + if (isZEMtdc) { registry.get(HIST("hZEM"))->Fill(zem1 + zem2); registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); registry.get(HIST("hZPAvsZEM"))->Fill(zem1 + zem2, zpa); registry.get(HIST("hZPCvsZEM"))->Fill(zem1 + zem2, zpc); } - if(isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); - if(isZPAtdc || isZPCtdc) registry.get(HIST("hZPvsZEM"))->Fill(zem1 + zem2, zpa + zpc); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPvsZEM"))->Fill(zem1 + zem2, zpa + zpc); // - if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); + if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) + registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); // - if(centrFT0C > -1. && centrFT0C < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); - registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna/2.680); - registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc/2.680); - registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa/2.680); - registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc/2.680); + if (centrFT0C > -1. && centrFT0C < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); + registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc / 2.680); } - if(centrFT0A > -1. && centrFT0A < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); + if (centrFT0A > -1. && centrFT0A < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); } - if(centrFT0M > -1. && centrFT0M < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); - registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna/2.680); - registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc/2.680); - registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa/2.680); - registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc/2.680); - registry.get(HIST("hNpvsNnZNA"))->Fill(zna/2.680, zpa/2.680); - registry.get(HIST("hNpvsNnZNC"))->Fill(znc/2.680, zpc/2.680); + if (centrFT0M > -1. && centrFT0M < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc / 2.680); + registry.get(HIST("hNpvsNnZNA"))->Fill(zna / 2.680, zpa / 2.680); + registry.get(HIST("hNpvsNnZNC"))->Fill(znc / 2.680, zpc / 2.680); } } } From 9c8a62b355baa0715ed0e5452d12956464f00171 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 11:40:20 +0200 Subject: [PATCH 07/10] Fix variable name typo for triggerTVX --- Common/DataModel/zdcTableReader.cxx | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/Common/DataModel/zdcTableReader.cxx b/Common/DataModel/zdcTableReader.cxx index 1e1137d8cfa..ef7c3f19e85 100644 --- a/Common/DataModel/zdcTableReader.cxx +++ b/Common/DataModel/zdcTableReader.cxx @@ -23,6 +23,8 @@ #include #include +#include + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -39,7 +41,7 @@ struct ZDCLIAnalysis { // Configurable tStampOffset{"tStampOffset", 0, "offset value for timestamp"}; Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; - Configurable tStampMax{"tStampMax", 1000, ",maximum value for timestamp"}; + Configurable tStampMax{"tStampMax", 1000, ", maximum value for timestamp"}; // Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; @@ -70,7 +72,7 @@ struct ZDCLIAnalysis { // Configurable selectZvtx{"selectZvtx", true, "Activate Z vertex selection"}; Configurable sel8{"sel8", true, "Activate sel8 selection"}; - Configurable triggetTVX{"triggerTVX", true, "Activate trigger TVX selection"}; + Configurable triggerTVX{"triggerTVX", true, "Activate trigger TVX selection"}; Configurable doOccupancySel{"doOccupancySel", false, "Activate occupancy selection"}; Configurable noSameBunchPileupCut{"noSameBunchPileupCut", true, "Activate no same bunch pileup selection"}; Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", true, "Activate is good Z vertex FT0 vs PV selection"}; @@ -316,9 +318,9 @@ struct ZDCLIAnalysis { isGoodITSLayersAllsel = true; // bool istriggerTVX = false; - if (!triggetTVX) + if (triggerTVX && CHECK_BIT(selectionBits, 9)) istriggerTVX = true; - else if (triggetTVX && CHECK_BIT(selectionBits, 9)) + else if (!triggerTVX) istriggerTVX = true; if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) From e7d2a4cdb57c51231f68b6dfdb24e633724a6122 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 11:59:28 +0200 Subject: [PATCH 08/10] Add files via upload --- Common/zdcTableReader.cxx | 614 ++++++++++++++++++++++++++++++++++++ Common/zdcTaskLightIons.cxx | 408 ++++++++++++++++++++++++ 2 files changed, 1022 insertions(+) create mode 100644 Common/zdcTableReader.cxx create mode 100644 Common/zdcTaskLightIons.cxx diff --git a/Common/zdcTableReader.cxx b/Common/zdcTableReader.cxx new file mode 100644 index 00000000000..ef7c3f19e85 --- /dev/null +++ b/Common/zdcTableReader.cxx @@ -0,0 +1,614 @@ +// 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. +/// +/// \brief Read output table from ZDC light ion task +/// \author chiara.oppedisano@cern.ch +// + +#include "Common/DataModel/ZDCLightIons.h" + +#include +#include +#include +#include + +#include +#include + +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod; + +#define CHECK_BIT(var, pos) (((var) >> (pos)) & 1) + +struct ZDCLIAnalysis { + + // Configurable + Configurable selectBC{"selectBC", 0, "Select BC events"}; + Configurable selectOnlyB{"selectOnlyB", 0, "Select BC with A && C"}; + Configurable selectColl{"selectColl", 0, "Select ALICE collision events"}; + // + Configurable tStampOffset{"tStampOffset", 0, "offset value for timestamp"}; + Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; + Configurable tStampMax{"tStampMax", 1000, ", maximum value for timestamp"}; + // + Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; + Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; + Configurable tdcZPmincut{"tdcZPmincut", -1.5, "Min. ZP TDC cut value"}; + Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; + // + Configurable nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; + Configurable nBinsAmpZN{"nBinsAmpZN", 1025, "n bins 4 ZN amplitudes"}; + Configurable nBinsAmpZP{"nBinsAmpZP", 1025, "n bins 4 ZP amplitudes"}; + Configurable nBinsTDC{"nBinsTDC", 480, "n bins 4 TDCs"}; + Configurable nBinsFit{"nBinsFit", 1000, "n bins 4 FIT"}; + Configurable MaxZN{"MaxZN", 4099.5, "Max 4 ZN histos"}; + Configurable MaxZP{"MaxZP", 3099.5, "Max 4 ZP histos"}; + Configurable MaxZEM{"MaxZEM", 3099.5, "Max 4 ZEM histos"}; + // + Configurable MaxMultFV0{"MaxMultFV0", 3000, "Max 4 FV0 histos"}; + Configurable MaxMultFT0{"MaxMultFT0", 3000, "Max 4 FT0 histos"}; + // + Configurable enCalibZNA{"enCalibZNA", 1.0, "Energy calibration ZNA"}; + Configurable enCalibZNC{"enCalibZNC", 1.0, "Energy calibration ZNC"}; + Configurable enCalibZPA{"enCalibZPA", 1.0, "Energy calibration ZPA"}; + Configurable enCalibZPC{"enCalibZPC", 1.0, "Energy calibration ZPC"}; + // + Configurable applyZDCcut{"applyZDCcut", false, "Apply ZDC cut for light ion analysis"}; + Configurable zdcaCutLow{"zdcaCutLow", 12., "ZDCA cut for light ion analysis"}; + Configurable zdccCutLow{"zdccCutLow", 12., "ZDCC cut for light ion analysis"}; + // + Configurable selectZvtx{"selectZvtx", true, "Activate Z vertex selection"}; + Configurable sel8{"sel8", true, "Activate sel8 selection"}; + Configurable triggerTVX{"triggerTVX", true, "Activate trigger TVX selection"}; + Configurable doOccupancySel{"doOccupancySel", false, "Activate occupancy selection"}; + Configurable noSameBunchPileupCut{"noSameBunchPileupCut", true, "Activate no same bunch pileup selection"}; + Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", true, "Activate is good Z vertex FT0 vs PV selection"}; + Configurable noCollInTimeRangeStandard{"noCollInTimeRangeStandard", true, "Activate no collision in time range standard selection"}; + Configurable noTimeFrameBorder{"noTimeFrameBorder", true, "Activate no time frame border selection"}; + Configurable noITSROFFrameBorder{"noITSROFFrameBorder", true, "Activate no ITS ROF frame border selection"}; + Configurable isGoodITSLayersAll{"isGoodITSLayersAll", false, "Activate is good ITS layers all selection"}; + // + HistogramRegistry registry{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + void init(InitContext const&) + { + registry.add("hBCmask", "mask; BC; counts", {HistType::kTH1F, {{5, 0., 5.}}}); + registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{14, 0., 14.}}}); + registry.add("hzvertex", "z vertex; z_vertex (cm); Entries", {HistType::kTH1F, {{200, -20., 20.}}}); + // + registry.add("hZNApmc", "ZNA pmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPApmc", "ZPA pmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZNCpmc", "ZNC pmc; ZNC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); + registry.add("hZPCpmc", "ZPC pmc; ZPC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); + registry.add("hZEM", "ZEM; ZEM1+ZEM2 amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZEM}}}); + registry.add("hZDCA", "ZNA+ZPA; ZNA+ZPA; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCC", "ZNC+ZPC; ZNC+ZPC; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZDCApmcwZDCCcut", "ZDCA w. ZDCC cut; ZDCA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + registry.add("hZDCCpmcwZDCAcut", "ZDCC w. ZDCA cut; ZDCC amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}); + // + registry.add("hZNAtdc", "ZNA tdc; ZNA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPAtdc", "ZPA tdc; ZPA tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZNCtdc", "ZNC tdc; ZNC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + registry.add("hZPCtdc", "ZPC tdc; ZPC tdc; Entries", {HistType::kTH1F, {{520, -14., 12.}}}); + // + registry.add("hZDCCvsA", "ZDC side C vs. side A; ZDCA; ZDCC", {HistType::kTH2F, {{{nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}, {nBinsAmpZN + nBinsAmpZP, -0.5, MaxZN + MaxZP}}}}); + // + registry.add("hZNAamplvsADC", "ZNA amplitude vs. ADC; ZNA ADC; ZNA amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCamplvsADC", "ZNC amplitude vs. ADC; ZNC ADC; ZNC amplitude", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, 3. * MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAamplvsADC", "ZPA amplitude vs. ADC; ZPA ADC; ZPA amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZPvsZEM", "ZP vs ZEM; ZEM; ZPA+ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, 2. * MaxZP}}}}); + registry.add("hZNAvsZEM", "ZNA vs ZEM; ZEM; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZEM", "ZNC vs ZEM; ZEM; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZEM", "ZPA vs ZEM; ZEM; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvsZEM", "ZPC vs ZEM; ZEM; ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNAvsZPA", "ZNA vs ZPA; ZPA; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsZPC", "ZNC vs ZPC; ZPC; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZN, -0.5, MaxZN}}}}); + // + registry.add("hZNCcvsZNCsum", "ZNC PMC vs PMsum; ZNCC ADC; ZNC sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + registry.add("hZNAcvsZNAsum", "ZNA PMC vs PMsum; ZNAC ADC; ZNA sum", {HistType::kTH2F, {{{nBinsADC, -0.5, 3. * MaxZN}, {nBinsADC, -0.5, 3. * MaxZN}}}}); + // + registry.add("hZNCvstdc", "ZNC vs tdc; ZNC TDC (ns); ZNC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvstdc", "ZNA vs tdc; ZNA TDC (ns); ZNA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvstdc", "ZPC vs tdc; ZPC TDC (ns); ZPC amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvstdc", "ZPA vs tdc; ZPA TDC (ns); ZPA amplitude", {HistType::kTH2F, {{{480, -13.5, 11.45}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hZNvsV0A", "ZN vs V0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFV0}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZNAvsFT0A", "ZNA vs FT0A", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvsFT0C", "ZNC vs FT0C", {HistType::kTH2F, {{{nBinsFit, 0., MaxMultFT0}, {nBinsAmpZN, -0.5, MaxZN}}}}); + // + registry.add("hZNAvscentrFT0A", "ZNA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0C", "ZNA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNAvscentrFT0M", "ZNA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvscentrFT0A", "ZPA vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0C", "ZPA vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPAvscentrFT0M", "ZPA vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZNCvscentrFT0A", "ZNC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0C", "ZNC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvscentrFT0M", "ZNC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPCvscentrFT0A", "ZPC vs centrality FT0A", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0C", "ZPC vs centrality FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvscentrFT0M", "ZPC vs centrality FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {nBinsAmpZP, -0.5, MaxZP}}}}); + // + registry.add("hNnZNAvscentrFT0C", "N_{neutrons} in ZNA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0C", "N_{neutrons} in ZNC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0C", "N_{protons} in ZPA vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0C", "N_{protons} in ZPC vs FT0C", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNAvscentrFT0M", "N_{neutrons} in ZNA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNnZNCvscentrFT0M", "N_{neutrons} in ZNC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPAvscentrFT0M", "N_{protons} in ZPA vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + registry.add("hNpZPCvscentrFT0M", "N_{protons} in ZPC vs FT0M", {HistType::kTH2F, {{{100, 0., 100.}, {12, -0.5, 11.5}}}}); + // + registry.add("hNpvsNnZNA", "N_{protons} vs N_{neutrons} in ZNA", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + registry.add("hNpvsNnZNC", "N_{protons} vs N_{neutrons} in ZNC", {HistType::kTH2F, {{{12, -0.5, 11.5}, {12, -0.5, 11.5}}}}); + // + registry.add("hZNAvstimestamp", "ZNA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZNCvstimestamp", "ZNC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvstimestamp", "ZPA vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvstimestamp", "ZPC vs timestamp", {HistType::kTH2F, {{{nBinstStamp, 0., tStampMax}, {nBinsAmpZP, -0.5, MaxZP}}}}); + } + + void process(aod::ZDCLightIons const& zdclightions) + { + for (auto const& zdc : zdclightions) { + auto tdczna = zdc.znaTdc(); + auto tdcznc = zdc.zncTdc(); + auto tdczpa = zdc.zpaTdc(); + auto tdczpc = zdc.zpcTdc(); + auto tdczem1 = zdc.zem1Tdc(); + auto tdczem2 = zdc.zem2Tdc(); + auto zna = zdc.znaAmpl(); + auto znaADC = zdc.znaPmc(); + auto znapm1 = zdc.znaPm1(); + auto znapm2 = zdc.znaPm2(); + auto znapm3 = zdc.znaPm3(); + auto znapm4 = zdc.znaPm4(); + auto znc = zdc.zncAmpl(); + auto zncADC = zdc.zncPmc(); + auto zncpm1 = zdc.zncPm1(); + auto zncpm2 = zdc.zncPm2(); + auto zncpm3 = zdc.zncPm3(); + auto zncpm4 = zdc.zncPm4(); + auto zpa = zdc.zpaAmpl(); + auto zpaADC = zdc.zpaPmc(); + auto zpc = zdc.zpcAmpl(); + auto zpcADC = zdc.zpcPmc(); + auto zem1 = zdc.zem1Ampl(); + auto zem2 = zdc.zem2Ampl(); + auto multFT0A = zdc.multFt0a(); + auto multFT0C = zdc.multFt0c(); + auto multV0A = zdc.multV0a(); + auto zvtx = zdc.vertexZ(); + auto centrFT0C = zdc.centralityFt0c(); + auto centrFT0A = zdc.centralityFt0a(); + auto centrFT0M = zdc.centralityFt0m(); + auto timestamp = zdc.timestamp(); + auto selectionBits = zdc.selectionBits(); + auto bcMask = zdc.bcMask(); + + bool isZNAtdc = false; + bool isZNCtdc = false; + bool isZPAtdc = false; + bool isZPCtdc = false; + bool isZEMtdc = false; + + if (tdczna > -99999.0) { + isZNAtdc = true; + } + if (tdcznc > -99999.0) { + isZNCtdc = true; + } + if (tdczpa > -99999.0) { + isZPAtdc = true; + } + if (tdczpc > -99999.0) { + isZPCtdc = true; + } + if (tdczem1 > -99999.0 || tdczem2 > -99999.0) { + isZEMtdc = true; + } + + if (tdcCut) { // TDC cuts applied + if ((tdczna < tdcZNmincut) || (tdczna > tdcZNmaxcut)) + isZNAtdc = false; + if ((tdcznc < tdcZNmincut) || (tdcznc > tdcZNmaxcut)) + isZNCtdc = false; + if ((tdczpa < tdcZPmincut) || (tdczpa > tdcZPmaxcut)) + isZPAtdc = false; + if ((tdczpc < tdcZPmincut) || (tdczpc > tdcZPmaxcut)) + isZPCtdc = false; + } + + bool eventSelected = false; + + // for BC events ------- + if (selectBC) { + // printf("BCmask: %x \n", bcMask); + + registry.get(HIST("hBCmask"))->Fill(0., 1.); + auto isB = CHECK_BIT(bcMask, 0); + if (isB) + registry.get(HIST("hBCmask"))->Fill(1., 1.); + if (CHECK_BIT(bcMask, 1)) + registry.get(HIST("hBCmask"))->Fill(2., 1.); + if (CHECK_BIT(bcMask, 2)) + registry.get(HIST("hBCmask"))->Fill(3., 1.); + if (CHECK_BIT(bcMask, 3)) + registry.get(HIST("hBCmask"))->Fill(4., 1.); + // + if (selectOnlyB && isB) + eventSelected = true; + else if (!selectOnlyB) + eventSelected = true; + } + + // for collision events ------- + if (selectColl) { + bool zvtxSel = false; + if (selectZvtx && CHECK_BIT(selectionBits, 0)) + zvtxSel = true; + else if (!selectZvtx) + zvtxSel = true; + // + bool ottoSel = false; + if (sel8 && CHECK_BIT(selectionBits, 1)) + ottoSel = true; + else if (!sel8) + ottoSel = true; + // + bool isdoOccupancySel = false; + if (doOccupancySel && CHECK_BIT(selectionBits, 2)) + isdoOccupancySel = true; + else if (!doOccupancySel) + isdoOccupancySel = true; + // + bool isnoSameBunchPileupCut = false; + if (noSameBunchPileupCut && CHECK_BIT(selectionBits, 3)) + isnoSameBunchPileupCut = true; + else if (!noSameBunchPileupCut) + isnoSameBunchPileupCut = true; + // + bool isGoodZvtxFT0vsPVsel = false; + if (isGoodZvtxFT0vsPV && CHECK_BIT(selectionBits, 4)) + isGoodZvtxFT0vsPVsel = true; + else if (!isGoodZvtxFT0vsPV) + isGoodZvtxFT0vsPVsel = true; + // + bool isnoCollInTimeRangeStandard = false; + if (noCollInTimeRangeStandard && CHECK_BIT(selectionBits, 5)) + isnoCollInTimeRangeStandard = true; + else if (!noCollInTimeRangeStandard) + isnoCollInTimeRangeStandard = true; + // + bool isnoTimeFrameBorder = false; + if (noTimeFrameBorder && CHECK_BIT(selectionBits, 6)) + isnoTimeFrameBorder = true; + else if (!noTimeFrameBorder) + isnoTimeFrameBorder = true; + // + bool isnoITSROFFrameBorder = false; + if (noITSROFFrameBorder && CHECK_BIT(selectionBits, 7)) + isnoITSROFFrameBorder = true; + else if (!noITSROFFrameBorder) + isnoITSROFFrameBorder = true; + // + bool isGoodITSLayersAllsel = false; + if (isGoodITSLayersAll && CHECK_BIT(selectionBits, 8)) + isGoodITSLayersAllsel = true; + else if (!isGoodITSLayersAll) + isGoodITSLayersAllsel = true; + // + bool istriggerTVX = false; + if (triggerTVX && CHECK_BIT(selectionBits, 9)) + istriggerTVX = true; + else if (!triggerTVX) + istriggerTVX = true; + + if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) + eventSelected = true; + // if (zvtxSel && ottoSel && isnoSameBunchPileupCut) eventSelected = true; + + if (eventSelected) { + registry.get(HIST("hcounts"))->Fill(0., 1.); + if (isZNAtdc) + registry.get(HIST("hcounts"))->Fill(1., 1.); + if (isZPAtdc) + registry.get(HIST("hcounts"))->Fill(2., 1.); + if (isZNCtdc) + registry.get(HIST("hcounts"))->Fill(3., 1.); + if (isZPCtdc) + registry.get(HIST("hcounts"))->Fill(4., 1.); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hcounts"))->Fill(5., 1.); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hcounts"))->Fill(6., 1.); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(7., 1.); + if (isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(8., 1.); + if (isZNAtdc && isZNCtdc) + registry.get(HIST("hcounts"))->Fill(9., 1.); + if (isZNAtdc && isZPAtdc) + registry.get(HIST("hcounts"))->Fill(10., 1.); + if (isZNCtdc && isZPCtdc) + registry.get(HIST("hcounts"))->Fill(11., 1.); + if (isZEMtdc) + registry.get(HIST("hcounts"))->Fill(12., 1.); + } + } + + if (eventSelected) { + + if (enCalibZNA > 0.) { + zna *= enCalibZNA; + znaADC *= enCalibZNA; + znapm1 *= enCalibZNA; + znapm2 *= enCalibZNA; + znapm3 *= enCalibZNA; + znapm4 *= enCalibZNA; + } + if (enCalibZNC > 0.) { + znc *= enCalibZNC; + zncADC *= enCalibZNC; + zncpm1 *= enCalibZNC; + zncpm2 *= enCalibZNC; + zncpm3 *= enCalibZNC; + zncpm4 *= enCalibZNC; + } + if (enCalibZPA > 0.) { + zpa *= enCalibZPA; + zpaADC *= enCalibZPA; + } + if (enCalibZPC > 0.) { + zpc *= enCalibZPC; + zpcADC *= enCalibZPC; + } + + registry.get(HIST("hzvertex"))->Fill(zvtx); + + if (!applyZDCcut) { + + if (isZNAtdc) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc) + registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); + // + if (isZNAtdc) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); + if (isZNAtdc) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } else { + bool isZNChigh = false; + if (znc >= zdccCutLow) + isZNChigh = true; + bool isZNAhigh = false; + if (zna >= zdcaCutLow) + isZNAhigh = true; + bool isZPAhigh = false; + if (zpa >= zdcaCutLow) + isZPAhigh = true; + bool isZPChigh = false; + if (zpc >= zdccCutLow) + isZPChigh = true; + // + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCpmc"))->Fill(zpc); + // + if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); + // + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + // + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + // + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + // + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } + + // Timestamp + if (tStampOffset > timestamp) { + printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %lu \n\n", timestamp); + return; + } + // float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours + if (timestamp > tStampMax) { + printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", timestamp); + return; + } + + if (!applyZDCcut) { + if (isZNAtdc) + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + } else { + if (isZNAtdc && znc >= zdccCutLow) { + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + } + if (isZPAtdc && zpc >= zdccCutLow) { + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + } + if ((isZNAtdc || isZPAtdc) && (znc >= zdccCutLow && zpc >= zdccCutLow)) { + registry.get(HIST("hZDCApmcwZDCCcut"))->Fill(zna + zpa); + } + if (isZNCtdc && zna >= zdcaCutLow) { + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + } + if (isZPCtdc && zpa >= zdcaCutLow) { + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); + } + if ((isZNCtdc || isZPCtdc) && (zna >= zdcaCutLow && zpa >= zdcaCutLow)) { + registry.get(HIST("hZDCCpmcwZDCAcut"))->Fill(znc + zpc); + } + } + // TDCs + if (isZNAtdc) + registry.get(HIST("hZNAtdc"))->Fill(tdczna); + if (isZNCtdc) + registry.get(HIST("hZNCtdc"))->Fill(tdcznc); + if (isZPAtdc) + registry.get(HIST("hZPAtdc"))->Fill(tdczpa); + if (isZPCtdc) + registry.get(HIST("hZPCtdc"))->Fill(tdczpc); + // + if (isZEMtdc) { + registry.get(HIST("hZEM"))->Fill(zem1 + zem2); + registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); + registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); + registry.get(HIST("hZPAvsZEM"))->Fill(zem1 + zem2, zpa); + registry.get(HIST("hZPCvsZEM"))->Fill(zem1 + zem2, zpc); + } + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPvsZEM"))->Fill(zem1 + zem2, zpa + zpc); + // + if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) + registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); + // + if (centrFT0C > -1. && centrFT0C < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); + registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc / 2.680); + } + if (centrFT0A > -1. && centrFT0A < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); + } + if (centrFT0M > -1. && centrFT0M < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc / 2.680); + registry.get(HIST("hNpvsNnZNA"))->Fill(zna / 2.680, zpa / 2.680); + registry.get(HIST("hNpvsNnZNC"))->Fill(znc / 2.680, zpc / 2.680); + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc) // + }; +} diff --git a/Common/zdcTaskLightIons.cxx b/Common/zdcTaskLightIons.cxx new file mode 100644 index 00000000000..fa2bb1c865a --- /dev/null +++ b/Common/zdcTaskLightIons.cxx @@ -0,0 +1,408 @@ +// 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 zdcTaskLightIons.cxx +/// \brief Task for ZDC in light ions +/// \author chiara.oppedisano@cern.ch + + +#include +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/ZDCLightIons.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +using namespace o2; +using namespace o2::aod; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::evsel; + +using BCsRun3 = soa::Join; +using ColEvSels = soa::Join; + +struct ZdcTaskLightIons { + + Produces zdcTableLI; + Service ccdb; + static const int nBCsPerOrbit = o2::constants::lhc::LHCMaxBunches; + std::bitset beamPatternA; + std::bitset beamPatternC; + std::bitset bcPatternB; + std::bitset bcPatternA; + std::bitset bcPatternC; + std::bitset bcPatternE; + + // Configurable parameters + Configurable nBinsTiming{"nBinsTiming", 200, "n bins for debunching histo"}; + Configurable tdcCut{"tdcCut", true, "Flag for TDC cut"}; + Configurable tdcZNmincut{"tdcZNmincut", -2.5, "Min. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 2.5, "Max. ZN TDC cut value"}; + // + // Event selections + Configurable cfgEvSelVtxZ{"cfgEvSelVtxZ", 10, "Event selection: zVtx"}; + Configurable cfgEvSelSel8{"cfgEvSelSel8", true, "Event selection: sel8"}; + Configurable cfgEvSelsDoOccupancySel{"cfgEvSelsDoOccupancySel", true, "Event selection: do occupancy selection"}; + Configurable cfgEvSelsMaxOccupancy{"cfgEvSelsMaxOccupancy", 10000, "Event selection: set max occupancy"}; + Configurable cfgEvSelsNoSameBunchPileupCut{"cfgEvSelsNoSameBunchPileupCut", true, "Event selection: no same bunch pileup cut"}; + Configurable cfgEvSelsIsGoodZvtxFT0vsPV{"cfgEvSelsIsGoodZvtxFT0vsPV", true, "Event selection: is good ZVTX FT0 vs PV"}; + Configurable cfgEvSelsNoCollInTimeRangeStandard{"cfgEvSelsNoCollInTimeRangeStandard", true, "Event selection: no collision in time range standard"}; + Configurable cfgEvSelsIsVertexITSTPC{"cfgEvSelsIsVertexITSTPC", true, "Event selection: is vertex ITSTPC"}; + Configurable cfgEvSelsIsGoodITSLayersAll{"cfgEvSelsIsGoodITSLayersAll", true, "Event selection: is good ITS layers all"}; + // + HistogramRegistry registry{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + enum SelectionCriteria { + evSel_zvtx, + evSel_sel8, + evSel_occupancy, + evSel_kNoSameBunchPileup, + evSel_kIsGoodZvtxFT0vsPV, + evSel_kNoCollInTimeRangeStandard, + evSel_kNoITSROFrameBorder, + evSel_kIsGoodITSLayersAll, + evSel_allEvents, + nEventSelections + }; + + enum bcMaskBits { + bcMask_beamB, + bcMask_beamA, + bcMask_beamC, + bcMask_beamE, + nBits + }; + + void init(InitContext const&) + { + registry.add("zdcDebunchHist", "ZN sum vs. diff; ZNA-ZNC (ns); ZNA+ZNC (ns)", {HistType::kTH2D, {{nBinsTiming, -20., 20.}, {nBinsTiming, -20., 20.}}}); + + if (doprocessALICEcoll) { + registry.add("hEventCount", "Number of Event; Cut; #Events Passed Cut", {HistType::kTH1D, {{nEventSelections, 0, nEventSelections}}}); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_allEvents + 1, "All events"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_zvtx + 1, "vtxZ"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_sel8 + 1, "Sel8"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_occupancy + 1, "kOccupancy"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoSameBunchPileup + 1, "kNoSameBunchPileup"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kIsGoodZvtxFT0vsPV + 1, "kIsGoodZvtxFT0vsPV"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoCollInTimeRangeStandard + 1, "kNoCollInTimeRangeStandard"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kNoITSROFrameBorder + 1, "kNoITSROFrameBorder"); + registry.get(HIST("hEventCount"))->GetXaxis()->SetBinLabel(evSel_kIsGoodITSLayersAll + 1, "kkIsGoodITSLayersAll"); + } + } + + template + uint8_t eventSelected(const TCollision& collision) + { + uint8_t selectionBits = 0; + bool selected; + + registry.fill(HIST("hEventCount"), evSel_allEvents); + + selected = std::fabs(collision.posZ()) < cfgEvSelVtxZ; + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_zvtx); + registry.fill(HIST("hEventCount"), evSel_zvtx); + } + + selected = collision.sel8(); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_sel8); + registry.fill(HIST("hEventCount"), evSel_sel8); + } + + auto occupancy = collision.trackOccupancyInTimeRange(); + selected = occupancy <= cfgEvSelsMaxOccupancy; + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_occupancy); + registry.fill(HIST("hEventCount"), evSel_occupancy); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoSameBunchPileup); + registry.fill(HIST("hEventCount"), evSel_kNoSameBunchPileup); + } + + selected = collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kIsGoodZvtxFT0vsPV); + registry.fill(HIST("hEventCount"), evSel_kIsGoodZvtxFT0vsPV); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoCollInTimeRangeStandard); + registry.fill(HIST("hEventCount"), evSel_kNoCollInTimeRangeStandard); + } + + selected = collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kNoITSROFrameBorder); + registry.fill(HIST("hEventCount"), evSel_kNoITSROFrameBorder); + } + + selected = collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll); + if (selected) { + selectionBits |= (uint8_t)(0x1u << evSel_kIsGoodITSLayersAll); + registry.fill(HIST("hEventCount"), evSel_kIsGoodITSLayersAll); + } + + return selectionBits; + } + + void processZDCBC(BCsRun3 const& bcs, aod::Zdcs const& /*zdcs*/) + { + auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance(); + uint64_t timeStamp = bcs.iteratorAt(0).timestamp(); + std::map metadata; + // use getSpecific to set metadata to avoid crashes related to specific run number + auto grplhcif = ccdbMgr.getSpecific("GLO/Config/GRPLHCIF", timeStamp, metadata); + // auto grplhcif = ccdb->getForTimeStamp("GLO/Config/GRPLHCIF", timeStamp); + if (grplhcif == nullptr) { + LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp; + } + + beamPatternA = grplhcif->getBunchFilling().getBeamPattern(0); + beamPatternC = grplhcif->getBunchFilling().getBeamPattern(1); + bcPatternB = grplhcif->getBunchFilling().getBCPattern(); + bcPatternA = beamPatternA & ~beamPatternC; + bcPatternC = ~beamPatternA & beamPatternC; + bcPatternE = ~beamPatternA & ~beamPatternC; + + for (const auto& bc : bcs) { + + if (bc.has_zdc()) { + + // int64_t timestamp = bc.timestamp(); + auto timestampFromSOR = (bc.timestamp() - grplhcif->getFillNumberTime()) / 1e3; // Convert to seconds + + int bcInOrbit = bc.globalBC() % nBCsPerOrbit; + + uint8_t maskSel = 0; + if (bcPatternB[bcInOrbit]) { + maskSel |= (uint8_t)(0x1u << bcMask_beamB); + } + if (bcPatternA[bcInOrbit]) { + maskSel |= (uint8_t)(0x1u << bcMask_beamA); + } + if (bcPatternC[bcInOrbit]) { + maskSel |= (uint8_t)(0x1u << bcMask_beamC); + } + if (bcPatternE[bcInOrbit]) { + maskSel |= (uint8_t)(0x1u << bcMask_beamE); + } + + auto tdcZNA = bc.zdc().timeZNA(); + auto tdcZNC = bc.zdc().timeZNC(); + auto tdcZPA = bc.zdc().timeZPA(); + auto tdcZPC = bc.zdc().timeZPC(); + auto tdcZEM1 = bc.zdc().timeZEM1(); + auto tdcZEM2 = bc.zdc().timeZEM2(); + // + double zna = bc.zdc().amplitudeZNA(); + double znc = bc.zdc().amplitudeZNC(); + double zpa = bc.zdc().amplitudeZPA(); + double zpc = bc.zdc().amplitudeZPC(); + double zem1 = bc.zdc().amplitudeZEM1(); + double zem2 = bc.zdc().amplitudeZEM2(); + // + double pmcZNA = bc.zdc().energyCommonZNA(); + double pmcZNC = bc.zdc().energyCommonZNC(); + double pmcZPA = bc.zdc().energyCommonZPA(); + double pmcZPC = bc.zdc().energyCommonZPC(); + double pmqZNC[4] = { + 0, + 0, + 0, + 0, + }; + double pmqZNA[4] = { + 0, + 0, + 0, + 0, + }; + const int noofZNsectors = 4; + for (int itow = 0; itow < noofZNsectors; itow++) { + pmqZNA[itow] = (bc.zdc().energySectorZNA())[itow]; + pmqZNC[itow] = (bc.zdc().energySectorZNC())[itow]; + } + + bool isZNChit = false, isZNAhit = false; + if (tdcCut) { // a narrow TDC window is set + if ((tdcZNC >= tdcZNmincut) && (tdcZNC <= tdcZNmaxcut)) { + isZNChit = true; + } + if ((tdcZNA >= tdcZNmincut) && (tdcZNA <= tdcZNmaxcut)) { + isZNAhit = true; + } + } else { // if no window on TDC is set + if (pmcZNC > 0.) { + isZNChit = true; + } + if (pmcZNA > 0.) { + isZNAhit = true; + } + } + if (isZNChit && isZNAhit) { + registry.get(HIST("zdcDebunchHist"))->Fill(zna - znc, zna + znc); + } + + zdcTableLI(tdcZNA, zna, pmcZNA, pmqZNA[0], pmqZNA[1], pmqZNA[2], pmqZNA[3], + tdcZNC, znc, pmcZNC, pmqZNC[0], pmqZNC[1], pmqZNC[2], pmqZNC[3], + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, + -1, -1, -1, + -1., + -1, -1, -1, + timestampFromSOR, + 0, + maskSel); + } + } + } + /// name, description, function pointer, default value + /// note that it has to be declared after the function, so that the pointer is known + PROCESS_SWITCH(ZdcTaskLightIons, processZDCBC, "Processing ZDC 4 auto-triggered events", true); + + void processALICEcoll(ColEvSels const& cols, BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/, aod::FT0s const& /*ft0s*/, aod::FV0As const& /*fv0*/) + { + // collision-based event selection + for (auto const& collision : cols) { + + const auto& foundBC = collision.foundBC_as(); + uint8_t evSelection = eventSelected(collision); + auto zv = collision.posZ(); + auto centralityFT0C = collision.centFT0C(); + auto centralityFT0A = collision.centFT0A(); + auto centralityFT0M = collision.centFT0M(); + + // FT0 + float multFT0A = 0.; + float multFT0C = 0.; + if (foundBC.has_ft0()) { + for (auto const& amplitude : foundBC.ft0().amplitudeA()) { + multFT0A += amplitude; + } + for (auto const& amplitude : foundBC.ft0().amplitudeC()) { + multFT0C += amplitude; + } + } + // FV0 + float multV0A = 0; + if (foundBC.has_fv0a()) { + for (auto const& amplitude : foundBC.fv0a().amplitude()) { + multV0A += amplitude; + } + } + + if (foundBC.has_zdc()) { + const auto& zdc = foundBC.zdc(); + + auto tdcZNA = zdc.timeZNA(); + auto tdcZNC = zdc.timeZNC(); + auto tdcZPA = zdc.timeZPA(); + auto tdcZPC = zdc.timeZPC(); + auto tdcZEM1 = zdc.timeZEM1(); + auto tdcZEM2 = zdc.timeZEM2(); + // + double zna = zdc.amplitudeZNA(); + double znc = zdc.amplitudeZNC(); + double zpa = zdc.amplitudeZPA(); + double zpc = zdc.amplitudeZPC(); + double zem1 = zdc.amplitudeZEM1(); + double zem2 = zdc.amplitudeZEM2(); + // + double pmcZNA = zdc.energyCommonZNA(); + double pmcZNC = zdc.energyCommonZNC(); + double pmcZPA = zdc.energyCommonZPA(); + double pmcZPC = zdc.energyCommonZPC(); + double pmqZNC[4] = { + 0, + 0, + 0, + 0, + }; + double pmqZNA[4] = { + 0, + 0, + 0, + 0, + }; + const int noofZNsectors = 4; + for (int itow = 0; itow < noofZNsectors; itow++) { + pmqZNA[itow] = (zdc.energySectorZNA())[itow]; + pmqZNC[itow] = (zdc.energySectorZNC())[itow]; + } + + bool isZNChit = false, isZNAhit = false; + if (tdcCut) { // a narrow TDC window is set + if ((tdcZNC >= tdcZNmincut) && (tdcZNC <= tdcZNmaxcut)) { + isZNChit = true; + } + if ((tdcZNA >= tdcZNmincut) && (tdcZNA <= tdcZNmaxcut)) { + isZNAhit = true; + } + } else { // if no window on TDC is set + if (pmcZNC > 0.) { + isZNChit = true; + } + if (pmcZNA > 0.) { + isZNAhit = true; + } + } + if (isZNChit && isZNAhit) { + registry.get(HIST("zdcDebunchHist"))->Fill(zna - znc, zna + znc); + } + + zdcTableLI(tdcZNA, zna, pmcZNA, pmqZNA[0], pmqZNA[1], pmqZNA[2], pmqZNA[3], + tdcZNC, znc, pmcZNC, pmqZNC[0], pmqZNC[1], pmqZNC[2], pmqZNC[3], + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, + multFT0A, multFT0C, multV0A, + zv, + centralityFT0C, centralityFT0A, centralityFT0M, + foundBC.timestamp(), + evSelection, + 0); + } + } + } + /// name, description, function pointer, default value + /// note that it has to be declared after the function, so that the pointer is known + PROCESS_SWITCH(ZdcTaskLightIons, processALICEcoll, "Processing ZDC for ALICE collisions", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) // o2-linter: disable=name/file-cpp +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} +Common / Tasks / zdcTableReader.cxx From f9709f1d43b9de678d592ff47ae3fb5d1e2bfa51 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 14:55:45 +0200 Subject: [PATCH 09/10] Removing not needed print and fixing timestamp --- Common/Tasks/zdcTableReader.cxx | 493 ++++++++++++++++++++------------ 1 file changed, 312 insertions(+), 181 deletions(-) diff --git a/Common/Tasks/zdcTableReader.cxx b/Common/Tasks/zdcTableReader.cxx index 122f997e709..9a47d4876e9 100644 --- a/Common/Tasks/zdcTableReader.cxx +++ b/Common/Tasks/zdcTableReader.cxx @@ -23,6 +23,8 @@ #include #include +#include + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -33,15 +35,19 @@ using namespace o2::aod; struct ZDCLIAnalysis { // Configurable + Configurable selectBC{"selectBC", 0, "Select BC events"}; + Configurable selectOnlyB{"selectOnlyB", 0, "Select BC with A && C"}; + Configurable selectColl{"selectColl", 0, "Select ALICE collision events"}; + // Configurable tStampOffset{"tStampOffset", 0, "offset value for timestamp"}; Configurable nBinstStamp{"nBinstStamp", 1000, "no. bins in histo vs. timestamp"}; - Configurable tStampMax{"tStampMax", 1000, ",maximum value for timestamp"}; + Configurable tStampMax{"tStampMax", 1000, ", maximum value for timestamp"}; // - Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; + Configurable tdcCut{"tdcCut", false, "Flag for TDC cut"}; Configurable tdcZNmincut{"tdcZNmincut", -1.5, "Min. ZN TDC cut value"}; - Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; + Configurable tdcZNmaxcut{"tdcZNmaxcut", 1.5, "Max. ZN TDC cut value"}; Configurable tdcZPmincut{"tdcZPmincut", -1.5, "Min. ZP TDC cut value"}; - Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; + Configurable tdcZPmaxcut{"tdcZPmaxcut", 1.5, "Max. ZP TDC cut value"}; // Configurable nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; Configurable nBinsAmpZN{"nBinsAmpZN", 1025, "n bins 4 ZN amplitudes"}; @@ -66,7 +72,7 @@ struct ZDCLIAnalysis { // Configurable selectZvtx{"selectZvtx", true, "Activate Z vertex selection"}; Configurable sel8{"sel8", true, "Activate sel8 selection"}; - Configurable triggetTVX{"triggerTVX", true, "Activate trigger TVX selection"}; + Configurable triggerTVX{"triggerTVX", true, "Activate trigger TVX selection"}; Configurable doOccupancySel{"doOccupancySel", false, "Activate occupancy selection"}; Configurable noSameBunchPileupCut{"noSameBunchPileupCut", true, "Activate no same bunch pileup selection"}; Configurable isGoodZvtxFT0vsPV{"isGoodZvtxFT0vsPV", true, "Activate is good Z vertex FT0 vs PV selection"}; @@ -79,8 +85,9 @@ struct ZDCLIAnalysis { void init(InitContext const&) { + registry.add("hBCmask", "mask; BC; counts", {HistType::kTH1F, {{5, 0., 5.}}}); + registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{14, 0., 14.}}}); registry.add("hzvertex", "z vertex; z_vertex (cm); Entries", {HistType::kTH1F, {{200, -20., 20.}}}); - registry.add("hcounts", "counts; selections; counts", {HistType::kTH1F, {{12, 0., 12.}}}); // registry.add("hZNApmc", "ZNA pmc; ZNA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZN, -0.5, MaxZN}}}); registry.add("hZPApmc", "ZPA pmc; ZPA amplitude; Entries", {HistType::kTH1F, {{nBinsAmpZP, -0.5, MaxZP}}}); @@ -106,8 +113,11 @@ struct ZDCLIAnalysis { registry.add("hZPCamplvsADC", "ZPC amplitude vs. ADC; ZPC ADC; ZPC amplitude", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, 3. * MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); // registry.add("hZNvsZEM", "ZN vs ZEM; ZEM; ZNA+ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, 2. * MaxZN}}}}); + registry.add("hZPvsZEM", "ZP vs ZEM; ZEM; ZPA+ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, 2. * MaxZP}}}}); registry.add("hZNAvsZEM", "ZNA vs ZEM; ZEM; ZNA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZNCvsZEM", "ZNC vs ZEM; ZEM; ZNC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZN, -0.5, MaxZN}}}}); + registry.add("hZPAvsZEM", "ZPA vs ZEM; ZEM; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); + registry.add("hZPCvsZEM", "ZPC vs ZEM; ZEM; ZPC", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZEM}, {nBinsAmpZP, -0.5, MaxZP}}}}); // registry.add("hZNAvsZNC", "ZNA vs ZNC; ZNC; ZNA", {HistType::kTH2F, {{{nBinsAmpZN, -0.5, MaxZN}, {nBinsAmpZN, -0.5, MaxZN}}}}); registry.add("hZPAvsZPC", "ZPA vs ZPC; ZPC; ZPA", {HistType::kTH2F, {{{nBinsAmpZP, -0.5, MaxZP}, {nBinsAmpZP, -0.5, MaxZP}}}}); @@ -164,6 +174,8 @@ struct ZDCLIAnalysis { auto tdcznc = zdc.zncTdc(); auto tdczpa = zdc.zpaTdc(); auto tdczpc = zdc.zpcTdc(); + auto tdczem1 = zdc.zem1Tdc(); + auto tdczem2 = zdc.zem2Tdc(); auto zna = zdc.znaAmpl(); auto znaADC = zdc.znaPmc(); auto znapm1 = zdc.znaPm1(); @@ -191,20 +203,29 @@ struct ZDCLIAnalysis { auto centrFT0M = zdc.centralityFt0m(); auto timestamp = zdc.timestamp(); auto selectionBits = zdc.selectionBits(); + auto bcMask = zdc.bcMask(); bool isZNAtdc = false; bool isZNCtdc = false; bool isZPAtdc = false; bool isZPCtdc = false; + bool isZEMtdc = false; - if (tdczna > -99999.0) + if (tdczna > -99999.0) { isZNAtdc = true; - if (tdcznc > -99999.0) + } + if (tdcznc > -99999.0) { isZNCtdc = true; - if (tdczpa > -99999.0) + } + if (tdczpa > -99999.0) { isZPAtdc = true; - if (tdczpc > -99999.0) + } + if (tdczpc > -99999.0) { isZPCtdc = true; + } + if (tdczem1 > -99999.0 || tdczem2 > -99999.0) { + isZEMtdc = true; + } if (tdcCut) { // TDC cuts applied if ((tdczna < tdcZNmincut) || (tdczna > tdcZNmaxcut)) @@ -217,82 +238,125 @@ struct ZDCLIAnalysis { isZPCtdc = false; } - bool zvtxSel = false; - if (selectZvtx && CHECK_BIT(selectionBits, 0)) - zvtxSel = true; - else if (!selectZvtx) - zvtxSel = true; - // - bool ottoSel = false; - if (sel8 && CHECK_BIT(selectionBits, 1)) - ottoSel = true; - else if (!sel8) - ottoSel = true; - // - bool isdoOccupancySel = false; - if (doOccupancySel && CHECK_BIT(selectionBits, 2)) - isdoOccupancySel = true; - else if (!doOccupancySel) - isdoOccupancySel = true; - // - bool isnoSameBunchPileupCut = false; - if (noSameBunchPileupCut && CHECK_BIT(selectionBits, 3)) - isnoSameBunchPileupCut = true; - else if (!noSameBunchPileupCut) - isnoSameBunchPileupCut = true; - // - bool isGoodZvtxFT0vsPVsel = false; - if (isGoodZvtxFT0vsPV && CHECK_BIT(selectionBits, 4)) - isGoodZvtxFT0vsPVsel = true; - else if (!isGoodZvtxFT0vsPV) - isGoodZvtxFT0vsPVsel = true; - // - bool isnoCollInTimeRangeStandard = false; - if (noCollInTimeRangeStandard && CHECK_BIT(selectionBits, 5)) - isnoCollInTimeRangeStandard = true; - else if (!noCollInTimeRangeStandard) - isnoCollInTimeRangeStandard = true; - // - bool isnoTimeFrameBorder = false; - if (noTimeFrameBorder && CHECK_BIT(selectionBits, 6)) - isnoTimeFrameBorder = true; - else if (!noTimeFrameBorder) - isnoTimeFrameBorder = true; - // - bool isnoITSROFFrameBorder = false; - if (noITSROFFrameBorder && CHECK_BIT(selectionBits, 7)) - isnoITSROFFrameBorder = true; - else if (!noITSROFFrameBorder) - isnoITSROFFrameBorder = true; - // - bool isGoodITSLayersAllsel = false; - if (isGoodITSLayersAll && CHECK_BIT(selectionBits, 8)) - isGoodITSLayersAllsel = true; - else if (!isGoodITSLayersAll) - isGoodITSLayersAllsel = true; - // - bool istriggerTVX = false; - if (!triggetTVX) - istriggerTVX = true; - else if (triggetTVX && CHECK_BIT(selectionBits, 9)) - istriggerTVX = true; + bool eventSelected = false; + + // for BC events ------- + if (selectBC) { + // printf("BCmask: %x \n", bcMask); + + registry.get(HIST("hBCmask"))->Fill(0., 1.); + auto isB = CHECK_BIT(bcMask, 0); + if (isB) + registry.get(HIST("hBCmask"))->Fill(1., 1.); + if (CHECK_BIT(bcMask, 1)) + registry.get(HIST("hBCmask"))->Fill(2., 1.); + if (CHECK_BIT(bcMask, 2)) + registry.get(HIST("hBCmask"))->Fill(3., 1.); + if (CHECK_BIT(bcMask, 3)) + registry.get(HIST("hBCmask"))->Fill(4., 1.); + // + if (selectOnlyB && isB) + eventSelected = true; + else if (!selectOnlyB) + eventSelected = true; + } + + // for collision events ------- + if (selectColl) { + bool zvtxSel = false; + if (selectZvtx && CHECK_BIT(selectionBits, 0)) + zvtxSel = true; + else if (!selectZvtx) + zvtxSel = true; + // + bool ottoSel = false; + if (sel8 && CHECK_BIT(selectionBits, 1)) + ottoSel = true; + else if (!sel8) + ottoSel = true; + // + bool isdoOccupancySel = false; + if (doOccupancySel && CHECK_BIT(selectionBits, 2)) + isdoOccupancySel = true; + else if (!doOccupancySel) + isdoOccupancySel = true; + // + bool isnoSameBunchPileupCut = false; + if (noSameBunchPileupCut && CHECK_BIT(selectionBits, 3)) + isnoSameBunchPileupCut = true; + else if (!noSameBunchPileupCut) + isnoSameBunchPileupCut = true; + // + bool isGoodZvtxFT0vsPVsel = false; + if (isGoodZvtxFT0vsPV && CHECK_BIT(selectionBits, 4)) + isGoodZvtxFT0vsPVsel = true; + else if (!isGoodZvtxFT0vsPV) + isGoodZvtxFT0vsPVsel = true; + // + bool isnoCollInTimeRangeStandard = false; + if (noCollInTimeRangeStandard && CHECK_BIT(selectionBits, 5)) + isnoCollInTimeRangeStandard = true; + else if (!noCollInTimeRangeStandard) + isnoCollInTimeRangeStandard = true; + // + bool isnoTimeFrameBorder = false; + if (noTimeFrameBorder && CHECK_BIT(selectionBits, 6)) + isnoTimeFrameBorder = true; + else if (!noTimeFrameBorder) + isnoTimeFrameBorder = true; + // + bool isnoITSROFFrameBorder = false; + if (noITSROFFrameBorder && CHECK_BIT(selectionBits, 7)) + isnoITSROFFrameBorder = true; + else if (!noITSROFFrameBorder) + isnoITSROFFrameBorder = true; + // + bool isGoodITSLayersAllsel = false; + if (isGoodITSLayersAll && CHECK_BIT(selectionBits, 8)) + isGoodITSLayersAllsel = true; + else if (!isGoodITSLayersAll) + isGoodITSLayersAllsel = true; + // + bool istriggerTVX = false; + if (triggerTVX && CHECK_BIT(selectionBits, 9)) + istriggerTVX = true; + else if (!triggerTVX) + istriggerTVX = true; + + if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) + eventSelected = true; + // if (zvtxSel && ottoSel && isnoSameBunchPileupCut) eventSelected = true; + + if (eventSelected) { + registry.get(HIST("hcounts"))->Fill(0., 1.); + if (isZNAtdc) + registry.get(HIST("hcounts"))->Fill(1., 1.); + if (isZPAtdc) + registry.get(HIST("hcounts"))->Fill(2., 1.); + if (isZNCtdc) + registry.get(HIST("hcounts"))->Fill(3., 1.); + if (isZPCtdc) + registry.get(HIST("hcounts"))->Fill(4., 1.); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hcounts"))->Fill(5., 1.); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hcounts"))->Fill(6., 1.); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(7., 1.); + if (isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) + registry.get(HIST("hcounts"))->Fill(8., 1.); + if (isZNAtdc && isZNCtdc) + registry.get(HIST("hcounts"))->Fill(9., 1.); + if (isZNAtdc && isZPAtdc) + registry.get(HIST("hcounts"))->Fill(10., 1.); + if (isZNCtdc && isZPCtdc) + registry.get(HIST("hcounts"))->Fill(11., 1.); + if (isZEMtdc) + registry.get(HIST("hcounts"))->Fill(12., 1.); + } + } - // comment the if when you want the output for BC selection!!! - //if (zvtxSel && ottoSel && istriggerTVX && isdoOccupancySel && isnoSameBunchPileupCut && isGoodZvtxFT0vsPVsel && isnoCollInTimeRangeStandard && isnoTimeFrameBorder && isnoITSROFFrameBorder && isGoodITSLayersAllsel) { - if (zvtxSel && ottoSel && isnoSameBunchPileupCut) { - - registry.get(HIST("hcounts"))->Fill(0., 1.); - if(isZNAtdc) registry.get(HIST("hcounts"))->Fill(1., 1.); - if(isZPAtdc) registry.get(HIST("hcounts"))->Fill(2., 1.); - if(isZNCtdc) registry.get(HIST("hcounts"))->Fill(3., 1.); - if(isZPCtdc) registry.get(HIST("hcounts"))->Fill(4., 1.); - if(isZNAtdc || isZNCtdc) registry.get(HIST("hcounts"))->Fill(5., 1.); - if(isZNAtdc || isZPAtdc) registry.get(HIST("hcounts"))->Fill(6., 1.); - if(isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(7., 1.); - if(isZNAtdc || isZPAtdc || isZNCtdc || isZPCtdc) registry.get(HIST("hcounts"))->Fill(8., 1.); - if(isZNAtdc && isZNCtdc) registry.get(HIST("hcounts"))->Fill(9., 1.); - if(isZNAtdc && isZPAtdc) registry.get(HIST("hcounts"))->Fill(10., 1.); - if(isZNCtdc && isZPCtdc) registry.get(HIST("hcounts"))->Fill(11., 1.); + if (eventSelected) { if (enCalibZNA > 0.) { zna *= enCalibZNA; @@ -321,40 +385,61 @@ struct ZDCLIAnalysis { registry.get(HIST("hzvertex"))->Fill(zvtx); - if (!applyZDCcut) { - if (isZNAtdc) registry.get(HIST("hZNApmc"))->Fill(zna); - if (isZNCtdc) registry.get(HIST("hZNCpmc"))->Fill(znc); - if (isZPAtdc) registry.get(HIST("hZPApmc"))->Fill(zpa); - if (isZPCtdc) registry.get(HIST("hZPCpmc"))->Fill(zpc); + if (isZNAtdc) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc) + registry.get(HIST("hZPCpmc"))->Fill(zpc); // - if (isZNAtdc || isZPAtdc) registry.get(HIST("hZDCA"))->Fill(zna + zpa); - if (isZNCtdc || isZPCtdc) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); // - if (isZNAtdc) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); - if (isZNCtdc) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); - if (isZPAtdc) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); - if (isZPCtdc) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + if (isZNAtdc) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); // - if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); - if (isZPAtdc || isZPCtdc) registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); - if (isZNAtdc || isZPAtdc) registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); - if (isZNCtdc || isZPCtdc) registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNAvsZNC"))->Fill(znc, zna); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPAvsZPC"))->Fill(zpc, zpa); + if (isZNAtdc || isZPAtdc) + registry.get(HIST("hZNAvsZPA"))->Fill(zpa, zna); + if (isZNCtdc || isZPCtdc) + registry.get(HIST("hZNCvsZPC"))->Fill(zpc, znc); // - if (isZNAtdc) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); - if (isZNCtdc) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); - if (isZPAtdc) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); - if (isZPCtdc) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + if (isZNAtdc) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); // - if (isZNAtdc) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); - if (isZNCtdc) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + if (isZNAtdc) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); // - if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); - if (isZNAtdc) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); - if (isZNCtdc) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); - } - else { + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsV0A"))->Fill(multV0A / 100., zna + znc); + if (isZNAtdc) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + } else { bool isZNChigh = false; if (znc >= zdccCutLow) isZNChigh = true; @@ -368,107 +453,153 @@ struct ZDCLIAnalysis { if (zpc >= zdccCutLow) isZPChigh = true; // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNApmc"))->Fill(zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCpmc"))->Fill(znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPApmc"))->Fill(zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCpmc"))->Fill(zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNApmc"))->Fill(zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCpmc"))->Fill(znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPApmc"))->Fill(zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCpmc"))->Fill(zpc); // - if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) registry.get(HIST("hZDCA"))->Fill(zna + zpa); - if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) registry.get(HIST("hZDCC"))->Fill(znc + zpc); + if ((isZNAtdc || isZPAtdc) && (isZNChigh && isZPChigh)) + registry.get(HIST("hZDCA"))->Fill(zna + zpa); + if ((isZNCtdc || isZPCtdc) && (isZNAhigh && isZPAhigh)) + registry.get(HIST("hZDCC"))->Fill(znc + zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAamplvsADC"))->Fill(znaADC, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCamplvsADC"))->Fill(zncADC, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAamplvsADC"))->Fill(zpaADC, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCamplvsADC"))->Fill(zpcADC, zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); - if (isZPAtdc && isZPChigh) registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); - if (isZPCtdc && isZPAhigh) registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvstdc"))->Fill(tdczna, zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvstdc"))->Fill(tdcznc, znc); + if (isZPAtdc && isZPChigh) + registry.get(HIST("hZPAvstdc"))->Fill(tdczpa, zpa); + if (isZPCtdc && isZPAhigh) + registry.get(HIST("hZPCvstdc"))->Fill(tdczpc, zpc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAcvsZNAsum"))->Fill(0.25 * (znapm1 + znapm2 + znapm3 + znapm4), zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCcvsZNCsum"))->Fill(0.25 * (zncpm1 + zncpm2 + zncpm3 + zncpm4), znc); // - if (isZNAtdc && isZNChigh) registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); - if (isZNCtdc && isZNAhigh) registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); + if (isZNAtdc && isZNChigh) + registry.get(HIST("hZNAvsFT0A"))->Fill((multFT0A) / 100., zna); + if (isZNCtdc && isZNAhigh) + registry.get(HIST("hZNCvsFT0C"))->Fill((multFT0C) / 100., znc); } - - // Timestamp - if (tStampOffset > timestamp) { - printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %llu \n\n", timestamp); + + // Timestamp + /*if (tStampOffset > timestamp) { + printf("\n\n ################# OFFSET timestamp too large!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp %lu \n\n", timestamp); return; - } - float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours - if (tsh > tStampMax) { - printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", tsh); + }*/ + // float tsh = (timestamp / 1000.) - (tStampOffset / 1000.); // in hours + /*if (timestamp > tStampMax) { + printf("\n\n MAXIMUM timestamp too small!!!!!!!!!!!!!!!!!!!!!!!!!! > timestamp-offset %f \n\n", timestamp); return; - } + }*/ - if (!applyZDCcut) { - if (isZNAtdc) registry.get(HIST("hZNAvstimestamp"))->Fill(tsh, zna); - if (isZNCtdc) registry.get(HIST("hZNCvstimestamp"))->Fill(tsh, znc); - if (isZPAtdc) registry.get(HIST("hZPAvstimestamp"))->Fill(tsh, zpa); - if (isZPCtdc) registry.get(HIST("hZPCvstimestamp"))->Fill(tsh, zpc); + if (!applyZDCcut) { + if (isZNAtdc) + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); + if (isZNCtdc) + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); + if (isZPAtdc) + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); + if (isZPCtdc) + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); } else { if (isZNAtdc && znc >= zdccCutLow) { - registry.get(HIST("hZNAvstimestamp"))->Fill(tsh, zna); + registry.get(HIST("hZNAvstimestamp"))->Fill(timestamp, zna); } if (isZPAtdc && zpc >= zdccCutLow) { - registry.get(HIST("hZPAvstimestamp"))->Fill(tsh, zpa); + registry.get(HIST("hZPAvstimestamp"))->Fill(timestamp, zpa); } if ((isZNAtdc || isZPAtdc) && (znc >= zdccCutLow && zpc >= zdccCutLow)) { registry.get(HIST("hZDCApmcwZDCCcut"))->Fill(zna + zpa); } if (isZNCtdc && zna >= zdcaCutLow) { - registry.get(HIST("hZNCvstimestamp"))->Fill(tsh, znc); + registry.get(HIST("hZNCvstimestamp"))->Fill(timestamp, znc); } if (isZPCtdc && zpa >= zdcaCutLow) { - registry.get(HIST("hZPCvstimestamp"))->Fill(tsh, zpc); + registry.get(HIST("hZPCvstimestamp"))->Fill(timestamp, zpc); } if ((isZNCtdc || isZPCtdc) && (zna >= zdcaCutLow && zpa >= zdcaCutLow)) { registry.get(HIST("hZDCCpmcwZDCAcut"))->Fill(znc + zpc); } } // TDCs - if (isZNAtdc) registry.get(HIST("hZNAtdc"))->Fill(tdczna); - if (isZNCtdc) registry.get(HIST("hZNCtdc"))->Fill(tdcznc); - if (isZPAtdc) registry.get(HIST("hZPAtdc"))->Fill(tdczpa); - if (isZPCtdc) registry.get(HIST("hZPCtdc"))->Fill(tdczpc); + if (isZNAtdc) + registry.get(HIST("hZNAtdc"))->Fill(tdczna); + if (isZNCtdc) + registry.get(HIST("hZNCtdc"))->Fill(tdcznc); + if (isZPAtdc) + registry.get(HIST("hZPAtdc"))->Fill(tdczpa); + if (isZPCtdc) + registry.get(HIST("hZPCtdc"))->Fill(tdczpc); // - registry.get(HIST("hZEM"))->Fill(zem1 + zem2); - if (isZNAtdc || isZNCtdc) registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); - if (isZNAtdc) registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); - if (isZNCtdc) registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); + if (isZEMtdc) { + registry.get(HIST("hZEM"))->Fill(zem1 + zem2); + registry.get(HIST("hZNAvsZEM"))->Fill(zem1 + zem2, zna); + registry.get(HIST("hZNCvsZEM"))->Fill(zem1 + zem2, znc); + registry.get(HIST("hZPAvsZEM"))->Fill(zem1 + zem2, zpa); + registry.get(HIST("hZPCvsZEM"))->Fill(zem1 + zem2, zpc); + } + if (isZNAtdc || isZNCtdc) + registry.get(HIST("hZNvsZEM"))->Fill(zem1 + zem2, zna + znc); + if (isZPAtdc || isZPCtdc) + registry.get(HIST("hZPvsZEM"))->Fill(zem1 + zem2, zpa + zpc); // - if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); + if (isZNAtdc || isZNCtdc || isZPAtdc || isZPCtdc) + registry.get(HIST("hZDCCvsA"))->Fill(zna + zpa, znc + zpc); // - if(centrFT0C > -1. && centrFT0C < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); - registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna/2.680); - registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc/2.680); - registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa/2.680); - registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc/2.680); + if (centrFT0C > -1. && centrFT0C < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0C"))->Fill(centrFT0C, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0C"))->Fill(centrFT0C, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0C"))->Fill(centrFT0C, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0C"))->Fill(centrFT0C, zpc); + registry.get(HIST("hNnZNAvscentrFT0C"))->Fill(centrFT0C, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0C"))->Fill(centrFT0C, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0C"))->Fill(centrFT0C, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0C"))->Fill(centrFT0C, zpc / 2.680); } - if(centrFT0A > -1. && centrFT0A < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); + if (centrFT0A > -1. && centrFT0A < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0A"))->Fill(centrFT0A, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0A"))->Fill(centrFT0A, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0A"))->Fill(centrFT0A, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0A"))->Fill(centrFT0A, zpc); } - if(centrFT0M > -1. && centrFT0M < 101.) { - if (isZNAtdc) registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); - if (isZPAtdc) registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); - if (isZNCtdc) registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); - if (isZPCtdc) registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); - registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna/2.680); - registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc/2.680); - registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa/2.680); - registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc/2.680); - registry.get(HIST("hNpvsNnZNA"))->Fill(zna/2.680, zpa/2.680); - registry.get(HIST("hNpvsNnZNC"))->Fill(znc/2.680, zpc/2.680); + if (centrFT0M > -1. && centrFT0M < 101.) { + if (isZNAtdc) + registry.get(HIST("hZNAvscentrFT0M"))->Fill(centrFT0M, zna); + if (isZPAtdc) + registry.get(HIST("hZPAvscentrFT0M"))->Fill(centrFT0M, zpa); + if (isZNCtdc) + registry.get(HIST("hZNCvscentrFT0M"))->Fill(centrFT0M, znc); + if (isZPCtdc) + registry.get(HIST("hZPCvscentrFT0M"))->Fill(centrFT0M, zpc); + registry.get(HIST("hNnZNAvscentrFT0M"))->Fill(centrFT0M, zna / 2.680); + registry.get(HIST("hNnZNCvscentrFT0M"))->Fill(centrFT0M, znc / 2.680); + registry.get(HIST("hNpZPAvscentrFT0M"))->Fill(centrFT0M, zpa / 2.680); + registry.get(HIST("hNpZPCvscentrFT0M"))->Fill(centrFT0M, zpc / 2.680); + registry.get(HIST("hNpvsNnZNA"))->Fill(zna / 2.680, zpa / 2.680); + registry.get(HIST("hNpvsNnZNC"))->Fill(znc / 2.680, zpc / 2.680); } } } From 790dcbb8af157f5e7db27714503e93055cd1f8e9 Mon Sep 17 00:00:00 2001 From: Chiara Date: Wed, 30 Sep 2026 15:00:32 +0200 Subject: [PATCH 10/10] Fix include order for EventSelectionParams --- Common/TableProducer/zdcTaskLightIons.cxx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Common/TableProducer/zdcTaskLightIons.cxx b/Common/TableProducer/zdcTaskLightIons.cxx index d778f5087a6..2449cd99a48 100644 --- a/Common/TableProducer/zdcTaskLightIons.cxx +++ b/Common/TableProducer/zdcTaskLightIons.cxx @@ -13,11 +13,12 @@ /// \brief Task for ZDC in light ions /// \author chiara.oppedisano@cern.ch -#include "Common/CCDB/EventSelectionParams.h" + #include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/ZDCLightIons.h" +#include "Common/CCDB/EventSelectionParams.h" #include #include #include