Refactor heat conduction example and improve Jacobi solver

- Updated mesh configuration in HeatConduction2DFinCG.html to reduce the number of elements for better performance.
- Enhanced FEAScript.js to prepare the mesh and extract node coordinates before matrix assembly.
- Modified jacobiMethodScript.js documentation to clarify return object structure.
- Rewrote jacobiSolverScript.js to implement a CPU synchronous version of the Jacobi method, removing the WebGPU dependency.
- Adjusted convergence check in webgpuJacobiWorker.js to use absolute differences.
- Removed testWebGPU.html as it is no longer needed.

Author: sridhar-mani

dist/feascript.esm.js.map

@@ -35,8 +35,8 @@ <h1>Heat Conduction in 2D Fin - Conjugate Gradient Solver</h1>
             model.setMeshConfig({
                 meshDimension: "2D",
                 elementOrder: "quadratic",
-                numElementsX: 40,
-                numElementsY: 20,
+                numElementsX: 20,
+                numElementsY: 10,
                 maxX: 4000,
                 maxY: 2000,
             });

examples/heatConductionScript/heatConduction2DFin/HeatConduction2DFinCG.html

@@ -82,13 +82,24 @@ export class FEAScriptModel {
     let solutionVector = [];
     let nodesCoordinates = {};
 
+    // Prepare the mesh
+    basicLog("Preparing mesh...");
+    const meshData = prepareMesh(this.meshConfig);
+    basicLog("Mesh preparation completed");
+
+    // Extract node coordinates from meshData
+    nodesCoordinates = {
+      nodesXCoordinates: meshData.nodesXCoordinates,
+      nodesYCoordinates: meshData.nodesYCoordinates,
+    };
+
     // Assembly matrices
     basicLog("Beginning matrix assembly...");
     console.time("assemblyMatrices");
     if (this.solverConfig === "solidHeatTransferScript") {
       basicLog(`Using solver: ${this.solverConfig}`);
-      ({ jacobianMatrix, residualVector, nodesCoordinates } = assembleSolidHeatTransferMat(
-        this.meshConfig,
+      ({ jacobianMatrix, residualVector } = assembleHeatConductionMat(
+        meshData,
         this.boundaryConditions
       ));
     }

src/FEAScript.js

@@ -21,7 +21,7 @@ import { WebGPUComputeEngine } from "../utilities/webgpuComputeEngine.js";
  * @param {number} [tolerance=1e-7] - Convergence tolerance
  * @param {boolean} [useFloat64=true] - Whether to use Float64Array for higher precision
  * @returns {object} An object containing:
- *  - solution: The solution vector
+ *  - solutionVector: The solution vector
  *  - iterations: The number of iterations performed
  *  - converged: Boolean indicating whether the method converged
  */

src/methods/jacobiMethodScript.js

@@ -8,35 +8,47 @@
 //                                            |_|   | |_   //
 //       Website: https://feascript.com/             \__|  //
 
-import * as Comlink from "../vendor/comlink.mjs";
-import { WebGPUComputeEngine } from "../utilities/webgpuComputeEngine.js";
-
 /**
- * Function to solve a system of linear equations using the Jacobi iterative method
- * This version uses the WebGPU compute engine for maximum performance and reusability
+ * Function to solve a system of linear equations using the Jacobi iterative method (CPU synchronous version)
  * @param {array} A - The coefficient matrix (must be square)
  * @param {array} b - The right-hand side vector
  * @param {array} x0 - Initial guess for solution vector
- * @param {number} [maxIterations=100] - Maximum number of iterations
- * @param {number} [tolerance=1e-7] - Convergence tolerance
- * @param {boolean} [useFloat64=true] - Whether to use Float64Array for higher precision
+ * @param {object} [options] - Additional options for the solver
+ * @param {number} [options.maxIterations=1000] - Maximum number of iterations
+ * @param {number} [options.tolerance=1e-6] - Convergence tolerance
  * @returns {object} An object containing:
  *  - solutionVector: The solution vector
  *  - iterations: The number of iterations performed
  *  - converged: Boolean indicating whether the method converged
  */
-export async function jacobiMethod(A, b, x0, maxIterations = 100, tolerance = 1e-7, useFloat64 = true) {
-  // Use the dedicated worker file
-  const worker = new Worker('./workers/webgpuJacobiWorker.js', { type: 'module' });
-  const jacobiWorker = Comlink.wrap(worker);
+export function jacobiSolver(A, b, x0, options = {}) {
+  const { maxIterations = 1000, tolerance = 1e-6 } = options;
+  const n = A.length;
+  let x = [...x0];
+  let xNew = new Array(n);
+
+  for (let iter = 0; iter < maxIterations; iter++) {
+    for (let i = 0; i < n; i++) {
+      let sum = 0;
+      for (let j = 0; j < n; j++) {
+        if (i !== j) {
+          sum += A[i][j] * x[j];
+        }
+      }
+      xNew[i] = (b[i] - sum) / A[i][i];
+    }
+
+    let maxDiff = 0;
+    for (let i = 0; i < n; i++) {
+      maxDiff = Math.max(maxDiff, Math.abs(xNew[i] - x[i]));
+    }
 
-  try {
-    const result = await jacobiWorker.jacobiMethod(A, b, x0, maxIterations, tolerance, useFloat64);
-    return result;
-  } catch (error) {
-    console.error("Error in WebGPU Jacobi method:", error);
-    throw error;
-  } finally {
-    worker.terminate();
+    x = [...xNew];
+
+    if (maxDiff < tolerance) {
+      return { solutionVector: x, iterations: iter + 1, converged: true };
+    }
   }
+
+  return { solutionVector: x, iterations: maxIterations, converged: false };
 }

src/methods/jacobiSolverScript.js

@@ -65,7 +65,7 @@ class WebGPUJacobiWorker {
       xNew = await xNewField.toArray();
 
       // Check convergence by computing max difference
-      const diffField = ti.field(ti.f32, [n]);
+      const absDiffField = ti.field(ti.f32, [n]);
       diffField.fromArray(xNew.map((val, i) => val - x[i]));
 
       ti.addToKernelScope({diffField, absDiffField});