TidalPy 0.4.1__tar.gz → 0.5.1__tar.gz

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Multilayer - Tobie+2005 - Roberts & Nimmo 2008.py

@@ -9,18 +9,18 @@ TMS05 : Tobie+ (2005; Icarus; DOI: 10.1016/j.icarus.2005.04.006)
 import numpy as np
 import time
 from TidalPy.constants import G
-from TidalPy.toolbox.conversions import orbital_motion2semi_a
-from TidalPy.rheology.complex_compliance.compliance_models import maxwell
+from TidalPy.utilities.conversions import orbital_motion2semi_a
+from TidalPy.rheology import Maxwell
 
 # Load TidalPy's multilayer functions
-from tides.multilayer.numerical_int import radial_solver
-from tides.multilayer.matrix import fundamental_matrix_orderl2, propagate
+from TidalPy.RadialSolver import radial_solver
+from TidalPy.radial_solver.matrix import fundamental_matrix_orderl2, matrix_propagate
 from TidalPy.utilities.graphics.multilayer import yplot
 
 # Switches
 show_shooting_method_technique = True
 show_propagation_matrix_technique = True
-use_static_liquid_core = False
+use_static_liquid_core = True
 nondimensionalize_during_integration = True
 use_kamata_starting_values = True
 # Set the following two switches to true for comparison to Roberts and Nimmo.
@@ -29,14 +29,13 @@ use_fake_incompressible_limit = False
 use_real_incompressible_limit = False
 
 # Integration properties
-integrator = 'scipy'
 integration_method = 'RK45'
 r_tol = 1.e-8
 a_tol = 1.e-10
 
 # Plot switches
 plot_tobie = True
-plot_roberts = False
+plot_roberts = True
 
 # Planet Structure
 R_planet = 1600.e3
@@ -52,8 +51,8 @@ viscosity_core = 1.e13 / 1.e9
 shear_core = 0.
 
 if use_fake_incompressible_limit:
-    bulk_mantle = 1.e15
-    bulk_core = 1.e15
+    bulk_mantle = 1.e14
+    bulk_core = 1.e14
 else:
     bulk_mantle = 1.2210e11
     bulk_core = 2.88e11
@@ -63,16 +62,17 @@ planet_mass = 1.08e20
 host_mass = 5.683e26
 eccentricity = 0.0045
 orbital_freq_HZ = 2. * np.pi * 5.308e-5  # This is reported in Hz in RN08. We will need to convert them to rad s-1
-orbital_freq_TB_match = 2. * np.pi / (86400. * 1.0)
+#orbital_freq_TB_match = 2. * np.pi / (86400. * 1.0)
+#orbital_freq_TB_match = 2. * np.pi / (86400. * 0.1) 
 freq_europa = 2.04793e-05
 freq_titan = 4.55938e-06
 
-orbital_freq = orbital_freq_TB_match
+orbital_freq = orbital_freq_HZ
 semi_major_axis = orbital_motion2semi_a(orbital_freq, host_mass, planet_mass)
 
 # Setup homogeneous domain
 N = 100
-radius_array = np.linspace(1., R_planet, N)
+radius_array = np.linspace(0.1, R_planet, N)
 volume_array = np.zeros_like(radius_array)
 volume_array[0] = (4. / 3.) * np.pi * radius_array[0]**3
 volume_array[1:] = (4. / 3.) * np.pi * (radius_array[1:]**3 - radius_array[:-1]**3)
@@ -101,7 +101,8 @@ for model_name, (core_density, mantle_density) in models.items():
 
     # Set the density for each layer
     density_array = mantle_density * np.ones_like(radius_array)
-    mantle_radii = np.ones_like(radius_array, dtype=np.bool)
+    mantle_radii = np.ones_like(radius_array, dtype=np.bool_)
+    core_radii = None
     if R_core is not None:
         core_radii = radius_array <= R_core
         mantle_radii = radius_array > R_core
@@ -128,8 +129,9 @@ for model_name, (core_density, mantle_density) in models.items():
         bulk_array[core_radii] = bulk_core
 
     # Use the Maxwell rheology
