PythonicDISORT 1.0.3__py3-none-any.whl → 1.2__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)
@@ -200,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",
@@ -208,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
@@ -238,7 +241,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:
@@ -254,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(
@@ -263,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",
@@ -271,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(
@@ -298,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
@@ -323,7 +331,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]):
@@ -362,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",
@@ -370,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)
@@ -400,18 +410,20 @@ 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
             
-        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)
@@ -428,7 +440,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,20 +469,11 @@ 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
         
-        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],
@@ -479,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",
@@ -490,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:
@@ -509,7 +522,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,24 +551,11 @@ 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
-        
-        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],
@@ -564,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:
@@ -592,6 +606,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,33 +205,17 @@ 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, :, :]
             )
 
         # --------------------------------------------------------------------------------------------------------------------------
 
-        
-    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/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,23 @@ 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):
+        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.")
     # 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.")
@@ -255,13 +257,13 @@ 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.")
     # 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.")
@@ -315,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 
@@ -345,6 +354,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,12 +363,13 @@ 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:
+    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 ##############################
@@ -667,7 +678,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)[()]
     
@@ -386,8 +387,8 @@ def linear_spline_coefficients(x, y, check_inputs=True):
 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.
-    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.
+    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
     ----------
@@ -413,12 +414,19 @@ 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]
+
+    return linear_spline_coefficients(
+        tau_arr_with_0, blackbody_emission_at_each_boundary, check_inputs=False
+    )
+
 
 
 
@@ -432,17 +440,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 +472,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
@@ -551,15 +567,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 +791,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 +818,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 +831,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 +847,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 +856,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.3.dist-info → pythonicdisort-1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.0.3
+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.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
+PythonicDISORT/_assemble_intensity_and_fluxes.py,sha256=okORQDxUWZgmMZmIRPNzIOqk8UQAcoc7o8Wr3wxrgDc,29261
+PythonicDISORT/_solve_for_coeffs.py,sha256=Bb-C5OJt355x8_v8WFB2sJutBtSTAFNIX4OxLQJk9-0,16539
+PythonicDISORT/_solve_for_gen_and_part_sols.py,sha256=InZPpyRkfmt7gq5r64FPHjXJVMV41ixZygJd4pWpLI4,12461
+PythonicDISORT/pydisort.py,sha256=ULGw_fqcnC7JQ3voJr9oKlaB3yrDI_sKe5jOU0Xj2Rc,40043
+PythonicDISORT/subroutines.py,sha256=d0mjOgxqSFoNZnLmOkuSWqO3HjojR9S-2orGZSdGJkU,33208
+pythonicdisort-1.2.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
+pythonicdisort-1.2.dist-info/METADATA,sha256=PLXXaPDMmva47U6AM6cNFSrb0J-FT9xCkiww8tsvE3c,8297
+pythonicdisort-1.2.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+pythonicdisort-1.2.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
+pythonicdisort-1.2.dist-info/RECORD,,

pythonicdisort-1.0.3.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=HNZIeAihmouboHk4L--ajI4ww7O-dFKUZI1S1J-0H78,32548
-pythonicdisort-1.0.3.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
-pythonicdisort-1.0.3.dist-info/METADATA,sha256=stYzyWETkJTPxBAOmmIuAQngjKdS9tBCnoFaftB1TAQ,8310
-pythonicdisort-1.0.3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-pythonicdisort-1.0.3.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
-pythonicdisort-1.0.3.dist-info/RECORD,,