diff --git a/Common/DataModel/ZDCLightIons.h b/Common/DataModel/ZDCLightIons.h index b2faa13ba9d..c1a0dc668b5 100644 --- a/Common/DataModel/ZDCLightIons.h +++ b/Common/DataModel/ZDCLightIons.h @@ -13,8 +13,8 @@ /// \brief ZDC data model for O-O Ne-Ne and p-O collisions /// \author Chiara Oppedisano -#ifndef PWGMM_DATAMODEL_ZDCLIGHTIONS_H_ -#define PWGMM_DATAMODEL_ZDCLIGHTIONS_H_ +#ifndef COMMON_DATAMODEL_ZDCLIGHTIONS_H_ +#define COMMON_DATAMODEL_ZDCLIGHTIONS_H_ #include "Common/DataModel/Centrality.h" @@ -77,8 +77,10 @@ DECLARE_SOA_TABLE(ZDCLightIons, "AOD", "ZDCTABLELIGHTIONS", zdclightions::ZncPm4, zdclightions::ZpaTdc, zdclightions::ZpaAmpl, + zdclightions::ZpaPmc, zdclightions::ZpcTdc, zdclightions::ZpcAmpl, + zdclightions::ZpcPmc, zdclightions::Zem1Tdc, zdclightions::Zem1Ampl, zdclightions::Zem2Tdc, diff --git a/Common/TableProducer/zdcTaskLightIons.cxx b/Common/TableProducer/zdcTaskLightIons.cxx index 455ae737086..64b9cbeb7de 100644 --- a/Common/TableProducer/zdcTaskLightIons.cxx +++ b/Common/TableProducer/zdcTaskLightIons.cxx @@ -173,6 +173,8 @@ struct ZdcTaskLightIons { // 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, @@ -213,7 +215,9 @@ struct ZdcTaskLightIons { 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, tdcZPC, zpc, tdcZEM1, zem1, tdcZEM2, zem2, + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, -1, -1, -1, -1., -1, -1, -1, @@ -276,6 +280,8 @@ struct ZdcTaskLightIons { // double pmcZNA = zdc.energyCommonZNA(); double pmcZNC = zdc.energyCommonZNC(); + double pmcZPA = zdc.energyCommonZPA(); + double pmcZPC = zdc.energyCommonZPC(); double pmqZNC[4] = { 0, 0, @@ -316,7 +322,9 @@ struct ZdcTaskLightIons { 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, tdcZPC, zpc, tdcZEM1, zem1, tdcZEM2, zem2, + tdcZPA, zpa, pmcZPA, + tdcZPC, zpc, pmcZPC, + tdcZEM1, zem1, tdcZEM2, zem2, multFT0A, multFT0C, multV0A, zv, centralityFT0C, centralityFT0A, centralityFT0M, diff --git a/Common/Tasks/CMakeLists.txt b/Common/Tasks/CMakeLists.txt index 932398c97a9..e60d7838882 100644 --- a/Common/Tasks/CMakeLists.txt +++ b/Common/Tasks/CMakeLists.txt @@ -92,4 +92,9 @@ o2physics_add_dpl_workflow(flow-test o2physics_add_dpl_workflow(muon-qa SOURCES qaMuon.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::Field O2::DetectorsBase O2::DetectorsCommonDataFormats O2::MathUtils O2::MCHTracking O2::DataFormatsMCH O2::GlobalTracking O2::MCHBase O2::MCHGeometryTransformer O2::CommonUtils + COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(zdc-table-reader + SOURCES zdcTableReader.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) \ No newline at end of file diff --git a/Common/Tasks/zdcTableReader.cxx b/Common/Tasks/zdcTableReader.cxx new file mode 100644 index 00000000000..b4b16094d49 --- /dev/null +++ b/Common/Tasks/zdcTableReader.cxx @@ -0,0 +1,192 @@ +// 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; + +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 nBinsADC{"nBinsADC", 1000, "n bins 4 ZDC ADCs"}; + Configurable nBinsAmp{"nBinsAmp", 1025, "n bins 4 ZDC 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"}; + // + 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("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("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.}, {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("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}}}}); + } + + 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 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(); + + 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); + // + 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("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); + // + 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); + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc) // + }; +}