@@ -12,9 +12,7 @@
 #ifndef ALICEO2_ITSMFT_TRACKING_MATERIALPHYSICS_H_
 #define ALICEO2_ITSMFT_TRACKING_MATERIALPHYSICS_H_
 
-#include <cstddef>
 #include <cstdint>
-#include <type_traits>
 
 #include "ReconstructionDataFormats/PID.h"
 
@@ -38,71 +36,6 @@ struct IntegratedMaterialBudget {
   float arealDensityGPerCm2; ///< crossed length*density, g/cm^2
 };
 
-// Reasons a scalar material-physics operation can fail. SourceSurfaceKindMismatch,
-// NonFiniteState, InvalidStateKinematics, and InvalidCovariance are reserved
-// for future full-state operations and are never emitted by
-// calculateMaterialPhysics().
-enum class MaterialFailureReason : uint8_t {
-  None = 0,
-  SourceSurfaceKindMismatch = 1,
-  NonFiniteState = 2,
-  InvalidStateKinematics = 3,
-  InvalidPID = 4,
-  ChargedMasslessPID = 5,
-  InvalidDirection = 6,
-  InvalidMaterial = 7,
-  StoppedInMaterial = 8,
-  MomentumBelowMinimum = 9,
-  ExcessiveScattering = 10,
-  InvalidCovariance = 11,
-  NonFiniteResult = 12
-};
-
-enum class MaterialOperationFlags : uint8_t {
-  None = 0,
-  SubstepCountClamped = 1
-};
-
-// Result of one scalar material-physics evaluation. On failure,
-// momentumBeforeGeV echoes the input, failure gives the reason, and all other
-// fields are deterministic zero/None values with no physical meaning.
-// reserved is always zero.
-struct MaterialOperationResult {
-  float momentumBeforeGeV;
-  float momentumAfterGeV;
-  float signedEnergyChangeGeV;
-  float highlandTheta2Rad2;
-  float relativeInverseMomentumVariance;
-  uint8_t energyLossSubsteps;
-  MaterialOperationFlags flags;
-  MaterialFailureReason failure;
-  uint8_t reserved;
-
-  bool ok() const noexcept { return failure == MaterialFailureReason::None; }
-};
-
-// Lock the current in-memory layout; this is not a serialized or device ABI.
-#define O2_ITSMFT_MATERIAL_ASSERT_LAYOUT(Type, Size, Alignment) \
-  static_assert(std::is_standard_layout_v<Type>);               \
-  static_assert(std::is_trivially_copyable_v<Type>);            \
-  static_assert(sizeof(Type) == Size);                          \
-  static_assert(alignof(Type) == Alignment)
-
-O2_ITSMFT_MATERIAL_ASSERT_LAYOUT(IntegratedMaterialBudget, 8, 4);
-O2_ITSMFT_MATERIAL_ASSERT_LAYOUT(MaterialOperationResult, 24, 4);
-
-#undef O2_ITSMFT_MATERIAL_ASSERT_LAYOUT
-
-static_assert(offsetof(MaterialOperationResult, momentumBeforeGeV) == 0);
-static_assert(offsetof(MaterialOperationResult, momentumAfterGeV) == 4);
-static_assert(offsetof(MaterialOperationResult, signedEnergyChangeGeV) == 8);
-static_assert(offsetof(MaterialOperationResult, highlandTheta2Rad2) == 12);
-static_assert(offsetof(MaterialOperationResult, relativeInverseMomentumVariance) == 16);
-static_assert(offsetof(MaterialOperationResult, energyLossSubsteps) == 20);
-static_assert(offsetof(MaterialOperationResult, flags) == 21);
-static_assert(offsetof(MaterialOperationResult, failure) == 22);
-static_assert(offsetof(MaterialOperationResult, reserved) == 23);
-
 // Detector-neutral, PID/absCharge-aware scalar material-physics kernel.
 // pid supplies the mass; absCharge supplies |q| for energy-loss and
 // scattering scale factors. It need not equal PID::getCharge(). For
