handy-diffusion 1.0.1 → 1.0.3

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

@@ -0,0 +1,118 @@
+/**
+ * Type definitions for handy-diffusion
+ */
+
+/**
+ * Set properties for the ADI (Alternating Direction Implicit) method
+ * @param width - Grid width
+ * @param height - Grid height
+ * @param diffusionCoefficient - Diffusion coefficient
+ * @param deltaX - Spatial step size
+ * @param deltaT - Time step size
+ * @param decayRate - Decay rate constant (default: 0)
+ */
+export function setADIProperties(
+    width: number,
+    height: number,
+    diffusionCoefficient: number,
+    deltaX: number,
+    deltaT: number,
+    decayRate?: number
+): void;
+
+/**
+ * Solve 2D diffusion equation using ADI method
+ * @param concentrationData - Concentration array (width * height)
+ * @param sources - Source terms array
+ * @param totalNumberOfIterations - Number of time steps
+ * @param allowNegativeValues - Whether to allow negative concentrations (default: false)
+ */
+export function ADI(
+    concentrationData: Float64Array | number[],
+    sources: Float64Array | number[],
+    totalNumberOfIterations: number,
+    allowNegativeValues?: boolean
+): void;
+
+/**
+ * Set properties for the Crank-Nicolson method (1D)
+ * @param length - Number of grid points
+ * @param diffusionCoefficient - Diffusion coefficient
+ * @param deltaX - Spatial step size
+ * @param deltaT - Time step size
+ * @param decayRate - Decay rate constant (default: 0)
+ */
+export function setCNProperties(
+    length: number,
+    diffusionCoefficient: number,
+    deltaX: number,
+    deltaT: number,
+    decayRate?: number
+): void;
+
+/**
+ * Solve 1D diffusion equation using Crank-Nicolson method
+ * @param concentrationData - Initial concentration values
+ * @param sources - Source terms
+ * @param totalNumberOfIterations - Number of time steps
+ * @param allowNegativeValues - Whether to allow negative concentrations (default: false)
+ */
+export function CrankNicolson(
+    concentrationData: Float64Array | number[],
+    sources: Float64Array | number[],
+    totalNumberOfIterations: number,
+    allowNegativeValues?: boolean
+): void;
+
+/**
+ * Calculate analytic steady-state solution
+ * @param WIDTH - Grid width
+ * @param HEIGHT - Grid height
+ * @param DIFFUSION_RATE - Diffusion rate
+ * @param DECAY_RATE - Decay rate
+ * @param deltaX - Spatial step size
+ * @param sources - Source terms array
+ * @param maxMode - Maximum mode for series expansion
+ * @returns Steady-state concentration array
+ */
+export function analyticSteadyState(
+    WIDTH: number,
+    HEIGHT: number,
+    DIFFUSION_RATE: number,
+    DECAY_RATE: number,
+    deltaX: number,
+    sources: Float64Array | number[],
+    maxMode: number
+): Float64Array;
+
+/**
+ * Calculate effective influence of sources
+ * @param width - Grid width
+ * @param height - Grid height
+ * @param sources - Source terms array
+ * @param lambda - Length scale parameter
+ * @param scale - Scaling factor
+ * @returns Effective influence array
+ */
+export function efectiveInfluence(
+    width: number,
+    height: number,
+    sources: Float64Array | number[],
+    lambda: number,
+    scale: number
+): 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/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,8 +1,9 @@
 {
   "name": "handy-diffusion",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "algorithms to simulate diffusion",
   "main": "index.js",
+  "types": "index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },