CHANGES.md

TidalPy Major Change Log

Version 0.8.X

Version 0.8.0 (2026-10-10)

This release is extensive (this update has been in the works for almost 2.5 years!) sorry for that. I would recommend treating this as a major new update and just dive into the documentation as if it was a new package. Please reach out to joseph.p.renaud@nasa.gov to invite you to the TidalPy slack for more discussion and help.

TidalPy 0.8.0 replaces TidalPy's backend with a new C++ backend. The classic Cython, numba, and Python modules are removed, and the new modules carry their final names: Structures, RadialSolver, Tides, Material, Rheology, Viscosity, PartialMelt, Cooling, Radiogenics, Dynamics, Stellar, and Utilities. Module, class, and function names and signatures change, so code written for 0.7.X needs to be updated: see the migration guide in the documentation (https://tidalpy.readthedocs.io/en/latest/future_structure.html). Pin TidalPy<0.8 to keep using 0.7.X API.

New Features

C++ Backend

This is a high-level summary only. The full API and design notes can be found in TidalPy's documentation. The migration guide explains the rationale for this change and presents porting examples.

• TidalPy.Utilities adds a C++ base-class hierarchy with schema-versioned TOML config files; C++ logging via spdlog; non-dimensionalization scales (Utilities.dimensions) and unit/orbital-element conversions (Utilities.conversions); and closed-form associated Legendre tables for degrees 2..10 (plus a generic evaluator via xsf sub module).
• Physics model families (Rheology, Viscosity, PartialMelt, Cooling, Radiogenics, the tide models of Tides, the luminosity models of Stellar, and the equation-of-state and shear-modulus laws of Material), each with vectorized (ndarray) calls, config save/loads, and binary serialization support. All are built on one parameter-spec system, so every model shares the same Python surface (construction by position or keyword, make_*, parameters, get_parameter, with_parameters, get_config_dict) and refuses a config key it does not read, naming the closest one it does.
• A Zener (standard linear solid) rheology, Rheology.Zener (zener, sls), which relaxes to a set fraction of its modulus instead of to zero, as a bulk response needs.
• Materials (TidalPy.Material): a Material combines a solid and a liquid Phase (each an equation-of-state law, a shear-modulus law, viscosity laws, default rheologies, and thermal constants) with melting curves that can follow the pressure, melt weakening, optional bulk mixing of the melt (which a Zener bulk rheology turns into bulk dissipation), and latent heat. Material.calc_state gives every property at a pressure and temperature. Each layer carries physics switches that default to the simplest and fastest case: use_thermal_expansion, use_melting, use_pressure_melting, use_melt_density, use_heating, use_tides, and state.
• World, layer, and system classes (TidalPy.Structures). TOML-driven world building; one Layer class with its material and other models; a whole-planet EOS solve with radius-continuous profile getters, which finds each layer's solid and liquid zones as it integrates (the Love solve takes each zone as a layer), lets a layer hold its mass and move, and can integrate temperature and heat flow through each layer's cooling model (conduction, or boundary layers around an adiabat) with radiogenic, tidal, and prescribed heat sources and per-layer temperature rates; whole-planet Love numbers as a world method (shooting or propagation-matrix, tidal/loading/free boundary conditions, cached for repeated solves, with a surface-conditioning diagnostic); global (1D) tidal dissipation for every world type (rheology-driven through the radial solver, or analytic cpl/ctl/ctl_q models); 3D tidal stress/strain/heating (secular or instantaneous, full 4D grids or analytically collapsed totals/profiles, latitude bands); spin and orbital rate engines (Dynamics); stellar luminosity models (Stellar); and a System class linking worlds (insolation, single- and dual-body tidal evolution with energy-balance checks).
• A melting layer is split into a liquid zone only where its shear modulus vanishes ([numerical] minimum_solid_rigidity default 0), so partial melt stays a melt-weakened solid that flexes and dissipates with the layers around it, and minimum_complex_rigidity defaults to 1e-15; the tidal response and heating change continuously as a layer melts.
• A rebuilt standalone radial solver (TidalPy.RadialSolver.radial_solver), call-compatible with the 0.7.X one, using CyRK dense output so the radial solution is evaluated exactly at any radius instead of interpolated from a fixed grid. Adds dense post-solve evaluation (get_radial_solution, eos_call), per-Love-number quality factors and phase lags, and a homogeneous-sphere convenience helper (homogeneous_love_numbers).
• CyRK's explicit Tsit5, Vern7, and Vern8 integrators are available to the EOS and Love-number solves (integration_method of radial_solver, solve_eos, and solve_love_numbers, and the [eos_solver] and [radial_solver] tables).
• A rebuilt tides engine (TidalPy.Tides): unsquared eccentricity functions for degrees 2..10 at truncation levels 2, 4, 6, 8, 10, 20, and 50 (default 10), where level N keeps every product of two eccentricity functions, and so the heating, through e^N as the 0.7.X level N did, and unsquared obliquity functions (off, I^1, I^2, and fully general), used by one truncation-based Kaula potential engine in place of the 0.7.X per-scenario potential modules. Note the convention change: the 0.7.X eccentricity and inclination functions were the squared G^2/F^2, while the new ones are unsquared G/F. A tidal solve warns once per world when its eccentricity is past the range of its truncation level at its spin rate; the ranges are measured separately for near-synchronous, moderate, and fast rotators, and recommend_eccentricity_truncation and recommend_obliquity_truncation pick a level for a tolerance and spin rate.
• 20 executed tutorial notebooks (Demos/), validation benchmarks against published Love numbers, BurnMan, and the tidal dissipation results of Renaud et al. (2021) plus a performance-tracking harness (Benchmarks/), and end-to-end tests (Tests/Test_E2E/).
• Speed, measured against TidalPy 0.7 on the same machine with the same inputs (the full table, method, and caveats are in the migration guide). Building a planet with its interior is about 220x faster now that the equation of state is integrated directly and the materials and worlds are read from memory: a fresh Io went from 1.4 seconds to about a millisecond. 3D heating maps are 2.4-5.9x faster on one thread (instantaneous and orbit-averaged) and 6.8-13x at the default thread count, a single radiogenic heating evaluation about 5x, vectorized rheology 3x, and global tidal heating 2.2-3.8x at every truncation level measured. The numba start-up cost is gone: a 0.7.X tidal heating call takes about 7 seconds during warm up and about a second at the start of every later session, while 0.8.0 takes a fraction of a millisecond. The standalone radial solver is about the same or in some cases a little slower, however it is much more accurate and stable then the previous versions.
• Every object writes the configuration it was built from (get_config_dict, with model tables keyed exactly as the make_* factories accept them) and rebuilds from it (build_world and build_system take a name, a path, or a config dictionary, with optional nested overrides; build_layer_from_dict rebuilds a layer), and save_to_toml writes the current state of a world or system as a buildable file under a version header. A world file may pin its own [eos_solver] and [radial_solver] settings so that it reproduces a run with the configuration file alone, and the configuration loader warns about keys it does not read.
• Conveniences on the world and system classes: calc_tides and the 3D calls take their orbital state from the world's System when it is left out, and calc_tides returns its results.
• Native radial-solver input builders (TidalPy.RadialSolver.build_inputs): build_rs_input_homogeneous_layers and build_rs_input_from_data assemble the density and complex-modulus profiles the standalone solver takes from layer descriptions and Rheology models, in C++.
• Bundled worlds, rebuilt on the new schema from the 0.7.X WorldPack: the terrestrial bodies io, europa, luna, mercury, earth_simple, earth_thermal, earth_prem, pluto, charon, triton, and trappist1b through trappist1h; the luna_dynamic, mercury_dynamic, pluto_dynamic, and europa_dynamic variants, whose liquid layer (and, for Europa, a new ocean) is solved with the dynamic equations on a pressure-dependent law; the gas giants jupiter_simple, jupiter, and neptune; the stars sol and trappist1; and the systems sol_system and pluto_charon_system (Pluto and Charon as a mutually synchronous pair about the Sun).
• MatPack (TidalPy.Material.load_material, available_materials): many named materials with their literature sources (simplified materials; mantle, crust, and core materials; water ices, water, and other volatiles; giant-planet envelopes and cores).
• The material, world, and system files of the data directory (and the packaged ones it has no copy of) are read into memory when TidalPy is imported (TidalPy.database). A file edited, added, or deleted during a session is noticed by the next build. On Python 3.11 and later these files are parsed with the standard library's tomllib, about ten times faster than toml.
• System.evolve(host, world) integrates a world and its tidal host in C++ with CyRK's implicit solvers (LSODA by default), evolving their shared orbit, both spins, and optionally every layer's temperature with both bodies raising tides. Capture into, passage through, and release from spin-orbit locks follow from the equations. It returns a PairedEvolutionResult, and its defaults come from the [evolution] configuration section, which a system file's own [evolution] table overrides.