@@ -114,7 +47,7 @@ static_assert(offsetof(MaterialOperationResult, reserved) == 23);
 // The PID range is checked before accessing its mass.
 //
 // For charged massive states, non-positive beta^2 is rejected before either
-// material-effect calculation. Failure gives NonFiniteResult.
+// material-effect calculation.
 //
 // For charged massive states, momentumGeV is the caller-selected physical
 // momentum; no covariance projection is performed. Energy loss uses the same
@@ -123,29 +56,30 @@ static_assert(offsetof(MaterialOperationResult, reserved) == 23);
 // requested substep count is
 //   1 + floor(|dE_full| / eKin * o2::track::ELoss2EKinThreshInv)
 // with a range-bounded float-to-int conversion, capped at
-// o2::track::MaxELossIter (50). flags marks SubstepCountClamped when the
-// request exceeds 50. All arealDensityGPerCm2 is processed; only the
+// o2::track::MaxELossIter (50). All arealDensityGPerCm2 is processed; only the
 // granularity changes. Bethe-Bloch is recomputed from the current momentum
 // at each substep.
 // MaterialTraversalDirection::AlongMomentum subtracts energy per substep;
-// OppositeMomentum adds it; signedEnergyChangeGeV is always
-// Eafter - Ebefore. A particle whose energy would fall to or below its rest
-// mass fails with StoppedInMaterial; a particle that completes with
-// momentum below 0.01 GeV/c fails with MomentumBelowMinimum.
+// OppositeMomentum adds it. Reject particles stopped in material or ending
+// with momentum below 0.01 GeV/c.
 //
 // highlandTheta2Rad2 and relativeInverseMomentumVariance use the simplified
 // O2 Highland variance (no logarithmic correction) and pre-material momentum,
 // energy, and beta. Both scale with absCharge^2. highlandTheta2Rad2 > pi^2
-// fails with ExcessiveScattering.
+// is rejected.
 //
 // This kernel does not construct track states, detector geometry, or
 // ITS/MFT/topology/propagation objects.
-MaterialOperationResult calculateMaterialPhysics(
+// Output values are committed only on success.
+bool calculateMaterialPhysics(
   float momentumGeV,
   o2::track::PID pid,
   uint8_t absCharge,
   MaterialTraversalDirection direction,
-  IntegratedMaterialBudget material) noexcept;
+  IntegratedMaterialBudget material,
+  float& momentumAfterGeV,
+  float& highlandTheta2Rad2,
+  float& relativeInverseMomentumVariance) noexcept;
 
 } // namespace o2::itsmft::tracking::material
 
 
@@ -20,7 +20,6 @@
 #include "ITSMFTTracking/SurfaceDescriptor.h"
 #include "ITSMFTTracking/SurfaceTrackState.h"
 #include "ITSMFTTracking/SurfaceMeasurement.h"
-#include "ITSMFTTracking/SurfaceStateOperationResult.h"
 
 // Descriptor-driven propagation using the material and kind resolved from
 // SurfaceDescriptor and SurfaceCatalogView.
@@ -36,23 +35,20 @@ class Propagator
   static bool attachMeasurement(SurfaceTrackState& state, const SurfaceDescriptor& targetSurface,
                                 const SurfaceMeasurement& measurement, float bz,
                                 material::MaterialTraversalDirection direction,
-                                bool chi2GateEnabled, float maxChi2, float& chi2,
-                                OperationFailureReason& reason) noexcept;
+                                bool chi2GateEnabled, float maxChi2, float& chi2) noexcept;
 
   // Compatibility chi2 for two states in the same surface convention. The
   // coordinate convention is selected from the states, never by the caller.
   static bool stateChi2(const SurfaceTrackState& reference, const SurfaceTrackState& candidate,
-                        float& chi2, OperationFailureReason& reason) noexcept;
+                        float& chi2) noexcept;
 
   // Propagate in the state’s current surface convention to its target
   // reference coordinate. Disk transport uses helix propagation for
   // |bz| > 0.01f and linear transport otherwise. Both objects are unchanged
   // on failure when a linearization reference is supplied.
