From 965711ff4cddb7479b13281ac3a9ffad39e74d2d Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 15:44:42 +0300
Subject: [PATCH 01/10] Add separate task for forward muon analysis, propagate
 muon tracks to zero + small bug fixes

---
 PWGUD/Core/UPCHelpers.h                       |   2 +-
 PWGUD/TableProducer/CMakeLists.txt            |   5 +
 .../UPCCandidateProducerMuon.cxx              | 532 ++++++++++++++++++
 PWGUD/TableProducer/fwdTrackPropagation.cxx   |  10 +-
 4 files changed, 543 insertions(+), 6 deletions(-)
 create mode 100644 PWGUD/TableProducer/UPCCandidateProducerMuon.cxx

diff --git a/PWGUD/Core/UPCHelpers.h b/PWGUD/Core/UPCHelpers.h
index a7ca4b63af4..16a91bb5eb0 100644
--- a/PWGUD/Core/UPCHelpers.h
+++ b/PWGUD/Core/UPCHelpers.h
@@ -102,7 +102,7 @@ void applyFwdCuts(UPCCutparHolder& upcCuts, const T& track, TSelectorsArray& fwd
   fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                     // check pt
   fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                // check pseudorapidity
   fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh(); // check muon R
-  fwdSelectors[kFwdSelpDCA] = track.pDca() < 26.5 ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond();        // check pDCA
+  fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < 26.5 ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond();        // check pDCA
   fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                           // check chi2
 }
 
diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index 651a51bddc6..a38b861ecf7 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -60,3 +60,8 @@ o2physics_add_dpl_workflow(tau-three-prong-event-table-producer
                            SOURCES tauThreeProngEventTableProducer.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
                            COMPONENT_NAME Analysis)
