Refactor solidHeatTransferScript.js to implement convection, constant temperature and symmetry boundary conditions

Author: nikoscham

src/solvers/solidHeatTransferScript.js

@@ -38,10 +38,13 @@ export function assembleSolidHeatTrasnferMat(
     topBoundary,
     bottomBoundary,
     leftBoundary,
-    rightBoundary,
-    robinHeatTranfCoeff,
-    robinExtTemp,
+    rightBoundary
   } = boundaryConditions;
+  let convectionHeatTranfCoeff = topBoundary[1];
+  let convectionExtTemp = topBoundary[2];
+
+  console.log("convectionHeatTranfCoeff:", convectionHeatTranfCoeff);
+  console.log("convectionExtTemp:", convectionExtTemp);
 
   // Create a new instance of the meshGeneration class
   const meshGenerationData = new meshGeneration({
@@ -72,12 +75,12 @@ export function assembleSolidHeatTrasnferMat(
   // Initialize variables for matrix assembly
   const ne = numElementsX * numElementsY; // Total number of elements
   const np = totalNodesX * totalNodesY; // Total number of nodes
-  let robinBoundaryFlagTop = new Array(ne).fill(0); // Robin boundary condition flag (elements at the top side of the domain)
-  let robinBoundaryFlagBottom = new Array(ne).fill(0); // Robin boundary condition flag (elements at the bottom side of the domain)
-  let robinBoundaryFlagLeft = new Array(ne).fill(0); // Robin boundary condition flag (elements at the left side of the domain)
-  let robinBoundaryFlagRight = new Array(ne).fill(0); // Robin boundary condition flag (elements at the right side of the domain)
-  let dirichletBoundaryFlag = new Array(np).fill(0); // Dirichlet boundary condition flag
-  let dirichletBoundaryValue = new Array(np).fill(0); // Dirichlet boundary condition value
+  let convectionBoundaryFlagTop = new Array(ne).fill(0); // Convection boundary condition flag (elements at the top side of the domain)
+  let convectionBoundaryFlagBottom = new Array(ne).fill(0); // Convection boundary condition flag (elements at the bottom side of the domain)
+  let convectionBoundaryFlagLeft = new Array(ne).fill(0); // Convection boundary condition flag (elements at the left side of the domain)
+  let convectionBoundaryFlagRight = new Array(ne).fill(0); // Convection boundary condition flag (elements at the right side of the domain)
+  let constantTempBoundaryFlag = new Array(np).fill(0); // ConstantTemp boundary condition flag
+  let constantTempBoundaryValue = new Array(np).fill(0); // ConstantTemp boundary condition value
   let localNodalNumbers = []; // Local nodal numbering
   let gaussPoints = []; // Gauss points
   let gaussWeights = []; // Gauss weights
@@ -123,41 +126,41 @@ export function assembleSolidHeatTrasnferMat(
   gaussPoints = gaussPointsAndWeights.gaussPoints;
   gaussWeights = gaussPointsAndWeights.gaussWeights;
 
-  // Check for elements to impose Robin boundary conditions
+  // Check for elements to impose Convection boundary conditions
   for (
     let i = 0;
     i < ne - numElementsY;
     i += numElementsY // Elements along yCoordinates=yStart (bottom side of the domain)
   ) {
-    if (bottomBoundary[0] == "robin") {
-      robinBoundaryFlagBottom[i] = 1;
+    if (bottomBoundary[0] == "convection") {
+      convectionBoundaryFlagBottom[i] = 1;
     }
   }
   for (
     let i = 0;
     i < numElementsY;
     i++ // Elements along xCoordinates=xStart (left side of the domain)
   ) {
-    if (leftBoundary[0] == "robin") {
-      robinBoundaryFlagLeft[i] = 1;
+    if (leftBoundary[0] == "convection") {
+      convectionBoundaryFlagLeft[i] = 1;
     }
   }
   for (
     let i = numElementsY - 1;
     i < ne;
     i += numElementsY // Elements along yCoordinates=maxY (top side of the domain)
   ) {
-    if (topBoundary[0] == "robin") {
-      robinBoundaryFlagTop[i] = 1;
+    if (topBoundary[0] == "convection") {
+      convectionBoundaryFlagTop[i] = 1;
     }
   }
   for (
     let i = ne - numElementsY;
     i < ne;
     i++ // Elements along xCoordinates=maxX (right side of the domain)
   ) {
-    if (rightBoundary[0] == "robin") {
-      robinBoundaryFlagRight[i] = 1;
+    if (rightBoundary[0] == "convection") {
+      convectionBoundaryFlagRight[i] = 1;
     }
   }
 
@@ -236,38 +239,38 @@ export function assembleSolidHeatTrasnferMat(
       }
     }
 
-    // Impose Robin boundary conditions
+    // Impose Convection boundary conditions
     if (
-      robinBoundaryFlagTop[i] == 1 ||
-      robinBoundaryFlagBottom[i] == 1 ||
-      robinBoundaryFlagLeft[i] == 1 ||
-      robinBoundaryFlagRight[i] == 1
+      convectionBoundaryFlagTop[i] == 1 ||
+      convectionBoundaryFlagBottom[i] == 1 ||
+      convectionBoundaryFlagLeft[i] == 1 ||
+      convectionBoundaryFlagRight[i] == 1
     ) {
       for (let l = 0; l < 3; l++) {
         let gp1, gp2, firstNode, finalNode, nodeIncr;
         // Set gp1 and gp2 based on boundary conditions
-        if (robinBoundaryFlagTop[i] == 1) {
+        if (convectionBoundaryFlagTop[i] == 1) {
           // Set gp1 and gp2 for elements at the top side of the domain (nodes 2, 5, 8)
           gp1 = gaussPoints[l];
           gp2 = 1;
           firstNode = 2;
           finalNode = 9; // final node minus one
           nodeIncr = 3;
-        } else if (robinBoundaryFlagBottom[i] == 1) {
+        } else if (convectionBoundaryFlagBottom[i] == 1) {
           // Set gp1 and gp2 for elements at the bottom side of the domain (nodes 0, 3, 6)
           gp1 = gaussPoints[l];
           gp2 = 0;
           firstNode = 0;
           finalNode = 7;
           nodeIncr = 3;
-        } else if (robinBoundaryFlagLeft[i] == 1) {
+        } else if (convectionBoundaryFlagLeft[i] == 1) {
           // Set gp1 and gp2 for elements at the left side of the domain (nodes 0, 1, 2)
           gp1 = 0;
           gp2 = gaussPoints[l];
           firstNode = 0;
           finalNode = 3;
           nodeIncr = 1;
-        } else if (robinBoundaryFlagRight[i] == 1) {
+        } else if (convectionBoundaryFlagRight[i] == 1) {
           // Set gp1 and gp2 for elements at the right side of the domain (nodes 6, 7, 8)
           gp1 = 1;
           gp2 = gaussPoints[l];
@@ -298,68 +301,68 @@ export function assembleSolidHeatTrasnferMat(
             -gaussWeights[l] *
             ksiDerivX *
             basisFunction[m] *
-            robinHeatTranfCoeff *
-            robinExtTemp; // Add the Robin boundary term to the residual vector
+            convectionHeatTranfCoeff *
+            convectionExtTemp; // Add the Convection boundary term to the residual vector
           for (let n = firstNode; n < finalNode; n += nodeIncr) {
             let n1 = localNodalNumbers[n];
             jacobianMatrix[m1][n1] +=
               -gaussWeights[l] *
               ksiDerivX *
               basisFunction[m] *
               basisFunction[n] *
-              robinHeatTranfCoeff; // Add the Robin boundary term to the Jacobian matrix
+              convectionHeatTranfCoeff; // Add the Convection boundary term to the Jacobian matrix
           }
         }
       }
     }
   }
 
-  // Check for elements to impose Dirichlet boundary conditions
+  // Check for elements to impose ConstantTemp boundary conditions
   for (
     let i = 0;
     i < np - totalNodesY + 1;
-    i += totalNodesY // Define dirichletBoundaryFlag and dirichletBoundaryValue for nodes on yCoordinates=yStart (bottom side of the domain)
+    i += totalNodesY // Define constantTempBoundaryFlag and constantTempBoundaryValue for nodes on yCoordinates=yStart (bottom side of the domain)
   ) {
-    if (bottomBoundary[0] == "dirichlet") {
-      dirichletBoundaryFlag[i] = 1;
-      dirichletBoundaryValue[i] = bottomBoundary[1];
+    if (bottomBoundary[0] == "constantTemp") {
+      constantTempBoundaryFlag[i] = 1;
+      constantTempBoundaryValue[i] = bottomBoundary[1];
     }
   }
   for (
     let i = 0;
     i < totalNodesY;
-    i++ // Define dirichletBoundaryFlag and dirichletBoundaryValue for nodes on xCoordinates=xStart (left side of the domain)
+    i++ // Define constantTempBoundaryFlag and constantTempBoundaryValue for nodes on xCoordinates=xStart (left side of the domain)
   ) {
-    if (leftBoundary[0] == "dirichlet") {
-      dirichletBoundaryFlag[i] = 1;
-      dirichletBoundaryValue[i] = leftBoundary[1];
+    if (leftBoundary[0] == "constantTemp") {
+      constantTempBoundaryFlag[i] = 1;
+      constantTempBoundaryValue[i] = leftBoundary[1];
     }
   }
   for (
     let i = totalNodesY - 1;
     i < np;
-    i += totalNodesY // Define dirichletBoundaryFlag and dirichletBoundaryValue for nodes on yCoordinates=maxY (top side of the domain)
+    i += totalNodesY // Define constantTempBoundaryFlag and constantTempBoundaryValue for nodes on yCoordinates=maxY (top side of the domain)
   ) {
-    if (topBoundary[0] == "dirichlet") {
-      dirichletBoundaryFlag[i] = 1;
-      dirichletBoundaryValue[i] = topBoundary[1];
+    if (topBoundary[0] == "constantTemp") {
+      constantTempBoundaryFlag[i] = 1;
+      constantTempBoundaryValue[i] = topBoundary[1];
     }
   }
   for (
     let i = np - totalNodesY;
     i < np;
-    i++ // Define dirichletBoundaryFlag and dirichletBoundaryValue for nodes on xCoordinates=maxX (right side of the domain)
+    i++ // Define constantTempBoundaryFlag and constantTempBoundaryValue for nodes on xCoordinates=maxX (right side of the domain)
   ) {
-    if (rightBoundary[0] == "dirichlet") {
-      dirichletBoundaryFlag[i] = 1;
-      dirichletBoundaryValue[i] = rightBoundary[1];
+    if (rightBoundary[0] == "constantTemp") {
+      constantTempBoundaryFlag[i] = 1;
+      constantTempBoundaryValue[i] = rightBoundary[1];
     }
   }
 
-  // Impose Dirichlet boundary conditions
+  // Impose ConstantTemp boundary conditions
   for (let i = 0; i < np; i++) {
-    if (dirichletBoundaryFlag[i] == 1) {
-      residualVector[i] = dirichletBoundaryValue[i]; // Set the residual vector to the Dirichlet value
+    if (constantTempBoundaryFlag[i] == 1) {
+      residualVector[i] = constantTempBoundaryValue[i]; // Set the residual vector to the ConstantTemp value
       for (let j = 0; j < np; j++) {
         jacobianMatrix[i][j] = 0; // Set the Jacobian matrix to zero
         jacobianMatrix[i][i] = 1; // Set the diagonal entry to one