generate_restricted_eos_table.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate a restricted SCvH EOS table for a H-He mixture\n",
    "Generate a new EOS table based on the SCvH equation of state [Saumon et al. 1995](https://ui.adsabs.harvard.edu/abs/1995ApJS...99..713S/abstract) for Hydrogen and Helium with extensions to lower temperatures [Vazan et al. 2013](https://academic.oup.com/mnras/article/434/4/3283/961935) restricted to low densities and temperatures where the isotherms behave sensible. In this regime the fluid behaves like an ideal gas and the EOS can be extended to $\\rho \\to 0$ using the ideal gas law.\n",
    "\n",
    "\n",
    "\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": [
    "The mixture was obtained using the additive volume law (AVL) and Y=0.275."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = np.loadtxt(\"scvh_hhe_y0.275_dt_cgs.csv\", delimiter=\",\", skiprows=1) \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",
    "# 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(\"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",
    "#print(\"logrho_table = {:}\".format(logrho_table))\n",
    "#print(\"logT_table   = {:}\".format(logT_table))\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Write an EOS table to an output file.\n",
    "def write_eos_table(filename, logrho_axis, logT_axis, logP_array, logu_array, logs_array, 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='%.8f', delimiter=delimiter, comments=comments)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Test if write_eos_table works\n",
    "write_eos_table(\"output.txt\", logrho_table, logT_table, logP, logu, logs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def press_ideal_gas(rho, T, mu=2.3, gamma=5.0/3.0):\n",
    "    kB = 1.38e-16  # erg/K\n",
    "    m_H = 1.67e-24 # g\n",
    "    return kB/(mu*m_H)*rho*T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def intenergy_ideal_gas(T, mu=2.3, gamma=5.0/3.0):\n",
    "    kB = 1.38e-16  # erg/K\n",
    "    m_H = 1.67e-24 # g\n",
    "    return kB/((gamma-1.0)*mu*m_H)*T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def entropy_ideal_gas(T, mu=2.3, gamma=5.0/3.0):\n",
    "    kB = 1.38e-16  # erg/K\n",
    "    m_H = 1.67e-24 # g\n",
    "    return kB/(mu*m_H)*(np.log(T/T0) - 1.0/(gamma-1.0)*np.log(rho/rho0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skip some curves otherwise the plots are very hard to read\n",
    "nSkipT = 4\n",
    "nSkipRho = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot log(P), log(u) and log(s) of the original table\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, nSkipT):\n",
    "    ax[0][0].plot(logrho_table, 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, nRho, nSkipRho):\n",
    "    ax[0][1].plot(logT_table, 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, nT, nSkipT):\n",
    "    ax[1][0].plot(logrho_table, 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, nRho, nSkipRho):\n",
    "    ax[1][1].plot(logT_table, 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, nT, nSkipT):\n",
    "    ax[2][0].plot(logrho_table, 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, nRho, nSkipRho):\n",
    "    ax[2][1].plot(logT_table, 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": [
    "# Limit the data to the region in which we are interested\n",
    "logrho_grid_min = logrho_min\n",
    "logrho_grid_max = -4.0\n",
    "\n",
    "logT_grid_min = logT_min\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(logrho_table < logrho_grid_max)[0]\n",
    "index_logT_grid = np.where(logT_table < 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 = logrho_table[index_logrho_grid]\n",
    "logT_grid = logT_table[index_logT_grid]\n",
    "\n",
    "logP_grid = logP[:nT_grid,:nRho_grid]\n",
    "logu_grid = logu[:nT_grid,:nRho_grid]\n",
    "logs_grid = logs[:nT_grid,:nRho_grid]\n",
    "\n",
    "print(logP.shape)\n",
    "print(logP_grid.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the reduced grid\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",
    "fig.suptitle(r\"{:} $\\leq \\log(\\rho) \\leq$ {:}, {:} $\\leq \\log(T) \\leq$ {:}\".format(logrho_grid_min, logrho_grid_max, logT_grid_min, logT_grid_max), x=0.5, y=0.0, verticalalignment='bottom', horizontalalignment='center')\n",
    "\n",
    "# P(rho, T=const)\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, logP_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-He (T=const.)\")\n",
    "\n",
    "# P(rho=const, T)\n",
    "ax[0][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, logP_grid[:,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-He (rho=const.)\")\n",
    "\n",
    "# u(rho, T=const)\n",
    "ax[1][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[1][0].plot(logrho_grid, logu_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",
    "ax[1][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[1][1].plot(logT_grid, logu_grid[:,i], '-')\n",
    "\n",
    "ax[1][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "\n",
    "# s(rho, T=const)\n",
    "ax[2][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[2][0].plot(logrho_grid, logs_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",
    "ax[2][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[2][1].plot(logT_grid, logs_grid[:,i], '-')\n",
    "\n",
    "ax[2][1].set(xlabel=\"log(T) [K]\", ylabel=\"log(s) [erg g$^{-1}$ K$^{-1}$]\")\n",
    "\n",
    "\n",
    "print(logT_grid[-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare the reduced grid to an ideal gas\n",
    "fig, ax = plt.subplots(2, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 2*y)\n",
    "\n",
    "# P(rho, T=const)\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, logP_grid[i,:], '-')\n",
    "\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, np.log10(press_ideal_gas(10**logrho_grid, 10**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",
    "ax[0][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, logP_grid[:,i], '-')\n",
    "\n",
    "ax[0][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, np.log10(press_ideal_gas(10**logrho_grid[i], 10**logT_grid)), '--')\n",
    "\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",
    "ax[1][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[1][0].plot(logrho_grid, logu_grid[i,:], '-')\n",
    "\n",
    "ax[1][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[1][0].plot(logrho_grid, np.ones(nRho_grid)*np.log10(intenergy_ideal_gas(10**logT_grid[i])), '--')\n",
    "\n",
    "ax[1][0].set(xlabel=\"log(rho) [g cm^${-3}$]\", ylabel=\"log(u) [erg g$^{-1}$]\")\n",
    "ax[1][0].set(title=\"SCvH EOS H (T=const.)\")\n",
    "\n",
    "\n",
    "# u(rho=const, T)\n",
    "ax[1][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[1][1].plot(logT_grid, logu_grid[:,i], '-')\n",
    "\n",
    "ax[1][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[1][1].plot(logT_grid, np.log10(intenergy_ideal_gas(10**logT_grid)), '--')\n",
    "\n",
    "ax[1][1].get_xlim()\n",
    "ax[1][1].get_ylim()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Write the restricted EOS table to an output file.\n",
    "write_eos_table(\"scvh_hhe_y0.275_dt_cgs_lowrhot.csv\", logrho_grid, logT_grid, logP_grid, logu_grid, logs_grid)\n",
    "write_eos_table(\"scvh_hhe_y0.275_dt_cgs_lowrhot.txt\", logrho_grid, logT_grid, logP_grid, logu_grid, logs_grid, delimiter=\" \")\n",
    "\n",
    "\n",
    "new_table = np.loadtxt(\"scvh_hhe_y0.275_dt_cgs_lowrhot.csv\", delimiter=\",\")\n",
    "\n",
    "logT_new   = new_table[:, 0] \n",
    "logrho_new = new_table[:, 1]\n",
    "logP_new   = new_table[:, 2]\n",
    "logu_new   = new_table[:, 3]\n",
    "logs_new   = new_table[:, 4]\n",
    "\n",
    "# The restricted SCVH EOS table has a different size\n",
    "nRho_new = np.size(logrho_grid)\n",
    "nT_new   = np.size(logT_grid)\n",
    "\n",
    "print(\"nRho_grid = {:}\".format(nRho_grid))\n",
    "print(\"nT_grid   = {:}\".format(nT_grid))\n",
    "\n",
    "logrho_new = logrho_new[0:nRho_new]\n",
    "logT_new = logT_new[0:np.size(logT_new):nRho_new]\n",
    "\n",
    "# Split into arrays of constant T\n",
    "logP_array_new = np.split(logP_new, nT_new)\n",
    "logu_array_new = np.split(logu_new, nT_new)\n",
    "logs_array_new = np.split(logs_new, nT_new)\n",
    "\n",
    "# Generate 2d arrays\n",
    "logP_new = np.vstack(logP_array_new)\n",
    "logu_new = np.vstack(logu_array_new)\n",
    "logs_new = np.vstack(logs_array_new)\n",
    "\n",
    "print(np.where(np.abs(logrho_new-logrho_grid) > 0.0))\n",
    "print(np.where(np.abs(logT_new-logT_grid) > 0.0))\n",
    "print(np.where(np.abs(logP_new-logP_grid) > 0.0))\n",
    "print(np.where(np.abs(logs_new-logs_grid) > 0.0))\n",
    "print(np.where(np.abs(logs_new-logs_grid) > 0.0))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check how the table extrapolates to rho = 0\n",
    "logrho_min_extrap = -25.0\n",
    "logrho_max_extrap = -4.0\n",
    "#logT_min_extrap = np.min(logT_new)\n",
    "#logT_max_extrap = np.max(logT_new)\n",
    "logT_min_extrap = 0.5\n",
    "logT_max_extrap = 4.0\n",
    "\n",
    "# Generate interpolation functions for all isotherms\n",
    "logP_rho_int = list()\n",
    "logu_rho_int = list()\n",
    "logs_rho_int = list()\n",
    "\n",
    "for i in range(0, nT_new):\n",
    "    logP_rho_int.append(interp.interp1d(logrho_new, logP_new[i,:], kind='linear', fill_value='extrapolate'))\n",
    "    logu_rho_int.append(interp.interp1d(logrho_new, logu_new[i,:], kind='linear', fill_value='extrapolate' ))\n",
    "    logs_rho_int.append(interp.interp1d(logrho_new, logs_new[i,:], kind='linear', fill_value='extrapolate'))\n",
    "    \n",
    "# Generate interpolation functions for rho=const.\n",
    "logP_T_int = list()\n",
    "logu_T_int = list()\n",
    "logs_T_int = list()\n",
    "\n",
    "for i in range(0, nT_new):\n",
    "    logP_T_int.append(interp.interp1d(logT_new, logP_new[:,i], kind='linear', fill_value='extrapolate'))\n",
    "    logu_T_int.append(interp.interp1d(logT_new, logu_new[:,i], kind='linear', fill_value='extrapolate' ))\n",
    "    logs_T_int.append(interp.interp1d(logT_new, logs_new[:,i], kind='linear', fill_value='extrapolate'))\n",
    "\n",
    "    \n",
    "    \n",
    "# Generate interpolation axis\n",
    "nRho_int = 1000\n",
    "nT_int = 1000\n",
    "\n",
    "logrho_int = np.linspace(logrho_min_extrap, logrho_max_extrap, 1000)\n",
    "logT_int = np.linspace(logT_min_extrap, logT_max_extrap, 1000)\n",
    "\n",
    "# Compare the reduced grid to an ideal gas\n",
    "fig, ax = plt.subplots(2, 2)\n",
    "\n",
    "x, y = fig.get_size_inches()\n",
    "\n",
    "fig.set_size_inches(2*x, 2*y)\n",
    "\n",
    "# P(rho, T=const)\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, logP_grid[i,:], '-')\n",
    "\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_int, logP_int[i](logrho_int), '--')\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, T=const)\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_grid, logP_grid[i,:], '-')\n",
    "\n",
    "ax[0][0].set_prop_cycle(None)\n",
    "for i in range(0, nT_grid, nSkipT):\n",
    "    ax[0][0].plot(logrho_int, logP_int[i](logrho_int), '--')\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",
    "ax[0][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, logP_grid[:,i], '-')\n",
    "\n",
    "ax[0][1].set_prop_cycle(None)\n",
    "for i in range(0, nRho_grid, nSkipRho):\n",
    "    ax[0][1].plot(logT_grid, np.log10(press_ideal_gas(10**logrho_grid[i], 10**logT_grid)), '--')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(logT_table)"
   ]
  },
  {
   "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
}