TPC SCD: add keepClustersOnPropFail to keep tracks whose reference propagation fails

TrackInterpolation drops the whole track when the propagation of the reference track to a TPC pad row (or to the
TRD/TOF anchor) fails, e.g. at scdcalib.maxSnp. That propagation follows the ITS-predicted direction, so the drop
selects tracks by the reference's own curvature error and biases the residuals of the surviving sample at low pt.

With scdcalib.keepClustersOnPropFail=true the track is kept. TPC clusters without a reference are stored
position-only: y, z = cluster position, dy = dz = 0, tgSlp = UnbinnedResid::TgSlpPositionOnly (-0x8000, which the
tgSlp packing never produces; UnbinnedResid::isPositionOnly()). extrapolateTrack: all clusters after the failure.
interpolateTrack: a row keeps its residual only if both the outward and the inward propagation reached it; a failure
of the outer TRD/TOF anchor makes all TPC clusters position-only and suppresses the TRD/TOF residuals. Position-only
clusters are excluded from validateTrack and stored in row order. The ITS and PV residuals are unaffected.
ResidualsContainer::fill, staticMapCreator.C and TPCResidualReaderSpec skip position-only (and tgSlp-clamped)
residuals for the binned voxel fit. Default false: output unchanged (verified on one MC TF, all fields identical).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: matthias-kleiner

Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCResidualReaderSpec.cxx

@@ -189,6 +189,9 @@ void TPCResidualReader::run(ProcessingContext& pc)
           }
           for (int i = trkInfo.idxFirstResidual; i < trkInfo.idxFirstResidual + trkInfo.nResiduals; ++i) {
             const auto& residIn = mUnbinnedResiduals[i];
+            if (residIn.isTgSlpClamped() || residIn.isPositionOnly()) {
+              continue; // scdcalib.clampTgSlp / keepClustersOnPropFail: tgSlp or dy, dz not usable for the binned voxel fit
+            }
             int sec = residIn.sec;
             auto& residVecOut = mResidualsSector[sec];
             auto& statVecOut = mVoxStatsSector[sec];

Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h

@@ -49,6 +49,7 @@ struct SpacePointsCalibConfParam : public o2::conf::ConfigurableParamHelper<Spac
   float sigYZ2TOF{.75f};   ///< for now assume cluster error for TOF equal for all clusters in both Y and Z
   float maxSnp{.85f};      ///< max snp when propagating tracks
   bool clampTgSlp{false};  ///< store TPC cluster residuals with |tan(phi)| >= param::MaxTgSlp saturated (tgSlp = +-0x7fff, see UnbinnedResid::isTgSlpClamped) instead of dropping them: the cut is on the reference track's direction, so dropping selects on the reference's error
+  bool keepClustersOnPropFail{false}; ///< if the reference track propagation fails (maxSnp, rotation), keep the track: TPC clusters without a reference are stored position-only (y, z = cluster; dy = dz = 0; tgSlp = UnbinnedResid::TgSlpPositionOnly) instead of dropping the whole track, which selects on the reference's error
   float maxStep{2.f};      ///< maximum step for propagation
   bool debugTRDTOF{false}; ///< if true, ITS-TPC-TRD-TOF tracks and their seeding ITS-TPC-TRD track will both be interpolated and their residuals stored
 

Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h

@@ -97,6 +97,10 @@ struct UnbinnedResid {
 
   /// true if tgSlp was saturated at +-param::MaxTgSlp (scdcalib.clampTgSlp): unclamped values have |tgSlp| <= 0x7fff - 1
   bool isTgSlpClamped() const { return tgSlp == 0x7fff || tgSlp == -0x7fff; }
+  /// tgSlp marker of a position-only TPC cluster (scdcalib.keepClustersOnPropFail): no reference track at this cluster,
+  /// y and z are the cluster position, dy = dz = 0. Not reachable by the tgSlp packing (|tgSlp| <= 0x7fff)
+  static constexpr short TgSlpPositionOnly = -0x8000;
+  bool isPositionOnly() const { return tgSlp == TgSlpPositionOnly; }
   bool isTPC() const { return row < constants::MAXGLOBALPADROW; }
   bool isTRD() const { return row >= 160 && row < 166; }
   bool isTOF() const { return row == 170; }
@@ -500,6 +504,8 @@ class TrackInterpolation
   size_t mNRejRefit = 0;
   size_t mNRejProp = 0;
   size_t mNRejLoop = 0;
+  size_t mNPosOnlyTracks = 0;   ///< tracks kept with position-only clusters after a propagation failure (keepClustersOnPropFail)
+  size_t mNPosOnlyClusters = 0; ///< position-only TPC clusters stored (keepClustersOnPropFail)
 
   ClassDefNV(TrackInterpolation, 1);
 };

Detectors/TPC/calibration/SpacePoints/macro/staticMapCreator.C

@@ -320,9 +320,9 @@ void staticMapCreator(std::string fileInput = "files.txt",
           if (useResidualsForVd && residualsVd.size() < 10'000'000UL) {
             residualsVd.push_back(residIn);
           }
-          if (residIn.isTgSlpClamped()) {
+          if (residIn.isTgSlpClamped() || residIn.isPositionOnly()) {
             // scdcalib.clampTgSlp: tgSlp saturated -- the voxel fit (dX from dY vs tan(phi)) and the map correction below
-            // use it, so keep this residual out of the binned residuals
+            // use it, so keep this residual out of the binned residuals; scdcalib.keepClustersOnPropFail: no reference (dy = dz = 0)
             continue;
           }
           int sec = residIn.sec;

Detectors/TPC/calibration/SpacePoints/src/ResidualAggregator.cxx

@@ -197,9 +197,9 @@ void ResidualsContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::sp
     if (!writeBinnedResid) {
       continue;
     }
-    if (residIn.isTgSlpClamped()) {
+    if (residIn.isTgSlpClamped() || residIn.isPositionOnly()) {
       // scdcalib.clampTgSlp: kept in the unbinned output, but its tgSlp is saturated and the voxel fit uses tgSlp (dX from
-      // dY vs tan(phi)), so it must not enter the binned residuals
+      // dY vs tan(phi)), so it must not enter the binned residuals; scdcalib.keepClustersOnPropFail: no reference, dy = dz = 0
       continue;
     }
     int sec = residIn.sec;