Refactor helper functions and update documentation: improve version logging, enhance CORS instructions in HTML and README, and remove unused numerical integration script. Implement imposeConvectionBoundaryConditions function and refactor boundary condition handling in solidHeatTransferScript.js. Rename variables to be more appropriate and consistent.

Author: nikoscham

examples/solidHeatTransferScript/exampleSolidHeatTransfer01/FEAScriptExampleSolidHeatTransfer01.html

@@ -75,8 +75,9 @@ <h1>Heat Conduction in a Two-Dimensional Fin</h1>
     </p>
 
     <p>
-      This example requires Cross-Origin Resource Sharing (CORS) to run. To
-      enable CORS on Firefox, you can follow these steps:
+      This example requires Cross-Origin Resource Sharing (CORS) to run if the
+      JSON files are stored locally. To enable CORS on Firefox, you can follow
+      these steps:
     </p>
     <ol>
       <li>

examples/solidHeatTransferScript/exampleSolidHeatTransfer01/README.md

@@ -1,9 +1,34 @@
-# Heat Conduction in a Two-Dimensional Fin
+<img src="https://feascript.github.io/FEAScript-website/images/FEAScriptLogo.png" width="80">
 
-This example demonstrates how to solve a stationary heat transfer problem within a 2D rectangular domain using the FEAScript library. The problem is a typical cooling fin scenario, where cooling fins are used to increase the area available for heat transfer between metal walls and poorly conducting fluids such as air.
+## Heat Conduction in a Two-Dimensional Fin
 
-## Files
+This example demonstrates how to solve a stationary heat transfer problem within a 2D rectangular domain using the FEAScript library. The problem is a typical cooling fin scenario.
+
+### Files
 
 - `meshConfig.json`: Defines the computational mesh parameters.
 - `boundaryConditionsConfig.json`: Specifies the boundary conditions for the problem.
-- `FEAScriptExampleSolidHeatTransfer01.html`: The main HTML file that sets up and runs the example.
+- `FEAScriptExampleSolidHeatTransfer01.html`: The main HTML file that sets up and runs the example.
+
+### CORS Configuration
+
+<p>
+  This example requires Cross-Origin Resource Sharing (CORS) to run if the JSON files are stored locally. To
+  enable CORS on Firefox, you can follow these steps:
+</p>
+<ol>
+  <li>
+    Open Firefox and type <code>about:config</code> in the address bar, then
+    press Enter.
+  </li>
+  <li>Accept the risk and continue to the advanced settings.</li>
+  <li>
+    In the search bar, type
+    <code>security.fileuri.strict_origin_policy</code>.
+  </li>
+  <li>
+    Double-click on the
+    <code>security.fileuri.strict_origin_policy</code> preference to set it
+    to <code>false</code>.
+  </li>
+</ol>

src/mesh/meshGenerationScript.js

