PythonicDISORT 1.3__tar.gz → 1.5__tar.gz

{pythonicdisort-1.3/src/PythonicDISORT.egg-info → pythonicdisort-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.3
+Version: 1.5
 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
@@ -18,6 +18,7 @@ Provides-Extra: notebook-dependencies
 Requires-Dist: autograd>=1.5; extra == "notebook-dependencies"
 Requires-Dist: jupyter>1.0.0; extra == "notebook-dependencies"
 Requires-Dist: notebook>6.5.2; extra == "notebook-dependencies"
+Requires-Dist: matplotlib>=3.6.0; extra == "notebook-dependencies"
 
 [![Run PyTests](https://github.com/LDEO-CREW/Pythonic-DISORT/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/LDEO-CREW/Pythonic-DISORT/actions/workflows/continuous_integration.yml)
 [![DOI](https://joss.theoj.org/papers/10.21105/joss.06442/status.svg)](https://doi.org/10.21105/joss.06442)
@@ -70,6 +71,7 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * 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)
+* Test Problem I: Antiderivative / integration functionality (no corresponding Jupyter Notebook)
 
 # Installation
 
@@ -81,15 +83,16 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Python 3.8+
 * `numpy >= 1.8.0`
 * `scipy >= 1.8.0`
+* (OPTIONAL) `autograd >= 1.5` (`autograd` can be used to compute gradients of the output functions)
 * (OPTIONAL) `pytest >= 6.2.5` (Required to use the command `pytest`, see *PyTest and examples of how to use PythonicDISORT*)
 
 ## (OPTIONAL) Additional requirements to run the Jupyter Notebook
-* `autograd >= 1.5`
 * `jupyter > 1.0.0`
 * `notebook > 6.5.2`
 * `matplotlib >= 3.6.0`
 
-In addition, a F2PY-wrapped Stamnes' DISORT, or equivalent, is required to properly run the last section (section 6).
+In addition, a F2PY-wrapped Stamnes' DISORT or equivalent (https://github.com/kconnour/pyRT_DISORT may work) 
+is required to properly run the last section (section 6).
 
 ## Compatibility
 
@@ -127,3 +130,4 @@ Science and Technology Center (STC) (Award #2019625) under which this package wa
 12) T. Nakajima and M. Tanaka. 1988. *Algorithms for radiative intensity calculations in moderately thick atmospheres using a truncation approximation.* https://www.sciencedirect.com/science/article/pii/0022407388900313.
 
 13) Connour, Kyle and Wolff, Michael. 2020. *pyRT_DISORT: A pre-processing front-end to help make DISORT simulations easier in Python.* https://github.com/kconnour/pyRT_DISORT.
+

{pythonicdisort-1.3 → pythonicdisort-1.5}/README.md

@@ -49,6 +49,7 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * 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)
+* Test Problem I: Antiderivative / integration functionality (no corresponding Jupyter Notebook)
 
 # Installation
 
@@ -60,15 +61,16 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Python 3.8+
 * `numpy >= 1.8.0`
 * `scipy >= 1.8.0`
+* (OPTIONAL) `autograd >= 1.5` (`autograd` can be used to compute gradients of the output functions)
 * (OPTIONAL) `pytest >= 6.2.5` (Required to use the command `pytest`, see *PyTest and examples of how to use PythonicDISORT*)
 
 ## (OPTIONAL) Additional requirements to run the Jupyter Notebook
-* `autograd >= 1.5`
 * `jupyter > 1.0.0`
 * `notebook > 6.5.2`
 * `matplotlib >= 3.6.0`
 
-In addition, a F2PY-wrapped Stamnes' DISORT, or equivalent, is required to properly run the last section (section 6).
+In addition, a F2PY-wrapped Stamnes' DISORT or equivalent (https://github.com/kconnour/pyRT_DISORT may work) 
+is required to properly run the last section (section 6).
 
 ## Compatibility
 
@@ -106,3 +108,4 @@ Science and Technology Center (STC) (Award #2019625) under which this package wa
 12) T. Nakajima and M. Tanaka. 1988. *Algorithms for radiative intensity calculations in moderately thick atmospheres using a truncation approximation.* https://www.sciencedirect.com/science/article/pii/0022407388900313.
 
 13) Connour, Kyle and Wolff, Michael. 2020. *pyRT_DISORT: A pre-processing front-end to help make DISORT simulations easier in Python.* https://github.com/kconnour/pyRT_DISORT.
+

{pythonicdisort-1.3 → pythonicdisort-1.5}/pyproject.toml

@@ -8,7 +8,7 @@ dependencies = [
   "scipy>=1.8.0",
 ]
 name = "PythonicDISORT"
-version = "1.3"
+version = "1.5"
 authors = [
   { name="Dion HO Jia Xu", email="dh3065@columbia.edu" },
 ]
@@ -27,6 +27,7 @@ notebook_dependencies = [
 	"autograd>=1.5",
 	"jupyter>1.0.0",
 	"notebook>6.5.2",
+	"matplotlib >= 3.6.0",
 ]
 
 [project.urls]

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT/_assemble_intensity_and_fluxes.py

@@ -236,7 +236,7 @@ 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, 
+                    scaled_tau, scale_tau, l_inv, 
                     Nscoeffs,
                     scaled_s_poly_coeffs[l_uniq],
                     G_collect_0[l_uniq],
@@ -411,7 +411,7 @@ 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,
+                scaled_tau, scale_tau, l_inv,
                 Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq],
