@geotechcli/core 0.4.108 → 0.4.109

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

@@ -180,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) {
@@ -1489,27 +1563,30 @@ function assemblePlaneStrainSystem(model, options = {}) {
     };
 }
 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) {
@@ -1538,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),
@@ -1578,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()) {
@@ -1602,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,
@@ -1707,7 +1820,10 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
     const system = assemblePlaneStrainSystem(model, {
         storage: linearSolver === 'sparse-csr-cg' ? 'triplets-only' : 'dense-and-triplets',
     });
-    const loadStepFractions = normalizeLoadStepFractions(options.loadStepFractions);
+    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.');
@@ -1724,12 +1840,18 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
         })
         : 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 = [
@@ -1769,11 +1891,18 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
             }
             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;
+        if (converged)
+            committedStates = evaluation.trialStates;
         const terminationReason = druckerPragerTerminationReason(evaluation, system.policy, converged, iterations, linearSolverFailure);
         const lastLinearAudit = linearSolverAudits.at(-1);
         loadSteps.push({
@@ -1785,6 +1914,7 @@ 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),
@@ -1819,13 +1949,15 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
         linearSolver,
         nonlinearAlgorithm: 'modified-newton',
         globalTangent: 'elastic',
-        materialIntegration: 'total-strain-drucker-prager-projection',
+        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,
@@ -1844,8 +1976,8 @@ export function runPlaneStrainDruckerPragerLoadSteps(model, options = {}) {
             '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.'] : []),
             linearSolver === 'sparse-csr-cg'
-                ? 'Uses an experimental CSR Conjugate Gradient linear solve audit, elastic global tangent, and Gauss-point Drucker-Prager stress projection; no production consistent tangent, hardening calibration, staged activation, pore-pressure DOF, or route-backed result manifest is provided.'
-                : 'Uses elastic global tangent with Gauss-point Drucker-Prager stress projection; no production consistent tangent, production sparse solver, hardening calibration, staged activation, pore-pressure DOF, or route-backed result manifest is provided.',
+                ? '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.',
         ],
     };