PythonicDISORT 0.8.0__tar.gz → 0.9.1__tar.gz

{pythonicdisort-0.8.0/src/PythonicDISORT.egg-info → pythonicdisort-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PythonicDISORT
-Version: 0.8.0
+Version: 0.9.1
 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
@@ -28,8 +28,10 @@ On the other hand, PythonicDISORT should be easier to install, use, and modify t
 
 PythonicDISORT is based on Stamnes' FORTRAN DISORT (see References, in particular [2, 3, 8]) and has its main features: multi-layer solver, 
 delta-M scaling, Nakajima-Tanaka (NT) corrections, only flux option, direct beam source, isotropic internal source (blackbody emission), 
-Dirichlet boundary conditions (diffuse flux boundary sources), Bi-Directional Reflectance Function (BDRF) for surface reflection, and more.
-In addition, subroutine to calculate actinic fluxes was added to satisfy a user request and further feature requests as well as feedback are welcome.
+Dirichlet boundary conditions (diffuse flux boundary sources), Bi-Directional Reflectance Function (BDRF) for surface reflection, 
+interpolation with respect to polar angle and more.
+In addition, we added a subroutine to calculate actinic fluxes to satisfy a user request, and integration with respect to tau was also added.
+Further feature requests as well as feedback are welcome.
 
 You may contact me, Dion, through dh3065@columbia.edu.
 
@@ -50,8 +52,8 @@ Not only are there verification tests in `Pythonic-DISORT.ipynb`,
 most of the test problems in Stamnes' `disotest.f90` (download DISORT 4.0.99 from http://www.rtatmocn.com/disort/) have also been recreated.
 In these tests, the solutions from PythonicDISORT are compared against solutions 
 from a F2PY-wrapped Stamnes' DISORT (version 4.0.99; wrapper inspired by https://github.com/kconnour/pyRT_DISORT). With PyTest installed, execute the console command `pytest` 
-in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks that correspond to each test
-to show how it was implemented. These notebooks double up as examples of how to use PythonicDISORT.
+in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks to show the implementation of each test.
+These notebooks double up as examples of how to use PythonicDISORT.
 
 # Installation
 

{pythonicdisort-0.8.0 → pythonicdisort-0.9.1}/README.md

@@ -7,8 +7,10 @@ On the other hand, PythonicDISORT should be easier to install, use, and modify t
 
 PythonicDISORT is based on Stamnes' FORTRAN DISORT (see References, in particular [2, 3, 8]) and has its main features: multi-layer solver, 
 delta-M scaling, Nakajima-Tanaka (NT) corrections, only flux option, direct beam source, isotropic internal source (blackbody emission), 
-Dirichlet boundary conditions (diffuse flux boundary sources), Bi-Directional Reflectance Function (BDRF) for surface reflection, and more.
-In addition, subroutine to calculate actinic fluxes was added to satisfy a user request and further feature requests as well as feedback are welcome.
+Dirichlet boundary conditions (diffuse flux boundary sources), Bi-Directional Reflectance Function (BDRF) for surface reflection, 
+interpolation with respect to polar angle and more.
+In addition, we added a subroutine to calculate actinic fluxes to satisfy a user request, and integration with respect to tau was also added.
+Further feature requests as well as feedback are welcome.
 
 You may contact me, Dion, through dh3065@columbia.edu.
 
@@ -29,8 +31,8 @@ Not only are there verification tests in `Pythonic-DISORT.ipynb`,
 most of the test problems in Stamnes' `disotest.f90` (download DISORT 4.0.99 from http://www.rtatmocn.com/disort/) have also been recreated.
 In these tests, the solutions from PythonicDISORT are compared against solutions 
 from a F2PY-wrapped Stamnes' DISORT (version 4.0.99; wrapper inspired by https://github.com/kconnour/pyRT_DISORT). With PyTest installed, execute the console command `pytest` 
-in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks that correspond to each test
-to show how it was implemented. These notebooks double up as examples of how to use PythonicDISORT.
+in the `pydisotest` directory to run these tests. The `pydisotest` directory also contains Jupyter Notebooks to show the implementation of each test.
+These notebooks double up as examples of how to use PythonicDISORT.
 
 # Installation
 

{pythonicdisort-0.8.0 → pythonicdisort-0.9.1}/pyproject.toml

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

{pythonicdisort-0.8.0 → pythonicdisort-0.9.1}/src/PythonicDISORT/_assemble_intensity_and_fluxes.py

@@ -20,12 +20,12 @@ def _assemble_intensity_and_fluxes(
     there_is_beam_source,               # Is there a beam source?
     b_pos, b_neg,                       # Dirichlet BCs
     b_pos_is_scalar, b_neg_is_scalar,   # Is each Dirichlet BCs scalar (isotropic)?
-    s_poly_coeffs,                      # Polynomial coefficients of isotropic source
     Nscoeffs,                           # Number of isotropic source polynomial coefficients
+    s_poly_coeffs,                      # Polynomial coefficients of isotropic source
     there_is_iso_source,                # Is there an isotropic source?
     scale_tau,                          # Delta-scale factor for tau
     only_flux,                          # Only compute fluxes?
-    NLayers_to_use_sparse,              # Number of layers above or equal which to use sparse matrices
+    use_banded_solver_NLayers,          # Number of layers above or equal which to use `scipy.linalg.solve_banded`
     _autograd_compatible,               # Should the output functions be compatible with autograd?
 ):  
     """Assembles the solution functions: intensity `u`, upward flux `flux_up`, downward flux `flux_down` 
@@ -66,13 +66,13 @@ def _assemble_intensity_and_fluxes(
     | `b_pos`                        | `NQuad/2 x NFourier` or scalar     |
     | `b_neg`                        | `NQuad/2 x NFourier` or scalar     |
     | `b_pos_is_scalar`              | boolean                            |
-    | `b_neg_is_scalar`              | boolean                            |              
+    | `b_neg_is_scalar`              | boolean                            |        
+    | `Nscoeffs`                     | scalar                             |    
     | `s_poly_coeffs`                | `NLayers x Nscoeffs` or `Nscoeffs` |
-    | `Nscoeffs`                     | scalar                             |
     | `there_is_iso_source`          | boolean                            |
     | `scale_tau`                    | `NLayers`                          |
     | `only_flux`                    | boolean                            |
-    | `NLayers_to_use_sparse`        | scalar                             |
+    | `use_banded_solver_NLayers`    | scalar                             |
     | `_autograd_compatible`         | boolean                            |
     
     Notable internal variables of _assemble_intensity_and_fluxes
@@ -146,10 +146,10 @@ def _assemble_intensity_and_fluxes(
         there_is_beam_source,
         b_pos, b_neg,
         b_pos_is_scalar, b_neg_is_scalar,
-        s_poly_coeffs,
         Nscoeffs,
+        s_poly_coeffs,
         there_is_iso_source,
-        NLayers_to_use_sparse,
+        use_banded_solver_NLayers,
     )
     
     G_collect_0 = G_collect[0, :, :, :]
@@ -198,26 +198,28 @@ def _assemble_intensity_and_fluxes(
             
             if is_antiderivative_wrt_tau:
                 if there_is_beam_source:
-                    um = np.einsum(
-                        "mtij, mtj -> mti",
-                        GC_collect[:, l, :, :],
-                        np.exp(exponent) / (scale_tau[None, l, None] * K_collect[:, l, :]),
-                        optimize=True,
-                    ) + B_collect[:, l, :] * np.exp(-scaled_tau[None, :, None] / mu0) / (
-                        -scale_tau[None, l, None] / mu0
+                    um = (
+                        np.einsum(
+                            "mtij, mtj -> mti",
+                            GC_collect[:, l, :, :],
+                            np.exp(exponent) / (scale_tau[None, :, None] * K_collect)[:, l, :],
+                            optimize=True,
+                        )
+                        + (B_collect / (-scale_tau / mu0)[None, :, None])[:, l, :]
+                        * np.exp(-scaled_tau / mu0)[None, :, None]
                     )
                 else:
                     um = np.einsum(
                         "mtij, mtj -> mti",
                         GC_collect[:, l, :, :],
-                        np.exp(exponent) / (scale_tau[None, l, None] * K_collect[:, l, :]),
+                        np.exp(exponent) / (scale_tau[None, l, None] * K_collect)[:, l, :],
                         optimize=True,
                     )
             else:
                 if there_is_beam_source:
                     um = np.einsum(
                         "mtij, mtj -> mti", GC_collect[:, l, :, :], np.exp(exponent), optimize=True
-                    ) + B_collect[:, l, :] * np.exp(-scaled_tau[None, :, None] / mu0)
+                    ) + B_collect[:, l, :] * np.exp(-scaled_tau / mu0)[None, :, None]
                 else:
                     um = np.einsum(
                         "mtij, mtj -> mti", GC_collect[:, l, :, :], np.exp(exponent), optimize=True
@@ -225,20 +227,23 @@ def _assemble_intensity_and_fluxes(
             
             # Contribution from particular solution for isotropic internal sources
             if there_is_iso_source:
+                l_uniq, l_inv = np.unique(l, return_inverse=True)
                 _mathscr_v_contribution = _mathscr_v(
-                    tau, l,
-                    s_poly_coeffs,
-                    Nscoeffs,
-                    G_collect_0,
-                    K_collect_0,
-                    G_inv_collect_0,
+                    tau, l_inv, Nscoeffs,
+                    s_poly_coeffs[l_uniq],
+                    G_collect_0[l_uniq],
+                    K_collect_0[l_uniq],
+                    G_inv_collect_0[l_uniq],
                     mu_arr,
-                    _autograd_compatible,
-                    is_antiderivative_wrt_tau
+                    is_antiderivative_wrt_tau,
+                    _autograd_compatible
                 )
                 
                 if _autograd_compatible:
-                    um = um + np.concatenate((_mathscr_v_contribution.T, np.zeros((NFourier - 1, len(tau), NQuad))))
+                    if NFourier == 1:
+                        um = um + _mathscr_v_contribution.T
+                    else:
+                        um = um + np.concatenate((_mathscr_v_contribution.T, np.zeros((NFourier - 1, len(tau), NQuad))))
                 else:
                     um[0, :, :] += _mathscr_v_contribution.T
                 
@@ -259,26 +264,28 @@ def _assemble_intensity_and_fluxes(
                 )
                 if is_antiderivative_wrt_tau:
                     if there_is_beam_source:
-                        ulast = np.einsum(
-                            "tij, tj -> it",
-                            GC_collect[-1, l, :, :],
-                            np.exp(exponent) / (scale_tau[l, None] * K_collect[-1, l, :]),
-                            optimize=True,
-                        ) + B_collect[-1, l, :].T * np.exp(-scaled_tau[None, :] / mu0) / (
-                            -scale_tau[None, l] / mu0
+                        ulast = (
+                            np.einsum(
+                                "tij, tj -> it",
+                                GC_collect[-1, l, :, :],
+                                np.exp(exponent) / (scale_tau[:, None] * K_collect[-1, :, :])[l, :],
+                                optimize=True,
+                            )
+                            + (B_collect.T[-1, :, :] / (-scale_tau / mu0)[None, :])[:, l]
+                            * np.exp(-scaled_tau / mu0)[None, :]
                         )
                     else:
                         ulast = np.einsum(
                             "tij, tj -> it",
                             GC_collect[-1, l, :, :],
-                            np.exp(exponent) / (scale_tau[l, None] * K_collect[-1, l, :]),
+                            np.exp(exponent) / (scale_tau[:, None] * K_collect[-1, :, :])[l, :],
                             optimize=True,
                         )
                 else:
                     if there_is_beam_source:
                         ulast = np.einsum(
                             "tij, tj -> it", GC_collect[-1, l, :, :], np.exp(exponent), optimize=True
-                        ) + B_collect[-1, l, :].T * np.exp(-scaled_tau[None, :] / mu0)
+                        ) + B_collect.T[-1, :, l] * np.exp(-scaled_tau / mu0)[None, :]
                     else:
                         ulast = np.einsum(
                             "tij, tj -> it", GC_collect[-1, l, :, :], np.exp(exponent), optimize=True
@@ -330,7 +337,10 @@ def _assemble_intensity_and_fluxes(
             # in performing the reclassification of delta-scaled actinic flux
             if _return_act_dscale_for_reclass: 
                 if is_antiderivative_wrt_tau:
-                    act_dscale_reclassification = I0 * np.exp(-scaled_tau / mu0) / (-scale_tau[l] / mu0) - I0 * np.exp(-tau / mu0) * -mu0
+                    act_dscale_reclassification = (
+                        I0 * np.exp(-scaled_tau / mu0) / (-scale_tau[l] / mu0)
+                        - I0 * np.exp(-tau / mu0) * -mu0
+                    )
                 else:
                     act_dscale_reclassification = I0 * np.exp(-scaled_tau / mu0) - I0 * np.exp(-tau / mu0)
         else:
@@ -348,26 +358,28 @@ def _assemble_intensity_and_fluxes(
         
         if is_antiderivative_wrt_tau:
             if there_is_beam_source:
-                u0 = np.einsum(
-                    "tij, tj -> it",
-                    GC_collect_0[l, :, :],
-                    np.exp(exponent) / (scale_tau[l, None] * K_collect_0[l, :]),
-                    optimize=True,
-                ) + B_collect_0[l, :].T * np.exp(-scaled_tau[None, :] / mu0) / (
-                    -scale_tau[None, l] / mu0
+                u0 = (
+                    np.einsum(
+                        "tij, tj -> it",
+                        GC_collect_0[l, :, :],
+                        np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :],
+                        optimize=True,
+                    )
+                    + (B_collect_0.T / (-scale_tau / mu0)[None, :])[:, l]
+                    * np.exp(-scaled_tau / mu0)[None, :]
                 )
             else:
                 u0 = np.einsum(
                     "tij, tj -> it",
                     GC_collect_0[l, :, :],
-                    np.exp(exponent) / (scale_tau[l, None] * K_collect_0[l, :]),
+                    np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :],
                     optimize=True,
                 )
         else:
             if there_is_beam_source:
                 u0 = np.einsum(
                     "tij, tj -> it", GC_collect_0[l, :, :], np.exp(exponent), optimize=True
-                ) + B_collect_0[l, :].T * np.exp(-scaled_tau[None, :] / mu0)
+                ) + B_collect_0.T[:, l] * np.exp(-scaled_tau / mu0)[None, :]
             else:
                 u0 = np.einsum(
                     "tij, tj -> it", GC_collect_0[l, :, :], np.exp(exponent), optimize=True
@@ -375,16 +387,16 @@ def _assemble_intensity_and_fluxes(
         
         # Contribution from particular solution for isotropic internal sources
         if there_is_iso_source:
+            l_uniq, l_inv = np.unique(l, return_inverse=True)
             _mathscr_v_contribution = _mathscr_v(
-                tau, l,
-                s_poly_coeffs,
-                Nscoeffs,
-                G_collect_0,
-                K_collect_0,
-                G_inv_collect_0,
+                tau, l_inv, Nscoeffs,
+                s_poly_coeffs[l_uniq],
+                G_collect_0[l_uniq],
+                K_collect_0[l_uniq],
+                G_inv_collect_0[l_uniq],
                 mu_arr,
-                _autograd_compatible,
-                is_antiderivative_wrt_tau
+                is_antiderivative_wrt_tau,
+                _autograd_compatible
             )
             u0 = u0 + _mathscr_v_contribution
         
@@ -428,27 +440,27 @@ def _assemble_intensity_and_fluxes(
             scaled_tau = tau
 
         if there_is_iso_source:
+            l_uniq, l_inv = np.unique(l, return_inverse=True)
             _mathscr_v_contribution = _mathscr_v(
-                tau, l,
-                s_poly_coeffs,
-                Nscoeffs,
-                G_collect_0,
-                K_collect_0,
-                G_inv_collect_0,
+                tau, l_inv, Nscoeffs,
+                s_poly_coeffs[l_uniq],
+                G_collect_0[l_uniq, :N, :],
+                K_collect_0[l_uniq],
+                G_inv_collect_0[l_uniq],
                 mu_arr,
-                _autograd_compatible,
-                is_antiderivative_wrt_tau
-            )[:N, :]
+                is_antiderivative_wrt_tau,
+                _autograd_compatible
+            )
         else:
             _mathscr_v_contribution = 0
         
         if there_is_beam_source:
             if is_antiderivative_wrt_tau:
                 direct_beam_contribution = (
-                    B_pos[:, l] * np.exp(-scaled_tau[None, :] / mu0) / (-scale_tau[None, l] / mu0)
+                    (B_pos / (-scale_tau / mu0)[None, :])[:, l] * np.exp(-scaled_tau / mu0)[None, :] 
                 )
             else:
-                direct_beam_contribution = B_pos[:, l] * np.exp(-scaled_tau[None, :] / mu0)
+                direct_beam_contribution = B_pos[:, l] * np.exp(-scaled_tau / mu0)[None, :]
         else:
             direct_beam_contribution = 0
 
@@ -465,7 +477,7 @@ def _assemble_intensity_and_fluxes(
                 np.einsum(
                     "tij, tj -> it",
                     GC_pos[l, :, :],
-                    np.exp(exponent) / (scale_tau[l, None] * K_collect_0[l, :]),
+                    np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :],
                 )
                 + direct_beam_contribution
                 + _mathscr_v_contribution
@@ -507,27 +519,27 @@ def _assemble_intensity_and_fluxes(
             scaled_tau = tau
 
         if there_is_iso_source:
+            l_uniq, l_inv = np.unique(l, return_inverse=True)
             _mathscr_v_contribution = _mathscr_v(
-                tau, l,
-                s_poly_coeffs,
-                Nscoeffs,
-                G_collect_0,
-                K_collect_0,
-                G_inv_collect_0,
+                tau, l_inv, Nscoeffs,
+                s_poly_coeffs[l_uniq],
+                G_collect_0[l_uniq, N:, :],
+                K_collect_0[l_uniq],
+                G_inv_collect_0[l_uniq],
                 mu_arr,
-                _autograd_compatible,
-                is_antiderivative_wrt_tau
-            )[N:, :]
+                is_antiderivative_wrt_tau,
+                _autograd_compatible
+            )
         else:
             _mathscr_v_contribution = 0
         
         if there_is_beam_source:
             if is_antiderivative_wrt_tau:
-                direct_beam_contribution = B_neg[:, l] * np.exp(-scaled_tau[None, :] / mu0) / (-scale_tau[None, l] / mu0)
+                direct_beam_contribution = (B_neg / (-scale_tau / mu0)[None, l])[:, l] * np.exp(-scaled_tau / mu0)[None, :]
                 direct_beam = I0 * mu0 * np.exp(-tau / mu0) * -mu0
-                direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0) / (-scale_tau[None, l] / mu0)
+                direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0) / (-scale_tau / mu0)[None, l]
             else:
-                direct_beam_contribution = B_neg[:, l] * np.exp(-scaled_tau[None, :] / mu0)
+                direct_beam_contribution = B_neg[:, l] * np.exp(-scaled_tau / mu0)[None, :]
                 direct_beam = I0 * mu0 * np.exp(-tau / mu0)
                 direct_beam_scaled = I0 * mu0 * np.exp(-scaled_tau / mu0)
         else:
@@ -545,7 +557,7 @@ def _assemble_intensity_and_fluxes(
         
         if is_antiderivative_wrt_tau:
             u0_neg = (
-                np.einsum("tij, tj -> it", GC_neg[l, :, :], np.exp(exponent) / (scale_tau[l, None] * K_collect_0[l, :]))
+                np.einsum("tij, tj -> it", GC_neg[l, :, :], np.exp(exponent) / (scale_tau[:, None] * K_collect_0)[l, :])
                 + direct_beam_contribution
                 + _mathscr_v_contribution
             )