-    complex_compliance_array = maxwell(orbital_freq, shear_array**(-1), viscosity_array)
-    complex_shear_array = complex_compliance_array**(-1)
+    rheology_inst = Maxwell()
+    complex_shear_array = np.zeros(shear_array.size, dtype=np.complex128)
+    rheology_inst.vectorize_modulus_viscosity(orbital_freq, shear_array, viscosity_array, complex_shear_array)
 
     if show_propagation_matrix_technique:
         print('Solving with propagation matrix...')
@@ -154,7 +156,7 @@ for model_name, (core_density, mantle_density) in models.items():
         central_boundary_condition[5, 2] = 1.
 
         tidal_y_prop = \
-            propagate(Y, Y_inv, derivative_mtx, central_boundary_condition, R_planet, order_l=2)
+            matrix_propagate(Y, Y_inv, derivative_mtx, central_boundary_condition, R_planet, order_l=2)
 
         model_radii.append(radius_used)
         model_names.append(model_name + '-PropMtx')
@@ -166,34 +168,62 @@ for model_name, (core_density, mantle_density) in models.items():
         print('Solving with shooting method...')
         if R_core is None:
             # Use homogeneous method
-            tidal_y_shoot = \
+            radial_solution = \
                 radial_solver(
-                    radius_array, shear_array, bulk_array, density_array, gravity_array,
-                    orbital_freq, planet_bulk_density, is_solid_by_layer=[True],
-                    is_static_by_layer=[use_static_mantle],
-                    indices_by_layer=[mantle_radii], order_l=2, surface_boundary_condition=None,
-                    solve_load_numbers=False, use_kamata=use_kamata_starting_values,
-                    integrator=integrator,
+                    radius_array,
+                    density_array,
+                    gravity_array,
+                    bulk_array,
+                    complex_shear_array,
+                    orbital_freq,
+                    planet_bulk_density,
+                    layer_types=('solid',),
+                    is_static_by_layer=(use_static_mantle,),
+                    is_incompressible_by_layer=(use_real_incompressible_limit,),
+                    upper_radius_by_layer=(R_planet,),
+                    degree_l=2,
+                    solve_for=('tidal',),
+                    use_kamata=use_kamata_starting_values,
                     integration_method=integration_method,
-                    integration_rtol=r_tol, integration_atol=a_tol,
-                    verbose=False, nondimensionalize=nondimensionalize_during_integration,
-                    incompressible=use_real_incompressible_limit
+                    integration_rtol=r_tol,
+                    integration_atol=a_tol,
+                    scale_rtols_by_layer_type=False,
+                    max_num_steps=5_000_000,
+                    max_ram_MB=2_000,
+                    nondimensionalize=nondimensionalize_during_integration
                     )
+            if not radial_solution.success:
+                raise AssertionError(radial_solution.message)
+            tidal_y_shoot = np.copy(radial_solution.result)
         else:
             # Use liquid-solid method
-            tidal_y_shoot = \
+            radial_solution = \
                 radial_solver(
-                    radius_array, shear_array, bulk_array, density_array, gravity_array,
-                    orbital_freq, planet_bulk_density, is_solid_by_layer=[False, True],
-                    is_static_by_layer=[use_static_liquid_core, use_static_mantle],
-                    indices_by_layer=[core_radii, mantle_radii], order_l=2, surface_boundary_condition=None,
-                    solve_load_numbers=False, use_kamata=use_kamata_starting_values,
-                    integrator=integrator,
+                    radius_array,
+                    density_array,
+                    gravity_array,
+                    bulk_array,
+                    complex_shear_array,
+                    orbital_freq,
+                    planet_bulk_density,
+                    layer_types=('liquid', 'solid'),
+                    is_static_by_layer=(use_static_liquid_core, use_static_mantle),
+                    is_incompressible_by_layer=(use_real_incompressible_limit, use_real_incompressible_limit),
+                    upper_radius_by_layer=(R_core, R_planet),
+                    degree_l=2,
+                    solve_for=('tidal',),
+                    use_kamata=use_kamata_starting_values,
                     integration_method=integration_method,
-                    integration_rtol=r_tol, integration_atol=a_tol,
-                    verbose=False, nondimensionalize=nondimensionalize_during_integration,
-                    incompressible=use_real_incompressible_limit
+                    integration_rtol=r_tol,
+                    integration_atol=a_tol,
+                    scale_rtols_by_layer_type=False,
+                    max_num_steps=5_000_000,
+                    max_ram_MB=2_000,
+                    nondimensionalize=nondimensionalize_during_integration
                     )
