PythonicDISORT 1.1__tar.gz → 1.2__tar.gz

{pythonicdisort-1.1/src/PythonicDISORT.egg-info → pythonicdisort-1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.1
+Version: 1.2
 Summary: Discrete Ordinates Solver for the (1D) Radiative Transfer Equation in a single or multi-layer atmosphere.
 Author-email: Dion HO Jia Xu <dh3065@columbia.edu>
 Project-URL: Homepage, https://github.com/LDEO-CREW/Pythonic-DISORT
@@ -67,8 +67,8 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Test Problem 5: Cloud C.1 Scattering, Beam Source
 * Test Problem 6: No Scattering, Increasingly Complex Sources (relevant for modeling longwave radiation)
 * Test Problem 7: Absorption + Scattering + All Possible Sources, Lambertian and Hapke Surface Reflectivities (one layer)
-* Test Problem 8: Absorbing / Isotropic-Scattering Medium With (two layers)
-* Test Problem 9: General Emitting / Absorbing / Scattering Medium with (many different layers)
+* Test Problem 8: Absorbing / Isotropic-Scattering Medium (multiple layers)
+* Test Problem 9: General Emitting / Absorbing / Scattering Medium (multiple layers)
 * Test Problem 11: Single-Layer vs. Multiple Layers (no corresponding Jupyter Notebook)
 
 # Installation

{pythonicdisort-1.1 → pythonicdisort-1.2}/README.md

@@ -46,8 +46,8 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Test Problem 5: Cloud C.1 Scattering, Beam Source
 * Test Problem 6: No Scattering, Increasingly Complex Sources (relevant for modeling longwave radiation)
 * Test Problem 7: Absorption + Scattering + All Possible Sources, Lambertian and Hapke Surface Reflectivities (one layer)
-* Test Problem 8: Absorbing / Isotropic-Scattering Medium With (two layers)
-* Test Problem 9: General Emitting / Absorbing / Scattering Medium with (many different layers)
+* Test Problem 8: Absorbing / Isotropic-Scattering Medium (multiple layers)
+* Test Problem 9: General Emitting / Absorbing / Scattering Medium (multiple layers)
 * Test Problem 11: Single-Layer vs. Multiple Layers (no corresponding Jupyter Notebook)
 
 # Installation

{pythonicdisort-1.1 → pythonicdisort-1.2}/pyproject.toml

@@ -8,7 +8,7 @@ dependencies = [
   "scipy>=1.8.0",
 ]
 name = "PythonicDISORT"
-version = "1.1"
+version = "1.2"
 authors = [
   { name="Dion HO Jia Xu", email="dh3065@columbia.edu" },
 ]

{pythonicdisort-1.1 → pythonicdisort-1.2}/src/PythonicDISORT/_assemble_intensity_and_fluxes.py

@@ -201,7 +201,13 @@ def _assemble_intensity_and_fluxes(
                 axis=-1,
             )
             
-            if is_antiderivative_wrt_tau and there_is_beam_source:
+            direct_beam_contribution = 0
+            if is_antiderivative_wrt_tau:
+                if there_is_beam_source:
+                    direct_beam_contribution = (B_collect / (-scale_tau / mu0)[None, :, None])[
+                        :, l, :
+                    ] * np.exp(-scaled_tau / mu0)[None, :, None]
+
                 um = (
                     np.einsum(
                         "mtij, mtj -> mti",
@@ -209,23 +215,19 @@ def _assemble_intensity_and_fluxes(
                         np.exp(exponent) / (scale_tau[None, :, None] * K_collect)[:, l, :],
                         optimize=True,
                     )
-                    + (B_collect / (-scale_tau / mu0)[None, :, None])[:, l, :]
-                    * np.exp(-scaled_tau / mu0)[None, :, None]
-                )
-            elif is_antiderivative_wrt_tau and not there_is_beam_source:
-                um = np.einsum(
-                    "mtij, mtj -> mti",
-                    GC_collect[:, l, :, :],
-                    np.exp(exponent) / (scale_tau[None, l, None] * K_collect)[:, l, :],
-                    optimize=True,
+                    + direct_beam_contribution
                 )
-            elif not is_antiderivative_wrt_tau and there_is_beam_source:
-                um = np.einsum(
-                    "mtij, mtj -> mti", GC_collect[:, l, :, :], np.exp(exponent), optimize=True
-                ) + B_collect[:, l, :] * np.exp(-scaled_tau / mu0)[None, :, None]
             else:
-                um = np.einsum(
-                    "mtij, mtj -> mti", GC_collect[:, l, :, :], np.exp(exponent), optimize=True
+                if there_is_beam_source:
+                    direct_beam_contribution = (
+                        B_collect[:, l, :] * np.exp(-scaled_tau / mu0)[None, :, None]
+                    )
+
+                um = (
+                    np.einsum(
+                        "mtij, mtj -> mti", GC_collect[:, l, :, :], np.exp(exponent), optimize=True
+                    )
+                    + direct_beam_contribution
                 )
             
             # Contribution from particular solution for isotropic internal sources
@@ -255,6 +257,9 @@ def _assemble_intensity_and_fluxes(
                 np.cos(np.arange(NFourier)[:, None] * (phi0 - phi)[None, :]),
                 optimize=True,
             )
+            
+            outputs = (rescale_factor * np.squeeze(u),)
+            outputs_len = 1
 
             if return_Fourier_error:
                 exponent = np.concatenate(
@@ -264,7 +269,14 @@ def _assemble_intensity_and_fluxes(
                     ],
                     axis=-1,
                 )
-                if is_antiderivative_wrt_tau and there_is_beam_source:
+                
+                direct_beam_contribution = 0
+                if is_antiderivative_wrt_tau:
+                    if there_is_beam_source:
+                        direct_beam_contribution = (
+                            B_collect.T[-1, :, :] / (-scale_tau / mu0)[None, :]
+                        )[:, l] * np.exp(-scaled_tau / mu0)[None, :]
+
                     ulast = (
                         np.einsum(
                             "tij, tj -> it",
@@ -272,25 +284,21 @@ def _assemble_intensity_and_fluxes(
                             np.exp(exponent) / (scale_tau[:, None] * K_collect[-1, :, :])[l, :],
                             optimize=True,
                         )
-                        + (B_collect.T[-1, :, :] / (-scale_tau / mu0)[None, :])[:, l]
-                        * np.exp(-scaled_tau / mu0)[None, :]
+                        + direct_beam_contribution
                     )
-                elif is_antiderivative_wrt_tau and not there_is_beam_source:
-                    ulast = np.einsum(
-                        "tij, tj -> it",
-                        GC_collect[-1, l, :, :],
-                        np.exp(exponent) / (scale_tau[:, None] * K_collect[-1, :, :])[l, :],
-                        optimize=True,
-                        )
-                elif not is_antiderivative_wrt_tau and not there_is_beam_source:
-                    ulast = np.einsum(
-                        "tij, tj -> it", GC_collect[-1, l, :, :], np.exp(exponent), optimize=True
-                    ) + B_collect.T[-1, :, l] * np.exp(-scaled_tau / mu0)[None, :]
                 else:
-                    ulast = np.einsum(
-                        "tij, tj -> it", GC_collect[-1, l, :, :], np.exp(exponent), optimize=True
+                    if there_is_beam_source:
+                        direct_beam_contribution = (
+                            B_collect.T[-1, :, l] * np.exp(-scaled_tau / mu0)[None, :]
+                        )
+
+                    ulast = (
+                        np.einsum(
+                            "tij, tj -> it", GC_collect[-1, l, :, :], np.exp(exponent), optimize=True
+                        )
+                        + direct_beam_contribution
                     )
-                        
+        
                 u_abs = np.abs(u)
                 Fourier_error = np.max(
                     np.divide(
@@ -299,19 +307,18 @@ def _assemble_intensity_and_fluxes(
                         ),
                         u_abs,
                         out=np.zeros_like(u_abs),
-                        where=u_abs > 1e-15,
+                        where=u_abs > 1e-8,
                     )
                 )
                 
-                if return_tau_arr:
-                    return rescale_factor * np.squeeze(u), Fourier_error, tau_arr
-                else:
-                    return rescale_factor * np.squeeze(u), Fourier_error
-            else:
-                if return_tau_arr:
-                    return rescale_factor * np.squeeze(u), tau_arr
-                else:
-                    return rescale_factor * np.squeeze(u)
+                outputs += (Fourier_error,)
+                outputs_len += 1
+                
+            if return_tau_arr:
+                outputs += (tau_arr,)
+                outputs_len += 1
+                
+            return outputs[0] if outputs_len == 1 else outputs
         # --------------------------------------------------------------------------------------------------------------------------
     
     # Construct u0
@@ -363,7 +370,13 @@ def _assemble_intensity_and_fluxes(
             axis=-1,
         )
         
+        direct_beam_contribution = 0
         if is_antiderivative_wrt_tau and there_is_beam_source:
+            if there_is_beam_source:
+                direct_beam_contribution = (B_collect_0.T / (-scale_tau / mu0)[None, :])[
+                    :, l
+                ] * np.exp(-scaled_tau / mu0)[None, :]
+
             u0 = (
                 np.einsum(
                     "tij, tj -> it",
@@ -371,25 +384,21 @@ def _assemble_intensity_and_fluxes(
                     np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :],
                     optimize=True,
                 )
-                + (B_collect_0.T / (-scale_tau / mu0)[None, :])[:, l]
-                * np.exp(-scaled_tau / mu0)[None, :]
-            )
-        elif is_antiderivative_wrt_tau and not there_is_beam_source:
-            u0 = np.einsum(
-                "tij, tj -> it",
-                GC_collect_0[l, :, :],
-                np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :],
-                optimize=True,
+                + direct_beam_contribution
             )
-        elif not is_antiderivative_wrt_tau and there_is_beam_source:
-            u0 = np.einsum(
-                "tij, tj -> it", GC_collect_0[l, :, :], np.exp(exponent), optimize=True
-            ) + B_collect_0.T[:, l] * np.exp(-scaled_tau / mu0)[None, :]
         else:
-            u0 = np.einsum(
-                "tij, tj -> it", GC_collect_0[l, :, :], np.exp(exponent), optimize=True
+            if there_is_beam_source:
+                direct_beam_contribution = (
+                    B_collect_0.T[:, l] * np.exp(-scaled_tau / mu0)[None, :]
+                )
+
+            u0 = (
+                np.einsum(
+                    "tij, tj -> it", GC_collect_0[l, :, :], np.exp(exponent), optimize=True
+                )
+                + direct_beam_contribution
             )
-        
+
         # Contribution from particular solution for isotropic internal sources
         if there_is_iso_source:
             l_uniq, l_inv = np.unique(l, return_inverse=True)
@@ -405,14 +414,16 @@ def _assemble_intensity_and_fluxes(
             )
             u0 = u0 + _mathscr_v_contribution
             
-        if return_tau_arr and _return_act_dscale_for_reclass:
-            return rescale_factor * np.squeeze(u0), tau_arr, act_dscale_reclassification
-        elif return_tau_arr and not _return_act_dscale_for_reclass:
-            return rescale_factor * np.squeeze(u0), tau_arr
-        elif not return_tau_arr and _return_act_dscale_for_reclass:
-            return rescale_factor * np.squeeze(u0), act_dscale_reclassification
-        else:
-            return rescale_factor * np.squeeze(u0)
+        outputs = (rescale_factor * np.squeeze(u0),)
+        outputs_len = 1
+        if return_tau_arr:
+            outputs += (tau_arr,)
+            outputs_len += 1
+        if _return_act_dscale_for_reclass:
+            outputs += (act_dscale_reclassification,)
+            outputs_len += 1
+        return outputs[0] if outputs_len == 1 else outputs
+        
     # --------------------------------------------------------------------------------------------------------------------------
     
     # Construct the flux functions (refer to section 3.8 of the Comprehensive Documentation)
@@ -463,15 +474,6 @@ def _assemble_intensity_and_fluxes(
         else:
             _mathscr_v_contribution = 0
         
-        if there_is_beam_source and is_antiderivative_wrt_tau:
-            direct_beam_contribution = (
-                (B_pos / (-scale_tau / mu0)[None, :])[:, l] * np.exp(-scaled_tau / mu0)[None, :] 
-            )
-        elif there_is_beam_source and not is_antiderivative_wrt_tau:
-            direct_beam_contribution = B_pos[:, l] * np.exp(-scaled_tau / mu0)[None, :]
-        else:
-            direct_beam_contribution = 0
-
         exponent = np.concatenate(
             [
                 K_collect_0[l, :N] * (scaled_tau - scaled_tau_arr_lm1)[:, None],
@@ -480,7 +482,13 @@ def _assemble_intensity_and_fluxes(
             axis=-1,
         )
         
+        direct_beam_contribution = 0
         if is_antiderivative_wrt_tau:
+            if there_is_beam_source:
+                direct_beam_contribution = (
+                    (B_pos / (-scale_tau / mu0)[None, :])[:, l] * np.exp(-scaled_tau / mu0)[None, :] 
+                )
+                
             u0_pos = (
                 np.einsum(
                     "tij, tj -> it",
@@ -491,11 +499,15 @@ def _assemble_intensity_and_fluxes(
                 + _mathscr_v_contribution
             )
         else:
+            if there_is_beam_source:
+                direct_beam_contribution = B_pos[:, l] * np.exp(-scaled_tau / mu0)[None, :]
+                
             u0_pos = (
                 np.einsum("tij, tj -> it", GC_pos[l, :, :], np.exp(exponent))
                 + direct_beam_contribution
                 + _mathscr_v_contribution
             )
+            
         flux = 2 * pi * (mu_arr_pos * W) @ u0_pos
         
         if return_tau_arr:
@@ -543,20 +555,7 @@ def _assemble_intensity_and_fluxes(
             )
         else:
             _mathscr_v_contribution = 0
-        
-        if there_is_beam_source and is_antiderivative_wrt_tau:
-            direct_beam_contribution = (B_neg / (-scale_tau / mu0)[None, l])[:, l] * np.exp(-scaled_tau / mu0)[None, :]
-            direct_beam = I0 * mu0 * np.exp(-tau / mu0) * -mu0
-            direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0) / (-scale_tau / mu0)[None, l]
-        elif there_is_beam_source and not is_antiderivative_wrt_tau:
-            direct_beam_contribution = B_neg[:, l] * np.exp(-scaled_tau / mu0)[None, :]
-            direct_beam = I0 * mu0 * np.exp(-tau / mu0)
-            direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0)
-        else:
-            direct_beam_contribution = 0
-            direct_beam = 0
-            direct_beam_scaled = 0
-        
+            
         exponent = np.concatenate(
             [
                 K_collect_0[l, :N] * (scaled_tau - scaled_tau_arr_lm1)[:, None],
@@ -565,18 +564,32 @@ def _assemble_intensity_and_fluxes(
             axis=-1,
         )
         
+        direct_beam_contribution = 0
+        direct_beam = 0
+        direct_beam_scaled = 0
         if is_antiderivative_wrt_tau:
+            if there_is_beam_source:
+                direct_beam_contribution = (B_neg / (-scale_tau / mu0)[None, l])[:, l] * np.exp(-scaled_tau / mu0)[None, :]
+                direct_beam = I0 * mu0 * np.exp(-tau / mu0) * -mu0
+                direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0) / (-scale_tau / mu0)[None, l]
+            
             u0_neg = (
                 np.einsum("tij, tj -> it", GC_neg[l, :, :], np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :])
                 + direct_beam_contribution
                 + _mathscr_v_contribution
             )
         else:
+            if there_is_beam_source:
+                direct_beam_contribution = B_neg[:, l] * np.exp(-scaled_tau / mu0)[None, :]
+                direct_beam = I0 * mu0 * np.exp(-tau / mu0)
+                direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0)
+            
             u0_neg = (
                 np.einsum("tij, tj -> it", GC_neg[l, :, :], np.exp(exponent))
                 + direct_beam_contribution
                 + _mathscr_v_contribution
             )
+            
         diffuse_flux = 2 * pi * (mu_arr_pos * W) @ u0_neg + direct_beam_scaled - direct_beam
         
         if return_tau_arr:

{pythonicdisort-1.1 → pythonicdisort-1.2}/src/PythonicDISORT/_solve_for_gen_and_part_sols.py

@@ -210,28 +210,12 @@ def _solve_for_gen_and_part_sols(
 
         # --------------------------------------------------------------------------------------------------------------------------
 
-        
-    if there_is_beam_source and there_is_iso_source:
-        return (
-            G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
-            K_collect.reshape((NFourier, NLayers, NQuad)),
-            B_collect.reshape((NFourier, NLayers, NQuad)),
-            G_inv_collect_0,
-        )
-    elif there_is_beam_source and not there_is_iso_source:
-        return (
-            G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
-            K_collect.reshape((NFourier, NLayers, NQuad)),
-            B_collect.reshape((NFourier, NLayers, NQuad)),
-        )
-    elif not there_is_beam_source and there_is_iso_source:
-        return (
-            G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
-            K_collect.reshape((NFourier, NLayers, NQuad)),
-            G_inv_collect_0,
-        )
-    else:
-        return (
-            G_collect.reshape((NFourier, NLayers, NQuad, NQuad)), 
-            K_collect.reshape((NFourier, NLayers, NQuad)),
-        )
+    outputs = (
+        G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
+        K_collect.reshape((NFourier, NLayers, NQuad)),
+    )
+    if there_is_beam_source:
+        outputs += (B_collect.reshape((NFourier, NLayers, NQuad)),)
+    if there_is_iso_source:
+        outputs += (G_inv_collect_0,)
+    return outputs

{pythonicdisort-1.1 → pythonicdisort-1.2}/src/PythonicDISORT/pydisort.py

@@ -243,9 +243,10 @@ def pydisort(
         raise ValueError("The zeroth dimension of the shape of `s_poly_coeffs` does not match the number of layers which is deduced from the length of `tau_arr`.")
     # Value checks on the phase function Legendre coefficients
     if not np.all(omega_arr * Leg_coeffs_all[:, 0] == omega_arr):
-        raise ValueError("The first phase function Legendre coefficient must equal 1.") 
+        warnings.warn("The zeroth index phase function Legendre coefficient must be, and has been corrected to, 1.")
+        Leg_coeffs_all[:, 0] = 1
     if not (np.all(-1 <= Leg_coeffs_all) and np.all(Leg_coeffs_all <= 1)):
-        raise ValueError("The phase function Legendre coefficients must all be between -1 and 1.") 
+        raise ValueError("The phase function Legendre coefficients must all be between -1 and 1.")
     # Conditions on the number of quadrature angles (NQuad), Legendre coefficients (NLeg) and loops (NFourier)
     if not NQuad >= 2:
         raise ValueError("There must be at least two streams.")
@@ -256,7 +257,7 @@ def pydisort(
     if not NFourier <= NLeg:
         raise ValueError("The number of Fourier modes to use in the solution must be less than or equal to the number of phase function Legendre coefficients used.")
     if NFourier > 64 and not only_flux:
-        warnings.warn("`NFourier` is large and may cause errors, consider decreasing `NFourier` to 64 and it probably should be even less.")
+        warnings.warn("`NFourier` is large and may cause errors, consider decreasing `NFourier` to 64 and it probably should be even less. By default `NFourier` equals `NQuad`.")
     # Not strictly necessary but there will be tremendous inaccuracies if this is violated
     if not NLeg <= NQuad:
         raise ValueError("There should be more streams than the number of phase function Legendre coefficients used.")
@@ -316,24 +317,31 @@ def pydisort(
         scale_tau = 1 - omega_arr * f_arr
         scaled_thickness_arr = scale_tau * thickness_arr
         scaled_tau_arr_with_0 = np.insert(np.cumsum(scaled_thickness_arr), 0, 0)
-        weighted_scaled_Leg_coeffs = ((Leg_coeffs - f_arr[:, None]) / (1 - f_arr[:, None])) * (
-            2 * np.arange(NLeg) + 1
-        )[None, :]
+        scaled_Leg_coeffs = (Leg_coeffs - f_arr[:, None]) / (1 - f_arr[:, None])
+        weighted_scaled_Leg_coeffs = scaled_Leg_coeffs * (2 * np.arange(NLeg) + 1)[None, :]
         scaled_omega_arr = (1 - f_arr) / scale_tau * omega_arr
 
         translations = scaled_tau_arr_with_0[:-1] - scale_tau * np.insert(tau_arr[:-1], 0, 0)
         scaled_s_poly_coeffs = (
             subroutines.affine_transform_poly_coeffs(s_poly_coeffs, scale_tau, translations)
             / scale_tau[:, None]  # Divide by d\tau^* / d\tau
-        )
+        ) * (1 - omega_arr[:, None])  # Enforce Kirchoff's Law of Thermal Radiation: absorptivity equals emissivity
 
     else:
         # This is a shortcut to the same results
         scale_tau = np.ones(NLayers)
         scaled_tau_arr_with_0 = np.insert(tau_arr, 0, 0)
-        weighted_scaled_Leg_coeffs = Leg_coeffs * (2 * np.arange(NLeg) + 1)[None, :]
+        scaled_Leg_coeffs = Leg_coeffs
+        weighted_scaled_Leg_coeffs = scaled_Leg_coeffs * (2 * np.arange(NLeg) + 1)[None, :]
         scaled_omega_arr = omega_arr
-        scaled_s_poly_coeffs = s_poly_coeffs
+        scaled_s_poly_coeffs = s_poly_coeffs * (1 - omega_arr[:, None])  # Enforce Kirchoff's Law of Thermal Radiation: absorptivity equals emissivity
+        
+    if np.any(scaled_omega_arr > 1 - 1e-6):
+        warnings.warn("Some delta-scaled single-scattering albedos are very close to 1 which may cause numerical instability.")
+    if (np.any(-0.95 > scaled_Leg_coeffs[:, 1:]) and np.any(scaled_Leg_coeffs[:, 1:] > 0.95)):
+        warnings.warn("Some delta-scaled phase function Legendre coefficients have a magnitude that is very close to 1" +
+        " (this excludes the zeroth index coefficient which must be 1) and this may cause numerical instability.")
+    
     # --------------------------------------------------------------------------------------------------------------------------
     
     # Rescale of sources 
@@ -361,7 +369,7 @@ def pydisort(
             b_neg = (b_neg / rescale_factor).copy()
     # --------------------------------------------------------------------------------------------------------------------------
     
-    if NT_cor and not only_flux and there_is_beam_source and np.any(f_arr > 0) and NLeg < NLeg_all:
+    if NT_cor and not only_flux and there_is_beam_source and np.any(f_arr > 0) and NLeg < NLeg_all and np.any(omega_arr > 0):
         
         ############################### Perform NT corrections on the intensity but not the flux ###############################
         ############################### Refer to section 3.7.2 of the Comprehensive Documentation ##############################

{pythonicdisort-1.1 → pythonicdisort-1.2}/src/PythonicDISORT/subroutines.py

@@ -384,12 +384,11 @@ def linear_spline_coefficients(x, y, check_inputs=True):
 
 
 
-def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, omega_arr=None, **kwargs):
+def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, **kwargs):
     """Generate DISORT-equivalent ``s_poly_coeffs`` for input into ``pydisort``.
     This convenience function is provided to help match the inputs for Stamnes' DISORT to those for PythonicDISORT.
-    If ``omega_arr`` is specified, the coefficients will be multiplied by emissivity factors equal to ``1 - omega_arr`` 
-    per Kirchoff's law of thermal radiation, and Kirchoff's law is enforced in Stamnes' DISORT. 
-    Otherwise, the emissivities will be set to 1 and users can multiply their own emissivity factors.
+    Note that the coefficients will be multiplied by emissivity factors equal to ``1 - omega_arr`` inside
+    `pydisort`, i.e. Kirchoff's law of thermal radiation is enforced, just like in Stamnes' DISORT. 
     
     Parameters
     ----------
@@ -402,8 +401,6 @@ def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, omega_arr=None, **kw
         Lower bound of wavenumber interval with units m^-1. This variable is identically named in Stamnes' DISORT.
     WVNMHI : float
         Upper bound of wavenumber interval with units m^-1. This variable is identically named in Stamnes' DISORT.
-    omega_arr : optional, array or float
-        Single-scattering albedo of each atmospheric layer which is required to compute the emissivity of each layer.
     **kwargs
         Keyword arguments to pass to ``scipy.integrate.quad_vec``.
         
@@ -426,26 +423,10 @@ def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, omega_arr=None, **kw
         lambda WVNM: Planck(TEMPER, WVNM), WVNMLO, WVNMHI, **kwargs
     )[0]
 
-    if omega_arr is None:
-        return (
-            linear_spline_coefficients(
-                tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False
-            )
-        )
-    elif np.isscalar(omega_arr):
-        return (
-            linear_spline_coefficients(
-                tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False
-            )
-            * (1 - omega_arr)
-        )
-    else:
-        return (
-            linear_spline_coefficients(
-                tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False
-            )
-            * (1 - omega_arr)[:, None]
-        )
+    return linear_spline_coefficients(
+        tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False
+    )
+
 
 
 

{pythonicdisort-1.1 → pythonicdisort-1.2/src/PythonicDISORT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.1
+Version: 1.2
 Summary: Discrete Ordinates Solver for the (1D) Radiative Transfer Equation in a single or multi-layer atmosphere.
 Author-email: Dion HO Jia Xu <dh3065@columbia.edu>
 Project-URL: Homepage, https://github.com/LDEO-CREW/Pythonic-DISORT
@@ -67,8 +67,8 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Test Problem 5: Cloud C.1 Scattering, Beam Source
 * Test Problem 6: No Scattering, Increasingly Complex Sources (relevant for modeling longwave radiation)
 * Test Problem 7: Absorption + Scattering + All Possible Sources, Lambertian and Hapke Surface Reflectivities (one layer)
-* Test Problem 8: Absorbing / Isotropic-Scattering Medium With (two layers)
-* Test Problem 9: General Emitting / Absorbing / Scattering Medium with (many different layers)
+* Test Problem 8: Absorbing / Isotropic-Scattering Medium (multiple layers)
+* Test Problem 9: General Emitting / Absorbing / Scattering Medium (multiple layers)
 * Test Problem 11: Single-Layer vs. Multiple Layers (no corresponding Jupyter Notebook)
 
 # Installation