invert_eos_table_den_temp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Generate tables in density and temperatures for the extended SCvH EOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "The original SCvH EOS table was extended to lower temperatures (and pressures?). However, these tables use $(P, T)$ as variables which is not useful for applications in hydro codes. \n",
    "\n",
    "We therefore have to invert $\\rho \\left( P, T \\right)$ to $ P\\left( \\rho, T \\right)$ by solving\n",
    "$$ \\rho \\left( P, T=const \\right) - \\rho_i = 0$$\n",
    "for a grid of $\\rho_i$ using a root finder. The notebook uses the brent root finder and different interpolation (and extrapolation) methods.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "from scipy import interpolate as interp\n",
    "from scipy import optimize\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "%config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mpl.rcParams['figure.dpi'] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert units from cgs to SI:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "press_unit_si = 0.1        # erg/cm^3 in Pascal\n",
    "spec_energy_unit_si = 1e4  # erg/g in J/kg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.loadtxt(\"hydrogen_scvh_extended.data\") \n",
    "\n",
    "logT_table   = data[:, 0] \n",
    "logP_table   = data[:, 1]\n",
    "frac_H2      = data[:, 2]\n",
    "frac_H       = data[:, 3]\n",
    "logrho_table = data[:, 4]\n",
    "logu_table   = data[:, 5]\n",
    "logs_table   = data[:, 6]\n",
    "\n",
    "# All the SCvH EOS tables are tabulated along isotherms\n",
    "logT_table_axis = np.unique(logT_table)\n",
    "nT = np.size(logT_table_axis)\n",
    "\n",
    "print(\"Number of isotherms: nT = {:}\".format(nT))\n",
    "\n",
    "# The number of grid points in P are different for each isotherm\n",
    "logP_table_axis = list()\n",
    "logrho_isotherm = list()\n",
    "logu_isotherm = list()\n",
    "logs_isotherm = list()\n",
    "\n",
    "for logT in logT_table_axis:\n",
    "    logP_table_axis.append(logP_table[np.where(logT_table == logT)])\n",
    "    logrho_isotherm.append(logrho_table[np.where(logT_table == logT)])\n",
    "    logu_isotherm.append(logu_table[np.where(logT_table == logT)])\n",
    "    logs_isotherm.append(logs_table[np.where(logT_table == logT)])\n",
    "\n",
    "logT_min = np.min(logT_table_axis)\n",
    "logT_max = np.max(logT_table_axis)\n",
    "\n",
    "print(\"logT_min = {:}\".format(logT_min))\n",
    "print(\"logT_max = {:}\".format(logT_max))\n",
    "print()\n",
    "\n",
    "# Mark where the original SCvH EOS table was extended below T=100K\n",
    "index = np.min(np.where(logT_table_axis >= 2.0))\n",
    "print(\"The EOS table was extended until index={:} logT={:}\".format(index, logT_table_axis[index]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the min and max density of each isotherm\n",
    "logrho_min = list()\n",
    "logrho_max = list()\n",
    "\n",
    "for i in range(nT):\n",
    "    logrho_min.append(np.min(logrho_isotherm[i]))\n",
    "    logrho_max.append(np.max(logrho_isotherm[i]))\n",
    "    \n",
    "    #print(\"i={:} logT={:} (T={:}): logrho_min={:} logrho_max={:}\".format(i, logT_table_axis[i], pow(10.0, logT_table_axis[i]), logrho_min[i], logrho_max[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate interpolation functions for each isotherm\n",
    "\n",
    "logrho_of_logP_int = list()\n",
    "logu_of_logP_int = list()\n",
    "logs_of_logP_int = list()\n",
    "\n",
    "for i in range(0, nT):\n",
    "    logrho_of_logP_int.append(interp.InterpolatedUnivariateSpline(logP_table_axis[i], logrho_isotherm[i], k=1, ext='extrapolate'))\n",
    "    logu_of_logP_int.append(interp.InterpolatedUnivariateSpline(logP_table_axis[i], logu_isotherm[i], k=1, ext='extrapolate'))\n",
    "    logs_of_logP_int.append(interp.InterpolatedUnivariateSpline(logP_table_axis[i], logs_isotherm[i], k=1, ext='extrapolate'))\n",
    "    \"\"\"\n",
    "    logrho_of_logP_int.append(interp.CubicSpline(logP_table_axis[i], logrho_isotherm[i], extrapolate=True))\n",
    "    logu_of_logP_int.append(interp.CubicSpline(logP_table_axis[i], logu_isotherm[i], extrapolate=True))\n",
    "    logs_of_logP_int.append(interp.CubicSpline(logP_table_axis[i], logs_isotherm[i], extrapolate=True))\n",
    "    \"\"\"\n",
    "    \"\"\"\n",
    "    logrho_of_logP_int.append(interp.PchipInterpolator(logP_table_axis[i], logrho_isotherm[i], extrapolate=True))\n",
    "    logu_of_logP_int.append(interp.PchipInterpolator(logP_table_axis[i], logu_isotherm[i], extrapolate=True))\n",
    "    logs_of_logP_int.append(interp.PchipInterpolator(logP_table_axis[i], logs_isotherm[i], extrapolate=True))\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First plot the table and check if the result looks sensible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skip some curves otherwise the plots are very hard to read\n",
    "nSkipT = 5\n",
    "nSkipRho = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot log(rho), log(u) and log(s)\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "# rho(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[0][0].plot(logP_table_axis[i], logrho_isotherm[i], '-')\n",
    "    \n",
    "ax[0][0].plot(logP_table_axis[0], logrho_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[0][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(rho) [g cm^${-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "#plt.gca().set_prop_cycle(None)\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[0][1].plot(logP_table_axis[i], logrho_isotherm[i], '-')\n",
    "\n",
    "#plt.gca().set_prop_cycle(None)\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[0][1].plot(logP, logrho_of_logP_int[i](logP), '--')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(rho) [g cm^${-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# u(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[1][0].plot(logP_table_axis[i], logu_isotherm[i], '-')\n",
    "    \n",
    "ax[1][0].plot(logP_table_axis[0], logu_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[1][1].plot(logP_table_axis[i], logu_isotherm[i], '-')\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[1][1].plot(logP, logu_of_logP_int[i](logP), '--')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[2][0].plot(logP_table_axis[i], logs_isotherm[i], '-')\n",
    "    \n",
    "ax[2][0].plot(logP_table_axis[0], logs_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[2][1].plot(logP_table_axis[i], logs_isotherm[i], '-')\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[2][1].plot(logP, logs_of_logP_int[i](logP), '--')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot extrapolated log(rho), log(u) and log(s)\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "logP_axis_extrap = np.linspace(-10, 25)\n",
    "\n",
    "# rho(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[0][0].plot(logP_table_axis[i], logrho_isotherm[i], '-')\n",
    "    \n",
    "ax[0][0].plot(logP_table_axis[0], logrho_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[0][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(rho) [g cm^${-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "#plt.gca().set_prop_cycle(None)\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[0][1].plot(logP_table_axis[i], logrho_isotherm[i], '-')\n",
    "\n",
    "#plt.gca().set_prop_cycle(None)\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[0][1].plot(logP_axis_extrap, logrho_of_logP_int[i](logP_axis_extrap), '--')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(rho) [g cm^${-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# u(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[1][0].plot(logP_table_axis[i], logu_isotherm[i], '-')\n",
    "    \n",
    "ax[1][0].plot(logP_table_axis[0], logu_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[1][1].plot(logP_table_axis[i], logu_isotherm[i], '-')\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[1][1].plot(logP_axis_extrap, logu_of_logP_int[i](logP_axis_extrap), '--')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(P, T=const)\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[2][0].plot(logP_table_axis[i], logs_isotherm[i], '-')\n",
    "    \n",
    "ax[2][0].plot(logP_table_axis[0], logs_isotherm[0], '--', color='black', label=r\"T$_{min}$\")\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# Interpolated for T=const.\n",
    "for i in range(0, nT, nSkipT):\n",
    "    ax[2][1].plot(logP_table_axis[i], logs_isotherm[i], '-')\n",
    "\n",
    "for i in range(0, nT, nSkipT):\n",
    "    logP = np.linspace(np.min(logP_table_axis[i]), np.max(logP_table_axis[i]), 1000)\n",
    "    ax[2][1].plot(logP_axis_extrap, logs_of_logP_int[i](logP_axis_extrap), '--')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(P) [erg cm$^{-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def func_logrho(logP, logrho_of_logP_int, logrho_i):\n",
    "    \"\"\"\n",
    "    Calculate logrho(logP, logT=const) - logrho_i.\n",
    "    \"\"\"\n",
    "    return logrho_of_logP_int(logP)-logrho_i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test if root finding works\n",
    "logrho_of_logP = logrho_of_logP_int[0]\n",
    "logrho_int = logrho_isotherm[0][1]\n",
    "\n",
    "logP_min = np.min(logP_table_axis[0])\n",
    "logP_max = np.max(logP_table_axis[0])\n",
    "\n",
    "print(logP_min)\n",
    "print(logP_max)\n",
    "\n",
    "\n",
    "\n",
    "sol = optimize.root_scalar(func_logrho, args=(logrho_of_logP_int[0], logrho_isotherm[0][1]), bracket=[-100, 100], method='brentq')\n",
    "\n",
    "logP_of_logrho = sol.root\n",
    "\n",
    "print(\"rho= {:}: P= {:} err= {:}\".format(logrho_int, logP_of_logrho, (logP_of_logrho-logP_table_axis[0][1])/logP_of_logrho))\n",
    "#sol = optimize.root_scalar(func_logrho, args=(logrho_of_logP, logrho_int), bracket=[0, 100], method='brentq')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invert an isotherm from logrho(logP) to logP(logrho)\n",
    "def inv_isotherm_logrho(logrho_axis, logrho_of_logP_int, logP_min=-100, logP_max=100):\n",
    "    nRho = np.size(logrho_axis)\n",
    "    \n",
    "    logP_of_logrho = np.zeros(nRho)\n",
    "    \n",
    "    # This is shitty but it seems that root_scalar does not work with an array of inputs\n",
    "    for i in range(nRho):\n",
    "        sol = optimize.root_scalar(func_logrho, args=(logrho_of_logP_int, logrho_axis[i]), bracket=[logP_min, logP_max], method='brentq')\n",
    "        logP_of_logrho[i] = sol.root\n",
    "        \n",
    "    return logP_of_logrho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test the function inv_isotherm_logrho()\n",
    "index = 0\n",
    "\n",
    "logrho_of_logP = logrho_of_logP_int[index]\n",
    "logrho_int = logrho_isotherm[index][1]\n",
    "\n",
    "logP_min = np.min(logP_table_axis[index])\n",
    "logP_max = np.max(logP_table_axis[index])\n",
    "\n",
    "logrho_min = np.min(logrho_isotherm[index])\n",
    "logrho_max = np.max(logrho_isotherm[index])\n",
    "\n",
    "print(\"logP_min= {:} logP_max= {:}\".format(logP_min, logP_max))\n",
    "print(\"logrho_min= {:} logrho_max= {:}\".format(logrho_min, logrho_max))\n",
    "\n",
    "\n",
    "logrho_axis = np.linspace(logrho_min, logrho_max, 100)\n",
    "\n",
    "logP_isotherm = inv_isotherm_logrho(logrho_axis, logrho_of_logP)\n",
    "\n",
    "\"\"\"\n",
    "print(\"logrho_axis= {:}\".format(logrho_axis))\n",
    "print()\n",
    "print(\"logP={:}\".format(logP_isotherm))\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Write the inverted EOS table to an output file\n",
    "def write_eos_table(filename, logrho_axis, logT_axis, logP, logu, logs, delimiter=\",\", comments=\"#\"):\n",
    "    nRho = np.size(logrho_axis)\n",
    "    nT = np.size(logT_axis)\n",
    "    \n",
    "    # Store the different isotherms in 1d arrays\n",
    "    logrho = np.tile(logrho_axis, nT)\n",
    "    logT = np.repeat(logT_axis, nRho)\n",
    "\n",
    "    #logP = logP_array.flatten(order='C')\n",
    "    #logu = logu_array.flatten(order='C')\n",
    "    #logs = logs_array.flatten(order='C')   \n",
    "\n",
    "    header = \"nT = {:} nRho= {:}\\n\"\\\n",
    "             \"{:},{:},{:},{:},{:}\".format(nT, nRho, \"logT [K]\", \"logRho [g/cc]\", \"logP [barye]\", \"logE [erg/g]\", \"logS [erg/g/K]\")\n",
    "    \n",
    "    np.savetxt(filename, np.column_stack([logT, logrho, logP, logu, logs]), header=header, fmt='%15.8e', delimiter=delimiter, comments=comments)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invert logrho(logP, logT) for a given logrho_axis\n",
    "logrho_axis_min = -15.0\n",
    "logrho_axis_max = 2.0\n",
    "\n",
    "logrho_axis = np.linspace(logrho_axis_min, logrho_axis_max)\n",
    "\n",
    "logP_of_logrho = list()\n",
    "logu_of_logrho = list()\n",
    "logs_of_logrho = list()\n",
    "\n",
    "# Invert each isotherm\n",
    "for i in range(nT):\n",
    "    logP_of_logrho.append(inv_isotherm_logrho(logrho_axis, logrho_of_logP_int[i]))\n",
    "    logu_of_logrho.append(logu_of_logP_int[i](logP_of_logrho[i]))\n",
    "    logs_of_logrho.append(logs_of_logP_int[i](logP_of_logrho[i]))\n",
    "\n",
    "    logP_min = np.min(logP_table_axis[index])\n",
    "    logP_max = np.max(logP_table_axis[index])\n",
    "\n",
    "    #print(\"Isotherm {:} (logT={:.2f}):\".format(i, logT_table_axis[i]))\n",
    "    #print(\"logP_min= {:} logP_max= {:}\".format(logP_min, logP_max))\n",
    "    #print(\"P(rho)={:}\".format(logP_of_logrho[i]))\n",
    "\n",
    "# Generate 1D numpy arrays\n",
    "logP_of_logrho_1d = np.concatenate(logP_of_logrho)\n",
    "logu_of_logrho_1d = np.concatenate(logu_of_logrho)\n",
    "logs_of_logrho_1d = np.concatenate(logs_of_logrho)\n",
    "\n",
    "# Generate 2D numpy arrays because these are more convenient to use\n",
    "logP_array = np.stack(logP_of_logrho)\n",
    "logu_array = np.stack(logu_of_logrho)\n",
    "logs_array = np.stack(logs_of_logrho)\n",
    "\n",
    "write_eos_table(\"hydrogen_scvh_extended.csv\", logrho_axis, logT_table_axis, logP_of_logrho_1d, logu_of_logrho_1d, logs_of_logrho_1d)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Load an EOS table assuming that the variables are (rho, T) and that each isotherm has the same number of gridpoints\n",
    "def load_eos_table(filename, delimiter=\",\", skiprows=0):\n",
    "    data = np.loadtxt(filename, delimiter=delimiter, skiprows=skiprows)\n",
    "\n",
    "    logT_table   = data[:, 0]\n",
    "    logrho_table = data[:, 1]\n",
    "    logP_table   = data[:, 2]\n",
    "    logu_table   = data[:, 3]\n",
    "    logs_table   = data[:, 4]\n",
    "\n",
    "    \n",
    "    # All the SCvH EOS tables are tabulated along isotherms\n",
    "    #logT_table_axis = np.unique(logT_table)\n",
    "    #nT = np.size(logT_table_axis)\n",
    "    \n",
    "    # All SCVH EOS tables obtained from Ravit have the same size\n",
    "    nRho = 201\n",
    "    nT   = 100\n",
    "\n",
    "    logrho_table = logrho_table[0:nRho]\n",
    "    logT_table = logT_table[0:np.size(logT_table):nRho]\n",
    "\n",
    "    logrho_min = np.min(logrho_table)\n",
    "    logrho_max = np.max(logrho_table)\n",
    "    logT_min   = np.min(logT_table)\n",
    "    logT_max   = np.max(logT_table)\n",
    "    \n",
    "    dlogrho = logrho_table[1:]-logrho_table[:-1]\n",
    "    dlogT = logT_table[1:]-logT_table[:-1]\n",
    "    \n",
    "    print(\"Read EOS table: {:}\".format(filename))\n",
    "    print(\"logrho_min = {:}\".format(logrho_min))\n",
    "    print(\"logrho_max = {:}\".format(logrho_max))\n",
    "    print(\"logT_min   = {:}\".format(logT_min))\n",
    "    print(\"logT_max   = {:}\".format(logT_max))\n",
    "    print()\n",
    "\n",
    "    # Mark where the original SCvH EOS table was extended below T=100K\n",
    "    #index = np.min(np.where(logT_table>=2.0))\n",
    "    #print(\"The EOS table was extended until index={:} logT={:}\".format(index, logT_table[index]))\n",
    "\n",
    "\n",
    "    # Split into arrays of constant T\n",
    "    logP_array = np.split(logP_table, nT)\n",
    "    logu_array = np.split(logu_table, nT)\n",
    "    logs_array = np.split(logs_table, nT)\n",
    "    \n",
    "    # Generate 2d arrays\n",
    "    logP = np.vstack(logP_array)\n",
    "    logu = np.vstack(logu_array)\n",
    "    logs = np.vstack(logs_array)\n",
    "    \n",
    "    # Generate 2D interpolation functions for the old EOS tables\n",
    "    logP_int = interp.interp2d(logrho_table, logT_table, logP, kind='linear')\n",
    "    logu_int = interp.interp2d(logrho_table, logT_table, logu, kind='linear')\n",
    "    logs_int = interp.interp2d(logrho_table, logT_table, logs, kind='linear')\n",
    "\n",
    "    eos_table = {\n",
    "        \"nRho\":     nRho,\n",
    "        \"nT\":       nT,\n",
    "        \"logrho\":   logrho_table,\n",
    "        \"logT\":     logT_table,\n",
    "        \"logP\":     logP,\n",
    "        \"logu\":     logu,\n",
    "        \"logs\":     logs,\n",
    "        \"logP_int\": logP_int,\n",
    "        \"logu_int\": logu_int,\n",
    "        \"logs_int\": logs_int,\n",
    "    }\n",
    "    \n",
    "    return eos_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test if reading the old EOS tables work\n",
    "scvheos_h_old = load_eos_table(\"scvh_h_dt_cgs.csv\", skiprows=1)\n",
    "\n",
    "# Plot curves of log(P), log(u) and log(s)\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "\n",
    "# P(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[0][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logP\"][i,:], '-')\n",
    "    \n",
    "ax[0][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# P(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[0][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logP\"][:,i], '-')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (rho=const.)\")\n",
    "\n",
    "# u(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[1][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logu\"][i,:], '-')\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# u(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[1][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logu\"][:,i], '-')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[2][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logs\"][i,:], '-')\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# s(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[2][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logs\"][:,i], '-')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare the inverted EOS table to the tables I obtained from Ravit\n",
    "scvheos_h_old = load_eos_table(\"scvh_h_dt_cgs.csv\", skiprows=1)\n",
    "\n",
    "# Generate 2D interpolation functions for the new EOS tables\n",
    "logP_int = interp.interp2d(logrho_axis, logT_table_axis, logP_array, kind='linear')\n",
    "logu_int = interp.interp2d(logrho_axis, logT_table_axis, logu_array, kind='linear')\n",
    "logs_int = interp.interp2d(logrho_axis, logT_table_axis, logs_array, kind='linear')\n",
    "\n",
    "# Plot curves of log(P), log(u) and log(s)\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "# P(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[0][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logP\"][i,:], '-')\n",
    "    ax[0][0].plot(scvheos_h_old[\"logrho\"], logP_int(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logT\"][i]), '--')\n",
    "\n",
    "ax[0][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# P(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[0][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logP\"][:,i], '-')\n",
    "    ax[0][1].plot(scvheos_h_old[\"logT\"], logP_int(scvheos_h_old[\"logrho\"][i], scvheos_h_old[\"logT\"]), '--')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (rho=const.)\")\n",
    "\n",
    "# u(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[1][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logu\"][i,:], '-')\n",
    "    ax[1][0].plot(scvheos_h_old[\"logrho\"], logu_int(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logT\"][i]), '--')\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# u(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[1][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logu\"][:,i], '-')\n",
    "    ax[1][1].plot(scvheos_h_old[\"logT\"], logu_int(scvheos_h_old[\"logrho\"][i], scvheos_h_old[\"logT\"]), '--')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(rho, T=const)\n",
    "for i in range(0, scvheos_h_old[\"nT\"], nSkipT):\n",
    "    ax[2][0].plot(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logs\"][i,:], '-')\n",
    "    ax[2][0].plot(scvheos_h_old[\"logrho\"], logs_int(scvheos_h_old[\"logrho\"], scvheos_h_old[\"logT\"][i]), '--')\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# s(rho=const, T)\n",
    "for i in range(0, scvheos_h_old[\"nRho\"], nSkipRho):\n",
    "    ax[2][1].plot(scvheos_h_old[\"logT\"], scvheos_h_old[\"logs\"][:,i], '-')\n",
    "    ax[2][1].plot(scvheos_h_old[\"logT\"], logs_int(scvheos_h_old[\"logrho\"][i], scvheos_h_old[\"logT\"]), '--')\n",
    "\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a restricted EOS table\n",
    "scvheos_h_old = load_eos_table(\"scvh_h_dt_cgs.csv\", skiprows=1)\n",
    "\n",
    "# Limit the data to the region in which we are interested\n",
    "logrho_grid_min = np.min(scvheos_h_old['logrho'])\n",
    "logrho_grid_max = -4.0\n",
    "\n",
    "logT_grid_min = np.min(scvheos_h_old['logT'])\n",
    "logT_grid_max = 3.49\n",
    "\n",
    "# Remove the last isotherm because it causes problems when extrapolating\n",
    "logT_grid_max = 3.46\n",
    "\n",
    "print(\"logrho_grid_min= {:} rho_grid_min= {:}\".format(logrho_grid_min, 10**logrho_grid_min))\n",
    "print(\"logrho_grid_max= {:} rho_grid_max= {:}\".format(logrho_grid_max, 10**logrho_grid_max))\n",
    "print(\"logT_grid_min= {:} T_grid_min= {:}\".format(logT_grid_min, 10**logT_grid_min))\n",
    "print(\"logT_grid_max= {:} T_grid_max= {:}\".format(logT_grid_max, 10**logT_grid_max))\n",
    "print()\n",
    "\n",
    "index_logrho_grid = np.where(scvheos_h_old['logrho'] < logrho_grid_max)[0]\n",
    "index_logT_grid = np.where(scvheos_h_old['logT'] < logT_grid_max)[0]\n",
    "\n",
    "nRho_grid = np.size(index_logrho_grid)\n",
    "nT_grid = np.size(index_logT_grid)\n",
    "print(\"nRho= {:} nT= {:}\".format(nRho_grid, nT_grid))\n",
    "\n",
    "logrho_grid = scvheos_h_old['logrho'][index_logrho_grid]\n",
    "logT_grid = scvheos_h_old['logT'][index_logT_grid]\n",
    "\n",
    "logP_grid = scvheos_h_old['logP'][:nT_grid,:nRho_grid]\n",
    "logu_grid = scvheos_h_old['logu'][:nT_grid,:nRho_grid]\n",
    "logs_grid = scvheos_h_old['logs'][:nT_grid,:nRho_grid]\n",
    "\n",
    "print(logP.shape)\n",
    "print(logP_grid.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare the inverted EOS table to the restricted EOS tables\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "# P(rho, T=const)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, logP_grid[i,:], '-')\n",
    "    ax[0][0].plot(logrho_grid, logP_int(logrho_grid, logT_grid[i]), '--')\n",
    "\n",
    "ax[0][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# P(rho=const, T)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, logP_grid[:,i], '-')\n",
    "    ax[0][1].plot(logT_grid, logP_int(logrho_grid[i], logT_grid), '--')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (rho=const.)\")\n",
    "\n",
    "# u(rho, T=const)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[1][0].plot(logrho_grid, logu_grid[i,:], '-')\n",
    "    ax[1][0].plot(logrho_grid, logu_int(logrho_grid, logT_grid[i]), '--')\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# u(rho=const, T)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[1][1].plot(logT_grid, logu_grid[:,i], '-')\n",
    "    ax[1][1].plot(logT_grid, logu_int(logrho_grid[i], logT_grid), '--')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(rho, T=const)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[2][0].plot(logrho_grid, logs_grid[i,:], '-')\n",
    "    ax[2][0].plot(logrho_grid, logs_int(logrho_grid, logT_grid[i]), '--')\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# s(rho=const, T)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[2][1].plot(logT_grid, logs_grid[:,i], '-')\n",
    "    ax[2][1].plot(logT_grid, logs_int(logrho_grid[i], logT_grid), '--')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare the inverted EOS table to the restricted EOS tables when extrapolating\n",
    "fig, ax = plt.subplots(3, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 3*y)\n",
    "\n",
    "nT_ext = np.size(logT_table_axis)\n",
    "nRho_ext = np.size(logrho_axis)\n",
    "\n",
    "# Isotherms\n",
    "logP_of_logrho_grid_int = list()\n",
    "logu_of_logrho_grid_int = list()\n",
    "logs_of_logrho_grid_int = list()\n",
    "\n",
    "logP_of_logrho_ext_int = list()\n",
    "logu_of_logrho_ext_int = list()\n",
    "logs_of_logrho_ext_int = list()\n",
    "\n",
    "for i in range(0, nT_grid):\n",
    "    logP_of_logrho_grid_int.append(interp.InterpolatedUnivariateSpline(logrho_grid, logP_grid[i,:], k=1, ext='extrapolate'))\n",
    "    logu_of_logrho_grid_int.append(interp.InterpolatedUnivariateSpline(logrho_grid, logu_grid[i,:], k=1, ext='extrapolate'))\n",
    "    logs_of_logrho_grid_int.append(interp.InterpolatedUnivariateSpline(logrho_grid, logs_grid[i,:], k=1, ext='extrapolate'))\n",
    "\n",
    "for i in range(nT_ext):\n",
    "    logP_of_logrho_ext_int.append(interp.InterpolatedUnivariateSpline(logrho_axis, logP_array[i,:], k=1, ext='extrapolate'))\n",
    "    logu_of_logrho_ext_int.append(interp.InterpolatedUnivariateSpline(logrho_axis, logu_array[i,:], k=1, ext='extrapolate'))\n",
    "    logs_of_logrho_ext_int.append(interp.InterpolatedUnivariateSpline(logrho_axis, logs_array[i,:], k=1, ext='extrapolate'))\n",
    "\n",
    "# rho=const.\n",
    "logP_of_logT_grid_int = list()\n",
    "logu_of_logT_grid_int = list()\n",
    "logs_of_logT_grid_int = list()\n",
    "\n",
    "logP_of_logT_ext_int = list()\n",
    "logu_of_logT_ext_int = list()\n",
    "logs_of_logT_ext_int = list()\n",
    "\n",
    "for i in range(0, nRho_grid):\n",
    "    logP_of_logT_grid_int.append(interp.InterpolatedUnivariateSpline(logT_grid, logP_grid[:,i], k=1, ext='extrapolate'))\n",
    "    logu_of_logT_grid_int.append(interp.InterpolatedUnivariateSpline(logT_grid, logu_grid[:,i], k=1, ext='extrapolate'))\n",
    "    logs_of_logT_grid_int.append(interp.InterpolatedUnivariateSpline(logT_grid, logs_grid[:,i], k=1, ext='extrapolate'))\n",
    "\n",
    "for i in range(0, nRho_ext):\n",
    "    logP_of_logT_ext_int.append(interp.InterpolatedUnivariateSpline(logT_table_axis, logP_grid[:,i], k=1, ext='extrapolate'))\n",
    "    logu_of_logT_ext_int.append(interp.InterpolatedUnivariateSpline(logT_table_axislogT_grid, logu_grid[:,i], k=1, ext='extrapolate'))\n",
    "    logs_of_logT_ext_int.append(interp.InterpolatedUnivariateSpline(logT_grid, logs_grid[:,i], k=1, ext='extrapolate'))\n",
    "\n",
    "logrho_axis_extrap = np.concatenate((np.linspace(-15.0, logrho_grid_min, 10), logrho_grid))\n",
    "logT_axis_extrap = np.concatenate((np.linspace(0.1, logT_grid_min, 10), logT_grid))\n",
    "\n",
    "nRho_extrap = np.size(logrho_axis_extrap)\n",
    "nT_extrap = np.size(logT_axis_extrap)\n",
    "\n",
    "print(\"nRho_extrap= {:} nRho_grid= {:}\".format(nRho_extrap, nRho_grid))\n",
    "print(\"nT_extrap= {:} nT_grid= {:}\".format(nT_extrap, nT_grid))\n",
    "\n",
    "#logrho_axis_extrap = np.linspace(-15.0, -4.0, nRho_grid)\n",
    "#logT_axis_extrap = np.linspace(0.0, 3, nT_grid)\n",
    "\n",
    "#logrho_axis_extrap = logrho_grid\n",
    "#logT_axis_extrap = logT_grid\n",
    "    \n",
    "# P(rho, T=const)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_axis_extrap, logP_of_logrho_grid_int[i](logrho_axis_extrap), '-')\n",
    "    \n",
    "for i in range(0, nT_extrap, nSkipT):\n",
    "    ax[0][0].plot(logrho_axis_extrap, logP_int(logrho_axis_extrap, logT_axis_extrap[i]), '--')\n",
    "\n",
    "ax[0][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "# P(rho=const, T)\n",
    "for i in range(0, nRho_extrap, nSkipRho):\n",
    "    ax[0][1].plot(logT_axis_extrap, logP_of_logT_grid_int[i](logT_axis_extrap), '-')\n",
    "    ax[0][1].plot(logT_axis_extrap, logP_int(logrho_axis_extrap[i], logT_axis_extrap), '--')\n",
    "\n",
    "ax[0][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(P) [erg cm$^{-3}$]\")\n",
    "ax[0][1].set(title=\"SCvH EOS H (rho=const.)\")\n",
    "\n",
    "# u(rho, T=const)\n",
    "for i in range(0, nT_extrap, nSkipT):\n",
    "    ax[1][0].plot(logrho_axis_extrap, logu_of_logrho_grid_int[i](logrho_axis_extrap), '-')\n",
    "    ax[1][0].plot(logrho_axis_extrap, logu_int(logrho_axis_extrap, logT_axis_extrap[i]), '--')\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# u(rho=const, T)\n",
    "for i in range(0, nRho_extrap, nSkipRho):\n",
    "    ax[1][1].plot(logT_axis_extrap, logu_of_logT_grid_int[i](logT_axis_extrap), '-')\n",
    "    ax[1][1].plot(logT_axis_extrap, logu_int(logrho_axis_extrap[i], logT_axis_extrap), '--')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(rho, T=const)\n",
    "for i in range(0, nT_extrap, nSkipT):\n",
    "    ax[2][0].plot(logrho_axis_extrap, logs_of_logrho_grid_int[i](logrho_axis_extrap), '-')\n",
    "    ax[2][0].plot(logrho_axis_extrap, logs_int(logrho_axis_extrap, logT_axis_extrap[i]), '--')\n",
    "\n",
    "ax[2][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "# s(rho=const, T)\n",
    "for i in range(0, nRho_extrap, nSkipRho):\n",
    "    ax[2][1].plot(logT_grid, logs_grid[:,i], '-')\n",
    "    ax[2][1].plot(logT_grid, logs_int(logrho_grid[i], logT_grid), '--')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}