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.
@@ -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 = np.insert(2 / (1 - 4 * np.arange(1, Nphi_pos + 1) ** 2), 0, 2)
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 = np.insert(tau_arr, 0, 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, mu0, BDRF_Fourier_modes):
465
- """If the same BDRF, number of streams and ``mu0`` will be used repeatedly,
466
- consider using this function to cache ``BDRF_Fourier_modes`` and instead input
467
- ``cached_BDRF_Fourier_modes`` into ``pydisort``.
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
- BDRF_Fourier_modes_evaluated = [
491
- (
492
- None
493
- if np.isscalar(BDRF_Fourier_modes[m])
494
- else BDRF_Fourier_modes[m](mu_arr_pos, np.append(mu_arr_pos, mu0))
495
- )
496
- for m in range(NBDRF)
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
- for m in range(NBDRF)
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
- if u.__code__.co_argcount == 5: # Function is u instead of u0
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 u.__code__.co_argcount == 4: # Function is u0 instead of u
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, # Input optical depths
688
- l, # Layer index of each input optical depth
689
- Nscoeffs, # Number of isotropic source polynomial coefficients
690
- s_poly_coeffs, # Polynomial coefficients of isotropic source
691
- G, # Eigenvector matrices
692
- K, # Eigenvalues
693
- G_inv, # Inverse of eigenvector matrix
694
- mu_arr, # Quadrature nodes for both hemispheres
695
- is_antiderivative_wrt_tau=False, # Switch to an antiderivative of the function?
696
- autograd_compatible=False, # Should the output functions be compatible with autograd?
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`` | ``NLayers x Nscoeffs`` |
711
- | ``G`` | ``NLayers<= x NQuad x NQuad`` |
712
- | ``K`` | ``NLayers<= x NQuad`` |
713
- | ``G_inv`` | ``NLayers<= x NQuad x NQuad`` or ``None`` |
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
- shape = np.shape(K)
755
- i_arr = np.arange(Nscoeffs)
756
- i_arr_repeat = np.repeat(i_arr, i_arr + 1)
757
- j_arr = np.concatenate([i_arr[:i] for i in range(1, Nscoeffs + 1)])
758
- s_poly_coeffs_nj = s_poly_coeffs[:, n - j_arr]
759
-
760
- mathscr_v_coeffs = np.zeros((Nscoeffs, shape[0], shape[1]))
761
- np.add.at(
762
- mathscr_v_coeffs,
763
- i_arr_repeat,
764
- np.moveaxis(
765
- (sc.special.factorial(n - j_arr) / sc.special.factorial(n - i_arr_repeat))[
766
- None, None, :
767
- ]
768
- * K[:, :, None] ** -(i_arr_repeat - j_arr + 1)[None, None, :]
769
- * s_poly_coeffs_nj[:, None, :],
770
- -1,
771
- 0,
772
- ),
773
- )
774
-
775
- powers = np.arange(Nscoeffs - 1, -1, -1)[None, :]
776
- if is_antiderivative_wrt_tau:
777
- tau_poly = tau[:, None] ** (powers + 1) / (powers + 1)
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
- tau_poly = tau[:, None] ** powers
780
-
781
- return np.einsum(
782
- "tik, tc, ctk -> it",
783
- G[l, :, :],
784
- tau_poly,
785
- (mathscr_v_coeffs * (G_inv @ (1 / mu_arr))[None, :, :])[:, l, :],
786
- optimize=True,
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.2
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,5 +1,5 @@
1
1
  Wheel-Version: 1.0
2
- Generator: setuptools (75.3.2)
2
+ Generator: setuptools (75.3.3)
3
3
  Root-Is-Purelib: true
4
4
  Tag: py3-none-any
5
5
 
@@ -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,,