+
+o2physics_add_dpl_workflow(upccand-producer-muon
+                           SOURCES UPCCandidateProducerMuon.cxx
+                           PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::UPCCutparHolder O2::GlobalTracking
+                           COMPONENT_NAME Analysis)
diff --git a/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx b/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
new file mode 100644
index 00000000000..c62aaef3f9c
--- /dev/null
+++ b/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
@@ -0,0 +1,532 @@
+// 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.
+
+#include "PWGUD/Core/UPCCutparHolder.h"
+#include "PWGUD/Core/UPCHelpers.h"
+#include "PWGUD/DataModel/UDTables.h"
+
+#include "CCDB/BasicCCDBManager.h"
+#include "CommonConstants/LHCConstants.h"
+#include "DataFormatsFIT/Triggers.h"
+#include "DataFormatsParameters/GRPMagField.h"
+#include "DetectorsBase/Propagator.h"
+#include "Field/MagneticField.h"
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/runDataProcessing.h"
+#include "GlobalTracking/MatchGlobalFwd.h"
+#include "MCHTracking/TrackExtrap.h"
+#include "MCHTracking/TrackParam.h"
+#include "ReconstructionDataFormats/TrackFwd.h"
+
+#include "Math/SMatrix.h"
+#include "TGeoGlobalMagField.h"
+
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+using namespace o2::framework;
+using namespace o2::framework::expressions;
+
+struct UpcCandProducerMuon {
+  bool fDoMC{false};
+
+  std::map<int32_t, int32_t> fNewPartIDs;
+
+  Produces<o2::aod::UDMcCollisions> udMCCollisions;
+  Produces<o2::aod::UDMcParticles> udMCParticles;
+  Produces<o2::aod::UDMcFwdTrackLabels> udFwdTrackLabels;
+
+  Produces<o2::aod::UDFwdTracks> udFwdTracks;
+  Produces<o2::aod::UDFwdTracksExtra> udFwdTracksExtra;
+  Produces<o2::aod::UDFwdIndices> udFwdIndices;
+  Produces<o2::aod::UDCollisions> eventCandidates;
+  Produces<o2::aod::UDCollisionsSelsFwd> eventCandidatesSelsFwd;
+  Produces<o2::aod::UDZdcsReduced> udZdcsReduced;
+
+  Configurable<int> fSignalGenID{"signalGenID", 1, "Signal generator ID"};
+
+  UPCCutparHolder upcCuts = UPCCutparHolder();
+  MutableConfigurable<UPCCutparHolder> inputCuts{"UPCCuts", {}, "UPC event cuts"};
+  Configurable<uint64_t> fBCWindowFITAmps{"bcWindowFITAmps", 20, "BC range for T0A/V0A amplitudes array [-range, +(range-1)]"};
+  Configurable<int> fBcWindowMCH{"bcWindowMCH", 20, "Time window for MCH-MID to MCH-only matching for Muon candidates"};
+  Configurable<float> fMaxFV0Amp{"maxFV0Amp", 100.f, "Max FV0 amplitude in the same BC"};
+
+  using ForwardTracks = o2::soa::Join<o2::aod::FwdTracks, o2::aod::FwdTracksCov>;
+
+  HistogramRegistry histRegistry{"HistRegistry", {}, OutputObjHandlingPolicy::AnalysisObject};
+
+  int fRun{0};
+  Service<o2::ccdb::BasicCCDBManager> fCCDB;
+  o2::ccdb::CcdbApi fCCDBApi;
+  o2::globaltracking::MatchGlobalFwd fMatching;
+
+  void init(InitContext&)
+  {
+    upcCuts = (UPCCutparHolder)inputCuts;
+    if (upcCuts.getUseFwdCuts()) {
+      fCCDB->setURL("http://alice-ccdb.cern.ch");
+      fCCDB->setCaching(true);
+      fCCDB->setLocalObjectValidityChecking();
+      fCCDBApi.init("http://alice-ccdb.cern.ch");
+    }
+    const AxisSpec axisSelFwd{upchelpers::kNFwdSels, 0., static_cast<double>(upchelpers::kNFwdSels), ""};
+    histRegistry.add("MuonsSelCounter", "", kTH1F, {axisSelFwd});
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelAll + 1, "All");
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelPt + 1, "Pt");
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelEta + 1, "Eta");
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelRabs + 1, "Rabs");
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelpDCA + 1, "pDCA");
+    histRegistry.get<TH1>(HIST("MuonsSelCounter"))->GetXaxis()->SetBinLabel(upchelpers::kFwdSelChi2 + 1, "Chi2");
+  }
+
+  bool cut(const o2::dataformats::GlobalFwdTrack& pft, const ForwardTracks::iterator& fwdTrack)
+  {
+    histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelAll, 1);
+    auto pt = pft.getPt();
+    auto eta = pft.getEta();
+    auto pdca = fwdTrack.pDca();
+    auto rabs = fwdTrack.rAtAbsorberEnd();
+    auto chi2 = fwdTrack.chi2();
+    bool passPt = pt > upcCuts.getFwdPtLow() && pt < upcCuts.getFwdPtHigh();
+    bool passEta = eta > upcCuts.getFwdEtaLow() && eta < upcCuts.getFwdEtaHigh();
+    bool passRabs = rabs > upcCuts.getMuonRAtAbsorberEndLow() && rabs < upcCuts.getMuonRAtAbsorberEndHigh();
+    bool passPDca = rabs < 26.5 ? pdca < upcCuts.getMuonPDcaHighFirst() : pdca < upcCuts.getMuonPDcaHighSecond();
+    bool passChi2 = chi2 > upcCuts.getFwdChi2Low() && chi2 < upcCuts.getFwdChi2High();
+    if (passPt)
+      histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelPt, 1);
+    if (passEta)
+      histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelEta, 1);
+    if (passRabs)
+      histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelRabs, 1);
+    if (passPDca)
+      histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelpDCA, 1);
+    if (passChi2)
+      histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelChi2, 1);
+    return passPt && passEta && passRabs && passPDca && passChi2;
+  }
+
+  void skimMCInfo(o2::aod::McCollisions const& mcCollisions, o2::aod::McParticles const& mcParticles)
+  {
+    std::vector<int32_t> newEventIDs(mcCollisions.size(), -1);
+
+    int32_t newPartID = 0;
+    int32_t newEventID = 0;
+    int32_t nMCParticles = mcParticles.size();
+    // loop over MC particles to select only the ones from signal events
+    // and calculate new MC table IDs
+    for (int32_t mcPartID = 0; mcPartID < nMCParticles; mcPartID++) {
+      const auto& mcPart = mcParticles.iteratorAt(mcPartID);
+      if (!mcPart.has_mcCollision())
+        continue;
+      int32_t mcEventID = mcPart.mcCollisionId();
+      const auto& mcEvent = mcCollisions.iteratorAt(mcEventID);
+      bool isSignal = mcEvent.getGeneratorId() == fSignalGenID;
+      if (!isSignal) {
+        continue;
+      }
+      fNewPartIDs[mcPartID] = newPartID;
+      newPartID++;
+      if (newEventIDs[mcEventID] == -1) {
+        newEventIDs[mcEventID] = newEventID;
+        newEventID++;
+      }
+    }
+
+    std::vector<int32_t> newMotherIDs{};
+
+    // storing MC particles
+    for (const auto& item : fNewPartIDs) {
+      int32_t mcPartID = item.first;
+      const auto& mcPart = mcParticles.iteratorAt(mcPartID);
+      int32_t mcEventID = mcPart.mcCollisionId();
+      int32_t newEventID = newEventIDs[mcEventID];
+      // collecting new mother IDs
+      if (mcPart.has_mothers()) {
+        const auto& motherIDs = mcPart.mothersIds();
+        for (auto motherID : motherIDs) {
+          if (motherID >= nMCParticles) {
+            continue;
+          }
+          auto it = fNewPartIDs.find(motherID);
+          if (it != fNewPartIDs.end()) {
+            newMotherIDs.push_back(it->second);
+          }
+        }
+      }
+      // collecting new daughter IDs
+      int32_t newDaughterIDs[2] = {-1, -1};
+      if (mcPart.has_daughters()) {
+        const auto& daughterIDs = mcPart.daughtersIds();
+        int32_t firstDaughter = daughterIDs.front();
+        int32_t lastDaughter = daughterIDs.back();
+        if (firstDaughter >= nMCParticles || lastDaughter >= nMCParticles) {
+          continue;
+        }
+        auto itFirst = fNewPartIDs.find(firstDaughter);
+        auto itLast = fNewPartIDs.find(lastDaughter);
+        if (itFirst != fNewPartIDs.end() && itLast != fNewPartIDs.end()) {
+          newDaughterIDs[0] = fNewPartIDs.at(daughterIDs.front());
+          newDaughterIDs[1] = fNewPartIDs.at(daughterIDs.back());
+        }
+      }
+      udMCParticles(newEventID, mcPart.pdgCode(), mcPart.getHepMCStatusCode(), mcPart.flags(), newMotherIDs, newDaughterIDs,
+                    mcPart.weight(), mcPart.px(), mcPart.py(), mcPart.pz(), mcPart.e());
+      newMotherIDs.clear();
+    }
+
+    // storing MC events
+    for (int32_t i = 0; i < mcCollisions.size(); i++) {
+      if (newEventIDs[i] == -1) {
+        continue;
+      }
+      const auto& mcEvent = mcCollisions.iteratorAt(i);
+      const auto& bc = mcEvent.bc();
+      udMCCollisions(bc.globalBC(), mcEvent.generatorsID(), mcEvent.posX(), mcEvent.posY(), mcEvent.posZ(),
+                     mcEvent.t(), mcEvent.weight(), mcEvent.impactParameter());
+    }
+
+    newEventIDs.clear();
+  }
+
+  int64_t bcDiff(uint64_t bc1, uint64_t bc2)
+  {
+    return bc1 > bc2 ? bc1 - bc2 : bc2 - bc1;
+  }
+
+  // find starting point for scrolling in some BC map -- closest to the input gbc
+  template <typename T>
+  T::iterator getStartForScroll(uint64_t inGbc, T& gbcMap)
+  {
+    auto it1 = gbcMap.lower_bound(inGbc);
+    typename T::iterator it;
+    if (it1 != gbcMap.end()) { // found lower bound
+      auto it2 = it1;
+      uint64_t bc1 = it1->first;
+      if (it2 != gbcMap.begin())
+        --it2;
+      uint64_t bc2 = it2->first;
+      uint64_t dbc1 = bcDiff(bc1, inGbc);
+      uint64_t dbc2 = bcDiff(bc2, inGbc);
+      it = (dbc1 <= dbc2) ? it1 : it2;
+    } else { // ended up in the end
+      it = it1;
+      --it;
+    }
+    return it;
+  }
+
+  // scroll over gbcMap and do some operation on container
+  template <typename T, typename F>
+  void scrollBackForth(uint64_t inGbc, uint64_t maxDbc, T& gbcMap, F&& func)
+  {
+    auto it = getStartForScroll(inGbc, gbcMap);
+    uint64_t gbc = it->first;
+    uint64_t dbc = bcDiff(inGbc, gbc);
+
+    // start scrolling backward
+    int count = 0;
+    while (dbc <= maxDbc) {
+      func(it, gbc);
+      count++;
+      if (it == gbcMap.begin())
+        break;
+      --it;
+      gbc = it->first;
+      dbc = bcDiff(inGbc, gbc);
+    }
+
+    std::advance(it, count + 1); // move back to the starting point + 1
+
+    if (it == gbcMap.end()) // ended up in the end of map
+      return;
+
+    gbc = it->first;
+    dbc = bcDiff(inGbc, gbc);
+
+    // start scrolling forward
+    while (dbc <= maxDbc) {
+      func(it, gbc);
+      ++it;
+      if (it == gbcMap.end())
+        break;
+      gbc = it->first;
+      dbc = bcDiff(inGbc, gbc);
+    }
+  }
+
+  void getMchTrackIds(uint64_t inGbc, std::map<uint64_t, std::vector<int64_t>>& mchTracksPerBC,
+                      uint64_t maxDbc, std::map<int64_t, uint64_t>& outMchTrkIds)
+  {
+    auto fillMchIds = [&outMchTrkIds](std::map<uint64_t, std::vector<int64_t>>::iterator& inIt, uint64_t gbc) {
+      std::vector<int64_t>& ids = inIt->second;
+      for (auto id : ids)
+        outMchTrkIds[id] = gbc;
+    };
+    scrollBackForth(inGbc, maxDbc, mchTracksPerBC, fillMchIds);
+  }
+
+  void getFV0Amplitudes(uint64_t inGbc, o2::aod::FV0As const& fv0s, uint64_t maxDbc,
+                        std::map<uint64_t, int64_t>& mapBcs, std::vector<float>& amps, std::vector<int8_t>& relBcs)
+  {
+
+    auto fillAmps = [this, &fv0s, &amps, &relBcs, inGbc](std::map<uint64_t, int64_t>::iterator& inIt, uint64_t gbc) {
+      int64_t fv0Id = inIt->second;
+      const auto& fv0 = fv0s.iteratorAt(fv0Id);
+      const auto& amplitudes = fv0.amplitude();
+      float totalAmp = std::accumulate(amplitudes.begin(), amplitudes.end(), 0.f);
+      if (totalAmp > 0.f) {
+        amps.push_back(totalAmp);
+        auto relBc = static_cast<int8_t>(bcDiff(gbc, inGbc));
+        if (gbc < inGbc)
+          relBc *= -1;
+        relBcs.push_back(relBc);
+      }
+    };
+    scrollBackForth(inGbc, maxDbc, mapBcs, fillAmps);
+  }
+
+  auto propagateToZero(ForwardTracks::iterator const& muon)
+  {
+    using SMatrix55 = ROOT::Math::SMatrix<double, 5, 5, ROOT::Math::MatRepSym<double, 5>>;
+    using SMatrix5 = ROOT::Math::SVector<double, 5>;
+    SMatrix5 tpars(muon.x(), muon.y(), muon.phi(), muon.tgl(), muon.signed1Pt());
+    std::vector<double> v1{muon.cXX(), muon.cXY(), muon.cYY(), muon.cPhiX(), muon.cPhiY(),
+                           muon.cPhiPhi(), muon.cTglX(), muon.cTglY(), muon.cTglPhi(), muon.cTglTgl(),
+                           muon.c1PtX(), muon.c1PtY(), muon.c1PtPhi(), muon.c1PtTgl(), muon.c1Pt21Pt2()};
+    SMatrix55 tcovs(v1.begin(), v1.end());
+    o2::dataformats::GlobalFwdTrack propmuon;
+    o2::dataformats::GlobalFwdTrack track;
+    track.setParameters(tpars);
+    track.setZ(muon.z());
+    track.setCovariances(tcovs);
+    auto mchTrack = fMatching.FwdtoMCH(track);
+    o2::mch::TrackExtrap::extrapToVertex(mchTrack, 0., 0., 0., 0., 0.);
+    auto proptrack = fMatching.MCHtoFwd(mchTrack);
+    propmuon.setParameters(proptrack.getParameters());
+    propmuon.setZ(proptrack.getZ());
+    propmuon.setCovariances(proptrack.getCovariances());
+    return propmuon;
+  }
+
+  bool addToFwdTable(int64_t candId, int64_t trackId, uint64_t gbc, float trackTime, ForwardTracks const& fwdTracks, const o2::aod::McFwdTrackLabels* mcFwdTrackLabels)
+  {
+    const auto& track = fwdTracks.iteratorAt(trackId);
+    float px, py, pz;
+    int sign;
+    if (upcCuts.getUseFwdCuts()) {
+      auto pft = propagateToZero(track);
+      bool pass = cut(pft, track);
+      if (!pass)
+        return false;
+      px = pft.getPx();
+      py = pft.getPy();
+      pz = pft.getPz();
+      sign = (pft.getInvQPt() > 0) ? 1 : -1;
+    } else {
+      px = track.px();
+      py = track.py();
+      pz = track.pz();
+      sign = track.sign();
+    }
+    udFwdTracks(candId, px, py, pz, sign, gbc, trackTime, track.trackTimeRes());
+    udFwdTracksExtra(track.trackType(), track.nClusters(), track.pDca(), track.rAtAbsorberEnd(), track.chi2(), track.chi2MatchMCHMID(), -1., track.mchBitMap(), track.midBitMap(), track.midBoards());
+    udFwdIndices(candId, trackId, track.matchMCHTrackId(), -1);
+    if (fDoMC) {
+      const auto& label = mcFwdTrackLabels->iteratorAt(trackId);
+      uint16_t mcMask = label.mcMask();
+      auto it = fNewPartIDs.find(label.mcParticleId());
+      int32_t newPartID = it != fNewPartIDs.end() ? it->second : -1;
+      udFwdTrackLabels(newPartID, mcMask);
+    }
+    return true;
+  }
+
+  void createCandidates(ForwardTracks const& fwdTracks,
+                        o2::aod::AmbiguousFwdTracks const& ambFwdTracks,
+                        o2::aod::BCs const& bcs,
+                        o2::aod::Collisions const& collisions,
+                        o2::aod::FV0As const& fv0s,
+                        o2::aod::Zdcs const& zdcs,
+                        const o2::aod::McFwdTrackLabels* mcFwdTrackLabels)
+  {
+    int32_t runNumber = bcs.iteratorAt(0).runNumber();
+    if (upcCuts.getUseFwdCuts()) {
+      if (runNumber != fRun) {
+        fRun = runNumber;
+        std::map<std::string, std::string> metadata;
+        auto soreor = o2::ccdb::BasicCCDBManager::getRunDuration(fCCDBApi, fRun);
+        auto ts = soreor.second;
+        auto grpmag = fCCDBApi.retrieveFromTFileAny<o2::parameters::GRPMagField>("GLO/Config/GRPMagField", metadata, ts);
+        o2::base::Propagator::initFieldFromGRP(grpmag);
+        if (!o2::base::GeometryManager::isGeometryLoaded())
+          fCCDB->get<TGeoManager>("GLO/Config/GeometryAligned");
+        o2::mch::TrackExtrap::setField();
+      }
+    }
+
+    auto nBcs = bcs.size();
+    std::vector<uint64_t> vGlobalBCs(nBcs, 0);
+    for (const auto& bc : bcs) {
+      vGlobalBCs[bc.globalIndex()] = bc.globalBC();
+    }
+
+    auto nCols = collisions.size();
+    std::vector<int64_t> vColIndexBCs(nCols, -1);
+    for (const auto& col : collisions) {
+      vColIndexBCs[col.globalIndex()] = col.bcId();
+    }
+
+    std::map<uint64_t, int64_t> mapGlobalBcWithV0A{};
+    for (const auto& fv0 : fv0s) {
+      if (std::abs(fv0.time()) > 15.f)
+        continue;
+      uint64_t globalBC = vGlobalBCs[fv0.bcId()];
+      mapGlobalBcWithV0A[globalBC] = fv0.globalIndex();
+    }
+    auto nFV0s = mapGlobalBcWithV0A.size();
+
+    std::map<uint64_t, int64_t> mapGlobalBcWithZdc{};
+    for (const auto& zdc : zdcs) {
+      if (std::abs(zdc.timeZNA()) > 2.f && std::abs(zdc.timeZNC()) > 2.f)
+        continue;
+      uint64_t globalBC = vGlobalBCs[zdc.bcId()];
+      mapGlobalBcWithZdc[globalBC] = zdc.globalIndex();
+    }
+    auto nZdcs = mapGlobalBcWithZdc.size();
+
+    auto nFwdTracks = fwdTracks.size();
+    auto nAmbFwdTracks = ambFwdTracks.size();
+    std::vector<int64_t> vAmbFwdTrackIndex(nFwdTracks, -1);
+    std::vector<int64_t> vAmbFwdTrackIndexBCs(nAmbFwdTracks, -1);
+    for (const auto& ambTr : ambFwdTracks) {
+      vAmbFwdTrackIndex[ambTr.fwdtrackId()] = ambTr.globalIndex();
+      vAmbFwdTrackIndexBCs[ambTr.globalIndex()] = ambTr.bcIds()[0];
+    }
+
+    std::map<uint64_t, std::vector<int64_t>> mapGlobalBcsWithMCHMIDTrackIds;
+    std::map<uint64_t, std::vector<int64_t>> mapGlobalBcsWithMCHTrackIds;
+    for (const auto& fwdTrack : fwdTracks) {
+      if (fwdTrack.trackType() != 3 && fwdTrack.trackType() != 4)
+        continue;
+      auto trackId = fwdTrack.globalIndex();
+      int64_t indexBC = vAmbFwdTrackIndex[trackId] < 0 ? vColIndexBCs[fwdTrack.collisionId()] : vAmbFwdTrackIndexBCs[vAmbFwdTrackIndex[trackId]];
+      auto globalBC = vGlobalBCs[indexBC] + TMath::FloorNint(fwdTrack.trackTime() / o2::constants::lhc::LHCBunchSpacingNS + 1.);
+      if (fwdTrack.trackType() == 3)
+        mapGlobalBcsWithMCHMIDTrackIds[globalBC].push_back(trackId);
+      if (fwdTrack.trackType() == 4)
+        mapGlobalBcsWithMCHTrackIds[globalBC].push_back(trackId);
+    }
+
+    int32_t candId = 0;
+    for (auto& gbc_muids : mapGlobalBcsWithMCHMIDTrackIds) {
+      uint64_t globalBcMid = gbc_muids.first;
+      auto itFv0Id = mapGlobalBcWithV0A.find(globalBcMid);
+      if (itFv0Id != mapGlobalBcWithV0A.end()) {
+        auto fv0Id = itFv0Id->second;
+        const auto& fv0 = fv0s.iteratorAt(fv0Id);
+        float fv0Amp = 0.f;
+        for (auto amp : fv0.amplitude())
+          fv0Amp += amp;
+        if (fv0Amp > fMaxFV0Amp)
+          continue;
+      }
+      uint16_t numContrib = 0;
+      auto& vMuonIds = gbc_muids.second;
+      // writing MCH-MID tracks
+      for (auto imuon : vMuonIds) {
+        if (!addToFwdTable(candId, imuon, globalBcMid, 0., fwdTracks, mcFwdTrackLabels))
+          continue;
+        numContrib++;
+      }
+      if (numContrib < 1) // didn't save any MCH-MID tracks
+        continue;
+      std::map<int64_t, uint64_t> mapMchIdBc{};
+      getMchTrackIds(globalBcMid, mapGlobalBcsWithMCHTrackIds, fBcWindowMCH, mapMchIdBc);
+      // writing MCH-only tracks
+      for (auto& [imch, gbc] : mapMchIdBc) {
+        if (!addToFwdTable(candId, imch, gbc, (gbc - globalBcMid) * o2::constants::lhc::LHCBunchSpacingNS, fwdTracks, mcFwdTrackLabels))
+          continue;
+        numContrib++;
+      }
+      eventCandidates(globalBcMid, runNumber, 0., 0., 0., 0, numContrib, 0, 0);
+      std::vector<float> amplitudesV0A{};
+      std::vector<int8_t> relBCsV0A{};
+      std::vector<float> amplitudesT0A{};
+      std::vector<int8_t> relBCsT0A{};
+      if (nFV0s > 0) {
+        getFV0Amplitudes(globalBcMid, fv0s, fBCWindowFITAmps, mapGlobalBcWithV0A, amplitudesV0A, relBCsV0A);
+      }
+      eventCandidatesSelsFwd(0., 0., amplitudesT0A, relBCsT0A, amplitudesV0A, relBCsV0A);
+      if (nZdcs > 0) {
+        auto itZDC = mapGlobalBcWithZdc.find(globalBcMid);
+        if (itZDC != mapGlobalBcWithZdc.end()) {
+          const auto& zdc = zdcs.iteratorAt(itZDC->second);
+          float timeZNA = zdc.timeZNA();
+          float timeZNC = zdc.timeZNC();
+          float eComZNA = zdc.energyCommonZNA();
+          float eComZNC = zdc.energyCommonZNC();
+          udZdcsReduced(candId, timeZNA, timeZNC, eComZNA, eComZNC);
+        }
+      }
+      candId++;
+    }
+
+    vGlobalBCs.clear();
+    vColIndexBCs.clear();
+    mapGlobalBcWithV0A.clear();
+    mapGlobalBcWithZdc.clear();
+    vAmbFwdTrackIndex.clear();
+    vAmbFwdTrackIndexBCs.clear();
+    mapGlobalBcsWithMCHMIDTrackIds.clear();
+    mapGlobalBcsWithMCHTrackIds.clear();
+  }
+
+  void processFwd(ForwardTracks const& fwdTracks,
+                  o2::aod::AmbiguousFwdTracks const& ambFwdTracks,
+                  o2::aod::BCs const& bcs,
+                  o2::aod::Collisions const& collisions,
+                  o2::aod::FV0As const& fv0s,
+                  o2::aod::Zdcs const& zdcs)
+  {
+    fDoMC = false;
+    createCandidates(fwdTracks, ambFwdTracks, bcs, collisions, fv0s, zdcs, (o2::aod::McFwdTrackLabels*)nullptr);
+  }
+
+  void processFwdMC(ForwardTracks const& fwdTracks,
+                    o2::aod::AmbiguousFwdTracks const& ambFwdTracks,
+                    o2::aod::BCs const& bcs,
+                    o2::aod::Collisions const& collisions,
+                    o2::aod::FV0As const& fv0s,
+                    o2::aod::Zdcs const& zdcs,
+                    o2::aod::McCollisions const& mcCollisions,
+                    o2::aod::McParticles const& mcParticles,
+                    o2::aod::McFwdTrackLabels const& mcFwdTrackLabels)
+  {
+    fDoMC = true;
+    skimMCInfo(mcCollisions, mcParticles);
+    createCandidates(fwdTracks, ambFwdTracks, bcs, collisions, fv0s, zdcs, &mcFwdTrackLabels);
+    fNewPartIDs.clear();
+  }
+
+  PROCESS_SWITCH(UpcCandProducerMuon, processFwd, "Produce candidates in forward region", true);
+  PROCESS_SWITCH(UpcCandProducerMuon, processFwdMC, "Produce candidates in forward region with MC information", false);
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{adaptAnalysisTask<UpcCandProducerMuon>(cfgc)};
+}
diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index 52fa510b176..d63892e9632 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -65,13 +65,12 @@ struct FwdTrackPropagation {
                            muon.cPhiPhi(), muon.cTglX(), muon.cTglY(), muon.cTglPhi(), muon.cTglTgl(),
                            muon.c1PtX(), muon.c1PtY(), muon.c1PtPhi(), muon.c1PtTgl(), muon.c1Pt21Pt2()};
     SMatrix55 tcovs(v1.begin(), v1.end());