+            if not radial_solution.success:
+                raise AssertionError(radial_solution.message)
+            tidal_y_shoot = np.copy(radial_solution.result)
 
         model_radii.append(radius_array)
         model_names.append(model_name + '-Shooting')

TidalPy-0.5.1/Benchmarks & Performance/Performance/performance suite/multilayer_radial_solver.py

@@ -0,0 +1,180 @@
+import numpy as np
+
+from performance_base import PerformanceTrackBase
+
+import TidalPy
+TidalPy.config['stream_level'] = 'WARNING'
+TidalPy.reinit()
+from TidalPy.radial_solver import radial_solver
+from TidalPy.rheology.complex_compliance.compliance_models import maxwell
+from TidalPy.utilities.spherical_helper.mass import calculate_mass_gravity_arrays
+
+
+class TidalYPerformance(PerformanceTrackBase):
+
+    def __init__(self):
+        # Setup constant geometry
+        self.R = 6378.1e3
+        self.N = 14
+        self.radius = np.linspace(0.01e3, self.R, self.N)
+        self.layer_radius = []
+        self.planet_volume = (4. / 3.) * np.pi * self.R**3
+        self.planet_bulk_density = None
+        self.frequency = np.pi * 2 / (86400. * 10.)
+
+        # Define constants
+        self.liquid_density = 1000.
+        self.solid_density = 3500.
+        self.iron_density = 8000.
+        self.solid_viscosity = 1.0e20
+        self.liquid_viscosity = 1_000.
+        self.solid_shear = 50.e9
+        self.liquid_shear = 0.
+        self.solid_bulk = 200.0e9
+        self.liquid_bulk = 100.0e9
+
+        # Build empty arrays
+        self.volumes   = np.empty_like(self.radius)
+        self.masses    = np.empty_like(self.radius)
+        self.shear     = np.empty_like(self.radius)
+        self.viscosity = np.empty_like(self.radius)
+        self.bulk      = np.empty_like(self.radius)
+        self.gravity   = np.empty_like(self.radius)
+        self.density   = np.empty_like(self.radius)
+        self.complex_shear = np.empty_like(self.radius)
+
+        # Define layer flags as empty lists
+        self.layers_are_solid  = []
+        self.layers_are_static = []
+        self.layer_indices     = []
+
+        # Inputs to radial_solver
+        self.radial_solver_args = tuple()
+        self.radial_solver_kwargs = {
+            'order_l': 2,
+            'surface_boundary_condition': None,
+            'solve_load_numbers': False,
+            'use_kamata': False,
+            'integrator': 'numba',
+            'integration_method': 'RK45',
+            'integration_rtol': 1.0e-8,
+            'integration_atol': 1.e-9,
+            'verbose': False,
+            'nondimensionalize': True,
+            'incompressible': False
+            }
+
+        super().__init__()
+
+    def build_world(self):
+
+        self.planet_bulk_density = 0.
+        # Reset layer indices
+        self.layer_indices = []
+        last_layer_r = 0.
+        num_layers = len(self.layer_radius)
+        # Find Index
+        for layer_i, layer_r in enumerate(self.layer_radius):
+            if layer_i == 0:
+                index = self.radius <= layer_r
+                layer_volume = (4. / 3.) * np.pi * layer_r**3
+            elif layer_i == num_layers - 1:
+                index = self.radius > last_layer_r
+                layer_volume = (4. / 3.) * np.pi * (layer_r**3 - last_layer_r**3)
+            else:
+                index = np.logical_and(self.radius > last_layer_r, self.radius <= layer_r)
+                layer_volume = (4. / 3.) * np.pi * (layer_r**3 - last_layer_r**3)
+
+            # Build density array
+            is_solid = self.layers_are_solid[layer_i]
+            if is_solid:
+                self.viscosity[index] = self.solid_viscosity
+                self.shear[index]     = self.solid_shear
+                self.bulk[index]      = self.solid_bulk
+                if layer_i == 0:
+                    self.density[index] = self.iron_density
+                else:
+                    self.density[index] = self.solid_density
+            else:
+                self.viscosity[index] = self.liquid_viscosity
+                self.shear[index]     = self.liquid_shear
+                self.bulk[index]      = self.liquid_bulk
+                self.density[index]   = self.liquid_density
+
+            # Add to global bulk density
+            self.planet_bulk_density += self.density[index][0] * (layer_volume / self.planet_volume)
+
+            self.layer_indices.append(index)
+            last_layer_r = layer_r
+
+        # Determine gravity from density
+        self.volumes, self.masses, self.gravity = \
+            calculate_mass_gravity_arrays(self.radius, self.density)
+
+        # Determine complex shear
+        self.complex_shear = maxwell(self.frequency, self.shear**(-1), self.viscosity)**(-1)
+
+        # Call input builder
+        self.build_args()
+
+    def build_args(self):
+        arg_list = [
+            self.radius, self.complex_shear, self.bulk,
+            self.density, self.gravity, self.frequency, self.planet_bulk_density,
+            self.layers_are_solid, self.layers_are_static, self.layer_indices
+            ]
+        self.radial_solver_args = tuple(arg_list)
+
+    def run_perform_tidal_y_homogen_solid_static(self):
+
+        self.layers_are_solid = [True]
+        self.layers_are_static = [True]
+        self.layer_radius = [self.R]
+        self.build_world()
+
+        self.record_performance('Tidal-y Calc - Homogen-Solid - Static - Numba-RK45', radial_solver,
+                                inputs=self.radial_solver_args, kwargs=self.radial_solver_kwargs, repeats=3, number=10)
+
+    def run_perform_tidal_y_homogen_solid_dynamic(self):
+
+        self.layers_are_solid = [True]
+        self.layers_are_static = [False]
+        self.layer_radius = [self.R]
+        self.build_world()
+
+        self.record_performance('Tidal-y Calc - Homogen-Solid - Dynamic - Numba-RK45', radial_solver,
+                                inputs=self.radial_solver_args, kwargs=self.radial_solver_kwargs, repeats=3, number=10)
+
+    def run_perform_tidal_y_liquid_solid_allstatic(self):
+
+        self.layers_are_solid = [False, True]
+        self.layers_are_static = [True, True]
+        self.layer_radius = [3483.e3, self.R]
+        self.build_world()
+
+        self.record_performance('Tidal-y Calc - Liquid-Solid - Static-Static - Numba-RK45', radial_solver,
+                                inputs=self.radial_solver_args, kwargs=self.radial_solver_kwargs, repeats=3, number=10)
+
+    def run_perform_tidal_y_liquid_solid_dynamicsolid(self):
+
+        self.layers_are_solid = [False, True]
+        self.layers_are_static = [True, False]
+        self.layer_radius = [3483.e3, self.R]
+        self.build_world()
+
+        self.record_performance('Tidal-y Calc - Liquid-Solid - Static-Dynamic - Numba-RK45', radial_solver,
+                                inputs=self.radial_solver_args, kwargs=self.radial_solver_kwargs, repeats=3, number=10)
+
+    def run_perform_tidal_y_solid_liquid_solid_dynamicsolid(self):
+
+        self.layers_are_solid = [True, False, True]
+        self.layers_are_static = [False, True, False]
+        self.layer_radius = [self.R * (1. / 3.), self.R * (2./ 3.), self.R]
+        self.build_world()
+
+        self.record_performance('Tidal-y Calc - Solid-Liquid-Solid - Dynamic-Static-Dynamic - Numba-RK45', radial_solver,
+                                inputs=self.radial_solver_args, kwargs=self.radial_solver_kwargs, repeats=3, number=10)
+
+
+if __name__ == '__main__':
+    performance_tracker = TidalYPerformance()

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Performance/performance suite/multimode_solver.py