@@ -83,7 +83,7 @@ export class meshGeneration {
 
   /**
    * Generate a structured mesh based on the geometry configuration
-   * @returns {object} An object containing the coordinates of nodes, 
+   * @returns {object} An object containing the coordinates of nodes,
    * total number of nodes, nodal numbering (NOP) array, and boundary elements
    */
   generateMeshFromGeometry() {
@@ -98,8 +98,9 @@ export class meshGeneration {
       deltaX = (this.maxX - xStart) / this.numElementsX;
 
       nodesXCoordinates[0] = xStart;
-      for (let i = 1; i < totalNodesX; i++) {
-        nodesXCoordinates[i] = nodesXCoordinates[i - 1] + deltaX;
+      for (let nodeIndex = 1; nodeIndex < totalNodesX; nodeIndex++) {
+        nodesXCoordinates[nodeIndex] =
+          nodesXCoordinates[nodeIndex - 1] + deltaX;
       }
 
       // Generate nodal numbering (NOP) array
@@ -126,18 +127,20 @@ export class meshGeneration {
 
       nodesXCoordinates[0] = xStart;
       nodesYCoordinates[0] = yStart;
-      for (let i = 1; i < totalNodesY; i++) {
-        nodesXCoordinates[i] = nodesXCoordinates[0];
-        nodesYCoordinates[i] = nodesYCoordinates[0] + (i * deltaY) / 2;
+      for (let nodeIndexY = 1; nodeIndexY < totalNodesY; nodeIndexY++) {
+        nodesXCoordinates[nodeIndexY] = nodesXCoordinates[0];
+        nodesYCoordinates[nodeIndexY] =
+          nodesYCoordinates[0] + (nodeIndexY * deltaY) / 2;
       }
-      for (let i = 1; i < totalNodesX; i++) {
-        const nnode = i * totalNodesY;
-        nodesXCoordinates[nnode] = nodesXCoordinates[0] + (i * deltaX) / 2;
+      for (let nodeIndexX = 1; nodeIndexX < totalNodesX; nodeIndexX++) {
+        const nnode = nodeIndexX * totalNodesY;
+        nodesXCoordinates[nnode] =
+          nodesXCoordinates[0] + (nodeIndexX * deltaX) / 2;
         nodesYCoordinates[nnode] = nodesYCoordinates[0];
-        for (let j = 1; j < totalNodesY; j++) {
-          nodesXCoordinates[nnode + j] = nodesXCoordinates[nnode];
-          nodesYCoordinates[nnode + j] =
-            nodesYCoordinates[nnode] + (j * deltaY) / 2;
+        for (let nodeIndexY = 1; nodeIndexY < totalNodesY; nodeIndexY++) {
+          nodesXCoordinates[nnode + nodeIndexY] = nodesXCoordinates[nnode];
+          nodesYCoordinates[nnode + nodeIndexY] =
+            nodesYCoordinates[nnode] + (nodeIndexY * deltaY) / 2;
         }
       }
 
@@ -187,27 +190,36 @@ export class meshGeneration {
     if (this.dimension === "1D") {
       // . . . implementation for 1D . . .
     } else {
-      for (let i = 0; i < this.numElementsX; i++) {
-        for (let j = 0; j < this.numElementsY; j++) {
-          const elementIndex = i * this.numElementsY + j;
+      for (
+        let elementIndexX = 0;
+        elementIndexX < this.numElementsX;
+        elementIndexX++
+      ) {
+        for (
+          let elementIndexY = 0;
+          elementIndexY < this.numElementsY;
+          elementIndexY++
+        ) {
+          const elementIndex =
+            elementIndexX * this.numElementsY + elementIndexY;
 
           // Bottom boundary
-          if (j === 0) {
+          if (elementIndexY === 0) {
             boundaryElements[0].push([elementIndex, 0]);
           }
 
           // Top boundary
-          if (j === this.numElementsY - 1) {
+          if (elementIndexY === this.numElementsY - 1) {
             boundaryElements[2].push([elementIndex, 2]);
           }
 
           // Left boundary
-          if (i === 0) {
+          if (elementIndexX === 0) {
             boundaryElements[1].push([elementIndex, 1]);
           }
 
           // Right boundary
-          if (i === this.numElementsX - 1) {
+          if (elementIndexX === this.numElementsX - 1) {
             boundaryElements[3].push([elementIndex, 3]);
           }
         }
@@ -244,25 +256,38 @@ export class meshGeneration {
        *
        */
 
-      for (let i = 0; i < numElementsX * numElementsY; i++) {
+      for (
+        let elementIndex = 0;
+        elementIndex < numElementsX * numElementsY;
+        elementIndex++
+      ) {
         nop.push([]);
-        for (let j = 0; j < 9; j++) {
-          nop[i][j] = 0;
+        for (let nodeIndex = 0; nodeIndex < 9; nodeIndex++) {
+          nop[elementIndex][nodeIndex] = 0;
         }
       }
 
-      for (let i = 1; i <= numElementsX; i++) {
-        for (let j = 1; j <= numElementsY; j++) {
-          for (let k = 1; k <= 3; k++) {
-            let l = 3 * k - 2;
+      for (
+        let elementIndexX = 1;
+        elementIndexX <= numElementsX;
+        elementIndexX++
+      ) {
+        for (
+          let elementIndexY = 1;
+          elementIndexY <= numElementsY;
+          elementIndexY++
+        ) {
+          for (let nodeIndex = 1; nodeIndex <= 3; nodeIndex++) {
+            let l = 3 * nodeIndex - 2;
             nop[elementIndex][l - 1] =
-              totalNodesY * (2 * i + k - 3) + 2 * j - 1;
+              totalNodesY * (2 * elementIndexX + nodeIndex - 3) +
+              2 * elementIndexY -
+              1;
             nop[elementIndex][l] = nop[elementIndex][l - 1] + 1;
             nop[elementIndex][l + 1] = nop[elementIndex][l - 1] + 2;
           }
           elementIndex = elementIndex + 1;
-      
-  }
+        }
       }
     }