@woosh/meep-engine 2.130.0 → 2.131.0

package/src/core/math/physics/mie/compute_bhmie_optical_properties.js

@@ -0,0 +1,151 @@
+
+// Complex arithmetic helpers (a,b represent a + i b)
+function cadd(a, b) { return [a[0] + b[0], a[1] + b[1]]; }
+function csub(a, b) { return [a[0] - b[0], a[1] - b[1]]; }
+function cmul(a, b) { return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]]; }
+function cdiv(a, b) { const d = b[0]*b[0] + b[1]*b[1]; return [(a[0]*b[0] + a[1]*b[1]) / d, (a[1]*b[0] - a[0]*b[1]) / d]; }
+function creal(a) { return a[0]; }
+function cabs2(a) { return a[0]*a[0] + a[1]*a[1]; }
+
+
+/**
+ * Canonical Bohren–Huffman Mie solver (reference implementation)
+ * Computes scattering/extinction cross-sections and asymmetry parameter for a
+ * homogeneous sphere embedded in a host medium.
+ *
+ * @param {number} wavelength Vacuum wavelength (meters)
+ * @param {number} radius Sphere radius (meters)
+ * @param {[number,number]} n_p Particle complex RI [n, k]
+ * @param {[number,number]} n_med Medium complex RI [n, k]
+ * @returns {{sigma_a_med:number, C_ext:number, C_sca:number, g:number}}
+ */
+export function compute_bhmie_optical_properties(wavelength, radius, n_p, n_med) {
+  // Geometry
+  const k0 = 2 * Math.PI / wavelength;
+  const nmed_r = n_med[0];
+  const x = k0 * nmed_r * radius; // size parameter in the (weakly absorbing) medium
+
+  if (!(x > 0)) {
+    return { sigma_a_med: 4 * Math.PI * n_med[1] / wavelength, C_ext: 0, C_sca: 0, g: 0 };
+  }
+
+  // Relative refractive index m = n_p / n_med
+  const m = cdiv([n_p[0], n_p[1]], [n_med[0], n_med[1]]);
+  // mx is complex (m * x)
+  const mx = [m[0] * x, m[1] * x];
+
+  // Truncation for series
+  const nstop = Math.max(2, Math.round(x + 4.0 * Math.cbrt(x) + 2));
+
+  // Downward recurrence for D_n(mx) = ψ'_n(mx)/ψ_n(mx), complex n from nstop..1
+  const D = new Array(nstop + 1);
+  D[nstop] = [0, 0];
+  for (let n = nstop; n >= 1; --n) {
+    // D_{n-1} = n/(mx) - 1 / (D_n + n/(mx))
+    const n_over_mx = cdiv([n, 0], mx);
+    const denom = cadd(D[n], n_over_mx);
+    const invDen = cdiv([1, 0], denom);
+    D[n - 1] = csub(n_over_mx, invDen);
+  }
+
+  // Upward recurrence for real ψ_n(x) and complex ξ_n(x) at real x
+  const sx = Math.sin(x);
+  const cx = Math.cos(x);
+  // ψ_0, ψ_1 (real)
+  let psi_nm1 = sx;                      // ψ_0
+  let psi_n = sx / x - cx;               // ψ_1
+  // ξ_0, ξ_1 (complex): ξ_n = ψ_n + i χ_n, with χ_0 = -cos x, χ_1 = -cos x / x - sin x
+  let xi_nm1 = [sx, -cx];                // ξ_0
+  let xi_n = [psi_n, -(cx / x + sx)];    // ξ_1
+
+  // Sums
+  let sum_ext = 0; // Σ (2n+1) Re(a_n + b_n)
+  let sum_sca = 0; // Σ (2n+1) (|a_n|^2 + |b_n|^2)
+
+  const a = new Array(nstop + 1); // 1..nstop
+  const b = new Array(nstop + 1);
+
+  for (let n = 1; n <= nstop; ++n) {
+    // Next ψ and ξ (prepare ψ_{n+1}, ξ_{n+1}) using recurrence
+    const two_n_plus_1 = 2 * n + 1;
+    const psi_np1 = two_n_plus_1 * psi_n / x - psi_nm1; // ψ_{n+1}
+    const xi_np1 = [ (two_n_plus_1 / x) * xi_n[0] - xi_nm1[0], (two_n_plus_1 / x) * xi_n[1] - xi_nm1[1] ]; // ξ_{n+1}
+
+    // Derivatives at x (real x): ψ'_n = ψ_{n-1} - n/x ψ_n ; ξ'_n = ξ_{n-1} - n/x ξ_n
+    const n_over_x = n / x;
+    const psi_prime = psi_nm1 - n_over_x * psi_n;
+    const xi_prime = [xi_nm1[0] - n_over_x * xi_n[0], xi_nm1[1] - n_over_x * xi_n[1]];
+
+    // Log-derivative at mx
+    const Dn = D[n];
+
+    // Compute a_n and b_n using D-forms (no ψ_n(mx) factors)
+    // a_n = [m ψ'_n(x) − D(mx) ψ_n(x)] / [m ξ'_n(x) − D(mx) ξ_n(x)]
+    const m_psi_prime = [m[0] * psi_prime, m[1] * psi_prime];
+    const Dn_psi_n = [Dn[0] * psi_n, Dn[1] * psi_n];
+    const num_a = csub(m_psi_prime, Dn_psi_n);
+    const m_xi_prime = cmul(m, xi_prime);
+    const Dn_xi_n = cmul(Dn, xi_n);
+    const den_a = csub(m_xi_prime, Dn_xi_n);
+    const a_n = cdiv(num_a, den_a);
+
+    // b_n = [ψ'_n(x) − m D(mx) ψ_n(x)] / [ξ'_n(x) − m D(mx) ξ_n(x)]
+    const mDn = cmul(m, Dn);
+    const mDn_psi_n = [mDn[0] * psi_n, mDn[1] * psi_n];
+    const num_b = csub([psi_prime, 0], mDn_psi_n);
+    const mDn_xi_n = cmul(mDn, xi_n);
+    const den_b = csub(xi_prime, mDn_xi_n);
+    const b_n = cdiv(num_b, den_b);
+
+    a[n] = a_n;
+    b[n] = b_n;
+
+    const weight = 2 * n + 1;
+    sum_ext += weight * (creal(a_n) + creal(b_n));
+    sum_sca += weight * (cabs2(a_n) + cabs2(b_n));
+
+    // Shift recurrences (n→n+1)
+    psi_nm1 = psi_n;
+    psi_n = psi_np1;
+    xi_nm1 = xi_n;
+    xi_n = xi_np1;
+  }
+
+  const x2 = x * x;
+  const Q_ext = (2 / x2) * sum_ext;
+  const Q_sca = (2 / x2) * sum_sca;
+
+  // Asymmetry parameter g using BH expression
+  // sum_g accumulates the two standard terms:
+  //  Σ (2n+1)/(n(n+1)) Re(a_n b_n*) + Σ n(n+2)/(n+1) Re(a_n a_{n+1}* + b_n b_{n+1}*)
+  let sum_g = 0;
+  for (let n = 1; n <= nstop; ++n) {
+    const a_n = a[n];
+    const b_n = b[n];
+    const re_ab = a_n[0]*b_n[0] + a_n[1]*b_n[1]; // Re(a_n b_n*)
+    sum_g += ((2*n + 1) / (n * (n + 1))) * re_ab;
+  }
+  for (let n = 1; n <= nstop - 1; ++n) {
+    const a_n = a[n], a_np1 = a[n+1];
+    const b_n = b[n], b_np1 = b[n+1];
+    const re_aa1 = a_n[0]*a_np1[0] + a_n[1]*(-a_np1[1]); // Re(a_n a_{n+1}*)
+    const re_bb1 = b_n[0]*b_np1[0] + b_n[1]*(-b_np1[1]); // Re(b_n b_{n+1}*)
+    sum_g += (n * (n + 2)) / (n + 1) * (re_aa1 + re_bb1);
+  }
+
+  // Using relation g = 2 * sum_g / sum_sca to avoid re-scaling by x^2
+  let g = 0;
+  if (sum_sca > 1e-30) {
+    g = (2 * sum_g) / sum_sca;
+    if (g > 1) g = 1;
+    if (g < -1) g = -1;
+  }
+
+  const area = Math.PI * radius * radius;
+  const C_ext = Q_ext * area;
+  const C_sca = Q_sca * area;
+
+  const sigma_a_med = (4 * Math.PI * n_med[1]) / wavelength;
+
+  return { sigma_a_med, C_ext, C_sca, g };
+}

