TidalPy 0.7.5__tar.gz → 0.7.6__tar.gz

{tidalpy-0.7.5 → tidalpy-0.7.6}/MANIFEST.in

@@ -19,7 +19,6 @@ global-include *.pyx
 include cython_extensions.json
 
 # Include required hpp and cpp files
-include TidalPy/utilities/arrays/interp_.cpp
 include TidalPy/utilities/arrays/interp_.hpp
 include TidalPy/RadialSolver/love_.cpp
 include TidalPy/RadialSolver/love_.hpp

{tidalpy-0.7.5/TidalPy.egg-info → tidalpy-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TidalPy
-Version: 0.7.5
+Version: 0.7.6
 Summary: Tidal Dynamics and Thermal-Orbital Evolution Software Suite Implemented in Cython and Python
 Author-email: "Joe P. Renaud" <TidalPy@gmail.com>
 License-Expression: Apache-2.0
@@ -61,8 +61,6 @@ Requires-Dist: nbsphinx; extra == "docs"
 Requires-Dist: ipykernel; extra == "docs"
 Requires-Dist: nbconvert; extra == "docs"
 Requires-Dist: jupyter; extra == "docs"
-Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
-Requires-Dist: breathe; extra == "docs"
 Provides-Extra: graphics
 Requires-Dist: jupyter; extra == "graphics"
 Requires-Dist: cmcrameri<2.0,>=1.4; extra == "graphics"
@@ -84,7 +82,7 @@ Dynamic: license-file
 <div align="center" style="text-align: center;">
     <a href="https://app.readthedocs.org/projects/tidalpy/builds/?version__slug=latest"><img src="https://app.readthedocs.org/projects/tidalpy/badge/?version=latest&style=flat" alt="TidalPy Documentation" /></a>
     <a href="https://doi.org/10.5281/zenodo.7017475"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.7017475.svg" alt="DOI: 10.5281/zenodo.7017475"></a>
-    <a href="https://github.com/jrenaud90/TidalPy/releases"><img src="https://img.shields.io/badge/TidalPy-0.7.0a0.dev7-orange" alt="TidalPy Version 0.7.0a0.dev7" /></a><br />
+    <a href="https://github.com/jrenaud90/TidalPy/releases"><img src="https://img.shields.io/badge/TidalPy-0.7.6-orange" alt="TidalPy Version 0.7.6" /></a><br />
     <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.9|3.10|3.11|3.12|3.13-blue" alt="Python Version 3.9-3.13" /></a>
     <a href="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_win.yml"><img src="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_win.yml/badge.svg?branch=main" alt="Windows Tests" /></a>
     <a href="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_mac.yml"><img src="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_mac.yml/badge.svg?branch=main" alt="MacOS Tests" /></a>

{tidalpy-0.7.5 → tidalpy-0.7.6}/README.md

@@ -5,7 +5,7 @@
 <div align="center" style="text-align: center;">
     <a href="https://app.readthedocs.org/projects/tidalpy/builds/?version__slug=latest"><img src="https://app.readthedocs.org/projects/tidalpy/badge/?version=latest&style=flat" alt="TidalPy Documentation" /></a>
     <a href="https://doi.org/10.5281/zenodo.7017475"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.7017475.svg" alt="DOI: 10.5281/zenodo.7017475"></a>
-    <a href="https://github.com/jrenaud90/TidalPy/releases"><img src="https://img.shields.io/badge/TidalPy-0.7.0a0.dev7-orange" alt="TidalPy Version 0.7.0a0.dev7" /></a><br />
+    <a href="https://github.com/jrenaud90/TidalPy/releases"><img src="https://img.shields.io/badge/TidalPy-0.7.6-orange" alt="TidalPy Version 0.7.6" /></a><br />
     <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.9|3.10|3.11|3.12|3.13-blue" alt="Python Version 3.9-3.13" /></a>
     <a href="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_win.yml"><img src="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_win.yml/badge.svg?branch=main" alt="Windows Tests" /></a>
     <a href="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_mac.yml"><img src="https://github.com/jrenaud90/TidalPy/actions/workflows/push_tests_mac.yml/badge.svg?branch=main" alt="MacOS Tests" /></a>

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/Material/eos/solver.pyx

@@ -175,7 +175,7 @@ cdef void solve_eos(
                 max_step,          # Maximum step size [double]
                 first_step,        # Initial step size (0 = find good value) [double]
                 True,              # Force retain solver
-                NULL               # Analytic Jacobian (only used by implicit methods) [JacobianFuncType]
+                NULL               # Analytic Jacobian (null = numerical; used by implicit methods) [JacobianFuncType]
                 )
             #########################################################
             last_solution_size = integration_result_ptr.size

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/boundaries/boundaries.pxd

@@ -15,3 +15,11 @@ cdef void cf_apply_surface_bc(
     cpp_bool layer_is_static,
     cpp_bool layer_is_incomp
     ) noexcept nogil
+
+cdef double cf_estimate_surface_amplification(
+    double complex* constant_vector_ptr,
+    double complex* uppermost_y_per_solution_ptr,
+    size_t num_sols,
+    size_t num_ys,
+    size_t max_num_y
+    ) noexcept nogil

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/boundaries/boundaries.pyx

@@ -1,9 +1,11 @@
 # distutils: language = c++
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
+from libc.math cimport fmax
+
 from scipy.linalg.cython_lapack cimport zgesv
 
-from TidalPy.constants cimport d_PI, d_NAN
+from TidalPy.constants cimport d_PI, d_NAN, d_EPS
 
 cdef void cf_apply_surface_bc(
         double complex* constant_vector_ptr,
@@ -184,3 +186,69 @@ cdef void cf_apply_surface_bc(
         num_sols_int_ptr,     # (Input)
         bc_solution_info_ptr  # (Output)
         )
+
+
+cdef double cf_estimate_surface_amplification(
+        double complex* constant_vector_ptr,
+        double complex* uppermost_y_per_solution_ptr,
+        size_t num_sols,
+        size_t num_ys,
+        size_t max_num_y
+        ) noexcept nogil:
+    """
+    cf_estimate_surface_amplification
+
+    Estimate how strongly the surface boundary condition solve amplifies error.
+
+    The collapsed surface solution is y_k = sum_s c_s * y_ks over the independent solutions s. When the
+    solution constants c_s are large and cancel (deep starting radii, high harmonic degrees), roundoff and
+    integration error in the y_ks are amplified into the collapsed values by roughly the returned factor:
+    the largest cancellation scale sum_s |c_s| |y_ks| across the y rows divided by the largest collapsed
+    magnitude |y_k|. The relative accuracy of the surface solution, and of the Love numbers derived from it,
+    is then floor limited to about (returned factor) * machine epsilon regardless of integration tolerance.
+
+    Parameters
+    ----------
+    constant_vector_ptr : double complex*
+        Solution constants found by `cf_apply_surface_bc`.
+    uppermost_y_per_solution_ptr : double complex*
+        Y values at the surface for each independent solution.
+    num_sols : size_t
+        Number of independent solutions (1, 2, or 3).
+    num_ys : size_t
+        Number of y values per solution.
+    max_num_y : size_t
+        Stride between solutions in `uppermost_y_per_solution_ptr`.
+
+    Returns
+    -------
+    double
+        Amplification factor (1 when a single solution leaves no room for cancellation).
+    """
+    cdef size_t y_i
+    cdef size_t solution_i
+    cdef double cancellation_scale
+    cdef double max_cancellation_scale = 0.0
+    cdef double max_collapsed_mag      = 0.0
+    cdef double complex collapsed_value
+    cdef double complex constant
+    cdef double complex y_value
+
+    for y_i in range(num_ys):
+        cancellation_scale = 0.0
+        collapsed_value    = 0.0
+        for solution_i in range(num_sols):
+            constant = constant_vector_ptr[solution_i]
+            y_value  = uppermost_y_per_solution_ptr[solution_i * max_num_y + y_i]
+            cancellation_scale = cancellation_scale + abs(constant) * abs(y_value)
+            collapsed_value    = collapsed_value + constant * y_value
+        max_cancellation_scale = fmax(max_cancellation_scale, cancellation_scale)
+        max_collapsed_mag      = fmax(max_collapsed_mag, abs(collapsed_value))
+
+    if max_cancellation_scale <= 0.0:
+        # Degenerate all-zero surface; no cancellation information.
+        return 1.0
+    if max_collapsed_mag <= d_EPS * max_cancellation_scale:
+        # Every y row cancels completely; cap at the largest meaningful amplification.
+        return 1.0 / d_EPS
+    return max_cancellation_scale / max_collapsed_mag

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/rs_solution.pxd

@@ -47,6 +47,7 @@ cdef extern from "rs_solution_.cpp" nogil:
         vector[double] full_solution_vec
         vector[double] complex_love_vec
         vector[size_t] shooting_method_steps_taken_vec
+        double surface_amplification
 
         EOSSolutionCC* get_eos_solution_ptr()
         void change_radius_array(

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/rs_solution.pyx

@@ -567,6 +567,20 @@ cdef class RadialSolverSolution:
         """ Number of integration steps by layer and solution. """
         return np.copy(self.shooting_method_steps_taken_array)
 
+    @property
+    def surface_solve_amplification(self):
+        """Worst-case error amplification of the surface boundary condition solve (shooting method).
+
+        The collapsed surface solution combines the independent solutions with constants that can grow large
+        and cancel (deep starting radii, high harmonic degrees). Roundoff and integration error are amplified
+        into the surface solution, and the Love numbers derived from it, by up to this factor; the achievable
+        relative accuracy is floor limited to about this value times machine epsilon regardless of the
+        integration tolerance. Values near 1 indicate a well conditioned solve. Only recorded when the solve
+        runs with ``warnings`` enabled, and stays 0 for the propagation matrix method, which does not use the
+        shooting surface collapse.
+        """
+        return self.solution_storage_ptr.surface_amplification
+
     def get_result_by_ytype_name(self, str ytype_name):
         """Get a specific solution type array."""
         cdef char ytype_i

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/rs_solution_.hpp

@@ -55,6 +55,10 @@ public:
     // Diagnostic data
     std::vector<size_t> shooting_method_steps_taken_vec = std::vector<size_t>();
 
+    // Worst-case error amplification of the surface boundary condition solve across ytypes (shooting method
+    // only; stays 0 for the matrix method). See cf_estimate_surface_amplification in boundaries.pyx.
+    double surface_amplification = 0.0;
+
     // Constructors and methods
     virtual ~RadialSolutionStorageCC();
     RadialSolutionStorageCC();

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/shooting.pxd

@@ -38,5 +38,6 @@ cdef int cf_shooting_solver(
     size_t expected_size,
     size_t max_ram_MB,
     double max_step,
-    cpp_bool verbose
+    cpp_bool verbose,
+    cpp_bool warnings
     ) noexcept nogil

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/shooting.pyx

@@ -24,7 +24,7 @@ from TidalPy.RadialSolver.starting.driver cimport cf_find_starting_conditions
 from TidalPy.RadialSolver.interfaces.interfaces cimport cf_solve_upper_y_at_interface
 from TidalPy.RadialSolver.interfaces.reversed cimport cf_top_to_bottom_interface_bc
 from TidalPy.RadialSolver.derivatives.odes cimport RadialSolverDiffeqArgStruct, cf_find_layer_diffeq
-from TidalPy.RadialSolver.boundaries.boundaries cimport cf_apply_surface_bc
+from TidalPy.RadialSolver.boundaries.boundaries cimport cf_apply_surface_bc, cf_estimate_surface_amplification
 from TidalPy.RadialSolver.boundaries.surface_bc cimport cf_get_surface_bc
 from TidalPy.RadialSolver.collapse.collapse cimport cf_collapse_layer_solution
 
@@ -125,7 +125,8 @@ cdef int cf_shooting_solver(
         size_t expected_size,
         size_t max_ram_MB,
         double max_step,
-        cpp_bool verbose
+        cpp_bool verbose,
+        cpp_bool warnings
         ) noexcept nogil:
     """ Solves the viscoelastic-gravitational problem for planets using a shooting method.
     """
@@ -722,7 +723,7 @@ cdef int cf_shooting_solver(
                 max_step_to_use,           # Maximum step size [double]
                 first_step_size,           # Initial step size (0 = find good value) [double]
                 True,                      # Force retain solver
-                NULL                       # Analytic Jacobian (only used by implicit methods) [JacobianFuncType]
+                NULL                       # Analytic Jacobian (null = numerical; used by implicit methods) [JacobianFuncType]
                 )
             #########################
 
@@ -783,6 +784,9 @@ cdef int cf_shooting_solver(
         # No errors. Proceed with collapsing all sub-solutions into final full solution.
         solution_storage_ptr.message = cpp_string('Integration completed for all layers. Beginning solution collapse.\n')
 
+        # Reset the surface conditioning diagnostic (the storage can be reused across solves).
+        solution_storage_ptr.surface_amplification = 0.0
+
         for ytype_i in range(num_ytypes):
             solution_storage_ptr.message = cpp_string('Collapsing radial solutions for "') + to_string(ytype_i) + cpp_string('" solver.\n')
 
@@ -888,6 +892,22 @@ cdef int cf_shooting_solver(
                         if verbose:
                             printf(solution_storage_ptr.message.c_str())
                         return solution_storage_ptr.error_code
+
+                    # Record the worst-case error amplification of the surface solve across ytypes. Large
+                    # constants that cancel at the surface amplify roundoff and integration error into the
+                    # collapsed solution; the solver wrapper warns from this diagnostic. Skipped when the
+                    # caller disabled warnings, so the hot path pays nothing for a diagnostic it will not use.
+                    if warnings:
+                        solution_storage_ptr.surface_amplification = fmax(
+                            solution_storage_ptr.surface_amplification,
+                            cf_estimate_surface_amplification(
+                                constant_vector_ptr,
+                                uppermost_y_per_solution_ptr,
+                                num_sols,
+                                num_ys,
+                                MAX_NUM_Y
+                                )
+                            )
                 else:
                     # Working on interior layers. Will need to find the constants of integration based on the layer above.
                     cf_top_to_bottom_interface_bc(

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/RadialSolver/solver.pyx

@@ -19,7 +19,7 @@ from CyRK cimport PreEvalFunc
 from TidalPy.logger import get_logger
 from TidalPy.exceptions import UnknownModelError, ArgumentException, SolutionFailedError
 
-from TidalPy.constants cimport d_G, d_MIN_FREQUENCY, d_MAX_FREQUENCY, d_NAN
+from TidalPy.constants cimport d_G, d_MIN_FREQUENCY, d_MAX_FREQUENCY, d_NAN, d_EPS
 from TidalPy.utilities.math.numerics cimport cf_isclose
 from TidalPy.utilities.dimensions.nondimensional cimport NonDimensionalScalesCC, cf_build_nondimensional_scales
 from TidalPy.RadialSolver.rs_solution cimport RadialSolverSolution
@@ -36,6 +36,41 @@ ctypedef EOS_ODEInput* EOS_ODEInputPtr
 
 log = get_logger("TidalPy")
 
+# The severe threshold sits well above the ~1e6 amplification of a healthy automatic-starting-radius solve.
+SEVERE_SURFACE_AMPLIFICATION = 1.0e8
+
+
+def check_surface_solve_conditioning(
+        double surface_amplification,
+        double integration_rtol):
+    """Log a warning when the surface boundary condition solve is poorly conditioned.
+
+    Warns when the roundoff floor (``surface_amplification`` times machine epsilon) exceeds the requested
+    integration tolerance, or when the amplification alone exceeds ``SEVERE_SURFACE_AMPLIFICATION``.
+
+    Parameters
+    ----------
+    surface_amplification : float
+        Error amplification of the surface solve (``RadialSolverSolution.surface_solve_amplification``).
+    integration_rtol : float
+        Relative tolerance the radial functions were integrated to.
+
+    Returns
+    -------
+    bool
+        True when the warning was logged.
+    """
+    if (surface_amplification * d_EPS > integration_rtol) or \
+            (surface_amplification > SEVERE_SURFACE_AMPLIFICATION):
+        log.warning(
+            f"Radial solver surface boundary condition solve is poorly conditioned (error amplification "
+            f"~{surface_amplification:0.1e}; achievable relative accuracy ~{surface_amplification * d_EPS:0.1e}; "
+            f"requested integration rtol {integration_rtol:0.1e}). Love numbers and surface outputs may be much "
+            f"less accurate than requested. A larger (or automatic) starting radius improves conditioning; "
+            f"tightening tolerances cannot beat the roundoff floor.")
+        return True
+    return False
+
 
 cdef int cf_radial_solver(
         RadialSolutionStorageCC* solution_storage_ptr,
@@ -159,7 +194,7 @@ cdef int cf_radial_solver(
                 layer_slices += 1
             
             if layer_slices < 5:
-                solution_storage_ptr.error_code == -5
+                solution_storage_ptr.error_code = -5
                 solution_storage_ptr.message = cpp_string('RadialSolver:: At least five layer slices per layer are required. Try using more slices in the input arrays.\n')
                 if verbose:
                     printf(solution_storage_ptr.message.c_str())
@@ -316,7 +351,7 @@ cdef int cf_radial_solver(
                 use_kamata,                     # Flag to use Kamata+ (2015)'s starting conditions vs. Takeuchi+Saito (1972) [cpp_bool]
                 starting_radius_to_use,         # Starting radius for solver. For higher degree solutions you generally want to start higher up in the planet. [double]
                 start_radius_tolerance,         # Tolerance used if `starting_radius` is not provided. [double]
-                integration_method_int,         # Integration method int (0=RK23, 1=RK45, 2=DOP853) [unsigned char]
+                integration_method_int,         # Integration method [CyRK ODEMethod enum]
                 integration_rtol,               # Integration relative tolerance [double]
                 integration_atol,               # Integration absolute tolerance [double]
                 scale_rtols_bylayer_type,       # Flag for if tolerances should vary with layer type (using pre-defined scaling) [cpp_bool]
@@ -325,6 +360,7 @@ cdef int cf_radial_solver(
                 max_ram_MB,                     # Maximum amount of ram allowed for each layer's integration (note if parallelized then radial solver will exceed this value; there is also overhead of other functions) [size_t]
                 max_step,                       # Maximum allowed step size per layer [double]
                 verbose,                        # Verbose flag [cpp_bool]
+                warnings,                       # Warnings flag; enables the surface conditioning diagnostic [cpp_bool]
                 )
 
     # Finalize solution storage
@@ -454,11 +490,14 @@ def radial_solver(
     use_kamata : bool, default=False
         If True, then the starting solution at the core will be based on equations from Kamata et al (2015; JGR:P)
         Otherwise, starting solution will be based on Takeuchi and Saito (1972)
-    integration_method : int32, default="DOP853"
-        Which CyRK integration protocol should be used. Options that are currently available are:
-            - 0: Runge-Kutta 2(3)
-            - 1: Runge-Kutta 4(5)
-            - 2: Runge-Kutta / DOP 8(5/3)
+    integration_method : str, default="DOP853"
+        Which CyRK integration protocol should be used (case-insensitive). Options that are currently available are:
+            - "RK23": Runge-Kutta 2(3)
+            - "RK45": Runge-Kutta 4(5)
+            - "DOP853": Runge-Kutta / DOP 8(5/3)
+            - "BDF": Implicit multi-step method (good for stiff problems)
+            - "LSODA": Adams/BDF method with automatic stiffness detection
+            - "Radau": Implicit Runge-Kutta method of the Radau IIA family, order 5
     integration_rtol : float64, default=1.0e-5
         Relative integration tolerance. Lower tolerance will lead to more precise results at increased computation.
     integration_atol : float64, default=1.0e-8
@@ -504,8 +543,10 @@ def radial_solver(
     surface_pressure: float64, default=0
         The pressure at the surface of the planet (defined as radius_array[-1]). [Pa]
         Used for EOS calculations.
-    eos_integration_method : unsigned int, default = "DOP853"
-        Integration method used to solve for the planet's equation of state.
+    eos_integration_method : str, default = "DOP853"
+        Integration method used to solve for the planet's equation of state. Accepts the same options as
+        `integration_method`. LSODA can fail to take its first step at the planet's singular center; BDF and Radau
+        handle the singular start.
     eos_rtol : double, default = 1.0e-3
         Integration relative tolerance for equation of state solver.
     eos_atol : double, default = 1.0e-5
@@ -517,13 +558,15 @@ def radial_solver(
     verbose : bool, default=False
         If True, then additional information will be printed to the terminal during the solution. 
     warnings : bool, default=True
-        If True, then warnings will be printed to the terminal during the solution. 
+        If True, then warnings will be printed to the terminal during the solution. Also enables the shooting method's
+        surface conditioning diagnostic (`RadialSolverSolution.surface_solve_amplification`) and its warning.
     raise_on_fail : bool, default=False
         If True, then the solver will raise an exception if integration was not successful. By default RadialSolver
         fails silently.
     perform_checks : bool, default=True
-        Performs sanity checks that raise python exceptions. If turned off then these checks will be skipped providing 
-        some boost to performance but at the risk of uncaught exceptions (crashes).
+        Performs sanity checks that raise python exceptions. If turned off then these checks will be skipped providing
+        some boost to performance but at the risk of uncaught exceptions. The input array and tuple length checks
+        always run, whatever this is set to.
     log_info : bool, default=False
         Flag to turn on logging of key information (diagnostic and physical) from the RadialSolverSolution.
         Note there is a performance hit if this is true, particularly if file logging is enabled.
@@ -539,6 +582,26 @@ def radial_solver(
     cdef double last_layer_r = 0.
     cdef size_t total_slices = radius_array.size
     cdef size_t num_layers   = len(layer_types)
+
+    # Every radial array must match the radius array's length; the solver reads and writes all
+    # of them over the radius-derived slice count, so a shorter array would be accessed out of
+    # bounds (heap corruption). These checks run even when `perform_checks` is False.
+    if total_slices == 0:
+        raise ArgumentException('radius_array must not be empty.')
+    if (<size_t>density_array.size != total_slices
+            or <size_t>complex_bulk_modulus_array.size != total_slices
+            or <size_t>complex_shear_modulus_array.size != total_slices):
+        raise ArgumentException(
+            'density, complex bulk modulus, and complex shear modulus arrays must all match '
+            f'the radius array length ({total_slices}); got {density_array.size}, '
+            f'{complex_bulk_modulus_array.size}, {complex_shear_modulus_array.size}.')
+    if <size_t>upper_radius_bylayer_array.size != num_layers:
+        raise ArgumentException(
+            f'upper_radius_bylayer_array length ({upper_radius_bylayer_array.size}) must match '
+            f'the number of layers ({num_layers}).')
+    if len(is_static_bylayer) != num_layers or len(is_incompressible_bylayer) != num_layers:
+        raise ArgumentException(
+            'layer_types, is_static_bylayer, and is_incompressible_bylayer must have equal lengths.')
     cdef size_t layer_check, slice_check
     cdef cpp_bool top_layer
     cdef double last_layer_radius
@@ -691,9 +754,17 @@ def radial_solver(
         integration_method_int = ODEMethod.RK23
     elif integration_method_lower == 'dop853':
         integration_method_int = ODEMethod.DOP853
+    elif integration_method_lower == 'bdf':
+        integration_method_int = ODEMethod.BDF
+    elif integration_method_lower == 'lsoda':
+        integration_method_int = ODEMethod.LSODA
+    elif integration_method_lower == 'radau':
+        integration_method_int = ODEMethod.RADAU
     else:
-        raise UnknownModelError(f"Unsupported integration method provided: {integration_method_lower}.")
-    
+        raise UnknownModelError(
+            f"Unsupported integration method provided: {integration_method_lower}. "
+            "Supported: rk23, rk45, dop853, bdf, lsoda, radau.")
+
     cdef str eos_integration_method_lower = eos_integration_method.lower()
     cdef ODEMethod eos_integration_method_int = ODEMethod.NO_METHOD_SET
     if eos_integration_method_lower == 'rk45':
@@ -702,8 +773,16 @@ def radial_solver(
         eos_integration_method_int = ODEMethod.RK23
     elif eos_integration_method_lower == 'dop853':
         eos_integration_method_int = ODEMethod.DOP853
+    elif eos_integration_method_lower == 'bdf':
+        eos_integration_method_int = ODEMethod.BDF
+    elif eos_integration_method_lower == 'lsoda':
+        eos_integration_method_int = ODEMethod.LSODA
+    elif eos_integration_method_lower == 'radau':
+        eos_integration_method_int = ODEMethod.RADAU
     else:
-        raise UnknownModelError(f"Unsupported EOS integration method provided: {eos_integration_method_lower}.")
+        raise UnknownModelError(
+            f"Unsupported EOS integration method provided: {eos_integration_method_lower}. "
+            "Supported: rk23, rk45, dop853, bdf, lsoda, radau.")
 
     # Convert EOS methods from string to int
     cdef str eos_method_str
@@ -742,6 +821,10 @@ def radial_solver(
                 '   ("tidal", "loading")  # If you just want tidal and loading Love numbers.'
                 )
         num_bc_models = len(solve_for)
+        # The boundary-condition models are written into a fixed int[5] buffer.
+        if num_bc_models > 5:
+            raise ArgumentException(
+                f'radial_solver supports at most 5 simultaneous solve_for entries; got {num_bc_models}.')
         for i in range(num_bc_models):
             solve_for_tmp = solve_for[i]
             if solve_for_tmp == "free":
@@ -832,5 +915,6 @@ def radial_solver(
     if warnings:
         if np.any(solution.steps_taken > 7_000):
             log.warning(f"Large number of steps taken found in radial solver solution (max = {np.max(solution.steps_taken)}). Recommend checking for instabilities (a good method is looking at `<solution>.plot_ys()`).")
+        check_surface_solve_conditioning(solution.surface_solve_amplification, integration_rtol)
 
     return solution

tidalpy-0.7.6/TidalPy/__init__.py

@@ -0,0 +1,95 @@
+# Find Version Number
+import importlib.metadata
+__version__ = importlib.metadata.version("TidalPy")
+version = __version__
+
+# Set test_mode to False (used to turn off logging during testing)
+_test_mode = False
+
+import os
+if os.environ.get('TIDALPY_TEST_MODE', '').strip().lower() in ('1', 'true', 'yes', 'on'):
+    _test_mode = True
+
+import time
+
+# Initial Runtime
+init_time = time.time()
+
+# Various properties to be set by the configuration file and initializer (these should not be changed by user)
+_tidalpy_init = False
+_in_jupyter = False
+_output_dir = None
+_config_path = None
+
+# TidalPy configurations
+config = None
+
+# World configuration directory
+world_config_dir = None
+
+# Public properties that can be changed by user
+extensive_logging = False
+extensive_checks = False
+
+# Load the TidalPy initializer and run it (user can run it later so load it with the handle `reinitialize`)
+from TidalPy.initialize import initialize as reinit
+
+# Call reinit for the first initialization
+reinit()
+
+# Import module functions
+from .cache import clear_cache as clear_cache
+from .cache import clear_data as clear_data
+
+# Announce the backend change coming in TidalPy 0.8.0, once per session.
+import warnings as _warnings
+from TidalPy.exceptions import TidalPyDeprecationWarning
+
+_warnings.warn(
+    "TidalPy 0.8.0 will replace this version's backend with a new C++ backend. The current modules (structures, tides," \
+    "RadialSolver, rheology, ...) will be removed and module, class, and function names and signatures will change," \
+    "so code written for TidalPy 0.7.X will need to be updated. Pin 'TidalPy<0.8' to keep using the current API." \
+    "Silence this message with" \
+    "warnings.filterwarnings('ignore', category=TidalPy.exceptions.TidalPyDeprecationWarning).",
+    TidalPyDeprecationWarning,
+    stacklevel=2)
+
+def test_mode():
+    """ Turn on test mode and reinitialize TidalPy """
+    global _test_mode
+
+    if _test_mode:
+        # Don't need to do anything.
+        pass
+    else:
+        _test_mode = True
+        reinit()
+
+def log_to_file():
+    """ Quick switch to turn on saving logs to file """
+    if not config['logging']['write_log_to_disk']:
+        config['logging']['write_log_to_disk'] = True
+        reinit()
+
+# Helper function that provides directories to TidalPy's (and CyRK's) C++ headers
+def get_include():
+    """ Return the include directories of TidalPy's C++ source files, plus CyRK's, for dependent builds. """
+    import CyRK
+
+    # Since we depend on CyRK to build TidalPy; we likely want to include its headers as well.
+    tidalpy_dirs = CyRK.get_include()
+
+    tidalpy_dir = os.path.dirname(__file__)
+    tidalpy_dirs += [
+        # Utilities
+        os.path.join(tidalpy_dir, 'utilities', 'arrays'),
+        os.path.join(tidalpy_dir, 'utilities', 'dimensions'),
+
+        # RadialSolver
+        os.path.join(tidalpy_dir, 'RadialSolver'),
+
+        # Material
+        os.path.join(tidalpy_dir, 'Material', 'eos')
+    ]
+
+    return tidalpy_dirs

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/configurations.py

@@ -59,7 +59,7 @@ def save_dict_to_toml(dict_to_save: dict,
             # Append a number to the config name until one is found that is not already in use.
             file_path = unique_path(file_path, is_dir=False, make_dir=False)
     
-    with open(file_path, 'w') as toml_file:
+    with open(file_path, 'w', encoding='utf-8') as toml_file:
         toml_output = toml.dump(dict_to_save, toml_file)
     return toml_output
 
@@ -87,7 +87,7 @@ def check_config_version(
         Flag for if this configuration file is compatible.
     """
     compatible = False
-    with open(config_path, 'r') as config_file:
+    with open(config_path, 'r', encoding='utf-8') as config_file:
         config_version_found = False
         for line in islice(config_file, 0, 10):  # Assume the version number is in the first 10 lines
             if 'version:' in line.lower():
@@ -134,7 +134,7 @@ def get_default_config() -> dict:
     # Check if TidalPy's config file is not present.
     if not os.path.isfile(config_path):
         # Create toml file with default configurations.
-        with open(config_path, 'w') as config_file:
+        with open(config_path, 'w', encoding='utf-8') as config_file:
             config_file.write('#===========================================================#\n')
             config_file.write(f'#    TidalPy Default Configurations for Version: {version}\n')
             config_file.write('#===========================================================#\n\n')

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/constants.pyx

@@ -73,13 +73,15 @@ from scipy.constants import G as G_
 from scipy.constants import au as au_
 from scipy.constants import Stefan_Boltzmann
 from scipy.constants import R as R_
+from scipy.constants import k as k_
+from scipy.constants import Julian_year
 
 # Sun
 cdef double d_mass_solar       = 1.988435e30  # [kg]
 mass_solar = d_mass_solar
 cdef double d_radius_solar     = 6.957e8  # [m]
 radius_solar = d_radius_solar
-cdef double d_luminosity_solar = 3.848e26  # [Watts]
+cdef double d_luminosity_solar = 3.828e26  # IAU 2015 nominal [Watts]
 luminosity_solar = d_luminosity_solar
 
 # TRAPPIST-1
@@ -97,9 +99,9 @@ cdef double d_radius_earth = 6.371008e6  # [m]
 radius_earth = d_radius_earth
 
 # Jupiter
-cdef double d_mass_jupiter   = 1.89813e27  # [kg]
+cdef double d_mass_jupiter   = 1.898125e27  # [kg]
 mass_jupiter = d_mass_jupiter
-cdef double d_radius_jupiter = 6.9911e7  # [m]
+cdef double d_radius_jupiter = 6.9911e7  # IAU nominal mean radius [m]
 radius_jupiter = d_radius_jupiter
 
 # Pluto
@@ -129,6 +131,13 @@ SBC = d_SBC
 cdef double d_newtons_constant = G
 newtons_constant = d_newtons_constant
 
+# Boltzmann's constant [J K-1]
+k_boltzmann = k_
+
+# Julian year [s]
+year = Julian_year
+yr   = year
+
 cdef double d_M_sol   = mass_solar
 M_sol = d_M_sol
 cdef double d_M_earth = mass_earth

{tidalpy-0.7.5 → tidalpy-0.7.6}/TidalPy/cooling/cooling_models.py

@@ -112,7 +112,7 @@ def convection(
     # Calculate the Rayleigh number and then check for over/under shoots
     rayleigh = parcel_rise_rate / rate_heat_loss
     rayleigh = (delta_temp_shape > float_eps) * rayleigh
-    rayleigh = (layer_thickness_shape >= MIN_THICKNESS) * rayleigh
+    rayleigh = (layer_thickness_shape > MIN_THICKNESS) * rayleigh
 
     # Calculate the Nusselt number and then check for over/under shoots (minimum nusselt = 2.)
     nusselt = convection_alpha * (rayleigh / critical_rayleigh)**convection_beta