Update mesh generation to support pre-parsed mesh data and improve logging for mesh size calculations

Author: nikoscham

src/FEAScript.js

@@ -37,9 +37,7 @@ export class FEAScriptModel {
   setMeshConfig(meshConfig) {
     this.meshConfig = meshConfig;
     debugLog(
-      `Mesh config set with dimensions: ${meshConfig.meshDimension}, elements: ${meshConfig.numElementsX}x${
-        meshConfig.numElementsY || 1
-      }`
+      `Mesh config set with dimensions: ${meshConfig.meshDimension}`
     );
   }
 

src/mesh/meshGenerationScript.js

@@ -24,42 +24,35 @@ export class meshGeneration {
    * @param {number} [config.numElementsY=1] - Number of elements along the y-axis (for 1D meshes)
    * @param {number} [config.maxY=0] - Maximum y-coordinate of the mesh (for 1D meshes)
    * @param {string} [config.meshDimension='2D'] - The dimension of the mesh, either 1D or 2D
-   * @param {string|File} [config.meshFile=null] - Optional mesh file for predefined meshes (.msh)
    * @param {string} [config.elementOrder='linear'] - The order of elements, either 'linear' or 'quadratic'
+   * @param {object} [config.parsedMesh=null] - Optional pre-parsed mesh data 
    */
   constructor({
     numElementsX = null,
     maxX = null,
     numElementsY = null,
     maxY = null,
     meshDimension = null,
-    meshFile = null,
     elementOrder = "linear",
+    parsedMesh = null,
   }) {
     this.numElementsX = numElementsX;
     this.numElementsY = numElementsY;
     this.maxX = maxX;
     this.maxY = maxY;
     this.meshDimension = meshDimension;
-    this.meshFile = meshFile;
     this.elementOrder = elementOrder;
+    this.parsedMesh = parsedMesh;
   }
 
   /**
-   * Function to generate the mesh based on the dimension or parse a custom mesh file
+   * Function to generate the mesh based on the dimension or use a pre-parsed mesh
    * @returns {object} The generated mesh containing node coordinates and total nodes
    */
   generateMesh() {
-    if (this.meshFile) {
-      // If a mesh file is provided, check if it's a Gmsh (.msh) file and parse it
-      if ((typeof this.meshFile === 'string' && this.meshFile.toLowerCase().endsWith('.msh')) ||
-          (this.meshFile instanceof File && this.meshFile.name.toLowerCase().endsWith('.msh'))) {
-        return this.generateMeshFromMshFile(this.meshFile);
-      } else {
-        const errorMessage = "Only .msh files are supported for mesh import";
-        errorLog(errorMessage);
-        throw new Error(errorMessage);
-      }
+    // If pre-parsed mesh data is provided, use it directly
+    if (this.parsedMesh) {
+      return this.parsedMesh;
     } else {
       // Validate required geometry parameters based on mesh dimension
       if (this.meshDimension === "1D") {
@@ -88,19 +81,6 @@ export class meshGeneration {
     }
   }
 
-  /**
-   * Function to import a mesh from a Gmsh (.msh) file
-   * @param {string|File} file - Path or File object to the mesh file (.msh format)
-   * @returns {object} An object containing the coordinates of nodes,
-   * total number of nodes, nodal numbering (NOP) array, and boundary elements
-   */
-  async generateMeshFromMshFile(file) {
-    // Import mesh data from the Gmsh file
-    const outputMesh = await importGmshQuadTri(file);
-
-    return outputMesh;
-  }
-
   /**
    * Function to generate a structured mesh based on the geometry configuration
    * @returns {object} An object containing the coordinates of nodes,

src/solvers/solidHeatTransferScript.js

@@ -35,14 +35,9 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
     maxX, // Max x-coordinate (m) of the domain
     maxY, // Max y-coordinate (m) of the domain (only for 2D)
     elementOrder, // The order of elements
+    parsedMesh, // The pre-parsed mesh data (if available)
   } = meshConfig;
 
-  debugLog(
-    `Mesh configuration: ${meshDimension}, Elements: ${numElementsX}x${numElementsY || 1}, Size: ${maxX}x${
-      maxY || 0
-    }, Order: ${elementOrder}`
-  );
-
   // Create a new instance of the meshGeneration class
   debugLog("Generating mesh...");
   const meshGenerationData = new meshGeneration({
@@ -52,6 +47,7 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
     maxY,
     meshDimension,
     elementOrder,
+    parsedMesh, // Pass the parsed mesh to the mesh generator
   });
 
   // Generate the mesh
@@ -65,9 +61,27 @@ export function assembleSolidHeatTransferMat(meshConfig, boundaryConditions) {
   let nop = nodesCoordinatesAndNumbering.nodalNumbering;
   let boundaryElements = nodesCoordinatesAndNumbering.boundaryElements;
 
+  // Check the mesh type
+  const isParsedMesh = parsedMesh !== undefined && parsedMesh !== null;
+
+  // Calculate totalElements and totalNodes based on mesh type
+  let totalElements, totalNodes;
+
+  if (isParsedMesh) {
+    totalElements = nop.length; // Number of elements is the length of the nodal numbering array
+    totalNodes = nodesXCoordinates.length; // Number of nodes is the length of the coordinates array
+    
+    // Debug log for mesh size
+    debugLog(`Using parsed mesh with ${totalElements} elements and ${totalNodes} nodes`);
+  } else {
+    // For structured mesh, calculate based on dimensions
+    totalElements = numElementsX * (meshDimension === "2D" ? numElementsY : 1);
+    totalNodes = totalNodesX * (meshDimension === "2D" ? totalNodesY : 1);
+    // Debug log for mesh size
+    debugLog(`Using mesh generated from geometry with ${totalElements} elements and ${totalNodes} nodes`);
+  }
+
   // Initialize variables for matrix assembly
-  const totalElements = numElementsX * (meshDimension === "2D" ? numElementsY : 1); // Total number of elements
-  const totalNodes = totalNodesX * (meshDimension === "2D" ? totalNodesY : 1); // Total number of nodes
   let localNodalNumbers = []; // Local nodal numbering
   let gaussPoints = []; // Gauss points
   let gaussWeights = []; // Gauss weights