package/src/core/math/physics/mie/compute_lorenz_mie_optical_properties.d.ts

@@ -0,0 +1,12 @@
+/**
+ * For refractive index, the imaginary part controls the absorption coefficient.
+ * For non-absorbing media, such as pure water - this will be 0.
+ *
+ * Note: for most different types of media (and particles), the refractive index will depend on wavelength.
+ * @param {number} wavelength (in meters)
+ * @param {number} radius (in meters)
+ * @param {number[]} n_p 2d vector, complex refractive index of the particle
+ * @param {number[]} n_med 2d vector, complex refractive index of the medium (e.g. [1.0, 0.0] for air)
+ */
+export function compute_lorenz_mie_optical_properties(wavelength: number, radius: number, n_p: number[], n_med: number[]): any;
+//# sourceMappingURL=compute_lorenz_mie_optical_properties.d.ts.map

package/src/core/math/physics/mie/compute_lorenz_mie_optical_properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_lorenz_mie_optical_properties.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_lorenz_mie_optical_properties.js"],"names":[],"mappings":"AAsVA;;;;;;;;;GASG;AACH,kEALW,MAAM,UACN,MAAM,OACN,MAAM,EAAE,SACR,MAAM,EAAE,OAWlB"}

package/src/core/math/physics/mie/compute_lorenz_mie_optical_properties.js

