From a7a6f861e7c6c3965d4b2f4052564e9473ec198a Mon Sep 17 00:00:00 2001 From: minjungkim12 Date: Tue, 4 Nov 2025 09:20:05 +0100 Subject: [PATCH] [PWGDQ] Add FIT information to DQ reduced data tables MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR adds comprehensive FIT (Forward Interaction Trigger) detector information to the DQ analysis framework's reduced data tables, enabling studies of event topology and pileup characteristics in dilepton analyses. Changes include: - Add new ReducedFIT table with FIT amplitudes, timing, trigger masks, pileup flags, and BC distances - Extend VarManager with FIT-related variables and FillFIT() method - Update tableMaker_withAssoc to populate FIT information using UPC helpers - Add event fill map bit for ReducedFit (BIT 22) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- PWGDQ/Core/VarManager.cxx | 89 +++++++++++++++++- PWGDQ/Core/VarManager.h | 99 ++++++++++++++++++-- PWGDQ/DataModel/ReducedInfoTables.h | 54 +++++++++++ PWGDQ/TableProducer/tableMaker_withAssoc.cxx | 63 +++++++++++-- 4 files changed, 285 insertions(+), 20 deletions(-) diff --git a/PWGDQ/Core/VarManager.cxx b/PWGDQ/Core/VarManager.cxx index 30f68fdd03e..1f35b2e278a 100644 --- a/PWGDQ/Core/VarManager.cxx +++ b/PWGDQ/Core/VarManager.cxx @@ -8,12 +8,14 @@ // In applying this license CERN does not waive the privileges and immunities // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +#include "PWGDQ/Core/VarManager.h" + +#include "Tools/KFparticle/KFUtilities.h" + #include #include -#include #include -#include "PWGDQ/Core/VarManager.h" -#include "Tools/KFparticle/KFUtilities.h" +#include using std::cout; using std::endl; @@ -29,7 +31,7 @@ bool VarManager::fgUsedKF = false; float VarManager::fgMagField = 0.5; float VarManager::fgzMatching = -77.5; float VarManager::fgValues[VarManager::kNVars] = {0.0f}; -float VarManager::fgTPCInterSectorBoundary = 1.0; // cm +float VarManager::fgTPCInterSectorBoundary = 1.0; // cm int VarManager::fgITSROFbias = 0; int VarManager::fgITSROFlength = 100; int VarManager::fgITSROFBorderMarginLow = 0; @@ -425,6 +427,57 @@ void VarManager::SetDefaultVarNames() fgVariableUnits[kMultFDDA] = ""; fgVariableNames[kMultFDDC] = "Multiplicity FDDC"; fgVariableUnits[kMultFDDC] = ""; + // FIT timing information + fgVariableNames[kTimeFT0A] = "Time FT0A"; + fgVariableUnits[kTimeFT0A] = "ns"; + fgVariableNames[kTimeFT0C] = "Time FT0C"; + fgVariableUnits[kTimeFT0C] = "ns"; + fgVariableNames[kTimeFDDA] = "Time FDDA"; + fgVariableUnits[kTimeFDDA] = "ns"; + fgVariableNames[kTimeFDDC] = "Time FDDC"; + fgVariableUnits[kTimeFDDC] = "ns"; + fgVariableNames[kTimeFV0A] = "Time FV0A"; + fgVariableUnits[kTimeFV0A] = "ns"; + // FIT trigger masks + fgVariableNames[kTriggerMaskFT0] = "Trigger mask FT0"; + fgVariableUnits[kTriggerMaskFT0] = ""; + fgVariableNames[kTriggerMaskFDD] = "Trigger mask FDD"; + fgVariableUnits[kTriggerMaskFDD] = ""; + fgVariableNames[kTriggerMaskFV0A] = "Trigger mask FV0A"; + fgVariableUnits[kTriggerMaskFV0A] = ""; + // FIT beam-beam pileup flags + fgVariableNames[kBBFT0Apf] = "BB FT0A pileup flag"; + fgVariableUnits[kBBFT0Apf] = ""; + fgVariableNames[kBBFT0Cpf] = "BB FT0C pileup flag"; + fgVariableUnits[kBBFT0Cpf] = ""; + fgVariableNames[kBBFV0Apf] = "BB FV0A pileup flag"; + fgVariableUnits[kBBFV0Apf] = ""; + fgVariableNames[kBBFDDApf] = "BB FDDA pileup flag"; + fgVariableUnits[kBBFDDApf] = ""; + fgVariableNames[kBBFDDCpf] = "BB FDDC pileup flag"; + fgVariableUnits[kBBFDDCpf] = ""; + // FIT beam-gas pileup flags + fgVariableNames[kBGFT0Apf] = "BG FT0A pileup flag"; + fgVariableUnits[kBGFT0Apf] = ""; + fgVariableNames[kBGFT0Cpf] = "BG FT0C pileup flag"; + fgVariableUnits[kBGFT0Cpf] = ""; + fgVariableNames[kBGFV0Apf] = "BG FV0A pileup flag"; + fgVariableUnits[kBGFV0Apf] = ""; + fgVariableNames[kBGFDDApf] = "BG FDDA pileup flag"; + fgVariableUnits[kBGFDDApf] = ""; + fgVariableNames[kBGFDDCpf] = "BG FDDC pileup flag"; + fgVariableUnits[kBGFDDCpf] = ""; + // Distance to closest BC with triggers + fgVariableNames[kDistClosestBcTOR] = "Distance to closest BC with TOR"; + fgVariableUnits[kDistClosestBcTOR] = "BC"; + fgVariableNames[kDistClosestBcTSC] = "Distance to closest BC with TSC"; + fgVariableUnits[kDistClosestBcTSC] = "BC"; + fgVariableNames[kDistClosestBcTVX] = "Distance to closest BC with TVX"; + fgVariableUnits[kDistClosestBcTVX] = "BC"; + fgVariableNames[kDistClosestBcV0A] = "Distance to closest BC with V0A"; + fgVariableUnits[kDistClosestBcV0A] = "BC"; + fgVariableNames[kDistClosestBcT0A] = "Distance to closest BC with T0A"; + fgVariableUnits[kDistClosestBcT0A] = "BC"; fgVariableNames[kMultZNA] = "Multiplicity ZNA"; fgVariableUnits[kMultZNA] = ""; fgVariableNames[kMultZNC] = "Multiplicity ZNC"; @@ -1544,6 +1597,34 @@ void VarManager::SetDefaultVarNames() fgVarNamesMap["kTwoR2SP2"] = kTwoR2SP2; fgVarNamesMap["kTwoR2EP1"] = kTwoR2EP1; fgVarNamesMap["kTwoR2EP2"] = kTwoR2EP2; + // FIT timing information + fgVarNamesMap["kTimeFT0A"] = kTimeFT0A; + fgVarNamesMap["kTimeFT0C"] = kTimeFT0C; + fgVarNamesMap["kTimeFDDA"] = kTimeFDDA; + fgVarNamesMap["kTimeFDDC"] = kTimeFDDC; + fgVarNamesMap["kTimeFV0A"] = kTimeFV0A; + // FIT trigger masks + fgVarNamesMap["kTriggerMaskFT0"] = kTriggerMaskFT0; + fgVarNamesMap["kTriggerMaskFDD"] = kTriggerMaskFDD; + fgVarNamesMap["kTriggerMaskFV0A"] = kTriggerMaskFV0A; + // FIT beam-beam pileup flags + fgVarNamesMap["kBBFT0Apf"] = kBBFT0Apf; + fgVarNamesMap["kBBFT0Cpf"] = kBBFT0Cpf; + fgVarNamesMap["kBBFV0Apf"] = kBBFV0Apf; + fgVarNamesMap["kBBFDDApf"] = kBBFDDApf; + fgVarNamesMap["kBBFDDCpf"] = kBBFDDCpf; + // FIT beam-gas pileup flags + fgVarNamesMap["kBGFT0Apf"] = kBGFT0Apf; + fgVarNamesMap["kBGFT0Cpf"] = kBGFT0Cpf; + fgVarNamesMap["kBGFV0Apf"] = kBGFV0Apf; + fgVarNamesMap["kBGFDDApf"] = kBGFDDApf; + fgVarNamesMap["kBGFDDCpf"] = kBGFDDCpf; + // Distance to closest BC with triggers + fgVarNamesMap["kDistClosestBcTOR"] = kDistClosestBcTOR; + fgVarNamesMap["kDistClosestBcTSC"] = kDistClosestBcTSC; + fgVarNamesMap["kDistClosestBcTVX"] = kDistClosestBcTVX; + fgVarNamesMap["kDistClosestBcV0A"] = kDistClosestBcV0A; + fgVarNamesMap["kDistClosestBcT0A"] = kDistClosestBcT0A; fgVarNamesMap["kNEventWiseVariables"] = kNEventWiseVariables; fgVarNamesMap["kX"] = kX; fgVarNamesMap["kY"] = kY; diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 2e19c26ad9c..d5984f2fe38 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -108,6 +108,7 @@ class VarManager : public TObject ReducedEventMultExtra = BIT(19), CollisionQvectCentr = BIT(20), RapidityGapFilter = BIT(21), + ReducedFit = BIT(22), Track = BIT(0), TrackCov = BIT(1), TrackExtra = BIT(2), @@ -436,6 +437,34 @@ class VarManager : public TObject kTwoR2SP2, // Scalar product resolution of event2 for ME technique kTwoR2EP1, // Event plane resolution of event2 for ME technique kTwoR2EP2, // Event plane resolution of event2 for ME technique + // FIT timing information + kTimeFT0A, // FT0A time + kTimeFT0C, // FT0C time + kTimeFDDA, // FDDA time + kTimeFDDC, // FDDC time + kTimeFV0A, // FV0A time + // FIT trigger masks + kTriggerMaskFT0, // FT0 trigger mask + kTriggerMaskFDD, // FDD trigger mask + kTriggerMaskFV0A, // FV0A trigger mask + // FIT beam-beam pileup flags + kBBFT0Apf, // Beam-beam flag in FT0A + kBBFT0Cpf, // Beam-beam flag in FT0C + kBBFV0Apf, // Beam-beam flag in FV0A + kBBFDDApf, // Beam-beam flag in FDDA + kBBFDDCpf, // Beam-beam flag in FDDC + // FIT beam-gas pileup flags + kBGFT0Apf, // Beam-gas flag in FT0A + kBGFT0Cpf, // Beam-gas flag in FT0C + kBGFV0Apf, // Beam-gas flag in FV0A + kBGFDDApf, // Beam-gas flag in FDDA + kBGFDDCpf, // Beam-gas flag in FDDC + // Distance to closest BC with triggers + kDistClosestBcTOR, // Distance to closest BC with TOR trigger + kDistClosestBcTSC, // Distance to closest BC with TSC trigger + kDistClosestBcTVX, // Distance to closest BC with TVX trigger + kDistClosestBcV0A, // Distance to closest BC with V0A trigger + kDistClosestBcT0A, // Distance to closest BC with T0A trigger kNEventWiseVariables, // Variables for event mixing with cumulant @@ -1155,6 +1184,8 @@ class VarManager : public TObject template static void FillZDC(const T& zdc, float* values = nullptr); template + static void FillFIT(const T& fit, float* values = nullptr); + template static void FillBdtScore(const T& bdtScore, float* values = nullptr); static void SetCalibrationObject(CalibObjects calib, TObject* obj) @@ -1230,15 +1261,15 @@ class VarManager : public TObject static float fgMagField; static float fgzMatching; - static float fgCenterOfMassEnergy; // collision energy - static float fgMassofCollidingParticle; // mass of the colliding particle - static float fgTPCInterSectorBoundary; // TPC inter-sector border size at the TPC outer radius, in cm - static int fgITSROFbias; // ITS ROF bias (from ALPIDE parameters) - static int fgITSROFlength; // ITS ROF length (from ALPIDE parameters) - static int fgITSROFBorderMarginLow; // ITS ROF border low margin - static int fgITSROFBorderMarginHigh; // ITS ROF border high margin - static uint64_t fgSOR; // Timestamp for start of run - static uint64_t fgEOR; // Timestamp for end of run + static float fgCenterOfMassEnergy; // collision energy + static float fgMassofCollidingParticle; // mass of the colliding particle + static float fgTPCInterSectorBoundary; // TPC inter-sector border size at the TPC outer radius, in cm + static int fgITSROFbias; // ITS ROF bias (from ALPIDE parameters) + static int fgITSROFlength; // ITS ROF length (from ALPIDE parameters) + static int fgITSROFBorderMarginLow; // ITS ROF border low margin + static int fgITSROFBorderMarginHigh; // ITS ROF border high margin + static uint64_t fgSOR; // Timestamp for start of run + static uint64_t fgEOR; // Timestamp for end of run static ROOT::Math::PxPyPzEVector fgBeamA; // beam from A-side 4-momentum vector static ROOT::Math::PxPyPzEVector fgBeamC; // beam from C-side 4-momentum vector @@ -5030,6 +5061,56 @@ void VarManager::FillZDC(T const& zdc, float* values) values[kTimeZPC] = zdc.timeZPC(); } +// ----------------------------------------------------------------------- +// Fill FIT detector information +template +void VarManager::FillFIT(T const& fit, float* values) +{ + if (!values) { + values = fgValues; + } + + // FIT amplitudes (reuse existing multiplicity variables) + values[kMultFT0A] = fit.ampFT0A; + values[kMultFT0C] = fit.ampFT0C; + values[kMultFDDA] = fit.ampFDDA; + values[kMultFDDC] = fit.ampFDDC; + values[kMultFV0A] = fit.ampFV0A; + + // FIT timing information + values[kTimeFT0A] = fit.timeFT0A; + values[kTimeFT0C] = fit.timeFT0C; + values[kTimeFDDA] = fit.timeFDDA; + values[kTimeFDDC] = fit.timeFDDC; + values[kTimeFV0A] = fit.timeFV0A; + + // FIT trigger masks + values[kTriggerMaskFT0] = fit.triggerMaskFT0; + values[kTriggerMaskFDD] = fit.triggerMaskFDD; + values[kTriggerMaskFV0A] = fit.triggerMaskFV0A; + + // Beam-beam pileup flags + values[kBBFT0Apf] = fit.BBFT0Apf; + values[kBBFT0Cpf] = fit.BBFT0Cpf; + values[kBBFV0Apf] = fit.BBFV0Apf; + values[kBBFDDApf] = fit.BBFDDApf; + values[kBBFDDCpf] = fit.BBFDDCpf; + + // Beam-gas pileup flags + values[kBGFT0Apf] = fit.BGFT0Apf; + values[kBGFT0Cpf] = fit.BGFT0Cpf; + values[kBGFV0Apf] = fit.BGFV0Apf; + values[kBGFDDApf] = fit.BGFDDApf; + values[kBGFDDCpf] = fit.BGFDDCpf; + + // Distance to closest BC with triggers + values[kDistClosestBcTOR] = fit.distClosestBcTOR; + values[kDistClosestBcTSC] = fit.distClosestBcTSC; + values[kDistClosestBcTVX] = fit.distClosestBcTVX; + values[kDistClosestBcV0A] = fit.distClosestBcV0A; + values[kDistClosestBcT0A] = fit.distClosestBcT0A; +} + template void VarManager::FillDileptonHadron(T1 const& dilepton, T2 const& hadron, float* values, float hadronMass) { diff --git a/PWGDQ/DataModel/ReducedInfoTables.h b/PWGDQ/DataModel/ReducedInfoTables.h index 61074b2215e..76b7371bbe7 100644 --- a/PWGDQ/DataModel/ReducedInfoTables.h +++ b/PWGDQ/DataModel/ReducedInfoTables.h @@ -281,6 +281,60 @@ DECLARE_SOA_TABLE(ReducedZdcsExtra, "AOD", "REDUCEDZDCEXTRA", //! Event ZDC ex using ReducedZdc = ReducedZdcs::iterator; using ReducedZdcExtra = ReducedZdcsExtra::iterator; +namespace reducedfit +{ +// FIT amplitudes +DECLARE_SOA_COLUMN(AmpFT0A, ampFT0A, float); //! FT0A amplitude +DECLARE_SOA_COLUMN(AmpFT0C, ampFT0C, float); //! FT0C amplitude +DECLARE_SOA_COLUMN(AmpFDDA, ampFDDA, float); //! FDDA amplitude +DECLARE_SOA_COLUMN(AmpFDDC, ampFDDC, float); //! FDDC amplitude +DECLARE_SOA_COLUMN(AmpFV0A, ampFV0A, float); //! FV0A amplitude +// FIT times +DECLARE_SOA_COLUMN(TimeFT0A, timeFT0A, float); //! FT0A time +DECLARE_SOA_COLUMN(TimeFT0C, timeFT0C, float); //! FT0C time +DECLARE_SOA_COLUMN(TimeFDDA, timeFDDA, float); //! FDDA time +DECLARE_SOA_COLUMN(TimeFDDC, timeFDDC, float); //! FDDC time +DECLARE_SOA_COLUMN(TimeFV0A, timeFV0A, float); //! FV0A time +// FIT trigger masks +DECLARE_SOA_COLUMN(TriggerMaskFT0, triggerMaskFT0, uint8_t); //! FT0 trigger mask +DECLARE_SOA_COLUMN(TriggerMaskFDD, triggerMaskFDD, uint8_t); //! FDD trigger mask +DECLARE_SOA_COLUMN(TriggerMaskFV0A, triggerMaskFV0A, uint8_t); //! FV0A trigger mask +// FIT pileup flags +DECLARE_SOA_COLUMN(BBFT0Apf, bbFT0Apf, int32_t); //! Beam-beam flag in FT0A +DECLARE_SOA_COLUMN(BGFT0Apf, bgFT0Apf, int32_t); //! Beam-gas flag in FT0A +DECLARE_SOA_COLUMN(BBFT0Cpf, bbFT0Cpf, int32_t); //! Beam-beam flag in FT0C +DECLARE_SOA_COLUMN(BGFT0Cpf, bgFT0Cpf, int32_t); //! Beam-gas flag in FT0C +DECLARE_SOA_COLUMN(BBFV0Apf, bbFV0Apf, int32_t); //! Beam-beam flag in FV0A +DECLARE_SOA_COLUMN(BGFV0Apf, bgFV0Apf, int32_t); //! Beam-gas flag in FV0A +DECLARE_SOA_COLUMN(BBFDDApf, bbFDDApf, int32_t); //! Beam-beam flag in FDDA +DECLARE_SOA_COLUMN(BGFDDApf, bgFDDApf, int32_t); //! Beam-gas flag in FDDA +DECLARE_SOA_COLUMN(BBFDDCpf, bbFDDCpf, int32_t); //! Beam-beam flag in FDDC +DECLARE_SOA_COLUMN(BGFDDCpf, bgFDDCpf, int32_t); //! Beam-gas flag in FDDC +// Distance to closest BC with various triggers +DECLARE_SOA_COLUMN(DistClosestBcTOR, distClosestBcTOR, int32_t); //! Distance to closest BC with TOR trigger +DECLARE_SOA_COLUMN(DistClosestBcTSC, distClosestBcTSC, int32_t); //! Distance to closest BC with TSC trigger +DECLARE_SOA_COLUMN(DistClosestBcTVX, distClosestBcTVX, int32_t); //! Distance to closest BC with TVX trigger +DECLARE_SOA_COLUMN(DistClosestBcV0A, distClosestBcV0A, int32_t); //! Distance to closest BC with V0A trigger +DECLARE_SOA_COLUMN(DistClosestBcT0A, distClosestBcT0A, int32_t); //! Distance to closest BC with T0A trigger +} // namespace reducedfit + +DECLARE_SOA_TABLE(ReducedFITs, "AOD", "REDUCEDFIT", //! Event FIT information + reducedfit::AmpFT0A, reducedfit::AmpFT0C, + reducedfit::AmpFDDA, reducedfit::AmpFDDC, reducedfit::AmpFV0A, + reducedfit::TimeFT0A, reducedfit::TimeFT0C, + reducedfit::TimeFDDA, reducedfit::TimeFDDC, reducedfit::TimeFV0A, + reducedfit::TriggerMaskFT0, reducedfit::TriggerMaskFDD, reducedfit::TriggerMaskFV0A, + reducedfit::BBFT0Apf, reducedfit::BGFT0Apf, + reducedfit::BBFT0Cpf, reducedfit::BGFT0Cpf, + reducedfit::BBFV0Apf, reducedfit::BGFV0Apf, + reducedfit::BBFDDApf, reducedfit::BGFDDApf, + reducedfit::BBFDDCpf, reducedfit::BGFDDCpf, + reducedfit::DistClosestBcTOR, reducedfit::DistClosestBcTSC, + reducedfit::DistClosestBcTVX, reducedfit::DistClosestBcV0A, + reducedfit::DistClosestBcT0A); + +using ReducedFIT = ReducedFITs::iterator; + namespace reducedtrack { // basic track information diff --git a/PWGDQ/TableProducer/tableMaker_withAssoc.cxx b/PWGDQ/TableProducer/tableMaker_withAssoc.cxx index 2be35a784a8..cd8fee315c1 100644 --- a/PWGDQ/TableProducer/tableMaker_withAssoc.cxx +++ b/PWGDQ/TableProducer/tableMaker_withAssoc.cxx @@ -33,6 +33,8 @@ #include "PWGDQ/Core/MuonMatchingMlResponse.h" #include "PWGDQ/Core/VarManager.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" +#include "PWGUD/Core/UDHelpers.h" +#include "PWGUD/Core/UPCHelpers.h" #include "Common/CCDB/TriggerAliases.h" #include "Common/Core/TableHelper.h" @@ -118,7 +120,7 @@ using MyMuonsWithCov = soa::Join; using MyMuonsColl = soa::Join; using MyMuonsCollWithCov = soa::Join; -using MyBCs = soa::Join; +using MyBCs = soa::Join; using ExtBCs = soa::Join; // Declaration of various bit maps containing information on which tables are included in a Join @@ -130,6 +132,7 @@ constexpr static uint32_t gkEventFillMapWithMultsZdc = VarManager::ObjTypes::BC constexpr static uint32_t gkEventFillMapWithMultsAndEventFilter = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionMult | VarManager::ObjTypes::CollisionMultExtra | VarManager::ObjTypes::EventFilter; constexpr static uint32_t gkEventFillMapWithMultsEventFilterZdc = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionMult | VarManager::ObjTypes::CollisionMultExtra | VarManager::ObjTypes::EventFilter | VarManager::ObjTypes::Zdc; constexpr static uint32_t gkEventFillMapWithMultsRapidityGapFilterZdc = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionMult | VarManager::ObjTypes::CollisionMultExtra | VarManager::ObjTypes::RapidityGapFilter | VarManager::ObjTypes::Zdc; +constexpr static uint32_t gkEventFillMapWithMultsRapidityGapFilterZdcFit = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionMult | VarManager::ObjTypes::CollisionMultExtra | VarManager::ObjTypes::RapidityGapFilter | VarManager::ObjTypes::Zdc | VarManager::ObjTypes::ReducedFit; // constexpr static uint32_t gkEventFillMapWithCent = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionCent; constexpr static uint32_t gkEventFillMapWithCentAndMults = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionCent | VarManager::CollisionMult | VarManager::ObjTypes::CollisionMultExtra; constexpr static uint32_t gkEventFillMapWithMultsExtra = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision | VarManager::CollisionMult | VarManager::ObjTypes::CollisionMultExtra; @@ -166,6 +169,7 @@ struct TableMaker { Produces eventVtxCov; Produces eventInfo; Produces zdc; + Produces fit; Produces multPV; Produces multAll; Produces trackBarrelInfo; @@ -786,9 +790,11 @@ struct TableMaker { } // end loop over collisions } - template - void skimCollisions(TEvents const& collisions, TBCs const& /*bcs*/, TZdcs const& /*zdcs*/, - TTrackAssoc const& trackAssocs, TTracks const& tracks) + template + void skimCollisions(TEvents const& collisions, TBCs const& bcs, TZdcs const& /*zdcs*/, + TTrackAssoc const& trackAssocs, TTracks const& tracks, + TFT0s const& ft0s = nullptr, TFV0As const& fv0as = nullptr, TFDDs const& fdds = nullptr) { // Skim collisions // NOTE: So far, collisions are filtered based on the user specified analysis cuts AND the filterPP or Zorro event filter. @@ -962,6 +968,31 @@ struct TableMaker { zdc(-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0); } } + // Fill FIT information + if constexpr ((TEventFillMap & VarManager::ObjTypes::ReducedFit) > 0) { + upchelpers::FITInfo fitInfo{}; + if constexpr (!std::is_same_v && + !std::is_same_v && + !std::is_same_v) { + // Get the BC from the bcs table using the collision's BC index + auto bc = bcs.iteratorAt(collision.bcId()); + udhelpers::getFITinfo(fitInfo, bc, bcs, ft0s, fv0as, fdds); + VarManager::FillFIT(fitInfo); // Fill VarManager for QA histograms + } + fit(fitInfo.ampFT0A, fitInfo.ampFT0C, + fitInfo.ampFDDA, fitInfo.ampFDDC, fitInfo.ampFV0A, + fitInfo.timeFT0A, fitInfo.timeFT0C, + fitInfo.timeFDDA, fitInfo.timeFDDC, fitInfo.timeFV0A, + fitInfo.triggerMaskFT0, fitInfo.triggerMaskFDD, fitInfo.triggerMaskFV0A, + fitInfo.BBFT0Apf, fitInfo.BGFT0Apf, + fitInfo.BBFT0Cpf, fitInfo.BGFT0Cpf, + fitInfo.BBFV0Apf, fitInfo.BGFV0Apf, + fitInfo.BBFDDApf, fitInfo.BGFDDApf, + fitInfo.BBFDDCpf, fitInfo.BGFDDCpf, + fitInfo.distClosestBcTOR, fitInfo.distClosestBcTSC, + fitInfo.distClosestBcTVX, fitInfo.distClosestBcV0A, + fitInfo.distClosestBcT0A); + } if constexpr ((TEventFillMap & VarManager::ObjTypes::CollisionMultExtra) > 0) { multPV(collision.multNTracksHasITS(), collision.multNTracksHasTPC(), collision.multNTracksHasTOF(), collision.multNTracksHasTRD(), collision.multNTracksITSOnly(), collision.multNTracksTPCOnly(), collision.multNTracksITSTPC(), @@ -1397,10 +1428,12 @@ struct TableMaker { // Produce standard barrel + muon tables with event filter (typically for pp and p-Pb) ------------------------------------------------------ template + typename TTrackAssoc, typename TFwdTrackAssoc, typename TMFTTrackAssoc, typename TMFTCov, + typename TFT0s = std::nullptr_t, typename TFV0As = std::nullptr_t, typename TFDDs = std::nullptr_t> void fullSkimming(TEvents const& collisions, TBCs const& bcs, TZdcs const& zdcs, TTracks const& tracksBarrel, TMuons const& muons, TMFTTracks const& mftTracks, - TTrackAssoc const& trackAssocs, TFwdTrackAssoc const& fwdTrackAssocs, TMFTTrackAssoc const& mftAssocs, TMFTCov const& mftCovs) + TTrackAssoc const& trackAssocs, TFwdTrackAssoc const& fwdTrackAssocs, TMFTTrackAssoc const& mftAssocs, TMFTCov const& mftCovs, + TFT0s const& ft0s = nullptr, TFV0As const& fv0as = nullptr, TFDDs const& fdds = nullptr) { if (bcs.size() > 0 && fCurrentRun != bcs.begin().runNumber()) { @@ -1455,7 +1488,7 @@ struct TableMaker { eventExtended.reserve(collisions.size()); eventVtxCov.reserve(collisions.size()); - skimCollisions(collisions, bcs, zdcs, trackAssocs, tracksBarrel); + skimCollisions(collisions, bcs, zdcs, trackAssocs, tracksBarrel, ft0s, fv0as, fdds); if (fCollIndexMap.size() == 0) { return; } @@ -1652,6 +1685,22 @@ struct TableMaker { fullSkimming(collisions, bcs, zdcs, tracksBarrel, nullptr, nullptr, trackAssocs, nullptr, nullptr, nullptr); } + // produce the barrel-only DQ skimmed data model for UPC Pb-Pb with FIT information + void processPbPbWithFilterBarrelOnlyWithFIT(MyEventsWithMultsAndRapidityGapFilter const& collisions, + MyBCs const& bcs, + aod::Zdcs& zdcs, + aod::FT0s const& ft0s, + aod::FV0As const& fv0as, + aod::FDDs const& fdds, + MyBarrelTracksWithCov const& tracksBarrel, + TrackAssoc const& trackAssocs) + { + fullSkimming(collisions, bcs, zdcs, tracksBarrel, nullptr, nullptr, trackAssocs, nullptr, nullptr, nullptr, + ft0s, fv0as, fdds); + } + PROCESS_SWITCH(TableMaker, processPbPbWithFilterBarrelOnlyWithFIT, + "Produce barrel DQ skimmed data for UPC Pb-Pb with rapidity gap filter, ZDC, and FIT info", false); + // produce the barrel only DQ skimmed data model typically for Pb-Pb (with centrality), no subscribtion to the DQ event filter void processPbPbBarrelOnlyWithV0Bits(MyEventsWithCentAndMults const& collisions, BCsWithTimestamps const& bcs, MyBarrelTracksWithV0Bits const& tracksBarrel,