diff --git a/PWGUD/Core/SGSelector.h b/PWGUD/Core/SGSelector.h index 4845818f244..b9fc3ecf2e7 100644 --- a/PWGUD/Core/SGSelector.h +++ b/PWGUD/Core/SGSelector.h @@ -8,17 +8,26 @@ // 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 SGSelector.h +/// \author Alexander Bylinkin +/// \author Adam Matyja +/// \since 2023-11-21 +/// \brief Support class holding tools to work with Single Gap selection in central barrel UPCs +/// #ifndef PWGUD_CORE_SGSELECTOR_H_ #define PWGUD_CORE_SGSELECTOR_H_ -#include -#include "TDatabasePDG.h" -#include "TLorentzVector.h" -#include "Framework/Logger.h" -#include "Framework/AnalysisTask.h" -#include "PWGUD/Core/UDHelpers.h" #include "PWGUD/Core/SGCutParHolder.h" +#include "PWGUD/Core/UDHelpers.h" + +#include "Common/CCDB/RCTSelectionFlags.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/Logger.h" + +#include template struct SelectionResult { @@ -26,10 +35,20 @@ struct SelectionResult { BC* bc; // Pointer to the BC object }; +namespace o2::aod::sgselector +{ +enum TrueGap : int { + NoGap = -1, + SingleGapA = 0, + SingleGapC = 1, + DoubleGap = 2 +}; +} + class SGSelector { public: - SGSelector() : fPDG(TDatabasePDG::Instance()) {} + SGSelector() : myRCTChecker{"CBT"}, myRCTCheckerHadron{"CBT_hadronPID"}, myRCTCheckerZDC{"CBT", true}, myRCTCheckerHadronZDC{"CBT_hadronPID", true} {} template int Print(SGCutParHolder /*diffCuts*/, CC& collision, BCs& /*bcRange*/, TCs& /*tracks*/, FWs& /*fwdtracks*/) @@ -107,7 +126,8 @@ class SGSelector template int FwdTrkSelector(TFwdTrack const& fwdtrack) { - if (fwdtrack.trackType() == 0 || fwdtrack.trackType() == 3) + // if (fwdtrack.trackType() == 0 || fwdtrack.trackType() == 3) + if (fwdtrack.trackType() == o2::aod::fwdtrack::ForwardTrackTypeEnum::GlobalMuonTrack || fwdtrack.trackType() == o2::aod::fwdtrack::ForwardTrackTypeEnum::MuonStandaloneTrack) return 1; else return 0; @@ -125,29 +145,68 @@ class SGSelector FT0C = collision.totalFT0AmplitudeC(); ZNA = collision.energyCommonZNA(); ZNC = collision.energyCommonZNC(); - if (gap == 0) { + if (gap == o2::aod::sgselector::SingleGapA) { // gap == 0 if (FV0A > fit_cut[0] || FT0A > fit_cut[1] || ZNA > zdc_cut) - true_gap = -1; - } else if (gap == 1) { + true_gap = o2::aod::sgselector::NoGap; // -1 + } else if (gap == o2::aod::sgselector::SingleGapC) { // gap == 1 if (FT0C > fit_cut[2] || ZNC > zdc_cut) - true_gap = -1; - } else if (gap == 2) { + true_gap = o2::aod::sgselector::NoGap; // -1 + } else if (gap == o2::aod::sgselector::DoubleGap) { // gap == 2 if ((FV0A > fit_cut[0] || FT0A > fit_cut[1] || ZNA > zdc_cut) && (FT0C > fit_cut[2] || ZNC > zdc_cut)) - true_gap = -1; + true_gap = o2::aod::sgselector::NoGap; // -1 else if ((FV0A > fit_cut[0] || FT0A > fit_cut[1] || ZNA > zdc_cut) && (FT0C <= fit_cut[2] && ZNC <= zdc_cut)) - true_gap = 1; + true_gap = o2::aod::sgselector::SingleGapC; // 1 else if ((FV0A <= fit_cut[0] && FT0A <= fit_cut[1] && ZNA <= zdc_cut) && (FT0C > fit_cut[2] || ZNC > zdc_cut)) - true_gap = 0; + true_gap = o2::aod::sgselector::SingleGapA; // 0 else if (FV0A <= fit_cut[0] && FT0A <= fit_cut[1] && ZNA <= zdc_cut && FT0C <= fit_cut[2] && ZNC <= zdc_cut) - true_gap = 2; + true_gap = o2::aod::sgselector::DoubleGap; // 2 else - std::cout << "Something wrong with DG" << std::endl; + LOGF(info, "Something wrong with DG"); } return true_gap; } + // check CBT flags + template + bool isCBTOk(CC& collision) + { + if (myRCTChecker(collision)) + return true; + return false; + } + + // check CBT+hadronPID flags + template + bool isCBTHadronOk(CC& collision) + { + if (myRCTCheckerHadron(collision)) + return true; + return false; + } + + // check CBT+ZDC flags + template + bool isCBTZdcOk(CC& collision) + { + if (myRCTCheckerZDC(collision)) + return true; + return false; + } + + // check CBT+hadronPID+ZDC flags + template + bool isCBTHadronZdcOk(CC& collision) + { + if (myRCTCheckerHadronZDC(collision)) + return true; + return false; + } + private: - TDatabasePDG* fPDG; + o2::aod::rctsel::RCTFlagsChecker myRCTChecker; + o2::aod::rctsel::RCTFlagsChecker myRCTCheckerHadron; + o2::aod::rctsel::RCTFlagsChecker myRCTCheckerZDC; + o2::aod::rctsel::RCTFlagsChecker myRCTCheckerHadronZDC; }; #endif // PWGUD_CORE_SGSELECTOR_H_ diff --git a/PWGUD/DataModel/UDTables.h b/PWGUD/DataModel/UDTables.h index b84f6cd26e7..8a4251ec74d 100644 --- a/PWGUD/DataModel/UDTables.h +++ b/PWGUD/DataModel/UDTables.h @@ -8,18 +8,29 @@ // 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 UDTables.h +/// \brief Defines tables and colums for derived data used by UD group +/// \author Paul Buhler , Wiena +/// \since January 2023 +/// \author Sasha Bylinkin , Bergen +/// \since January 2024 +/// \author Adam Matyja , INP PAN Krakow, Poland +/// \since May 2025 #ifndef PWGUD_DATAMODEL_UDTABLES_H_ #define PWGUD_DATAMODEL_UDTABLES_H_ -#include -#include +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/TrackSelectionTables.h" + #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" #include "Framework/DataTypes.h" #include "MathUtils/Utils.h" -#include "Common/DataModel/PIDResponse.h" -#include "Common/DataModel/TrackSelectionTables.h" + +#include +#include namespace o2::aod { @@ -111,6 +122,10 @@ DECLARE_SOA_COLUMN(ITSROFb, itsROFb, int); DECLARE_SOA_COLUMN(Sbp, sbp, int); DECLARE_SOA_COLUMN(ZvtxFT0vPV, zVtxFT0vPV, int); DECLARE_SOA_COLUMN(VtxITSTPC, vtxITSTPC, int); +// information about mask names -> Common/CCDB/RCTSelectionFlags.h +// DECLARE_SOA_COLUMN(Rct, rct, uint32_t); //! run condition table mask +DECLARE_SOA_BITMAP_COLUMN(Rct, rct, 32); //! run condition table mask + // Gap Side Information DECLARE_SOA_COLUMN(GapSide, gapSide, uint8_t); // 0 for side A, 1 for side C, 2 for both sides (or use an enum for better readability) // FIT selection flags @@ -249,6 +264,24 @@ DECLARE_SOA_TABLE_VERSIONED(UDCollisionSelExtras_002, "AOD", "UDCOLSELEXTRA", 2, udcollision::ZvtxFT0vPV, //! kIsGoodZvtxFT0vsPV udcollision::VtxITSTPC); //! kIsVertexITSTPC +DECLARE_SOA_TABLE_VERSIONED(UDCollisionSelExtras_003, "AOD", "UDCOLSELEXTRA", 3, + udcollision::ChFT0A, //! number of active channels in FT0A + udcollision::ChFT0C, //! number of active channels in FT0C + udcollision::ChFDDA, //! number of active channels in FDDA + udcollision::ChFDDC, //! number of active channels in FDDC + udcollision::ChFV0A, //! number of active channels in FV0A + udcollision::OccupancyInTime, //! Occupancy + udcollision::HadronicRate, //! Interaction Rate + udcollision::Trs, //! kNoCollInTimeRangeStandard + udcollision::Trofs, //! kNoCollInRofStandard + udcollision::Hmpr, //! kNoHighMultCollInPrevRof + udcollision::TFb, //! kNoTimeFrameBorder + udcollision::ITSROFb, //! kNoITSROFrameBorder + udcollision::Sbp, //! kNoSameBunchPileup + udcollision::ZvtxFT0vPV, //! kIsGoodZvtxFT0vsPV + udcollision::VtxITSTPC, //! kIsVertexITSTPC + udcollision::Rct); //! RCT mask + // central barrel-specific selections DECLARE_SOA_TABLE(UDCollisionsSelsCent, "AOD", "UDCOLSELCNT", udcollision::DBcTOR, @@ -272,7 +305,7 @@ DECLARE_SOA_TABLE(UDMcCollsLabels, "AOD", "UDMCCOLLSLABEL", udcollision::UDMcCollisionId); using UDCollisions = UDCollisions_001; -using UDCollisionSelExtras = UDCollisionSelExtras_002; +using UDCollisionSelExtras = UDCollisionSelExtras_003; using UDCollision = UDCollisions::iterator; using SGCollision = SGCollisions::iterator; diff --git a/PWGUD/TableProducer/Converters/CMakeLists.txt b/PWGUD/TableProducer/Converters/CMakeLists.txt index 8230278b45c..7d5a6297ba1 100644 --- a/PWGUD/TableProducer/Converters/CMakeLists.txt +++ b/PWGUD/TableProducer/Converters/CMakeLists.txt @@ -29,3 +29,8 @@ o2physics_add_dpl_workflow(collisionselextras-converter-v002 SOURCES UDCollisionSelExtrasV002Converter.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(collisionselextras-converter-v003 + SOURCES UDCollisionSelExtrasV003Converter.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/PWGUD/TableProducer/Converters/UDCollisionSelExtrasV003Converter.cxx b/PWGUD/TableProducer/Converters/UDCollisionSelExtrasV003Converter.cxx new file mode 100644 index 00000000000..a41b2c4efa6 --- /dev/null +++ b/PWGUD/TableProducer/Converters/UDCollisionSelExtrasV003Converter.cxx @@ -0,0 +1,126 @@ +// 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 UDCollisionSelExtrasV003Converter.cxx +/// \brief Converts UDCollisionSelExtras table from version 000 to 003 and 001 to 003 and 002 to 003 +/// \author Adam Matyja + +#include "PWGUD/DataModel/UDTables.h" + +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; + +// Converts UDCollisions for version 000 to 003 and 001 to 003 and 002 to 003 +struct UDCollisionSelExtrasV003Converter { + Produces udCollisionSelExtras_003; + + void init(InitContext const&) + { + if (!doprocessV000ToV003 && !doprocessV001ToV003 && !doprocessV002ToV003) { + LOGF(fatal, "Neither processV000ToV003 nor processV001ToV003 nor processV002ToV003 is enabled. Please choose one!"); + } + if (static_cast(doprocessV000ToV003) + static_cast(doprocessV001ToV003) + static_cast(doprocessV002ToV003) > 1) { + LOGF(fatal, "More than one among processV000ToV003, processV001ToV003, processV002ToV003 is enabled. Please choose only one!"); + } + } + + void processV000ToV003(o2::aod::UDCollisionSelExtras_000 const& collisions) + { + + for (const auto& collision : collisions) { + + udCollisionSelExtras_003(collision.chFT0A(), + collision.chFT0C(), + collision.chFDDA(), + collision.chFDDC(), + collision.chFV0A(), + 0, // dummy occupancy + 0.0f, // dummy rate + 0, // dummy trs + 0, // dummy trofs + 0, // dummy hmpr + 0, // dummy tfb + 0, // dummy itsROFb + 0, // dummy sbp + 0, // dummy zVtxFT0vPV + 0, // dummy vtxITSTPC + 0); // dummy rct + } + } + PROCESS_SWITCH(UDCollisionSelExtrasV003Converter, processV000ToV003, "process v000-to-v003 conversion", false); + + void processV001ToV003(o2::aod::UDCollisionSelExtras_001 const& collisions) + { + + for (const auto& collision : collisions) { + + udCollisionSelExtras_003(collision.chFT0A(), + collision.chFT0C(), + collision.chFDDA(), + collision.chFDDC(), + collision.chFV0A(), + collision.occupancyInTime(), + collision.hadronicRate(), + collision.trs(), + collision.trofs(), + collision.hmpr(), + 0, // dummy tfb + 0, // dummy itsROFb + 0, // dummy sbp + 0, // dummy zVtxFT0vPV + 0, // dummy vtxITSTPC + 0); // dummy rct + } + } + PROCESS_SWITCH(UDCollisionSelExtrasV003Converter, processV001ToV003, "process v001-to-v003 conversion", false); + + void processV002ToV003(o2::aod::UDCollisionSelExtras_002 const& collisions) + { + + for (const auto& collision : collisions) { + + udCollisionSelExtras_003(collision.chFT0A(), + collision.chFT0C(), + collision.chFDDA(), + collision.chFDDC(), + collision.chFV0A(), + collision.occupancyInTime(), + collision.hadronicRate(), + collision.trs(), + collision.trofs(), + collision.hmpr(), + collision.tfb(), + collision.itsROFb(), + collision.sbp(), + collision.zVtxFT0vPV(), + collision.vtxITSTPC(), + 0); // dummy rct + } + } + PROCESS_SWITCH(UDCollisionSelExtrasV003Converter, processV002ToV003, "process v002-to-v003 conversion", true); +}; + +/// Spawn the extended table for UDCollisionSelExtras003 to avoid the call to the internal spawner and a consequent circular dependency +// struct UDCollisionSelExtrasSpawner { +// Spawns udCollisionSelExtras_003; +// }; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc), + // adaptAnalysisTask(cfgc), + }; +} diff --git a/PWGUD/TableProducer/DGCandProducer.cxx b/PWGUD/TableProducer/DGCandProducer.cxx index 54c353d3d9a..84c892f5660 100644 --- a/PWGUD/TableProducer/DGCandProducer.cxx +++ b/PWGUD/TableProducer/DGCandProducer.cxx @@ -12,20 +12,23 @@ // \brief Saves relevant information of DG candidates // \author Paul Buehler, paul.buehler@oeaw.ac.at -#include -#include -#include -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Framework/HistogramRegistry.h" -#include "ReconstructionDataFormats/Vertex.h" +#include "PWGUD/Core/DGSelector.h" +#include "PWGUD/Core/UPCHelpers.h" +#include "PWGUD/DataModel/UDTables.h" + +#include "Common/CCDB/ctpRateFetcher.h" #include "EventFiltering/Zorro.h" #include "EventFiltering/ZorroSummary.h" + #include "CCDB/BasicCCDBManager.h" -#include "Common/CCDB/ctpRateFetcher.h" -#include "PWGUD/DataModel/UDTables.h" -#include "PWGUD/Core/UPCHelpers.h" -#include "PWGUD/Core/DGSelector.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/Vertex.h" + +#include +#include +#include using namespace o2; using namespace o2::framework; @@ -354,7 +357,7 @@ struct DGCandProducer { fitInfo.BBFT0Apf, fitInfo.BBFT0Cpf, fitInfo.BGFT0Apf, fitInfo.BGFT0Cpf, fitInfo.BBFV0Apf, fitInfo.BGFV0Apf, fitInfo.BBFDDApf, fitInfo.BBFDDCpf, fitInfo.BGFDDApf, fitInfo.BGFDDCpf); - outputCollisionSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, occ, ir, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC); + outputCollisionSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, occ, ir, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC, collision.rct_raw()); outputCollsLabels(collision.globalIndex()); // update DGTracks tables diff --git a/PWGUD/TableProducer/SGCandProducer.cxx b/PWGUD/TableProducer/SGCandProducer.cxx index de75fff3e72..37fba3120db 100644 --- a/PWGUD/TableProducer/SGCandProducer.cxx +++ b/PWGUD/TableProducer/SGCandProducer.cxx @@ -14,38 +14,43 @@ /// /// \author Alexander Bylinkin , Uniersity of Bergen /// \since 23.11.2023 +/// \author Adam Matyja , INP PAN Krakow, Poland +/// \since May 2025 // -#include -#include -#include -#include +#include "PWGUD/Core/SGSelector.h" +#include "PWGUD/Core/UPCHelpers.h" +#include "PWGUD/DataModel/UDTables.h" + +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/CCDB/ctpRateFetcher.h" +#include "Common/DataModel/EventSelection.h" + #include "CCDB/BasicCCDBManager.h" -#include "Framework/ASoA.h" -#include "Framework/AnalysisDataModel.h" -#include "ReconstructionDataFormats/Vertex.h" #include "CommonConstants/LHCConstants.h" #include "DataFormatsFIT/Triggers.h" +#include "DataFormatsParameters/AggregatedRunInfo.h" +#include "DataFormatsParameters/GRPLHCIFData.h" #include "DataFormatsParameters/GRPMagField.h" #include "DataFormatsParameters/GRPObject.h" -#include "DataFormatsParameters/GRPLHCIFData.h" -#include "DataFormatsParameters/AggregatedRunInfo.h" - -#include "Framework/AnalysisTask.h" +#include "Framework/ASoA.h" #include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" #include "Framework/runDataProcessing.h" -#include "Common/CCDB/EventSelectionParams.h" -#include "Common/CCDB/ctpRateFetcher.h" -#include "Common/DataModel/EventSelection.h" -#include "PWGUD/DataModel/UDTables.h" -#include "PWGUD/Core/UPCHelpers.h" -#include "PWGUD/Core/SGSelector.h" +#include "ReconstructionDataFormats/Vertex.h" + +#include +#include +#include +#include using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; using namespace o2::dataformats; +using namespace o2::aod::rctsel; #define getHist(type, name) std::get>(histPointers[name]) @@ -80,6 +85,9 @@ struct SGCandProducer { Configurable ITSTPCVertex{"ITSTPCVertex", true, "reject ITS-only vertex"}; // if one wants to look at Single Gap pp events Configurable> generatorIds{"generatorIds", std::vector{-1}, "MC generatorIds to process"}; + Configurable isGoodRCTCollision{"isGoodRCTCollision", true, "Check RCT flags for FT0,ITS,TPC and tracking"}; + Configurable isGoodRCTZdc{"isGoodRCTZdc", false, "Check RCT flags for ZDC if present in run"}; + // Configurables to decide which tables are filled Configurable fillTrackTables{"fillTrackTables", true, "Fill track tables"}; Configurable fillFwdTrackTables{"fillFwdTrackTables", true, "Fill forward track tables"}; @@ -88,6 +96,9 @@ struct SGCandProducer { SGSelector sgSelector; ctpRateFetcher mRateFetcher; + // initialize RCT flag checker + RCTFlagsChecker myRCTChecker{"CBT"}; + // data tables Produces outputSGCollisions; Produces outputCollisions; @@ -303,6 +314,18 @@ struct SGCandProducer { return; } getHist(TH1, histdir + "/Stat")->Fill(6., 1.); + // RCT CBT for collision check + if (isGoodRCTCollision && !myRCTChecker(collision)) { + return; + } + getHist(TH1, histdir + "/Stat")->Fill(7., 1.); + // RCT CBT+ZDC for collision check + if (isGoodRCTZdc && !myRCTChecker(collision)) { + return; + } + getHist(TH1, histdir + "/Stat")->Fill(8., 1.); + + // int trs = collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard) ? 1 : 0; int trofs = collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard) ? 1 : 0; int hmpr = collision.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof) ? 1 : 0; @@ -331,7 +354,7 @@ struct SGCandProducer { if (verboseInfo) LOGF(info, "No Newbc %i", bc.globalBC()); } - getHist(TH1, histdir + "/Stat")->Fill(issgevent + 8, 1.); + getHist(TH1, histdir + "/Stat")->Fill(issgevent + 10, 1.); if (issgevent <= 2) { if (verboseInfo) LOGF(info, "Current BC: %i, %i, %i", bc.globalBC(), newbc.globalBC(), issgevent); @@ -363,7 +386,7 @@ struct SGCandProducer { fitInfo.BBFT0Apf, fitInfo.BBFT0Cpf, fitInfo.BGFT0Apf, fitInfo.BGFT0Cpf, fitInfo.BBFV0Apf, fitInfo.BGFV0Apf, fitInfo.BBFDDApf, fitInfo.BBFDDCpf, fitInfo.BGFDDApf, fitInfo.BGFDDCpf); - outputCollisionSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, occ, ir, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC); + outputCollisionSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, occ, ir, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC, collision.rct_raw()); outputCollsLabels(collision.globalIndex()); if (newbc.has_zdc()) { auto zdc = newbc.zdc(); @@ -428,6 +451,10 @@ struct SGCandProducer { if (context.mOptions.get("processMcData")) { histPointers.insert({"MCreco/Stat", registry.add("MCreco/Stat", "Cut statistics; Selection criterion; Collisions", {HistType::kTH1F, {{14, -0.5, 13.5}}})}); } + + if (isGoodRCTZdc) { + myRCTChecker.init("CBT", true); + } } // process function for reconstructed data diff --git a/PWGUD/TableProducer/UPCCandidateProducer.cxx b/PWGUD/TableProducer/UPCCandidateProducer.cxx index e7f029ae91d..2208060bd59 100644 --- a/PWGUD/TableProducer/UPCCandidateProducer.cxx +++ b/PWGUD/TableProducer/UPCCandidateProducer.cxx @@ -12,24 +12,27 @@ /// \author Diana Krupova, diana.krupova@cern.ch /// \since 04.06.2024 -#include -#include -#include -#include -#include -#include -#include -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" +#include "PWGUD/Core/UPCCutparHolder.h" +#include "PWGUD/Core/UPCHelpers.h" +#include "PWGUD/DataModel/UDTables.h" + #include "Common/CCDB/EventSelectionParams.h" #include "Common/DataModel/EventSelection.h" + #include "CommonConstants/LHCConstants.h" #include "DataFormatsFIT/Triggers.h" -#include "PWGUD/Core/UPCCutparHolder.h" -#include "PWGUD/Core/UPCHelpers.h" -#include "PWGUD/DataModel/UDTables.h" #include "DataFormatsITSMFT/ROFRecord.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +#include +#include +#include +#include +#include +#include +#include using namespace o2::framework; using namespace o2::framework::expressions; @@ -1512,7 +1515,7 @@ struct UpcCandProducer { fitInfo.BBFT0Apf, fitInfo.BBFT0Cpf, fitInfo.BGFT0Apf, fitInfo.BGFT0Cpf, fitInfo.BBFV0Apf, fitInfo.BGFV0Apf, fitInfo.BBFDDApf, fitInfo.BBFDDCpf, fitInfo.BGFDDApf, fitInfo.BGFDDCpf); - eventCandidatesSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + eventCandidatesSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); eventCandidatesSelsFwd(fitInfo.distClosestBcV0A, fitInfo.distClosestBcT0A, amplitudesT0A, @@ -1828,7 +1831,7 @@ struct UpcCandProducer { fitInfo.BBFT0Apf, fitInfo.BBFT0Cpf, fitInfo.BGFT0Apf, fitInfo.BGFT0Cpf, fitInfo.BBFV0Apf, fitInfo.BGFV0Apf, fitInfo.BBFDDApf, fitInfo.BBFDDCpf, fitInfo.BGFDDApf, fitInfo.BGFDDCpf); - eventCandidatesSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, 0, 0, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC); + eventCandidatesSelExtras(chFT0A, chFT0C, chFDDA, chFDDC, chFV0A, 0, 0, trs, trofs, hmpr, tfb, itsROFb, sbp, zVtxFT0vPv, vtxITSTPC, 0); eventCandidatesSelsFwd(fitInfo.distClosestBcV0A, fitInfo.distClosestBcT0A, amplitudesT0A,