-  static bool propagateToReference(SurfaceTrackState& state, float targetReferenceCoordinate, float bz,
-                                   OperationFailureReason& reason) noexcept;
+  static bool propagateToReference(SurfaceTrackState& state, float targetReferenceCoordinate, float bz) noexcept;
   static bool propagateToReference(SurfaceTrackState& state, SurfaceTrackParameters& linRef,
-                                   float targetReferenceCoordinate, float bz,
-                                   OperationFailureReason& reason) noexcept;
+                                   float targetReferenceCoordinate, float bz) noexcept;
 
   // Re-express the state on the fixed target plane through its nominal point:
   // fixed z for Disk, fixed local x and radial alpha for Cylinder. Transport
@@ -62,8 +58,7 @@ class Propagator
   // Preserves absCharge, PID, and all fields outside the parameter convention.
   // Rejects tangent/unsupported directions and non-finite conversions without
   // changing the state. Cylinder targets require an outward radial direction.
-  static bool convertKind(SurfaceTrackState& state, SurfaceKind targetKind, float bz,
-                          OperationFailureReason& reason) noexcept;
+  static bool convertKind(SurfaceTrackState& state, SurfaceKind targetKind, float bz) noexcept;
 
   // Propagate to a measurement, converting the state to the target surface
   // kind when needed, then applying material, the chi2 gate, and the update.
@@ -75,7 +70,7 @@ class Propagator
                                      const SurfaceDescriptor& targetSurface, const SurfaceMeasurement& targetMeasurement,
                                      float bz, material::MaterialTraversalDirection direction,
                                      bool chi2GateEnabled, float maxChi2, float& chi2,
-                                     bool shiftReferenceToMeasurement, OperationFailureReason& reason) noexcept;
+                                     bool shiftReferenceToMeasurement) noexcept;
 };
 
 } // namespace o2::itsmft::tracking
 
@@ -27,7 +27,6 @@
 #include "ITSMFTTracking/TimeFrame.h"
 #include "ITSMFTTracking/Propagator.h"
 #include "ITSMFTTracking/SurfaceDescriptor.h"
-#include "ITSMFTTracking/SurfaceStateOperationResult.h"
 #include "ReconstructionDataFormats/TrackParametrization.h"
 
 // Descriptor-driven refit built on Propagator operations.
@@ -82,10 +81,9 @@ inline bool driveRefitLeg(SurfaceTrackState& state, SurfaceTrackParameters& linR
                           float& chi2, uint32_t& acceptedHitCount,
                           gsl::span<const RefitMeasurementSlot> orderedSlots, SurfaceCatalogView surfaceCatalog,
                           float bz, material::MaterialTraversalDirection direction,
-                          bool shiftReferenceToMeasurement, float maxChi2, OperationFailureReason& reason) noexcept
+                          bool shiftReferenceToMeasurement, float maxChi2) noexcept
 {
   if (chi2 < 0.f) {
-    reason = OperationFailureReason::PredictedChi2Failure;
     return false;
   }
 
@@ -100,13 +98,12 @@ inline bool driveRefitLeg(SurfaceTrackState& state, SurfaceTrackParameters& linR
     }
     if (!slot.surface.isValid() || !(surfaceCatalog.nSurfaces == 0 || surfaceCatalog.surfaces != nullptr) ||
         !(slot.surface.value() < surfaceCatalog.nSurfaces)) {
-      reason = OperationFailureReason::InvalidSurfaceCatalogAssociation;
       return false;
     }
     const SurfaceDescriptor& descriptor = surfaceCatalog.getSurface(slot.surface);
     if (!Propagator::propagateToMeasurement(scratchState, scratchLinRef, descriptor, slot.measurement, bz, direction,
                                             scratchAcceptedHitCount >= kChi2GateMinAcceptedHits, maxChi2, scratchChi2,
-                                            shiftReferenceToMeasurement, reason)) {
+                                            shiftReferenceToMeasurement)) {
       return false;
     }
     ++scratchAcceptedHitCount;
