PyPI - PythonicDISORT - Versions diffs - 0.6.0__tar.gz → 0.6.2__tar.gz - Mend

PythonicDISORT 0.6.0tar.gz → 0.6.2tar.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-0.6.0/src/PythonicDISORT.egg-info → PythonicDISORT-0.6.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.6.0
+Version: 0.6.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
@@ -32,25 +32,25 @@ In addition, upon the request of a user, we added a subroutine to calculate acti
 You may contact me, Dion, through dh3065@columbia.edu.
-This repository also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
+Our **GitHub repository:** https://github.com/LDEO-CREW/Pythonic-DISORT also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
 The original was downloaded from http://www.rtatmocn.com/disort/. The wrapper is inspired by https://github.com/kconnour/pyRT_DISORT.
 # Documentation
 https://pythonic-disort.readthedocs.io/en/latest/
-Also see the accompanying Jupyter Notebook: `Pythonic-DISORT.ipynb` in the `docs` directory
-of our GitHub repository: https://github.com/LDEO-CREW/Pythonic-DISORT.
+Also see the accompanying Jupyter Notebook `Pythonic-DISORT.ipynb` in the `docs` directory
+of our GitHub repository.
 The Jupyter Notebook provides comprehensive documentation, suggested inputs, explanations,
 mathematical derivations and verification tests.
 We highly recommend reading the non-optional parts of sections 1 and 2 before use.
 ## PyTest and examples of how to use PythonicDISORT
-Separate from the verification tests in the Jupyter Notebook, we used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`,
-which is included in the `disort4.0.99_f2py` directory in this repository. In these tests, the solutions from PythonicDISORT are compared
+Not only do we have verification tests in the Jupyter Notebook, we also used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`;
+`disotest.f90` is included in the `disort4.0.99_f2py` directory of our GitHub repository. In these tests, the solutions from PythonicDISORT are compared
 against solutions from our F2PY-wrapped Stamnes' DISORT (version 4.0.99). With PyTest installed, execute the console command `pytest`
 in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks, one for each test,
-to show how the test was implemented. These notebooks double up as examples of how to use PythonicDISORT.
+to show how the tests were implemented. These notebooks double up as examples of how to use PythonicDISORT.
 # Installation
@@ -74,16 +74,16 @@ must be set up to run the last section (section 6).
 ## Compatibility
-The PythonicDISORT package should be system agnostic given its minimal dependencies and pure Python code.
+The PythonicDISORT package *should* be system agnostic given its minimal dependencies and pure Python code.
 We do not guarantee that our Jupyter Notebook and F2PY-wrapped Stamnes' DISORT will work on other systems though.
 The latter will almost certainly need user edits to work and in any case it requires FORTRAN compilers which
-are not included in this repository. Everything in this repository was built and tested on Windows 11 and
+are not included in our GitHub repository. Everything in the repository was built and tested on Windows 11 but
 not yet tested on other systems.
 # Acknowledgements
 I acknowledge funding from NSF through the Learning the Earth with Artificial intelligence and Physics (LEAP)
-Science and Technology Center (STC) (Award #2019625).
+Science and Technology Center (STC) (Award #2019625) under which this package was initially created.
 # References
 1) S. Chandrasekhar. 1960. *Radiative Transfer.*

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/README.md RENAMED Viewed

@@ -11,25 +11,25 @@ In addition, upon the request of a user, we added a subroutine to calculate acti
 You may contact me, Dion, through dh3065@columbia.edu.
-This repository also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
+Our **GitHub repository:** https://github.com/LDEO-CREW/Pythonic-DISORT also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
 The original was downloaded from http://www.rtatmocn.com/disort/. The wrapper is inspired by https://github.com/kconnour/pyRT_DISORT.
 # Documentation
 https://pythonic-disort.readthedocs.io/en/latest/
-Also see the accompanying Jupyter Notebook: `Pythonic-DISORT.ipynb` in the `docs` directory
-of our GitHub repository: https://github.com/LDEO-CREW/Pythonic-DISORT.
+Also see the accompanying Jupyter Notebook `Pythonic-DISORT.ipynb` in the `docs` directory
+of our GitHub repository.
 The Jupyter Notebook provides comprehensive documentation, suggested inputs, explanations,
 mathematical derivations and verification tests.
 We highly recommend reading the non-optional parts of sections 1 and 2 before use.
 ## PyTest and examples of how to use PythonicDISORT
-Separate from the verification tests in the Jupyter Notebook, we used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`,
-which is included in the `disort4.0.99_f2py` directory in this repository. In these tests, the solutions from PythonicDISORT are compared
+Not only do we have verification tests in the Jupyter Notebook, we also used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`;
+`disotest.f90` is included in the `disort4.0.99_f2py` directory of our GitHub repository. In these tests, the solutions from PythonicDISORT are compared
 against solutions from our F2PY-wrapped Stamnes' DISORT (version 4.0.99). With PyTest installed, execute the console command `pytest`
 in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks, one for each test,
-to show how the test was implemented. These notebooks double up as examples of how to use PythonicDISORT.
+to show how the tests were implemented. These notebooks double up as examples of how to use PythonicDISORT.
 # Installation
@@ -53,16 +53,16 @@ must be set up to run the last section (section 6).
 ## Compatibility
-The PythonicDISORT package should be system agnostic given its minimal dependencies and pure Python code.
+The PythonicDISORT package *should* be system agnostic given its minimal dependencies and pure Python code.
 We do not guarantee that our Jupyter Notebook and F2PY-wrapped Stamnes' DISORT will work on other systems though.
 The latter will almost certainly need user edits to work and in any case it requires FORTRAN compilers which
-are not included in this repository. Everything in this repository was built and tested on Windows 11 and
+are not included in our GitHub repository. Everything in the repository was built and tested on Windows 11 but
 not yet tested on other systems.
 # Acknowledgements
 I acknowledge funding from NSF through the Learning the Earth with Artificial intelligence and Physics (LEAP)
-Science and Technology Center (STC) (Award #2019625).
+Science and Technology Center (STC) (Award #2019625) under which this package was initially created.
 # References
 1) S. Chandrasekhar. 1960. *Radiative Transfer.*
@@ -87,4 +87,4 @@ Science and Technology Center (STC) (Award #2019625).
 11) 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.
-12) K. Connour and A. Stcherbinine. 2022. *pyRT_DISORT.* https://github.com/kconnour/pyRT_DISORT.
+12) K. Connour and A. Stcherbinine. 2022. *pyRT_DISORT.* https://github.com/kconnour/pyRT_DISORT.

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/pyproject.toml RENAMED Viewed

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

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_assemble_solution_functions.py RENAMED Viewed

