Refactor mesh configuration and helper functions: rename dimension to meshDimension, update element order handling, and improve version printing functionality

Author: nikoscham

examples/solidHeatTransferScript/exampleSolidHeatTransfer01/FEAScriptExampleSolidHeatTransfer01.html

@@ -128,12 +128,12 @@ <h1>Heat Conduction in a Two-Dimensional Fin</h1>
       import {
         FEAScript,
         plotSolution,
-        FEAScriptVersion,
+        printVersion,
       } from "https://feascript.github.io/FEAScript/src/index.js";
 
       window.addEventListener("DOMContentLoaded", () => {
         // Print FEAScript version in the console
-        FEAScriptVersion();
+        printVersion();
         // Calculate solution and render plot once JSON data is loaded
         let { solutionVector, nodesCoordinates } = FEAScript(
           solverConfig,
@@ -145,7 +145,7 @@ <h1>Heat Conduction in a Two-Dimensional Fin</h1>
           solutionVector,
           nodesCoordinates,
           solverConfig,
-          meshConfig.dimension,
+          meshConfig.meshDimension,
           "contour"
         );
       });

examples/solidHeatTransferScript/exampleSolidHeatTransfer01/meshConfig.json

@@ -1,8 +1,8 @@
 {
-  "dimension": "2D",
+  "meshDimension": "2D",
+  "elementOrder": "quadratic",
   "numElementsX": 8,
   "numElementsY": 4,
   "maxX": 4,
-  "maxY": 2,
-  "order": "quadratic"
+  "maxY": 2
 }

src/index.js

@@ -10,4 +10,4 @@
 
 export { FEAScript } from "./FEAScript.js";
 export { plotSolution } from "./visualization/plotSolutionScript.js";
-export { FEAScriptVersion } from "./utilities/helperFunctionsScript.js";
+export { printVersion } from "./utilities/helperFunctionsScript.js";

src/mesh/basisFunctionsScript.js

