PythonicDISORT 0.2.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

PythonicDISORT/_loop_and_assemble_results.py

@@ -15,7 +15,7 @@ def _loop_and_assemble_results(
     N, NQuad, NLeg, NLoops,
     NLayers, NBDRF,
     weighted_scaled_Leg_coeffs,
-    weighted_Leg_coeffs_BDRF,
+    BDRF_Fourier_modes,
     mu0, I0, I0_orig, phi0,
     b_pos, b_neg,
     scalar_b_pos, scalar_b_neg,
@@ -46,7 +46,7 @@ def _loop_and_assemble_results(
         N, NQuad, NLeg,
         NLayers, NBDRF,
         weighted_scaled_Leg_coeffs,
-        weighted_Leg_coeffs_BDRF,
+        BDRF_Fourier_modes,
         mu0, I0,
         b_pos, b_neg,
         scalar_b_pos, scalar_b_neg,
@@ -91,7 +91,7 @@ def _loop_and_assemble_results(
                     N, NQuad, NLeg,
                     NLayers, NBDRF,
                     weighted_scaled_Leg_coeffs,
-                    weighted_Leg_coeffs_BDRF,
+                    BDRF_Fourier_modes,
                     mu0, I0,
                     b_pos, b_neg,
                     scalar_b_pos, scalar_b_neg,
@@ -116,7 +116,7 @@ def _loop_and_assemble_results(
                 N, NQuad, NLeg,
                 NLayers, NBDRF,
                 weighted_scaled_Leg_coeffs,
-                weighted_Leg_coeffs_BDRF,
+                BDRF_Fourier_modes,
                 mu0, I0,
                 b_pos, b_neg,
                 scalar_b_pos, scalar_b_neg,

PythonicDISORT/_one_Fourier_mode.py

@@ -15,7 +15,7 @@ def _one_Fourier_mode(
     N, NQuad, NLeg,
     NLayers, NBDRF,
     weighted_scaled_Leg_coeffs,
-    weighted_Leg_coeffs_BDRF,
+    BDRF_Fourier_modes,
     mu0, I0,
     b_pos, b_neg,
     scalar_b_pos, scalar_b_neg,
@@ -45,45 +45,39 @@ def _one_Fourier_mode(
     
     # Generate mathscr_D and mathscr_X (BDRF terms)
     # --------------------------------------------------------------------------------------------------------------------------
-    # If h_\ell = 0 for all \ell \geq m, then there is no BDRF contribution
-    # We take precautions against overflow and underflow
-    if m < NBDRF and np.all(np.isfinite(asso_leg_term_pos[:NBDRF, :])):
-        weighted_asso_Leg_coeffs_BDRF = (
-            weighted_Leg_coeffs_BDRF[ells[: (NBDRF - m)]] * fac[: (NBDRF - m)]
-        )
-        mathscr_D_temp = (
-            weighted_asso_Leg_coeffs_BDRF[None, :] * asso_leg_term_pos.T[:, :NBDRF]
-        )
-        mathscr_D_neg = 2 * mathscr_D_temp @ asso_leg_term_neg[:NBDRF, :]
+    if m < NBDRF:
+        mathscr_D_neg = (1 + (m == 0) * 1) * BDRF_Fourier_modes[m](mu_arr_pos, -mu_arr_pos)
         R = mathscr_D_neg * (mu_arr_pos * W)[None, :]
 
         if I0 > 0:
-            mathscr_X_temp = (
-                (mu0 * I0 * (2 - (m == 0)) / pi)
-                * weighted_asso_Leg_coeffs_BDRF
-                * asso_leg_term_mu0[:NBDRF]
-            )
-            mathscr_X_pos = mathscr_X_temp @ asso_leg_term_pos[:NBDRF, :]
+            mathscr_X_pos = (mu0 * I0 / pi) * BDRF_Fourier_modes[m](
+                mu_arr_pos, -np.array([mu0])
+            )[:, 0]
     # --------------------------------------------------------------------------------------------------------------------------
 
     # Loop over NLayers atmospheric layers
     # --------------------------------------------------------------------------------------------------------------------------
     if Nscoeffs > 0 and m == 0:
         G_inv_collect_0 = np.empty((NLayers, NQuad, NQuad))
-    G_collect_m = np.empty((NLayers, NQuad, NQuad))
-    K_collect_m = np.empty((NLayers, NQuad))
     if I0 > 0:
         B_collect_m = np.zeros((NLayers, NQuad))
+        
+    G_collect_m = np.empty((NLayers, NQuad, NQuad))
+    K_collect_m = np.empty((NLayers, NQuad))
+    alpha_list = []
+    beta_list = []
+    X_tilde_list=[]
+    if_indices = []
 
     for l in range(NLayers):
         # More setup
         weighted_asso_Leg_coeffs_l = weighted_scaled_Leg_coeffs[l, :][ells] * fac
         scaled_omega_l = scaled_omega_arr[l]
         
-        # We take precautions against overflow and underflow
+        # We take precautions against overflow and underflow (this shouldn't happen though)
         if np.any(weighted_asso_Leg_coeffs_l > 0) and np.all(
             np.isfinite(asso_leg_term_pos)
-        ):
+        ):  
             # Generate mathscr_D and mathscr_X (BDRF terms)
             # --------------------------------------------------------------------------------------------------------------------------
             D_temp = weighted_asso_Leg_coeffs_l[None, :] * asso_leg_term_pos.T
@@ -104,63 +98,81 @@ def _one_Fourier_mode(
             # --------------------------------------------------------------------------------------------------------------------------
             alpha = M_inv[:, None] * (D_pos * W[None, :] - np.eye(N))
             beta = M_inv[:, None] * D_neg * W[None, :]
-            A = np.vstack([np.hstack([-alpha, -beta]), np.hstack([beta, alpha])])
-            if I0 > 0:
-                X_tilde = np.concatenate([-M_inv * X_pos, M_inv * X_neg])
-            # --------------------------------------------------------------------------------------------------------------------------
-
-            # Diagonalization of coefficient matrix
-            # --------------------------------------------------------------------------------------------------------------------------
-            K_squared, eigenvecs_GpG = np.linalg.eig((alpha - beta) @ (alpha + beta))
-            if m == 0:
-                if np.any(K_squared < 1e-9): # Then |K| < 1e-3
-                    warn(
-                        "Single-scattering albedo for layer "
-                        + str(l)
-                        + " (counting from 0) is too close to 1. Results may be inaccurate."
-                    )
-
-            # Eigenvalues arranged negative then positive, from largest to smallest magnitude
-            K = np.concatenate([-np.sqrt(K_squared), np.sqrt(K_squared)])
-            eigenvecs_GpG = np.hstack([eigenvecs_GpG, eigenvecs_GpG])
-            eigenvecs_GmG = (alpha + beta) @ eigenvecs_GpG / K
-
-            # Eigenvector matrix
-            G_pos = (eigenvecs_GpG - eigenvecs_GmG) / 2
-            G_neg = (eigenvecs_GpG + eigenvecs_GmG) / 2
-            G = np.vstack([G_pos, G_neg])
-            # We only need G^{-1} in special cases
-            if Nscoeffs > 0 and m == 0:
-                G_inv = np.linalg.inv(G)
-            # --------------------------------------------------------------------------------------------------------------------------
-
-            # Particular solution for the sunbeam source
-            # --------------------------------------------------------------------------------------------------------------------------
             if I0 > 0:
-                if Nscoeffs > 0 and m == 0:
-                    B = -G / (1 / mu0 + K)[None, :] @ G_inv @ X_tilde
-                else:
-                    # This method is more numerically stable
-                    LHS = A.copy()
-                    np.fill_diagonal(LHS, 1 / mu0 + np.diag(A))
-                    B = np.linalg.solve(LHS, -X_tilde)
-
-                B_collect_m[l, :] = B
+                X_tilde_list.append(np.concatenate([-M_inv * X_pos, M_inv * X_neg]))
             # --------------------------------------------------------------------------------------------------------------------------
+            
+            if_indices.append(l)
+            alpha_list.append(alpha)
+            beta_list.append(beta)
+            
         else:
-            # This is a shortcut to the same results
-            K = -1 / mu_arr
+            # This is a shortcut to the diagonalization results
             G = np.zeros((NQuad, NQuad))
             G[N:, :N] = np.eye(N)
             G[:N, N:] = np.eye(N)
+            
+            G_collect_m[l, :, :] = G
+            K_collect_m[l, :] = -1 / mu_arr
             if Nscoeffs > 0 and m == 0:
-                G_inv = G
+                G_inv_collect_0[l, :, :] = G
+            
+    if len(if_indices) > 0:       
+    
+        # Diagonalization of coefficient matrix
+        # --------------------------------------------------------------------------------------------------------------------------
+        alpha_list = np.atleast_3d(np.array(alpha_list))
+        beta_list = np.atleast_3d(np.array(beta_list))
+
+        K_squared_arr, eigenvecs_GpG_arr = np.linalg.eig(
+            np.einsum(
+                "lij, ljk -> lik", alpha_list - beta_list, alpha_list + beta_list, optimize=True
+            ),
+        )
+        if m == 0:
+            if np.any(K_squared_arr < 1e-9):  # Then |K| < 1e-3
+                warn(
+                    "Some single-scattering albedos are too close to 1. Results may be inaccurate."
+                )
+
+        # Eigenvalues arranged negative then positive, from largest to smallest magnitude
+        K_arr = np.concatenate((-np.sqrt(K_squared_arr), np.sqrt(K_squared_arr)), axis=1)
+        eigenvecs_GpG_arr = np.concatenate((eigenvecs_GpG_arr, eigenvecs_GpG_arr), axis=2)
+        eigenvecs_GmG_arr = (
+            np.einsum(
+                "lij, ljk -> lik", alpha_list + beta_list, eigenvecs_GpG_arr, optimize=True
+            )
+            / K_arr[:, None, :]
+        )
 
-        G_collect_m[l, :, :] = G
-        K_collect_m[l, :] = K
+        # Eigenvector matrix
+        G_arr = np.concatenate(
+            (
+                (eigenvecs_GpG_arr - eigenvecs_GmG_arr) / 2,
+                (eigenvecs_GpG_arr + eigenvecs_GmG_arr) / 2,
+            ),
+            axis=1,
+        )
+        G_inv_arr = np.linalg.inv(G_arr)
+        
+        G_collect_m[if_indices, :, :] = G_arr
+        K_collect_m[if_indices, :] = K_arr
         if Nscoeffs > 0 and m == 0:
-            G_inv_collect_0[l, :, :] = G_inv
-    # --------------------------------------------------------------------------------------------------------------------------
+            G_inv_collect_0[if_indices, :, :] = G_inv_arr
+        # --------------------------------------------------------------------------------------------------------------------------
+
+        # Particular solution for the sunbeam source
+        # --------------------------------------------------------------------------------------------------------------------------
+        if I0 > 0:
+            X_tilde_list = np.atleast_2d(np.array(X_tilde_list))
+            B_collect_m[if_indices, :] = np.einsum(
+                "lij, ljk, lk -> li",
+                -G_arr / (1 / mu0 + K_arr)[:, None, :],
+                G_inv_arr,
+                X_tilde_list,
+                optimize=True,
+            )
+        # --------------------------------------------------------------------------------------------------------------------------
 
     ################################## Solve for coefficients of homogeneous solution ##########################################
     
@@ -243,7 +255,6 @@ def _one_Fourier_mode(
     else:
         _mathscr_v_contribution = 0
     
-    # If h_\ell = 0 for all \ell >= m, then there is no BDRF contribution
     if I0 > 0:
         if m < NBDRF:
             BDRF_RHS_contribution = mathscr_X_pos + R @ B_collect_m[-1, N:]
@@ -279,11 +290,7 @@ def _one_Fourier_mode(
     
     # Assemble LHS
     # --------------------------------------------------------------------------------------------------------------------------
-    dim = NLayers * NQuad
-    if NLayers >= use_sparse_NLayers:
-        LHS = sc.sparse.lil_matrix((dim, dim))
-    else:
-        LHS = np.zeros((dim, dim))
+    LHS = np.zeros((NLayers * NQuad, NLayers * NQuad))
 
     G_0_nn = G_collect_m[0, N:, :N]
     G_0_np = G_collect_m[0, N:, N:]
@@ -343,7 +350,7 @@ def _one_Fourier_mode(
     # Solve the system and return computations
     # --------------------------------------------------------------------------------------------------------------------------
     if NLayers >= use_sparse_NLayers:
-        C_m = sc.sparse.linalg.spsolve(LHS.asformat("csr"), RHS).reshape(NLayers, NQuad)
+        C_m = sc.sparse.linalg.spsolve(sc.sparse.csr_matrix(LHS), RHS).reshape(NLayers, NQuad)
     else:
         C_m = np.linalg.solve(LHS, RHS).reshape(NLayers, NQuad)
     

PythonicDISORT/pydisort.py

@@ -22,9 +22,9 @@ def pydisort(
     only_flux=False,
     f_arr=0, 
     NT_cor=False,
-    Leg_coeffs_BDRF=np.array([]),
+    BDRF_Fourier_modes=[],
     s_poly_coeffs=np.array([[]]),
-    use_sparse_NLayers=6,
+    use_sparse_NLayers=13,
     n_jobs=1
 ):
     """Solves the 1D RTE for the fluxes, and optionally intensity,
@@ -67,8 +67,9 @@ def pydisort(
         Fractional scattering into peak for each atmospheric layer.
     NT_cor : optional, bool
         Perform Nakajima-Tanaka intensity corrections?
-    Leg_coeffs_BDRF : optional, array
-        Unweighted BDRF Legendre coefficients.
+    BDRF_Fourier_modes : optional, list
+        BDRF Fourier modes, each a function with arguments mu, -mup 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.
         Arrange coefficients from lowest order term to highest.
@@ -85,19 +86,19 @@ def pydisort(
     array
         All mu (cosine of polar angle) quadrature nodes.
     function
-        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
-        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 (mu, tau) variation.
+        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.
     function, optional
         Intensity function with arguments (tau, phi, return_Fourier_error=False) of types (array, array, bool).
-        Returns an ndarray with axes corresponding to (mu, tau, phi) variation.
+        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.
 
@@ -125,10 +126,6 @@ def pydisort(
         Nscoeffs = 0
     else:
         Nscoeffs = np.shape(s_poly_coeffs)[1]
-    if np.all(Leg_coeffs_BDRF == 0):
-        NBDRF = 0
-    else:
-        NBDRF = len(Leg_coeffs_BDRF)
     NLayers = len(tau_arr)
     scalar_b_pos = False
     scalar_b_neg = False
@@ -150,7 +147,7 @@ def pydisort(
     assert NLeg > 0
     assert np.all(Leg_coeffs_all[:, 0] == 1)
     assert np.all(np.abs(Leg_coeffs_all) <= 1)
-    assert np.all(np.abs(Leg_coeffs_BDRF) <= 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
     assert np.shape(Leg_coeffs_all)[0] == NLayers
@@ -188,7 +185,7 @@ def pydisort(
     
     # Some more setup
     # --------------------------------------------------------------------------------------------------------------------------
-    weighted_Leg_coeffs_BDRF = (2 * np.arange(NBDRF) + 1) * Leg_coeffs_BDRF
+    NBDRF = len(BDRF_Fourier_modes)
     weighted_Leg_coeffs_all = (2 * np.arange(NLeg_all) + 1) * Leg_coeffs_all
     Leg_coeffs = Leg_coeffs_all[:, :NLeg]
     if (scalar_b_pos and b_pos == 0) and (scalar_b_neg and b_neg == 0) and Nscoeffs == 0 and I0 > 0:
@@ -243,7 +240,7 @@ def pydisort(
             N, NQuad, NLeg, NLoops,
             NLayers, NBDRF,
             weighted_scaled_Leg_coeffs,
-            weighted_Leg_coeffs_BDRF,
+            BDRF_Fourier_modes,
             mu0, I0, I0_orig, phi0,
             b_pos, b_neg,
             scalar_b_pos, scalar_b_neg,
@@ -368,7 +365,7 @@ def pydisort(
                 )
                 return (
                     mathscr_B[:, l, :]
-                    * np.vstack([TMS_correction_pos, TMS_correction_neg])[:, :, None]
+                    * np.vstack((TMS_correction_pos, TMS_correction_neg))[:, :, None]
                     + Contribution_from_other_layers
                 )
             # --------------------------------------------------------------------------------------------------------------------------
@@ -376,7 +373,7 @@ def pydisort(
             else:
                 return (
                     mathscr_B[:, l, :]
-                    * np.vstack([TMS_correction_pos, TMS_correction_neg])[:, :, None]
+                    * np.vstack((TMS_correction_pos, TMS_correction_neg))[:, :, None]
                 )
         # --------------------------------------------------------------------------------------------------------------------------
 
@@ -453,7 +450,7 @@ def pydisort(
             N, NQuad, NLeg, NLoops,
             NLayers, NBDRF,
             weighted_scaled_Leg_coeffs,
-            weighted_Leg_coeffs_BDRF,
+            BDRF_Fourier_modes,
             mu0, I0, I0_orig, phi0,
             b_pos, b_neg,
             scalar_b_pos, scalar_b_neg,

PythonicDISORT/subroutines.py

@@ -75,7 +75,7 @@ def calculate_nu(mu, phi, mu_p, phi_p):
     Returns
     -------
     ndarray
-        Cosine of scattering angles.
+        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)
@@ -88,7 +88,7 @@ def calculate_nu(mu, phi, mu_p, phi_p):
 
 
 def Gauss_Legendre_quad(N, c=0, d=1):
-    """Generates Gauss-Legendre quadrature weights and zero points for integration from c to d.
+    """Generates Gauss-Legendre quadrature zero points and weights for integration from c to d.
 
     Parameters
     ----------
@@ -223,6 +223,37 @@ def atleast_2d_append(*arys):
         return res[0]
     else:
         return res
+        
+        
+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.
+    Reclassification of delta-scaled flux is not performed and must be done manually.
+
+    Parameters
+    ----------
+    u0 : func
+        Zeroth Fourier mode of the intensity.
+        See the fourth "return" of the `pydisort` function.
+
+    Returns
+    -------
+    function
+        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.
+        Returns the diffuse flux magnitudes (type: array).
+
+    """
+    N = np.shape(u0(0))[0] // 2
+    GL_weights = Gauss_Legendre_quad(N, 0, 1)[1]
+
+    # Note that the zeroth axis of the array u0(tau) captures variation with mu
+    flux_act_up = lambda tau: 2 * pi * GL_weights @ u0(tau)[:N]
+    flux_act_down_diffuse = lambda tau: 2 * pi * GL_weights @ u0(tau)[N:]
+    
+    return flux_act_up, flux_act_down_diffuse
 
 
 def _mathscr_v(tau, l, s_poly_coeffs, Nscoeffs, G, K, G_inv, mu_arr):

{PythonicDISORT-0.2.4.dist-info → PythonicDISORT-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.2.4
+Version: 0.4.0
 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/PythonicDISORT
@@ -9,7 +9,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: numpy >=1.17.3
+Requires-Dist: numpy >=1.8.0
 Requires-Dist: scipy >=1.8.0
 Provides-Extra: joblib
 Requires-Dist: joblib >=1.0.0 ; extra == 'joblib'
@@ -53,7 +53,7 @@ With PyTest installed, execute the console command `pytest` in the `pydisotest`
 
 ## Requirements to run PythonicDISORT
 * Python 3.8+
-* `numpy >= 1.17.3`
+* `numpy >= 1.8.0`
 * `scipy >= 1.8.0`
 * (OPTIONAL) `joblib >= 1.0.0` (Required for parallelization)
 * (OPTIONAL) `pytest >= 6.2.5` (Required for non-Notebook tests)

PythonicDISORT-0.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
+PythonicDISORT/_loop_and_assemble_results.py,sha256=JjQApo_EXbEkqOsw4jDI6WkhN5DJc9Pl9kgxCGUQGeM,15746
+PythonicDISORT/_one_Fourier_mode.py,sha256=FZL1isE2dxRRAHExH_g4J9ygkbBIq2wNMg-3INp1vac,15191
+PythonicDISORT/pydisort.py,sha256=KX6g45CvwazVrdj7m7QEGraosWSalcvKtHesurG-oC8,21449
+PythonicDISORT/subroutines.py,sha256=G3-LwkAsCkiVwPT_PzJkzmqVRdV1U0alsVyFeGtub7Q,11756
+PythonicDISORT-0.4.0.dist-info/METADATA,sha256=Z9pjwzDjt-wMih3lUTdiAkCeznQtoVjIvEB7iiEvFxc,5828
+PythonicDISORT-0.4.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+PythonicDISORT-0.4.0.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
+PythonicDISORT-0.4.0.dist-info/RECORD,,

PythonicDISORT-0.2.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
-PythonicDISORT/_loop_and_assemble_results.py,sha256=WiSX14S2R7OUNqTdxUA2QHxZ4ZPX6U77mIFkfwtKuIw,15770
-PythonicDISORT/_one_Fourier_mode.py,sha256=Lo13JHcLPQTEqIy60-_RrXjybKPX7PCSwC_fEGO9ksw,15498
-PythonicDISORT/pydisort.py,sha256=YcFOsMAVwiU9jWHhDvUUSMQN6JRdW_aweauUk5kgeMU,21389
-PythonicDISORT/subroutines.py,sha256=zYj5nPG_XCAvR0Rj6ae4XtEKaY2Gxsyjr_Yw41BLI_E,10495
-PythonicDISORT-0.2.4.dist-info/METADATA,sha256=vRrKIs4Pfu1P1ZLPUBN-tjSfCGN5EU_RETk1WfpCzW0,5830
-PythonicDISORT-0.2.4.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-PythonicDISORT-0.2.4.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
-PythonicDISORT-0.2.4.dist-info/RECORD,,