From 8c165e4d3b2c90caf2c9406e823898926cdf0296 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Fri, 26 Jun 2026 16:24:21 +0200 Subject: [PATCH 1/3] updated code with fine time rec --- PWGLF/TableProducer/Common/spvector.cxx | 46 ++++++++++++++++++------- 1 file changed, 33 insertions(+), 13 deletions(-) diff --git a/PWGLF/TableProducer/Common/spvector.cxx b/PWGLF/TableProducer/Common/spvector.cxx index be27699fc8f..b4504f74f7d 100644 --- a/PWGLF/TableProducer/Common/spvector.cxx +++ b/PWGLF/TableProducer/Common/spvector.cxx @@ -127,10 +127,13 @@ struct spvector { Configurable useCallibvertex{"useCallibvertex", false, "use calibration for vxy"}; Configurable coarse1{"coarse1", false, "RE1"}; Configurable fine1{"fine1", false, "REfine1"}; + Configurable finetime1{"finetime1", false, "REfinetime1"}; Configurable coarse2{"coarse2", false, "RE2"}; Configurable fine2{"fine2", false, "REfine2"}; + Configurable finetime2{"finetime2", false, "REfinetime2"}; Configurable coarse3{"coarse3", false, "RE3"}; Configurable fine3{"fine3", false, "REfine3"}; + Configurable finetime3{"finetime3", false, "REfinetime3"}; Configurable coarse4{"coarse4", false, "RE4"}; Configurable fine4{"fine4", false, "REfine4"}; Configurable coarse5{"coarse5", false, "RE5"}; @@ -139,6 +142,7 @@ struct spvector { Configurable fine6{"fine6", false, "REfine6"}; Configurable useRecentereSp{"useRecentereSp", false, "use Recentering with Sparse or THn"}; Configurable useRecenterefineSp{"useRecenterefineSp", false, "use fine Recentering with THn"}; + Configurable useTimeRecentering{"useTimeRecentering", false, "Use residual time recentering"}; Configurable ConfGainPath{"ConfGainPath", "Users/p/prottay/My/Object/NewPbPbpass4_10092024/gaincallib", "Path to gain calibration"}; Configurable ConfGainPathvxy{"ConfGainPathvxy", "Users/p/prottay/My/Object/swapcoords/PbPbpass4_20112024/recentervert", "Path to gain calibration for vxy"}; Configurable ConfRecentereSp{"ConfRecentereSp", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for recentere"}; @@ -173,8 +177,9 @@ struct spvector { Configurable ConfRecenterevzSp6{"ConfRecenterevzSp6", "Users/p/prottay/My/Object/Testingwithsparse/NewPbPbpass4_17092024/recenter", "Sparse or THn Path for vz recentere6"}; Configurable ConfShiftC{"ConfShiftC", "Users/p/prottay/My/Object/Testinglocaltree/shiftcallib2", "Path to shift C"}; Configurable ConfShiftA{"ConfShiftA", "Users/p/prottay/My/Object/Testinglocaltree/shiftcallib2", "Path to shift A"}; - Configurable useTimeRecentering{"useTimeRecentering", false, "Use residual time recentering"}; - Configurable confRecentereTimeSp{"confRecentereTimeSp", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map"}; + Configurable confRecentereTimeSp1{"confRecentereTimeSp1", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map 1"}; + Configurable confRecentereTimeSp2{"confRecentereTimeSp2", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast2", "Path to time recentering map 2"}; + Configurable confRecentereTimeSp3{"confRecentereTimeSp3", "Users/p/prottay/My/Object/GCwithoutcfactorgoodVztimedep/From676541/TestDDlocal/2024PbPbpass3_23062026/recenterlast3", "Path to time recentering map 3"}; // Event selection cuts - Alex /* @@ -314,7 +319,9 @@ struct spvector { std::array hrecenterevzSpA; // Array of 5 histograms TProfile3D* shiftprofileA; TProfile3D* shiftprofileC; - TH2F* hrecentereTimeSp = nullptr; + TH2F* hrecentereTimeSp1 = nullptr; + TH2F* hrecentereTimeSp2 = nullptr; + TH2F* hrecentereTimeSp3 = nullptr; Bool_t Correctcoarse(const THnF* hrecentereSp, auto centrality, auto vx, auto vy, auto vz, auto& qxZDCA, auto& qyZDCA, auto& qxZDCC, auto& qyZDCC) { @@ -652,6 +659,14 @@ struct spvector { resfine = Correctfine(hrecenterecentSpA[0], hrecenterevxSpA[0], hrecenterevySpA[0], hrecenterevzSpA[0], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } + if (finetime1 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp1 = ccdb->getForTimeStamp(confRecentereTimeSp1.value, bc.timestamp()); + } + bool restime = false; + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp1, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } + if (coarse2) { if (useRecentereSp && (currentRunNumber != lastRunNumber)) { hrecentereSpA[1] = ccdb->getForTimeStamp(ConfRecentereSp2.value, bc.timestamp()); @@ -669,6 +684,13 @@ struct spvector { resfine = Correctfine(hrecenterecentSpA[1], hrecenterevxSpA[1], hrecenterevySpA[1], hrecenterevzSpA[1], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } + if (finetime2 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp2 = ccdb->getForTimeStamp(confRecentereTimeSp2.value, bc.timestamp()); + } + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp2, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } + if (coarse3) { if (useRecentereSp && (currentRunNumber != lastRunNumber)) { hrecentereSpA[2] = ccdb->getForTimeStamp(ConfRecentereSp3.value, bc.timestamp()); @@ -686,6 +708,13 @@ struct spvector { resfine = Correctfine(hrecenterecentSpA[2], hrecenterevxSpA[2], hrecenterevySpA[2], hrecenterevzSpA[2], centrality, vx, vy, vz, qxZDCA, qyZDCA, qxZDCC, qyZDCC); } + if (finetime3 && (currentRunNumber != lastRunNumber)) { + hrecentereTimeSp3 = ccdb->getForTimeStamp(confRecentereTimeSp3.value, bc.timestamp()); + } + if (useTimeRecentering) { + restime = Correcttime(hrecentereTimeSp3, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); + } + if (coarse4) { if (useRecentereSp && (currentRunNumber != lastRunNumber)) { hrecentereSpA[3] = ccdb->getForTimeStamp(ConfRecentereSp4.value, bc.timestamp()); @@ -741,16 +770,7 @@ struct spvector { LOG(info) << "Histograms are null"; } - if (useTimeRecentering && (currentRunNumber != lastRunNumber)) { - hrecentereTimeSp = ccdb->getForTimeStamp(confRecentereTimeSp.value, bc.timestamp()); - } - - bool restime = false; - if (useTimeRecentering) { - restime = Correcttime(hrecentereTimeSp, timeMin, qxZDCA, qyZDCA, qxZDCC, qyZDCC); - } - - if (restime == 0) { + if (useTimeRecentering && restime == 0 && check == 0) { LOG(info) << "Histograms are null"; } From 1eb8777396a579f4cfb1628483a9d2e8b1516c66 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Sat, 27 Jun 2026 13:42:30 +0200 Subject: [PATCH 2/3] updated tableproducer with ch tracks info --- PWGLF/DataModel/ZDCCalTables.h | 24 +++++++ PWGLF/TableProducer/Common/zdcvector.cxx | 79 +++++++++++++++++++++--- 2 files changed, 95 insertions(+), 8 deletions(-) diff --git a/PWGLF/DataModel/ZDCCalTables.h b/PWGLF/DataModel/ZDCCalTables.h index 0d11fe4b1ca..9a3e2181728 100644 --- a/PWGLF/DataModel/ZDCCalTables.h +++ b/PWGLF/DataModel/ZDCCalTables.h @@ -102,5 +102,29 @@ DECLARE_SOA_TABLE(ZDCTimeTables, "AOD", "ZDCTIME", zdctimetable::TimeMin); using ZDCTimeTable = ZDCTimeTables::iterator; + +// charged-track linked table comes here + +namespace zdcchargedtrack +{ +DECLARE_SOA_INDEX_COLUMN(ZDCCalTable, zdcCalTable); + +DECLARE_SOA_COLUMN(Px, px, float); +DECLARE_SOA_COLUMN(Py, py, float); +DECLARE_SOA_COLUMN(Pz, pz, float); +DECLARE_SOA_COLUMN(Sign, sign, int8_t); +} // namespace zdcchargedtrack + +DECLARE_SOA_TABLE(ZDCChargedTracks, + "AOD", + "ZDCCHTRK", + zdcchargedtrack::ZDCCalTableId, + zdcchargedtrack::Px, + zdcchargedtrack::Py, + zdcchargedtrack::Pz, + zdcchargedtrack::Sign); + +using ZDCChargedTrack = ZDCChargedTracks::iterator; + } // namespace o2::aod #endif // PWGLF_DATAMODEL_ZDCCALTABLES_H_ diff --git a/PWGLF/TableProducer/Common/zdcvector.cxx b/PWGLF/TableProducer/Common/zdcvector.cxx index b6b5407156f..c32e81cdc7f 100644 --- a/PWGLF/TableProducer/Common/zdcvector.cxx +++ b/PWGLF/TableProducer/Common/zdcvector.cxx @@ -62,6 +62,7 @@ struct zdcvector { Produces zdccaltable; Produces zdcenergytable; Produces zdctimetable; + Produces zdcchargedtracks; // Configurables. struct : ConfigurableGroup { @@ -80,6 +81,12 @@ struct zdcvector { Configurable usemem{"usemem", true, "usemem"}; Configurable usecfactor{"usecfactor", false, "use c factor"}; + Configurable cfgTrackPtMin{"cfgTrackPtMin", 0.2f, "Minimum charged-track pT"}; + Configurable cfgTrackPtMax{"cfgTrackPtMax", 10.0f, "Maximum charged-track pT"}; + Configurable cfgTrackEtaMax{"cfgTrackEtaMax", 0.8f, "Maximum absolute eta"}; + Configurable cfgUseGlobalTracks{"cfgUseGlobalTracks", true, "Use global tracks"}; + Configurable storeChargedTracks{"storeChargedTracks", true, "Store selected charged tracks in a linked extra table"}; + struct : ConfigurableGroup { Configurable vzFineNbins{"vzFineNbins", 20, "Number of bins in Vz fine histograms"}; Configurable lfinebinVz{"lfinebinVz", -10.0, "lower bin value in Vz fine histograms"}; @@ -143,13 +150,35 @@ struct zdcvector { ccdb->setCreatedNotAfter(std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count()); } + template + bool selectionTrack(const T& candidate) + { + if (!(candidate.isGlobalTrack() && + candidate.isPVContributor() && + candidate.itsNCls() > 3 && + candidate.tpcNClsFound() > 50.0 && + candidate.itsNClsInnerBarrel() >= 1)) { + return false; + } + + if (std::abs(candidate.dcaXY()) >= 0.1) { + return false; + } + + if (std::abs(candidate.dcaZ()) >= 0.1) { + return false; + } + + return true; + } + int currentRunNumber = -999; int lastRunNumber = -999; TH2D* gainprofile = nullptr; TProfile* gainprofilevxy = nullptr; // int lastRunNumberTimeRec = -999; - // for time since start of run + // for time since start of run // int runForStartTime = -999; // uint64_t runStartTime = 0; @@ -217,7 +246,7 @@ struct zdcvector { float qxA, float qxC, float qyA, - float qyC) { + float qyC) -> int32_t { zdccaltable(trigger, currentRunNumber, centrality, @@ -229,7 +258,7 @@ struct zdcvector { qyA, qyC); - auto zdcCalIndex = zdccaltable.lastIndex(); + const auto zdcCalIndex = static_cast(zdccaltable.lastIndex()); if (storeZdcEnergy) { zdcenergytable(zdcCalIndex, @@ -244,11 +273,14 @@ struct zdcvector { znc2, znc3); } + if (storeZdcTime) { zdctimetable(zdcCalIndex, timestampzdc, timeInMinutes); } + + return zdcCalIndex; }; if (!bc.has_zdc()) { @@ -439,11 +471,42 @@ struct zdcvector { lastRunNumber = currentRunNumber; } // zdccaltable(triggerevent, currentRunNumber, centrality, vx, vy, vz, qxZDCA, qxZDCC, qyZDCA, qyZDCC); - fillTables(triggerevent, - qxZDCA, - qxZDCC, - qyZDCA, - qyZDCC); + const auto zdcCalIndex = fillTables(triggerevent, + qxZDCA, + qxZDCC, + qyZDCA, + qyZDCC); + + // Do not write tracks for events rejected by your ZDC/event selection + if (!triggerevent || !storeChargedTracks) { + return; + } + + // In this process signature, "tracks" are the tracks associated with + // the current collision. + for (const auto& track : tracks) { + if (!selectionTrack(track)) { + continue; + } + + if (track.pt() < cfgTrackPtMin || track.pt() > cfgTrackPtMax) { + continue; + } + + if (track.sign() == 0) { + continue; + } + + if (std::abs(track.eta()) > cfgTrackEtaMax) { + continue; + } + + zdcchargedtracks(zdcCalIndex, + track.px(), + track.py(), + track.pz(), + static_cast(track.sign())); + } } }; From f853d0ebf5e89de62e53b2fd20b53d041bc18796 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Sat, 27 Jun 2026 23:18:52 +0200 Subject: [PATCH 3/3] updated datamodel with index --- PWGLF/DataModel/ZDCCalTables.h | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGLF/DataModel/ZDCCalTables.h b/PWGLF/DataModel/ZDCCalTables.h index 9a3e2181728..30851802438 100644 --- a/PWGLF/DataModel/ZDCCalTables.h +++ b/PWGLF/DataModel/ZDCCalTables.h @@ -38,6 +38,7 @@ DECLARE_SOA_COLUMN(QyA, qyA, float); DECLARE_SOA_COLUMN(QyC, qyC, float); } // namespace zdccaltable DECLARE_SOA_TABLE(ZDCCalTables, "AOD", "ZDCCALTABLE", + o2::soa::Index<>, zdccaltable::TriggerEventZDC, zdccaltable::TriggerEventRunNo, zdccaltable::Cent,