create a importing a simple gmsh file v4.1 for quadrilateral mesh file

Author: sridhar-mani

src/mesh/meshGenerationScript.js

@@ -11,6 +11,11 @@
 /**
  * Class to handle the generation of structured finite element meshes
  */
+
+
+import { importGmsh } from '../readers/gmshQuadReader';
+
+
 export class meshGeneration {
   /**
    * Constructor to initialize the meshGeneration class
@@ -84,6 +89,19 @@ export class meshGeneration {
     };
   }
 
+ /**
+   * Generate a structured mesh based on the msh file
+   * @returns {object} An object containing the coordinates of nodes,
+   * total number of nodes, nodal numbering (NOP) array, and boundary elements
+   */
+  async generateMeshFromMshFile(file){
+
+    //for now i have made a parsing of simple quadrilateral .msh file of version 4.1
+    const outputMesh = await importGmsh(file)  
+
+    return outputMesh
+  }
+
   /**
    * Generate a structured mesh based on the geometry configuration
    * @returns {object} An object containing the coordinates of nodes,

src/readers/gmshQuadReader.js

@@ -0,0 +1,153 @@
+const importGmsh = async (file) => {
+  let newFin = {
+    nodesXCoordinates: [],
+    nodesYCoordinates: [],
+    nodalNumbering: [],
+    boundaryElements: [],
+    gmshV: 0,
+    ascii: false,
+    fltBytes: 8,
+    totalNodesX:0,
+    totalNodesY:0
+  };
+  let textre = await file.text();
+  textre = textre
+    .split("\n")
+    .map((eachLine) => eachLine.trim())
+    .filter((eachLine) => eachLine != "" && eachLine != " ");
+
+  let inNodesSections = false;
+
+  let inElementsSecitons = false;
+
+  let inMeshSections = false;
+
+  let lineNumber = 0;
+
+  for (let line of textre) {
+    if (line == "$MeshFormat") {
+      inMeshSections = true;
+      continue;
+    }
+    if (line == "$EndMeshFormat") {
+      lineNumber = 0;
+      inMeshSections = false;
+      continue;
+    }
+    if (line == "$Nodes") {
+      inNodesSections = true;
+      continue;
+    }
+    if (line == "$EndNodes") {
+      lineNumber = 0;
+      inNodesSections = false;
+      continue;
+    }
+    if (line == "$Elements") {
+      inElementsSecitons = true;
+      continue;
+    }
+    if (line == "$EndElements") {
+      lineNumber = 0;
+
+      inElementsSecitons = false;
+      continue;
+    }
+    lineNumber = lineNumber + 1;
+    if (inMeshSections) {
+      let temp = line.split(" ");
+      let gmshVersion = parseFloat(temp[0]);
+      let asciiOr = temp[1] === "0" ? true : false;
+      let fltBytesOr = temp[2];
+
+      newFin.gmshV = gmshVersion;
+      newFin.ascii = asciiOr;
+      newFin.fltBytes = fltBytesOr;
+    }
+    let temp = line.split(" ");
+    if (inNodesSections) {
+      if (temp.length === 3) {
+        newFin.totalNodesX += 1;
+        newFin.totalNodesY += 1;
+        newFin.nodesXCoordinates = [
+          ...newFin.nodesXCoordinates,
+          parseFloat(temp[0]),
+        ];
+        newFin.nodesYCoordinates = [
+          ...newFin.nodesYCoordinates,
+          parseFloat(temp[1]),
+        ];
+      }
+    }
+
+    if (inElementsSecitons) {
+      if (temp.length === 5) {
+        newFin.nodalNumbering = [
+          ...newFin.nodalNumbering,
+          temp.slice(1).map((num) => parseInt(num, 10)),
+        ];
+      }
+    }
+  }
+
+
+  // const taichiRunner = new TaichiRunner();
+  // await taichiRunner.init();
+
+  // await taichiRunner.addToScope({ newFin, tempBoundary });
+
+  // const useKernel = await taichiRunner.createKernel(() => {
+    const edgeCount = {};
+    for (let i = 0; i < newFin.nodalNumbering.length; i++) {
+      const element = newFin.nodalNumbering[i];
+      const edges = [
+        [element[0], element[1]],
+        [element[1], element[2]],
+        [element[2], element[3]],
+        [element[3], element[0]],
+      ];
+      edges.forEach((edge) => {
+        const key =
+          edge[0] < edge[1]
+            ? `${edge[0]}-${edge[1]}`
+            : `${edge[1]}-${edge[0]}`;
+        edgeCount[key] = (edgeCount[key] || 0) + 1;
+      });
+    }
+  
+    newFin.boundaryElements = []; 
+    for (let i = 0; i < newFin.nodalNumbering.length; i++) {
+      const element = newFin.nodalNumbering[i];
+      const edges = [
+        [element[0], element[1]],
+        [element[1], element[2]],
+        [element[2], element[3]],
+        [element[3], element[0]],
+      ];
+      for (let j = 0; j < edges.length; j++) {
+        const edge = edges[j];
+        const key =
+          edge[0] < edge[1]
+            ? `${edge[0]}-${edge[1]}`
+            : `${edge[1]}-${edge[0]}`;
+        if (edgeCount[key] === 1) {
+          if (!newFin.boundaryElements[i]) {
+            newFin.boundaryElements[i] = [];
+          }
+          newFin.boundaryElements[i].push([i, j]);
+        }
+      }
+    }
+  
+    newFin.boundaryElements = newFin.boundaryElements.filter((each) => each);
+  
+  // });
+
+  // if (useKernel) {
+  //   await taichiRunner.runKernel(useKernel);
+  // }
+
+  return newFin;
+};
+
+export { importGmsh };