PythonicDISORT 1.0.2__py3-none-any.whl → 1.1__py3-none-any.whl

PythonicDISORT/_assemble_intensity_and_fluxes.py

@@ -100,6 +100,7 @@ def _assemble_intensity_and_fluxes(
     else:
         import numpy as np
     
+    
     ################################## Assemble uncorrected intensity and flux functions #######################################
     
     # Compute all the necessary quantities
@@ -172,7 +173,7 @@ def _assemble_intensity_and_fluxes(
             Pass `return_Fourier_error = True` (defaults to `False`) to return the 
             Cauchy / Fourier convergence evaluation (type: float) for the last Fourier term.
             Pass `is_antiderivative_wrt_tau = True` (defaults to `False`)
-            to switch to an antiderivative of the function with respect to `tau`.
+            to switch to an antiderivative of this function with respect to `tau`.
             """
             tau = np.atleast_1d(tau)
             phi = np.atleast_1d(phi)
@@ -238,7 +239,7 @@ def _assemble_intensity_and_fluxes(
                     G_inv_collect_0[l_uniq],
                     mu_arr,
                     is_antiderivative_wrt_tau,
-                    autograd_compatible
+                    autograd_compatible,
                 )
                 
                 if NFourier == 1:
@@ -323,7 +324,7 @@ def _assemble_intensity_and_fluxes(
         but reclassification of delta-scaled flux and other corrections must be done manually
         (for actinic flux `generate_diff_act_flux_funcs` will automatically perform the reclassification).
         Pass `is_antiderivative_wrt_tau = True` (defaults to `False`)
-        to switch to an antiderivative of the function with respect to `tau`.
+        to switch to an antiderivative of this function with respect to `tau`.
         """
         tau = np.atleast_1d(tau)
         if np.any(tau < 0) or np.any(tau > tau_arr[-1]):
@@ -400,7 +401,7 @@ def _assemble_intensity_and_fluxes(
                 G_inv_collect_0[l_uniq],
                 mu_arr,
                 is_antiderivative_wrt_tau,
-                autograd_compatible
+                autograd_compatible,
             )
             u0 = u0 + _mathscr_v_contribution
             
@@ -428,7 +429,7 @@ def _assemble_intensity_and_fluxes(
         (Energetic) Flux function with argument `tau` (type: array or float) for positive (upward) `mu` values.
         Returns the diffuse flux magnitudes (same type and size as `tau`).
         Pass `is_antiderivative_wrt_tau = True` (defaults to `False`)
-        to switch to an antiderivative of the function with respect to `tau`.
+        to switch to an antiderivative of this function with respect to `tau`.
         """
         tau = np.atleast_1d(tau)
         if np.any(tau < 0) or np.any(tau > tau_arr[-1]):
@@ -457,7 +458,7 @@ def _assemble_intensity_and_fluxes(
                 G_inv_collect_0[l_uniq],
                 mu_arr,
                 is_antiderivative_wrt_tau,
-                autograd_compatible
+                autograd_compatible,
             )
         else:
             _mathscr_v_contribution = 0
@@ -509,7 +510,7 @@ def _assemble_intensity_and_fluxes(
         Returns a tuple of the diffuse and direct flux magnitudes respectively where each entry is of the
         same type and size as `tau`.
         Pass `is_antiderivative_wrt_tau = True` (defaults to `False`)
-        to switch to an antiderivative of the function with respect to `tau`.
+        to switch to an antiderivative of this function with respect to `tau`.
         """
         tau = np.atleast_1d(tau)
         if np.any(tau < 0) or np.any(tau > tau_arr[-1]):
@@ -538,7 +539,7 @@ def _assemble_intensity_and_fluxes(
                 G_inv_collect_0[l_uniq],
                 mu_arr,
                 is_antiderivative_wrt_tau,
-                autograd_compatible
+                autograd_compatible,
             )
         else:
             _mathscr_v_contribution = 0
@@ -592,6 +593,6 @@ def _assemble_intensity_and_fluxes(
         # --------------------------------------------------------------------------------------------------------------------------
 
     if only_flux:
-        return flux_up, flux_down, u0#, GC_collect_0, K_collect_0, B_collect_0
+        return flux_up, flux_down, u0#, GC_collect_0, K_collect_0#, B_collect_0
     else:
         return flux_up, flux_down, u0, u

PythonicDISORT/_solve_for_gen_and_part_sols.py

@@ -101,16 +101,17 @@ def _solve_for_gen_and_part_sols(
         # Loop over NLayers atmospheric layers
         # --------------------------------------------------------------------------------------------------------------------------          
         for l in range(NLayers):
-            weighted_asso_Leg_coeffs_l = weighted_scaled_Leg_coeffs[l, :][ells] * fac
+            weighted_scaled_Leg_coeffs_l = weighted_scaled_Leg_coeffs[l, :][ells]
+            scaled_omega_l = scaled_omega_arr[l]
+            omega_times_Leg_coeffs = (scaled_omega_l / 2) * weighted_scaled_Leg_coeffs_l
             
-            if np.any(weighted_asso_Leg_coeffs_l > 0): # There are shortcuts if the coefficients are all zero
-                scaled_omega_l = scaled_omega_arr[l]
+            if np.any(np.abs(omega_times_Leg_coeffs) > 1e-8): # There are shortcuts if multiple scattering is insignificant
                 
                 # Generate D
                 # --------------------------------------------------------------------------------------------------------------------------
-                D_temp = weighted_asso_Leg_coeffs_l[None, :] * asso_leg_term_pos.T
-                D_pos = (scaled_omega_l / 2) * D_temp @ asso_leg_term_pos
-                D_neg = (scaled_omega_l / 2) * D_temp @ asso_leg_term_neg
+                D_temp = omega_times_Leg_coeffs[None, :] * (fac[None, :] * asso_leg_term_pos.T)
+                D_pos = D_temp @ asso_leg_term_pos
+                D_neg = D_temp @ asso_leg_term_neg
                 
                 # --------------------------------------------------------------------------------------------------------------------------
                 
@@ -130,8 +131,8 @@ def _solve_for_gen_and_part_sols(
                     # Generate X
                     X_temp = (
                         (scaled_omega_l * I0 * (2 - (m == 0)) / (4 * pi))
-                        * weighted_asso_Leg_coeffs_l
-                        * asso_leg_term_mu0
+                        * weighted_scaled_Leg_coeffs_l
+                        * (fac * asso_leg_term_mu0)
                     )
                     X_pos = X_temp @ asso_leg_term_pos
                     X_neg = X_temp @ asso_leg_term_neg
@@ -149,7 +150,6 @@ def _solve_for_gen_and_part_sols(
                     
                 # --------------------------------------------------------------------------------------------------------------------------
                 
-                
                 alpha_arr[ind, :, :] = alpha
                 beta_arr[ind, :, :] = beta
                 no_shortcut_indices.append(ind)
@@ -173,15 +173,15 @@ def _solve_for_gen_and_part_sols(
     
         # Diagonalization of coefficient matrix (refer to section 3.4.2 of the Comprehensive Documentation)
         # --------------------------------------------------------------------------------------------------------------------------
-        alpha_arr = alpha_arr[: len(no_shortcut_indices), :, :]
-        beta_arr = beta_arr[: len(no_shortcut_indices), :, :]
+        alpha_arr = alpha_arr[no_shortcut_indices, :, :]
+        beta_arr = beta_arr[no_shortcut_indices, :, :]
 
         K_squared_arr, eigenvecs_GpG_arr = np.linalg.eig(
             np.einsum(
                 "lij, ljk -> lik", alpha_arr - beta_arr, alpha_arr + beta_arr, optimize=True
             ),
         )
-
+        
         # Eigenvalues arranged negative then positive, from largest to smallest magnitude
         K_arr = np.concatenate((-np.sqrt(K_squared_arr), np.sqrt(K_squared_arr)), axis=1)
         eigenvecs_GpG_arr = np.concatenate((eigenvecs_GpG_arr, eigenvecs_GpG_arr), axis=2)
@@ -205,7 +205,7 @@ def _solve_for_gen_and_part_sols(
         K_collect[no_shortcut_indices, :] = K_arr
         if len(no_shortcut_indices_0) > 0: # If there is no isotropic source this list will be empty
             G_inv_collect_0[no_shortcut_indices_0, :, :] = np.linalg.inv(
-                G_collect[: len(no_shortcut_indices_0), :, :]
+                G_collect[no_shortcut_indices_0, :, :]
             )
 
         # --------------------------------------------------------------------------------------------------------------------------

PythonicDISORT/pydisort.py

@@ -76,7 +76,7 @@ def pydisort(
     NT_cor : optional, bool
         Perform Nakajima-Tanaka intensity corrections?
     BDRF_Fourier_modes : optional, list of functions
-        BDRF Fourier modes, each a scalar, or a function with arguments ``mu, -mu_p`` of type array
+        BDRF Fourier modes, each a float, or a function with arguments ``mu, -mu_p`` of type array
         which output has the same dimensions as the outer product of the two arrays.
     s_poly_coeffs : optional, array
         Polynomial coefficients of isotropic internal sources.
@@ -86,17 +86,17 @@ def pydisort(
         At or above how many atmospheric layers should ``scipy.linalg.solve_banded`` be used?
     autograd_compatible : optional, bool
         If ``True``, the autograd package: https://github.com/HIPS/autograd can be used to compute
-        the ``tau``-derivatives of the output functions but ``pydisort`` will be less efficient.  
+        the ``tau``-derivatives of the output functions but ``pydisort`` will be less efficient. 
 
     Returns
     -------
-    mu_arr : array or float
+    mu_arr : array
         All ``mu`` (cosine of polar angle) quadrature nodes.
     Fp(tau) : function
         (Energetic) Flux function with argument ``tau`` (type: array or float) for positive (upward) ``mu`` values.
         Returns the diffuse flux magnitudes (same type and size as ``tau``).
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         For example, ``Fp(tau_arr, is_antiderivative_wrt_tau = True) - Fp(np.insert(tau_arr[:-1] + 1e-15, 0, 0), is_antiderivative_wrt_tau = True)``
         will produce an array of the tau-integral over each layer.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
@@ -105,7 +105,7 @@ def pydisort(
         Returns a tuple of the diffuse and direct flux magnitudes respectively where each entry is of the
         same type and size as ``tau``.
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
     u0(tau) : function
         Zeroth Fourier mode of the intensity with argument ``tau`` (type: array or float).
@@ -114,13 +114,13 @@ def pydisort(
         but reclassification of delta-scaled flux and other corrections must be done manually
         (for actinic flux ``subroutines.generate_diff_act_flux_funcs`` will automatically perform the reclassification).
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
     u(tau, phi) : function, optional
         Intensity function with arguments ``(tau, phi)`` each of type array or float.
         Returns an ndarray with axes corresponding to variation with ``mu, tau, phi`` respectively.
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_Fourier_error = True`` (defaults to ``False``) to return the 
         Cauchy / Fourier convergence evaluation (type: float) for the last Fourier term.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
@@ -172,13 +172,13 @@ def pydisort(
     | `Leg_coeffs_residue_avg`     | `NLeg_all`           |
     | `scaled_mu0`                 | scalar               |
     """
-
+    
     if autograd_compatible:
         import autograd.numpy as np
     else:
         import numpy as np
     
-    # Turn scalars into arrays
+    # Turn floats into arrays
     # --------------------------------------------------------------------------------------------------------------------------
     tau_arr = np.atleast_1d(tau_arr)
     omega_arr = np.atleast_1d(omega_arr)
@@ -222,7 +222,7 @@ def pydisort(
     if not np.all(tau_arr > 0):
         raise ValueError("tau values cannot be non-positive.")
     if not np.all(thickness_arr > 0):
-        raise ValueError("Layer thickness cannot be non-positive.")
+        raise ValueError("Layer thicknesses cannot be non-positive.")
     # Single-scattering albedo must be between 0 and 1, excluding 1
     if not (np.all(omega_arr >= 0) and np.all(omega_arr < 1)):
         raise ValueError("Single-scattering albedo must be between 0 and 1, excluding 1.") 
@@ -230,21 +230,22 @@ def pydisort(
     # The user must supply at least as many phase function Legendre coefficients as intended for use
     if not NLeg > 0:
         raise ValueError("The number of phase function Legendre coefficients must be positive.") 
-    if not np.all(omega_arr * Leg_coeffs_all[:, 0] == omega_arr):
-        raise ValueError("The first phase function Legendre coefficient must equal 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.") 
     if not NLeg <= NLeg_all:
         raise ValueError("`NLeg` cannot be larger than the number of phase function Legendre coefficients provided.")
     # Ensure that the first dimension of the following inputs corresponds to the number of layers
     if not np.shape(Leg_coeffs_all)[0] == NLayers:
-        raise ValueError("The zeroth dimension of the shape of `Leg_coeffs_all` does not match the number of layers as deduced from the length of `tau_arr`.")
+        raise ValueError("The zeroth dimension of the shape of `Leg_coeffs_all` does not match the number of layers which is deduced from the length of `tau_arr`.")
     if not len(omega_arr) == NLayers:
-        raise ValueError("The zeroth dimension of the shape of `omega_arr` does not match the number of layers as deduced from the length of `tau_arr`.")
+        raise ValueError("The zeroth dimension of the shape of `omega_arr` does not match the number of layers which is deduced from the length of `tau_arr`.")
     if np.any(f_arr != 0) and not len(f_arr) == NLayers:
-        raise ValueError("The length of `f_arr` does not match the number of layers as deduced from the length of `tau_arr`.")
+        raise ValueError("The length of `f_arr` does not match the number of layers which is deduced from the length of `tau_arr`.")
     if there_is_iso_source and not np.shape(s_poly_coeffs)[0] == NLayers:
-        raise ValueError("The zeroth dimension of the shape of `s_poly_coeffs` does not match the number of layers as deduced from the length of `tau_arr`.")
+        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.") 
+    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.") 
     # 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.")
@@ -261,7 +262,7 @@ def pydisort(
         raise ValueError("There should be more streams than the number of phase function Legendre coefficients used.")
     # We require principal angles and a downward incident beam
     if I0 < 0:
-        raise ValueError("The incident beam must have positive intensity.")
+        raise ValueError("The intensity of the incident beam cannot be negative.")
     if there_is_beam_source:
         if not (0 < mu0 and mu0 <= 1):
             raise ValueError("The cosine of the polar angle of the incident beam must be between 0 and 1, excluding 0.")
@@ -345,6 +346,7 @@ def pydisort(
                 np.max(b_pos),
                 np.max(b_neg),
                 scaled_s_poly_coeffs[0, 0],
+                scaled_s_poly_coeffs[-1, :] @ (scaled_tau_arr_with_0[-1] ** np.arange(Nscoeffs))
             )
         )
         I0 = (I0 / rescale_factor).copy()
@@ -353,9 +355,10 @@ def pydisort(
         scaled_s_poly_coeffs = (scaled_s_poly_coeffs / rescale_factor).copy()
     else:
         rescale_factor = np.max((I0, np.max(b_pos), np.max(b_neg)))
-        I0 = (I0 / rescale_factor).copy()
-        b_pos = (b_pos / rescale_factor).copy()
-        b_neg = (b_neg / rescale_factor).copy()
+        if rescale_factor != 0:
+            I0 = (I0 / rescale_factor).copy()
+            b_pos = (b_pos / rescale_factor).copy()
+            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:
@@ -667,7 +670,7 @@ def pydisort(
             tau = np.atleast_1d(tau)
             phi = np.atleast_1d(phi)
             NT_corrections = TMS_correction(tau, phi, is_antiderivative_wrt_tau)
-
+            
             if autograd_compatible:
                 NT_corrections = NT_corrections + np.concatenate(
                     [np.zeros((N, len(tau), len(phi))), IMS_correction(tau, phi, is_antiderivative_wrt_tau)], axis=0

PythonicDISORT/subroutines.py

@@ -12,13 +12,13 @@ def transform_interval(arr, c, d, a, b):
     arr : array
         The 1D array to transform.
     c : float
-        The beginning of interval [c, d].
+        Lower bound of interval [c, d].
     d : float
-        The end of interval [c, d].
+        Upper bound of interval [c, d].
     a : float, optional
-        The beginning of interval [a, b].
+        Lower bound of interval [a, b].
     b : float, optional
-        The end of interval [a, b].
+        Upper bound of interval [a, b].
 
     Returns
     -------
@@ -38,13 +38,13 @@ def transform_weights(weights, c, d, a, b):
     weights : array
         The weights to transform.
     c : float
-        The beginning of interval [c, d].
+        Lower bound of interval [c, d].
     d : float
-        The end of interval [c, d].
+        Upper bound of interval [c, d].
     a : float, optional
-        The beginning of interval [a, b].
+        Lower bound of interval [a, b].
     b : float, optional
-        The end of interval [a, b].
+        Upper bound of interval [a, b].
 
     Returns
     -------
@@ -95,9 +95,9 @@ def Gauss_Legendre_quad(N, c=0, d=1):
     N : int (will be converted to int)
         Number of quadrature nodes.
     c : float, optional
-        Start of integration interval.
+        Lower bound of integration interval.
     d : float, optional
-        End of integration interval.
+        Upper bound of integration interval.
 
     Returns
     -------
@@ -248,18 +248,18 @@ def generate_diff_act_flux_funcs(u0):
         Actinic flux function with argument ``tau`` (type: array) for positive (upward) ``mu`` values.
         Returns the diffuse flux magnitudes (type: array).
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
     Fm_act(tau) : function
         Actinic flux function with argument ``tau`` (type: array) for negative (downward) ``mu`` values.
         Returns the diffuse flux magnitudes (type: array).
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
 
     """
     N = len(u0(0)) // 2
-    GL_weights = Gauss_Legendre_quad(N, 0, 1)[1]
+    GL_weights = Gauss_Legendre_quad(N)[1]
 
     # Note that the zeroth axis of the array u0(tau) captures variation with mu
     def flux_act_up(tau, is_antiderivative_wrt_tau=False, return_tau_arr=False):
@@ -314,11 +314,12 @@ def Planck(T, WVNM):
     not_zeros_ind = T != 0
     
     results = np.zeros(len(T))
-    results[~not_zeros_ind] = 0
-    
-    # Coded in this way to prevent overflow
-    expterm = np.exp(-100 * sc.constants.h * sc.constants.c * WVNM / (sc.constants.k * T[not_zeros_ind]))
-    results[not_zeros_ind] = (2e8 * sc.constants.h * sc.constants.c**2 * WVNM**3 * expterm) / (1 - expterm)
+    if np.sum(not_zeros_ind) > 0:
+        results[~not_zeros_ind] = 0
+        
+        # Coded in this way to prevent overflow
+        expterm = np.exp(-100 * sc.constants.h * sc.constants.c * WVNM / (sc.constants.k * T[not_zeros_ind]))
+        results[not_zeros_ind] = (2e8 * sc.constants.h * sc.constants.c**2 * WVNM**3 * expterm) / (1 - expterm)
         
     return np.squeeze(results)[()]
     
@@ -383,11 +384,12 @@ def linear_spline_coefficients(x, y, check_inputs=True):
 
 
 
-def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, **kwargs):
+def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, omega_arr=None, **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.
-    Users will have to manually adjust emissivities, however, and they should note that PythonicDISORT allows much
-    more flexibility in choosing blackbody emission profiles than DISORT.
+    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.
     
     Parameters
     ----------
@@ -400,6 +402,8 @@ def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, **kwargs):
         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``.
         
@@ -413,12 +417,35 @@ def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, **kwargs):
     """
     tau_arr = np.atleast_1d(tau_arr)
     if not len(TEMPER) == len(tau_arr) + 1:
-        raise ValueError("Missing temperature specification at some boundaries / interfaces.")
-    
+        raise ValueError(
+            "Missing temperature specification at some boundaries / interfaces."
+        )
+
     tau_arr_with_0 = np.insert(tau_arr, 0, 0)
-    blackbody_emission_at_each_boundary = sc.integrate.quad_vec(lambda WVNM: Planck(TEMPER, WVNM), WVNMLO, WVNMHI, **kwargs)[0]
-    
-    return linear_spline_coefficients(tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False)
+    blackbody_emission_at_each_boundary = sc.integrate.quad_vec(
+        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]
+        )
 
 
 
@@ -432,17 +459,24 @@ def generate_emissivity_from_BDRF(N, zeroth_BDRF_Fourier_mode):
     ----------
     N : int
         Number of upper hemisphere quadrature nodes. Equal to ``NQuad // 2``.
-    zeroth_BDRF_Fourier_mode : function
+    zeroth_BDRF_Fourier_mode : function or float
         Zeroth BDRF Fourier mode with arguments ``mu, -mu_p`` of type array
         and which output has the same dimensions as the outer product of the two arrays.
+        A scalar input represents a constant function and in that case the output 
+        is simply one minus the scalar input.
 
     Returns
     -------
-    array
+    array or float
         Emissivity for the blackbody contribution to the lower boundary source ``b_neg``.
     """
-    mu_arr_pos, W = Gauss_Legendre_quad(N)
-    return 1 - 2 * zeroth_BDRF_Fourier_mode(mu_arr_pos, mu_arr_pos) * mu_arr_pos[None, :] @ W
+    if np.isscalar(zeroth_BDRF_Fourier_mode):
+        return 1 - zeroth_BDRF_Fourier_mode
+    else:
+        mu_arr_pos, W = Gauss_Legendre_quad(N)
+        return (
+            1 - 2 * zeroth_BDRF_Fourier_mode(mu_arr_pos, mu_arr_pos) * mu_arr_pos[None, :] @ W
+        )
 
 
 
@@ -457,8 +491,9 @@ def cache_BDRF_Fourier_modes(N, mu0, BDRF_Fourier_modes):
         Number of upper hemisphere quadrature nodes. Equal to ``NQuad // 2``.
     mu0 : float
         Cosine of polar angle of the incident beam.
-    BDRF_Fourier_modes : list of functions
-        BDRF Fourier modes, each a scalar, or a function with arguments ``mu, -mu_p`` of type array
+    BDRF_Fourier_modes : list of functions and scalars
+        BDRF Fourier modes, each a scalar representing a constant function, 
+        or a function with arguments ``mu, -mu_p`` of type array
         which output has the same dimensions as the outer product of the two arrays.
 
     Returns
@@ -471,7 +506,7 @@ def cache_BDRF_Fourier_modes(N, mu0, BDRF_Fourier_modes):
     NBDRF = len(BDRF_Fourier_modes)
     mu_arr_pos = Gauss_Legendre_quad(N)[0]
 
-    [
+    BDRF_Fourier_modes_evaluated = [
         (
             None
             if np.isscalar(BDRF_Fourier_modes[m])
@@ -551,15 +586,16 @@ def interpolate(u):
     -------
     u_interpol : function
         Intensity function with arguments ``(mu, tau, phi)`` (for ``u``) 
-        or ``(mu, tau)`` (for ``u0``) each of type array or float.
+        or ``(mu, tau)`` (for ``u0``) each an array or scalar.
         Returns an ndarray with axes corresponding to variation with each argument in the same order.
         Pass ``is_antiderivative_wrt_tau = True`` (defaults to ``False``)
-        to switch to an antiderivative of the function with respect to ``tau``.
+        to switch to an antiderivative of this function with respect to ``tau``.
         Pass ``return_Fourier_error = True`` (defaults to ``False``) to return the 
         Cauchy / Fourier convergence evaluation (type: float) for the last Fourier term.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
 
     """
+    
     N = len(u(0, 0)) // 2
     mu_arr_pos = Gauss_Legendre_quad(N)[0]
     
@@ -774,18 +810,19 @@ def _mathscr_v(tau,                              # Input optical depths
 def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
     """Performs pointwise comparisons between results from Stamnes' DISORT,
     which are stored in ``.npz`` files, against results from PythonicDISORT. Used in our PyTests.
-
+    See the ``*_test`` Jupyter Notebooks to see how this function is used and the arguments that go into it.
+    
     """
     # Load saved results from Stamnes' DISORT
     flup = results["flup"]
     rfldn = results["rfldn"]
     rfldir = results["rfldir"]
-    if u != None:
+    if u is not None:
         uu = results["uu"]
 
     # Load comparison points
     tau_test_arr = results["tau_test_arr"]
-    if u != None:
+    if u is not None:
         phi_arr = results["phi_arr"]
 
     # Perform and print the comparisons
@@ -800,7 +837,7 @@ def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
         diff_flux_up,
         flup,
         out=np.zeros_like(diff_flux_up),
-        where=flup > 1e-8,
+        where=(flup != 0),
     )
     print("Difference =", np.max(diff_flux_up))
     print("Difference ratio =", np.max(ratio_flux_up))
@@ -813,7 +850,7 @@ def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
         diff_flux_down_diffuse,
         rfldn,
         out=np.zeros_like(diff_flux_down_diffuse),
-        where=rfldn > 1e-8,
+        where=(rfldn != 0),
     )
     print("Difference =", np.max(diff_flux_down_diffuse))
     print(
@@ -829,7 +866,7 @@ def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
         diff_flux_down_direct,
         rfldir,
         out=np.zeros_like(diff_flux_down_direct),
-        where=rfldir > 1e-8,
+        where=(rfldir != 0),
     )
     print("Difference =", np.max(diff_flux_down_direct))
     print(
@@ -838,14 +875,15 @@ def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
     )
     print()
     
-    if u != None:
+    if u is not None:
         # Intensity
-        diff = np.abs(uu - u(tau_test_arr, phi_arr)[reorder_mu])[mu_to_compare]
+        u_cache = u(tau_test_arr, phi_arr)[reorder_mu].reshape(np.shape(uu))
+        diff = np.abs(uu - u_cache)[mu_to_compare]
         diff_ratio = np.divide(
             diff,
             uu[mu_to_compare],
             out=np.zeros_like(diff),
-            where=uu[mu_to_compare] > 1e-8,
+            where=(uu[mu_to_compare] != 0),
         )
         max_diff_tau_index = np.argmax(np.max(np.max(diff, axis=0), axis=1))
         max_ratio_tau_index = np.argmax(np.max(np.max(diff_ratio, axis=0), axis=1))

{pythonicdisort-1.0.2.dist-info → pythonicdisort-1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.0.2
+Version: 1.1
 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

pythonicdisort-1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
+PythonicDISORT/_assemble_intensity_and_fluxes.py,sha256=H7XxaRBHNIxNZsB49onFcU1hAsBIFWCeTBJ4NhoCT4w,29926
+PythonicDISORT/_solve_for_coeffs.py,sha256=Bb-C5OJt355x8_v8WFB2sJutBtSTAFNIX4OxLQJk9-0,16539
+PythonicDISORT/_solve_for_gen_and_part_sols.py,sha256=NVAFve6FNIEiku4xqaXBAI4G2HYIbhjcLC_B0nhGXXM,13131
+PythonicDISORT/pydisort.py,sha256=jiPMLw-zcwRoZQq2IjZhAxiuHlhC3yY72wvAxAepfgg,39113
+PythonicDISORT/subroutines.py,sha256=rf36t8coXQdnMb0NrEfgrOWDWZHkkH6KDIE3COueEbQ,34034
+pythonicdisort-1.1.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
+pythonicdisort-1.1.dist-info/METADATA,sha256=boJu4nE6zzVbJrwuVJWv2M3PTQhJpoS87XeS9M8ki2U,8308
+pythonicdisort-1.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+pythonicdisort-1.1.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
+pythonicdisort-1.1.dist-info/RECORD,,

pythonicdisort-1.0.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
-PythonicDISORT/_assemble_intensity_and_fluxes.py,sha256=M9mS2tD-GvMgze2MnHZEIarv7bpJsVe32fVPUEn0YpE,29911
-PythonicDISORT/_solve_for_coeffs.py,sha256=Bb-C5OJt355x8_v8WFB2sJutBtSTAFNIX4OxLQJk9-0,16539
-PythonicDISORT/_solve_for_gen_and_part_sols.py,sha256=_sPHgBTn58nOO0u13WCmCiDa6Qbv4HEu-7F_auFUcG4,13089
-PythonicDISORT/pydisort.py,sha256=xeHeW_XcQwSwLYTwYr2tnBUPnu0RqSTrOppO2KEHiT8,38865
-PythonicDISORT/subroutines.py,sha256=BFd0RqtmqzYF8J_ZE8KZB7GE5cl6ARHzbxqy0ewulbg,32517
-pythonicdisort-1.0.2.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
-pythonicdisort-1.0.2.dist-info/METADATA,sha256=-AEj3RRB4SbPh8aydWQtNmBlORzSEhjQ-kEhTjy9WBk,8310
-pythonicdisort-1.0.2.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-pythonicdisort-1.0.2.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
-pythonicdisort-1.0.2.dist-info/RECORD,,