Package

• One configuration file, TidalPy_Configs.toml (packaged defaults in TidalPy.defaultc, loaded to TidalPy.config). The packaged defaults are parsed on every load and the user's file is merged over them, so a partial file works and a new default reaches an existing file. TidalPy.save_config(path) writes the effective configuration under a header naming the TidalPy, SciPy, and CyRK versions.
• The C++ (spdlog) logger now writes a single TidalPy_<timestamp>.log file. The Python logging-based logger is removed. In a Jupyter notebook, warnings print below the cell ([logging] notebook_console_level), and TidalPy.capture_log collects log messages within a with block.
• The TidalPy data/config directories move with the minor version to .../TidalPy/0.8.X/. Upgrading from 0.7.X starts a fresh directory; the 0.7.X configuration and world files use a different format and are not read by 0.8.0.
• TidalPy.get_include() lists every TidalPy directory that holds a C++ header, after CyRK's include directories.

Removed

• The classic modules: TidalPy.structures, tides, the classic RadialSolver and Material, rheology, cooling, radiogenics, dynamics, stellar, orbit, Extending (BurnMan planet building), the classic WorldPack archive, numba_scipy, utilities, output, and logger. The migration guide maps each onto its replacement.
• TidalPy.toolbox (quick_tidal_dissipation, quick_dual_body_tidal_dissipation) has no replacement yet. Instead most functionality should be done using the new world and system classes (the migration guide has the worked example).
• The import-time deprecation notice added in 0.7.6. TidalPy.exceptions.TidalPyDeprecationWarning remains importable, so code that filters it keeps working.
• TidalPy.exceptions keeps only TidalPyException, InitializationError, ArgumentException, ConfigurationException, ModelException, UnknownModelError, TidalPyIntegrationException, SolutionFailedError, and TidalPyDeprecationWarning. The C++ backend raises ValueError, RuntimeError, TypeError, and NotImplementedError.
• TidalPy.extensive_logging, TidalPy.extensive_checks, TidalPy.world_config_dir, and the constants min_spin_orbit_diff and min_viscosity, which only the classic modules read.

Fixes