@@ -0,0 +1,363 @@
+import { assert } from "../../../assert.js";
+import { v2_dot } from "../../../geom/vec2/v2_dot.js";
+import { v2_length } from "../../../geom/vec2/v2_length.js";
+import { complex_add } from "../../complex/complex_add.js";
+import { complex_div } from "../../complex/complex_div.js";
+import { complex_mul } from "../../complex/complex_mul.js";
+import { complex_sub } from "../../complex/complex_sub.js";
+
+// Complex number operations
+
+function vec2(x, y) {
+    return new Float64Array([x, y]);
+}
+
+function vec4(x, y, z, w) {
+    return new Float64Array([x, y, z, w]);
+}
+
+function cadd(a, b) {
+    const r = vec2(0, 0);
+
+    complex_add(r, a, b);
+
+    return r;
+}
+
+function csub(a, b) {
+    const r = vec2(0, 0);
+
+
+    complex_sub(r, a, b);
+
+    return r;
+}
+
+function cmult(a, b) {
+    const r = vec2(0, 0);
+
+
+    complex_mul(r, a, b);
+
+    return r;
+}
+
+function cdiv(a, b) {
+    const r = vec2(0, 0);
+
+
+    complex_div(r, a, b);
+
+    return r;
+}
+
+// Number of terms to include in infinite sums (truncation)
+function terms_to_sum(z) {
+    const size = v2_length(z[0], z[1]);
+    return Math.ceil(size + 4.3 * Math.cbrt(size) + 1.0);
+}
+
+
+// Downward recurrence for A
+function A_all_n(z, M) {
+    const A = new Array(M + 2);
+    A[M + 1] = vec2(0.0, 0.0);
+    for (let n = M; n >= 0; --n) {
+        const tmp = cdiv(vec2(n + 1.0, 0.0), z);
+        A[n] = csub(tmp, cdiv(vec2(1.0, 0.0), cadd(tmp, A[n + 1])));
+    }
+    return A;
+}
+
+// Upward recurrences for B, psi_zeta, and R
+function psi_zeta(n, z, A, old_B, old_psi_zeta) {
+    if (n > 0) {
+        const n_z = cdiv(vec2(n, 0.0), z);
+        const tmp = cmult(csub(n_z, A[n - 1]), csub(n_z, old_B));
+        old_psi_zeta = cmult(old_psi_zeta, tmp);
+    }
+    return old_psi_zeta;
+}
+
+/**
+ * Calculates the B_n(z) coefficient for term 'n' via upward recurrence.
+ * This is a helper function for LorenzMie_ab.
+ *
+ * @param {number} n - The current recurrence term index (n >= 0).
+ * @param {vec2} z - The complex size parameter (x or y).
+ * @param {Array<vec2>} A - Pre-computed log-derivatives A_n(z).
+ * @param {vec2} old_B - The previous B coefficient (B_{n-1}).
+ * @param {vec2} old_psi_zeta - The previous psi_zeta product term.
+ * @returns {vec2} The new B_n coefficient (complex number).
+ */
+function B(n, z, A, old_B, old_psi_zeta) {
+
+    if (n > 0) {
+        old_B.psi_zeta = psi_zeta(n, z, A, old_B, old_psi_zeta);
+        old_B = cadd(A[n], cdiv(vec2(0.0, 1.0), old_B.psi_zeta));
+    }
+
+    return old_B;
+}
+
+/**
+ * Calculates the R_n(z) coefficient (ratio psi_n / zeta_n) for term 'n'.
+ * This is a helper function for LorenzMie_ab.
+ *
+ * @param {number} n - The current recurrence term index (n >= 0).
+ * @param {vec2} z - The complex size parameter (x).
+ * @param {Array<vec2>} A - Pre-computed log-derivatives A_n(z).
+ * @param {vec2} B_n - The current B_n(z) coefficient.
+ * @param {vec2} old_R - The previous R coefficient (R_{n-1}).
+ * @returns {vec2} The new R_n coefficient (complex number).
+ */
+function R(n, z, A, B_n, old_R) {
+    if (n > 0) {
+        const n_z = cdiv(vec2(n, 0.0), z);
+        const tmp = cdiv(cadd(B_n, n_z), cadd(A[n], n_z));
+        old_R = cmult(old_R, tmp);
+    }
+    return old_R;
+}
+
+/**
+ * Calculates the Lorenz-Mie scattering coefficients a_n and b_n for a single term 'n'.
+ * This implements the formulas from Figure 3 of Frisvad et al. 2007.
+ *
+ * @param {number} n - The current recurrence term index (n >= 0).
+ * @param {number} size - Unitless size parameter x_vac = 2*pi*r / lambda_vac.
+ * @param {vec2} n_p - Complex refractive index of the particle.
+ * @param {vec2} n_med - Complex refractive index of the medium.
+ * @param {Array<vec2>} A_p - Pre-computed log-derivatives A_n(y) for the particle.
+ * @param {Array<vec2>} A_med - Pre-computed log-derivatives A_n(x) for the medium.
+ * @param {vec2} old_B - The previous B_{n-1}(x) coefficient.
+ * @param {vec2} old_R - The previous R_{n-1}(x) coefficient.
+ * @param {vec2} old_psi_zeta - The previous psi_zeta product.
+ * @returns {vec4} A vec4 [Re(a_n), Im(a_n), Re(b_n), Im(b_n)] with state properties
+ * (.old_B, .old_R, .old_psi_zeta) attached for the next iteration.
+ */
+function LorenzMie_ab(n, size, n_p, n_med, A_p, A_med, old_B, old_R, old_psi_zeta) {
+
+    const x = vec2(size * n_med[0], size * n_med[1]);
+    const B_n = B(n, x, A_med, old_B, old_psi_zeta);
+    const R_n = R(n, x, A_med, B_n, old_R);
+    const n_med_A_p = cmult(n_med, A_p[n]);
+    const n_p_A_med = cmult(n_p, A_med[n]);
+    const n_p_A_p = cmult(n_p, A_p[n]);
+    const n_med_A_med = cmult(n_med, A_med[n]);
+    const n_p_B_n = cmult(n_p, B_n);
+    const n_med_B_n = cmult(n_med, B_n);
+    const a = cmult(R_n, cdiv(csub(n_med_A_p, n_p_A_med), csub(n_med_A_p, n_p_B_n)));
+    const b = cmult(R_n, cdiv(csub(n_p_A_p, n_med_A_med), csub(n_p_A_p, n_med_B_n)));
+
+
+    const ab = vec4(a[0], a[1], b[0], b[1]);
+
+    ab.old_psi_zeta = n > 0 ? old_B.psi_zeta : old_psi_zeta;
+    ab.old_B = B_n;
+    ab.old_R = R_n;
+
+    return ab;
+}
+
+/**
+ * The following source code implements Lorenz-Mie theory using the formulas presented in the SIGGRAPH 2007 paper
+ *
+ * Computing the Scattering Properties of Participating
+ * Media Using Lorenz-Mie Theory
+ *
+ * By authors: Jeppe Revall Frisvad
+ *             Niels Joergen Christensen
+ *             Henrik Wann Jensen
+ *
+ * Code written by Jeppe Revall Frisvad, 2017.
+ * Copyright (c) Jeppe Revall Frisvad 2017
+ *
+ * Permission is granted to anyone to use this code as
+ * software for any purpose, including commercial applications.
+ * However, the software is provided 'as-is' without any warranty.
+ *
+ * @param {number} radius_m - Particle radius (in meters).
+ * @param {number} wavelength_m - Wavelength of light in vacuum (in meters).
+ * @param {vec2} n_p - Complex refractive index of the particle
+ * @param {vec2} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
+ */
+function lorenz_mie_coefs(
+    wavelength_m,
+    radius_m,
+    n_p,
+    n_med
+) {
+
+    assert.isNumber(wavelength_m, 'wavelength_m');
+    assert.isFinite(wavelength_m, 'wavelength_m');
+    assert.greaterThan(wavelength_m, 0, 'wavelength_m');
+
+    assert.isNumber(radius_m, 'radius_m');
+    assert.isFinite(radius_m, 'radius_m');
+    assert.greaterThan(radius_m, 0, 'radius_m');
+
+    const psize = 2.0 * Math.PI * radius_m / wavelength_m;
+
+    const x = vec2(psize * n_med[0], psize * n_med[1]);
+    const y = vec2(psize * n_p[0], psize * n_p[1]);
+    const M = terms_to_sum(x);
+    const A_med = A_all_n(x, M);
+    const A_p = A_all_n(y, M);
+
+    const e_term = Math.exp(2.0 * x[1]);
+
+    let prev_psi_zeta = vec2(0.5 * (1.0 - Math.cos(2.0 * x[0]) / e_term), -0.5 * Math.sin(2.0 * x[0]) / e_term);
+    let prev_B = vec2(0.0, 1.0);
+    let prev_R = vec2(0.5 * (1.0 - Math.cos(2.0 * x[0]) * e_term), 0.5 * Math.sin(2.0 * x[0]) * e_term);
+
+    const ab = new Float64Array(M * 4);
+
+    for (let n = 0; n < M; ++n) {
+
+        const ab_n = LorenzMie_ab(
+            n, psize, n_p, n_med, A_p, A_med,
+            prev_B, prev_R, prev_psi_zeta
+        );
+
+        prev_psi_zeta = ab_n.old_psi_zeta;
+        prev_B = ab_n.old_B;
+        prev_R = ab_n.old_R;
+
+        // plug the data in
+        ab[4 * n] = ab_n[0];
+        ab[4 * n + 1] = ab_n[1];
+        ab[4 * n + 2] = ab_n[2];
+        ab[4 * n + 3] = ab_n[3];
+    }
+    return ab;
+}
+
+/**
+ * Calculates the final optical properties by summing the Mie coefficients.
+ * This function implements Equations (2) and (3) from the 2007 paper
+ * "Computing the Scattering Properties of Participating Media..."
+ *
+ * @param {Float32Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
+ * @param {number} radius - Particle radius (in meters).
+ * @param {number} wavelength - Wavelength of light in vacuum (in meters).
+ * @param {vec2} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
+ * @returns {object} An object with Q_e, Q_s, albedo, C_ext, and C_sca.
+ */
+function ab_to_optical_properties(
+    ab,
+    wavelength,
+    radius,
+    n_med
+) {
+    const M = ab.length / 4;
+
+    let sum_t = vec2(0, 0); // Complex sum for Ct
+    let sum_s = 0; // Real sum for Cs
+    let sum_g = 0;          // Real sum for Asymmetry (g)
+
+    for (let n = 1; n < M; ++n) {
+        // The 'n' in the paper's formulas
+        const multiplier = 2 * n + 1;
+
+        // Get an and bn from your flat array
+        const an = vec2(ab[4 * n], ab[4 * n + 1]);
+        const bn = vec2(ab[4 * n + 2], ab[4 * n + 3]);
+
+        // 1. For Extinction (Ct)
+        const an_plus_bn = cadd(an, bn);
+        // You need complex math functions cadd, cdiv
+        const n_med_sq = cmult(n_med, n_med);
+        const term_t = cdiv(an_plus_bn, n_med_sq);
+        sum_t = cadd(sum_t, cmult(vec2(multiplier, 0), term_t));
+
+        // 2. For Scattering (Cs)
+        const an_mag_sq = an[0] * an[0] + an[1] * an[1];
+        const bn_mag_sq = bn[0] * bn[0] + bn[1] * bn[1];
+        sum_s += multiplier * (an_mag_sq + bn_mag_sq);
+
+        // 3. Asymmetry Accumulation (New)
+        // Term A: Interference of an and bn
+        // Formula: (2n+1) / (n(n+1)) * Re(an * bn*)
+        const factor_A = (2 * n + 1) / (n * (n + 1));
+        sum_g += factor_A * v2_dot(an[0], an[1], bn[0], bn[1]);
+
+        // Term B: Interference of n and n+1
+        // Formula: (n(n+2)) / (n+1) * Re(an * an+1* + bn * bn+1*)
+        if (n < M - 1) {
+            const n_next = n + 1;
+            const an1_r = ab[4 * n_next];
+            const an1_i = ab[4 * n_next + 1];
+            const bn1_r = ab[4 * n_next + 2];
+            const bn1_i = ab[4 * n_next + 3];
+
+            const factor_B = (n * (n + 2)) / (n + 1);
+
+            const term_an_an1 = v2_dot(an[0], an[1], an1_r, an1_i);
+            const term_bn_bn1 = v2_dot(bn[0], bn[1], bn1_r, bn1_i);
+
+            sum_g += factor_B * (term_an_an1 + term_bn_bn1);
+        }
+    }
+
+    // --- Final Calculations ---
+
+    // Asymmetry Parameter (g)
+    // g = (4/x^2 * sum_g) / (2/x^2 * sum_s) => 2 * sum_g / sum_s
+    let g = 0;
+    if (sum_s > 1e-12) {
+        g = (2 * sum_g) / sum_s;
+    }
+
+    // Extinction (Ct from Eq. 22)
+    const C_t = (Math.pow(wavelength, 2) / (2 * Math.PI)) * sum_t[0]; //
+
+    // Scattering (Cs from Eq. 23)
+    const alpha = (4 * Math.PI * radius * n_med[1]) / wavelength;
+    let gamma;
+    if (Math.abs(alpha) < 1e-10) {
+        // avoid division by 0
+        gamma = 1;
+    } else {
+        gamma = (2 * (1 + (alpha - 1) * Math.exp(alpha))) / Math.pow(alpha, 2);
+    }
+    const n_med_mag_sq = n_med[0] * n_med[0] + n_med[1] * n_med[1];
+    const C_s_factor = (Math.pow(wavelength, 2) * Math.exp(-alpha)) / (2 * Math.PI * gamma * n_med_mag_sq);
+    const C_s = C_s_factor * sum_s;
+
+    // Bulk Coefficients (assuming number density N)
+    const sigma_a_med = (4 * Math.PI * n_med[1]) / wavelength;
+
+    // To get bulk coefficients sigma_t and sigma_s, use the following formulae, where N is numeric density (particles per cubic meter):
+    // sigma_t = sigma_a_med + C_t * N;
+    // sigma_s = C_s * N;
+
+    return {
+        sigma_a_med,
+        C_ext: C_t,
+        C_sca: C_s,
+        g, // Anisotropy parameter
+    }
+}
+
+/**
+ * For refractive index, the imaginary part controls the absorption coefficient.
+ * For non-absorbing media, such as pure water - this will be 0.
+ *
+ * Note: for most different types of media (and particles), the refractive index will depend on wavelength.
+ * @param {number} wavelength (in meters)
+ * @param {number} radius (in meters)
+ * @param {number[]} n_p 2d vector, complex refractive index of the particle
+ * @param {number[]} n_med 2d vector, complex refractive index of the medium (e.g. [1.0, 0.0] for air)
+ */
+export function compute_lorenz_mie_optical_properties(
+    wavelength,
+    radius,
+    n_p,
+    n_med,
+) {
+    const ab = lorenz_mie_coefs(wavelength, radius, n_p, n_med);
+
+    return ab_to_optical_properties(ab, wavelength, radius, n_med);
+}
+

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compute scattering and extinction for a given particle/medium configuration
+ * @param {number} radius
+ * @param {function(result:number[], wavelength_nm:number)} n_p Particle Refraction Index. function of wavelength, Complex number.
+ * @param {function(result:number[], wavelength_nm:number)} n_med Medium Refraction Index. function of wavelength, Complex number.
+ * @param {number} [step_size_nm] In nanometers. Controls step size in spectral integration steps, smaller steps = more accurate. Use 1, or multiples of 5
+ */
+export function compute_mie_particle_properties_rgb(radius: number, n_p: any, n_med: any, step_size_nm?: number): {
+    scattering_coefficients: number[];
+    extinction_coefficients: number[];
+    extinction_intercept: number[];
+    albedo: number[];
+    g: number;
+};
+//# sourceMappingURL=compute_mie_particle_properties_rgb.d.ts.map

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_mie_particle_properties_rgb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_particle_properties_rgb.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,4DALW,MAAM,uCAGN,MAAM;;;;;;EAwIhB"}

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.js

