PyPI - PythonicDISORT - Versions diffs - 1.1__tar.gz → 1.3__tar.gz - Mend

PythonicDISORT 1.1tar.gz → 1.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

{pythonicdisort-1.1/src/PythonicDISORT.egg-info → pythonicdisort-1.3}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.1
+Version: 1.3
 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.3}/README.md RENAMED Viewed

@@ -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.3}/pyproject.toml RENAMED Viewed

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

{pythonicdisort-1.1 → pythonicdisort-1.3}/src/PythonicDISORT/_assemble_intensity_and_fluxes.py RENAMED Viewed

@@ -9,14 +9,15 @@ def _assemble_intensity_and_fluxes(
     scaled_omega_arr,                   # Delta-scaled single-scattering albedos
     tau_arr,                            # Lower boundary of layers
     scaled_tau_arr_with_0,              # Delta-scaled lower boundary of layers with 0 inserted in front
-    mu_arr_pos, mu_arr,                 # Quadrature nodes for 1) upper 2) both hemispheres
-    M_inv, W,                           # 1) 1 / mu; 2) quadrature weights for each hemisphere
+    mu_arr_pos,                         # Upper hemisphere quadrature nodes (cosine polar angles)
+    M_inv, W,                           # 1) 1 / `mu_arr_pos`; 2) quadrature weights for each hemisphere
     N, NQuad, NLeg,                     # Number of 1) upper 2) both hemispheres quadrature nodes; 3) phase function Legendre coefficients
     NFourier, NLayers, NBDRF,           # Number of 1) intensity Fourier modes; 2) layers; 3) BDRF Fourier modes
     is_atmos_multilayered,              # Is the atmosphere multilayered?
     weighted_scaled_Leg_coeffs,         # Weighted and delta-scaled Legendre coefficients
     BDRF_Fourier_modes,                 # BDRF Fourier modes
-    mu0, I0, rescale_factor, phi0,      # Properties of the direct beam
+    mu0, I0, I0_div_4pi,                # Primary direct beam parameters
+    rescale_factor, phi0,               # Secondary direct beam parameters
     there_is_beam_source,               # Is there a beam source?
     b_pos, b_neg,                       # Dirichlet BCs
     b_pos_is_scalar, b_neg_is_scalar,   # Is each Dirichlet BCs scalar and so isotropic?
@@ -47,7 +48,6 @@ def _assemble_intensity_and_fluxes(
     | `tau_arr`                      | `NLayers`                                    |
     | `scaled_tau_arr_with_0`        | `NLayers + 1`                                |
     | `mu_arr_pos`                   | `NQuad/2`                                    |
-    | `mu_arr`                       | `NQuad`                                      |
     | `M_inv`                        | `NQuad/2`                                    |
     | `W`                            | `NQuad/2`                                    |
     | `N`                            | scalar                                       |
@@ -61,6 +61,7 @@ def _assemble_intensity_and_fluxes(
     | `BDRF_Fourier_modes`           | `NBDRF`                                      |
     | `mu0`                          | scalar                                       |
     | `I0`                           | scalar                                       |
+    | `I0_div_4pi`                   | scalar                                       |
     | `rescale_factor`               | scalar                                       |
     | `phi0`                         | scalar                                       |
     | `there_is_beam_source`         | scalar                                       |
@@ -83,7 +84,7 @@ def _assemble_intensity_and_fluxes(
     | ----------------- | -------------------------------------- |
     | `G_collect`       | `NFourier x NLayers x NQuad x NQuad`   |
     | `G_collect_0`     | `NLayers x NQuad x NQuad`              |
-    | `G_inv_collect_0` | `NLayers x NQuad x NQuad` or `None`    |
+    | `G_inv_mu_inv`    | `NLayers x NQuad x NQuad` or `None`    |
     | `K_collect`       | `NFourier x NLayers x NQuad`           |
     | `K_collect_0`     | `NLayers x NQuad`                      |
     | `B_collect`       | `NFourier x NLayers x NQuad` or `None` |
@@ -108,45 +109,45 @@ def _assemble_intensity_and_fluxes(
     outputs = _solve_for_gen_and_part_sols(
         NFourier,
         scaled_omega_arr,
-        mu_arr_pos, mu_arr,
+        mu_arr_pos,
         M_inv, W,
         N, NQuad, NLeg,
         NLayers,
         weighted_scaled_Leg_coeffs,
-        mu0, I0,
+        mu0, I0_div_4pi,
         there_is_beam_source,
-        Nscoeffs,
         there_is_iso_source,
     )
     if there_is_beam_source and there_is_iso_source:
         G_collect, K_collect, B_collect, G_inv_collect_0 = outputs
         B_collect_0 = B_collect[0, :, :]
+        G_inv_mu_inv = G_inv_collect_0 @ np.concatenate([M_inv, -M_inv])
     elif there_is_beam_source and not there_is_iso_source:
         G_collect, K_collect, B_collect = outputs
         B_collect_0 = B_collect[0, :, :]
-        G_inv_collect_0 = None
+        G_inv_mu_inv = None
     elif not there_is_beam_source and there_is_iso_source:
         G_collect, K_collect, G_inv_collect_0 = outputs
         B_collect = None
+        G_inv_mu_inv = G_inv_collect_0 @ np.concatenate([M_inv, -M_inv])
     else:
         G_collect, K_collect = outputs
         B_collect = None
-        G_inv_collect_0 = None
+        G_inv_mu_inv = None
     GC_collect = _solve_for_coeffs(
         NFourier,
         G_collect,
         K_collect,
         B_collect,
-        G_inv_collect_0,
+        G_inv_mu_inv,
         scaled_tau_arr_with_0,
-        mu_arr, mu_arr_pos, mu_arr_pos * W,
+        mu_arr_pos, mu_arr_pos * W,
         N, NQuad,
         NLayers, NBDRF,
         is_atmos_multilayered,
         BDRF_Fourier_modes,
-        mu0, I0,
+        mu0, I0_div_4pi,
         there_is_beam_source,
         b_pos, b_neg,
         b_pos_is_scalar, b_neg_is_scalar,
@@ -166,7 +167,7 @@ def _assemble_intensity_and_fluxes(
         # Construct the intensity function (refer to section 3.7 of the Comprehensive Documentation)
         # --------------------------------------------------------------------------------------------------------------------------
-        def u(tau, phi, is_antiderivative_wrt_tau=False, return_Fourier_error=False, return_tau_arr=False):
+        def u(tau, phi, is_antiderivative_wrt_tau=False, return_Fourier_error=False, return_tau_arr=False, *, _return_l=False):
             """
             Intensity function with arguments `(tau, phi)` of types `(array or float, array or float)`.
             Returns an ndarray with axes corresponding to variation with `mu, tau, phi` respectively.
@@ -182,7 +183,7 @@ def _assemble_intensity_and_fluxes(
             # Atmospheric layer indices
             l = np.argmax(tau[:, None] <= tau_arr[None, :], axis=1)
-            scaled_tau_arr_l = scaled_tau_arr_with_0[l + 1]
+            scaled_tau_arr_l = scaled_tau_arr_with_0[1:][l]
             scaled_tau_arr_lm1 = scaled_tau_arr_with_0[l]
             # Delta-M scaling
@@ -201,60 +202,65 @@ 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.transpose(0, 2, 1) / (-scale_tau / mu0)[None, None, :]
+                    )[:, :, l] * np.exp(-scaled_tau / mu0)[None, None, :]
                 um = (
                     np.einsum(
-                        "mtij, mtj -> mti",
+                        "mtij, mtj -> mit",
                         GC_collect[:, l, :, :],
                         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]
+                    + direct_beam_contribution
                 )
-            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,
-                )
-            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.transpose(0, 2, 1)[:, :, l]
+                        * np.exp(-scaled_tau / mu0)[None, None, :]
+                    )
+                um = (
+                    np.einsum(
+                        "mtij, mtj -> mit", GC_collect[:, 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)
                 _mathscr_v_contribution = _mathscr_v(
-                    scaled_tau, l_inv, Nscoeffs,
+                    scaled_tau, l_inv,
+                    Nscoeffs,
                     scaled_s_poly_coeffs[l_uniq],
                     G_collect_0[l_uniq],
                     K_collect_0[l_uniq],
-                    G_inv_collect_0[l_uniq],
-                    mu_arr,
+                    G_inv_mu_inv[l_uniq],
                     is_antiderivative_wrt_tau,
                     autograd_compatible,
                 )
                 if NFourier == 1:
-                    um = um + _mathscr_v_contribution.T
+                    um = um + _mathscr_v_contribution
                 elif autograd_compatible:
-                    um = um + np.concatenate((_mathscr_v_contribution.T, np.zeros((NFourier - 1, len(tau), NQuad))))
+                    um = np.concatenate((um[[0], :, :] + _mathscr_v_contribution, um[1:, :, :]), axis=0)
                 else:
-                    um[0, :, :] += _mathscr_v_contribution.T
+                    um[0, :, :] += _mathscr_v_contribution
-            u = np.einsum(
-                "mti, mp -> itp",
-                um,
-                np.cos(np.arange(NFourier)[:, None] * (phi0 - phi)[None, :]),
-                optimize=True,
+            u = np.sum(
+                um[:, :, :, None]
+                * np.cos(np.arange(NFourier)[:, None] * (phi0 - phi)[None, :])[:, None, None, :],
+                axis=0,
             )
+            outputs = (rescale_factor * np.squeeze(u),)
+            output_is_tuple = False
             if return_Fourier_error:
                 exponent = np.concatenate(
@@ -264,7 +270,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 +285,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 +308,25 @@ 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,)
+                output_is_tuple = True
+            if return_tau_arr:
+                outputs += (tau_arr,)
+                output_is_tuple = True
+            if _return_l: # This indicates to the function that NT corrections are activated
+                output_is_tuple = True
+                outputs += (l,)
+                if there_is_iso_source:
+                    # The TMS correction will use these
+                    outputs += (l_uniq, l_inv)
+            return outputs if output_is_tuple else outputs[0]
         # --------------------------------------------------------------------------------------------------------------------------
     # Construct u0
@@ -332,7 +347,7 @@ def _assemble_intensity_and_fluxes(
         # Atmospheric layer indices
         l = np.argmax(tau[:, None] <= tau_arr[None, :], axis=1)
-        scaled_tau_arr_l = scaled_tau_arr_with_0[l + 1]
+        scaled_tau_arr_l = scaled_tau_arr_with_0[1:][l]
         scaled_tau_arr_lm1 = scaled_tau_arr_with_0[l]
         # Delta-M scaling
@@ -363,7 +378,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,48 +392,46 @@ 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)
             _mathscr_v_contribution = _mathscr_v(
-                scaled_tau, l_inv, Nscoeffs,
+                scaled_tau, l_inv,
+                Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq],
                 K_collect_0[l_uniq],
-                G_inv_collect_0[l_uniq],
-                mu_arr,
+                G_inv_mu_inv[l_uniq],
                 is_antiderivative_wrt_tau,
                 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)
@@ -437,7 +456,7 @@ def _assemble_intensity_and_fluxes(
         # Atmospheric layer indices
         l = np.argmax(tau[:, None] <= tau_arr[None, :], axis=1)
-        scaled_tau_arr_l = scaled_tau_arr_with_0[l + 1]
+        scaled_tau_arr_l = scaled_tau_arr_with_0[1:][l]
         scaled_tau_arr_lm1 = scaled_tau_arr_with_0[l]
         # Delta-M scaling
@@ -451,27 +470,18 @@ def _assemble_intensity_and_fluxes(
         if there_is_iso_source:
             l_uniq, l_inv = np.unique(l, return_inverse=True)
             _mathscr_v_contribution = _mathscr_v(
-                scaled_tau, l_inv, Nscoeffs,
+                scaled_tau, l_inv,
+                Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq, :N, :],
                 K_collect_0[l_uniq],
-                G_inv_collect_0[l_uniq],
-                mu_arr,
+                G_inv_mu_inv[l_uniq],
                 is_antiderivative_wrt_tau,
                 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],
@@ -480,7 +490,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 +507,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:
@@ -518,7 +538,7 @@ def _assemble_intensity_and_fluxes(
         # Atmospheric layer indices
         l = np.argmax(tau[:, None] <= tau_arr[None, :], axis=1)
-        scaled_tau_arr_l = scaled_tau_arr_with_0[l + 1]
+        scaled_tau_arr_l = scaled_tau_arr_with_0[1:][l]
         scaled_tau_arr_lm1 = scaled_tau_arr_with_0[l]
         # Delta-M scaling
@@ -532,31 +552,18 @@ def _assemble_intensity_and_fluxes(
         if there_is_iso_source:
             l_uniq, l_inv = np.unique(l, return_inverse=True)
             _mathscr_v_contribution = _mathscr_v(
-                scaled_tau, l_inv, Nscoeffs,
+                scaled_tau, l_inv,
+                Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq, N:, :],
                 K_collect_0[l_uniq],
-                G_inv_collect_0[l_uniq],
-                mu_arr,
+                G_inv_mu_inv[l_uniq],
                 is_antiderivative_wrt_tau,
                 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],
@@ -565,18 +572,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__tar.gz → 1.3__tar.gz

PythonicDISORT 1.1tar.gz → 1.3tar.gz