• TidalPy.clear_cache deleted every __pycache__ directory in the Python environment's site-packages, not only TidalPy's. It now clears only the installed TidalPy package.
• TidalPy.RadialSolver: the Takeuchi and Saito (1972) starting conditions, which the shooting method uses by default, evaluated their phi and psi functions with a truncated series at every argument, to avoid a floating-point cancellation near zero (issue #41). The series drifts once the argument k^2 r^2 passes about 1 (a 2e-5 relative error at 10, meaningless past about 30), which high degrees, short forcing periods, and dynamic liquid layers reach. Arguments above 0.5 now use the exact definitions, so the functions hold about 1e-13 everywhere. At such large arguments the Takeuchi solutions are themselves nearly dependent, and the re-orthonormalization of the shooting method (below) keeps such solves accurate.
• TidalPy.RadialSolver: the compressible-solid starting conditions (Takeuchi and Kamata) lost precision in (beta^2 k^2 - omega^2) / gamma when the forcing frequency squared is far above gamma = 4 pi G rho / 3, which is at periods shorter than about an hour (a 1e-10 relative error at 0.1 rad/s, 1e-6 at 1 rad/s). It is now computed without the cancellation. Together with the fix above, Love numbers at tidal periods are unchanged (the bundled worlds move by less than 1e-10 at tight tolerances), while at a one-minute period Takeuchi Love numbers that were off by up to 2.5% now match the Kamata starting conditions to 1e-10 for layered bodies and 7e-5 in the worst homogeneous case.
• TidalPy.RadialSolver now allows rigid translation of the body such that every degree-1 surface condition for loading are properly calculated (issues #53 and #99). The 0.7.X solver returned h', l', and k' carrying an arbitrary translation set by integration error, which changed with the forcing period and the tolerance, by order one at periods longer than about a month. A degree-1 loading solve now fixes the frame of the body's own center of mass (CE, k' = 0) in its surface solve (Guo et al. 2004; Martens 2016) and reports the Love numbers and the radial functions there, or in the CM, CF, CL, or CH frame of Blewitt (2003) through the new degree1_frame argument and [radial_solver] key. A body whose layers are all static now solves, and so does one with a liquid surface layer (a static liquid surface has no l', so the CF and CL frames are refused there). A 0.7.X result can mimic the new CE frame by performing (h' - k') and (l' - k').
• TidalPy.RadialSolver: dynamic liquid layers lost accuracy at long forcing periods and failed at longer ones, as their independent solutions became nearly dependent by the surface, and 0.7.X only printed a warning below a fixed 2.5e-5 rad/s. The shooting method now integrates a dynamic liquid in the pressure variable P = y2 - rho g y1 + rho y5, and a layer's independent solutions as one system that is re-orthonormalized where they become nearly dependent ([numerical] minimum_solution_independence). The Love numbers of neutral dynamic liquids and near-static solids hold the requested tolerance down to the 1e-16 rad/s minimum frequency, and the warning is removed. steps_taken gives each layer's step count, shared by its solutions, and orthonormalizations counts each layer's restarts.
• The off cooling model reported a boundary-layer thickness of half the layer, a value with no meaning for a layer that does not cool; it now reports NaN.
• TidalPy.RadialSolver.radial_solver never attached its extension to TidalPy's logger, so the C++ warnings of the world it builds from a supplied profile (its EOS and Love solves) were dropped. They now reach the log.

Refactors

Utilities

• Implemented a new constant/parameter backend that can be accessed in C++ but modified in Python/Cython.
  • Refactored constants.d_DBL_MANT_DIG to constants.d_DBL_MANT_DIGITS for readability.
  • Refactored constants.d_PI_DBL to constants.d_PI.
  • Refactored constants.d_NAN_DBL to constants.d_NAN.

Tests

• Test suites for every module. The tests that compared the new implementations against the 0.7.X ones now compare against frozen reference data generated from the 0.7.X code (frozen/*.npz beside each test, and Tests/Test_RadialSolver/test_dense_benchmark/).
• Tests/Test_Tides/Test_Classes/test_collapse_vs_legacy_01.py pins the global collapse (cpl) against frozen results from the 0.7.X toolbox.quick_tides for synchronous and non-synchronous cases at degrees 2 and 3.
• The 0.7.X test suites (Test_Old and the classic halves of the module suites) are removed with the modules they tested.
• The suite runs against a fresh temporary data directory (Tests/conftest.py sets TIDALPY_DATA_DIR before TidalPy is imported), so the user's TidalPy_Configs.toml no longer changes test results and nothing is written to the user's data directory.
• CI installs nbformat, nbclient, and ipykernel, so the demo and benchmark notebooks run there; the notebook test skips demo S02 by name, with its reason, so a plain pytest Tests/ passes.

Documentation

• A documentation page for every module, the tutorial notebooks, and the benchmarks. The migration guide (future_structure.md, kept at its 0.7.6 address) maps the 0.7.X modules, classes, and functions onto their replacements with verified porting examples. The 0.7.X module pages are removed.

Dependencies

• Removed: numba, dill, pathos, astropy, and astroquery (and the numba_scipy entry point), which only the classic modules used. psutil moves to the dev extra (used for performance-benchmark). The burnman and julia extras are removed; BurnMan is only needed to run the Benchmarks/EOS/EOS_vs_BurnMan.ipynb comparison.
• Added: tqdm (progress bars for long calculations).
• cyrk>=0.20.0. System.evolve drives CyRK's implicit solvers (BDF, LSODA, Radau) from C++ with events and a user Jacobian, and relies on the fix to their dense LU solve in CyRK 0.20.0, which also brings the explicit Tsit5, Vern7, and Vern8 methods.
• pandas>=1.5 was added to the dev requirements. It is used by the performance-benchmark views in Benchmarks/Performance.

spdlog Submodule

• Adds spdlog (header-only C++ logging) as a submodule at Dependencies/spdlog.

XSF Submodule

• Adds the xsf package as a submodule. The spherical Bessel function headers are used in various RadialSolver calculations.

Eigen Submodule

• Adds the Eigen package as a submodule. It provides much of LAPACK's functionality used in the radial solver's propagation-matrix method.

Version 0.7.X

Version 0.7.6 (2026-09-28)

TidalPy's backend and many function signatures will soon change! TidalPy 0.8.0 replaces it with a new C++ backend. The current modules (structures, tides, RadialSolver, rheology, ...) are removed in 0.8.0 and module, class, and function names and signatures change, so code written for 0.7.X will need to be updated. Pin TidalPy<0.8 to keep using the current API. Importing TidalPy now warns once per session through the new TidalPy.exceptions.TidalPyDeprecationWarning category (a FutureWarning subclass, so it is visible by default but can be silenced with a warnings.filterwarnings call).

This release backports the fixes to this backend that were found while developing 0.8.0. The version 0.7.X track will continue to get bug fix updates through the end of the year. But we strongly encourage users to move over to the new API. In 0.8.0's version branch you will find a migration guide in the documentation to help with the transition.

Fixes

• TidalPy.RadialSolver: radial_solver wrote one boundary-condition model per solve_for entry into a fixed 5-slot buffer without a length check, so a solve_for tuple with more than 5 entries overflowed the stack. It now rejects more than 5 entries with a clear error.
• TidalPy.RadialSolver: With perform_checks=False, radial_solver did not validate that the density and complex modulus arrays match the radius array's length (or that the per-layer tuples agree with the layer count). A shorter density array was written past its end during non-dimensionalization, corrupting the heap. Every input length is now validated up front, whatever perform_checks is set to.
• TidalPy.tides.love1d: effective_rigidity_general misplaced a parenthesis, multiplying mu / (rho g R) by 2 l^2 + 4 l + 3 / l instead of (2 l^2 + 4 l + 3) / l. Every degree was wrong: at degree 2 it gave 17.5 instead of 19/2, disagreeing with the degree-2 effective_rigidity. The error reached everything that computes Love numbers from a rheology through the homogeneous tides modules, including toolbox.quick_tidal_dissipation, toolbox.quick_dual_body_tidal_dissipation, and the homogeneous global_approx tides, which returned about 55 percent of the correct tidal heating for an Io-like homogeneous body. Models that take the Love number from a fixed Q or time lag (cpl, ctl) were not affected, and neither were Love numbers calculated through RadialSolver (shooting method or propagation matrix).
• TidalPy.radiogenics: The LLRI_and_SLRI isotope dataset of the default config (Castillo-Rogez et al. 2007) multiplied the paper's isotope concentrations by the isotopic abundances a second time, referenced its formation-epoch abundances to 4600 Myr so that they applied today, and held 60Fe at 100 ppb, a misreading of the 60Fe/56Fe ratio.
• TidalPy.utilities.arrays: Fixed several bugs in the C++ interpolation helpers (interp_.hpp and interp_.cpp, which TidalPy's own extensions do not use but dependent packages can reach through the new TidalPy.get_include): the provided index guess was used without a search (an unsigned >= 0 check that is always true), so a stale index selected the wrong segment; the complex interpolation wrote its imaginary part over its real part at exact grid points; an unsigned-underflow out-of-bounds read in cf_binary_search_with_guess for short domains; a cache-window read past the end for arrays shorter than 9; missing length 0 to 2 guards; and a mismatched cf_binary_search_with_guess declaration in interp.pxd. The helpers are now header-only (interp_.hpp; interp_.cpp is removed) with inline definitions, and the header no longer defines a global EPS constant.
• TidalPy.constants: The solar luminosity is now the IAU 2015 nominal value as is Jupiter's mass. luminosity_trap1 and the TidalPy.stellar mass-luminosity relations scale with the solar luminosity.
• TidalPy: TIDALPY_TEST_MODE turned test mode on for any non-empty value, including 0 and false. Only 1, true, yes, or on (any case).
• TidalPy.configurations: Configuration files are read and written as UTF-8 on every platform, rather than in the system's locale encoding.
• TidalPy.RadialSolver: The solver's own check for fewer than 5 slices in a layer compared the error code (==) instead of setting it, so with perform_checks=False the solve carried on with too few slices. It now fails with the "At least five layer slices" message.
• TidalPy.radiogenics: A layer's isotopes dataset name was checked in lower case but looked up as given, so a mixed-case dataset such as LLRI_and_SLRI could never be selected (it raised UnknownModelError, and llri_and_slri raised KeyError). Dataset names now match case-insensitively, and an unknown name lists the known datasets.
• TidalPy.cooling: At exactly MIN_THICKNESS, the convection model kept the layer's Rayleigh number (a >= guard) while setting its Nusselt number and boundary layer thickness to their thin-layer values (> guards). The layer is now too thin for every output.

New Features

RadialSolver

• TidalPy.RadialSolver.radial_solver now accepts CyRK's implicit (stiff) integration methods BDF, LSODA, and Radau alongside the explicit RK23/RK45/DOP853, for both integration_method and eos_integration_method. Method names are case-insensitive, and an unknown name lists the supported set. One caveat: the whole-planet EOS integration starts at the planet's singular center, where LSODA's startup can fail to take its first step (a clean failure). BDF and Radau handle the singular start.
• The shooting method now measures how strongly its surface boundary-condition solve amplifies error (deep starting radii and high harmonic degrees can make the collapse constants grow enormous and cancel, amplifying integration error into the Love numbers). The factor is recorded on the returned solution (surface_solve_amplification) and a warning is logged when the resulting roundoff floor exceeds the requested integration_rtol (computed only when the solve runs with warnings enabled). The check is also available as TidalPy.RadialSolver.solver.check_surface_solve_conditioning.
• Numerical note on manual starting radii deep in the planet: starting the shooting integration essentially at the center (e.g., starting_radius=0.1 m on a 6000 km planet) at degree 3 with a dynamic incompressible layer leaves the surface solve so ill-conditioned that the solver can report success with a badly wrong Love number. This is inherent conditioning, present in all versions. Prefer the automatic starting radius (starting_radius=0). If a deep manual start is required, tighten integration_rtol and take heed of the new conditioning warning.
• Numerical note on dynamic liquid layers and long forcing periods: a dynamic liquid layer sandwiched between solids is well-conditioned only at short forcing periods. At long periods the 1/omega^2 terms make the solve unstable. Use the static liquid assumption for long-period forcing.

Package

• Added TidalPy.get_include, which returns the paths to TidalPy's C++ source files (and CyRK's) so dependent packages can include them in their builds (similar to numpy.get_include).
• TidalPy.constants now exposes k_boltzmann (Boltzmann's constant) and year (the Julian year in seconds), with the alias yr, all from SciPy.
• The TidalPy data/config directories are now scoped to the package's <major>.<minor>.X version (e.g., .../TidalPy/0.7.X/) instead of the full patch version, so user configs and downloaded data are not duplicated (or lost) on each bugfix release. New helper TidalPy.paths.get_data_version() returns the scoped label. Upgrading from 0.7.5 starts a fresh 0.7.X directory: copy any edited Config/TidalPy_Configs.toml or Worlds/ files over from the 0.7.5 directory.

Tests

• New tests for the fixes above: radial_solver input validation, the implicit integrators, the surface conditioning diagnostic, effective_rigidity_general and the quick tidal dissipation it feeds, the LLRI_and_SLRI dataset, the new constants, get_include, the data-directory scoping, and the import-time deprecation notice.
• A root conftest.py drops the repository root from sys.path so tests import the installed, compiled package rather than the source tree.
• pytest now reports the 25 slowest tests of every run.

Repository

• The three per-OS test workflows are replaced by one tests.yml: a reduced suite (the latest two CPythons on all three operating systems) for pull requests and certain admin pushes.
• The PyPI workflow compiles the sdist and imports the result before anything uploads, uploads with PyPI trusted publishing (the pypi environment) instead of a stored API token, and no longer cancels a release build part way through.
• The Linux wheels pass TIDALPY_TEST_MODE into the manylinux container, and each wheel's import check is split into one command per group of compiled modules.
• The version-sync workflow checks out the pushed branch (it previously landed on a detached HEAD and failed to push), fails loudly when a version pattern stops matching (the README badge had sat on a stale version), and handles pre-release version strings.
• The JOSS paper workflow only commits the built PDF back on pushes, not on pull requests.
• Package now enforces LF line endings (.gitattributes) and marks binary files; updated the files that had CRLF line endings.
• Fixed an incorrect license URL and the Python requirement in codemeta.json.

Documentation

• The Read the Docs build no longer installs TidalPy: it installs Documentation/requirements.txt, renders the notebooks from their stored outputs, and no longer runs Doxygen or an autogenerated API reference (the hand-written module guides are the reference). GitHub-style alerts (> [!NOTE]) render as admonitions, and math renders through MathJax. The docs extra no longer includes breathe or sphinx-autodoc-typehints.

Version 0.7.5 (2026-09-08)

Fixes

• Fixed the macOS wheels on PyPI, which could not be imported unless an OpenMP run time happened to exist at the path used on the build machine (Library not loaded: @rpath/libomp.dylib). CyRK's macOS wheels had the same defect, which CyRK v0.19.0 fixes (see new pin below).
• Fixed the SyntaxWarning: invalid escape sequence (Python 3.12+) raised the first time rheology.complex_compliance.compliance_models was compiled: the Andrade docstrings contain LaTeX backslashes and are now raw strings.

Dependencies

• Bumped Python version pinning to >=3.9, <3.15.
• Updated the pinning of CyRK to >=0.19.0, <0.20.0.
• Updated the pinning of numpy >=1.22, <2.6.
• Added matplotlib>=3.4.2 back to the core dependencies. TidalPy.structures imports the plotting tools, so since v0.7.4 (which moved matplotlib into the optional extras) a minimal install could not import TidalPy.structures or build worlds.

Build

• Dropped the OpenMP compile and link flags. None of TidalPy's Cython uses prange, and CyRK no longer needs OpenMP either, so the flags only added a run time library that had to be bundled (or, on macOS, was not). Each platform's default compiler now works, including clang.
• Merged _build_tidalpy.py into setup.py. The cmdclass hook dated from the pyproject.toml conversion; setup.py already declared the extensions (the only way setuptools can mark a wheel as platform specific), so the hook was redundant and, through py-modules, was installing _build_tidalpy as a top-level module in users' site-packages.
• The macOS arm64 wheels are now built by cibuildwheel alongside the Linux and Windows wheels. Every wheel is installed into a fresh environment and the compiled RadialSolver entry points are imported before the upload job can start. Free-threaded CPython wheels are skipped because numba does not ship them.
• Classifiers now list Python 3.9 and 3.14 to match requires-python.
• MANIFEST.in prunes Dependencies/ so third-party checkouts under it can never reach the sdist (a stale, git-ignored TidalPy.egg-info/SOURCES.txt from another branch had been seeding them in).

Tests

• The macOS test workflow now installs TidalPy with clang through setup-python, the same way the Ubuntu and Windows workflows do (and the same toolchain the wheels are built with). The conda environment and the brew llvm/libomp steps are gone.

Conda-Forge

• The recipe pins cyrk >=0.19.0,<0.20.0, no longer lists vcomp14, llvm-openmp, or libgomp, drops the no-op --no-binary cyrk, and imports TidalPy.RadialSolver in its test.

Documentation

• README: the macOS source-build section no longer asks for brew's llvm and libomp; each platform's default compiler works.

Refactors

Material Module

• eos.solver: Updated the baseline_cysolve_ivp_noreturn call for CyRK 0.18's new analytic Jacobian argument (passed as null; TidalPy uses explicit methods).

RadialSolver Module

• shooting: Updated the baseline_cysolve_ivp_noreturn call for CyRK 0.18's new analytic Jacobian argument (passed as null).

Version 0.7.4 (2026-03-27)

Dependencies

• Moved non-critical dependencies out of main requirements.

Version 0.7.3 (2026-03-27)

Fixes

• RadialSolver: Fixed bug in Takeuchi starting conditions where y6 was pulling the incorrect value. Kamata starting conditions were not affected.

Performance

• The changes introduced in this release led to around 25% improvement in TidalPy's RadialSolver Love Number Calculator speed.

Dependencies

• TidalPy now works on Python 3.14.
• Bumped version of ipympl to <=0.11.0.
• Bumped version of CyRK to >=0.17.1, <0.18.1.
• Increased numpy's max pinnings to <2.5.

Other

• Changed TidalPy.constants.d_PI_DBL to TidalPy.constants.d_PI since the "DBL" is redundant with the "d_".
  • Same for d_INF, d_EPS_10, d_EPS_100, d_EPS, d_NAN

Version 0.7.2 (2026-03-27)

Version 0.7.2 was skipped! It was never released!

Version 0.7.1 (2026-02-05)

Fixes

• Fixed surface boundary condition bug where dynamic liquid layers were using too small of a struct and could cause crashes (and wrong results).

Package

• Removes support for MacOS 13 builds.

Version 0.7.0 (2025-12-02)

Fixes

• Fixed top-level directories and files being mistakenly installed.
• Updated np.trapz to scipy.integrate.trapezoid due to deprecation of the former.
• Fixed bug in the henning melting model where shear modulus may not have had the correct value when fully melted.
• Fixed issues in some of the demo notebooks.
• Fixed notebooks to work with changes to Matplotlib.

GitHub Actions

• Added action to automatically update version numbers, dates, and commit hashs in citation.cff, codemeta.json, and meta.yaml.

Utilities

• Added fontsize kwarg to projection plotter in utilities.graphics.
• Changed the default of yplot so plotting imaginary parts of radial solution is by default off.

Documentation

• Added JOSS paper draft to Papers/2025-JOSS.
• Added documentation interface with Sphinx and ReadTheDocs.
• Added and updated readme badges.
• Extensive changes to all documentation files and structure.
• Changed how CHANGES.md (main change log) is structured. Major versions will appear as top level headers.

Other

• Change TidalPy's license to Apache 2.0.
• Added CODE_OF_CONDUCT.md with TidalPy's code of conduct.
• Added CONTRIBUTING.md with information on how others can contribute to TidalPy.
• Updated citation.cff with latest information.
• Added codemeta.json with citation and metadata.
• Removed MacOS-13 tests.
• Removed unused code, tests, and documentations.
• TidalPy now uses ruff to check for code issues.
  • Added ruff lint check to ubuntu tests.
• Fixed many code issues found with ruff (these are not bug fixes, just syntax compliance and best practices).
• Moved more module/file level constants into TidalPy.constants and in the configuration file.
• Added TidalPy logo.

Version 0.6.X

Version 0.6.11 (2025-11-06)

Dependencies

• Added more restrictive pinning for numpy's max version to work with latest CyRK.

Version 0.6.10 (2025-11-05)

New

• RadialSolver solution can now provide quality factors rs_solution.Q and phase lag angles (in radians) rs_solution.lag.

Fixes

• Fixed issue where RadialSolver would incorrectly say a result was successful when the application of surface boundary conditions failed.
• Fixed issue where RadialSolver solution's diagnostics would print the incorrect parameter for a planet's mass.

Changes

• RadialSolver solution returns nan's instead of None for Love numbers when a solution fails.
• RadialSolver solution Love number attributes now return lists of np.nan if the user requested multiple solution types (e.g., "tidal, loading") and the solution failed. This allows the user to still subscript rs_solution.k[0], rs_solution.k[1] even if the solution was not successful.

Tests

• Added more tests to check RadialSolver Solution attributes.

Version 0.6.9 (2025-09-19)

Fixes

• Fixed issue where TidalPy.RadialSolver.shooting would pick the incorrect starting index. If the starting layer (set by the starting radius) was not the first layer it could cause a int overflow and lead to access violation crashes.

Dependencies

• Updates some GitHub action dependencies.

Tests

• Added more tests to check RadialSolver starting radius conditions to try to catch bugs like this patch fixed!

Version 0.6.8 (2025-08-19)

Changes

• TidalPy.tides.modes.collapse_multilayer_modes now checks for ill-formed radius_arrays and will raise an error if it detects a problem.
• Improved how projection_map displays colorbar numbers.

Fixes

• Fixed issue where TidalPy.tides.modes.collapse_multilayer_modes was not treating macro-layer boundaries correctly.

Version 0.6.7 (2025-08-19)

Changes

• TidalPy.tides.modes.collapse_multilayer_modes now requires a tuple of rheology instances for both shear and bulk rheology. One for each macro layer. This allows different rheologies to be used for different layers.

Fixes

• Fixed some warnings that were showing up in the multilayer demo notebook.

Version 0.6.6 (2025-08-15)

Changes

• Updated to work with CyRK v0.15.1
  • This change results in about a 18% performance improvement for RadialSolver depending on the problem.
• Converted RadialSolver and EOSSolver status message to C++ strings.
• Updated some documentation.

Fixes

• Fixed potential issue where RadialSolver could use a very small or even negative maximum step size.

Version 0.6.5 (2025-08-12)

New

• Added test to check if structure arrays have been changed.
• Added debug flag to installation files to help with cython debugging.

Fixes

• Fixed issue where TidalPy structures (layers, planets, etc.) would return editable arrays instead of copies of arrays. This could lead to subsequent functions (like planet paint) changing the arrays. This fixes GitHub Issue #74.
• Fixed issue where shooting method was corrupting data when starting radius was too large (which happened for higher orders of l) This fixes GitHub Issue #72.
• Fixed broken demo notebooks.

Version 0.6.4 (2025-04-10)

Dependencies

• Removed max version limit for platformdirs package

Version 0.6.3 (2025-04-09)

Changes

• Changes GitHub actions to avoid testing when not needed.
• Now supports Python 3.13

Fixes

• Removed various files that were being included in the manifest

Dependencies

• Updated to work with CyRK 0.13.3
• Updated to work with Numpy 2.x

Version 0.6.2 (2025-03-28)

• Bumping version to integrate into conda-forge.
• Fixed some build processes that could cause both numpy 1.X and 2.X to be installed and inconsistent use (only affected MacOS)

Version 0.6.1 (2025-01-11)

Benchmarks and Performance

• Added performance benchmark for TidalPy.RadialSolver.helpers.

Fixes

• Fixed memory leak that was occurring in the EOS Solver (therefore also RadialSolver) due to CyRK's CySolverSolution not being dereferenced (this is a problem with CyRK, but hack applied to TidalPy until a fix can be made to CyRK).

Performance

• Improved TidalPy.RadialSolver.helpers.build_rs_input_from_data performance by factor of 10x to 150x depending on layer structure.
• Improved TidalPy.RadialSolver.helpers.build_rs_input_homogeneous_layers performance by factor of 15% to 3.5x depending on layer structure.
• Improved TidalPy.RadialSolver.radial_solver performance by around 10% depending on layer structure.

Version 0.6.0 (2025-01-07)

Removed

• Removed support for the older non-cythonized TidalPy.radial_solver module in favor of TidalPy.RadialSolver

RadialSolver Changes

• Moved RadialSolver's Boundary Condition finder to its own function in TidalPy.RadialSolver.boundaries.surface_bc.pyx to allow it to be used by both the shooting and propagation matrix techniques.
• Decoupled radial solver from shooting method.
  • Moved the shooting method (formerly just called cf_radial_solver) to a dedicated file to prep for a different dedicated file for the prop matrix solver.
  • Now TidalPy.RadialSolver.solver only contains driver functions and output structures.
• Added Propagation Matrix technique to RadialSolver
  • This is simplified for now. Only planets with 1 solid, static, incompressible layer are allowed.
    • Other assumptions can be approximated, e.g., liquid layers use a small shear modulus.
    • Multiple layers should also work if you have discontinuities in density, shear, etc. within your "one layer".
  • A cythonized solid fundamental matrix implementation can be found in TidalPy.RadialSolver.PropMatrix.solid_matrix.
• New radial slicing scheme required:
  • TidalPy now requires radial_solver input arrays to be defined in a precise manner:
    • radius_array must start at 0.
    • Each layer's upper and lower radius must be in the radius_array. That means if there is more than one layer there will be two identical radius values!
      • E.g., if a planet has a ICB at 1000km and a CMB at 3500km. Then radius_array must be setup with 2 values of 1000km and 2 values of 3500km.
      • Other parameters should be defined on a "as layer" basis. So shear modulus at the 1st 1000km would be the shear of the inner core, at the 2nd 1000km it would be the shear modulus of the outer core. Likewise shear modulus at the 1st 3500km would be for the outer core and at the 2nd 3500km would be the shear modulus for the mantle. Same goes for density and bulk modulus.
• Added warning to check for instabilities (based on large number of steps taken; requires warnings=True).
• Changes to radial_solver arguments:
  • Many changes to the order as well as additions and removals of arguments to radial_solver highly suggest looking through the updated documentation.
  • radial_solver no longer requires gravity_array.
    • New with this update is a self-consistent equation of state solver (EOSS) that is called from radial_solver. This EOSS is used to find gravity(r).
  • Bulk modulus must now be provided as a complex-valued array
    • If a non-zero imaginary portion is provided (e.g., found via a rheology) then bulk dissipation is now tracked.
    • If imaginary portions are zero, then bulk dissipation is ignored as in TidalPy v0.5.x and earlier. (this is actually dependent on your bulk rheology; it could also cause infinities...)
  • Several arguments have had slight name refactors which will break calls that used keyword arguments. Review the RadialSolver documentation or "TidalPy/RadialSolver/solver.pyx" for the new argument names.
  • upper_radius_bylayer_array must now be provided as a numpy array (previously a tuple of floats was acceptable).
  • Added new optional argument surface_pressure (default=0.0) used with EOSS to find pressure convergence.
  • Added new optional argument core_model (default=0) used to set the lower boundary condition when the propagation matrix technique is used.
  • Added new optional argument starting_radius (default=0.0) to allow the user to set the initial radius for the radial solution.
    • Setting the solution radius higher in the planet can improve solution stability when using the shooting method. Particularly if looking at higher harmonic degree_ls. There is a trade off with accuracy so advise testing.
    • The starting radius must be >= 0.0, if 0.0 is provided (the default) then TidalPy will use the Martens technique to find a suitable starting radius (function of degree_l, planet radius, and the new optional argument start_radius_tolerance which defaults to 1.0e-5).
  • Removed limit_solution_to_radius argument.
  • Added new optional argument use_prop_matrix (default=False) to use the propagation matrix technique over the shooting method.
  • Equation of State Solver arguments:
    • eos_method_bylayer - EOSS method to use for each layer (currently only "interpolate" is supported).
    • eos_integration_method Runge-Kutta method to use for EOSS (default="RK45"). eos_rtol and eos_atol can also be provided to control integration error.
    • eos_pressure_tol (default=1.0e-3) and eos_max_iters (default=40) control the pressure convergence of the EOSS.
  • Added optional argument perform_checks (default=True) that performs many checks on the user input before running the solution (small performance penalty, but highly recommend leaving on until your inputs are tested).
  • Added optional argument log_info (default=False) that will log key physical and diagnostic information to TidalPy's log (which can be set to be consol print, log file, or both via TidalPy's configurations).
    • Note there is a performance hit when using this, particularly if logging to file is enabled.

New RadialSolver Helpers

• To assist with the generation of valid inputs to radial_solver, TidalPy now provides two helper functions:
  • For planets with homogeneous layers: from TidalPy.RadialSolver import build_rs_input_homogeneous_layers takes in attributes for a planet made of layers with constant physical properties and then provides the arrays and other required radial_solver inputs that conform to the new radius_array scheme.
  • For planets with inhomogeneous layers: from TidalPy.RadialSolver import build_rs_input_from_data which parses data arrays (loaded from a file or built elsewhere like using a more robust EOS than TidalPy offers) and makes changes to ensure they will work with radial_solver.

Expanded RadialSolverSolution Attributes and Methods

• The output of radial_solver, an instance of the RadialSolverSolution, has been greatly expanded to provide much more data and functionality to the user. Full details can be found in the new RadialSolver documentation. Highlights include:
  • EOSS results like <solution>.mass, <solution>.moi, <solution>.moi_factor, <solution>.central_pressure, <solution>.surface_gravity.
  • Diagnostic data like number of integration steps required per layer to find a solutions <solution>.steps_taken, or EOSS diagnostics: <solution>.eos_iterations, <solution>.eos_pressure_error, <solution>.eos_success, <solution>.eos_message, <solution>.eos_steps_taken.
    • Much of the new diagnostic data as well as key results can now be quickly printed using <solution>.print_diagnostics().
  • Method to quickly plot the viscoelastic-gravitational solution y's <solution>.plot_ys().
  • Method to quickly plot the EOS results <solution>.plot_interior().
  • In addition to the previously provided attributes like <solution>.love, <solution>.k, <solution>.h, <solution>.l, <solution>.result.

Cython / C Changes

• Shifted away from PyMem_Free to CyRK.utils.mem_free to allow for consistency in future development.
  • Avoiding using these manual heap allocations whenever possible. Many new uses of smart pointers and C++ vectors.

Other Changes

• Updated GitHub actions.
• Moved to more consistent and robust types (e.g., int for degree_l vs. prior unsigned-char; unsigned-int).
• Added inverse function cinv in TidalPy.utilities.math.complex.
• New "TidalPy/constants.pyx" isolates all TidalPy constants. Available to both Python and Cython. Refactored all files to use the constants in this file.
• New numerics module TidalPy.math.numerics for low-level floating point functions.
  • New cythonized isclose function that matches functionality of python's math.isclose
• Cythonized radial sensitivity to shear/bulk functions in TidalPy.tides.multilayer.sensitivity (based on Tobie+2005)
• Cythonized radial heating functions that use the sensitivity to shear/bulk functions in TidalPy.tides.multilayer.heating (based on Tobie+2005)
• Improved logging so it is less spammy.
• Logger now logs all exceptions raised.
• Moved TidalPy's default config and world config dir to user's "Documents" folder (from system appdata folder).
  • If upgrading from previous version of TidalPy, you can safely delete the old config directory.
    • On Windows the old dir was: "'C:\Users\\AppData\Local\TidalPy'"; The new dir is "'C:\Users\\Documents\TidalPy'"
    • On Mac the old dir was: "'/Users//Library/Application Support/TidalPy'"; The new dir is "'/Users//Documents/TidalPy'"
    • On Linux the old dir was: "'/Users//.local/share/TidalPy'"; The new dir is "'/home//Documents/TidalPy'"
• New switch TidalPy.log_to_file() to quickly turn on saving log to file (this can also be adjusted in the TidalPy configurations).
• TidalPy now looks for an environment variable "TIDALPY_TEST_MODE" to turn on test mode during first initialization (can later be changed using the TidalPy.test_mode() command or setting TidalPy._test_mode = False; TidalPy.reinit()).
• Made use of more TidalPy-specific exceptions.
• Tweaked the TidalPy.utilities.graphics -> yplot.
• User can now override TidalPy.config using TidalPy.reinit(<new config toml file path; or dictionary of configs>).
• Refactored and made improvements to TidalPy.utilities.graphics.planet_plot.

Dependencies

• Added support for CyRK v0.12.x
• Added support for Burnman v0.2.x

Documentation

• Reworked TidalPy's documentation structure in prep for a shift to Sphinx in the future.
• Greatly expanded and improved RadialSolver documentation which can be found in "TidalPy/Documentation/RadialSolver"

Fixes

• Fixed issue where radial_solver arrays could dealloc while references still pointed to them (hanging pointers).
• Missing Cython compile arguments in TidalPy's utilities, nondimensional.pyx.
• Fixed incorrect type in dynamic liquid layers that may have been causing some errors to propagate.
• Fixed issue where TidalPy._config_path was not being updated.
• Fixed issue where log files could not be created.

Version 0.5.X

Version 0.5.5 (2024-11-11)

Fixes:

• Fixed dependency compatibility issues.
• Fixed incorrect function signature type for scipy's spherical_jn. SciPy v.1.14.X uses a new signature which is breaking on MacOS. Limiting to "SciPy<1.14" for now. See GitHub Issue #65

Version 0.5.4 (2024-04-30)

Fixes:

• Fixed RadialSolver frequency warning message for dynamic liquid layers not displaying for correct layer types.

Additions:

• Added way to suppress warning messages in RadialSolver.
  • To turn this suppression on, pass warnings=False to RadialSolver.radial_solver.

Version 0.5.3 (2024-04-26)

Fixes:

• RadialSolver: Fixed bug where solutions between liquid and solid layers were not propagating correctly.

Additions:

• New Love number benchmarks for Earth provided by Nick Wagner in Benchmarks & Performance\RadialSolver\Earth Love Numbers.ipynb (Jupyter Notebook).

Changes:

• Pre-allocated several cythonized arrays to nans to help with debugging.
• Provided more error messages to improve user experience.
• Cythonized non-dim function now takes in the planet's density and radius as variables to change.
• Improved the Tobie and Roberts benchmarks for radial solver.

Other:

• Updated to work with CyRK 0.8.7

Version 0.5.2 (2024-02-22)

Documentation

• Improved RadialSolver documentation regarding higher degree-l.
• Added info about issues that can arise from using non C-continguous arrays in cythonized functions.

Fixes:

• Added error message to RadialSolver.radial_solver if length of provided assumption tuples is not the same.
• Fixed issue where non C-continguous arrays were allowed in cythonized functions that required them.

Version 0.5.1 (2024-02-14)

• Removed Python 3.8 support due to issues with building SciPy.

Version 0.5.0 (2024-02-14)

This version is likely to break code based on TidalPy v0.4.X and earlier

Cythonizing TidalPy

• A major change starting with v0.5.0 is the switch from numba.njited functions to cython precompiled functions and extension classes. The reasons for doing this are numerous. This transition will be completed in stages with minor versions (v0.X.0) each bringing a new set of cythonized updates until all njited functions are retired.
• For this version:
  • Converted TidalPy.radial_solver.radial_solver to cythonized TidalPy.RadialSolver.radial_solver.
    • The old radial solver method will be removed in TidalPy version 0.6.0.
  • Added new cython-based TidalPy.utilities.classes.base_x base cython extension class that other classes are built off of.
  • Converted TidalPy.rheology.complex_compliances.compliance_models to cythonized TidalPy.rheology.models.
    • Improved the new rheology methods to better handle extreme values of frequency and modulus.
    • The old rheology solvers will be removed in a future release of python.
  • Added several new cython-based helper functions in the utilities package.

Other Major Changes

• Added support for Python 3.11 and 3.12. TidalPy now runs on Python 3.8--3.12.
  • Note that currently the Burnman package does not support 3.12 so that functionality is limited to python 3.8-3.11.
• Removed support for solver_numba in the radial_solver module.
• Removed some imports from main package and sub modules' __init__ to avoid slow load times.
• Moved conversion tools from TidalPy.toolbox.conversions to TidalPy.utilities.conversions.
• Changed setup files so that cython code can be compiled.
  • special - for high-performance, general, scientific functions.
• Moved TidalPy configs to a standard user directory by default. The specific location will depend on the OS.
  • Default configs will be installed on the first import TidalPy call after installation.
    • These defaults are stored in the TidalPy.defaultc.py as a string which is copy and pasted to the new TidalPy_Configs.toml.
  • There is a new TidalPy.clear_data() function to delete all data stored in these locations. Data will be rebuilt the next time TidalPy is imported.
  • New TidalPy.set_config(config_path) to change the active configuration file used by TidalPy.
    • Note that TidalPy.reinit() should be called after changing the configurations.
  • New TidalPy.set_world_dir(world_dir_path) to change which directory to pull world configs from.
  • Moved away from the system of default.py configurations for sub modules. All default configs are stored in the same TidalPy_Config.toml
• Shifted from json to toml files for world configs.
  • Store all world configs to a zip file for easier distribution.
• TidalPy now requires:
  • CyRK>=0.8.6
  • Cython>=3.0.0
• Moved BurnMan 3rd party dependence to a more dedicated Extending folder for future development.
• To make TidalPy lighter weight we are starting to remove a lot of 3rd party packages.

Minor Changes and New Features

• complex_compliance configurations are now stored in the top level rheology in all configs.
  • For example, in prior TidalPy versions you would need to change the complex compliance model by editing config['layers']['mantle']['rheology']['complex_compliance']['model'] = 'andrade'. Now this would be: config['layers']['mantle']['rheology']['model'] = 'andrade'.
• Added unique frequency finder functions to the modes module.
• Moved most of the type hints behind the typing.TYPE_CHECKING flag.
• Moved non-critical files out of repository.
• Created a new tides.heating module and moved the volumetric heating calculations there.
• Expanded the performance suite to better track the radial_solver module.
• Moved cache.py to top-level.
• Turned off numba cacheing on several functions that may be used in the radial solver.
  • rheology
    • complex compliance functions
  • radial_solver.numerical
    • initial guess functions
    • interface functions
• Converted radial_solver.numerical initial guess and interface functions output to np.ndarrays rather than numba lists.
• Removed config_helper.py and the functions defined within.
• New RadialSolver class now supports more than just boolean inputs.
  • Future proofing to allow for a greater variety of layer types.
• Added exoplanet archive download functionality in TidalPy.utilities.exoplanets.

Bug Fixes

• Fixed floating point comparison bug in multilayer_modes solver.
• Fixed obliquity not being used issue in quick tides calculator.
• Fixed issue in incorrect TidalPy version being loaded into the package.

Performance Improvements

• Improved the performance of the stress and strain calculator by ~20%.
• Cythonize Performance Increases:
  • New RadialSolver.radial_solver leads to a ~50x performance boost.
  • New cythonized rheology models are 500% faster for arrays; 40,000% faster for scalars (not a typo!)

Version 0.4.X

Version 0.4.1 Alpha (Spring 2023)

Major Changes

• Moved radial_solver to a top-level module of TidalPy.
  • Added find_love function to the radial_solver module for the calculation of Love and Shida numbers.
  • Added sensitivity_to_shear function to the radial_solver module based on Tobie et al. (2005).
  • Added sensitivity_to_bulk function to the radial_solver module based on Tobie et al. (2005).
• Added newton and elastic complex compliances to rheology module for ALMA comparisons.

Minor Changes

• Updated and added to radial_solver test suite.
• Changed radial_solver.interfaces functions to only require the top most value of the radial solutions rather than the whole array.

Bug Fixes

• Fixed bug in radial_solver where interfaces between a dynamic and static liquid were not correctly handled.

Version 0.4.0 Alpha (Winter 2022/2023)

Major Changes

• Added a multilayer tidal potential that allows for arbitrary obliquity.
• Added in load Love number calculations to the multilayer code.
• Removed a lot of 3rd-party dependencies to make TidalPy's install more lean.
• Switched over to using the integrators from the new CyRK package
  • Changed the signature of the numerical-int multilayer solver.
    • Breaks Old Code
• Issue with Numba 0.55 and dictionary updates. This restricts TidalPy to Python version 3.9 or lower.
• Started a lot of prep work for a move to sphinx or similar for documentation (this will be a 0.5.0 feature).
• Created a generalized multi-layer collapse function in TidalPy.tides.multilayer.numerical_int.collapse.
  • This will likely break old code. It was introduced in v0.4.0.dev10.
  • Arbitrary layer structures can now be fed into the y-solver. e.g., liquid-solid, solid-liquid, liquid-solid-liquid-solid, etc.
    • Note: Multiple dynamic liquid layers will likely lead to stability problems.
  • y-solver no longer requires a model_name variable. The function will automatically utilize the correct model based on the is_layer_solid and is_layer_static lists.
  • Removed the old code that handled individual cases.
• Interfaces between multiple liquid layers are now supported (but not well tested).
  • Two liquid layers of different types can be next to one another (dynamic-static; static-dynamic).
• y-solvers functional argument signature has changed (both regular and numba versions)
  • Breaks Old Code
  • Numerical integrator declaration has changed.
  • Planet_bulk_density is now a required argument.
  • Modified several other TidalPy functions to match this new call signature for the y-solver.
• Removed the y-derivative return from the propagation matrix (to match the output format of the numerical int)
  • Breaks Old Code
• Refactored tidal_y_solver to radial_solver since non-tidal calculations can be made with it.
  • Breaks Old Code (pre v0.4.0.dev11)
• Switched from setup.py to a streamlined pyproject.toml installation process.
• Changes to radial ODE's
  • Input arguments and output diffeqs are now passed as numpy arrays rather than tuples.
  • Input and outputs are now passed as floats not complex (doubling the number of terms)
• Added numba-scipy dependence to allow the use of scipy's special functions.
  • Removed the pre-calculated factorial method. Using scipy's gamma now.
  • TODO: Note the numba-scipy package on github is not updated to the newest version of scipy. Packaging numba-scipy with TidalPy for now.

Performance Improvements

• Improved the performance of the pure-numba radial solve by ~10%

Minor Changes

• Added newer functions to the performance recording suite.
• Improved performance of eccentricity and inclination functions for non-multilayer tidal calculations.
• Added TidalPy to Zenodo. DOI added to readme.
• Removed Gitter account for now.
• Added files and functions to quickly install additional 3rd party applications
• Improvements to GitHub workflows
• Switched over to using the 3rd party cmcrameri colormap package rather than trying to maintain it within tidalpy
• Added a delta time to HH:MM:SS converter to utilities.string_helper
• Made improvements to multiprocessing user info
• Cleaned up & added some docstrings and type hints
• Tidal y solver for the prop matrix method no longer returns the y-derivatives.
  • dy1/dr is now calculated directly in the decompose() function.
• Created a config helper function TidalPy.test_mode() to quickly setup TidalPy configs for pytest'ing
• Cleaned up comments and reordered items in multilayer.numerical_int.collapse.
• Fixed a bug when using SciPy's Radau integrator method.
• The version number is now checked with importlib in TidalPy.init. Version number should only be changed in the pyproject.toml.
• Updated the pure-numba version of the radial solver's argument signature to better match the python implementation.
• Updated Github Actions

Bug Fixes

• Fixed bug in GridPlot related to number of subplots.
• Fixed bug in global variable for world config loader.
• Fixed type hint bug in the numba-based tidal y solver.
• Fixed bug that caused numba-based tidal y solver to not compile.
• Fixed bug that was causing full TidalPy log to print while in a Jupyter Notebook environment.
  • If you would like the log to print in a notebook then use TidalPy.toggle_log_print_in_jupyter() or set the print_log_in_jupyter to True in the "configurations.py" file.
• Fixed an error in the multimode volumetric heating calculation where "_rr", "_thth", "_phiphi" were being double counted
• Fixed an error in the stress/strain calculations where the static, instead of complex, shear was being used.

Version 0.3.X

Version 0.3.5 Alpha (Spring 2022)

Minor Changes

• Removed the soon-to-be deprecated np.float, np.complex, np.int references.
• Added a check to see if cartopy is installed before functions that depend on it are imported.

Bug Fixes

• Fixed coverage problem with github actions.
• Fixed issue importing nbTuple.
• Fixed issues with GitHub actions and coverage.

Version 0.3.4 Alpha (Winter/Spring 2022)

Multilayer scripts based on 0.3.3 or earlier will likely break with this version!

Major Changes

• Added TidalPy.modes.multilayer_modes.py module to offer simplified calculation of multilayer tidal heating.
• Added GridPlot class to quickly make grid-like matplotlib figures. Checkout TidalPy.utilities.graphics.grid_plot.py
• Added Cartopy dependence.
  • Can now make cool projection maps! Added basic functionality to TidalPy.utilities.graphics.global_map.py.
  • New jupyter notebooks to showcase map projects and GridPlot functionality.
• Improved performance on both mode and non-mode tidal potential functions by at least a factor of 3. If used correctly these can be nearly 100x faster.
• Added a new obliquity version of the mode version tidal potential.
• Stress and strain relationship for multi-layer tides now allows for arbitrary rheology.
• Created a single multilayer solver to handle an arbitrary layer structure. See TidalPy.tides.multilayer.numerical_int.solver.py
• Stress & Strain relationship now accounts for arbitrary rheology.
• Created a single multi-mode solver for multilayer problems. See TidalPy.tides.modes.multilayer_modes.py
• TidalPy now defaults to using the frequency dependent zeta versions of Andrade and Sundberg rheologies.
  • This was done to avoid issues with real(complex_comp) at zero frequency which happens in multi mode calculations.
• Added numba-safe version of multilayer calc

Minor Changes

• Added a helper function to quickly calculate masses, volumes, and gravity for spherical shells provided a radius and density array: TidalPy.utilities.spherical_helper.calculate_mass_gravity_arrays.
• Added more colormaps, updated how reserved versions are constructed, updated old maps.
• Better support for post-multiprocessing function inputs.
• Refactored tidal mode calculation functions into a new TidalPy.tides.modes module.
• Added a voxel calculator to TidalPy.utilities.spherical_helper. Also, added related tests & benchmarking tools.
• Added a dictionary to track known color maps. It can be imported at TidalPy.utilities.cmaps.KNOWN_CMAPS
• Made some improvements to the unique_path function in io_helper.py
• Rearranged the tidal potential argument order.
• Added some sanity checks on the various kinds on both mode and non-mode tidal potentials to compare with one another.
• Updated stress, strain, and displacement calculations to account for new low-memory calculation method.
• Greatly increased performance of multilayer stress, strain, and potential calculations.
• Refactored much of the multilayer functions from TidalPy.toolbox to TidalPy.tides.multilayer.numerical_int and sub modules
• Reworked numba-safe RK integrator. Does not reproduce scipy exactly for chaotic functions when numba is on.

Bug Fixes

• Fixed issue that was causing some multilayer boundary calculations to be 10x slower.
• Fixed issue where 2D arrays would not work on njited neg_array_for_log_plot function.
• Fixed issue where there could be negative love numbers with frequency is zero in multi-mode calculator

Version 0.3.3 Alpha (Fall 2021)

Major Changes

• Updated to work with BurnMan v1.0 release.
• Updated the NSR tidal potential for multilayer code to a multi-modal version
• Improvements to the multilayer module

Minor Changes

• Added more tests
• Removed the remaining _array functions

Version 0.3.2 Alpha (Summer 2021)

Major Changes

• Changes to setup to use released version of BurnMan.

Version 0.3.1 Alpha (Summer 2021)

Major Changes

• Added a simplistic (not modal version) NSR tidal potential for use in the multilayer code.
• Added multiprocessor toolkit to TidalPy.utilities.multiprocessing

Minor Changes

• Did large scale code reformatting (just style, no refactoring) on nearly all files.
• Cleaned up some doc strings.

Version 0.3.0 Alpha (Spring 2021)

Scripts based on 0.2.x will likely break with this version!

Major Changes:

• Added the first iteration of a multilayer tidal calculator module in TidalPy.tides.multilayer this module provides basic functionality to calculate tidal dissipation in a semi-homogeneous, shell-based approach. This is more accurate than the pure homogeneous model used throughout the rest of TidalPy. The downside with the current version is that it does not allow for NSR or high eccentricity / obliquity. A future version will attempt to add in a more robust Tidal Potential equation which will allow for additional physics.
• Setup.py has been revamped as has the installation process. This is in prep to allow for TidalPy to become available on PyPI.
• Did away with most of the _array functions. Found a way for njit to compile a function to handle either arrays or floats.
  • Left the self._func_array (in addition to self._func) in the model.py classes just in case we ever ** do** need to define array functions in the future: all the infrastructure is still in place.
• Added a numba-safe Explicit Runge-Kutta integrator. This is fully wrapped in njit'd functions.
  • On its own this can be 5--20 times faster than scipy.solve_ivp.
  • This also allows the integration function to be used from within another njit'd function(s).
  • This is still very experimental so please use caution and testing when using it.

Minor Changes

• Numerous bug fixes.
• Removed the array versions of the dynamic functions.
  • use_array is still tracked in OOP and some quick calculation functions. These may all be not necessary now.
• New cookbook to showcase the multilayer calculations.
• Added surface area slices to base physical class.
• Fixed some issues with how radius slices are tracked within layers and worlds.
  • <world/layer>.radii[0] is never the radius at the bottom of the object, it is always one dx up.
  • An interpolation had to be added to Burnman layers since Burnman radii starts at 0.
• Improved various docstrings.
• Refactored the TidalPy.tools to TidalPy.toolbox.
• Refactored Cookbooks to Demos.
• conversions.semi_a2orbital_motion and orbital_motion2semi_a now always return np.nan where they used to return complex numbers.

Version 0.2.X

Version 0.2.1 Alpha (Fall 2020)

Will break studies based on previous versions

Note: TidalPy version of "0.2.0" was never made publicly available. This is the next version after 0.1.0.

Major Changes

• Major refactoring all over.
• Replaced the custom logging system with one based on Python's logging package.
  • Logger will not print to console if using a Jupyter notebook.
  • User can decide if the log is saved to disk or not.
• Modified OOP Backend
  • Models are now free to access the state properties of layers and planets. This eliminates the need to pass arguments into model classes for calculations. All the user has to do is change the layer and/or planet's state properties and then those changes will automatically propagate.
• New Rheology Scheme
  • To better follow real physics, all strength-based models have been moved under the redesigned Rheology class.
  • This includes: liquid and solid viscosity calculations, partial melting, and complex compliance
  • Love numbers are now calculated by a new Tides class instead of the Rheology (see next bullet point).
• New Tides Module
  • New Tides class and child classes have been implemented which handle all Love number and tidal calculations for both a rheology-based approach or for the CPL/CTL model.
  • This module contains functionality to calculate tidal heating and tidal potential derivatives based on a complex compliance function and the various thermal and orbital parameters.
  • The functions to calculate the Love numbers are also stored here.
  • New eccentricity functions have been added including terms up to and including e^20 and tidal order l=7.
  • New inclination functions have been added (with arbitrary accuracy) up to tidal order l=7.
• Other
  • Various functions and classes have been reworked or removed to simplify the code base.

Minor Changes

• Removed ".pyname" from classes.
• Utilities package has been reorganized.
• Changed the setup pipeline to only require one command.

QOL Improvements

• Many new docstrings, type hints, and overall clean up of functions and classes. All docstrings should now follow the numpy format.
• Many new tests for both the functional and OOP versions of TidalPy.
• setup.py no longer requires a separate command line call to install the Burnman package.
• More comments and spelling/typo fixes everywhere.
• Added CVD-friendly color maps made by Crameri (2018; http://doi.org/10.5281/zenodo.1243862) to the utilities.graphics module
• More log.debug() calls all over. This should hopefully help bugfixes in the future (especially OOP bugs).

Bug Fixes:

• Fixed bug in world_builder.py : build_from_world where nested dicts were not being overwritten as expected.
• Fixed bug in melt fraction checks for the float version of the Henning model.
• Fixed bug in the Henning melting model where viscosity and shear was not being calculated correctly during the breakdown band (critical melt fraction + ~5%). This only affected a phase space that was rarely important for tidal calculations (planets would pass through it very quickly).

Version 0.1.X

Version 0.1.0 Alpha (July 2019)

Initial Release - Changes not tracked