@@ -0,0 +1,148 @@
+import { assert } from "../../../assert.js";
+import { D65_spd_tabulated } from "../../../color/illuminant/D65_spd_tabulated.js";
+import { xyz_cmf_tabulated } from "../../../color/xyz/xyz_cmf_tabulated.js";
+import { xyz_to_rgb } from "../../../color/xyz/xyz_to_rgb.js";
+import { compute_lorenz_mie_optical_properties } from "./compute_lorenz_mie_optical_properties.js";
+
+/**
+ * Compute scattering and extinction for a given particle/medium configuration
+ * @param {number} radius
+ * @param {function(result:number[], wavelength_nm:number)} n_p Particle Refraction Index. function of wavelength, Complex number.
+ * @param {function(result:number[], wavelength_nm:number)} n_med Medium Refraction Index. function of wavelength, Complex number.
+ * @param {number} [step_size_nm] In nanometers. Controls step size in spectral integration steps, smaller steps = more accurate. Use 1, or multiples of 5
+ */
+export function compute_mie_particle_properties_rgb(
+    radius,
+    n_p,
+    n_med,
+    step_size_nm = 5
+) {
+
+    assert.isFunction(n_p, 'n_p');
+    assert.isFunction(n_med, 'n_med');
+    assert.isFinite(radius, 'radius');
+    assert.greaterThan(radius, 0, 'radius must be positive');
+    assert.isNonNegativeInteger(step_size_nm, 'step_size_nm');
+
+    const cmf = [0, 0, 0];
+    let sum_Ey = 0;
+
+    const scattering_coefficients = [0, 0, 0];
+    const extinction_coefficients = [0, 0, 0];
+    const sigma_a_med = [0, 0, 0];
+
+    const ir_particle = [];
+    const ir_medium = [];
+
+    // Variables for G integration
+    let g_weighted_accumulator = 0;
+    let g_weight_total = 0;
+
+    // integrate CMF
+    const WAVELENGTH_MIN = 380;
+    const WAVELENGTH_MAX = 780;
+
+    for (let wavelength_nm = WAVELENGTH_MIN; wavelength_nm <= WAVELENGTH_MAX; wavelength_nm += step_size_nm) {
+
+        // visible light sweep
+        // Integrate over visible spectrum in nanometers for CMF/RI
+        const wavelength_m = wavelength_nm * 1e-9;
+
+        const E = D65_spd_tabulated(wavelength_nm);
+        xyz_cmf_tabulated(cmf, wavelength_nm);
+
+        // Calculate spectral weight W(λ) = E(λ) * CMF(λ)
+        const wX = cmf[0] * E;
+        const wY = cmf[1] * E;
+        const wZ = cmf[2] * E;
+
+        // accumulate illuminant-luminance denominator (single shared normalization)
+        sum_Ey += wY;
+
+        // compute IR coefficients
+        n_p(ir_particle, wavelength_nm);
+        n_med(ir_medium, wavelength_nm);
+
+        const properties = compute_lorenz_mie_optical_properties(
+            wavelength_m,
+            radius,
+            ir_particle,
+            ir_medium,
+        );
+
+        scattering_coefficients[0] += properties.C_sca * wX;
+        scattering_coefficients[1] += properties.C_sca * wY;
+        scattering_coefficients[2] += properties.C_sca * wZ;
+
+        extinction_coefficients[0] += properties.C_ext * wX;
+        extinction_coefficients[1] += properties.C_ext * wY;
+        extinction_coefficients[2] += properties.C_ext * wZ;
+
+        sigma_a_med[0] += properties.sigma_a_med * wX;
+        sigma_a_med[1] += properties.sigma_a_med * wY;
+        sigma_a_med[2] += properties.sigma_a_med * wZ;
+
+        // We weight 'g' by how much this wavelength contributes to
+        // the Visible Luminance (Y) of the Scattered light.
+        // If C_sca is 0, this wavelength should not affect the average G.
+        const scatter_luminance_weight = properties.C_sca * wY;
+
+        g_weighted_accumulator += properties.g * scatter_luminance_weight;
+        g_weight_total += scatter_luminance_weight;
+    }
+
+    // normalize using a single shared luminance-based denominator: k = 1 / Σ E(λ)·ȳ(λ)
+    const k = 1 / sum_Ey;
+
+    scattering_coefficients[0] *= k;
+    scattering_coefficients[1] *= k;
+    scattering_coefficients[2] *= k;
+
+    extinction_coefficients[0] *= k;
+    extinction_coefficients[1] *= k;
+    extinction_coefficients[2] *= k;
+
+    sigma_a_med[0] *= k;
+    sigma_a_med[1] *= k;
+    sigma_a_med[2] *= k;
+
+    // Resolve G
+    // If the particle is invisible (no scattering), default to isotropic (0)
+    const final_g = g_weight_total > 1e-12 ? (g_weighted_accumulator / g_weight_total) : 0;
+
+    // convert XYZ -> sRGB
+
+    xyz_to_rgb(scattering_coefficients, scattering_coefficients);
+    xyz_to_rgb(extinction_coefficients, extinction_coefficients);
+    xyz_to_rgb(sigma_a_med, sigma_a_med);
+
+    // Perform gamut clamp to remove potential negative lobes
+    scattering_coefficients[0] = Math.max(0, scattering_coefficients[0]);
+    scattering_coefficients[1] = Math.max(0, scattering_coefficients[1]);
+    scattering_coefficients[2] = Math.max(0, scattering_coefficients[2]);
+
+    extinction_coefficients[0] = Math.max(0, extinction_coefficients[0]);
+    extinction_coefficients[1] = Math.max(0, extinction_coefficients[1]);
+    extinction_coefficients[2] = Math.max(0, extinction_coefficients[2]);
+
+    sigma_a_med[0] = Math.max(0, sigma_a_med[0]);
+    sigma_a_med[1] = Math.max(0, sigma_a_med[1]);
+    sigma_a_med[2] = Math.max(0, sigma_a_med[2]);
+
+    // Derive the albedo.
+    // Prevent division by 0, and clamp gamut at the upper range to 1
+    const albedo = [
+        extinction_coefficients[0] !== 0 ? Math.min(1, scattering_coefficients[0] / extinction_coefficients[0]) : 0,
+        extinction_coefficients[1] !== 0 ? Math.min(1, scattering_coefficients[1] / extinction_coefficients[1]) : 0,
+        extinction_coefficients[2] !== 0 ? Math.min(1, scattering_coefficients[2] / extinction_coefficients[2]) : 0,
+    ];
+
+    return {
+        scattering_coefficients,
+        extinction_coefficients,
+        extinction_intercept: sigma_a_med,
+        albedo,
+        g: final_g,
+    }
+
+}