Unify application of systematics

Author: mpuccio

Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/Configuration.h

@@ -258,7 +258,7 @@ TrackingPlan getTrackingPlan(o2::detectors::DetID::ID detId, Type mode);
 namespace o2::itsmft::tracking
 {
 
-/// MFT uses o2::itsmft::TrackerParamConfig; ITS keeps its legacy parameter type.
+/// Detector-specific entry points for the common CA configuration.
 template <o2::detectors::DetID::ID DetId>
 struct TrackerParamRef;
 
@@ -271,7 +271,7 @@ struct TrackerParamRef<o2::detectors::DetID::MFT> {
 
 template <>
 struct TrackerParamRef<o2::detectors::DetID::ITS> {
-  using Type = o2::its::TrackerParamConfig;
+  using Type = o2::itsmft::ITSCommonCATrackerParam;
   static const Type& get() { return Type::Instance(); }
   static constexpr int nLayers() { return ITSNLayers; }
 };

Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/IOUtils.h

@@ -51,8 +51,8 @@ struct DecodedCluster {
   // ITS geometry supplies its cylindrical tracking frame here. Disk
   // projection uses global coordinates directly.
   SurfaceFramePoint cylinderFrame{};
-  // ALPIDE local row/column covariance. The detector projection determines
-  // which normalized axes these values describe.
+  // Intrinsic ALPIDE local row/column covariance, without alignment systematics.
+  // The shared loader adds configured systematics before detector projection.
   SurfaceCovariance2F rowColumnCovariance{};
   uint32_t nPixels{0};
   int layer{-1};
@@ -127,7 +127,6 @@ struct ClusterSourceInput {
   const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* labels{nullptr};
   gsl::span<const LayerId> layerToSurface{};
   ROFTimingConfig timing{};
-  bool applySysErrors{true};
   RuntimeROFViews rofViews{};
 };
 

Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/TrackingConfigParam.h

@@ -57,6 +57,8 @@ struct ITSCommonCATrackerParam : public o2::conf::ConfigurableParamHelper<ITSCom
   float diamondPos[3] = {0.f, 0.f, 0.f}; // Diamond vertex position when useDiamond is set.
   float pvRes = -1.f;                    // Diamond-vertex PV resolution; <=0 keeps the default.
   uint16_t holeLayerMask = 0;            // Detector layers that may be absent from accepted tracks.
+  float sysErr2Row[tracking::ITSNLayers] = {0}; // Additional sensor-row variance for cluster covariance and candidate windows (cm^2).
+  float sysErr2Col[tracking::ITSNLayers] = {0}; // Additional sensor-column variance for cluster covariance and candidate windows (cm^2).
 
   /// Number of tbb::task_arena threads for the ITS common-CA tracker.
   /// This dedicated field is separate from the legacy ITS configuration.
@@ -87,8 +89,8 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int maxHolesIter[o2::itsmft::tracking::MaxIter] = {};                                           // Maximum missing internal layers per iteration.
   uint16_t holeLayerMask = 0;                                                                     // Detector layers that may be absent from accepted tracks.
   float minPtIterLgt[o2::itsmft::tracking::MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // Async minimum pT by track length; <=0 keeps preset.
-  float sysErr2Row[getNLayers()] = {0};                                                           // Systematic sensor-row variance for candidate windows (cm^2).
-  float sysErr2Col[getNLayers()] = {0};                                                           // Systematic sensor-column variance for candidate windows (cm^2).
+  float sysErr2Row[getNLayers()] = {0};                                                           // Additional sensor-row variance for cluster covariance and candidate windows (cm^2).
+  float sysErr2Col[getNLayers()] = {0};                                                           // Additional sensor-column variance for cluster covariance and candidate windows (cm^2).
   float maxChi2ClusterAttachment = -1.f;
   float maxChi2NDF = -1.f;
   float nSigmaCut = -1.f;

Detectors/ITSMFT/common/tracking/src/Configuration.cxx

@@ -33,6 +33,20 @@ constexpr bool iequals(std::string_view a, std::string_view b)
   return std::equal(a.begin(), a.end(), b.begin(), b.end(),
                     [](char x, char y) { return std::tolower(x) == std::tolower(y); });
 }
+
+template <typename Config>
+void resolveSystematicErrors(o2::itsmft::DetectorParameters& parameters, const Config& config)
+{
+  for (size_t layer = 0; layer < std::size(config.sysErr2Row); ++layer) {
+    const auto row = config.sysErr2Row[layer];
+    const auto col = config.sysErr2Col[layer];
+    if (row < 0.f || col < 0.f) {
+      throw std::invalid_argument(std::format("{}.sysErr2Row/Col[{}] must be finite nonnegative variances", config.getName(), layer));
+    }
+    parameters.SystError2Row[layer] = row;
+    parameters.SystError2Col[layer] = col;
+  }
+}
 } // namespace
 
 namespace o2::itsmft
@@ -202,6 +216,7 @@ TrackingPlan getTrackingPlan(detectors::DetID::ID detId, Type mode)
   auto& trackParams = plan.iterations;
   if (detId == detectors::DetID::ITS) {
     const auto& tc = ITSCommonCATrackerParam::Instance();
+    resolveSystematicErrors(plan.detector, tc);
     if (mode == Async) {
       trackParams.assign(3, defaults);
       trackParams[1].TrackletMinPt = 0.2f;
@@ -338,9 +353,8 @@ TrackingPlan getTrackingPlan(detectors::DetID::ID detId, Type mode)
   }
 
   plan.execution = {tc.maxMemory, tc.dropTFUponFailure};
+  resolveSystematicErrors(plan.detector, tc);
   for (int i{0}; i < TrackerParamConfig<detectors::DetID::MFT>::getNLayers(); ++i) {
-    plan.detector.SystError2Row[i] = tc.sysErr2Row[i] > 0 ? tc.sysErr2Row[i] : plan.detector.SystError2Row[i];
-    plan.detector.SystError2Col[i] = tc.sysErr2Col[i] > 0 ? tc.sysErr2Col[i] : plan.detector.SystError2Col[i];
     plan.detector.AddTimeError[i] = tc.addTimeError[i];
   }
   plan.detector.ColBins = tc.LUTbinsU > 0 ? tc.LUTbinsU : plan.detector.ColBins;

Detectors/ITSMFT/common/tracking/src/IOUtils.cxx

@@ -26,45 +26,11 @@
 namespace
 {
 
-/// Return whether cluster-decoding systematic errors are configured for `DetId`.
-/// ITS is a no-op; MFT reads its live tracker configuration.
-template <o2::detectors::DetID::ID DetId>
-bool shouldApplySysErrors()
-{
-  if constexpr (DetId == o2::detectors::DetID::ITS) {
-    return false;
-  } else {
-    const auto& conf = o2::itsmft::tracking::TrackerParamRef<DetId>::get();
-    for (int il = 0; il < o2::itsmft::tracking::TrackerParamRef<DetId>::nLayers(); il++) {
-      if (conf.sysErr2Row[il] > 0.f || conf.sysErr2Col[il] > 0.f) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-/// Add configured systematic-error corrections to `sigma2Row` and `sigma2Col`.
-/// ITS is a no-op.
-template <o2::detectors::DetID::ID DetId>
-void addSysErrors(int layerId, float& sigma2Row, float& sigma2Col)
-{
-  if constexpr (DetId == o2::detectors::DetID::ITS) {
-    (void)layerId;
-    (void)sigma2Row;
-    (void)sigma2Col;
-  } else {
-    const auto& conf = o2::itsmft::tracking::TrackerParamRef<DetId>::get();
-    sigma2Row += conf.sysErr2Row[layerId];
-    sigma2Col += conf.sysErr2Col[layerId];
-  }
-}
-
 template <o2::detectors::DetID::ID DetId, typename GeomT>
 o2::itsmft::tracking::DecodedCluster decodeCluster(
   GeomT* geom, const o2::itsmft::CompClusterExt& cluster,
   gsl::span<const unsigned char>::iterator& patterns,
-  const o2::itsmft::TopologyDictionary* dict, bool applySysErrors)
+  const o2::itsmft::TopologyDictionary* dict)
 {
   o2::itsmft::tracking::DecodedCluster result;
   if (dict == nullptr) {
@@ -84,11 +50,8 @@ o2::itsmft::tracking::DecodedCluster decodeCluster(
   }
 
   const auto clusterData = o2::itsmft::ioutils::extractClusterData(cluster, patterns, dict);
-  float sigma2Row = clusterData.sig2Row;
-  float sigma2Col = clusterData.sig2Col;
-  if (applySysErrors && shouldApplySysErrors<DetId>()) {
-    addSysErrors<DetId>(layer, sigma2Row, sigma2Col);
-  }
+  const float sigma2Row = clusterData.sig2Row;
+  const float sigma2Col = clusterData.sig2Col;
 
   if constexpr (DetId == o2::detectors::DetID::ITS) {
     const auto trkXYZ = geom->getMatrixT2L(sensorID) ^ clusterData.coordinates;
@@ -118,7 +81,7 @@ void decodeDetectorSource(const o2::itsmft::tracking::ClusterSourceInput& source
     geometry->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
   }
   consume([&](const auto& cluster, auto& patterns) {
-    return decodeCluster<DetId>(geometry, cluster, patterns, source.dictionary, source.applySysErrors);
+    return decodeCluster<DetId>(geometry, cluster, patterns, source.dictionary);
   });
 }
 
@@ -342,14 +305,21 @@ void appendCluster(TimeFrame& frame, const SurfaceCatalogView& catalog,
   const auto expectedSurface = src.layerToSurface[decoded.layer];
   const auto& surfaceDescriptor = catalog.getSurface(expectedSurface);
   const auto localClusterId = static_cast<uint32_t>(frame.getGlobalMeasurements(expectedSurface).size());
+  // Apply alignment systematics once, for both detectors, before projecting
+  // either covariance. Use the same resolved configuration as search windows,
+  // indexed by the mapped surface (not the detector-local layer).
+  auto corrected = decoded;
+  const auto& configuration = frame.getDetectorConfiguration();
+  corrected.rowColumnCovariance.uu += configuration.systError2Row.empty() ? 0.f : configuration.systError2Row.at(expectedSurface.value());
+  corrected.rowColumnCovariance.vv += configuration.systError2Col.empty() ? 0.f : configuration.systError2Col.at(expectedSurface.value());
   GlobalMeasurement global;
   SurfaceMeasurement measurement;
   if (surfaceDescriptor.kind == SurfaceKind::Cylinder) {
-    global = makeCylinderGlobalMeasurement(decoded, localClusterId);
-    measurement = makeCylinderSurfaceMeasurement(decoded);
+    global = makeCylinderGlobalMeasurement(corrected, localClusterId);
+    measurement = makeCylinderSurfaceMeasurement(corrected);
   } else {
-    global = makeDiskGlobalMeasurement(decoded, localClusterId);
-    measurement = makeDiskSurfaceMeasurement(decoded);
+    global = makeDiskGlobalMeasurement(corrected, localClusterId);
+    measurement = makeDiskSurfaceMeasurement(corrected);
   }
   if (!decodedMeasurementIsValid(global, measurement)) {
     throw std::runtime_error(std::format("Malformed cluster loading input source={} rof={} clusterIndex={}", src.id.value(), r, externalIndex));

Detectors/ITSMFT/common/tracking/test/TrackingParameterTestSupport.h

@@ -93,14 +93,14 @@ inline std::vector<TrackingParameters> referenceTrackingParameters(o2::detectors
 // and ROF bookkeeping as production without constructing detector geometry.
 struct TestClusterSourceInput : ClusterSourceInput {
   std::function<DecodedCluster(const itsmft::CompClusterExt&, gsl::span<const unsigned char>::iterator&,
-                               const itsmft::TopologyDictionary*, uint32_t, bool)>
+                               const itsmft::TopologyDictionary*, uint32_t)>
     decode;
 
   template <typename Decoder>
   void setDecoder(const Decoder& decoder)
   {
-    decode = [&decoder](const auto& cluster, auto& patterns, const auto* dictionary, uint32_t index, bool sysErrors) {
-      return decoder.decode(cluster, patterns, dictionary, index, sysErrors);
+    decode = [&decoder](const auto& cluster, auto& patterns, const auto* dictionary, uint32_t index) {
+      return decoder.decode(cluster, patterns, dictionary, index);
     };
   }
 };
@@ -119,7 +119,7 @@ inline void loadSources(TimeFrame& frame, const SurfaceCatalogView& catalog,
     detail::validateSource(source, origin);
     detail::loadDecodedSource(frame, catalog, source, [&](const auto& cluster, auto& patterns) {
       const auto index = static_cast<uint32_t>(&cluster - source.clusters.data());
-      return source.decode(cluster, patterns, source.dictionary, index, source.applySysErrors); }, externalIndices, clusterSizes);
+      return source.decode(cluster, patterns, source.dictionary, index); }, externalIndices, clusterSizes);
     hasMCInformation |= source.labels != nullptr;
   }
   frame.setHasMCInformation(hasMCInformation);
@@ -153,7 +153,6 @@ void loadTimeFrameSource(
   o2::detectors::DetID::ID detector,
   gsl::span<const LayerId> layerToSurface,
   SurfaceCatalogView catalog,
-  bool applySysErrors = true,
   std::vector<std::vector<uint32_t>>* externalIndicesBySurface = nullptr,
   std::vector<std::vector<uint32_t>>* clusterSizesBySurface = nullptr)
 {
@@ -169,7 +168,6 @@ void loadTimeFrameSource(
   source.layerToSurface = layerToSurface;
   source.timing = timing;
   source.setDecoder(decoder);
-  source.applySysErrors = applySysErrors;
   source.rofViews = frame.getROFViews();
   loadTimeFrameSources(frame, gsl::span<const TestClusterSourceInput>{&source, 1}, catalog, origin,
                        externalIndicesBySurface, clusterSizesBySurface);

Detectors/ITSMFT/common/tracking/test/testCombinedTrackingComposition.cxx

@@ -103,8 +103,7 @@ class PrescribedDecoder
     const CompClusterExt& cluster,
     gsl::span<const unsigned char>::iterator& patterns,
     const TopologyDictionary* dictionary,
-    uint32_t externalIndex,
-    bool) const
+    uint32_t externalIndex) const
   {
     const auto clusterData = o2::itsmft::ioutils::extractClusterData(cluster, patterns, dictionary);
     o2::itsmft::tracking::DecodedCluster result;

Detectors/ITSMFT/common/tracking/test/testComputeLayerCellsOrchestration.cxx

@@ -84,7 +84,7 @@ class NeverDecodedDecoder
 
   o2::itsmft::tracking::DecodedCluster decode(
     const CompClusterExt&, gsl::span<const unsigned char>::iterator&, const TopologyDictionary*,
-    uint32_t, bool) const
+    uint32_t) const
   {
     return {};
   }
@@ -117,8 +117,7 @@ class FixedMeasurementDecoder
     const CompClusterExt& cluster,
     gsl::span<const unsigned char>::iterator&,
     const TopologyDictionary*,
-    uint32_t,
-    bool) const
+    uint32_t) const
   {
     o2::itsmft::tracking::DecodedCluster result;
     const int layer = cluster.getSensorID();

Detectors/ITSMFT/common/tracking/test/testComputeLayerTrackletsOrchestration.cxx

@@ -105,8 +105,7 @@ class PrescribedDecoder
     const CompClusterExt& cluster,
     gsl::span<const unsigned char>::iterator& patterns,
     const TopologyDictionary* dictionary,
-    uint32_t externalIndex,
-    bool) const
+    uint32_t externalIndex) const
   {
     const auto clusterData = o2::itsmft::ioutils::extractClusterData(cluster, patterns, dictionary);
     o2::itsmft::tracking::DecodedCluster result;

Detectors/ITSMFT/common/tracking/test/testGenericTrack.cxx

@@ -210,8 +210,7 @@ class FakeClusterDecoder
     const CompClusterExt& cluster,
     gsl::span<const unsigned char>::iterator& patterns,
     const TopologyDictionary* dict,
-    uint32_t,
-    bool applySysErrors) const
+    uint32_t) const
   {
     const auto clusterData = o2::itsmft::ioutils::extractClusterData(cluster, patterns, dict);
     o2::itsmft::tracking::DecodedCluster result;
@@ -472,8 +471,7 @@ class LegacyLikeDecoder
     const CompClusterExt& cluster,
     gsl::span<const unsigned char>::iterator& patterns,
     const TopologyDictionary* dict,
-    uint32_t,
-    bool applySysErrors) const
+    uint32_t) const
   {
     const auto clusterData = o2::itsmft::ioutils::extractClusterData(cluster, patterns, dict);
     o2::itsmft::tracking::DecodedCluster result;
@@ -537,7 +535,7 @@ struct TimeFrameFixture {
     const auto patterns = makePatternBytes(clusters.size());
     const std::vector<ROFRecord> rofs{ROFRecord{{100, 5}, 0, 0, 1}};
     test::loadTimeFrameSource(tf, decoder, origin, timing, clusters, patterns, rofs, &dict(), nullptr, o2::detectors::DetID::ITS,
-                              gsl::span<const LayerId>{layerMapping}, tf.getDetectorConfiguration().getSurfaceCatalog(), true,
+                              gsl::span<const LayerId>{layerMapping}, tf.getDetectorConfiguration().getSurfaceCatalog(),
                               &externalIndicesBySurface, &clusterSizesBySurface);
   }
 };