@@ -14,12 +14,12 @@
 export class basisFunctions {
   /**
    * Constructor to initialize the basisFunctions class
-   * @param {string} dimension - The dimension of the mesh
-   * @param {string} order - The order of elements
+   * @param {string} meshDimension - The dimension of the mesh
+   * @param {string} elementOrder - The order of elements
    */
-  constructor({ dimension, order }) {
-    this.dimension = dimension;
-    this.order = order;
+  constructor({ meshDimension, elementOrder }) {
+    this.meshDimension = meshDimension;
+    this.elementOrder = elementOrder;
   }
 
   /**
@@ -36,16 +36,16 @@ export class basisFunctions {
     let basisFunctionDerivKsi = [];
     let basisFunctionDerivEta = [];
 
-    if (this.dimension === "1D") {
-      if (this.order === 'linear') {
+    if (this.meshDimension === "1D") {
+      if (this.elementOrder === 'linear') {
         // Linear basis functions for 1D elements
         basisFunction[0] = 1 - ksi;
         basisFunction[1] = ksi;
 
         // Derivatives of basis functions with respect to ksi
         basisFunctionDerivKsi[0] = -1;
         basisFunctionDerivKsi[1] = 1;
-      } else if (this.order === 'quadratic') {
+      } else if (this.elementOrder === 'quadratic') {
         // Quadratic basis functions for 1D elements
         basisFunction[0] = 1 - 3*ksi + 2*ksi**2;
         basisFunction[1] = 4*ksi - 4*ksi**2;
@@ -56,13 +56,13 @@ export class basisFunctions {
         basisFunctionDerivKsi[1] = 4 - 8*ksi;
         basisFunctionDerivKsi[2] = -1 + 4*ksi;
       }
-    } else if (this.dimension === "2D") {
+    } else if (this.meshDimension === "2D") {
       if (eta === null) {
         console.log("Eta coordinate is required for 2D elements");
         return;
       }
 
-      if (this.order === 'linear') {
+      if (this.elementOrder === 'linear') {
         // Linear basis functions for 2D elements
         function l1(c) {
           return 1 - c;
@@ -94,7 +94,7 @@ export class basisFunctions {
         basisFunctionDerivEta[1] = l1(ksi) * dl2();
         basisFunctionDerivEta[2] = l2(ksi) * dl1();
         basisFunctionDerivEta[3] = l2(ksi) * dl2();
-      } else if (this.order === 'quadratic') {
+      } else if (this.elementOrder === 'quadratic') {
         // Quadratic basis functions for 2D elements
         function l1(c) {
           return 2 * c ** 2 - 3 * c + 1;

src/mesh/meshGenerationScript.js

@@ -19,26 +19,26 @@ export class meshGeneration {
    * @param {number} config.maxX - Maximum x-coordinate of the mesh
    * @param {number} [config.numElementsY=1] - Number of elements along the y-axis (default is 1 for 1D meshes)
    * @param {number} [config.maxY=0] - Maximum y-coordinate of the mesh (default is 0 for 1D meshes)
-   * @param {string} [config.dimension='2D'] - The dimension of the mesh, either 1D or 2D (default is 2D)
+   * @param {string} [config.meshDimension='2D'] - The dimension of the mesh, either 1D or 2D (default is 2D)
    * @param {string} [config.meshFile=null] - Optional mesh file (JSON) for predefined meshes
-   * @param {string} [config.order='linear'] - The order of elements, either 'linear' or 'quadratic' (default is 'linear')
+   * @param {string} [config.elementOrder='linear'] - The order of elements, either 'linear' or 'quadratic' (default is 'linear')
    */
   constructor({
     numElementsX,
     maxX,
     numElementsY = 1,
     maxY = 0,
-    dimension = "2D",
+    meshDimension = "2D",
     meshFile = null,
-    order = 'linear',
+    elementOrder = 'linear',
   }) {
     this.numElementsX = numElementsX;
     this.numElementsY = numElementsY;
     this.maxX = maxX;
     this.maxY = maxY;
-    this.dimension = dimension;
+    this.meshDimension = meshDimension;
     this.meshFile = meshFile;
-    this.order = order;
+    this.elementOrder = elementOrder;
   }
 
   /**
@@ -96,7 +96,7 @@ export class meshGeneration {
     const yStart = 0;
     let totalNodesX, totalNodesY, deltaX, deltaY;
 
-    if (this.dimension === "1D") {
+    if (this.meshDimension === "1D") {
       totalNodesX = 2 * this.numElementsX + 1;
       deltaX = (this.maxX - xStart) / this.numElementsX;
 
@@ -110,7 +110,7 @@ export class meshGeneration {
       const nodalNumbering = this.generateNodalNumbering(
         this.numElementsX,
         totalNodesX,
-        this.order
+        this.elementOrder
       );
 
       // Find boundary elements
@@ -154,7 +154,7 @@ export class meshGeneration {
         this.numElementsY,
         totalNodesX,
         totalNodesY,
-        this.order
+        this.elementOrder
       );
 
       // Find boundary elements
@@ -196,9 +196,9 @@ export class meshGeneration {
       boundaryElements.push([]);
     }
 
-    if (this.dimension === "1D") {
+    if (this.meshDimension === "1D") {
       console.log("Unsupported dimension or element order");
-    } else if (this.dimension === "2D") {
+    } else if (this.meshDimension === "2D") {
       for (
         let elementIndexX = 0;
         elementIndexX < this.numElementsX;
@@ -212,9 +212,9 @@ export class meshGeneration {
           const elementIndex =
             elementIndexX * this.numElementsY + elementIndexY;
 
-          if (this.order === 'linear') {
+          if (this.elementOrder === 'linear') {
             console.log("Unsupported dimension or element order");
-          } else if (this.order === 'quadratic') {
+          } else if (this.elementOrder === 'quadratic') {
             // Bottom boundary
             if (elementIndexY === 0) {
               boundaryElements[0].push([elementIndex, 0]);
@@ -249,23 +249,23 @@ export class meshGeneration {
    * @param {number} [numElementsY] - Number of elements along the y-axis (optional for 1D)
    * @param {number} totalNodesX - Total number of nodes along the x-axis
    * @param {number} [totalNodesY] - Total number of nodes along the y-axis (optional for 1D)
-   * @param {string} order - The order of elements, either 'linear' or 'quadratic'
+   * @param {string} elementOrder - The order of elements, either 'linear' or 'quadratic'
    * @returns {array} NOP - A two-dimensional array which represents the element-to-node connectivity for the entire mesh
    */
-  generateNodalNumbering(numElementsX, numElementsY, totalNodesX, totalNodesY, order) {
+  generateNodalNumbering(numElementsX, numElementsY, totalNodesX, totalNodesY, elementOrder) {
     let elementIndex = 0;
     let nop = [];
 
-    if (this.dimension === "1D") {
-      if (order === 'linear') {
+    if (this.meshDimension === "1D") {
+      if (elementOrder === 'linear') {
         console.log("Unsupported dimension or element order");
-      } else if (order === 'quadratic') {
+      } else if (elementOrder === 'quadratic') {
         console.log("Unsupported dimension or element order");
       }
-    } else if (this.dimension === "2D") {
-      if (order === 'linear') {
+    } else if (this.meshDimension === "2D") {
+      if (elementOrder === 'linear') {
         console.log("Unsupported dimension or element order");
-      } else if (order === 'quadratic') {
+      } else if (elementOrder === 'quadratic') {
         /**
          * Quadratic rectangular elements with the following nodes representation:
          *

src/methods/numericalIntegrationScript.js

@@ -14,12 +14,12 @@
 export class numericalIntegration {
   /**
    * Constructor to initialize the numIntegration class
-   * @param {string} dimension - The dimension of the mesh
-   * @param {number} order - The order of elements
+   * @param {string} meshDimension - The dimension of the mesh
+   * @param {number} elementOrder - The order of elements
    */
-  constructor({ dimension, order }) {
-    this.dimension = dimension;
-    this.order = order;
+  constructor({ meshDimension, elementOrder }) {
+    this.meshDimension = meshDimension;
+    this.elementOrder = elementOrder;
   }
 
   /**
@@ -32,16 +32,16 @@ export class numericalIntegration {
     let gaussPoints = []; // Gauss points
     let gaussWeights = []; // Gauss weights
 
-    if (this.dimension === "1D") {
-      if (this.order === 'linear') {
+    if (this.meshDimension === "1D") {
+      if (this.elementOrder === 'linear') {
         console.log("Unsupported dimension or element order");
-      } else if (this.order === 'quadratic') {
+      } else if (this.elementOrder === 'quadratic') {
         console.log("Unsupported dimension or element order");
       }
-    } else if (this.dimension === "2D") {
-      if (this.order === 'linear') {
+    } else if (this.meshDimension === "2D") {
+      if (this.elementOrder === 'linear') {
         console.log("Unsupported dimension or element order");
-      } else if (this.order === 'quadratic') {
+      } else if (this.elementOrder === 'quadratic') {
         // For 2D quadratic elements, use 3-point Gauss quadrature in each direction
         gaussPoints[0] = (1 - Math.sqrt(3 / 5)) / 2;
         gaussPoints[1] = 0.5;

src/methods/thermalBoundaryConditionsScript.js

@@ -12,15 +12,15 @@
  * Class to handle thermal boundary conditions application
  */
 export class ThermalBoundaryConditions {
-  constructor(boundaryConditions, boundaryElements, nop, dimension) {
+  constructor(boundaryConditions, boundaryElements, nop, meshDimension) {
     this.boundaryConditions = boundaryConditions;
     this.boundaryElements = boundaryElements;
     this.nop = nop;
-    this.dimension = dimension;
+    this.meshDimension = meshDimension;
   }
 
   imposeConstantTempBoundaryConditions(residualVector, jacobianMatrix) {
-    if (this.dimension === "2D") {
+    if (this.meshDimension === "2D") {
       const boundarySides = {
         0: [0, 3, 6], // Nodes at the bottom side of the reference element
         1: [0, 1, 2], // Nodes at the left side of the reference element
@@ -60,7 +60,7 @@ export class ThermalBoundaryConditions {
     convectionHeatTranfCoeff,
     convectionExtTemp
   ) {
-    if (this.dimension === "2D") {
+    if (this.meshDimension === "2D") {
       Object.keys(this.boundaryConditions).forEach((key) => {
         if (this.boundaryConditions[key][0] === "convection") {
           const convectionCoeff = convectionHeatTranfCoeff[key];

src/solvers/solidHeatTransferScript.js

@@ -25,12 +25,12 @@ import { ThermalBoundaryConditions } from "../methods/thermalBoundaryConditionsS
 export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
   // Extract mesh details from the configuration object
   const {
-    dimension, // The dimension of the mesh
+    meshDimension, // The dimension of the mesh
     numElementsX, // Number of elements in x-direction
     numElementsY, // Number of elements in y-direction
     maxX, // Max x-coordinate (m) of the domain
     maxY, // Max y-coordinate (m) of the domain
-    order, // The order of elements
+    elementOrder, // The order of elements
   } = meshConfig;
 
   // Extract boundary conditions from the configuration object
@@ -50,8 +50,8 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
     numElementsY,
     maxX,
     maxY,
-    dimension,
-    order,
+    meshDimension,
+    elementOrder,
   });
 
   // Generate the mesh
@@ -97,14 +97,14 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
 
   // Initialize the basisFunctions class
   const basisFunctionsData = new basisFunctions({
-    dimension,
-    order,
+    meshDimension,
+    elementOrder,
   });
 
   // Initialize the numericalIntegration class
   const numIntegrationData = new numericalIntegration({
-    dimension,
-    order,
+    meshDimension,
+    elementOrder,
   });
 
   // Calculate Gauss points and weights
@@ -208,7 +208,7 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
     boundaryConditions,
     boundaryElements,
     nop,
-    dimension
+    meshDimension
   );
 
   // Impose Convection boundary conditions

src/utilities/helperFunctionsScript.js

@@ -11,7 +11,7 @@
 /**
  * Function to handle version information and fetch the latest update date and release from GitHub
  */
-export async function FEAScriptVersion() {
+export async function printVersion() {
   // Fetch the latest release information
   const releaseResponse = await fetch('https://api.github.com/repos/FEAScript/FEAScript/releases/latest');
   const releaseData = await releaseResponse.json();

src/visualization/plotSolutionScript.js

@@ -8,21 +8,19 @@
 //                                            |_|   | |_   //
 //       Website: https://feascript.com/             \__|  //
 
-import { FEAScript } from "../FEAScript.js";
-
 /**
  * Create plots of the solution vector
  * @param {*} solutionVector - The computed solution vector
  * @param {*} nodesCoordinates - Object containing x and y coordinates for the nodes
  * @param {string} solverConfig - Parameter specifying the type of solver
- * @param {string} dimension - The dimension of the solution
+ * @param {string} meshDimension - The dimension of the solution
  * @param {string} plotType - The type of plot
  */
 export function plotSolution(
   solutionVector,
   nodesCoordinates,
   solverConfig,
-  dimension,
+  meshDimension,
   plotType
 ) {
   const { nodesXCoordinates, nodesYCoordinates } = nodesCoordinates;
@@ -34,7 +32,7 @@ export function plotSolution(
     return;
   }
 
-  if (dimension === "2D" && plotType === "contour") {
+  if (meshDimension === "2D" && plotType === "contour") {
     // Calculate the number of nodes along the x-axis and y-axis
     const numNodesX = new Set(nodesXCoordinates).size;
     const numNodesY = new Set(nodesYCoordinates).size;