handy-diffusion 1.0.2 → 1.0.4

package/ADI.js

@@ -8,7 +8,8 @@ let modifiedUpperDiagonal2, modifiedRightHandSide2, solution2;
 let intermediateConcentration;
 let a1, b1, c1, d1;
 let a2, b2, c2, d2;
-let alpha, halfDeltaT, oneMinus2AlphaMinusGamma, scaledSources;
+let alpha, halfDeltaT, scaledSources;
+let gamma;
 
 export const setADIProperties = (
     width,
@@ -16,7 +17,7 @@ export const setADIProperties = (
     diffusionCoefficient,
     deltaX,
     deltaT,
-    decayRate = 0
+    decayRates = 0
 ) => {
     WIDTH = width;
     HEIGHT = height;
@@ -38,11 +39,39 @@ export const setADIProperties = (
         d2,
         alpha,
         halfDeltaT,
-        oneMinus2AlphaMinusGamma,
         scaledSources,
-    } = initADIArrays(WIDTH, HEIGHT, diffusionCoefficient, deltaX, deltaT, decayRate));
+        gamma,
+    } = initADIArrays(WIDTH, HEIGHT, diffusionCoefficient, deltaX, deltaT));
 };
 
+export const updateSinksAndSources = (sinks, sources) => {
+    for (let i = 0; i < WIDTH * HEIGHT; i++) {
+        gamma[i] = (sinks[i] * halfDeltaT) / 4;
+        scaledSources[i] = sources[i] * halfDeltaT;
+    }
+}
+const updateMainDiagonalXstep = (yCoord) => {
+    //update b1
+    for (let i = 0; i < WIDTH; i++) {
+        const idx = yCoord * WIDTH + i;
+        b1[i] = 1 + 2 * alpha + gamma[idx];
+    }
+    //boundary conditions
+    b1[0] = 1 + alpha + gamma[yCoord * WIDTH + 0];
+    b1[WIDTH - 1] = 1 + alpha + gamma[yCoord * WIDTH + (WIDTH - 1)];
+}
+
+const updateMainDiagonalYstep = (xCoord) => {
+    //update b2
+    for (let j = 0; j < HEIGHT; j++) {
+        const idx = j * WIDTH + xCoord;
+        b2[j] = 1 + 2 * alpha + gamma[idx];
+    }
+    //boundary conditions
+    b2[0] = 1 + alpha + gamma[0 * WIDTH + xCoord];
+    b2[HEIGHT - 1] = 1 + alpha + gamma[(HEIGHT - 1) * WIDTH + xCoord];
+}
+
 export const ADI = (
     concentrationData,
     sources,
@@ -72,10 +101,11 @@ export const ADI = (
 
                 d1[i] =
                     alpha * bottom +
-                    oneMinus2AlphaMinusGamma * center +
+                    (1 - 2 * alpha - gamma[idx]) * center +
                     alpha * top +
                     scaledSources[idx];
             }
+            updateMainDiagonalXstep(j);
 
             thomasAlgorithm(
                 a1,
@@ -104,7 +134,7 @@ export const ADI = (
 
             d1[i] =
                 alpha * bottom +
-                oneMinus2AlphaMinusGamma * center +
+                (1 - 2 * alpha - gamma[idx]) * center +
                 alpha * top +
                 scaledSources[idx];
         }
@@ -133,7 +163,7 @@ export const ADI = (
 
             d1[i] =
                 alpha * bottom +
-                oneMinus2AlphaMinusGamma * center +
+                (1 - 2 * alpha - gamma[idx]) * center +
                 alpha * top +
                 scaledSources[idx];
         }
@@ -165,11 +195,11 @@ export const ADI = (
 
                 d2[j] =
                     alpha * left +
-                    oneMinus2AlphaMinusGamma * center +
+                    (1 - 2 * alpha - gamma[idx]) * center +
                     alpha * right +
                     scaledSources[idx];
             }
-
+            updateMainDiagonalYstep(i);
             thomasAlgorithm(
                 a2,
                 b2,
@@ -201,7 +231,7 @@ export const ADI = (
 
             d2[j] =
                 alpha * left +
-                oneMinus2AlphaMinusGamma * center +
+                (1 - 2 * alpha - gamma[idx]) * center +
                 alpha * right +
                 scaledSources[idx];
         }
@@ -234,7 +264,7 @@ export const ADI = (
 
             d2[j] =
                 alpha * left +
-                oneMinus2AlphaMinusGamma * center +
+                (1 - 2 * alpha - gamma[idx]) * center +
                 alpha * right +
                 scaledSources[idx];
         }

package/index.d.ts

@@ -100,4 +100,19 @@ export function efectiveInfluence(
     sources: Float64Array | number[],
     lambda: number,
     scale: number
-): Float64Array;
+): Float64Array;
+
+/**
+ * Solve tridiagonal system using Thomas algorithm
+ * @param a - Sub-diagonal coefficients
+ * @param b - Main diagonal coefficients
+ * @param c - Super-diagonal coefficients
+ * @param d - Right-hand side values
+ * @returns Solution array
+ */
+export function thomasAlgorithm(
+    a: Float64Array | number[],
+    b: Float64Array | number[],
+    c: Float64Array | number[],
+    d: Float64Array | number[]
+): Float64Array;    

package/index.js

@@ -8,4 +8,7 @@ export { CrankNicolson, setCNProperties } from './CrankNicolson.js';
 export { analyticSteadyState } from './analyticSolution.js';
 
 // Import and re-export effective influence
-export { efectiveInfluence } from './effective.js';
+export { efectiveInfluence } from './effective.js';
+
+// Import and re-export thomas algorithm
+export { thomasAlgorithm } from './thomasAlgorithm.js';

package/initArrays.js

@@ -12,7 +12,7 @@ const generateDiagonals = (length, alpha, gamma) => {
     return { lowerDiagonal, mainDiagonal, upperDiagonal, rightHandSide };
 };
 
-export const initADIArrays = (WIDTH, HEIGHT, DIFFUSION_RATE, deltaX, deltaT, decayRate) => {
+export const initADIArrays = (WIDTH, HEIGHT, DIFFUSION_RATE, deltaX, deltaT) => {
     const modifiedUpperDiagonal1 = new Float64Array(WIDTH);
     const modifiedRightHandSide1 = new Float64Array(WIDTH);
     const solution1 = new Float64Array(WIDTH);
@@ -21,23 +21,23 @@ export const initADIArrays = (WIDTH, HEIGHT, DIFFUSION_RATE, deltaX, deltaT, dec
     const solution2 = new Float64Array(HEIGHT);
     const intermediateConcentration = new Float64Array(WIDTH * HEIGHT);
     const scaledSources = new Float64Array(WIDTH * HEIGHT);
+    const gamma = new Float64Array(WIDTH * HEIGHT).fill(0);
 
     const alpha = (DIFFUSION_RATE * deltaT) / (2 * deltaX * deltaX);
-    const gamma = (decayRate * deltaT) / 4;
+    const gammaPoint = 0;
     const {
         lowerDiagonal: a1,
         mainDiagonal: b1,
         upperDiagonal: c1,
         rightHandSide: d1,
-    } = generateDiagonals(WIDTH, alpha, gamma);
+    } = generateDiagonals(WIDTH, alpha, gammaPoint);
     const {
         lowerDiagonal: a2,
         mainDiagonal: b2,
         upperDiagonal: c2,
         rightHandSide: d2,
-    } = generateDiagonals(HEIGHT, alpha, gamma);
+    } = generateDiagonals(HEIGHT, alpha, gammaPoint);
     const halfDeltaT = deltaT / 2;
-    const oneMinus2AlphaMinusGamma = 1 - 2 * alpha - gamma;
     return {
         modifiedUpperDiagonal1,
         modifiedRightHandSide1,
@@ -56,8 +56,8 @@ export const initADIArrays = (WIDTH, HEIGHT, DIFFUSION_RATE, deltaX, deltaT, dec
         d2,
         alpha,
         halfDeltaT,
-        oneMinus2AlphaMinusGamma,
         scaledSources,
-        deltaT,
+        gamma,
     };
 };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "handy-diffusion",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "algorithms to simulate diffusion",
   "main": "index.js",
   "types": "index.d.ts",