@@ -1,5 +1,3 @@
-from functools import partial
-
 import numpy as np
 
 from performance_base import PerformanceTrackBase
@@ -12,7 +10,7 @@ from TidalPy.tides.modes.multilayer_modes_numba import collapse_multilayer_modes
 from TidalPy.rheology.complex_compliance.compliance_models import maxwell
 from TidalPy.utilities.spherical_helper.volume import calculate_voxel_volumes
 from TidalPy.utilities.spherical_helper.mass import calculate_mass_gravity_arrays
-from TidalPy.toolbox.conversions import orbital_motion2semi_a
+from TidalPy.utilities.conversions import orbital_motion2semi_a
 
 radius = np.linspace(0.01e3, 6378.1e3, 15)
 layer_0 = radius <= 3483.e3

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Performance/performance suite/performance_base.py

@@ -10,7 +10,7 @@ import numpy as np
 import pandas as pd
 
 from TidalPy import version as tpy_version
-from TidalPy.toolbox.timing import convert_to_hms
+from TidalPy.utilities.conversions.timing import convert_to_hms
 
 PERFORMANCE_DIR = pathlib.Path(__file__).absolute()
 

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Performance/performance suite/performance_build_world.py

@@ -3,7 +3,7 @@ import TidalPy
 TidalPy.config['stream_level'] = 'WARNING'
 TidalPy.reinit()
 