-    o2::track::TrackParCovFwd fwdtrack{muon.z(), tpars, tcovs, chi2};
     o2::dataformats::GlobalFwdTrack propmuon;
 
     if (static_cast<int>(muon.trackType()) > 2) {
       o2::dataformats::GlobalFwdTrack track;
       track.setParameters(tpars);
-      track.setZ(fwdtrack.getZ());
+      track.setZ(muon.z());
       track.setCovariances(tcovs);
       auto mchTrack = fMatching.FwdtoMCH(track);
       o2::mch::TrackExtrap::extrapToVertex(mchTrack, vtx[0], vtx[1], vtx[2], vtxCov[0], vtxCov[1]);
@@ -81,7 +80,8 @@ struct FwdTrackPropagation {
       propmuon.setCovariances(proptrack.getCovariances());
     } else if (static_cast<int>(muon.trackType()) < 2) {
       double centerMFT[3] = {0, 0, -61.4};
-      o2::field::MagneticField* field = static_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());
+      o2::track::TrackParCovFwd fwdtrack{muon.z(), tpars, tcovs, chi2};
+      auto* field = dynamic_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());
       auto Bz = field->getBz(centerMFT); // Get field at centre of MFT
       auto geoMan = o2::base::GeometryManager::meanMaterialBudget(muon.x(), muon.y(), muon.z(), vtx[0], vtx[1], vtx[2]);
       auto x2x0 = static_cast<float>(geoMan.meanX2X0);