@@ -171,11 +168,9 @@ inline bool fitTrackSeedLegs(
   gsl::span<const float> minPt,
   SurfaceTrackState& outParamIn,
   SurfaceTrackState& outParamOut,
-  float& outChi2,
-  OperationFailureReason& reason) noexcept
+  float& outChi2) noexcept
 {
   if (layerGlobals.empty() || layerGlobals.size() > MaxLayoutSurfaces) {
-    reason = OperationFailureReason::InvalidSurfaceCatalogAssociation;
     return false;
   }
   // Legs run sequentially; reuse bounded storage without allocating inside
@@ -200,16 +195,14 @@ inline bool fitTrackSeedLegs(
   bool validSlots = false;
   const auto slotsA = detail::assembleRefitLegSlots(seed, frame, layerGlobals, 0, activeSurfaceCount, 1, activeSlots, validSlots);
   if (!validSlots) {
-    reason = OperationFailureReason::InvalidSurfaceCatalogAssociation;
     return false;
   }
   if (!detail::driveRefitLeg(stateA, linRefA, chi2A, acceptedA, slotsA, surfaceCatalog, bz,
                              material::MaterialTraversalDirection::AlongMomentum, shiftReferenceToMeasurement,
-                             maxChi2ClusterAttachment, reason)) {
+                             maxChi2ClusterAttachment)) {
     return false;
   }
   if (!legAcceptable(stateA, chi2A, acceptedA, o2::constants::math::VeryBig, maxChi2NDF)) {
-    reason = OperationFailureReason::LegAcceptanceFailure;
     return false;
   }
 
@@ -221,16 +214,14 @@ inline bool fitTrackSeedLegs(
   uint32_t acceptedB = 0;
   const auto slotsB = detail::assembleRefitLegSlots(seed, frame, layerGlobals, activeSurfaceCount - 1, -1, -1, activeSlots, validSlots);
   if (!validSlots) {
-    reason = OperationFailureReason::InvalidSurfaceCatalogAssociation;
     return false;
   }
   if (!detail::driveRefitLeg(stateB, linRefB, chi2B, acceptedB, slotsB, surfaceCatalog, bz,
                              material::MaterialTraversalDirection::OppositeMomentum, shiftReferenceToMeasurement,
-                             maxChi2ClusterAttachment, reason)) {
+                             maxChi2ClusterAttachment)) {
     return false;
   }
   if (!legAcceptable(stateB, chi2B, acceptedB, 50.f, maxChi2NDF)) {
-    reason = OperationFailureReason::LegAcceptanceFailure;
     return false;
   }
 
@@ -240,7 +231,6 @@ inline bool fitTrackSeedLegs(
   if (minPtSlot >= 0 && minPtSlot < static_cast<int>(minPt.size())) {
     const float minPtThreshold = minPt[minPtSlot];
     if (minPtThreshold > 0.f && ptFromQOverPt(stateB.parameters[4], stateB.absCharge) < minPtThreshold) {
-      reason = OperationFailureReason::MinPtFailure;
       return false;
     }
   }
@@ -255,16 +245,14 @@ inline bool fitTrackSeedLegs(
     uint32_t acceptedC = 0;
     const auto slotsC = detail::assembleRefitLegSlots(seed, frame, layerGlobals, 0, activeSurfaceCount, 1, activeSlots, validSlots);
     if (!validSlots) {
-      reason = OperationFailureReason::InvalidSurfaceCatalogAssociation;
       return false;
     }
     if (!detail::driveRefitLeg(stateC, linRefC, chi2C, acceptedC, slotsC, surfaceCatalog, bz,
                                material::MaterialTraversalDirection::AlongMomentum, shiftReferenceToMeasurement,
-                               maxChi2ClusterAttachment, reason)) {
+                               maxChi2ClusterAttachment)) {
       return false;
     }
     if (!legAcceptable(stateC, chi2C, acceptedC, o2::constants::math::VeryBig, maxChi2NDF)) {
-      reason = OperationFailureReason::LegAcceptanceFailure;
       return false;
     }
     stateOut = stateC;