{ "cells": [ { "cell_type": "markdown", "id": "f7382445-b6ba-4216-9e78-d99126414072", "metadata": {}, "source": [ "# Entropy estimates in the Hernquist potential" ] }, { "cell_type": "markdown", "id": "21de21a8-16e8-442d-840c-700f8db324c3", "metadata": {}, "source": [ "Here we estimate the entropy of samples in the Hernquist potential ([Hernquist 1990](https://ui.adsabs.harvard.edu/abs/1990ApJ...356..359H/abstract)), and plot it as a function of time while integrating orbits for these samples - see the Introduction for the general expressions. This is almost identical to the tutorial for the Isochrone potential, except that the Isochrone has an analytical expression for the period of radial oscillations $T_r(E,L)$, where $E$ is energy and $L$ is angular momentum, while the Hernquist model doesn't have that (as far as I know). This impacts the calculation of the density of states $g(E,L)$ when we assume the DF to be a function $f(E,L)$ of energy and angular momentum.\n", "\n", "The expression for the density of states is\n", "\n", "$g(E,L) = 8 \\pi^2 L T_r(E,L)$,\n", "\n", "where\n", "\n", "$T_r(E, L) = 2\\int_{r_\\mathrm{per}}^{r_\\mathrm{apo}} \\frac{\\mathrm{d}r}{\\sqrt{2\\left[ E - \\phi(r)\\right] - L^2/r^2}}$.\n", "\n", "Below we use the routine `tropygal.gEL_Spherical`, which calculates $T_r(E, L)$ numerically, while in the Isochrone case that is calculated analytically with `tropygal.gEL_Isochrone`. The numerical calculation of $T_r(E, L)$ in $\\texttt{tropygal}$ is much simpler and not as optimized as e.g. in $\\texttt{agama}$, but it serves for simple applications.\n", "\n", "We estimate the entropies for self-consistent and non-stationary samples. In the self-consistent case, we compare the estimates with the true entropy calculated with analytical expressions for $f(E)$ and $g(E)$ of the Hernquist model. We use use the [agama](https://github.com/GalacticDynamics-Oxford/Agama) package for the orbit integration, sampling from a DF and action calculations, but you may prefer other packages, such as [gala](http://gala.adrian.pw/en/latest/) or [galpy](https://www.galpy.org/). Of course, the entropy estimate itself does not depend on how the data were generated.\n", "\n", "We estimate the entropy of the DF $f(\\vec{w})$, where $\\vec{w} = (\\vec{r}, \\vec{v})$ are the 6D phase-space coordinates:\n", "\n", "$S \\equiv -\\int f(\\vec{w})\\ln\\left(\\frac{f}{\\mu}\\right)\\, \\mathrm{d}^6\\vec{w} = -\\int f'(\\vec{w}')\\ln f'\\, \\mathrm{d}^6\\vec{w}'$,\n", "\n", "where $\\mu = |\\Sigma|^{-1}$, $|\\Sigma|$ is the product of the dispersions in each of the coordinates, and $f'(\\vec{w}') = |\\Sigma|f(\\vec{w})$ is the DF of the coordinates normalized by their dispersions - see the Introduction.\n", "\n", "Assuming that $f(\\vec{w})$ is a function of integrals $\\vec{I}$ only, e.g. $f=f(E)$, $f = f(E,L)$, or $f = f(\\vec{J})$ (all valid assumptions for the self-consistent sample of the Hernquist model), with the appropriate change of variables we obtain in general\n", "\n", "$S_{\\vec{I}} = -\\int F(\\vec{I}) \\ln\\left( \\frac{|\\Sigma|F(\\vec{I})}{g(\\vec{I})}\\right)\\, \\mathrm{d}\\vec{I}$,\n", "\n", "where $g(\\vec{I})$ is the density of states -- see Appendix A of [Beraldo e Silva et al (2024)](https://arxiv.org/abs/2407.07947) for details. Note that $S_{\\vec{I}}$ is not \"the entropy in the space of integrals\" but, instead, $S_{\\vec{I}} = S(f)$ if one can assume that the DF is $f = f(\\vec{I})$, which is true for stationary samples (Jeans' theorem).\n", "\n", "In case the computation of $g(E,L)$ is too slow because $T_r(E, L)$ is calculated numerically with a simple routine (it takes a few minutes in my laptop), you can use your prefered galactic dynamics package for that (e.g. agama, galpy or gala), which may calculate $T_r(E, L)$ faster. \n", "\n", "We start importing the relevant modules and setting some parameters for prettier plots. We use agama to generate samples, integrate orbits and calculate actions, but any other libray could be used instead." ] }, { "cell_type": "code", "execution_count": 1, "id": "16a4fca0-b6a9-4058-a3c8-b51599c53597", "metadata": {}, "outputs": [], "source": [ "# Import modules\n", "import numpy as np\n", "from scipy import integrate\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "\n", "import agama\n", "import tropygal\n", "\n", "from matplotlib.ticker import ScalarFormatter, NullFormatter\n", "\n", "params = {'axes.labelsize': 24, 'xtick.labelsize': 20, \n", " 'xtick.direction': 'in', 'xtick.major.size': 8.0,\n", " 'xtick.bottom': 1, 'xtick.top': 1, 'ytick.labelsize': 20,\n", " 'ytick.direction': 'in','ytick.major.size': 8.0,'ytick.left': 1,\n", " 'ytick.right': 1,'text.usetex': True, 'lines.linewidth': 1,\n", " 'axes.titlesize': 32, 'font.family': 'serif'}\n", "plt.rcParams.update(params)\n", "plt.rcParams['figure.dpi'] = 60\n", "columnwidth = 240./72.27\n", "textwidth = 504.0/72.27\n", "\n", "%matplotlib inline\n", "%config InlineBackend.figure_format = 'retina'" ] }, { "cell_type": "markdown", "id": "e6ee3631-77ea-444f-bab8-0fe7446186bc", "metadata": {}, "source": [ "## Set constants" ] }, { "cell_type": "code", "execution_count": 2, "id": "9f370702-38e3-4af0-b526-10678ee587bb", "metadata": {}, "outputs": [], "source": [ "# Mass and scale radius for the Hernquist potential:\n", "M = 1.\n", "b = 1.\n", "_G = 1\n", "params = np.array([M, b, _G])\n", "\n", "n_steps = 100 # number of time steps in the orbit integration (and at which the entropy is estimated)" ] }, { "cell_type": "markdown", "id": "21db6c55-45fd-4124-9ef7-b5c1b8f40040", "metadata": {}, "source": [ "## Define functions for true entropy of self-consistent sample" ] }, { "cell_type": "code", "execution_count": 3, "id": "bdcaeedf-33ec-42cd-a7b3-5016e5070f3d", "metadata": {}, "outputs": [], "source": [ "# Analytical expressions for DF of self-consistent Hernquist model:\n", "def F_E(E, M, b, G):\n", " f_E = tropygal.DF_Hernquist(E, M, b, G=G)\n", " g_E = tropygal.g_Hernquist(E, M, b, G=G)\n", "\n", " return f_E*g_E # F(E) = f(E)g(E)\n", "#----------------- \n", "def S_E_true_integrand(E, M, b, mu, G):\n", " # Integrand for calculation of true entropy\n", " # F(E) = f(E) * g(E)\n", " # it returns F(E) * ln(F(E)/mu(E)), and mu(E) = |Sigma|^(-1) * g(E)\n", " f_E = tropygal.DF_Hernquist(E, M, b, G)\n", "\n", " return F_E(E, M, b, G)*np.log(f_E/mu) # externally, mu is set to |Sigma|^(-1)" ] }, { "cell_type": "markdown", "id": "138c6057-662f-40a6-908c-2af1ce8ea192", "metadata": {}, "source": [ "## Check normalization of F(E)" ] }, { "cell_type": "code", "execution_count": 4, "id": "c65e18f9-d6b9-45a0-bff1-c0d1c29b079e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "norm of F(E): 0.9999968005534102\n" ] } ], "source": [ "E_I_min = -M*_G/b # Minimum of potential\n", "E_I_max = -1e-6\n", "\n", "norm = integrate.quad(F_E, a=E_I_min, b=E_I_max, args=(M, b, _G))[0]\n", "print ('norm of F(E):', norm)" ] }, { "cell_type": "markdown", "id": "4b3594b9-b88e-444e-8002-9f65706b74b6", "metadata": {}, "source": [ "## Entropy estimates" ] }, { "cell_type": "code", "execution_count": 5, "id": "2485ec7d-edef-44bd-a6cf-c5abd27bc96a", "metadata": {}, "outputs": [], "source": [ "# Set params and initialize arrays:\n", "\n", "n_orbs = [int(N) for N in [1e+4, 1e+5, 1e+6]]\n", "# For the plots:\n", "N_label = ['10k', '100k', '1m']\n", "N_label_plot = [r'$10^4$', r'$10^5$', r'$10^6$']\n", "N_colors = ['black', 'red', 'blue']\n", "\n", "S_E_true = np.full(len(n_orbs), np.nan)\n", "\n", "Tcirc = np.full(len(n_orbs), np.nan) # mean circular period for each sample\n", "t = np.full((len(n_orbs), n_steps), np.nan) # time in the orbit integration\n", "\n", "S_6D = np.full((len(n_orbs), n_steps), np.nan) # Entropy evaluated in 6D\n", "# Entropies assuming the DF is f = f(E), or f = f(E,L), or f = f(J)\n", "# These should be the same as S_6D if f = f(E), or f = f(E,L), or f = f(J)\n", "S_E = np.full(len(n_orbs), np.nan)\n", "S_EL = np.full(len(n_orbs), np.nan)\n", "S_J = np.full(len(n_orbs), np.nan)" ] }, { "cell_type": "code", "execution_count": 6, "id": "01849244-07be-4226-8186-3c60db7ac98e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Agama used to generate initial samples, integrate orbits and estimate actions; agama.G: 1.0\n" ] } ], "source": [ "#-------------\n", "agama.setUnits()\n", "print ('Agama used to generate initial samples, integrate orbits and estimate actions; agama.G:', agama.G)\n", "# Potential and DF (using agama)\n", "# This creates an Hernquist potential of a given mass and scale radius:\n", "hern_pot = agama.Potential(type='Dehnen', mass=M, scaleRadius=b, gamma=1)\n", "# This creates a DF of a self-consistent sample:\n", "hern_df = agama.DistributionFunction(type='QuasiSpherical', potential=hern_pot, density=hern_pot)\n", "# This creates an action finder for the given potential:\n", "actF = agama.ActionFinder(hern_pot)" ] }, { "cell_type": "code", "execution_count": 7, "id": "a9fc86ab-47c7-486a-8288-d336834c44ae", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------\n", "Generating sample...\n", "S_E (true): 9.07381\n", "S_6D estimated: 9.54155\n", "S_E estimated: 9.07106\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/ln/7t1_bznj4l9cj5_59_yk0y640000gt/T/ipykernel_57036/120888349.py:20: IntegrationWarning: The integral is probably divergent, or slowly convergent.\n", " S_E_true[i] = -integrate.quad(S_E_true_integrand, a=E_I_min, b=E_I_max, args=(M, b, mu, _G))[0]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "S_EL estimated: 9.10449\n", "S_J estimated: 9.0869\n", "j: 10 S_6D estimated: 9.53912\n", "j: 20 S_6D estimated: 9.5351\n", "j: 30 S_6D estimated: 9.54301\n", "j: 40 S_6D estimated: 9.55713\n", "j: 50 S_6D estimated: 9.57169\n", "j: 60 S_6D estimated: 9.56425\n", "j: 70 S_6D estimated: 9.56394\n", "j: 80 S_6D estimated: 9.58931\n", "j: 90 S_6D estimated: 9.55079\n", "-------------------------\n", "Generating sample...\n", "S_E (true): 9.03025\n", "S_6D estimated: 9.34829\n", "S_E estimated: 9.03523\n", "S_EL estimated: 9.03992\n", "S_J estimated: 9.05359\n", "j: 10 S_6D estimated: 9.34344\n", "j: 20 S_6D estimated: 9.35426\n", "j: 30 S_6D estimated: 9.35587\n", "j: 40 S_6D estimated: 9.3497\n", "j: 50 S_6D estimated: 9.35109\n", "j: 60 S_6D estimated: 9.35674\n", "j: 70 S_6D estimated: 9.34634\n", "j: 80 S_6D estimated: 9.34868\n", "j: 90 S_6D estimated: 9.3463\n", "-------------------------\n", "Generating sample...\n", "S_E (true): 9.02568\n", "S_6D estimated: 9.22986\n", "S_E estimated: 9.02616\n", "S_EL estimated: 9.03057\n", "S_J estimated: 9.03697\n", "j: 10 S_6D estimated: 9.22945\n", "j: 20 S_6D estimated: 9.23158\n", "j: 30 S_6D estimated: 9.23207\n", "j: 40 S_6D estimated: 9.23172\n", "j: 50 S_6D estimated: 9.22852\n", "j: 60 S_6D estimated: 9.23074\n", "j: 70 S_6D estimated: 9.23063\n", "j: 80 S_6D estimated: 9.23194\n", "j: 90 S_6D estimated: 9.22885\n" ] } ], "source": [ "# Generate samples, integrate and estimate entropy:\n", "for i in range(len(n_orbs)):\n", " print ('-------------------------')\n", " dim = 6\n", " print ('Generating sample...')\n", " N = n_orbs[i]\n", " # Generate self-consistent sample of the Hernquist potential.\n", " # Some care is needed here, since it's important to make sure the initial sample is really stationary in the potential.\n", " # A constant entropy for this sample indicates that it is truly stationary - see plot below with the time evolution.\n", " # If using agama, see option #define DISABLE_QRNG in src/math_sample.cpp, or in Makefile.local, which might need to be set before compilation\n", " data,_ = agama.GalaxyModel(hern_pot, hern_df).sample(N)\n", " # data, _ = hern_pot.sample(N, potential=hern_pot) \n", " #------------------------------ \n", " sigma_6D_0 = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in data.T])\n", " mu = 1./np.prod(sigma_6D_0)\n", "\n", " # In principle, S_true shouldn't depend on the sample size, and could be calculated outside of this loop,\n", " # But we are using mu = |Sigma|^(-1) to normalize the coordinates, with the exact |Sigma| changing for different samples,\n", " # but |Sigma| converges for large samples\n", " S_E_true[i] = -integrate.quad(S_E_true_integrand, a=E_I_min, b=E_I_max, args=(M, b, mu, _G))[0]\n", " print ('S_E (true):', np.round(S_E_true[i], 5))\n", " #------------------------------ \n", " # Estimate S_6D (at t=0; estimates over time are done below):\n", "\n", " S_6D[i, 0] = tropygal.entropy(data/sigma_6D_0)\n", " print ('S_6D estimated:', np.round(S_6D[i, 0], 5))\n", " #------------------\n", " # Estimate S_E, i.e. assuming f = f(E):\n", " \n", " x = data[:,0]; y = data[:,1]; z = data[:,2]\n", " vx = data[:,3]; vy = data[:,4]; vz = data[:,5]\n", " \n", " v2 = vx**2 + vy**2 + vz**2\n", " pos = np.column_stack((x, y, z))\n", " E = hern_pot.potential(pos) + 0.5*v2\n", " sigma_E = 0.5*(np.percentile(E, 84) - np.percentile(E, 16))\n", " \n", " g_E = tropygal.g_Hernquist(E, M, b=b, G=_G)\n", " # It's convenient to normalize coordinates in the space where the entropy is estimated,\n", " # but we want to stick to the entropy definition we used before, so the normalized coordinates are passed as the data,\n", " # and mu takes care of the appropriate factors in the change of variables for the integral defining the entropy to be the same.\n", " S_E[i] = tropygal.entropy(E/sigma_E, mu= g_E*np.abs(sigma_E)/np.abs(np.prod(sigma_6D_0)))\n", " print ('S_E estimated:', np.round(S_E[i], 5))\n", " #-------------------------\n", " # Estimate S_EL, i.e. assuming f = f(E,L):\n", " \n", " Lx = (y*vz - z*vy)\n", " Ly = (z*vx - x*vz)\n", " Lz = (x*vy - y*vx)\n", " L = np.sqrt(Lx**2 + Ly**2 + Lz**2)\n", " EL = np.column_stack((E, L))\n", " sigma_L = 0.5*(np.percentile(L, 84) - np.percentile(L, 16))\n", " sigma_EL = np.array([sigma_E, sigma_L])\n", "\n", " g_EL = tropygal.gEL_Spherical(E, L, tropygal.Phi_Hernquist, tropygal.dPhi_dr_Hernquist, params)\n", " S_EL[i] = tropygal.entropy(EL/sigma_EL, mu= g_EL*np.prod(sigma_EL)/np.prod(sigma_6D_0))\n", " print ('S_EL estimated:', np.round(S_EL[i], 5))\n", " #------------------------------ \n", " # Estimate S_J, i.e. assuming f = f(J):\n", "\n", " J = actF(data, actions=True, frequencies=False, angles=False)\n", " sigma_J = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in J.T])\n", " S_J[i] = tropygal.entropy(J/sigma_J, mu= ((2.*np.pi)**3)*np.prod(sigma_J)/np.prod(sigma_6D_0))\n", " print ('S_J estimated:', np.round(S_J[i],5))\n", " #------------------------------ \n", " # Estimate S_6D at different times\n", "\n", " # define integration time (same for all orbits):\n", " Tcirc[i] = np.median(hern_pot.Tcirc(data))\n", " int_time = 50*Tcirc[i]\n", " delta_t = int_time/n_steps\n", " t[i, 0] = 0\n", " \n", " for j in range(1, n_steps):\n", " # Integrate orbits for one time-step:\n", " orbs = agama.orbit(potential=hern_pot, ic = data, time = delta_t, trajsize =1, verbose=False)\n", "\n", " t[i, j] = t[i, j-1] + delta_t\n", " all_coords = np.vstack(orbs[:,1]).reshape(len(x), 1, dim)\n", " # update data with new coords:\n", " data = all_coords[:,-1,:]\n", " sigma_6D = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in data.T])\n", " # Here we re-normalize again at every time-step (to facilitate the estimate), \n", " # \"compensating\" for that in the mu factor, i.e. making an appropriate change of variables every time-step:\n", " S_6D[i,j] = tropygal.entropy(data/sigma_6D, mu=np.prod(sigma_6D)/np.prod(sigma_6D_0))\n", " if (j%10==0):\n", " print ('j:', j, 'S_6D estimated:', np.round(S_6D[i, j], 5))" ] }, { "cell_type": "code", "execution_count": 8, "id": "ff65a6ff-791c-4834-af3c-0f53d8f756d3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "N: 10000 S_E_true: 9.02567953334228 err S_J: 0.06122435133819515\n", "N: 100000 S_E_true: 9.02567953334228 err S_J: 0.027905902981309794\n", "N: 1000000 S_E_true: 9.02567953334228 err S_J: 0.011293482930074816\n" ] } ], "source": [ "# Calc errors\n", "err_S_6D = np.zeros(len(n_orbs))\n", "err_S_E = np.zeros(len(n_orbs))\n", "err_S_EL = np.zeros(len(n_orbs))\n", "err_S_J = np.zeros(len(n_orbs))\n", "#-------------------\n", "for i in range(len(n_orbs)):\n", " # Calculate error with the time-average of S_6D, in respect to the true value:\n", " err_S_6D[i] = (np.mean(S_6D[i]) - S_E_true[-1])/S_E_true[-1]\n", " \n", " err_S_E[i] = (S_E[i] - S_E_true[-1])/S_E_true[-1]\n", " err_S_EL[i] = (S_EL[i] - S_E_true[-1])/S_E_true[-1]\n", " err_S_J[i] = (S_J[i] - S_E_true[-1])/S_E_true[-1]\n", "\n", " print ('N:', n_orbs[i],'S_E_true:', S_E_true[-1], 'err S_J:',(np.mean(S_J[i]) - S_E_true[-1]))" ] }, { "cell_type": "code", "execution_count": 9, "id": "49fb1dcd-4851-4598-9e36-d8056c8516e3", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 834, "width": 473 } }, "output_type": "display_data" } ], "source": [ "# Plot\n", "fig, axs = plt.subplots(2, 1, figsize=(8,14))\n", "fig.patch.set_facecolor('white')\n", "\n", "axs[0].set_title('Hernquist Model (self-consistent)')\n", "axs[1].set_title('Relative error (bias)')\n", "\n", "ones = np.ones(n_steps)\n", "\n", "for i in range(len(n_orbs)):\n", " axs[0].plot(t[i]/Tcirc[i], S_6D[i], ls='-', lw=2, c=N_colors[i], label=N_label_plot[i]) # Assumption-free estimate\n", " #axs[0].plot(t[i]/Tcirc[i], S_E[i]*ones, ls='--', dashes=(8,5), lw=2, c=N_colors[i]) # Assuming the DF is an unknown f = f(E)\n", " #axs[0].plot(t[i]/Tcirc[i], S_EL[i]*ones, ls='--', dashes=(8,5), lw=2, c=N_colors[i]) # Assuming the DF is an unknown f = f(E,L)\n", " axs[0].plot(t[i]/Tcirc[i], S_J[i]*ones, ls='--', dashes=(8,5), lw=2, c=N_colors[i]) # Assuming the DF is an unknown f = f(J)\n", "\n", "# To have two legends:\n", "l1 = axs[0].legend(fontsize=24)\n", "\n", "p1, = axs[0].plot(t[0]/Tcirc[0], S_6D[0], ls='-', lw=2, c=N_colors[0])\n", "p2, = axs[0].plot(t[0]/Tcirc[0], S_J[0]*ones, color=N_colors[0], linestyle='--', dashes=(8,5), lw=2)\n", "p3, = axs[0].plot(t[-1]/Tcirc[-1], S_E_true[-1]*ones, color='grey', linestyle='-', lw=4, zorder=0)\n", "axs[0].legend([p1, p2, p3], [r'$\\hat{S}_\\mathrm{6D}$', r'$\\hat{S}_{\\vec{J}}$', r'$S_{\\mathrm{E, true}}$'],\n", " loc='upper left', fontsize=24)\n", "# Add l1 as a separate artist to the axes\n", "axs[0].add_artist(l1)\n", "#----------------\n", "axs[1].plot(n_orbs, np.abs(err_S_6D),'h-',c='grey', ms=15, lw=2, mec='black', alpha=0.6, label=r'$\\hat{S}_\\mathrm{6D}$')\n", "axs[1].plot(n_orbs, np.abs(err_S_J), '^--', c='grey', ms=15, dashes=(8,5), lw=2, mec='black', alpha=0.6, label=r'$\\hat{S}_{\\vec{J}}$')\n", "axs[1].plot(n_orbs, np.abs(err_S_EL), 'x-.', c='grey', ms=15, lw=2, mec='black', alpha=0.6, label=r'$\\hat{S}_\\mathrm{EL}$')\n", "axs[1].plot(n_orbs, np.abs(err_S_E), '.:', c='grey', ms=20, lw=2, mec='black', alpha=0.6, label=r'$\\hat{S}_\\mathrm{E}$')\n", "\n", "axs[1].legend(fontsize=26, loc='lower left', ncol=2)\n", "#---------------------\n", "axs[0].set_xlabel(r'$t/T_\\mathrm{circ}$')\n", "axs[0].set_ylabel(r'$\\hat{S}$')\n", "axs[0].set_ylim(9.,10.2)\n", "axs[0].set_xlim(0, 50)\n", " \n", "axs[1].set_xscale('log')\n", "axs[1].set_yscale('log')\n", "\n", "axs[1].set_xlabel(r'$N$')\n", "axs[1].set_ylim(1e-5,1e-1)\n", "axs[1].set_ylabel(r'$|\\delta S|/S_{\\mathrm{E, true}}$')\n", "\n", "plt.tight_layout()" ] }, { "cell_type": "markdown", "id": "3b2783c8-f213-4949-b4cc-3824277518ed", "metadata": {}, "source": [ "## Evolve initial sample in new potential" ] }, { "cell_type": "code", "execution_count": 10, "id": "babf8a38-7c02-4061-bed7-fe7b43f4617f", "metadata": {}, "outputs": [], "source": [ "M_new = 3. # mass of new potential (where we integrate orbits for a non-stationary sample)\n", "params = np.array([M_new, b, _G])" ] }, { "cell_type": "code", "execution_count": 11, "id": "6001551a-23bc-4409-a821-2c82c3f0477d", "metadata": {}, "outputs": [], "source": [ "# Set params and initialize arrays:\n", "\n", "Tcirc_new = np.full(len(n_orbs), np.nan) # mean circular period for each sample\n", "t_new = np.full((len(n_orbs), n_steps), np.nan) # time in the orbit integration\n", "S_6D_new = np.full((len(n_orbs), n_steps), np.nan) # Entropy evaluated in 6D\n", "\n", "# Entropies assuming the DF is f = f(E,L), or f = f(J) - now only expected to be valid after the system phase-mixes\n", "# These should be the same as S_6D if f = f(E,L), or f = f(J). In the current case, this happens at the late times only.\n", "\n", "S_EL_new = np.full(len(n_orbs), np.nan)\n", "S_J_new = np.full(len(n_orbs), np.nan)\n", "\n", "# new Potential:\n", "hern_pot_new = agama.Potential(type='Dehnen', mass=M_new, scaleRadius=b, gamma=1)\n", "# Action finder in the new potential:\n", "actF_new = agama.ActionFinder(hern_pot_new)" ] }, { "cell_type": "code", "execution_count": 12, "id": "495064ba-5e71-46e6-9156-5258d6cea8a9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------------------------\n", "Generating sample...\n", "S_6D estimated: 9.4889\n", "S_EL estimated: 9.6156\n", "S_J estimated: 9.60298\n", "j: 10 S_6D estimated: 10.18267\n", "j: 20 S_6D estimated: 10.13872\n", "j: 30 S_6D estimated: 10.14314\n", "j: 40 S_6D estimated: 10.13627\n", "j: 50 S_6D estimated: 10.15025\n", "j: 60 S_6D estimated: 10.15571\n", "j: 70 S_6D estimated: 10.11178\n", "j: 80 S_6D estimated: 10.12433\n", "j: 90 S_6D estimated: 10.12461\n", "-------------------------\n", "Generating sample...\n", "S_6D estimated: 9.34002\n", "S_EL estimated: 9.61739\n", "S_J estimated: 9.62378\n", "j: 10 S_6D estimated: 9.96748\n", "j: 20 S_6D estimated: 9.96711\n", "j: 30 S_6D estimated: 9.96719\n", "j: 40 S_6D estimated: 9.9733\n", "j: 50 S_6D estimated: 9.96378\n", "j: 60 S_6D estimated: 9.9606\n", "j: 70 S_6D estimated: 9.95244\n", "j: 80 S_6D estimated: 9.95738\n", "j: 90 S_6D estimated: 9.95828\n", "-------------------------\n", "Generating sample...\n", "S_6D estimated: 9.22782\n", "S_EL estimated: 9.60551\n", "S_J estimated: 9.60664\n", "j: 10 S_6D estimated: 9.78336\n", "j: 20 S_6D estimated: 9.82769\n", "j: 30 S_6D estimated: 9.83739\n", "j: 40 S_6D estimated: 9.83601\n", "j: 50 S_6D estimated: 9.83713\n", "j: 60 S_6D estimated: 9.8366\n", "j: 70 S_6D estimated: 9.83536\n", "j: 80 S_6D estimated: 9.83266\n", "j: 90 S_6D estimated: 9.8287\n" ] } ], "source": [ "# Same as before, but generating sample stationary in the potential with mass M=1, and evolving it in a potential with mass M=3.\n", "# Generate samples, integrate and estimate entropy:\n", "for i in range(len(n_orbs)):\n", " print ('-------------------------')\n", " dim = 6\n", " print ('Generating sample...')\n", " N = n_orbs[i]\n", " data,_ = agama.GalaxyModel(hern_pot, hern_df).sample(N)\n", " # data, _ = hern_pot.sample(N, potential=hern_pot) \n", " sigma_6D_0 = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in data.T])\n", " #------------------------------ \n", " # Estimate S_6D (at t=0; estimates over time are done below):\n", "\n", " S_6D_new[i, 0] = tropygal.entropy(data/sigma_6D_0)\n", " print ('S_6D estimated:', np.round(S_6D_new[i, 0], 5))\n", " #------------------\n", " # Estimate S_EL, i.e. assuming f = f(E,L):\n", "\n", " x = data[:,0]; y = data[:,1]; z = data[:,2]\n", " vx = data[:,3]; vy = data[:,4]; vz = data[:,5]\n", " \n", " v2 = vx**2 + vy**2 + vz**2\n", " pos = np.column_stack((x, y, z))\n", " E = hern_pot_new.potential(pos) + 0.5*v2\n", " sigma_E = 0.5*(np.percentile(E, 84) - np.percentile(E, 16))\n", " \n", " Lx = (y*vz - z*vy)\n", " Ly = (z*vx - x*vz)\n", " Lz = (x*vy - y*vx)\n", " L = np.sqrt(Lx**2 + Ly**2 + Lz**2)\n", " EL = np.column_stack((E, L))\n", " sigma_L = 0.5*(np.percentile(L, 84) - np.percentile(L, 16))\n", " sigma_EL = np.array([sigma_E, sigma_L])\n", "\n", " g_EL = tropygal.gEL_Spherical(E, L, tropygal.Phi_Hernquist, tropygal.dPhi_dr_Hernquist, params)\n", " # It's convenient to normalize coordinates in the space where the entropy is estimated,\n", " # but we want to stick to the entropy definition we used before, so the normalized coordinates are passed as the data,\n", " # and mu takes care of the appropriate factors in the change of variables for the integral defining the entropy to be the same:\n", " S_EL_new[i] = tropygal.entropy(EL/sigma_EL, mu= g_EL*np.prod(sigma_EL)/np.prod(sigma_6D_0))\n", " print ('S_EL estimated:', np.round(S_EL_new[i], 5))\n", " #------------------------------ \n", " # Estimate S_J, i.e. assuming f = f(J):\n", "\n", " J = actF_new(data, actions=True, frequencies=False, angles=False)\n", " sigma_J = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in J.T])\n", "\n", " S_J_new[i] = tropygal.entropy(J/sigma_J, mu= ((2.*np.pi)**3)*np.prod(sigma_J)/np.prod(sigma_6D_0))\n", " print ('S_J estimated:', np.round(S_J_new[i],5))\n", " #------------------------------ \n", " # Estimate S_6D at different times\n", "\n", " # define integration time (same for all orbits):\n", " Tcirc_new[i] = np.median(hern_pot_new.Tcirc(data))\n", " int_time = 50*Tcirc_new[i]\n", " delta_t = int_time/n_steps\n", " t_new[i, 0] = 0\n", "\n", " for j in range(1, n_steps):\n", " # Integrate orbits for one time-step:\n", " orbs = agama.orbit(potential=hern_pot_new, ic = data, time = delta_t, trajsize =1, verbose=False)\n", "\n", " t_new[i, j] = t_new[i, j-1] + delta_t\n", " all_coords = np.vstack(orbs[:,1]).reshape(len(x), 1, dim)\n", " # update data with new coords:\n", " data = all_coords[:,-1,:]\n", "\n", " sigma_6D = np.array([0.5*(np.percentile(coord, 84) - np.percentile(coord, 16)) for coord in data.T])\n", " # Here we re-normalize again at every time-step (to facilitate the estimate), \n", " # \"compensating\" for that in the mu factor, i.e. making an appropriate change of variables every time-step:\n", " S_6D_new[i,j] = tropygal.entropy(data/sigma_6D, mu=np.prod(sigma_6D)/np.prod(sigma_6D_0))\n", " if (j%10==0):\n", " print ('j:', j, 'S_6D estimated:', np.round(S_6D_new[i, j], 5))" ] }, { "cell_type": "markdown", "id": "48927f0f-e34b-4e6c-bcc0-25627c9d1962", "metadata": {}, "source": [ "## Plot" ] }, { "cell_type": "code", "execution_count": 13, "id": "cb98138c-2908-45d5-b7b2-a626663d358b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 834, "width": 473 } }, "output_type": "display_data" } ], "source": [ "# Plot\n", "fig, axs = plt.subplots(2, 1, figsize=(8,14))\n", "fig.patch.set_facecolor('white')\n", "axs[0].set_title(r'Hernquist Model: $M_\\mathrm{ini}=1$; $M_\\mathrm{pot}=3$')\n", "axs[1].set_title('Entropy variation')\n", "\n", "ones = np.ones(n_steps)\n", "axs[0].axhline(y=S_EL_new[-1], color='grey', linestyle='-', lw=4, zorder=0)#, label=r'$S_{EL}$')\n", "\n", "for i in range(len(n_orbs)):\n", " axs[0].plot(t_new[i]/Tcirc_new[i], S_6D_new[i], ls='-', lw=2, c=N_colors[i])\n", " axs[0].plot(t_new[i]/Tcirc_new[i], S_J_new[i]*ones, ls='--', dashes=(8,5), lw=2, c=N_colors[i])\n", "\n", "p4, = axs[0].plot(t_new[-1]/Tcirc_new[-1], S_EL_new[-1]*ones, color='grey', ls='-', lw=4, zorder=0)\n", "\n", "axs[0].legend([p1, p2, p4], [r'$\\hat{S}_\\mathrm{6D}$', r'$\\hat{S}_{\\vec{J}}$', r'$\\hat{S}_{\\mathrm{EL, true}}$'], \n", " loc = 'lower left', fontsize=24)\n", "#---------------------\n", "# inset axes:\n", "x1, x2, y1, y2 = 35, 49.5, 9.595, 9.665 # subregion of the original image\n", "axins = axs[0].inset_axes([0.51, 0.1, 0.43, 0.3],\n", " xlim=(x1, x2), ylim=(y1, y2), xticklabels=[])#, yticklabels=[])\n", "axins.axhline(y=S_EL_new[-1], color='grey', linestyle='-', lw=4, zorder=0)\n", "for i in range(len(n_orbs)):\n", " axins.plot(t_new[i]/Tcirc_new[i], S_J_new[i]*ones, ls='--', dashes=(8,5), lw=2, c=N_colors[i])\n", "\n", "axs[0].indicate_inset_zoom(axins, edgecolor=\"black\")\n", "#---------------------\n", "# We take the final S_EL (estimated with the largest sample) as the true final S_EL:\n", "axs[1].axhline(y=S_EL_new[-1] - S_E_true[-1], \n", " color='grey', linestyle='-', lw=4, label=r'$\\Delta S_\\mathrm{true} = \\hat{S}_{\\mathrm{EL, true}} - S_{\\mathrm{E, true}}$')\n", "\n", "for i in range(len(n_orbs)):\n", " axs[1].plot(t_new[i]/Tcirc_new[i], S_6D_new[i]-S_6D_new[i, 0], ls='-', lw=2, c=N_colors[i], label=N_label_plot[i]) # Plotting Delta S\n", "\n", "axs[0].set_ylabel(r'$\\hat{S}$')\n", "axs[0].set_ylim(9.0, 10.2)\n", "axs[1].set_ylabel(r'$\\hat{S}_\\mathrm{6D}(t) - \\hat{S}_\\mathrm{6D}(0)$')\n", "axs[1].set_ylim(0, 0.7)\n", "axs[1].legend(fontsize=24)\n", "\n", "for i in range(2):\n", " axs[i].set_xlim(0, 50)\n", " axs[i].set_xlabel(r'$t/T_\\mathrm{circ}$')\n", "\n", "plt.tight_layout()" ] }, { "cell_type": "code", "execution_count": null, "id": "d4cab533-a9a9-49c3-be19-8c6b776c1f01", "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.11.8" } }, "nbformat": 4, "nbformat_minor": 5 }