Refactor Newton-Raphson method to accept matrix assembly function and context, enhancing front propagation solver with eikonal viscous term parameterization

nikoscham · nikoscham · commit 9c090d981ec7 · 2025-07-10T15:43:08.000+03:00
diff --git a/src/FEAScript.js b/src/FEAScript.js
@@ -73,32 +73,51 @@ export class FEAScriptModel {
         this.boundaryConditions
       ));
     } else if (this.solverConfig === "frontPropagationScript") {
+      basicLog(`Using solver: ${this.solverConfig}`);
       let eikonalActivationFlag = 0; // Parameterization flag (from 0 to 1)
       const initialEikonalViscousTerm = 0.1; // Initial viscous term for the front propagation (eikonal) equation
       let eikonalViscousTerm = 1 - eikonalActivationFlag + initialEikonalViscousTerm; // Viscous term for the front propagation (eikonal) equation
-      basicLog(`Using solver: ${this.solverConfig}`);
 
-      // Iterations for fully activating Eikonal equation
+      // Create context object with all necessary properties
+      const context = {
+        meshConfig: this.meshConfig,
+        boundaryConditions: this.boundaryConditions,
+        eikonalActivationFlag,
+        eikonalViscousTerm,
+        solverMethod: this.solverMethod
+      };
+
       while (eikonalActivationFlag <= 1) {
-        // Newton-Raphson iterations
-        ({ jacobianMatrix, residualVector, nodesCoordinates } = assembleFrontPropagationMat(
-          this.meshConfig,
-          this.boundaryConditions
-        ));
+        // Use Newton-Raphson to iterate
+        const newtonRaphsonResult = newtonRaphson(
+          assembleFrontPropagationMat, // Pass the function reference
+          context,
+          100, // maxIterations
+          1e-7 // tolerance
+        );
+
+        // Extract results
+        jacobianMatrix = newtonRaphsonResult.jacobianMatrix;
+        residualVector = newtonRaphsonResult.residualVector;
+        nodesCoordinates = newtonRaphsonResult.nodesCoordinates;
+        solutionVector = newtonRaphsonResult.solution;
+
+        // Increment eikonalActivationFlag for next step if needed
+        eikonalActivationFlag += 0.1;
       }
     }
     console.timeEnd("assemblyMatrices");
     basicLog("Matrix assembly completed");
 
-    // System solving
+    // Solve the linear system based on the specified solver method
     basicLog(`Solving system using ${this.solverMethod}...`);
     console.time("systemSolving");
     if (this.solverMethod === "lusolve") {
+      // Use LU decomposition method
       solutionVector = math.lusolve(jacobianMatrix, residualVector);
     } else if (this.solverMethod === "jacobi") {
-      // Create initial guess of zeros
+      // Use Jacobi method
       const initialGuess = new Array(residualVector.length).fill(0);
-      // Call Jacobi method with desired max iterations and tolerance
       const jacobiResult = jacobiMethod(jacobianMatrix, residualVector, initialGuess, 1000, 1e-6);
 
       // Log convergence information
diff --git a/src/methods/newtonRaphsonScript.js b/src/methods/newtonRaphsonScript.js
@@ -22,7 +22,7 @@ import { basicLog, debugLog, errorLog } from "./utilities/loggingScript.js";
  *  - converged: Boolean indicating whether the method converged
  */
 
-export function newtonRaphson(computeSystem, context, maxIterations = 100, tolerance = 1e-7) {
+export function newtonRaphson(assembleMat, context, maxIterations = 100, tolerance = 1e-7) {
   let errorNorm = 0;
   let converged = false;
   let iterations = 0;
@@ -32,18 +32,71 @@ export function newtonRaphson(computeSystem, context, maxIterations = 100, toler
   let residualVector = [];
   let nodesCoordinates = {};
 
+  // Initialize solution and deltaX
+  for (let i = 0; i < residualVector.length; i++) {
+    solution[i] = 0;
+    deltaX[i] = 0;
+  }
+
   while (iterations <= maxIterations && !converged) {
-    for (i = 0; i < solution.length; i++) {
-      solution[i] = solution[i] + deltaX[i]; // solution[i] or solution[i-1]? - Have to check
+    // Update solution
+    for (let i = 0; i < solution.length; i++) {
+      solution[i] = solution[i] + deltaX[i];
+    }
+
+    // Compute Jacobian and Residual matrices
+    if (assembleMat === "assembleFrontPropagationMat") {
+      // Pass an additional artificial visous parameter for front propagation
+      ({ jacobianMatrix, residualVector, nodesCoordinates } = assembleMat(
+        context.meshConfig,
+        context.boundaryConditions,
+        context.eikonalViscousTerm
+      ));
+    } else {
+      // Standard call for other assembly functions
+      ({ jacobianMatrix, residualVector, nodesCoordinates } = assembleMat(
+        context.meshConfig,
+        context.boundaryConditions
+      ));
+    }
+
+    // Solve the linear system based on the specified solver method
+    basicLog(`Solving system using ${context.solverMethod}...`);
+    if (context.solverMethod === "jacobi") {
+      // Use Jacobi method
+      const initialGuess = new Array(residualVector.length).fill(0);
+      const jacobiResult = jacobiMethod(jacobianMatrix, residualVector, initialGuess, 1000, 1e-6);
+      debugLog(
+        `Used Jacobi solver in Newton-Raphson iteration ${iterations + 1}, converged: ${
+          jacobiResult.converged
+        }`
+      );
+    } else if (context.solverMethod === "lusolve") {
+      // Use LU decomposition method
+      deltaX = math.lusolve(jacobianMatrix, residualVector);
+      debugLog(`Used LU decomposition solver in Newton-Raphson iteration ${iterations + 1}`);
     }
-    // Compute Residuals and Jacobian. Then solve the linear system
+
+    // Check convergence
     errorNorm = euclideanNorm(deltaX);
     if (errorNorm <= tolerance) {
       converged = true;
     } else if (errorNorm > 1e5) {
       errorLog(`Solution not converged. Error norm: ${errorNorm}`);
       break;
     }
+
     iterations++;
   }
+
+  debugLog(`Newton-Raphson ${converged ? "converged" : "did not converge"} in ${iterations} iterations`);
+
+  return {
+    solution,
+    converged,
+    iterations,
+    jacobianMatrix,
+    residualVector,
+    nodesCoordinates,
+  };
 }
diff --git a/src/solvers/frontPropagationScript.js b/src/solvers/frontPropagationScript.js
@@ -23,7 +23,7 @@ import { basicLog, debugLog, errorLog } from "../utilities/loggingScript.js";
  *  - residualVector: The assembled residual vector
  *  - nodesCoordinates: Object containing x and y coordinates of nodes
  */
-export function assembleFrontPropagationMat(meshConfig, boundaryConditions) {
+export function assembleFrontPropagationMat(meshConfig, boundaryConditions, eikonalViscousTerm) {
   basicLog("Starting front propagation matrix assembly...");
 
   // Extract mesh details from the configuration object