@@ -11,7 +11,7 @@ def _assemble_solution_functions(
     scaled_tau_arr_with_0,
     mu_arr_pos, mu_arr,
     M_inv, W,
-    N, NQuad, NLeg, NLoops,
+    N, NQuad, NLeg, NFourier,
     NLayers, NBDRF,
     atmos_is_multilayered,
     weighted_scaled_Leg_coeffs,
@@ -46,7 +46,7 @@ def _assemble_solution_functions(
     # Compute all the necessary quantities
     # --------------------------------------------------------------------------------------------------------------------------
     outputs = _diagonalize(
-        NLoops,
+        NFourier,
         scaled_omega_arr,
         mu_arr_pos, mu_arr,
         M_inv, W,
@@ -74,7 +74,7 @@ def _assemble_solution_functions(
         B_collect = None
     GC_collect = _solve_for_coefs(
-        NLoops,
+        NFourier,
         G_collect,
         K_collect,
         B_collect,
@@ -154,14 +154,14 @@ def _assemble_solution_functions(
                 )
                 if _is_compatible_with_autograd:
-                    um = um + np.concatenate((_mathscr_v_contribution.T, np.zeros((NLoops - 1, len(tau), NQuad))))
+                    um = um + np.concatenate((_mathscr_v_contribution.T, np.zeros((NFourier - 1, len(tau), NQuad))))
                 else:
                     um[0, :, :] += _mathscr_v_contribution.T
             intensities = np.einsum(
                 "mti, mp -> itp",
                 um,
-                np.cos(np.arange(NLoops)[:, None] * (phi0 - phi)[None, :]),
+                np.cos(np.arange(NFourier)[:, None] * (phi0 - phi)[None, :]),
                 optimize=True,
             )
@@ -183,7 +183,7 @@ def _assemble_solution_functions(
                     )
                 intensities_abs = np.abs(intensities)
                 Fourier_error = np.max(
-                    np.abs(ulast[:, :, None] * np.cos((NLoops - 1) * (phi0 - phi))[None, None, :]),
+                    np.abs(ulast[:, :, None] * np.cos((NFourier - 1) * (phi0 - phi))[None, None, :]),
                     intensities_abs,
                     out=np.zeros_like(intensities_abs),
                     where=intensities_abs > 1e-8,

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_diagonalize.py RENAMED Viewed

@@ -4,7 +4,7 @@ from math import pi
 def _diagonalize(
-    NLoops,
+    NFourier,
     scaled_omega_arr,
     mu_arr_pos, mu_arr,
     M_inv, W,
@@ -29,24 +29,24 @@ def _diagonalize(
     ells_all = np.arange(NLeg)
     ind = 0
-    G_collect = np.empty((NLoops * NLayers, NQuad, NQuad))
-    K_collect = np.empty((NLoops * NLayers, NQuad))
-    alpha_arr = np.empty((NLoops * NLayers, N, N))
-    beta_arr = np.empty((NLoops * NLayers, N, N))
-    X_tilde_arr = np.empty((NLoops * NLayers, NQuad))
+    G_collect = np.empty((NFourier * NLayers, NQuad, NQuad))
+    K_collect = np.empty((NFourier * NLayers, NQuad))
+    alpha_arr = np.empty((NFourier * NLayers, N, N))
+    beta_arr = np.empty((NFourier * NLayers, N, N))
+    X_tilde_arr = np.empty((NFourier * NLayers, NQuad))
     no_shortcut_indices = []
     no_shortcut_indices_0 = []
     if there_is_beam_source:
-        B_collect = np.zeros((NLoops * NLayers, NQuad))
+        B_collect = np.zeros((NFourier * NLayers, NQuad))
     if there_is_iso_source:
         G_inv_collect_0 = np.empty((NLayers, NQuad, NQuad))
     # --------------------------------------------------------------------------------------------------------------------------
-    # Loop over NLoops Fourier modes
+    # Loop over NFourier Fourier modes
     # These can easily be parallelized, but the speed-up is unlikely to be worth the overhead
     # --------------------------------------------------------------------------------------------------------------------------
-    for m in range(NLoops):
+    for m in range(NFourier):
         # Setup
         # --------------------------------------------------------------------------------------------------------------------------
         m_equals_0 = (m == 0)
@@ -169,26 +169,26 @@ def _diagonalize(
     if there_is_beam_source:
         if there_is_iso_source:
             return (
-                G_collect.reshape((NLoops, NLayers, NQuad, NQuad)),
-                K_collect.reshape((NLoops, NLayers, NQuad)),
-                B_collect.reshape((NLoops, NLayers, NQuad)),
+                G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
+                K_collect.reshape((NFourier, NLayers, NQuad)),
+                B_collect.reshape((NFourier, NLayers, NQuad)),
                 G_inv_collect_0,
             )
         else:
             return (
-                G_collect.reshape((NLoops, NLayers, NQuad, NQuad)),
-                K_collect.reshape((NLoops, NLayers, NQuad)),
-                B_collect.reshape((NLoops, NLayers, NQuad)),
+                G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
+                K_collect.reshape((NFourier, NLayers, NQuad)),
+                B_collect.reshape((NFourier, NLayers, NQuad)),
             )
     else:
         if there_is_iso_source:
             return (
-                G_collect.reshape((NLoops, NLayers, NQuad, NQuad)),
-                K_collect.reshape((NLoops, NLayers, NQuad)),
+                G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
+                K_collect.reshape((NFourier, NLayers, NQuad)),
                 G_inv_collect_0,
             )
         else:
             return (
-                G_collect.reshape((NLoops, NLayers, NQuad, NQuad)),
-                K_collect.reshape((NLoops, NLayers, NQuad)),
+                G_collect.reshape((NFourier, NLayers, NQuad, NQuad)),
+                K_collect.reshape((NFourier, NLayers, NQuad)),
             )

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_solve_for_coefs.py RENAMED Viewed

@@ -7,7 +7,7 @@ from math import pi
 def _solve_for_coefs(
-    NLoops,
+    NFourier,
     G_collect,
     K_collect,
     B_collect,
@@ -36,11 +36,11 @@ def _solve_for_coefs(
     """
     ################################## Solve for coefficients of homogeneous solution ##########################################
-    GC_collect = np.empty((NLoops, NLayers, NQuad, NQuad))
+    GC_collect = np.empty((NFourier, NLayers, NQuad, NQuad))
     use_sparse_framework = NLayers >= use_sparse_NLayers
     # The following loops can easily be parallelized, but the speed-up is unlikely to be worth the overhead
-    for m in range(NLoops):
+    for m in range(NFourier):
         m_equals_0 = (m == 0)
         BDRF_bool = m < NBDRF
@@ -89,7 +89,7 @@ def _solve_for_coefs(
                         K_collect_m[0:1, :],
                         G_inv_collect_0[0:1, :, :],
                         mu_arr,
-                    ).flatten()
+                    ).ravel()
             _mathscr_v_contribution_middle = np.array([])
             if atmos_is_multilayered:
@@ -115,7 +115,7 @@ def _solve_for_coefs(
                         G_inv_collect_0[1:, :, :],
                         mu_arr,
                     )
-                ).flatten()
+                ).ravel()
             _mathscr_v_contribution_bottom = _mathscr_v(
                     tau_arr[-1:], np.array([0]),
@@ -124,7 +124,7 @@ def _solve_for_coefs(
                     G_collect_m[-1:, N:, :],
                     K_collect_m[-1:, :],
                     G_inv_collect_0[-1:, :, :],
-                    mu_arr).flatten()
+                    mu_arr).ravel()
             if NBDRF > 0:
                 _mathscr_v_contribution_bottom = (
                     R + np.eye(N)
@@ -154,7 +154,7 @@ def _solve_for_coefs(
                         * np.exp(-mu0 * scaled_tau_arr_with_0[l + 1])
                         for l in range(NLayers - 1)
                     ]
-                ).flatten()
+                ).ravel()
             RHS = (
                 np.concatenate(
@@ -203,37 +203,37 @@ def _solve_for_coefs(
             block_row_ind = np.arange(block_row_len).reshape(NQuad, 2 * NQuad)
             block_row_sort = np.empty(block_row_len, dtype='int')
-            block_row_sort[:N_squared] = block_row_ind[:N, :N].flatten()
-            block_row_sort[N_squared : 2 * N_squared] = block_row_ind[N : 2 * N, :N].flatten()
-            block_row_sort[2 * N_squared : 4 * N_squared] = block_row_ind[:2 * N, N : 2 * N].flatten()
-            block_row_sort[4 * N_squared : 6 * N_squared] = block_row_ind[:2 * N, 2 * N : 3 * N].flatten()
-            block_row_sort[6 * N_squared : 7 * N_squared] = block_row_ind[:N, 3 * N : 4 * N].flatten()
-            block_row_sort[7 * N_squared : 8 * N_squared] = block_row_ind[N : 2 * N, 3 * N : 4 * N].flatten()
+            block_row_sort[:N_squared] = block_row_ind[:N, :N].ravel()
+            block_row_sort[N_squared : 2 * N_squared] = block_row_ind[N : 2 * N, :N].ravel()
+            block_row_sort[2 * N_squared : 4 * N_squared] = block_row_ind[:2 * N, N : 2 * N].ravel()
+            block_row_sort[4 * N_squared : 6 * N_squared] = block_row_ind[:2 * N, 2 * N : 3 * N].ravel()
+            block_row_sort[6 * N_squared : 7 * N_squared] = block_row_ind[:N, 3 * N : 4 * N].ravel()
+            block_row_sort[7 * N_squared : 8 * N_squared] = block_row_ind[N : 2 * N, 3 * N : 4 * N].ravel()
             # BCs for the entire atmosphere
             row_indices[:N_squared], col_indices[:N_squared] = _nd_slice_to_indexes(np.s_[:N, :N])
-            block_rows[:N_squared] = G_0_nn.flatten()
+            block_rows[:N_squared] = G_0_nn.ravel()
             (
                 row_indices[N_squared : 2 * N_squared],
                 col_indices[N_squared : 2 * N_squared],
             ) = _nd_slice_to_indexes(np.s_[:N, N:NQuad])
             block_rows[N_squared : 2 * N_squared] = (
                 G_0_np * np.exp(K_collect_m[0, :N] * scaled_tau_arr_with_0[1])[None, :]
-            ).flatten()
+            ).ravel()
             (
                 row_indices[2 * N_squared : 3 * N_squared],
                 col_indices[2 * N_squared : 3 * N_squared],
             ) = _nd_slice_to_indexes(np.s_[dim - N : dim, dim - NQuad : dim - N])
             block_rows[2 * N_squared : 3 * N_squared] = (
                 (G_L_pn - BDRF_LHS_contribution_neg) * E_Lm1L[None, :]
-            ).flatten()
+            ).ravel()
             (
                 row_indices[3 * N_squared : 4 * N_squared],
                 col_indices[3 * N_squared : 4 * N_squared],
             ) = _nd_slice_to_indexes(np.s_[dim - N : dim, dim - N : dim])
             block_rows[3 * N_squared : 4 * N_squared] = (
                 G_L_pp - BDRF_LHS_contribution_pos
-            ).flatten()
+            ).ravel()
             # Interlayer / continuity BCs
             for l in range(NLayers - 1):
@@ -263,12 +263,12 @@ def _solve_for_coefs(
                 ] = col_indices_l[block_row_sort]
                 starting_ind = 4 * N_squared + l * block_row_len
-                block_rows[starting_ind : N_squared + starting_ind] = (G_l_pn * E_lm1l[None, :]).flatten()
-                block_rows[starting_ind + N_squared : 2 * N_squared + starting_ind] = (G_l_nn * E_lm1l[None, :]).flatten()
-                block_rows[starting_ind + 2 * N_squared : 4 * N_squared + starting_ind] = G_l_ap.flatten()
-                block_rows[starting_ind + 4 * N_squared : 6 * N_squared + starting_ind] = -G_lp1_an.flatten()
-                block_rows[starting_ind + 6 * N_squared : 7 * N_squared + starting_ind] = -(G_lp1_pp * E_llp1[None, :]).flatten()
-                block_rows[starting_ind + 7 * N_squared : 8 * N_squared + starting_ind] = -(G_lp1_np * E_llp1[None, :]).flatten()
+                block_rows[starting_ind : N_squared + starting_ind] = (G_l_pn * E_lm1l[None, :]).ravel()
+                block_rows[starting_ind + N_squared : 2 * N_squared + starting_ind] = (G_l_nn * E_lm1l[None, :]).ravel()
+                block_rows[starting_ind + 2 * N_squared : 4 * N_squared + starting_ind] = G_l_ap.ravel()
+                block_rows[starting_ind + 4 * N_squared : 6 * N_squared + starting_ind] = -G_lp1_an.ravel()
+                block_rows[starting_ind + 6 * N_squared : 7 * N_squared + starting_ind] = -(G_lp1_pp * E_llp1[None, :]).ravel()
+                block_rows[starting_ind + 7 * N_squared : 8 * N_squared + starting_ind] = -(G_lp1_np * E_llp1[None, :]).ravel()
             LHS = sc.sparse.coo_matrix(
                 (

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/pydisort.py RENAMED Viewed

@@ -14,7 +14,7 @@ def pydisort(
     Leg_coeffs_all,
     mu0, I0, phi0,
     NLeg=None,
-    NLoops=None,
+    NFourier=None,
     b_pos=0,
     b_neg=0,
     only_flux=False,
@@ -42,9 +42,10 @@ def pydisort(
     omega_arr : array
         Single-scattering albedo of each atmospheric layer.
     NQuad : int
-        Number of mu quadrature nodes.
+        Number of `mu` quadrature nodes.
     Leg_coeffs_all : ndarray
-        All available unweighted phase function Legendre coefficients.
+        All available unweighted phase function Legendre coefficients.
+        Each coefficient should be between 0 and 1 inclusive.
     mu0 : float
         Cosine of polar angle of the incident beam.
     I0 : float
@@ -53,7 +54,7 @@ def pydisort(
         Azimuthal angle of the incident beam.
     NLeg : optional, int
         Number of phase function Legendre coefficients.
-    NLoops : optional, int
+    NFourier : optional, int
         Number of Fourier modes to use in the intensity function.
     b_pos : optional, 2darray or float
         Dirichlet boundary condition for the upward direction.
@@ -66,7 +67,7 @@ def pydisort(
     NT_cor : optional, bool
         Perform Nakajima-Tanaka intensity corrections?
     BDRF_Fourier_modes : optional, list
-        BDRF Fourier modes, each a function with arguments mu, -mup of type array
+        BDRF Fourier modes, each a function with arguments `mu, -mu_p` of type array
         and 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.
@@ -77,21 +78,22 @@ def pydisort(
     Returns
     -------
     array
-        All mu (cosine of polar angle) quadrature nodes.
+        All `mu` (cosine of polar angle) quadrature nodes.
     function
-        (Energetic) Flux function with argument tau (type: array) for positive (upward) mu values.
+        (Energetic) Flux function with argument `tau` (type: array) for positive (upward) `mu` values.
         Returns the diffuse flux magnitudes (type: array).
     function
-        (Energetic) Flux function with argument tau (type: array) for negative (downward) mu values.
+        (Energetic) Flux function with argument `tau` (type: array) for negative (downward) `mu` values.
         Returns a tuple of the diffuse and direct flux magnitudes respectively (type: (array, array)).
     function
-        Zeroth Fourier mode of the intensity with argument tau (type: array).
-        Returns an ndarray with axes corresponding to variation with mu and tau respectively.
+        Zeroth Fourier mode of the intensity with argument `tau` (type: array).
+        Returns an ndarray with axes corresponding to variation with `mu` and `tau` respectively.
         This function is useful for calculating actinic fluxes and other quantities of interest,
-        but reclassification of delta-scaled flux and other corrections must be done manually.
+        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).
     function, optional
-        Intensity function with arguments (tau, phi, return_Fourier_error=False) of types (array, array, bool).
-        Returns an ndarray with axes corresponding to variation with mu, tau, phi respectively.
+        Intensity function with arguments `(tau, phi, return_Fourier_error=False)` of types `(array, array, bool)`.
+        Returns an ndarray with axes corresponding to variation with `mu, tau, phi` respectively.
         The optional flag `return_Fourier_error` determines whether the function will also return
         the Cauchy / Fourier convergence evaluation (type: float) for the last Fourier term.
@@ -114,8 +116,8 @@ def pydisort(
     # --------------------------------------------------------------------------------------------------------------------------
     if NLeg is None:
         NLeg = NQuad
-    if NLoops is None:
-        NLoops = NQuad
+    if NFourier is None:
+        NFourier = NQuad
     if np.all(b_pos == 0):
         b_pos = 0
     if np.all(b_neg == 0):
@@ -147,7 +149,7 @@ def pydisort(
     # The user must supply at least as many phase function Legendre coefficients as intended for use
     assert NLeg > 0
     assert np.all(Leg_coeffs_all[:, 0] == 1)
-    assert np.all(np.abs(Leg_coeffs_all) <= 1)
+    assert np.all(0 <= Leg_coeffs_all) and np.all(Leg_coeffs_all <= 1)
     assert np.all(np.array([f.__code__.co_argcount for f in BDRF_Fourier_modes]) == 2)
     assert NLeg <= NLeg_all
     # Ensure that the first dimension of the following inputs corresponds to the number of layers
@@ -157,13 +159,13 @@ def pydisort(
         assert len(f_arr) == NLayers
     if there_is_iso_source:
         assert np.shape(s_poly_coeffs)[0] == NLayers
-    # Conditions on the number of quadrature angles (NQuad), Legendre coefficients (NLeg) and loops (NLoops)
+    # Conditions on the number of quadrature angles (NQuad), Legendre coefficients (NLeg) and loops (NFourier)
     assert NQuad >= 2
     assert NQuad % 2 == 0
-    assert NLoops > 0
-    assert NLoops <= NLeg
+    assert NFourier > 0
+    assert NFourier <= NLeg
     # Not strictly necessary but there will be tremendous inaccuracies if this is violated
-    assert NQuad >= NLeg
+    assert NLeg <= NQuad
     # We require principal angles and a downward incident beam
     assert I0 >= 0
     if there_is_beam_source:
@@ -173,11 +175,11 @@ def pydisort(
     if len(np.atleast_1d(b_pos)) == 1:
         b_pos_is_scalar = True
     else:
-        assert np.shape(b_pos) == (N, NLoops)
+        assert np.shape(b_pos) == (N, NFourier)
     if len(np.atleast_1d(b_neg)) == 1:
         b_neg_is_scalar = True
     else:
-        assert np.shape(b_neg) == (N, NLoops)
+        assert np.shape(b_neg) == (N, NFourier)
     # The fractional scattering must be between 0 and 1
     assert np.all(0 <= f_arr) and np.all(f_arr <= 1)
     # The minimum threshold is the minimum numbers of layers: 1
@@ -238,7 +240,7 @@ def pydisort(
             scaled_tau_arr_with_0,
             mu_arr_pos, mu_arr,
             M_inv, W,
-            N, NQuad, NLeg, NLoops,
+            N, NQuad, NLeg, NFourier,
             NLayers, NBDRF,
             atmos_is_multilayered,
             weighted_scaled_Leg_coeffs,
@@ -319,159 +321,100 @@ def pydisort(
             )
             ## Contribution from other layers
-            # TODO: Despite being vectorized and otherwise optimized, this block of code is slower than desired
-            # and is the bottleneck for the TMS correction
+            # TODO: Despite being vectorized and despite many attempts at further optimization,
+            # this block of code is slower than desired and is the bottleneck for the TMS correction.
             # --------------------------------------------------------------------------------------------------------------------------
             if atmos_is_multilayered:
                 layers_arr = np.arange(NLayers)[:, None]
-                pos_contribution_mask = (l[None, :] < layers_arr).flatten()
-                neg_contribution_mask = (l[None, :] > layers_arr).flatten()
+                pos_contribution_mask = (l[None, :] < layers_arr).ravel()
+                neg_contribution_mask = (l[None, :] > layers_arr).ravel()
                 layers_arr_repeat = np.repeat(layers_arr, Ntau)
                 scaled_tau_tile = np.tile(scaled_tau, NLayers)
                 scaled_tau_arr_with_0_repeat = np.repeat(scaled_tau_arr_with_0, Ntau)
-                if True:
-                    if np.any(pos_contribution_mask):
-                        contribution_from_other_layers_pos = np.zeros((N, NLayers * Ntau, Nphi))
-                        scaled_tau_l_tile_pos = scaled_tau_tile[pos_contribution_mask]
-                        mathscr_B_l_repeat_posmasked = mathscr_B[:N, layers_arr_repeat[pos_contribution_mask], :]
-                        scaled_tau_arr_with_0_l_tile_posmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
-                            pos_contribution_mask
-                        ]
-                        scaled_tau_arr_with_0_lp1_tile_posmasked = scaled_tau_arr_with_0_repeat[Ntau:][
-                            pos_contribution_mask
-                        ]
-                        contribution_from_other_layers_pos[:, pos_contribution_mask, :] = (
-                            mathscr_B_l_repeat_posmasked
-                            * (
-                                np.exp(
-                                    (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_l_tile_posmasked)
-                                    / mu_arr_pos[:, None]
-                                    - scaled_tau_arr_with_0_l_tile_posmasked / mu0
-                                )
-                                - np.exp(
-                                    (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_lp1_tile_posmasked)
-                                    / mu_arr_pos[:, None]
-                                    - scaled_tau_arr_with_0_lp1_tile_posmasked / mu0
-                                )
-                            )[:, :, None]
-                        )
-                        contribution_from_other_layers_pos = np.sum(
-                            contribution_from_other_layers_pos.reshape((N, NLayers, Ntau, Nphi)), axis=1
-                        )
-                    if np.any(neg_contribution_mask):
-                        contribution_from_other_layers_neg = np.zeros((N, NLayers * Ntau, Nphi))
-                        scaled_tau_l_tile_neg = scaled_tau_tile[neg_contribution_mask]
-                        mathscr_B_l_repeat_negmasked = mathscr_B[N:, layers_arr_repeat[neg_contribution_mask], :]
-                        scaled_tau_arr_with_0_l_tile_negmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
-                            neg_contribution_mask
-                        ]
-                        scaled_tau_arr_with_0_lp1_tile_negmasked = scaled_tau_arr_with_0_repeat[Ntau:][
-                            neg_contribution_mask
-                        ]
-                        contribution_from_other_layers_neg[:, neg_contribution_mask, :] = (
-                            mathscr_B_l_repeat_negmasked
-                            * (
-                                np.exp(
-                                    (scaled_tau_arr_with_0_lp1_tile_negmasked - scaled_tau_l_tile_neg)
-                                    / mu_arr_pos[:, None]
-                                    - scaled_tau_arr_with_0_lp1_tile_negmasked / mu0
-                                )
-                                - np.exp(
-                                    (scaled_tau_arr_with_0_l_tile_negmasked - scaled_tau_l_tile_neg)
-                                    / mu_arr_pos[:, None]
-                                    - scaled_tau_arr_with_0_l_tile_negmasked / mu0
-                                )
-                            )[:, :, None]
-                        )
-                        contribution_from_other_layers_neg = np.sum(
-                            contribution_from_other_layers_neg.reshape((N, NLayers, Ntau, Nphi)), axis=1
-                        )
-                    return (
+                if np.any(pos_contribution_mask):
+                    contribution_from_each_other_layer_pos = np.zeros((N, NLayers * Ntau, Nphi))
+                    scaled_tau_l_tile_pos = scaled_tau_tile[pos_contribution_mask]
+                    mathscr_B_l_repeat_posmasked = mathscr_B[
+                        :N, layers_arr_repeat[pos_contribution_mask], :
+                    ]
+                    scaled_tau_arr_with_0_l_tile_posmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
+                        pos_contribution_mask
+                    ]
+                    scaled_tau_arr_with_0_lp1_tile_posmasked = scaled_tau_arr_with_0_repeat[Ntau:][
+                        pos_contribution_mask
+                    ]
+                    contribution_from_each_other_layer_pos[:, pos_contribution_mask, :] = (
+                        mathscr_B_l_repeat_posmasked
+                        * (
+                            np.exp(
+                                (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_l_tile_posmasked)
+                                / mu_arr_pos[:, None]
+                                - scaled_tau_arr_with_0_l_tile_posmasked / mu0
+                            )
+                            - np.exp(
+                                (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_lp1_tile_posmasked)
+                                / mu_arr_pos[:, None]
+                                - scaled_tau_arr_with_0_lp1_tile_posmasked / mu0
+                            )
+                        )[:, :, None]
+                    )
+                    contribution_from_other_layers_pos = np.sum(
+                        contribution_from_each_other_layer_pos.reshape((N, NLayers, Ntau, Nphi)),
+                        axis=1,
+                    )
+                if np.any(neg_contribution_mask):
+                    contribution_from_each_other_layer_neg = np.zeros((N, NLayers * Ntau, Nphi))
+                    scaled_tau_l_tile_neg = scaled_tau_tile[neg_contribution_mask]
+                    mathscr_B_l_repeat_negmasked = mathscr_B[
+                        N:, layers_arr_repeat[neg_contribution_mask], :
+                    ]
+                    scaled_tau_arr_with_0_l_tile_negmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
+                        neg_contribution_mask
+                    ]
+                    scaled_tau_arr_with_0_lp1_tile_negmasked = scaled_tau_arr_with_0_repeat[Ntau:][
+                        neg_contribution_mask
+                    ]
+                    contribution_from_each_other_layer_neg[:, neg_contribution_mask, :] = (
+                        mathscr_B_l_repeat_negmasked
+                        * (
+                            np.exp(
+                                (scaled_tau_arr_with_0_lp1_tile_negmasked - scaled_tau_l_tile_neg)
+                                / mu_arr_pos[:, None]
+                                - scaled_tau_arr_with_0_lp1_tile_negmasked / mu0
+                            )
+                            - np.exp(
+                                (scaled_tau_arr_with_0_l_tile_negmasked - scaled_tau_l_tile_neg)
+                                / mu_arr_pos[:, None]
+                                - scaled_tau_arr_with_0_l_tile_negmasked / mu0
+                            )
+                        )[:, :, None]
+                    )
+                    contribution_from_other_layers_neg = np.sum(
+                        contribution_from_each_other_layer_neg.reshape((N, NLayers, Ntau, Nphi)),
+                        axis=1,
+                    )
+                if _is_compatible_with_autograd:
+                    solution = (
                         mathscr_B[:, l, :]
                         * np.vstack((TMS_correction_pos, TMS_correction_neg))[:, :, None]
-                        + np.concatenate(
-                            (contribution_from_other_layers_pos, contribution_from_other_layers_neg), axis=0
-                        )
                     )
+                    solution[:N, :, :] += contribution_from_other_layers_pos
+                    solution[N:, :, :] += contribution_from_other_layers_neg
+                    return solution
                 else:
-                    solution_movedaxis = np.moveaxis(
-                        mathscr_B[:, l, :]
-                        * np.vstack((TMS_correction_pos, TMS_correction_neg))[:, :, None],
-                        0,
-                        1,
+                    return mathscr_B[:, l, :] * np.vstack((TMS_correction_pos, TMS_correction_neg))[
+                        :, :, None
+                    ] + np.concatenate(
+                        (contribution_from_other_layers_pos, contribution_from_other_layers_neg),
+                        axis=0,
                     )
-                    tau_ind_tile = np.tile(np.arange(Ntau), NLayers)
-                    if np.any(pos_contribution_mask):
-                        scaled_tau_l_tile_pos = scaled_tau_tile[pos_contribution_mask]
-                        mathscr_B_l_repeat_posmasked = mathscr_B[:N, layers_arr_repeat[pos_contribution_mask], :]
-                        scaled_tau_arr_with_0_l_tile_posmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
-                            pos_contribution_mask
-                        ]
-                        scaled_tau_arr_with_0_lp1_tile_posmasked = scaled_tau_arr_with_0_repeat[Ntau:][
-                            pos_contribution_mask
-                        ]
-                        np.add.at(
-                            solution_movedaxis[:, :N, :],
-                            tau_ind_tile[pos_contribution_mask],
-                            np.moveaxis(
-                                mathscr_B_l_repeat_posmasked
-                                * (
-                                    np.exp(
-                                        (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_l_tile_posmasked)
-                                        / mu_arr_pos[:, None]
-                                        - scaled_tau_arr_with_0_l_tile_posmasked / mu0
-                                    )
-                                    - np.exp(
-                                        (scaled_tau_l_tile_pos - scaled_tau_arr_with_0_lp1_tile_posmasked)
-                                        / mu_arr_pos[:, None]
-                                        - scaled_tau_arr_with_0_lp1_tile_posmasked / mu0
-                                    )
-                                )[:, :, None],
-                                0,
-                                1,
-                            ),
-                        )
-                    if np.any(neg_contribution_mask):
-                        scaled_tau_l_tile_neg = scaled_tau_tile[neg_contribution_mask]
-                        mathscr_B_l_repeat_negmasked = mathscr_B[N:, layers_arr_repeat[neg_contribution_mask], :]
-                        scaled_tau_arr_with_0_l_tile_negmasked = scaled_tau_arr_with_0_repeat[:-Ntau][
-                            neg_contribution_mask
-                        ]
-                        scaled_tau_arr_with_0_lp1_tile_negmasked = scaled_tau_arr_with_0_repeat[Ntau:][
-                            neg_contribution_mask
-                        ]
-                        np.add.at(
-                            solution_movedaxis[:, N:, :],
-                            tau_ind_tile[neg_contribution_mask],
-                            np.moveaxis(
-                                mathscr_B_l_repeat_negmasked
-                                * (
-                                    np.exp(
-                                        (scaled_tau_arr_with_0_lp1_tile_negmasked - scaled_tau_l_tile_neg)
-                                        / mu_arr_pos[:, None]
-                                        - scaled_tau_arr_with_0_lp1_tile_negmasked / mu0
-                                    )
-                                    - np.exp(
-                                        (scaled_tau_arr_with_0_l_tile_negmasked - scaled_tau_l_tile_neg)
-                                        / mu_arr_pos[:, None]
-                                        - scaled_tau_arr_with_0_l_tile_negmasked / mu0
-                                    )
-                                )[:, :, None],
-                                0,
-                                1,
-                            ),
-                        )
-                    return np.moveaxis(solution_movedaxis, 0, 1)
             # --------------------------------------------------------------------------------------------------------------------------
             else:
@@ -544,14 +487,14 @@ def pydisort(
     else:
         if only_flux:
-            NLoops = 1 # We only need to solve for the 0th Fourier mode to compute the flux
+            NFourier = 1 # We only need to solve for the 0th Fourier mode to compute the flux
         return (mu_arr,) + _assemble_solution_functions(
             scaled_omega_arr,
             tau_arr,
             scaled_tau_arr_with_0,
             mu_arr_pos, mu_arr,
             M_inv, W,
-            N, NQuad, NLeg, NLoops,
+            N, NQuad, NLeg, NFourier,
             NLayers, NBDRF,
             atmos_is_multilayered,
             weighted_scaled_Leg_coeffs,

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/subroutines.py RENAMED Viewed

@@ -30,7 +30,7 @@ def transform_interval(arr, c, d, a=-1, b=1):
 def transform_weights(weights, c, d, a=-1, b=1):
-    """Transforms quadrature weights from interval [a, b] to [c, d].
+    """Transforms an array of quadrature weights from interval [a, b] to [c, d].
     Parameters
     ----------
@@ -55,8 +55,8 @@ def transform_weights(weights, c, d, a=-1, b=1):
 def calculate_nu(mu, phi, mu_p, phi_p):
-    """Calculates the cosine of the scattering angle nu
-    between incident angle (mu_p, phi_p) and scattering angle (mu, phi).
+    """Calculates the cosine of the scattering angle `nu`
+    between incident angle `(mu_p, phi_p)` and scattering angle `(mu, phi)`.
     Parameters
     ----------
@@ -72,7 +72,7 @@ def calculate_nu(mu, phi, mu_p, phi_p):
     Returns
     -------
     ndarray
-        Cosine of scattering angles which axes capture variation with mu, phi, mu_p, phi_p respectively.
+        Cosine of scattering angles which axes capture variation with `mu, phi, mu_p, phi_p` respectively.
     """
     mu, phi, mu_p, phi_p = np.atleast_1d(mu, phi, mu_p, phi_p)
@@ -110,7 +110,7 @@ def Gauss_Legendre_quad(N, c=0, d=1):
 def Clenshaw_Curtis_quad(Nphi, c=0, d=(2 * pi)):
-    """Generates Clenshaw_Curtis quadrature weights and zero points for integration from c to d.
+    """Generates Clenshaw-Curtis quadrature zero points and weights for integration from c to d.
     Parameters
     ----------
@@ -146,9 +146,9 @@ def Clenshaw_Curtis_quad(Nphi, c=0, d=(2 * pi)):
 def generate_FD_mat(Ntau, a, b):
-    """Generates a sparse first derivative matrix in `csr` format with second-order accuracy
-    on [a,b] with `Ntau` grid points.
-    We use second order forward or backward differences at the boundaries.
+    """Generates a sparse first derivative central difference (second-order accuracy)
+    matrix on [a,b] in `csr` format with `Ntau` grid points.
+    Second order forward or backward differences are used at the boundaries.
     Parameters
     ----------
@@ -181,15 +181,15 @@ def generate_FD_mat(Ntau, a, b):
     first_deriv[-1, -2] = -2 / h
     first_deriv[-1, -3] = 1 / (2 * h)
-    return tau_arr, first_deriv.asformat("csr")
+    return tau_arr, first_deriv.tocsr()
 def atleast_2d_append(*arys):
     """View inputs as arrays with at least two dimensions.
-    Dimensions are added, when necessary, to the back of the shape tuple rather than to the front.
+    Dimensions are added as necessary to the back of the shape tuple rather than to the front.
-        This is exactly NumPy's `atleast_2d` function but altered to add dimensions to the back of the shape tuple rather than to the front.
-        View the documentation for NumPy's `atleast_2d` function at https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html.
+        This is exactly NumPy's ``numpy.atleast_2d`` function but altered to add dimensions to the back of the shape tuple rather than to the front.
+        View the documentation for ``numpy.atleast_2d`` at https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html.
     Parameters
     ----------
@@ -223,23 +223,23 @@ def atleast_2d_append(*arys):
 def generate_diff_act_flux_funcs(u0):
-    """Generates respectively the up and down diffuse actinic flux functions.
-    This a use case of the u0 function that is an output of pydisort.
+    """Generates the up and down diffuse actinic flux functions respectively.
+    This is a use case of the ``u0`` function that is an output of ``pydisort``.
     The reclassification of delta-scaled actinic flux is automatically performed.
     Parameters
     ----------
     u0 : func
         Zeroth Fourier mode of the intensity.
-        See the fourth "return" of the `pydisort` function.
+        See the fourth "return" of the ``pydisort`` function.
     Returns
     -------
     function
-        Actinic flux function with argument tau (type: array) for positive (upward) mu values.
+        Actinic flux function with argument `tau` (type: array) for positive (upward) `mu` values.
         Returns the diffuse flux magnitudes (type: array).
     function
-        Actinic flux function with argument tau (type: array) for negative (downward) mu values.
+        Actinic flux function with argument `tau` (type: array) for negative (downward) `mu` values.
         Returns the diffuse flux magnitudes (type: array).
     """

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2/src/PythonicDISORT.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.6.0
+Version: 0.6.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
@@ -32,25 +32,25 @@ In addition, upon the request of a user, we added a subroutine to calculate acti
 You may contact me, Dion, through dh3065@columbia.edu.
-This repository also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
+Our **GitHub repository:** https://github.com/LDEO-CREW/Pythonic-DISORT also includes our F2PY-wrapped Stamnes DISORT (version 4.0.99) in the `disort4.0.99_f2py` directory.
 The original was downloaded from http://www.rtatmocn.com/disort/. The wrapper is inspired by https://github.com/kconnour/pyRT_DISORT.
 # Documentation
 https://pythonic-disort.readthedocs.io/en/latest/
-Also see the accompanying Jupyter Notebook: `Pythonic-DISORT.ipynb` in the `docs` directory
-of our GitHub repository: https://github.com/LDEO-CREW/Pythonic-DISORT.
+Also see the accompanying Jupyter Notebook `Pythonic-DISORT.ipynb` in the `docs` directory
+of our GitHub repository.
 The Jupyter Notebook provides comprehensive documentation, suggested inputs, explanations,
 mathematical derivations and verification tests.
 We highly recommend reading the non-optional parts of sections 1 and 2 before use.
 ## PyTest and examples of how to use PythonicDISORT
-Separate from the verification tests in the Jupyter Notebook, we used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`,
-which is included in the `disort4.0.99_f2py` directory in this repository. In these tests, the solutions from PythonicDISORT are compared
+Not only do we have verification tests in the Jupyter Notebook, we also used PyTest to recreate most of the test problems in Stamnes' `disotest.f90`;
+`disotest.f90` is included in the `disort4.0.99_f2py` directory of our GitHub repository. In these tests, the solutions from PythonicDISORT are compared
 against solutions from our F2PY-wrapped Stamnes' DISORT (version 4.0.99). With PyTest installed, execute the console command `pytest`
 in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks, one for each test,
-to show how the test was implemented. These notebooks double up as examples of how to use PythonicDISORT.
+to show how the tests were implemented. These notebooks double up as examples of how to use PythonicDISORT.
 # Installation
@@ -74,16 +74,16 @@ must be set up to run the last section (section 6).
 ## Compatibility
-The PythonicDISORT package should be system agnostic given its minimal dependencies and pure Python code.
+The PythonicDISORT package *should* be system agnostic given its minimal dependencies and pure Python code.
 We do not guarantee that our Jupyter Notebook and F2PY-wrapped Stamnes' DISORT will work on other systems though.
 The latter will almost certainly need user edits to work and in any case it requires FORTRAN compilers which
-are not included in this repository. Everything in this repository was built and tested on Windows 11 and
+are not included in our GitHub repository. Everything in the repository was built and tested on Windows 11 but
 not yet tested on other systems.
 # Acknowledgements
 I acknowledge funding from NSF through the Learning the Earth with Artificial intelligence and Physics (LEAP)
-Science and Technology Center (STC) (Award #2019625).
+Science and Technology Center (STC) (Award #2019625) under which this package was initially created.
 # References
 1) S. Chandrasekhar. 1960. *Radiative Transfer.*

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/LICENSE.md RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/setup.cfg RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT/__init__.py RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT.egg-info/SOURCES.txt RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT.egg-info/dependency_links.txt RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT.egg-info/requires.txt RENAMED Viewed

File without changes

{PythonicDISORT-0.6.0 → PythonicDISORT-0.6.2}/src/PythonicDISORT.egg-info/top_level.txt RENAMED Viewed

File without changes

PythonicDISORT 0.6.0__tar.gz → 0.6.2__tar.gz

PythonicDISORT 0.6.0tar.gz → 0.6.2tar.gz