{ "cells": [ { "cell_type": "markdown", "id": "ea9fce43", "metadata": {}, "source": [ "# Love Number Sensitivity\n", "In this cookbook we will explore how we can use TidalPy's multilayer functions to estimate the response of a planet to tidal or other loading stresses via the complex Love numbers.\n", "\n", "**References**:\n", "- SVC16 : Sabadini, Vermeerson, & Cambiotti (2016), DOI: [10.1007/978-94-017-7552-6](https://doi.org/10.1007/978-94-017-7552-6).\n", "- HH14 : Henning & Hurford (2014), DOI: [10.1088/0004-637X/789/1/30](https://doi.org/10.1088/0004-637X/789/1/30).\n", "- TB05 : Tobie et al. (2005), DOI: [10.1016/j.icarus.2005.04.006](https://doi.org/10.1016/j.icarus.2005.04.006).\n", "- S74 : Saito (1974), DOI: [10.4294/jpe1952.22.123](https://doi.org/10.4294/jpe1952.22.123).\n", "- TS72 : Takeuchi & Saito (1972), DOI: [10.1016/B978-0-12-460811-5.50010-6](http://dx.doi.org/10.1016/B978-0-12-460811-5.50010-6).\n", "- KMN15 : Kamata et al. (1972), DOI: [10.1002/2015JE004821](http://dx.doi.org/10.1002/2015JE004821).\n", "- M16 : Martens (2016, [PhD Thesis](https://resolver.caltech.edu/CaltechTHESIS:04102016-211741759)), DOI: [10.7907/Z9N29TX7](http://dx.doi.org/10.7907/Z9N29TX7).\n", "- ID : [IcyDwarf Code](https://github.com/MarcNeveu/IcyDwarf/blob/master/IcyDwarf/Thermal.h) written by Marc Neveu." ] }, { "cell_type": "code", "execution_count": 1, "id": "c1beac1e", "metadata": {}, "outputs": [], "source": [ "import sys\n", "import time\n", "from functools import lru_cache\n", "\n", "import numpy as np\n", "from ipywidgets import interact, widgets\n", "import matplotlib.pyplot as plt\n", "%matplotlib widget\n", "\n", "# Load TidalPy's Helper Functions\n", "from TidalPy.utilities.conversions import days2rads\n", "from TidalPy.utilities.spherical_helper import calculate_mass_gravity_arrays\n", "\n", "# Load TidalPy's Rheology Functions\n", "from TidalPy.rheology import Maxwell, Burgers, Andrade, Sundberg, Newton, Elastic\n", "\n", "# Load TidalPy's RadialSolver Module\n", "from TidalPy.RadialSolver import radial_solver, build_rs_input_homogeneous_layers\n", "\n", "rheologies = {\n", " 'Maxwell': Maxwell,\n", " 'Burgers': Burgers,\n", " 'Andrade': Andrade,\n", " 'Sundberg-Cooper': Sundberg,\n", " 'Newton': Newton,\n", " 'Elastic': Elastic\n", "}\n", "\n", "integration_method = \"RK45\"\n", "\n", "widget_styles = {\n", " 'layout': {'width': '50%'},\n", " 'style': {'description_width': 'initial'}\n", "}\n", "\n", "def clear_line():\n", " # Can't get ANSI escape codes to work properly in Jupyter so this is a hack.\n", " # The ANSI code would be \"\\033[1A\\033[K\"\n", " print('\\r ', end='\\r')\n", "\n", "common_kwargs = dict(\n", " degree_l = 2,\n", " solve_for = None,\n", " starting_radius = 0.0,\n", " start_radius_tolerance = 1.0e-5,\n", " nondimensionalize = True,\n", " # Shooting method parameters\n", " use_kamata = True,\n", " integration_method = 'DOP853',\n", " integration_rtol = 1.0e-5,\n", " integration_atol = 1.0e-8,\n", " scale_rtols_bylayer_type = False,\n", " max_num_steps = 500_000,\n", " expected_size = 1000,\n", " max_ram_MB = 500,\n", " max_step = 0,\n", " # Propagation matrix method parameters\n", " use_prop_matrix = False,\n", " core_model = 0,\n", " # Equation of State solver parameters\n", " eos_method_bylayer = None,\n", " surface_pressure = 0.0,\n", " eos_integration_method = 'DOP853',\n", " eos_rtol = 1.0e-3,\n", " eos_atol = 1.0e-5,\n", " eos_pressure_tol = 1.0e-3,\n", " eos_max_iters = 40,\n", " # Error and log reporting\n", " verbose = False,\n", " warnings = False,\n", " raise_on_fail = False,\n", " perform_checks = True,\n", " log_info = False\n", ")\n" ] }, { "cell_type": "markdown", "id": "1ecdb927", "metadata": {}, "source": [ "## Setup functions" ] }, { "cell_type": "code", "execution_count": 2, "id": "c6f41cb4", "metadata": {}, "outputs": [], "source": [ "def calculate_planet(build_func, **build_func_kwargs):\n", " \n", " # Get basic info to setup the plot\n", " radius_fraction_tuple, rs_input_original = build_func('Elastic', 0.0, \n", " False, False, False, False,\n", " **build_func_kwargs)\n", "\n", " planet_frequency = rs_input_original.frequency\n", " \n", " planet_radius = rs_input_original.radius_array[-1]\n", " radius_km = rs_input_original.radius_array / 1000.\n", " original_ic_frac = radius_fraction_tuple[0]\n", " original_oc_frac = radius_fraction_tuple[1]\n", " \n", " # Setup figure\n", " fig, axes = plt.subplots(figsize=(11, 7), ncols=3, nrows=2, sharey='all')\n", " plt.subplots_adjust(hspace=0.5, wspace=0.3)\n", " plt.show()\n", " tidal_lines = list()\n", " loading_lines = list()\n", " icb_lines = list()\n", " cmb_lines = list()\n", " twin_axes = list()\n", " for ax_i, ax in enumerate(axes.flatten()):\n", " ax2 = ax.twiny()\n", " twin_axes.append(ax2)\n", " if ax_i in [0, 3]:\n", " ax.set(ylabel='Radius [km]')\n", " ax.set(xlabel='$y_{' + f'{ax_i+1}' + '}$')\n", " tidal_lines.append((\n", " ax.plot([0], [0], c='blue', label='Tidal', ls='-')[0],\n", " ax2.plot([0], [0], c='blue', ls=':')[0]\n", " ))\n", " loading_lines.append((\n", " ax.plot([0], [0], c='orange', label='Loading', ls='-')[0],\n", " ax2.plot([0], [0], c='orange', ls=':')[0]\n", " ))\n", " icb_lines.append(ax.axhline(0, c='k', ls='--'))\n", " cmb_lines.append(ax.axhline(0, c='k', ls='--'))\n", " \n", "# @lru_cache\n", " def update_calculations(rheology_name, forcing_period, degree_l,\n", " inner_core_frac, outer_core_frac,\n", " solid_dynamic, liquid_dynamic, solve_load_numbers,\n", " integration_atol, integration_rtol):\n", " # Use pre-defined frequency or user-defined\n", " if forcing_period == 0.:\n", " # Pre-defined\n", " frequency = planet_frequency\n", " else:\n", " # Use user-defined\n", " frequency = days2rads(forcing_period)\n", " \n", " # Rebuild planet with updated inner and outer core radii\n", " solid_incompressible = False\n", " liquid_incompressible = True\n", " radius_fraction_tuple, rs_input = build_func(rheology_name, frequency,\n", " solid_dynamic, liquid_dynamic, solid_incompressible, liquid_incompressible,\n", " inner_core_radius=inner_core_frac*planet_radius,\n", " outer_core_radius=outer_core_frac*planet_radius,\n", " **build_func_kwargs)\n", "\n", " solve_for = ['tidal']\n", " if solve_load_numbers:\n", " solve_for.append('loading')\n", " \n", " # Calculate radial solution\n", " integration_rtol = 10**integration_rtol\n", " integration_atol = 10**integration_atol\n", "\n", " specific_kwargs = {**common_kwargs}\n", " specific_kwargs['integration_rtol'] = integration_rtol\n", " specific_kwargs['integration_atol'] = integration_atol\n", " specific_kwargs['integration_method'] = integration_method\n", " specific_kwargs['solve_for'] = tuple(solve_for)\n", " specific_kwargs['degree_l'] = degree_l\n", "\n", " solution = radial_solver(*rs_input, **specific_kwargs)\n", " \n", " assert solution.success\n", " return solution\n", " \n", " def update(rheology_name, forcing_period, degree_l,\n", " inner_core_frac, outer_core_frac,\n", " solid_dynamic, liquid_dynamic, solve_load_numbers,\n", " integration_atol, integration_rtol):\n", "\n", " if inner_core_frac >= outer_core_frac:\n", " inner_core_frac = 0.99 * outer_core_frac\n", " if outer_core_frac <= inner_core_frac:\n", " outer_core_frac = 1.01 * inner_core_frac\n", " \n", " # Perform calculations\n", " clear_line()\n", " print('Calculating Radial Solution...', end='\\r')\n", " t0 = time.time()\n", " solution = update_calculations(rheology_name, forcing_period, degree_l,\n", " inner_core_frac, outer_core_frac,\n", " solid_dynamic, liquid_dynamic, solve_load_numbers,\n", " integration_atol, integration_rtol)\n", " delta_t = time.time() - t0\n", " clear_line()\n", " out_str = f'Completed in: {delta_t:0.4f}s. Degree l = {degree_l}. '\n", " if solve_load_numbers:\n", " k_tidal = solution.k[0]\n", " k_load = solution.k[1]\n", " h_tidal = solution.h[0]\n", " h_load = solution.h[1]\n", " l_tidal = solution.l[0]\n", " l_load = solution.l[1]\n", " out_str += f'Tidal k, h, l = {np.real(k_tidal):0.3f}, {np.real(h_tidal):0.3f}, {np.real(l_tidal):0.3f}. '\n", " out_str += f'Load k, h, l = {np.real(k_load):0.3f}, {np.real(h_load):0.3f}, {np.real(l_load):0.3f}.'\n", " print(out_str, end='\\r')\n", " else:\n", " k_tidal = solution.k\n", " h_tidal = solution.h\n", " l_tidal = solution.l\n", " out_str += f'Tidal k, h, l = {np.real(k_tidal):0.3f}, {np.real(h_tidal):0.3f}, {np.real(l_tidal):0.3f}.'\n", " print(out_str, end='\\r')\n", " \n", "# # Update plot axis\n", "# ax_radial.clear()\n", "# ax_tang.clear()\n", " \n", " # Update ICB/CMB reference lines\n", " for icb_line, cmb_line in zip(icb_lines, cmb_lines):\n", " icb_line.set_ydata([inner_core_frac*planet_radius/1000., inner_core_frac*planet_radius/1000.])\n", " cmb_line.set_ydata([outer_core_frac*planet_radius/1000., outer_core_frac*planet_radius/1000.])\n", "\n", " # Update Tidal Results\n", " for t_i, tidal_line_tuple in enumerate(tidal_lines):\n", " if solve_load_numbers:\n", " x_data = solution.result[t_i, :]\n", " else:\n", " x_data = solution.result[t_i, :]\n", " tidal_line_tuple[0].set_data(np.real(x_data), solution.radius_array/1000.)\n", " tidal_line_tuple[1].set_data(np.imag(x_data), solution.radius_array/1000.)\n", " \n", " # Update Loading Results\n", " for t_i, loading_line_tuple in enumerate(loading_lines):\n", " if solve_load_numbers:\n", " x_data = solution.result[t_i, :]\n", " loading_line_tuple[0].set_data(np.real(x_data), solution.radius_array/1000.)\n", " loading_line_tuple[1].set_data(np.imag(x_data), solution.radius_array/1000.)\n", " else:\n", " loading_line_tuple[0].set_data([0], [0])\n", " loading_line_tuple[1].set_data([0], [0])\n", " \n", " # Update limits\n", " for ax_i, ax in enumerate(axes.flatten()):\n", " ax.relim()\n", " ax.autoscale_view()\n", " for ax_i, ax in enumerate(twin_axes):\n", " ax.relim()\n", " ax.autoscale_view()\n", " \n", " # Reshow plot\n", " fig.canvas.draw()\n", " \n", " # Setup interactive plot\n", " interact(update,\n", " rheology_name = widgets.Dropdown(\n", " options=['Maxwell', 'Burgers', 'Andrade', 'Sundberg-Cooper'],\n", " value='Andrade',\n", " description='Rheology:',\n", " disabled=False, **widget_styles\n", " ),\n", " forcing_period = widgets.IntSlider(\n", " min=0,\n", " max=50,\n", " step=1,\n", " value=6,\n", " description='Forcing Period [Days]:', **widget_styles\n", " ),\n", " degree_l = widgets.IntSlider(\n", " min=2,\n", " max=5,\n", " step=1,\n", " value=2,\n", " description='Degree $l$:', **widget_styles\n", " ),\n", " inner_core_frac = widgets.FloatSlider(\n", " value=original_ic_frac,\n", " min=0.05,\n", " max=0.9,\n", " step=0.01,\n", " description='IC-Fraction',\n", " disabled=False,\n", " readout_format='.2f',\n", " indent=False, **widget_styles\n", " ),\n", " outer_core_frac = widgets.FloatSlider(\n", " value=original_oc_frac,\n", " min=0.15,\n", " max=0.95,\n", " step=0.01,\n", " description='OC-Fraction',\n", " disabled=False,\n", " readout_format='.2f',\n", " indent=False, **widget_styles\n", " ),\n", " solid_dynamic = widgets.Checkbox(\n", " value=False,\n", " description='Dynamic Solid',\n", " disabled=False,\n", " indent=False, **widget_styles\n", " ),\n", " liquid_dynamic = widgets.Checkbox(\n", " value=False,\n", " description='Dynamic Liquid (Unstable!)',\n", " disabled=False,\n", " indent=False, **widget_styles\n", " ),\n", " solve_load_numbers = widgets.Checkbox(\n", " value=False,\n", " description='Solve Load Numbers',\n", " disabled=False,\n", " indent=False, **widget_styles\n", " ),\n", " integration_atol = widgets.IntSlider(\n", " min=-18,\n", " max=-3,\n", " step=1,\n", " value=-7,\n", " description='Integration atol ($10^{x}$):', **widget_styles\n", " ), \n", " integration_rtol = widgets.IntSlider(\n", " min=-18,\n", " max=-3,\n", " step=1,\n", " value=-6,\n", " description='Integration rtol ($10^{x}$):', **widget_styles\n", " ),\n", " )" ] }, { "cell_type": "markdown", "id": "f1d09651", "metadata": {}, "source": [ "## Four Layer Planet (Mercury-like)" ] }, { "cell_type": "code", "execution_count": 3, "id": "94742422", "metadata": {}, "outputs": [], "source": [ "from math import floor\n", "\n", "def build_four_layer(rheology_name, frequency,\n", " solid_dynamic, liquid_dynamic, solid_incompressible, liquid_incompressible,\n", " inner_core_radius=None, outer_core_radius=None, crust_radius=None, quasi_liquid=False):\n", " # Numerical Settings\n", " N = 50\n", "\n", " # Build Planet\n", " # # Radius\n", " if inner_core_radius is None:\n", " inner_core_radius = 1500.0e3\n", " if outer_core_radius is None:\n", " outer_core_radius = 2000.0e3\n", " if crust_radius is None:\n", " crust_radius = 2440.0e3\n", " mantle_radius = crust_radius - 100.0e3\n", " planet_radius = crust_radius\n", " \n", " # User may have provided unrealistic IC/OC fractions. Fix those here\n", " if inner_core_radius < 1.e3:\n", " inner_core_radius = 1.e3\n", " if outer_core_radius < 3.e3:\n", " outer_core_radius = 3.e3\n", " if inner_core_radius >= (outer_core_radius - 1.e3):\n", " inner_core_radius = outer_core_radius - 1.e3\n", " if outer_core_radius >= (mantle_radius - 1.e3):\n", " outer_core_radius = mantle_radius - 1.e3\n", " radius_fraction_tuple = (floor(1000*inner_core_radius/crust_radius)/1000,\n", " floor(1000*outer_core_radius/crust_radius)/1000,\n", " floor(1000*mantle_radius/crust_radius)/1000,\n", " floor(1000*crust_radius/crust_radius)/1000)\n", "\n", " # Build RS inputs\n", " if quasi_liquid:\n", " layer_types = (\"solid\", \"solid\", \"solid\", \"solid\")\n", " else:\n", " layer_types = (\"solid\", \"liquid\", \"solid\", \"solid\")\n", " layer_is_static_tuple = (not solid_dynamic, not liquid_dynamic, not solid_dynamic, not solid_dynamic)\n", " layer_is_incompressible_tuple = (solid_incompressible, liquid_incompressible, solid_incompressible, solid_incompressible)\n", "\n", " shear_rheology_list = list()\n", " bulk_rheology_list = list()\n", " for i in range(4):\n", " shear_rheology_list.append(rheologies[rheology_name]())\n", " bulk_rheology_list.append(rheologies['Elastic']())\n", "\n", " density_tuple = (8750., 7850., 3200., 2600.)\n", " static_shear_modulus_tuple = (100.0e9, 0.0, 50.0e9, 10.0e9)\n", " static_bulk_modulus_tuple = (199.0e9, 80.0e9, 120.0e9, 90.0e9)\n", " shear_viscosity_tuple = (1.0e24, 1.0e3, 1.0e20, 1.0e26)\n", " bulk_viscosity_tuple = (1.0e30, 1.0e30, 1.0e30, 1.0e30)\n", "\n", " if frequency == 0.0:\n", " forcing_frequency = days2rads(87.96926)\n", " else:\n", " forcing_frequency = frequency\n", " \n", " rs_input = build_rs_input_homogeneous_layers(\n", " planet_radius,\n", " forcing_frequency,\n", " density_tuple,\n", " static_bulk_modulus_tuple,\n", " static_shear_modulus_tuple,\n", " bulk_viscosity_tuple,\n", " shear_viscosity_tuple,\n", " layer_types,\n", " layer_is_static_tuple,\n", " layer_is_incompressible_tuple,\n", " tuple(shear_rheology_list),\n", " tuple(bulk_rheology_list),\n", " radius_fraction_tuple = radius_fraction_tuple,\n", " thickness_fraction_tuple = None,\n", " volume_fraction_tuple = None,\n", " slices_tuple = None,\n", " slice_per_layer = N,\n", " perform_checks = True)\n", "\n", " return radius_fraction_tuple, rs_input" ] }, { "cell_type": "code", "execution_count": 5, "id": "a5632030", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "122b0575c3d14537b01c216e0b756805", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "9a91ce1719214d8e93d701b7d9cfbf13", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(Dropdown(description='Rheology:', index=2, layout=Layout(width='50%'), options=('Maxwell…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Run Model!\n", "calculate_planet(build_four_layer)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.12" } }, "nbformat": 4, "nbformat_minor": 5 }