-from TidalPy import build_world, build_from_world, Orbit
+from TidalPy.structures import build_world, build_from_world, Orbit
 
 
 from performance_base import PerformanceTrackBase
@@ -18,10 +18,6 @@ class BuildWorldPerformance(PerformanceTrackBase):
         self.record_performance('Build World - Layered', build_world,
                                 inputs=('io_simple',), repeats=3, number=10)
 
-    def run_perform_build_burnman(self):
-        self.record_performance('Build World - Burnman', build_world,
-                                inputs=('earth',), repeats=3, number=10)
-
 
 if __name__ == '__main__':
     performance_tracker = BuildWorldPerformance()

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Performance/performance suite/performance_tides.py

@@ -3,7 +3,7 @@ import TidalPy
 TidalPy.config['stream_level'] = 'WARNING'
 TidalPy.reinit()
 
-from TidalPy import build_world, build_from_world, Orbit
+from TidalPy.structures import build_world, build_from_world, Orbit
 
 from performance_base import PerformanceTrackBase
 

{TidalPy-0.4.1 → TidalPy-0.5.1}/Benchmarks & Performance/Performance/performance suite/run_suite.py

@@ -3,7 +3,7 @@ from performance_complex_compliance_func import ComplexCompliancePerformance
 from performance_eccentricity_func import EccentricityFuncPerformance
 from performance_tides import TideCalcPerformance
 from performance_quick_calcs import QuickCalcPerformance
-from multilayer_tidal_y import TidalYPerformance
+from multilayer_radial_solver import TidalYPerformance
 from multimode_solver import MultilayerModeNumbaPerformance, MultilayerModePerformance
 
 if __name__ == '__main__':

{TidalPy-0.4.1 → TidalPy-0.5.1}/Documentation/Issues/Issue35/test.py

@@ -5,7 +5,7 @@ print(version)
 import numpy as np
 import pandas as pd
 
-from TidalPy.toolbox.conversions import days2rads
+from TidalPy.utilities.conversions import days2rads
 from TidalPy.rheology.complex_compliance.compliance_models import andrade
 from tides.multilayer.numerical_int import radial_solver
 from TidalPy.utilities.graphics.multilayer import yplot

TidalPy-0.5.1/MANIFEST.in

@@ -0,0 +1,12 @@
+# MANIFEST.in
+
+# Include data files used for plotting and benchmarking
+include TidalPy/utilities/graphics/multilayer/*.csv
+
+# Include World Configuration Files
+include TidalPy/WorldPack/*.zip
+
+# Include Cython pyx and pxd files
+global-include *.pxd
+global-include *.pyx
+include cython_extensions.json