@@ -470,7 +470,7 @@ 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,
+                scaled_tau, scale_tau, l_inv,
                 Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq, :N, :],
@@ -552,7 +552,7 @@ 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,
+                scaled_tau, scale_tau, l_inv,
                 Nscoeffs,
                 scaled_s_poly_coeffs[l_uniq],
                 G_collect_0[l_uniq, N:, :],

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT/_solve_for_coeffs.py

@@ -168,7 +168,8 @@ def _solve_for_coeffs(
         if m_equals_0 and there_is_iso_source:
             # Top boundary
             RHS[:N] -= _mathscr_v(
-                        np.array([0]), 
+                        np.array([0]),
+                        None,
                         np.array([0]),
                         Nscoeffs,
                         scaled_s_poly_coeffs[[0], :],
@@ -183,6 +184,7 @@ def _solve_for_coeffs(
                 RHS[N:-N] += (
                     _mathscr_v(
                         scaled_tau_arr_with_0[1:-1],
+                        None,
                         indices,
                         Nscoeffs,
                         scaled_s_poly_coeffs[indicesp1],
@@ -192,6 +194,7 @@ def _solve_for_coeffs(
                     )
                     - _mathscr_v(
                         scaled_tau_arr_with_0[1:-1],
+                        None,
                         indices,
                         Nscoeffs,
                         scaled_s_poly_coeffs[indices],
@@ -203,7 +206,8 @@ def _solve_for_coeffs(
                 
             # Bottom boundary
             RHS[-N:] -= _mathscr_v(
-                scaled_tau_arr_with_0[[-1]], 
+                scaled_tau_arr_with_0[[-1]],
+                None,
                 np.array([0]),
                 Nscoeffs,
                 scaled_s_poly_coeffs[[-1], :],
@@ -217,6 +221,7 @@ def _solve_for_coeffs(
                     R
                     @ _mathscr_v(
                         scaled_tau_arr_with_0[[-1]],
+                        None,
                         np.array([0]),
                         Nscoeffs,
                         scaled_s_poly_coeffs[[-1], :],

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT/_solve_for_gen_and_part_sols.py

@@ -198,7 +198,8 @@ def _solve_for_gen_and_part_sols(
         G_collect[no_shortcut_indices, N:, :N] = GpG_m_GmG_div_2
         
         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
+        len_no_shortcut_indices_0 = len(no_shortcut_indices_0)
+        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[no_shortcut_indices_0, :, :]
             )
@@ -209,10 +210,25 @@ def _solve_for_gen_and_part_sols(
         
             # Solve for particular solution w.r.t. direct beam source (refer to section 3.6.1 of the Comprehensive Documentation)
             # --------------------------------------------------------------------------------------------------------------------------
-            A_arr[:, :N, N:] = -A_arr[:, N:, :N]
-            A_arr[:, :N, :N] = -A_arr[:, N:, N:]
-            A_arr.reshape(-1, NQuad * NQuad)[:, ::NQuad + 1] += 1 / mu0
-            B_collect[no_shortcut_indices, :] = np.linalg.solve(A_arr, X_arr[no_shortcut_indices, :, None]).squeeze(-1)
+            if len_no_shortcut_indices_0 > 0: # In this case we have `G_inv_collect_0`, so use it
+                B_collect[no_shortcut_indices_0, :] = np.einsum(
+                    "bij, bjk, bk -> bi",
+                    # Note that the minus sign has been absorbed into `X_arr`
+                    G_collect[no_shortcut_indices_0, :, :]
+                    / (1 / mu0 + K_collect[no_shortcut_indices_0, None, :]),
+                    G_inv_collect_0[no_shortcut_indices_0, :, :],
+                    X_arr[no_shortcut_indices_0, :],
+                    optimize=True,
+                )
+                no_shortcut_indices = no_shortcut_indices[len_no_shortcut_indices_0:]
+            
+            if len(no_shortcut_indices) > 0:
+                A_arr = A_arr[len_no_shortcut_indices_0:]
+                A_arr[:, :N, N:] = -A_arr[:, N:, :N]
+                A_arr[:, :N, :N] = -A_arr[:, N:, N:]
+                A_arr.reshape(-1, NQuad * NQuad)[:, ::NQuad + 1] += 1 / mu0
+                # Note that the minus sign has been absorbed into `X_arr`
+                B_collect[no_shortcut_indices, :] = np.linalg.solve(A_arr, X_arr[no_shortcut_indices, :, None]).squeeze(-1)
             
             # --------------------------------------------------------------------------------------------------------------------------
 

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT/pydisort.py

@@ -98,7 +98,7 @@ def pydisort(
         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 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)``
+        For example, ``Fp(tau_arr, True) - Fp(np.insert(tau_arr[:-1] + 1e-15, 0, 0), True)``
         will produce an array of the tau-integral over each layer.
         Pass ``return_tau_arr`` to return ``tau_arr`` (defaults to ``False``).
     Fm(tau) : function
@@ -451,40 +451,33 @@ def pydisort(
             
             neg_scaled_tau_div_mu0 = -scaled_tau / mu0
             if is_antiderivative_wrt_tau:
-            
-                scale_tau_l = scale_tau[None, l_uniq]
+
+                scale_tau_l = scale_tau[l_uniq]
                 neg_scale_tau_l_div_mu0 = -scale_tau_l / mu0
-                scale_tau_l_div_mu_arr_pos = scale_tau_l / mu_arr_pos[:, None]
-                
+                scale_tau_l_div_mu_arr_pos = scale_tau_l[None, :] / mu_arr_pos[:, None]
+
                 TMS_correction_pos = (
-                    np.exp(neg_scaled_tau_div_mu0)[None, :] / neg_scale_tau_l_div_mu0[l_inv]
-                    - np.exp(
-                        (scaled_tau - scaled_tau_arr_l)[None, :] / mu_arr_pos[:, None]
-                        - scaled_tau_arr_l[None, :] / mu0
-                    ) / scale_tau_l_div_mu_arr_pos[l_inv]
-                )
+                    np.exp(neg_scaled_tau_div_mu0) / neg_scale_tau_l_div_mu0[l_inv]
+                )[None, :] - np.exp(
+                    (scaled_tau - scaled_tau_arr_l)[None, :] / mu_arr_pos[:, None]
+                    - scaled_tau_arr_l[None, :] / mu0
+                ) / scale_tau_l_div_mu_arr_pos[:, l_inv]
                 TMS_correction_neg = (
-                    np.exp(neg_scaled_tau_div_mu0)[None, :] / neg_scale_tau_l_div_mu0[l_inv]
-                    + np.exp(
-                        (scaled_tau_arr_lm1 - scaled_tau)[None, :] / mu_arr_pos[:, None]
-                        - scaled_tau_arr_lm1[None, :] / mu0
-                    ) / scale_tau_l_div_mu_arr_pos[l_inv]
-                )
+                    np.exp(neg_scaled_tau_div_mu0) / neg_scale_tau_l_div_mu0[l_inv]
+                )[None, :] + np.exp(
+                    (scaled_tau_arr_lm1 - scaled_tau)[None, :] / mu_arr_pos[:, None]
+                    - scaled_tau_arr_lm1[None, :] / mu0
+                ) / scale_tau_l_div_mu_arr_pos[:, l_inv]
             else:
-                TMS_correction_pos = (
-                    np.exp(neg_scaled_tau_div_mu0)[None, :]
-                    - np.exp(
-                        (scaled_tau - scaled_tau_arr_l)[None, :] / mu_arr_pos[:, None]
-                        - scaled_tau_arr_l[None, :] / mu0
-                    )
+                TMS_correction_pos = np.exp(neg_scaled_tau_div_mu0)[None, :] - np.exp(
+                    (scaled_tau - scaled_tau_arr_l)[None, :] / mu_arr_pos[:, None]
+                    - scaled_tau_arr_l[None, :] / mu0
                 )
-                TMS_correction_neg = (
-                    np.exp(neg_scaled_tau_div_mu0)[None, :]
-                    - np.exp(
-                        (scaled_tau_arr_lm1 - scaled_tau)[None, :] / mu_arr_pos[:, None]
-                        - scaled_tau_arr_lm1[None, :] / mu0
-                    )
+                TMS_correction_neg = np.exp(neg_scaled_tau_div_mu0)[None, :] - np.exp(
+                    (scaled_tau_arr_lm1 - scaled_tau)[None, :] / mu_arr_pos[:, None]
+                    - scaled_tau_arr_lm1[None, :] / mu0
                 )
+
             
             ## Contribution from other layers
             # --------------------------------------------------------------------------------------------------------------------------
@@ -525,13 +518,13 @@ def pydisort(
                 # POS: pre-accumulate "contribution from below" sums Rpos[N, l, Nphi]
                 # ====================================================================
                 if any_pos:
-                    # fac_pos = 1 - exp(-scaled_thickness_arr*(1/mu + 1/mu0)) = -expm1(-thickness_pos)
                     thickness_pos = scaled_thickness_arr[None, :] * (M_inv + mu0_inv)[:, None]  # (N, NLayers); always > 0
-                    fac_pos = -np.expm1(-thickness_pos)                                         # (N, NLayers)
+                    # em1_pos = 1 - exp(-scaled_thickness_arr*(1/mu + 1/mu0)) = -expm1(-thickness_pos)
+                    em1_pos = -np.expm1(-thickness_pos)                                         # (N, NLayers)
                     if is_antiderivative_wrt_tau:
-                        fac_pos = fac_pos * integration_factor
+                        em1_pos = integration_factor * em1_pos
 
-                    layer_term_pos = fac_pos * exp_taufront_mu0_inv[None, :]                    # (N, NLayers)
+                    layer_term_pos = em1_pos * exp_taufront_mu0_inv[None, :]                    # (N, NLayers)
 
                     # Reverse-scan via cumsum:
                     # Rpos[l] = (1/decay_prod[l+1]) * sum_{r=l+1..} (layer_term_pos[r] * decay_prod[r])
@@ -566,12 +559,12 @@ def pydisort(
                     exp_x0 = decay * exp_taufront_mu0_inv[None, :]                               # (N, NLayers)
 
                     # Let a = |thickness_neg| >= 0. Then expm1(-a) uses only non-positive inputs.
-                    em1 = np.expm1(-np.abs(thickness_neg))                                       # (N, NLayers)
+                    em1_neg = np.expm1(-np.abs(thickness_neg))                                       # (N, NLayers)
 
-                    # thickness_neg>=0: exp_x1 * (1 - exp(-a)) = exp_x1 * (-expm1(-a)) = exp_x1 * (-em1)
-                    # thickness_neg<0 : exp_x0 * (exp(-a) - 1) = exp_x0 * expm1(-a)    = exp_x0 * ( em1)
-                    layer_term_negthick = em1 * exp_x0                                           # (N, NLayers)
-                    layer_term_posthick = -em1 * exp_x1                                          # (N, NLayers)
+                    # thickness_neg>=0: exp_x1 * (1 - exp(-a)) = exp_x1 * (-expm1(-a)) = exp_x1 * (-em1_neg)
+                    # thickness_neg<0 : exp_x0 * (exp(-a) - 1) = exp_x0 * expm1(-a)    = exp_x0 * ( em1_neg)
+                    layer_term_negthick = em1_neg * exp_x0                                       # (N, NLayers)
+                    layer_term_posthick = -em1_neg * exp_x1                                      # (N, NLayers)
                     layer_term_neg = layer_term_posthick * mask + layer_term_negthick * (~mask)  # (N, NLayers)
 
                     if is_antiderivative_wrt_tau:

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT/subroutines.py

@@ -489,8 +489,8 @@ def generate_emissivity_from_BDRF(N, zeroth_BDRF_Fourier_mode):
 
 def cache_BDRF_Fourier_modes(N, BDRF_Fourier_modes, mu0=0):
     """If the same BDRF and number of streams will be used repeatedly,
-    consider using this function to cache ``BDRF_Fourier_modes`` and instead input
-    ``cached_BDRF_Fourier_modes`` into ``pydisort``. It is also possible
+    consider using this function to cache ``BDRF_Fourier_modes`` and pass
+    ``cached_BDRF_Fourier_modes`` to ``pydisort``. It is also possible
     to cache ``BDRF_Fourier_modes`` with respect to a fixed ``mu0``. 
 
     Parameters
@@ -744,6 +744,7 @@ def to_diag_ordered_form(A, Nsuperdiags, Nsubdiags):
 
     
 def _mathscr_v(tau,                             # Input optical depths
+               scale_tau,                       # Delta-scale factor for tau
                l,                               # Layer index of each input optical depth
                Nscoeffs,                        # Number of isotropic source polynomial coefficients
                s_poly_coeffs,                   # Polynomial coefficients of isotropic source
@@ -763,6 +764,7 @@ def _mathscr_v(tau,                             # Input optical depths
     |          Variable             |                   Shape                   |
     | ----------------------------- | ----------------------------------------- |
     | ``tau``                       | ``Ntau``                                  |
+    | ``scale_tau``                 | `NLayers`                                 |
     | ``l``                         | ``Ntau``                                  |
     | ``Nscoeffs``                  | scalar                                    |
     | ``s_poly_coeffs``             | ``NL x Nscoeffs``                         |
@@ -784,13 +786,13 @@ def _mathscr_v(tau,                             # Input optical depths
     if Nscoeffs == 1:
         s0 = s_poly_coeffs[:, 0:1]
         c0w = s0 * K_inv * G_inv_mu_inv  # (NL, 1) * (NL, NQuad) -> (NL, NQuad)
+        
+        d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True)
 
         if is_antiderivative_wrt_tau:
-            p0 = tau                 
+            p0 = tau / scale_tau                 
         else:
             p0 = np.ones_like(tau)       
-            
-        d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True)
 
         return d0[:, l] * p0[None, :]
 
@@ -803,19 +805,19 @@ def _mathscr_v(tau,                             # Input optical depths
 
         c0w = s1 * K_inv * G_inv_mu_inv
         c1w = (s0 * K_inv + s1 * K_inv2) * G_inv_mu_inv
+        
+        d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True)  # (NQuad, NL)
+        d1 = np.einsum("lij, lj -> il", G, c1w, optimize=True)  # (NQuad, NL)
 
         if is_antiderivative_wrt_tau:
             p0 = tau * tau / 2
             p1 = tau
+            return (d0[:, l] * p0[None, :] + d1[:, l] * p1[None, :]) / scale_tau
         else:
             p0 = tau
             p1 = np.ones_like(tau) 
-
-        d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True)  # (NQuad, NL)
-        d1 = np.einsum("lij, lj -> il", G, c1w, optimize=True)  # (NQuad, NL)
-
-        return d0[:, l] * p0[None, :] + d1[:, l] * p1[None, :]
-
+            return d0[:, l] * p0[None, :] + d1[:, l] * p1[None, :]
+        
     # --------------------- Nscoeffs > 2 ----------------------
     else:
         if Nscoeffs > 10:
@@ -853,7 +855,7 @@ def _mathscr_v(tau,                             # Input optical depths
         powers = np.arange(Nscoeffs - 1, -1, -1)[None, :]
         if is_antiderivative_wrt_tau:
             p = powers + 1
-            tau_poly = (tau[:, None] ** p) / p
+            tau_poly = (tau[:, None] ** p) / (p * scale_tau)
         else:
             tau_poly = tau[:, None] ** powers
 

{pythonicdisort-1.3 → pythonicdisort-1.5/src/PythonicDISORT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 1.3
+Version: 1.5
 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
@@ -18,6 +18,7 @@ Provides-Extra: notebook-dependencies
 Requires-Dist: autograd>=1.5; extra == "notebook-dependencies"
 Requires-Dist: jupyter>1.0.0; extra == "notebook-dependencies"
 Requires-Dist: notebook>6.5.2; extra == "notebook-dependencies"
+Requires-Dist: matplotlib>=3.6.0; extra == "notebook-dependencies"
 
 [![Run PyTests](https://github.com/LDEO-CREW/Pythonic-DISORT/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/LDEO-CREW/Pythonic-DISORT/actions/workflows/continuous_integration.yml)
 [![DOI](https://joss.theoj.org/papers/10.21105/joss.06442/status.svg)](https://doi.org/10.21105/joss.06442)
@@ -70,6 +71,7 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * 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)
+* Test Problem I: Antiderivative / integration functionality (no corresponding Jupyter Notebook)
 
 # Installation
 
@@ -81,15 +83,16 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
 * Python 3.8+
 * `numpy >= 1.8.0`
 * `scipy >= 1.8.0`
+* (OPTIONAL) `autograd >= 1.5` (`autograd` can be used to compute gradients of the output functions)
 * (OPTIONAL) `pytest >= 6.2.5` (Required to use the command `pytest`, see *PyTest and examples of how to use PythonicDISORT*)
 
 ## (OPTIONAL) Additional requirements to run the Jupyter Notebook
-* `autograd >= 1.5`
 * `jupyter > 1.0.0`
 * `notebook > 6.5.2`
 * `matplotlib >= 3.6.0`
 
-In addition, a F2PY-wrapped Stamnes' DISORT, or equivalent, is required to properly run the last section (section 6).
+In addition, a F2PY-wrapped Stamnes' DISORT or equivalent (https://github.com/kconnour/pyRT_DISORT may work) 
+is required to properly run the last section (section 6).
 
 ## Compatibility
 
@@ -127,3 +130,4 @@ Science and Technology Center (STC) (Award #2019625) under which this package wa
 12) T. Nakajima and M. Tanaka. 1988. *Algorithms for radiative intensity calculations in moderately thick atmospheres using a truncation approximation.* https://www.sciencedirect.com/science/article/pii/0022407388900313.
 
 13) Connour, Kyle and Wolff, Michael. 2020. *pyRT_DISORT: A pre-processing front-end to help make DISORT simulations easier in Python.* https://github.com/kconnour/pyRT_DISORT.
+

{pythonicdisort-1.3 → pythonicdisort-1.5}/src/PythonicDISORT.egg-info/requires.txt

@@ -5,6 +5,7 @@ scipy>=1.8.0
 autograd>=1.5
 jupyter>1.0.0
 notebook>6.5.2
+matplotlib>=3.6.0
 
 [pytest]
 pytest>=6.2.5