@geotechcli/core 0.4.107 → 0.4.109

package/dist/fem/plane-strain-assembly.js

@@ -1,4 +1,5 @@
 import { DEFAULT_FEM_CONVERGENCE_POLICY } from './engineering-evidence.js';
+import { buildCsrFromTriplets, solveCsrConjugateGradient, } from './sparse-linear-algebra.js';
 const GAUSS_POINTS = [
     [-1 / Math.sqrt(3), -1 / Math.sqrt(3), 1],
     [1 / Math.sqrt(3), -1 / Math.sqrt(3), 1],
@@ -6,6 +7,7 @@ const GAUSS_POINTS = [
     [-1 / Math.sqrt(3), 1 / Math.sqrt(3), 1],
 ];
 const MAX_DENSE_DOF_COUNT = 800;
+const MAX_SPARSE_EXPERIMENTAL_DOF_COUNT = 5_000;
 const MAX_BIOT_TIME_STEP_GROWTH_RATIO = 8;
 function assertFinite(value, label) {
     if (!Number.isFinite(value))
@@ -178,52 +180,126 @@ function deviatoricNorm(values) {
     const mean = (values[0] + values[1] + values[2]) / 3;
     return Math.hypot(values[0] - mean, values[1] - mean, values[2] - mean);
 }
-function projectDruckerPragerStress(input) {
+function principalTrace(values) {
+    return values[0] + values[1] + values[2];
+}
+function principalDeviator(values) {
+    const mean = principalTrace(values) / 3;
+    return [values[0] - mean, values[1] - mean, values[2] - mean];
+}
+function addPrincipal(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function scalePrincipal(values, scale) {
+    return [values[0] * scale, values[1] * scale, values[2] * scale];
+}
+function initialDruckerPragerState() {
+    return {
+        strain: [0, 0, 0],
+        stressKpa: [0, 0, 0],
+        sigmaZKpa: 0,
+        equivalentPlasticStrain: 0,
+        plasticStrainPrincipal: [0, 0, 0],
+        volumetricPlasticStrain: 0,
+    };
+}
+function integrateDruckerPragerStress(input) {
     const { material, strain } = input;
     const params = druckerPragerParameters(material);
-    const principal = principalCompressionFromPlaneStress(input.stress, input.sigmaZKpa);
+    const d = planeStrainD(material);
+    const strainIncrement = strain.map((value, index) => value - input.previous.strain[index]);
+    const stressIncrement = d.map((row) => row.reduce((sum, value, col) => sum + value * strainIncrement[col], 0));
+    const trialStress = [
+        input.previous.stressKpa[0] + stressIncrement[0],
+        input.previous.stressKpa[1] + stressIncrement[1],
+        input.previous.stressKpa[2] + stressIncrement[2],
+    ];
+    const trialSigmaZKpa = input.previous.sigmaZKpa + planeStrainSigmaZ(material, strainIncrement);
+    const principal = principalCompressionFromPlaneStress(trialStress, trialSigmaZKpa);
     const principalStress = principal.values;
-    const trace = principalStress[0] + principalStress[1] + principalStress[2];
+    const trace = principalTrace(principalStress);
     const mean = trace / 3;
     const q = deviatoricNorm(principalStress);
-    const intercept = params.compressionInterceptKpa;
+    const hardeningModulusKpa = material.hardeningModulusKpa ?? 0;
+    const intercept = params.compressionInterceptKpa +
+        hardeningModulusKpa * input.previous.equivalentPlasticStrain;
     const yieldValue = q - params.rho * trace - intercept;
     const yieldScale = Math.max(q, Math.abs(params.rho * trace), Math.abs(intercept), 1);
     if (yieldValue <= 0 || Math.abs(yieldValue) / yieldScale <= input.policy.residualTolerance) {
-        return {
+        const nextState = {
             strain,
-            stressKpa: input.stress,
-            outOfPlaneStressKpa: input.sigmaZKpa,
-            compressionPositivePrincipalStressKpa: principalStress,
-            yieldValueKpa: yieldValue,
-            yieldResidualRatio: Math.max(0, yieldValue) / yieldScale,
-            plasticMultiplier: 0,
-            equivalentPlasticStrain: 0,
-            state: 'elastic',
+            stressKpa: trialStress,
+            sigmaZKpa: trialSigmaZKpa,
+            equivalentPlasticStrain: input.previous.equivalentPlasticStrain,
+            plasticStrainPrincipal: input.previous.plasticStrainPrincipal,
+            volumetricPlasticStrain: input.previous.volumetricPlasticStrain,
+        };
+        return {
+            nextState,
+            result: {
+                strain,
+                stressKpa: trialStress,
+                outOfPlaneStressKpa: trialSigmaZKpa,
+                compressionPositivePrincipalStressKpa: principalStress,
+                strainIncrement,
+                previousEquivalentPlasticStrain: input.previous.equivalentPlasticStrain,
+                equivalentPlasticStrainIncrement: 0,
+                plasticStrainPrincipal: nextState.plasticStrainPrincipal,
+                volumetricPlasticStrain: nextState.volumetricPlasticStrain,
+                yieldValueKpa: yieldValue,
+                yieldResidualRatio: Math.max(0, yieldValue) / yieldScale,
+                plasticMultiplier: 0,
+                equivalentPlasticStrain: nextState.equivalentPlasticStrain,
+                state: 'elastic',
+            },
         };
     }
-    const targetQ = Math.max(0, params.rho * trace + intercept);
-    const scale = q > 0 ? targetQ / q : 0;
-    const correctedPrincipal = principalStress.map((value) => mean + (value - mean) * scale);
-    const corrected = planeStressFromPrincipalCompression(correctedPrincipal, principal.angleRad);
-    const correctedQ = deviatoricNorm(correctedPrincipal);
-    const correctedYieldValue = correctedQ - params.rho * trace - intercept;
-    const correctedScale = Math.max(correctedQ, Math.abs(params.rho * trace), Math.abs(intercept), 1);
     const moduli = elasticModuli(material);
     const denominator = 2 * moduli.shearModulusKpa +
         9 * moduli.bulkModulusKpa * params.rho * params.rhoBar +
-        (material.hardeningModulusKpa ?? 0);
+        hardeningModulusKpa;
     const plasticMultiplier = Math.max(0, yieldValue / Math.max(denominator, 1e-12));
-    return {
+    const updatedEquivalentPlasticStrain = input.previous.equivalentPlasticStrain + plasticMultiplier;
+    const updatedIntercept = params.compressionInterceptKpa +
+        hardeningModulusKpa * updatedEquivalentPlasticStrain;
+    const trialDeviator = principalDeviator(principalStress);
+    const flowDirection = q > 0 ? scalePrincipal(trialDeviator, 1 / q) : [0, 0, 0];
+    const plasticStrainIncrement = addPrincipal(scalePrincipal(flowDirection, plasticMultiplier), [-params.rhoBar * plasticMultiplier, -params.rhoBar * plasticMultiplier, -params.rhoBar * plasticMultiplier]);
+    const correctedDeviator = addPrincipal(trialDeviator, scalePrincipal(flowDirection, -2 * moduli.shearModulusKpa * plasticMultiplier));
+    const correctedTrace = trace + 9 * moduli.bulkModulusKpa * params.rhoBar * plasticMultiplier;
+    const correctedPrincipal = addPrincipal(correctedDeviator, [correctedTrace / 3, correctedTrace / 3, correctedTrace / 3]);
+    const corrected = planeStressFromPrincipalCompression(correctedPrincipal, principal.angleRad);
+    const correctedQ = deviatoricNorm(correctedPrincipal);
+    const correctedYieldValue = correctedQ - params.rho * correctedTrace - updatedIntercept;
+    const correctedScale = Math.max(correctedQ, Math.abs(params.rho * correctedTrace), Math.abs(updatedIntercept), 1);
+    const plasticStrainPrincipal = addPrincipal(input.previous.plasticStrainPrincipal, plasticStrainIncrement);
+    const volumetricPlasticStrain = input.previous.volumetricPlasticStrain + principalTrace(plasticStrainIncrement);
+    const nextState = {
         strain,
         stressKpa: corrected.stress,
-        outOfPlaneStressKpa: corrected.sigmaZKpa,
-        compressionPositivePrincipalStressKpa: correctedPrincipal,
-        yieldValueKpa: correctedYieldValue,
-        yieldResidualRatio: Math.abs(correctedYieldValue) / correctedScale,
-        plasticMultiplier,
-        equivalentPlasticStrain: plasticMultiplier,
-        state: 'plastic',
+        sigmaZKpa: corrected.sigmaZKpa,
+        equivalentPlasticStrain: updatedEquivalentPlasticStrain,
+        plasticStrainPrincipal,
+        volumetricPlasticStrain,
+    };
+    return {
+        nextState,
+        result: {
+            strain,
+            stressKpa: corrected.stress,
+            outOfPlaneStressKpa: corrected.sigmaZKpa,
+            compressionPositivePrincipalStressKpa: correctedPrincipal,
+            strainIncrement,
+            previousEquivalentPlasticStrain: input.previous.equivalentPlasticStrain,
+            equivalentPlasticStrainIncrement: plasticMultiplier,
+            plasticStrainPrincipal,
+            volumetricPlasticStrain,
+            yieldValueKpa: correctedYieldValue,
+            yieldResidualRatio: Math.abs(correctedYieldValue) / correctedScale,
+            plasticMultiplier,
+            equivalentPlasticStrain: updatedEquivalentPlasticStrain,
+            state: 'plastic',
+        },
     };
 }
 function shapeDerivativesNatural(xi, eta) {
@@ -284,6 +360,9 @@ function matVec(matrix, vector) {
 function dot(a, b) {
     return a.reduce((sum, value, index) => sum + value * b[index], 0);
 }
+function vectorNorm(values) {
+    return Math.sqrt(values.reduce((sum, value) => sum + value * value, 0));
+}
 function elementMatrices(input) {
     const { nodes, material, thicknessM } = input;
     const d = planeStrainD(material);
@@ -1344,7 +1423,7 @@ export function runPlaneStrainQuad4Assembly(model) {
         policy,
     };
 }
-function assemblePlaneStrainSystem(model) {
+function assemblePlaneStrainSystem(model, options = {}) {
     if (model.schemaVersion !== 'fem-plane-strain-model.v1') {
         throw new Error('Only fem-plane-strain-model.v1 is supported.');
     }
@@ -1370,10 +1449,17 @@ function assemblePlaneStrainSystem(model) {
     const nodeIndexById = new Map(model.nodes.map((node, index) => [node.id, index]));
     const materialById = new Map(model.materials.map((material) => [material.id, material]));
     const dofCount = model.nodes.length * 2;
-    if (dofCount > MAX_DENSE_DOF_COUNT) {
+    const storage = options.storage ?? 'dense-and-triplets';
+    if (storage === 'dense-and-triplets' && dofCount > MAX_DENSE_DOF_COUNT) {
         throw new Error(`Plane-strain dense assembly is capped at ${MAX_DENSE_DOF_COUNT} DOFs for benchmark-scale evidence runs.`);
     }
-    const stiffness = Array.from({ length: dofCount }, () => new Array(dofCount).fill(0));
+    if (storage === 'triplets-only' && dofCount > MAX_SPARSE_EXPERIMENTAL_DOF_COUNT) {
+        throw new Error(`Plane-strain sparse experimental assembly is capped at ${MAX_SPARSE_EXPERIMENTAL_DOF_COUNT} DOFs until production solver benchmarks are approved.`);
+    }
+    const stiffness = storage === 'dense-and-triplets'
+        ? Array.from({ length: dofCount }, () => new Array(dofCount).fill(0))
+        : undefined;
+    const stiffnessTriplets = [];
     const loads = new Array(dofCount).fill(0);
     for (const node of model.nodes) {
         assertFinite(node.xM, `node ${node.id} xM`);
@@ -1422,7 +1508,12 @@ function assemblePlaneStrainSystem(model) {
         const globalDofs = nodeIndices.flatMap((index) => [dofIndex(index, 'ux'), dofIndex(index, 'uy')]);
         for (let localRow = 0; localRow < 8; localRow += 1) {
             for (let localCol = 0; localCol < 8; localCol += 1) {
-                stiffness[globalDofs[localRow]][globalDofs[localCol]] += elementData.stiffness[localRow][localCol];
+                const row = globalDofs[localRow];
+                const col = globalDofs[localCol];
+                const value = elementData.stiffness[localRow][localCol];
+                stiffnessTriplets.push({ row, col, value });
+                if (stiffness)
+                    stiffness[row][col] += value;
             }
         }
         elementGaussCache.push({
@@ -1463,6 +1554,7 @@ function assemblePlaneStrainSystem(model) {
         policy,
         materialById,
         stiffness,
+        stiffnessTriplets,
         loads,
         prescribed,
         freeDofs,
@@ -1471,27 +1563,30 @@ function assemblePlaneStrainSystem(model) {
     };
 }
 function evaluatePlaneStrainDruckerPragerState(input) {
-    const { system, displacement, loadFactor } = input;
+    const { system, displacement, loadFactor, committedStates } = input;
     const internal = new Array(system.dofCount).fill(0);
     let maxYieldResidualRatio = 0;
     let maxEquivalentPlasticStrain = 0;
+    let maxEquivalentPlasticStrainIncrement = 0;
     let plasticGaussPointCount = 0;
-    const elements = system.elementGaussCache.map((entry) => {
+    const trialStates = [];
+    const elements = system.elementGaussCache.map((entry, elementIndex) => {
         const material = system.materialById.get(entry.element.materialId);
-        const d = planeStrainD(material);
         const elementDisplacement = entry.globalDofs.map((index) => displacement[index]);
         const gaussPoints = entry.gauss.map((point, index) => {
             const strain = point.b.map((row) => row.reduce((sum, value, col) => sum + value * elementDisplacement[col], 0));
-            const elasticStress = d.map((row) => row.reduce((sum, value, col) => sum + value * strain[col], 0));
-            const projected = projectDruckerPragerStress({
+            const integrated = integrateDruckerPragerStress({
                 material,
                 policy: system.policy,
                 strain,
-                stress: elasticStress,
-                sigmaZKpa: planeStrainSigmaZ(material, strain),
+                previous: committedStates[elementIndex]?.[index] ?? initialDruckerPragerState(),
             });
+            const projected = integrated.result;
+            trialStates[elementIndex] = trialStates[elementIndex] ?? [];
+            trialStates[elementIndex][index] = integrated.nextState;
             maxYieldResidualRatio = Math.max(maxYieldResidualRatio, projected.yieldResidualRatio);
             maxEquivalentPlasticStrain = Math.max(maxEquivalentPlasticStrain, projected.equivalentPlasticStrain);
+            maxEquivalentPlasticStrainIncrement = Math.max(maxEquivalentPlasticStrainIncrement, projected.equivalentPlasticStrainIncrement);
             if (projected.state === 'plastic')
                 plasticGaussPointCount += 1;
             for (let localDof = 0; localDof < 8; localDof += 1) {
@@ -1520,6 +1615,19 @@ function evaluatePlaneStrainDruckerPragerState(input) {
                     round(projected.compressionPositivePrincipalStressKpa[1], 8),
                     round(projected.compressionPositivePrincipalStressKpa[2], 8),
                 ],
+                strainIncrement: [
+                    round(projected.strainIncrement[0], 12),
+                    round(projected.strainIncrement[1], 12),
+                    round(projected.strainIncrement[2], 12),
+                ],
+                previousEquivalentPlasticStrain: round(projected.previousEquivalentPlasticStrain, 12),
+                equivalentPlasticStrainIncrement: round(projected.equivalentPlasticStrainIncrement, 12),
+                plasticStrainPrincipal: [
+                    round(projected.plasticStrainPrincipal[0], 12),
+                    round(projected.plasticStrainPrincipal[1], 12),
+                    round(projected.plasticStrainPrincipal[2], 12),
+                ],
+                volumetricPlasticStrain: round(projected.volumetricPlasticStrain, 12),
                 yieldValueKpa: round(projected.yieldValueKpa, 10),
                 yieldResidualRatio: round(projected.yieldResidualRatio, 12),
                 plasticMultiplier: round(projected.plasticMultiplier, 12),
@@ -1560,13 +1668,33 @@ function evaluatePlaneStrainDruckerPragerState(input) {
         reactionBalanceRatio,
         maxYieldResidualRatio,
         maxEquivalentPlasticStrain,
+        maxEquivalentPlasticStrainIncrement,
         plasticGaussPointCount,
+        trialStates,
         elements,
     };
 }
-function normalizeLoadStepFractions(loadStepFractions) {
-    const fractions = loadStepFractions && loadStepFractions.length > 0
-        ? [...loadStepFractions]
+function normalizeLoadStepFractions(options) {
+    if (options.loadStepFractions != null && options.loadHistoryFactors != null) {
+        throw new Error('Specify either loadStepFractions or loadHistoryFactors, not both.');
+    }
+    if (options.loadHistoryFactors != null) {
+        if (!Array.isArray(options.loadHistoryFactors) || options.loadHistoryFactors.length === 0) {
+            throw new Error('loadHistoryFactors must contain at least one load factor when provided.');
+        }
+        const history = [...options.loadHistoryFactors];
+        for (const [index, factor] of history.entries()) {
+            if (!Number.isFinite(factor) || factor < 0 || factor > 1) {
+                throw new Error(`loadHistoryFactors.${index} must be finite and between 0 and 1.`);
+            }
+        }
+        if (history[history.length - 1] !== 1) {
+            throw new Error('loadHistoryFactors must end at 1.');
+        }
+        return history;
+    }
+    const fractions = options.loadStepFractions && options.loadStepFractions.length > 0
+        ? [...options.loadStepFractions]
         : [0.25, 0.5, 0.75, 1];
     let previous = 0;
     for (const [index, fraction] of fractions.entries()) {
@@ -1584,6 +1712,9 @@ function isDruckerPragerStepConverged(evaluation, policy) {
     return evaluation.residualNormRatio <= policy.forceBalanceTolerance &&
         evaluation.maxYieldResidualRatio <= policy.residualTolerance;
 }
+function createInitialDruckerPragerStateGrid(system) {
+    return system.elementGaussCache.map((entry) => entry.gauss.map(() => initialDruckerPragerState()));
+}
 function druckerPragerResidualHistoryEntry(iteration, evaluation, policy) {
     return {
         iteration,
@@ -1596,48 +1727,184 @@ function druckerPragerResidualHistoryEntry(iteration, evaluation, policy) {
         converged: isDruckerPragerStepConverged(evaluation, policy),
     };
 }
-function druckerPragerTerminationReason(evaluation, policy, converged, iterations) {
+function druckerPragerTerminationReason(evaluation, policy, converged, iterations, linearSolverFailure) {
     if (converged)
         return 'converged';
+    if (linearSolverFailure)
+        return 'linear_solver_nonconverged';
     if (iterations >= policy.maxIterations)
         return 'max_iterations';
     if (evaluation.residualNormRatio > policy.forceBalanceTolerance)
         return 'force_residual_exceeded';
     return 'yield_residual_exceeded';
 }
+function normalizeLinearSolverKind(solver) {
+    const resolved = solver ?? 'dense-gaussian';
+    if (resolved !== 'dense-gaussian' && resolved !== 'sparse-csr-cg') {
+        throw new Error('linearSolver must be dense-gaussian or sparse-csr-cg.');
+    }
+    return resolved;
+}
+function denseNonzeroCount(matrix) {
+    return matrix.reduce((count, row) => count + row.filter((value) => Math.abs(value) > 0).length, 0);
+}
+function buildReducedCsr(input) {
+    const freeIndexByDof = new Map(input.freeDofs.map((dof, index) => [dof, index]));
+    const reducedTriplets = input.triplets.flatMap((entry) => {
+        const row = freeIndexByDof.get(entry.row);
+        const col = freeIndexByDof.get(entry.col);
+        return row != null && col != null ? [{ row, col, value: entry.value }] : [];
+    });
+    return buildCsrFromTriplets({
+        rowCount: input.freeDofs.length,
+        colCount: input.freeDofs.length,
+        triplets: reducedTriplets,
+        dropTolerance: 0,
+    });
+}
+function solveDenseDruckerPragerCorrection(input) {
+    const correction = solveDenseLinearSystem(input.reducedK, [...input.rhs]);
+    const solvedRhs = matVec(input.reducedK, correction);
+    const residual = solvedRhs.map((value, index) => value - input.rhs[index]);
+    const rhsNorm = Math.max(vectorNorm(input.rhs), 1);
+    const finalResidualNorm = vectorNorm(residual);
+    const correctionNorm = vectorNorm(correction);
+    return {
+        correction,
+        audit: {
+            schemaVersion: 'fem-plane-strain-linear-solver-audit.v1',
+            solver: 'dense-gaussian',
+            matrixDofCount: input.rhs.length,
+            nonzeroCount: denseNonzeroCount(input.reducedK),
+            iterations: input.rhs.length,
+            tolerance: input.tolerance,
+            maxIterations: input.maxIterations,
+            initialResidualNorm: vectorNorm(input.rhs),
+            finalResidualNorm,
+            residualNormRatio: finalResidualNorm / rhsNorm,
+            correctionNormM: correctionNorm,
+            correctionNormRatio: correctionNorm / Math.max(vectorNorm(input.currentFreeDisplacement), 1e-12),
+            converged: true,
+        },
+    };
+}
+function solveSparseDruckerPragerCorrection(input) {
+    const solved = solveCsrConjugateGradient(input.reducedK, input.rhs, {
+        tolerance: input.tolerance,
+        maxIterations: input.maxIterations,
+        preconditioner: 'jacobi',
+    });
+    const correctionNorm = vectorNorm(solved.solution);
+    return {
+        correction: solved.solution,
+        audit: {
+            schemaVersion: 'fem-plane-strain-linear-solver-audit.v1',
+            solver: 'sparse-csr-cg',
+            matrixDofCount: input.rhs.length,
+            nonzeroCount: input.reducedK.nonzeroCount,
+            iterations: solved.iterations,
+            tolerance: solved.tolerance,
+            maxIterations: solved.maxIterations,
+            initialResidualNorm: solved.initialResidualNorm,
+            finalResidualNorm: solved.finalResidualNorm,
+            residualNormRatio: solved.residualNormRatio,
+            correctionNormM: correctionNorm,
+            correctionNormRatio: correctionNorm / Math.max(vectorNorm(input.currentFreeDisplacement), 1e-12),
+            converged: solved.converged,
+            ...(solved.failureReason ? { failureReason: solved.failureReason } : {}),
+        },
+    };
+}
 export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
-    const system = assemblePlaneStrainSystem(model);
-    const loadStepFractions = normalizeLoadStepFractions(options.loadStepFractions);
-    const reducedK = system.freeDofs.map((row) => system.freeDofs.map((col) => system.stiffness[row][col]));
+    const linearSolver = normalizeLinearSolverKind(options.linearSolver);
+    const system = assemblePlaneStrainSystem(model, {
+        storage: linearSolver === 'sparse-csr-cg' ? 'triplets-only' : 'dense-and-triplets',
+    });
+    const loadStepFractions = normalizeLoadStepFractions({
+        loadStepFractions: options.loadStepFractions,
+        loadHistoryFactors: options.loadHistoryFactors,
+    });
+    const linearSolverTolerance = options.linearSolverTolerance ?? Math.min(1e-10, system.policy.forceBalanceTolerance / 10);
+    if (!Number.isFinite(linearSolverTolerance) || linearSolverTolerance <= 0) {
+        throw new Error('linearSolverTolerance must be a finite positive number.');
+    }
+    const linearSolverMaxIterations = options.linearSolverMaxIterations ?? Math.max(100, system.freeDofs.length * 10);
+    assertPositiveInteger(linearSolverMaxIterations, 'linearSolverMaxIterations');
+    const reducedDenseK = linearSolver === 'dense-gaussian'
+        ? system.freeDofs.map((row) => system.freeDofs.map((col) => system.stiffness[row][col]))
+        : undefined;
+    const reducedSparseK = linearSolver === 'sparse-csr-cg' && system.freeDofs.length > 0
+        ? buildReducedCsr({
+            freeDofs: system.freeDofs,
+            triplets: system.stiffnessTriplets,
+        })
+        : undefined;
     const displacement = new Array(system.dofCount).fill(0);
+    let committedStates = createInitialDruckerPragerStateGrid(system);
     let finalEvaluation;
     const loadSteps = [];
     for (const [stepIndex, loadFactor] of loadStepFractions.entries()) {
         for (const [index, value] of system.prescribed)
             displacement[index] = value * loadFactor;
-        let evaluation = evaluatePlaneStrainDruckerPragerState({ system, displacement, loadFactor });
+        let evaluation = evaluatePlaneStrainDruckerPragerState({
+            system,
+            displacement,
+            loadFactor,
+            committedStates,
+        });
         let iterations = 0;
         let converged = isDruckerPragerStepConverged(evaluation, system.policy);
         const residualHistory = [
             druckerPragerResidualHistoryEntry(iterations, evaluation, system.policy),
         ];
+        const linearSolverAudits = [];
+        let linearSolverFailure;
         while (!converged && iterations < system.policy.maxIterations) {
             iterations += 1;
             if (system.freeDofs.length === 0)
                 break;
             const correctionRhs = system.freeDofs.map((index) => -evaluation.residual[index]);
-            const correction = solveDenseLinearSystem(reducedK, correctionRhs);
+            const currentFreeDisplacement = system.freeDofs.map((index) => displacement[index]);
+            const solved = linearSolver === 'sparse-csr-cg'
+                ? solveSparseDruckerPragerCorrection({
+                    reducedK: reducedSparseK,
+                    rhs: correctionRhs,
+                    currentFreeDisplacement,
+                    tolerance: linearSolverTolerance,
+                    maxIterations: linearSolverMaxIterations,
+                })
+                : solveDenseDruckerPragerCorrection({
+                    reducedK: reducedDenseK,
+                    rhs: correctionRhs,
+                    currentFreeDisplacement,
+                    tolerance: linearSolverTolerance,
+                    maxIterations: linearSolverMaxIterations,
+                });
+            linearSolverAudits.push(solved.audit);
+            if (!solved.audit.converged) {
+                linearSolverFailure = solved.audit;
+                break;
+            }
+            const correction = solved.correction;
             for (const [correctionIndex, dof] of system.freeDofs.entries()) {
                 displacement[dof] += correction[correctionIndex];
             }
             for (const [index, value] of system.prescribed)
                 displacement[index] = value * loadFactor;
-            evaluation = evaluatePlaneStrainDruckerPragerState({ system, displacement, loadFactor });
+            evaluation = evaluatePlaneStrainDruckerPragerState({
+                system,
+                displacement,
+                loadFactor,
+                committedStates,
+            });
             converged = isDruckerPragerStepConverged(evaluation, system.policy);
             residualHistory.push(druckerPragerResidualHistoryEntry(iterations, evaluation, system.policy));
         }
         finalEvaluation = evaluation;
-        const terminationReason = druckerPragerTerminationReason(evaluation, system.policy, converged, iterations);
+        if (converged)
+            committedStates = evaluation.trialStates;
+        const terminationReason = druckerPragerTerminationReason(evaluation, system.policy, converged, iterations, linearSolverFailure);
+        const lastLinearAudit = linearSolverAudits.at(-1);
         loadSteps.push({
             step: stepIndex + 1,
             loadFactor: round(loadFactor, 8),
@@ -1647,9 +1914,16 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
             reactionBalanceRatio: round(evaluation.reactionBalanceRatio, 12),
             maxYieldResidualRatio: round(evaluation.maxYieldResidualRatio, 12),
             maxEquivalentPlasticStrain: round(evaluation.maxEquivalentPlasticStrain, 12),
+            maxEquivalentPlasticStrainIncrement: round(evaluation.maxEquivalentPlasticStrainIncrement, 12),
             plasticGaussPointCount: evaluation.plasticGaussPointCount,
+            linearSolver,
+            linearIterations: linearSolverAudits.reduce((sum, audit) => sum + audit.iterations, 0),
+            linearResidualNormRatio: round(lastLinearAudit?.residualNormRatio ?? 0, 12),
+            correctionNormRatio: round(lastLinearAudit?.correctionNormRatio ?? 0, 12),
+            linearSolverAudits,
             converged,
             terminationReason,
+            ...(linearSolverFailure?.failureReason ? { failureReason: linearSolverFailure.failureReason } : {}),
             residualHistory,
         });
     }
@@ -1672,12 +1946,18 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
         dofCount: system.dofCount,
         freeDofCount: system.freeDofs.length,
         constrainedDofCount: system.prescribed.size,
+        linearSolver,
+        nonlinearAlgorithm: 'modified-newton',
+        globalTangent: 'elastic',
+        materialIntegration: 'incremental-committed-drucker-prager-return-mapping',
+        stateStorage: 'committed-gauss-point-history',
         loadSteps,
         maxFreeResidualKn: round(finalEvaluation.maxFreeResidualKn, 12),
         residualNormRatio: round(finalEvaluation.residualNormRatio, 12),
         reactionBalanceRatio: round(finalEvaluation.reactionBalanceRatio, 12),
         maxYieldResidualRatio: round(finalEvaluation.maxYieldResidualRatio, 12),
         maxEquivalentPlasticStrain: round(finalEvaluation.maxEquivalentPlasticStrain, 12),
+        maxEquivalentPlasticStrainIncrement: round(finalEvaluation.maxEquivalentPlasticStrainIncrement, 12),
         plasticGaussPointCount: finalEvaluation.plasticGaussPointCount,
         converged: status === 'converged',
         status,
@@ -1695,7 +1975,9 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
         limitations: [
             'Benchmark-scale modified-Newton plane-strain plasticity evidence kernel only.',
             ...(failedStep ? ['Nonconverged load-step result is reported fail-closed and must not be treated as an accepted engineering solve.'] : []),
-            'Uses elastic global tangent with Gauss-point Drucker-Prager stress projection; no production consistent tangent, sparse solver, hardening calibration, staged activation, pore-pressure DOF, or route-backed result manifest is provided.',
+            linearSolver === 'sparse-csr-cg'
+                ? 'Uses an experimental CSR Conjugate Gradient linear solve audit, elastic global tangent, and committed Gauss-point Drucker-Prager return mapping; no production consistent tangent, hardening calibration, staged activation, pore-pressure DOF, or route-backed result manifest is provided.'
+                : 'Uses elastic global tangent with committed Gauss-point Drucker-Prager return mapping; no production consistent tangent, production sparse solver, hardening calibration, staged activation, pore-pressure DOF, or route-backed result manifest is provided.',
             'Use for deterministic evidence and regression tests only until independent published/commercial benchmark comparison and licensed production approval gates are complete.',
         ],
     };