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,