PythonicDISORT 0.6.1__tar.gz → 0.6.2__tar.gz

{PythonicDISORT-0.6.1/src/PythonicDISORT.egg-info → PythonicDISORT-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.6.1
+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

{PythonicDISORT-0.6.1 → PythonicDISORT-0.6.2}/pyproject.toml

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

{PythonicDISORT-0.6.1 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_assemble_solution_functions.py

@@ -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.1 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_diagonalize.py

@@ -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.1 → PythonicDISORT-0.6.2}/src/PythonicDISORT/_solve_for_coefs.py

@@ -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
         

{PythonicDISORT-0.6.1 → PythonicDISORT-0.6.2}/src/PythonicDISORT/pydisort.py

@@ -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,
@@ -54,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.
@@ -116,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):
@@ -159,11 +159,11 @@ 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 NLeg <= NQuad
     # We require principal angles and a downward incident beam
@@ -175,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
@@ -240,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,
@@ -487,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.1 → PythonicDISORT-0.6.2/src/PythonicDISORT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.6.1
+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