PythonicDISORT 1.2__py3-none-any.whl → 1.4__py3-none-any.whl
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.
- PythonicDISORT/_assemble_intensity_and_fluxes.py +57 -49
- PythonicDISORT/_solve_for_coeffs.py +208 -142
- PythonicDISORT/_solve_for_gen_and_part_sols.py +75 -69
- PythonicDISORT/pydisort.py +198 -197
- PythonicDISORT/subroutines.py +185 -112
- {pythonicdisort-1.2.dist-info → pythonicdisort-1.4.dist-info}/METADATA +3 -2
- pythonicdisort-1.4.dist-info/RECORD +11 -0
- {pythonicdisort-1.2.dist-info → pythonicdisort-1.4.dist-info}/WHEEL +1 -1
- pythonicdisort-1.2.dist-info/RECORD +0 -11
- {pythonicdisort-1.2.dist-info → pythonicdisort-1.4.dist-info}/LICENSE.md +0 -0
- {pythonicdisort-1.2.dist-info → pythonicdisort-1.4.dist-info}/top_level.txt +0 -0
PythonicDISORT/subroutines.py
CHANGED
|
@@ -1,6 +1,32 @@
|
|
|
1
1
|
import numpy as np
|
|
2
2
|
import scipy as sc
|
|
3
3
|
from math import pi
|
|
4
|
+
import warnings
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
def prepend(arr, arr_len, value):
|
|
8
|
+
"""Prepend value to array.
|
|
9
|
+
Faster than ``np.insert(arr, 0, value)``.
|
|
10
|
+
|
|
11
|
+
Parameters
|
|
12
|
+
----------
|
|
13
|
+
arr : array
|
|
14
|
+
The 1D array to which to prepend.
|
|
15
|
+
arr_len : int
|
|
16
|
+
Length of original array (``arr``).
|
|
17
|
+
value : float
|
|
18
|
+
Value to prepend.
|
|
19
|
+
|
|
20
|
+
Returns
|
|
21
|
+
-------
|
|
22
|
+
array
|
|
23
|
+
Array of length ``arr_len + 1`` with ``value`` prepended.
|
|
24
|
+
|
|
25
|
+
"""
|
|
26
|
+
new_arr = np.empty(arr_len + 1)
|
|
27
|
+
new_arr[1:] = arr
|
|
28
|
+
new_arr[0] = value
|
|
29
|
+
return new_arr
|
|
4
30
|
|
|
5
31
|
|
|
6
32
|
|
|
@@ -141,7 +167,7 @@ def Clenshaw_Curtis_quad(Nphi, c=0, d=(2 * pi)):
|
|
|
141
167
|
Nphi_pos = Nphi // 2
|
|
142
168
|
phi_arr_pos = np.cos(pi * np.arange(Nphi_pos) / Nphi)
|
|
143
169
|
phi_arr = np.concatenate([-phi_arr_pos, [0], np.flip(phi_arr_pos)])
|
|
144
|
-
diff =
|
|
170
|
+
diff = prepend(2 / (1 - 4 * np.arange(1, Nphi_pos + 1) ** 2), Nphi_pos, 2)
|
|
145
171
|
weights_phi_pos = sc.fft.idct(diff, type=1)
|
|
146
172
|
weights_phi_pos[0] /= 2
|
|
147
173
|
full_weights_phi = np.hstack((weights_phi_pos, np.flip(weights_phi_pos[:-1])))
|
|
@@ -418,7 +444,7 @@ def generate_s_poly_coeffs(tau_arr, TEMPER, WVNMLO, WVNMHI, **kwargs):
|
|
|
418
444
|
"Missing temperature specification at some boundaries / interfaces."
|
|
419
445
|
)
|
|
420
446
|
|
|
421
|
-
tau_arr_with_0 =
|
|
447
|
+
tau_arr_with_0 = prepend(tau_arr, len(tau_arr), 0)
|
|
422
448
|
blackbody_emission_at_each_boundary = sc.integrate.quad_vec(
|
|
423
449
|
lambda WVNM: Planck(TEMPER, WVNM), WVNMLO, WVNMHI, **kwargs
|
|
424
450
|
)[0]
|
|
@@ -461,21 +487,22 @@ def generate_emissivity_from_BDRF(N, zeroth_BDRF_Fourier_mode):
|
|
|
461
487
|
|
|
462
488
|
|
|
463
489
|
|
|
464
|
-
def cache_BDRF_Fourier_modes(N,
|
|
465
|
-
"""If the same BDRF
|
|
466
|
-
consider using this function to cache ``BDRF_Fourier_modes`` and
|
|
467
|
-
``cached_BDRF_Fourier_modes``
|
|
490
|
+
def cache_BDRF_Fourier_modes(N, BDRF_Fourier_modes, mu0=0):
|
|
491
|
+
"""If the same BDRF and number of streams will be used repeatedly,
|
|
492
|
+
consider using this function to cache ``BDRF_Fourier_modes`` and pass
|
|
493
|
+
``cached_BDRF_Fourier_modes`` to ``pydisort``. It is also possible
|
|
494
|
+
to cache ``BDRF_Fourier_modes`` with respect to a fixed ``mu0``.
|
|
468
495
|
|
|
469
496
|
Parameters
|
|
470
497
|
----------
|
|
471
498
|
N : int
|
|
472
499
|
Number of upper hemisphere quadrature nodes. Equal to ``NQuad // 2``.
|
|
473
|
-
mu0 : float
|
|
474
|
-
Cosine of polar angle of the incident beam.
|
|
475
500
|
BDRF_Fourier_modes : list of functions and scalars
|
|
476
501
|
BDRF Fourier modes, each a scalar representing a constant function,
|
|
477
502
|
or a function with arguments ``mu, -mu_p`` of type array
|
|
478
503
|
which output has the same dimensions as the outer product of the two arrays.
|
|
504
|
+
mu0 : float, optional
|
|
505
|
+
Cosine of polar angle of the incident beam.
|
|
479
506
|
|
|
480
507
|
Returns
|
|
481
508
|
-------
|
|
@@ -484,30 +511,61 @@ def cache_BDRF_Fourier_modes(N, mu0, BDRF_Fourier_modes):
|
|
|
484
511
|
and which output is a scalar (if the Fourier mode was a scalar)
|
|
485
512
|
or has the same dimensions as the outer product of the two arrays.
|
|
486
513
|
"""
|
|
514
|
+
|
|
515
|
+
if (0 < mu0 and mu0 <= 1):
|
|
516
|
+
mu0_caching = True
|
|
517
|
+
else:
|
|
518
|
+
mu0_caching = False
|
|
519
|
+
warnings.warn("No caching with respect to `mu0`.")
|
|
520
|
+
|
|
487
521
|
NBDRF = len(BDRF_Fourier_modes)
|
|
488
522
|
mu_arr_pos = Gauss_Legendre_quad(N)[0]
|
|
523
|
+
|
|
524
|
+
if mu0_caching:
|
|
525
|
+
BDRF_Fourier_modes_evaluated = [
|
|
526
|
+
(
|
|
527
|
+
BDRF_Fourier_modes[m]
|
|
528
|
+
if np.isscalar(BDRF_Fourier_modes[m])
|
|
529
|
+
else BDRF_Fourier_modes[m](mu_arr_pos, np.append(mu_arr_pos, mu0))
|
|
530
|
+
)
|
|
531
|
+
for m in range(NBDRF)
|
|
532
|
+
]
|
|
489
533
|
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
cached_BDRF_Fourier_modes = [
|
|
500
|
-
(
|
|
501
|
-
lambda mu, neg_mup, m=m: BDRF_Fourier_modes[m]
|
|
502
|
-
if np.isscalar(BDRF_Fourier_modes[m])
|
|
503
|
-
else (
|
|
504
|
-
BDRF_Fourier_modes_evaluated[m][:, [-1]]
|
|
505
|
-
if len(neg_mup) == 1
|
|
506
|
-
else BDRF_Fourier_modes_evaluated[m][:, :-1]
|
|
534
|
+
cached_BDRF_Fourier_modes = [
|
|
535
|
+
(
|
|
536
|
+
lambda mu, neg_mup, m=m: BDRF_Fourier_modes_evaluated[m]
|
|
537
|
+
if np.isscalar(BDRF_Fourier_modes_evaluated[m])
|
|
538
|
+
else (
|
|
539
|
+
BDRF_Fourier_modes_evaluated[m][:, [-1]]
|
|
540
|
+
if len(neg_mup) == 1
|
|
541
|
+
else BDRF_Fourier_modes_evaluated[m][:, :-1]
|
|
542
|
+
)
|
|
507
543
|
)
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
544
|
+
for m in range(NBDRF)
|
|
545
|
+
]
|
|
546
|
+
|
|
547
|
+
else:
|
|
548
|
+
BDRF_Fourier_modes_evaluated = [
|
|
549
|
+
(
|
|
550
|
+
BDRF_Fourier_modes[m]
|
|
551
|
+
if np.isscalar(BDRF_Fourier_modes[m])
|
|
552
|
+
else BDRF_Fourier_modes[m](mu_arr_pos, mu_arr_pos)
|
|
553
|
+
)
|
|
554
|
+
for m in range(NBDRF)
|
|
555
|
+
]
|
|
556
|
+
|
|
557
|
+
cached_BDRF_Fourier_modes = [
|
|
558
|
+
(
|
|
559
|
+
lambda mu, neg_mup, m=m: BDRF_Fourier_modes_evaluated[m]
|
|
560
|
+
if np.isscalar(BDRF_Fourier_modes_evaluated[m])
|
|
561
|
+
else (
|
|
562
|
+
BDRF_Fourier_modes[m](mu_arr_pos, neg_mup)
|
|
563
|
+
if len(neg_mup) == 1
|
|
564
|
+
else BDRF_Fourier_modes_evaluated[m]
|
|
565
|
+
)
|
|
566
|
+
)
|
|
567
|
+
for m in range(NBDRF)
|
|
568
|
+
]
|
|
511
569
|
|
|
512
570
|
return cached_BDRF_Fourier_modes
|
|
513
571
|
|
|
@@ -583,7 +641,8 @@ def interpolate(u):
|
|
|
583
641
|
u_pos_interpol = sc.interpolate.BarycentricInterpolator(mu_arr_pos)
|
|
584
642
|
u_neg_interpol = sc.interpolate.BarycentricInterpolator(-mu_arr_pos)
|
|
585
643
|
|
|
586
|
-
|
|
644
|
+
argcount = u.__code__.co_argcount
|
|
645
|
+
if argcount == 5: # Function is `u` instead of `u0`
|
|
587
646
|
def u_interpol(mu, tau, phi, is_antiderivative_wrt_tau=False, return_Fourier_error=False, return_tau_arr=False):
|
|
588
647
|
if not np.all(np.abs(mu) <= 1):
|
|
589
648
|
raise ValueError("mu values must be between -1 and 1.")
|
|
@@ -612,7 +671,7 @@ def interpolate(u):
|
|
|
612
671
|
else:
|
|
613
672
|
return np.squeeze(results)[()]
|
|
614
673
|
|
|
615
|
-
elif
|
|
674
|
+
elif argcount == 4: # Function is u0 instead of u
|
|
616
675
|
def u_interpol(mu, tau, is_antiderivative_wrt_tau=False, return_Fourier_error=False, return_tau_arr=False):
|
|
617
676
|
if not np.all(np.abs(mu) <= 1):
|
|
618
677
|
raise ValueError("mu values must be between -1 and 1.")
|
|
@@ -641,7 +700,7 @@ def interpolate(u):
|
|
|
641
700
|
else:
|
|
642
701
|
return np.squeeze(results)[()]
|
|
643
702
|
else:
|
|
644
|
-
raise ValueError("This subroutine can only interpolate u or u0")
|
|
703
|
+
raise ValueError("This subroutine can only interpolate u or u0.")
|
|
645
704
|
|
|
646
705
|
return u_interpol
|
|
647
706
|
|
|
@@ -684,17 +743,16 @@ def to_diag_ordered_form(A, Nsuperdiags, Nsubdiags):
|
|
|
684
743
|
|
|
685
744
|
|
|
686
745
|
|
|
687
|
-
def _mathscr_v(tau,
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
):
|
|
746
|
+
def _mathscr_v(tau, # Input optical depths
|
|
747
|
+
l, # Layer index of each input optical depth
|
|
748
|
+
Nscoeffs, # Number of isotropic source polynomial coefficients
|
|
749
|
+
s_poly_coeffs, # Polynomial coefficients of isotropic source
|
|
750
|
+
G, # Eigenvector matrices
|
|
751
|
+
K, # Eigenvalues
|
|
752
|
+
G_inv_mu_inv, # Inverse of eigenvector matrix @ (1 / `mu_arr`)
|
|
753
|
+
is_antiderivative_wrt_tau=False, # Switch to an antiderivative of the function?
|
|
754
|
+
autograd_compatible=False, # Should the output functions be compatible with autograd?
|
|
755
|
+
):
|
|
698
756
|
"""Particular solution for isotropic internal sources.
|
|
699
757
|
Refer to section 3.6.1 of the Comprehensive Documentation.
|
|
700
758
|
It has many seemingly redundant arguments to maximize
|
|
@@ -707,85 +765,100 @@ def _mathscr_v(tau, # Input optical depths
|
|
|
707
765
|
| ``tau`` | ``Ntau`` |
|
|
708
766
|
| ``l`` | ``Ntau`` |
|
|
709
767
|
| ``Nscoeffs`` | scalar |
|
|
710
|
-
| ``s_poly_coeffs`` | ``
|
|
711
|
-
| ``G`` | ``
|
|
712
|
-
| ``K`` | ``
|
|
713
|
-
| ``
|
|
714
|
-
| ``mu_arr`` | ``NQuad`` |
|
|
768
|
+
| ``s_poly_coeffs`` | ``NL x Nscoeffs`` |
|
|
769
|
+
| ``G`` | ``NL x NQuad x NQuad`` |
|
|
770
|
+
| ``K`` | ``NL x NQuad`` |
|
|
771
|
+
| ``G_inv_mu_inv`` | ``NL x NQuad`` |
|
|
715
772
|
| ``is_antiderivative_wrt_tau`` | boolean |
|
|
716
773
|
| ``autograd_compatible`` | boolean |
|
|
717
774
|
|
|
718
|
-
Notable internal variables of _mathscr_v
|
|
719
|
-
| Variable | Shape |
|
|
720
|
-
| ---------------- | ------------------------------------- |
|
|
721
|
-
| i_arr | ``Nscoeffs`` |
|
|
722
|
-
| i_arr_repeat | ``Nscoeffs*(Nscoeffs+1)/2`` | Using triangular number formula
|
|
723
|
-
| j_arr | ``Nscoeffs*(Nscoeffs+1)/2`` | Using triangular number formula
|
|
724
|
-
| s_poly_coeffs_nj | ``NLayers x Nscoeffs*(Nscoeffs+1)/2`` |
|
|
725
|
-
| OUTPUT | ``NQuad x Ntau`` |
|
|
726
775
|
"""
|
|
727
|
-
n = Nscoeffs - 1
|
|
728
|
-
|
|
729
776
|
if autograd_compatible:
|
|
730
777
|
import autograd.numpy as np
|
|
731
|
-
|
|
732
|
-
def mathscr_b(i):
|
|
733
|
-
"""
|
|
734
|
-
Notable internal variables of mathscr_b
|
|
735
|
-
| Variable | Shape |
|
|
736
|
-
| ---------------- | --------------------------------------- |
|
|
737
|
-
| j_arr | ``i + 1`` |
|
|
738
|
-
| s_poly_coeffs_nj | ``i + 1`` |
|
|
739
|
-
| OUTPUT | ``Nscoeffs x (i + 1) x NQuad`` |
|
|
740
|
-
"""
|
|
741
|
-
|
|
742
|
-
j_arr = np.arange(i + 1)
|
|
743
|
-
s_poly_coeffs_nj = s_poly_coeffs[:, n - j_arr]
|
|
744
|
-
return np.sum(
|
|
745
|
-
(sc.special.factorial(n - j_arr) / sc.special.factorial(n - i))[None, None, :]
|
|
746
|
-
* K[:, :, None] ** -(i - j_arr + 1)[None, None, :]
|
|
747
|
-
* s_poly_coeffs_nj[:, None, :],
|
|
748
|
-
axis=-1,
|
|
749
|
-
)
|
|
750
|
-
mathscr_v_coeffs = np.array(list(map(mathscr_b, range(Nscoeffs))))
|
|
751
778
|
else:
|
|
752
779
|
import numpy as np
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
np.
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
)
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
780
|
+
|
|
781
|
+
K_inv = 1 / K # (NL, NQuad)
|
|
782
|
+
|
|
783
|
+
# --------------------- Nscoeffs == 1 ---------------------
|
|
784
|
+
if Nscoeffs == 1:
|
|
785
|
+
s0 = s_poly_coeffs[:, 0:1]
|
|
786
|
+
c0w = s0 * K_inv * G_inv_mu_inv # (NL, 1) * (NL, NQuad) -> (NL, NQuad)
|
|
787
|
+
|
|
788
|
+
if is_antiderivative_wrt_tau:
|
|
789
|
+
p0 = tau
|
|
790
|
+
else:
|
|
791
|
+
p0 = np.ones_like(tau)
|
|
792
|
+
|
|
793
|
+
d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True)
|
|
794
|
+
|
|
795
|
+
return d0[:, l] * p0[None, :]
|
|
796
|
+
|
|
797
|
+
# --------------------- Nscoeffs == 2 ---------------------
|
|
798
|
+
elif Nscoeffs == 2:
|
|
799
|
+
s1 = s_poly_coeffs[:, 1:2] # (NL, )
|
|
800
|
+
s0 = s_poly_coeffs[:, 0:1] # (NL, )
|
|
801
|
+
|
|
802
|
+
K_inv2 = K_inv * K_inv
|
|
803
|
+
|
|
804
|
+
c0w = s1 * K_inv * G_inv_mu_inv
|
|
805
|
+
c1w = (s0 * K_inv + s1 * K_inv2) * G_inv_mu_inv
|
|
806
|
+
|
|
807
|
+
if is_antiderivative_wrt_tau:
|
|
808
|
+
p0 = tau * tau / 2
|
|
809
|
+
p1 = tau
|
|
810
|
+
else:
|
|
811
|
+
p0 = tau
|
|
812
|
+
p1 = np.ones_like(tau)
|
|
813
|
+
|
|
814
|
+
d0 = np.einsum("lij, lj -> il", G, c0w, optimize=True) # (NQuad, NL)
|
|
815
|
+
d1 = np.einsum("lij, lj -> il", G, c1w, optimize=True) # (NQuad, NL)
|
|
816
|
+
|
|
817
|
+
return d0[:, l] * p0[None, :] + d1[:, l] * p1[None, :]
|
|
818
|
+
|
|
819
|
+
# --------------------- Nscoeffs > 2 ----------------------
|
|
778
820
|
else:
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
821
|
+
if Nscoeffs > 10:
|
|
822
|
+
warnings.warn("`Nscoeffs` is large and may cause instability.")
|
|
823
|
+
n = Nscoeffs - 1
|
|
824
|
+
|
|
825
|
+
# K_invP[..., powers] = K_inv^(powers + 1); (NL, NQuad, Nscoeffs)
|
|
826
|
+
K_invP = np.cumprod(
|
|
827
|
+
np.broadcast_to(K_inv[:, :, None], K_inv.shape + (Nscoeffs,)),
|
|
828
|
+
axis=-1
|
|
829
|
+
)
|
|
830
|
+
|
|
831
|
+
ii = np.arange(Nscoeffs, dtype=int)[:, None]
|
|
832
|
+
pp = np.arange(Nscoeffs, dtype=int)[None, :]
|
|
833
|
+
jj = ii - pp
|
|
834
|
+
|
|
835
|
+
# Factorials
|
|
836
|
+
fac = np.empty(Nscoeffs)
|
|
837
|
+
fac[0] = 1
|
|
838
|
+
if Nscoeffs > 1:
|
|
839
|
+
fac[1:] = np.cumprod(np.arange(1, Nscoeffs))
|
|
840
|
+
fac_rev = fac[::-1]
|
|
841
|
+
inv_fac_rev = 1 / fac_rev
|
|
842
|
+
|
|
843
|
+
weighted_mathscr_a = s_poly_coeffs[:, ::-1] * fac_rev[None, :]
|
|
844
|
+
|
|
845
|
+
# Only take lower triangle values
|
|
846
|
+
lower_tri = np.where((jj >= 0)[None, :, :], np.take(weighted_mathscr_a, jj, axis=1), 0)
|
|
847
|
+
|
|
848
|
+
unweighted_mathscr_b_sigma = np.einsum("lkp, lip -> lki", K_invP, lower_tri, optimize=True)
|
|
849
|
+
mathscr_b_sigma = (unweighted_mathscr_b_sigma * inv_fac_rev[None, None, :]).transpose(2, 0, 1)
|
|
850
|
+
mathscr_b_right = mathscr_b_sigma * G_inv_mu_inv[None, :, :]
|
|
851
|
+
mathscr_b = np.einsum("lqk, plk- > lqp", G, mathscr_b_right, optimize=True)
|
|
852
|
+
|
|
853
|
+
powers = np.arange(Nscoeffs - 1, -1, -1)[None, :]
|
|
854
|
+
if is_antiderivative_wrt_tau:
|
|
855
|
+
p = powers + 1
|
|
856
|
+
tau_poly = (tau[:, None] ** p) / p
|
|
857
|
+
else:
|
|
858
|
+
tau_poly = tau[:, None] ** powers
|
|
859
|
+
|
|
860
|
+
return np.einsum("tqp, tp -> qt", mathscr_b[l, :, :], tau_poly, optimize=True)
|
|
861
|
+
|
|
789
862
|
|
|
790
863
|
|
|
791
864
|
def _compare(results, mu_to_compare, reorder_mu, flux_up, flux_down, u=None):
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
Metadata-Version: 2.1
|
|
2
2
|
Name: PythonicDISORT
|
|
3
|
-
Version: 1.
|
|
3
|
+
Version: 1.4
|
|
4
4
|
Summary: Discrete Ordinates Solver for the (1D) Radiative Transfer Equation in a single or multi-layer atmosphere.
|
|
5
5
|
Author-email: Dion HO Jia Xu <dh3065@columbia.edu>
|
|
6
6
|
Project-URL: Homepage, https://github.com/LDEO-CREW/Pythonic-DISORT
|
|
@@ -81,10 +81,10 @@ These notebooks double up as examples of how to use PythonicDISORT. The tests wh
|
|
|
81
81
|
* Python 3.8+
|
|
82
82
|
* `numpy >= 1.8.0`
|
|
83
83
|
* `scipy >= 1.8.0`
|
|
84
|
+
* (OPTIONAL) `autograd >= 1.5`
|
|
84
85
|
* (OPTIONAL) `pytest >= 6.2.5` (Required to use the command `pytest`, see *PyTest and examples of how to use PythonicDISORT*)
|
|
85
86
|
|
|
86
87
|
## (OPTIONAL) Additional requirements to run the Jupyter Notebook
|
|
87
|
-
* `autograd >= 1.5`
|
|
88
88
|
* `jupyter > 1.0.0`
|
|
89
89
|
* `notebook > 6.5.2`
|
|
90
90
|
* `matplotlib >= 3.6.0`
|
|
@@ -127,3 +127,4 @@ Science and Technology Center (STC) (Award #2019625) under which this package wa
|
|
|
127
127
|
12) T. Nakajima and M. Tanaka. 1988. *Algorithms for radiative intensity calculations in moderately thick atmospheres using a truncation approximation.* https://www.sciencedirect.com/science/article/pii/0022407388900313.
|
|
128
128
|
|
|
129
129
|
13) Connour, Kyle and Wolff, Michael. 2020. *pyRT_DISORT: A pre-processing front-end to help make DISORT simulations easier in Python.* https://github.com/kconnour/pyRT_DISORT.
|
|
130
|
+
|
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
|
|
2
|
+
PythonicDISORT/_assemble_intensity_and_fluxes.py,sha256=mNhV6KjXWiZwPFCH8nuI6hPssl4PXznOn2nkdqOmS9g,29823
|
|
3
|
+
PythonicDISORT/_solve_for_coeffs.py,sha256=8ok2xS6emv4Qtnj_5CTQkYRH8jYzKE06ypmZErQWTPg,19384
|
|
4
|
+
PythonicDISORT/_solve_for_gen_and_part_sols.py,sha256=OjMn1JrhyC7VqZUUMjJVloNvSRWd8l-dQ1MxGt2QZbc,13216
|
|
5
|
+
PythonicDISORT/pydisort.py,sha256=hHN4u6eG7w7QftlgS7fy-EKwU1a_aJQgk502S5kRdbo,39682
|
|
6
|
+
PythonicDISORT/subroutines.py,sha256=Yv81a57KBBijz5VFWKxQ99mnogJo2TllazL5IVZOTJU,34940
|
|
7
|
+
pythonicdisort-1.4.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
|
|
8
|
+
pythonicdisort-1.4.dist-info/METADATA,sha256=TkrQNF7KQEkfFAtkb5B2LYSqcmG6Sy29eMgVOyel-zY,8309
|
|
9
|
+
pythonicdisort-1.4.dist-info/WHEEL,sha256=WnJ8fYhv8N4SYVK2lLYNI6N0kVATA7b0piVUNvqIIJE,91
|
|
10
|
+
pythonicdisort-1.4.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
|
|
11
|
+
pythonicdisort-1.4.dist-info/RECORD,,
|
|
@@ -1,11 +0,0 @@
|
|
|
1
|
-
PythonicDISORT/__init__.py,sha256=V1obNzaFgqInxqYJ5h_r6JHbZRxx4VM5VgzCIS6EEzI,84
|
|
2
|
-
PythonicDISORT/_assemble_intensity_and_fluxes.py,sha256=okORQDxUWZgmMZmIRPNzIOqk8UQAcoc7o8Wr3wxrgDc,29261
|
|
3
|
-
PythonicDISORT/_solve_for_coeffs.py,sha256=Bb-C5OJt355x8_v8WFB2sJutBtSTAFNIX4OxLQJk9-0,16539
|
|
4
|
-
PythonicDISORT/_solve_for_gen_and_part_sols.py,sha256=InZPpyRkfmt7gq5r64FPHjXJVMV41ixZygJd4pWpLI4,12461
|
|
5
|
-
PythonicDISORT/pydisort.py,sha256=ULGw_fqcnC7JQ3voJr9oKlaB3yrDI_sKe5jOU0Xj2Rc,40043
|
|
6
|
-
PythonicDISORT/subroutines.py,sha256=d0mjOgxqSFoNZnLmOkuSWqO3HjojR9S-2orGZSdGJkU,33208
|
|
7
|
-
pythonicdisort-1.2.dist-info/LICENSE.md,sha256=q1i1QVh0OLzK0fj6kaNRNWsM_KZca66JwWgWwbuCPlA,1092
|
|
8
|
-
pythonicdisort-1.2.dist-info/METADATA,sha256=PLXXaPDMmva47U6AM6cNFSrb0J-FT9xCkiww8tsvE3c,8297
|
|
9
|
-
pythonicdisort-1.2.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
|
|
10
|
-
pythonicdisort-1.2.dist-info/top_level.txt,sha256=aX6kCeI1E7naZz3xfw4_mIbWh5KBh9dmF3FIvgP5m3Y,15
|
|
11
|
-
pythonicdisort-1.2.dist-info/RECORD,,
|
|
File without changes
|
|
File without changes
|