@@ -116,7 +116,7 @@ struct FwdTrackPropagation {
       if (t.z() < -90.f) {
         std::array<float, 3> vtx = {0.f, 0.f, 0.f};
         std::array<float, 2> vtxCov = {0.f, 0.f};
-        if (t.has_collision()) {
+        if (t.has_collision() && static_cast<int>(t.trackType()) < 2) { // propagate only global muon tracks to collision vtx
           auto col = cols.iteratorAt(t.collisionId());
           vtx[0] = col.posX();
           vtx[1] = col.posY();
@@ -129,7 +129,7 @@ struct FwdTrackPropagation {
                       pft.getX(), pft.getY(), pft.getZ(), pft.getPhi(), pft.getTgl(), pft.getInvQPt(),
                       pft.getEta(), pft.getPt(), pft.getP(),
                       t.nClusters(), t.pDca(), t.rAtAbsorberEnd(),
-                      pft.getTrackChi2(), t.chi2MatchMCHMID(), t.chi2MatchMCHMFT(),
+                      t.chi2(), t.chi2MatchMCHMID(), t.chi2MatchMCHMFT(),
                       t.matchScoreMCHMFT(), t.matchMFTTrackId(), t.matchMCHTrackId(),
                       t.mchBitMap(), t.midBoards(), t.midBitMap(),
                       t.trackTime(), t.trackTimeRes());

From 8b5cb3007e87624fd4f33dfa6b90eeffc29143ba Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 15:53:56 +0300
Subject: [PATCH 02/10] Fix formatting

---
 PWGUD/Core/UPCHelpers.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/PWGUD/Core/UPCHelpers.h b/PWGUD/Core/UPCHelpers.h
index 16a91bb5eb0..1afc2e4fdc2 100644
--- a/PWGUD/Core/UPCHelpers.h
+++ b/PWGUD/Core/UPCHelpers.h
@@ -99,11 +99,11 @@ struct FITInfo {
 template <typename T, typename TSelectorsArray>
 void applyFwdCuts(UPCCutparHolder& upcCuts, const T& track, TSelectorsArray& fwdSelectors)
 {
-  fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                     // check pt
-  fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                // check pseudorapidity
-  fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh(); // check muon R
-  fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < 26.5 ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond();        // check pDCA
-  fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                           // check chi2
+  fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                        // check pt
+  fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                   // check pseudorapidity
+  fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh();    // check muon R
+  fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < 26.5 ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond(); // check pDCA
+  fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                              // check chi2
 }
 
 template <typename T, typename TSelectorsArray>

From c9e2123ca6e16ac600a88b5108fc8ecbe690107c Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 16:16:55 +0300
Subject: [PATCH 03/10] Fix linter warnings

---
 .../UPCCandidateProducerMuon.cxx              | 73 ++++++++++---------
 1 file changed, 37 insertions(+), 36 deletions(-)

diff --git a/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx b/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
index c62aaef3f9c..8bb54499fcd 100644
--- a/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
+++ b/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
@@ -13,29 +13,24 @@
 #include "PWGUD/Core/UPCHelpers.h"
 #include "PWGUD/DataModel/UDTables.h"
 
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/runDataProcessing.h"
+
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonConstants/LHCConstants.h"
-#include "DataFormatsFIT/Triggers.h"
 #include "DataFormatsParameters/GRPMagField.h"
 #include "DetectorsBase/Propagator.h"
 #include "Field/MagneticField.h"
-#include "Framework/AnalysisDataModel.h"
-#include "Framework/AnalysisTask.h"
-#include "Framework/runDataProcessing.h"
 #include "GlobalTracking/MatchGlobalFwd.h"
 #include "MCHTracking/TrackExtrap.h"
-#include "MCHTracking/TrackParam.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
 
 #include "Math/SMatrix.h"
 #include "TGeoGlobalMagField.h"
 
 #include <algorithm>
-#include <limits>
 #include <map>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
 #include <vector>
 
 using namespace o2::framework;
@@ -57,13 +52,13 @@ struct UpcCandProducerMuon {
   Produces<o2::aod::UDCollisionsSelsFwd> eventCandidatesSelsFwd;
   Produces<o2::aod::UDZdcsReduced> udZdcsReduced;
 
-  Configurable<int> fSignalGenID{"signalGenID", 1, "Signal generator ID"};
+  Configurable<int> fSignalGenID{"fSignalGenID", 1, "Signal generator ID"};
 
-  UPCCutparHolder upcCuts = UPCCutparHolder();
-  MutableConfigurable<UPCCutparHolder> inputCuts{"UPCCuts", {}, "UPC event cuts"};
-  Configurable<uint64_t> fBCWindowFITAmps{"bcWindowFITAmps", 20, "BC range for T0A/V0A amplitudes array [-range, +(range-1)]"};
-  Configurable<int> fBcWindowMCH{"bcWindowMCH", 20, "Time window for MCH-MID to MCH-only matching for Muon candidates"};
-  Configurable<float> fMaxFV0Amp{"maxFV0Amp", 100.f, "Max FV0 amplitude in the same BC"};
+  UPCCutparHolder fUpcCuts = UPCCutparHolder();
+  MutableConfigurable<UPCCutparHolder> fUpcCutsConf{"fUpcCutsConf", {}, "UPC event cuts"};
+  Configurable<uint64_t> fBcWindowFITAmps{"fBcWindowFITAmps", 20, "BC range for T0A/V0A amplitudes array [-range, +(range-1)]"};
+  Configurable<int> fBcWindowMCH{"fBcWindowMCH", 20, "Time window for MCH-MID to MCH-only matching for Muon candidates"};
+  Configurable<float> fMaxFV0Amp{"fMaxFV0Amp", 100.f, "Max FV0 amplitude in the same BC"};
 
   using ForwardTracks = o2::soa::Join<o2::aod::FwdTracks, o2::aod::FwdTracksCov>;
 
@@ -76,8 +71,8 @@ struct UpcCandProducerMuon {
 
   void init(InitContext&)
   {
-    upcCuts = (UPCCutparHolder)inputCuts;
-    if (upcCuts.getUseFwdCuts()) {
+    fUpcCuts = (UPCCutparHolder)fUpcCutsConf;
+    if (fUpcCuts.getUseFwdCuts()) {
       fCCDB->setURL("http://alice-ccdb.cern.ch");
       fCCDB->setCaching(true);
       fCCDB->setLocalObjectValidityChecking();
@@ -95,17 +90,18 @@ struct UpcCandProducerMuon {
 
   bool cut(const o2::dataformats::GlobalFwdTrack& pft, const ForwardTracks::iterator& fwdTrack)
   {
+    constexpr double absorberMid = 26.5;
     histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelAll, 1);
     auto pt = pft.getPt();
     auto eta = pft.getEta();
     auto pdca = fwdTrack.pDca();
     auto rabs = fwdTrack.rAtAbsorberEnd();
     auto chi2 = fwdTrack.chi2();
-    bool passPt = pt > upcCuts.getFwdPtLow() && pt < upcCuts.getFwdPtHigh();
-    bool passEta = eta > upcCuts.getFwdEtaLow() && eta < upcCuts.getFwdEtaHigh();
-    bool passRabs = rabs > upcCuts.getMuonRAtAbsorberEndLow() && rabs < upcCuts.getMuonRAtAbsorberEndHigh();
-    bool passPDca = rabs < 26.5 ? pdca < upcCuts.getMuonPDcaHighFirst() : pdca < upcCuts.getMuonPDcaHighSecond();
-    bool passChi2 = chi2 > upcCuts.getFwdChi2Low() && chi2 < upcCuts.getFwdChi2High();
+    bool passPt = pt > fUpcCuts.getFwdPtLow() && pt < fUpcCuts.getFwdPtHigh();
+    bool passEta = eta > fUpcCuts.getFwdEtaLow() && eta < fUpcCuts.getFwdEtaHigh();
+    bool passRabs = rabs > fUpcCuts.getMuonRAtAbsorberEndLow() && rabs < fUpcCuts.getMuonRAtAbsorberEndHigh();
+    bool passPDca = rabs < absorberMid ? pdca < fUpcCuts.getMuonPDcaHighFirst() : pdca < fUpcCuts.getMuonPDcaHighSecond();
+    bool passChi2 = chi2 > fUpcCuts.getFwdChi2Low() && chi2 < fUpcCuts.getFwdChi2High();
     if (passPt)
       histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelPt, 1);
     if (passEta)
@@ -157,7 +153,7 @@ struct UpcCandProducerMuon {
       // collecting new mother IDs
       if (mcPart.has_mothers()) {
         const auto& motherIDs = mcPart.mothersIds();
-        for (auto motherID : motherIDs) {
+        for (const auto& motherID : motherIDs) {
           if (motherID >= nMCParticles) {
             continue;
           }
@@ -273,7 +269,7 @@ struct UpcCandProducerMuon {
   {
     auto fillMchIds = [&outMchTrkIds](std::map<uint64_t, std::vector<int64_t>>::iterator& inIt, uint64_t gbc) {
       std::vector<int64_t>& ids = inIt->second;
-      for (auto id : ids)
+      for (const auto& id : ids)
         outMchTrkIds[id] = gbc;
     };
     scrollBackForth(inGbc, maxDbc, mchTracksPerBC, fillMchIds);
@@ -327,7 +323,7 @@ struct UpcCandProducerMuon {
     const auto& track = fwdTracks.iteratorAt(trackId);
     float px, py, pz;
     int sign;
-    if (upcCuts.getUseFwdCuts()) {
+    if (fUpcCuts.getUseFwdCuts()) {
       auto pft = propagateToZero(track);
       bool pass = cut(pft, track);
       if (!pass)
@@ -363,8 +359,11 @@ struct UpcCandProducerMuon {
                         o2::aod::Zdcs const& zdcs,
                         const o2::aod::McFwdTrackLabels* mcFwdTrackLabels)
   {
+    using o2::aod::fwdtrack::ForwardTrackTypeEnum::MCHStandaloneTrack;
+    using o2::aod::fwdtrack::ForwardTrackTypeEnum::MuonStandaloneTrack;
+
     int32_t runNumber = bcs.iteratorAt(0).runNumber();
-    if (upcCuts.getUseFwdCuts()) {
+    if (fUpcCuts.getUseFwdCuts()) {
       if (runNumber != fRun) {
         fRun = runNumber;
         std::map<std::string, std::string> metadata;
@@ -391,8 +390,9 @@ struct UpcCandProducerMuon {
     }
 
     std::map<uint64_t, int64_t> mapGlobalBcWithV0A{};
+    constexpr float fv0ValidTime = 15.f;
     for (const auto& fv0 : fv0s) {
-      if (std::abs(fv0.time()) > 15.f)
+      if (std::abs(fv0.time()) > fv0ValidTime)
         continue;
       uint64_t globalBC = vGlobalBCs[fv0.bcId()];
       mapGlobalBcWithV0A[globalBC] = fv0.globalIndex();
@@ -400,8 +400,9 @@ struct UpcCandProducerMuon {
     auto nFV0s = mapGlobalBcWithV0A.size();
 
     std::map<uint64_t, int64_t> mapGlobalBcWithZdc{};
+    constexpr float zdcValidTime = 2.f;
     for (const auto& zdc : zdcs) {
-      if (std::abs(zdc.timeZNA()) > 2.f && std::abs(zdc.timeZNC()) > 2.f)
+      if (std::abs(zdc.timeZNA()) > zdcValidTime && std::abs(zdc.timeZNC()) > zdcValidTime)
         continue;
       uint64_t globalBC = vGlobalBCs[zdc.bcId()];
       mapGlobalBcWithZdc[globalBC] = zdc.globalIndex();
@@ -420,26 +421,26 @@ struct UpcCandProducerMuon {
     std::map<uint64_t, std::vector<int64_t>> mapGlobalBcsWithMCHMIDTrackIds;
     std::map<uint64_t, std::vector<int64_t>> mapGlobalBcsWithMCHTrackIds;
     for (const auto& fwdTrack : fwdTracks) {
-      if (fwdTrack.trackType() != 3 && fwdTrack.trackType() != 4)
+      if (fwdTrack.trackType() != MCHStandaloneTrack && fwdTrack.trackType() != MuonStandaloneTrack)
         continue;
       auto trackId = fwdTrack.globalIndex();
       int64_t indexBC = vAmbFwdTrackIndex[trackId] < 0 ? vColIndexBCs[fwdTrack.collisionId()] : vAmbFwdTrackIndexBCs[vAmbFwdTrackIndex[trackId]];
       auto globalBC = vGlobalBCs[indexBC] + TMath::FloorNint(fwdTrack.trackTime() / o2::constants::lhc::LHCBunchSpacingNS + 1.);
-      if (fwdTrack.trackType() == 3)
+      if (fwdTrack.trackType() == MuonStandaloneTrack)
         mapGlobalBcsWithMCHMIDTrackIds[globalBC].push_back(trackId);
-      if (fwdTrack.trackType() == 4)
+      if (fwdTrack.trackType() == MCHStandaloneTrack)
         mapGlobalBcsWithMCHTrackIds[globalBC].push_back(trackId);
     }
 
     int32_t candId = 0;
-    for (auto& gbc_muids : mapGlobalBcsWithMCHMIDTrackIds) {
+    for (const auto& gbc_muids : mapGlobalBcsWithMCHMIDTrackIds) {
       uint64_t globalBcMid = gbc_muids.first;
       auto itFv0Id = mapGlobalBcWithV0A.find(globalBcMid);
       if (itFv0Id != mapGlobalBcWithV0A.end()) {
         auto fv0Id = itFv0Id->second;
         const auto& fv0 = fv0s.iteratorAt(fv0Id);
         float fv0Amp = 0.f;
-        for (auto amp : fv0.amplitude())
+        for (const auto& amp : fv0.amplitude())
           fv0Amp += amp;
         if (fv0Amp > fMaxFV0Amp)
           continue;
@@ -447,7 +448,7 @@ struct UpcCandProducerMuon {
       uint16_t numContrib = 0;
       auto& vMuonIds = gbc_muids.second;
       // writing MCH-MID tracks
-      for (auto imuon : vMuonIds) {
+      for (const auto& imuon : vMuonIds) {
         if (!addToFwdTable(candId, imuon, globalBcMid, 0., fwdTracks, mcFwdTrackLabels))
           continue;
         numContrib++;
@@ -457,7 +458,7 @@ struct UpcCandProducerMuon {
       std::map<int64_t, uint64_t> mapMchIdBc{};
       getMchTrackIds(globalBcMid, mapGlobalBcsWithMCHTrackIds, fBcWindowMCH, mapMchIdBc);
       // writing MCH-only tracks
-      for (auto& [imch, gbc] : mapMchIdBc) {
+      for (const auto& [imch, gbc] : mapMchIdBc) {
         if (!addToFwdTable(candId, imch, gbc, (gbc - globalBcMid) * o2::constants::lhc::LHCBunchSpacingNS, fwdTracks, mcFwdTrackLabels))
           continue;
         numContrib++;
@@ -468,7 +469,7 @@ struct UpcCandProducerMuon {
       std::vector<float> amplitudesT0A{};
       std::vector<int8_t> relBCsT0A{};
       if (nFV0s > 0) {
-        getFV0Amplitudes(globalBcMid, fv0s, fBCWindowFITAmps, mapGlobalBcWithV0A, amplitudesV0A, relBCsV0A);
+        getFV0Amplitudes(globalBcMid, fv0s, fBcWindowFITAmps, mapGlobalBcWithV0A, amplitudesV0A, relBCsV0A);
       }
       eventCandidatesSelsFwd(0., 0., amplitudesT0A, relBCsT0A, amplitudesV0A, relBCsV0A);
       if (nZdcs > 0) {

From 8ca985e9de4a584364a9c5c4fd12324d5a3be4b4 Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 16:33:48 +0300
Subject: [PATCH 04/10] Fix linter warnings

---
 PWGUD/TableProducer/CMakeLists.txt            |  2 +-
 PWGUD/TableProducer/fwdTrackPropagation.cxx   | 25 +++++++++++--------
 ...oducerMuon.cxx => upccandProducerMuon.cxx} | 11 ++++----
 3 files changed, 20 insertions(+), 18 deletions(-)
 rename PWGUD/TableProducer/{UPCCandidateProducerMuon.cxx => upccandProducerMuon.cxx} (99%)

diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index a38b861ecf7..e0fa48e330a 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -62,6 +62,6 @@ o2physics_add_dpl_workflow(tau-three-prong-event-table-producer
                            COMPONENT_NAME Analysis)
 
 o2physics_add_dpl_workflow(upccand-producer-muon
-                           SOURCES UPCCandidateProducerMuon.cxx
+                           SOURCES upccandProducerMuon.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::UPCCutparHolder O2::GlobalTracking
                            COMPONENT_NAME Analysis)
diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index d63892e9632..b804e7a8911 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -12,25 +12,27 @@
 /// \author Diana Krupova, diana.krupova@cern.ch
 /// \since 04.06.2024
 
-#include "Framework/AnalysisDataModel.h"
-#include "Framework/AnalysisTask.h"
-#include "Framework/runDataProcessing.h"
+#include "PWGUD/DataModel/UDTables.h"
 
 #include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsParameters/GRPMagField.h"
-#include "TGeoGlobalMagField.h"
-#include "Field/MagneticField.h"
 #include "DetectorsBase/Propagator.h"
+#include "Field/MagneticField.h"
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/DataTypes.h"
+#include "Framework/runDataProcessing.h"
 #include "GlobalTracking/MatchGlobalFwd.h"
 #include "MCHTracking/TrackExtrap.h"
 #include "MCHTracking/TrackParam.h"
-#include "Math/SMatrix.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
 
-#include "PWGUD/DataModel/UDTables.h"
+#include "Math/SMatrix.h"
+#include "TGeoGlobalMagField.h"
 
 using namespace o2::framework;
 using namespace o2::framework::expressions;
+using o2::aod::fwdtrack::ForwardTrackTypeEnum;
 
 struct FwdTrackPropagation {
   using ForwardTracks = o2::soa::Join<o2::aod::FwdTracks, o2::aod::FwdTracksCov>;
@@ -67,7 +69,7 @@ struct FwdTrackPropagation {
     SMatrix55 tcovs(v1.begin(), v1.end());
     o2::dataformats::GlobalFwdTrack propmuon;
 
-    if (static_cast<int>(muon.trackType()) > 2) {
+    if (muon.trackType() > ForwardTrackTypeEnum::GlobalForwardTrack) { // tracks without MFT
       o2::dataformats::GlobalFwdTrack track;
       track.setParameters(tpars);
       track.setZ(muon.z());
@@ -78,7 +80,7 @@ struct FwdTrackPropagation {
       propmuon.setParameters(proptrack.getParameters());
       propmuon.setZ(proptrack.getZ());
       propmuon.setCovariances(proptrack.getCovariances());
-    } else if (static_cast<int>(muon.trackType()) < 2) {
+    } else if (muon.trackType() <= ForwardTrackTypeEnum::GlobalForwardTrack) { // tracks with MFT
       double centerMFT[3] = {0, 0, -61.4};
       o2::track::TrackParCovFwd fwdtrack{muon.z(), tpars, tcovs, chi2};
       auto* field = dynamic_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());
@@ -112,11 +114,12 @@ struct FwdTrackPropagation {
     propFwdTracks.reserve(fwdTracks.size());
     propFwdTracksCov.reserve(fwdTracks.size());
 
+    constexpr float zAbsorberFront = -90.f;
     for (const auto& t : fwdTracks) {
-      if (t.z() < -90.f) {
+      if (t.z() < zAbsorberFront) {
         std::array<float, 3> vtx = {0.f, 0.f, 0.f};
         std::array<float, 2> vtxCov = {0.f, 0.f};
-        if (t.has_collision() && static_cast<int>(t.trackType()) < 2) { // propagate only global muon tracks to collision vtx
+        if (t.has_collision() && t.trackType() < ForwardTrackTypeEnum::GlobalForwardTrack) { // propagate only global muon tracks to collision vtx
           auto col = cols.iteratorAt(t.collisionId());
           vtx[0] = col.posX();
           vtx[1] = col.posY();
diff --git a/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx b/PWGUD/TableProducer/upccandProducerMuon.cxx
similarity index 99%
rename from PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
rename to PWGUD/TableProducer/upccandProducerMuon.cxx
index 8bb54499fcd..1bf8a67d360 100644
--- a/PWGUD/TableProducer/UPCCandidateProducerMuon.cxx
+++ b/PWGUD/TableProducer/upccandProducerMuon.cxx
@@ -13,15 +13,14 @@
 #include "PWGUD/Core/UPCHelpers.h"
 #include "PWGUD/DataModel/UDTables.h"
 
-#include "Framework/AnalysisDataModel.h"
-#include "Framework/AnalysisTask.h"
-#include "Framework/runDataProcessing.h"
-
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonConstants/LHCConstants.h"
 #include "DataFormatsParameters/GRPMagField.h"
 #include "DetectorsBase/Propagator.h"
 #include "Field/MagneticField.h"
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/runDataProcessing.h"
 #include "GlobalTracking/MatchGlobalFwd.h"
 #include "MCHTracking/TrackExtrap.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
@@ -426,9 +425,9 @@ struct UpcCandProducerMuon {
       auto trackId = fwdTrack.globalIndex();
       int64_t indexBC = vAmbFwdTrackIndex[trackId] < 0 ? vColIndexBCs[fwdTrack.collisionId()] : vAmbFwdTrackIndexBCs[vAmbFwdTrackIndex[trackId]];
       auto globalBC = vGlobalBCs[indexBC] + TMath::FloorNint(fwdTrack.trackTime() / o2::constants::lhc::LHCBunchSpacingNS + 1.);
-      if (fwdTrack.trackType() == MuonStandaloneTrack)
+      if (fwdTrack.trackType() == MuonStandaloneTrack) // MCH-MID
         mapGlobalBcsWithMCHMIDTrackIds[globalBC].push_back(trackId);
-      if (fwdTrack.trackType() == MCHStandaloneTrack)
+      if (fwdTrack.trackType() == MCHStandaloneTrack) // MCH-only
         mapGlobalBcsWithMCHTrackIds[globalBC].push_back(trackId);
     }
 

From b2ea09fd321c47f296494b48af2d080f01fc7033 Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 16:44:03 +0300
Subject: [PATCH 05/10] Fix linter warnings

---
 PWGUD/TableProducer/CMakeLists.txt              |  4 ++--
 ...ProducerMuon.cxx => UpcCandProducerMuon.cxx} | 17 +++++++++++------
 PWGUD/TableProducer/fwdTrackPropagation.cxx     |  4 ++--
 3 files changed, 15 insertions(+), 10 deletions(-)
 rename PWGUD/TableProducer/{upccandProducerMuon.cxx => UpcCandProducerMuon.cxx} (97%)

diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index e0fa48e330a..5b8a249aadb 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -61,7 +61,7 @@ o2physics_add_dpl_workflow(tau-three-prong-event-table-producer
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
                            COMPONENT_NAME Analysis)
 
-o2physics_add_dpl_workflow(upccand-producer-muon
-                           SOURCES upccandProducerMuon.cxx
+o2physics_add_dpl_workflow(upc-cand-producer-muon
+                           SOURCES UpcCandProducerMuon.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::UPCCutparHolder O2::GlobalTracking
                            COMPONENT_NAME Analysis)
diff --git a/PWGUD/TableProducer/upccandProducerMuon.cxx b/PWGUD/TableProducer/UpcCandProducerMuon.cxx
similarity index 97%
rename from PWGUD/TableProducer/upccandProducerMuon.cxx
rename to PWGUD/TableProducer/UpcCandProducerMuon.cxx
index 1bf8a67d360..5ab764e9d30 100644
--- a/PWGUD/TableProducer/upccandProducerMuon.cxx
+++ b/PWGUD/TableProducer/UpcCandProducerMuon.cxx
@@ -9,6 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file UpcCandProducerMuon.cxx
+/// \brief UPC candidate producer for forward muons without MFT
+/// \author Nazar Burmasov, nazar.burmasov@cern.ch
+/// \since 19.12.2025
+
 #include "PWGUD/Core/UPCCutparHolder.h"
 #include "PWGUD/Core/UPCHelpers.h"
 #include "PWGUD/DataModel/UDTables.h"
@@ -89,7 +94,7 @@ struct UpcCandProducerMuon {
 
   bool cut(const o2::dataformats::GlobalFwdTrack& pft, const ForwardTracks::iterator& fwdTrack)
   {
-    constexpr double absorberMid = 26.5;
+    constexpr double AbsorberMid = 26.5;
     histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelAll, 1);
     auto pt = pft.getPt();
     auto eta = pft.getEta();
@@ -99,7 +104,7 @@ struct UpcCandProducerMuon {
     bool passPt = pt > fUpcCuts.getFwdPtLow() && pt < fUpcCuts.getFwdPtHigh();
     bool passEta = eta > fUpcCuts.getFwdEtaLow() && eta < fUpcCuts.getFwdEtaHigh();
     bool passRabs = rabs > fUpcCuts.getMuonRAtAbsorberEndLow() && rabs < fUpcCuts.getMuonRAtAbsorberEndHigh();
-    bool passPDca = rabs < absorberMid ? pdca < fUpcCuts.getMuonPDcaHighFirst() : pdca < fUpcCuts.getMuonPDcaHighSecond();
+    bool passPDca = rabs < AbsorberMid ? pdca < fUpcCuts.getMuonPDcaHighFirst() : pdca < fUpcCuts.getMuonPDcaHighSecond();
     bool passChi2 = chi2 > fUpcCuts.getFwdChi2Low() && chi2 < fUpcCuts.getFwdChi2High();
     if (passPt)
       histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelPt, 1);
@@ -389,9 +394,9 @@ struct UpcCandProducerMuon {
     }
 
     std::map<uint64_t, int64_t> mapGlobalBcWithV0A{};
-    constexpr float fv0ValidTime = 15.f;
+    constexpr float FV0ValidTime = 15.f;
     for (const auto& fv0 : fv0s) {
-      if (std::abs(fv0.time()) > fv0ValidTime)
+      if (std::abs(fv0.time()) > FV0ValidTime)
         continue;
       uint64_t globalBC = vGlobalBCs[fv0.bcId()];
       mapGlobalBcWithV0A[globalBC] = fv0.globalIndex();
@@ -399,9 +404,9 @@ struct UpcCandProducerMuon {
     auto nFV0s = mapGlobalBcWithV0A.size();
 
     std::map<uint64_t, int64_t> mapGlobalBcWithZdc{};
-    constexpr float zdcValidTime = 2.f;
+    constexpr float ZDCValidTime = 2.f;
     for (const auto& zdc : zdcs) {
-      if (std::abs(zdc.timeZNA()) > zdcValidTime && std::abs(zdc.timeZNC()) > zdcValidTime)
+      if (std::abs(zdc.timeZNA()) > ZDCValidTime && std::abs(zdc.timeZNC()) > ZDCValidTime)
         continue;
       uint64_t globalBC = vGlobalBCs[zdc.bcId()];
       mapGlobalBcWithZdc[globalBC] = zdc.globalIndex();
diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index b804e7a8911..afba62d862b 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -114,9 +114,9 @@ struct FwdTrackPropagation {
     propFwdTracks.reserve(fwdTracks.size());
     propFwdTracksCov.reserve(fwdTracks.size());
 
-    constexpr float zAbsorberFront = -90.f;
+    constexpr float ZAbsorberFront = -90.f;
     for (const auto& t : fwdTracks) {
-      if (t.z() < zAbsorberFront) {
+      if (t.z() < ZAbsorberFront) {
         std::array<float, 3> vtx = {0.f, 0.f, 0.f};
         std::array<float, 2> vtxCov = {0.f, 0.f};
         if (t.has_collision() && t.trackType() < ForwardTrackTypeEnum::GlobalForwardTrack) { // propagate only global muon tracks to collision vtx

From f1df02b3447c73f3e8d8c9e29d98656eb90823e0 Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 16:48:36 +0300
Subject: [PATCH 06/10] Fix linter warnings

---
 PWGUD/TableProducer/CMakeLists.txt                             | 2 +-
 PWGUD/TableProducer/fwdTrackPropagation.cxx                    | 3 +++
 .../{UpcCandProducerMuon.cxx => upcCandProducerMuon.cxx}       | 0
 3 files changed, 4 insertions(+), 1 deletion(-)
 rename PWGUD/TableProducer/{UpcCandProducerMuon.cxx => upcCandProducerMuon.cxx} (100%)

diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index 5b8a249aadb..d013cdd260a 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -62,6 +62,6 @@ o2physics_add_dpl_workflow(tau-three-prong-event-table-producer
                            COMPONENT_NAME Analysis)
 
 o2physics_add_dpl_workflow(upc-cand-producer-muon
-                           SOURCES UpcCandProducerMuon.cxx
+                           SOURCES upcCandProducerMuon.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::UPCCutparHolder O2::GlobalTracking
                            COMPONENT_NAME Analysis)
diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index afba62d862b..3864f699340 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -8,6 +8,9 @@
 // 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 fwdTrackPropagation.cxx
+/// \brief Forward track propagation task for UD tasks
 /// \author Nazar Burmasov, nazar.burmasov@cern.ch
 /// \author Diana Krupova, diana.krupova@cern.ch
 /// \since 04.06.2024
diff --git a/PWGUD/TableProducer/UpcCandProducerMuon.cxx b/PWGUD/TableProducer/upcCandProducerMuon.cxx
similarity index 100%
rename from PWGUD/TableProducer/UpcCandProducerMuon.cxx
rename to PWGUD/TableProducer/upcCandProducerMuon.cxx

From 4589de3d4b02e59b9c4eae5c0a54e1495ac82d4e Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 17:03:32 +0300
Subject: [PATCH 07/10] Fix linter warnings

---
 PWGUD/Core/UPCHelpers.h                                   | 8 ++++----
 PWGUD/TableProducer/CMakeLists.txt                        | 2 +-
 .../{fwdTrackPropagation.cxx => fwdtrackPropagation.cxx}  | 5 ++++-
 PWGUD/TableProducer/upcCandProducerMuon.cxx               | 5 ++---
 4 files changed, 11 insertions(+), 9 deletions(-)
 rename PWGUD/TableProducer/{fwdTrackPropagation.cxx => fwdtrackPropagation.cxx} (99%)

diff --git a/PWGUD/Core/UPCHelpers.h b/PWGUD/Core/UPCHelpers.h
index 1afc2e4fdc2..7e83d47fc23 100644
--- a/PWGUD/Core/UPCHelpers.h
+++ b/PWGUD/Core/UPCHelpers.h
@@ -22,8 +22,6 @@
 #include "CommonConstants/LHCConstants.h"
 #include "Framework/AnalysisDataModel.h"
 
-#include "TLorentzVector.h"
-
 using BCsWithBcSels = o2::soa::Join<o2::aod::BCs, o2::aod::BcSels>;
 
 using ForwardTracks = o2::soa::Join<o2::aod::FwdTracks, o2::aod::FwdTracksCov>;
@@ -96,13 +94,15 @@ struct FITInfo {
   int32_t distClosestBcT0A = 999;
 };
 
+constexpr double AbsorberMid = 26.5;
+
 template <typename T, typename TSelectorsArray>
 void applyFwdCuts(UPCCutparHolder& upcCuts, const T& track, TSelectorsArray& fwdSelectors)
 {
   fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                        // check pt
   fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                   // check pseudorapidity
   fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh();    // check muon R
-  fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < 26.5 ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond(); // check pDCA
+  fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < AbsorberMid ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond(); // check pDCA
   fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                              // check chi2
 }
 
@@ -131,7 +131,7 @@ void applyBarrelCuts(UPCCutparHolder& upcCuts, const T& track, TSelectorsArray&
 
   if (upcCuts.getCheckMaxDcaXY()) {
     float dca = track.dcaXY();
-    float maxDCA = 0.0105f + 0.0350f / pow(track.pt(), 1.1f);
+    float maxDCA = 0.0105f + 0.0350f / std::pow(track.pt(), 1.1f);
     barrelSelectors[kBarrelSelDCAXY] = dca < maxDCA;
   } else {
     barrelSelectors[kBarrelSelDCAXY] = true;
diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index d013cdd260a..7473496071b 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -42,7 +42,7 @@ o2physics_add_dpl_workflow(two-tracks-event-table-producer
                            COMPONENT_NAME Analysis)
 
 o2physics_add_dpl_workflow(fwdtrack-propagation
-                           SOURCES fwdTrackPropagation.cxx
+                           SOURCES fwdtrackPropagation.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::GlobalTracking
                            COMPONENT_NAME Analysis)
 
diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdtrackPropagation.cxx
similarity index 99%
rename from PWGUD/TableProducer/fwdTrackPropagation.cxx
rename to PWGUD/TableProducer/fwdtrackPropagation.cxx
index 3864f699340..61a34e4b8bd 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdtrackPropagation.cxx
@@ -27,12 +27,15 @@
 #include "Framework/runDataProcessing.h"
 #include "GlobalTracking/MatchGlobalFwd.h"
 #include "MCHTracking/TrackExtrap.h"
-#include "MCHTracking/TrackParam.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
 
 #include "Math/SMatrix.h"
 #include "TGeoGlobalMagField.h"
 
+#include <map>
+#include <string>
+#include <vector>
+
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using o2::aod::fwdtrack::ForwardTrackTypeEnum;
diff --git a/PWGUD/TableProducer/upcCandProducerMuon.cxx b/PWGUD/TableProducer/upcCandProducerMuon.cxx
index 5ab764e9d30..41857d1d921 100644
--- a/PWGUD/TableProducer/upcCandProducerMuon.cxx
+++ b/PWGUD/TableProducer/upcCandProducerMuon.cxx
@@ -16,7 +16,6 @@
 
 #include "PWGUD/Core/UPCCutparHolder.h"
 #include "PWGUD/Core/UPCHelpers.h"
-#include "PWGUD/DataModel/UDTables.h"
 
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonConstants/LHCConstants.h"
@@ -35,6 +34,7 @@
 
 #include <algorithm>
 #include <map>
+#include <string>
 #include <vector>
 
 using namespace o2::framework;
@@ -94,7 +94,6 @@ struct UpcCandProducerMuon {
 
   bool cut(const o2::dataformats::GlobalFwdTrack& pft, const ForwardTracks::iterator& fwdTrack)
   {
-    constexpr double AbsorberMid = 26.5;
     histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelAll, 1);
     auto pt = pft.getPt();
     auto eta = pft.getEta();
@@ -104,7 +103,7 @@ struct UpcCandProducerMuon {
     bool passPt = pt > fUpcCuts.getFwdPtLow() && pt < fUpcCuts.getFwdPtHigh();
     bool passEta = eta > fUpcCuts.getFwdEtaLow() && eta < fUpcCuts.getFwdEtaHigh();
     bool passRabs = rabs > fUpcCuts.getMuonRAtAbsorberEndLow() && rabs < fUpcCuts.getMuonRAtAbsorberEndHigh();
-    bool passPDca = rabs < AbsorberMid ? pdca < fUpcCuts.getMuonPDcaHighFirst() : pdca < fUpcCuts.getMuonPDcaHighSecond();
+    bool passPDca = rabs < upchelpers::AbsorberMid ? pdca < fUpcCuts.getMuonPDcaHighFirst() : pdca < fUpcCuts.getMuonPDcaHighSecond();
     bool passChi2 = chi2 > fUpcCuts.getFwdChi2Low() && chi2 < fUpcCuts.getFwdChi2High();
     if (passPt)
       histRegistry.fill(HIST("MuonsSelCounter"), upchelpers::kFwdSelPt, 1);

From 19776955c476e93d6e988661ea6ff39531436974 Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 17:08:38 +0300
Subject: [PATCH 08/10] Fix linter warnings

---
 PWGUD/Core/UPCHelpers.h                                   | 8 ++++----
 PWGUD/TableProducer/CMakeLists.txt                        | 4 ++--
 .../{fwdtrackPropagation.cxx => fwdTrackPropagation.cxx}  | 0
 3 files changed, 6 insertions(+), 6 deletions(-)
 rename PWGUD/TableProducer/{fwdtrackPropagation.cxx => fwdTrackPropagation.cxx} (100%)

diff --git a/PWGUD/Core/UPCHelpers.h b/PWGUD/Core/UPCHelpers.h
index 7e83d47fc23..9dfa5fe3776 100644
--- a/PWGUD/Core/UPCHelpers.h
+++ b/PWGUD/Core/UPCHelpers.h
@@ -99,11 +99,11 @@ constexpr double AbsorberMid = 26.5;
 template <typename T, typename TSelectorsArray>
 void applyFwdCuts(UPCCutparHolder& upcCuts, const T& track, TSelectorsArray& fwdSelectors)
 {
-  fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                        // check pt
-  fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                   // check pseudorapidity
-  fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh();    // check muon R
+  fwdSelectors[kFwdSelPt] = track.pt() > upcCuts.getFwdPtLow() && track.pt() < upcCuts.getFwdPtHigh();                                                               // check pt
+  fwdSelectors[kFwdSelEta] = track.eta() > upcCuts.getFwdEtaLow() && track.eta() < upcCuts.getFwdEtaHigh();                                                          // check pseudorapidity
+  fwdSelectors[kFwdSelRabs] = track.rAtAbsorberEnd() > upcCuts.getMuonRAtAbsorberEndLow() && track.rAtAbsorberEnd() < upcCuts.getMuonRAtAbsorberEndHigh();           // check muon R
   fwdSelectors[kFwdSelpDCA] = track.rAtAbsorberEnd() < AbsorberMid ? track.pDca() < upcCuts.getMuonPDcaHighFirst() : track.pDca() < upcCuts.getMuonPDcaHighSecond(); // check pDCA
-  fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                              // check chi2
+  fwdSelectors[kFwdSelChi2] = track.chi2() > upcCuts.getFwdChi2Low() && track.chi2() < upcCuts.getFwdChi2High();                                                     // check chi2
 }
 
 template <typename T, typename TSelectorsArray>
diff --git a/PWGUD/TableProducer/CMakeLists.txt b/PWGUD/TableProducer/CMakeLists.txt
index 7473496071b..c2fa718ddd0 100644
--- a/PWGUD/TableProducer/CMakeLists.txt
+++ b/PWGUD/TableProducer/CMakeLists.txt
@@ -41,8 +41,8 @@ o2physics_add_dpl_workflow(two-tracks-event-table-producer
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
                            COMPONENT_NAME Analysis)
 
-o2physics_add_dpl_workflow(fwdtrack-propagation
-                           SOURCES fwdtrackPropagation.cxx
+o2physics_add_dpl_workflow(fwd-track-propagation
+                           SOURCES fwdTrackPropagation.cxx
                            PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2::GlobalTracking
                            COMPONENT_NAME Analysis)
 
diff --git a/PWGUD/TableProducer/fwdtrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
similarity index 100%
rename from PWGUD/TableProducer/fwdtrackPropagation.cxx
rename to PWGUD/TableProducer/fwdTrackPropagation.cxx

From 1c7a9c4f72374bcf1d176f972766edb81cb3cbbb Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 17:17:54 +0300
Subject: [PATCH 09/10] Fix typo

---
 PWGUD/TableProducer/fwdTrackPropagation.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index 61a34e4b8bd..9be3f073218 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -125,7 +125,7 @@ struct FwdTrackPropagation {
       if (t.z() < ZAbsorberFront) {
         std::array<float, 3> vtx = {0.f, 0.f, 0.f};
         std::array<float, 2> vtxCov = {0.f, 0.f};
-        if (t.has_collision() && t.trackType() < ForwardTrackTypeEnum::GlobalForwardTrack) { // propagate only global muon tracks to collision vtx
+        if (t.has_collision() && t.trackType() <= ForwardTrackTypeEnum::GlobalForwardTrack) { // propagate only global muon tracks to collision vtx
           auto col = cols.iteratorAt(t.collisionId());
           vtx[0] = col.posX();
           vtx[1] = col.posY();

From 5640b7a616829820e523a1f0ce09d9eb2e496d89 Mon Sep 17 00:00:00 2001
From: nburmaso <nazar.burmasov@cern.ch>
Date: Fri, 19 Dec 2025 19:28:21 +0300
Subject: [PATCH 10/10] Fix linter warnings

---
 PWGUD/TableProducer/fwdTrackPropagation.cxx | 14 +++++++-------
 PWGUD/TableProducer/upcCandProducerMuon.cxx |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/PWGUD/TableProducer/fwdTrackPropagation.cxx b/PWGUD/TableProducer/fwdTrackPropagation.cxx
index 9be3f073218..64099fac4ed 100644
--- a/PWGUD/TableProducer/fwdTrackPropagation.cxx
+++ b/PWGUD/TableProducer/fwdTrackPropagation.cxx
@@ -90,10 +90,10 @@ struct FwdTrackPropagation {
       double centerMFT[3] = {0, 0, -61.4};
       o2::track::TrackParCovFwd fwdtrack{muon.z(), tpars, tcovs, chi2};
       auto* field = dynamic_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());
-      auto Bz = field->getBz(centerMFT); // Get field at centre of MFT
+      auto bz = field->getBz(centerMFT); // Get field at centre of MFT
       auto geoMan = o2::base::GeometryManager::meanMaterialBudget(muon.x(), muon.y(), muon.z(), vtx[0], vtx[1], vtx[2]);
       auto x2x0 = static_cast<float>(geoMan.meanX2X0);
-      fwdtrack.propagateToVtxhelixWithMCS(vtx[2], {vtx[0], vtx[1]}, {vtxCov[0], vtxCov[1]}, Bz, x2x0);
+      fwdtrack.propagateToVtxhelixWithMCS(vtx[2], {vtx[0], vtx[1]}, {vtxCov[0], vtxCov[1]}, bz, x2x0);
       propmuon.setParameters(fwdtrack.getParameters());
       propmuon.setZ(fwdtrack.getZ());
       propmuon.setCovariances(fwdtrack.getCovariances());
@@ -146,11 +146,11 @@ struct FwdTrackPropagation {
         // LOGP(info, "track {}, before: {} {} {} {} {} {}", t.globalIndex(), t.x(), t.y(), t.z(), t.phi(), t.tgl(), t.signed1Pt());
         // LOGP(info, "track {}, after: {} {} {} {} {} {}", t.globalIndex(), pft.getX(), pft.getY(), pft.getZ(), pft.getPhi(), pft.getTgl(), pft.getInvQPt());
         SMatrix55 cov = pft.getCovariances();
-        float sigX = TMath::Sqrt(cov(0, 0));
-        float sigY = TMath::Sqrt(cov(1, 1));
-        float sigPhi = TMath::Sqrt(cov(2, 2));
-        float sigTgl = TMath::Sqrt(cov(3, 3));
-        float sig1Pt = TMath::Sqrt(cov(4, 4));
+        float sigX = std::sqrt(cov(0, 0));
+        float sigY = std::sqrt(cov(1, 1));
+        float sigPhi = std::sqrt(cov(2, 2));
+        float sigTgl = std::sqrt(cov(3, 3));
+        float sig1Pt = std::sqrt(cov(4, 4));
         auto rhoXY = static_cast<int8_t>(128. * cov(0, 1) / (sigX * sigY));
         auto rhoPhiX = static_cast<int8_t>(128. * cov(0, 2) / (sigPhi * sigX));
         auto rhoPhiY = static_cast<int8_t>(128. * cov(1, 2) / (sigPhi * sigY));
diff --git a/PWGUD/TableProducer/upcCandProducerMuon.cxx b/PWGUD/TableProducer/upcCandProducerMuon.cxx
index 41857d1d921..329a83b432c 100644
--- a/PWGUD/TableProducer/upcCandProducerMuon.cxx
+++ b/PWGUD/TableProducer/upcCandProducerMuon.cxx
@@ -9,10 +9,10 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file UpcCandProducerMuon.cxx
-/// \brief UPC candidate producer for forward muons without MFT
+/// \file   upcCandProducerMuon.cxx
+/// \brief  UPC candidate producer for forward muons without MFT
 /// \author Nazar Burmasov, nazar.burmasov@cern.ch
-/// \since 19.12.2025
+/// \since  19.12.2025
 
 #include "PWGUD/Core/UPCCutparHolder.h"
 #include "PWGUD/Core/UPCHelpers.h"