diff --git a/code_new/Results_Mock.ipynb b/code_new/Results_Mock.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..34cf04ec962e365b589e49ee0ae74ba2c663c22c --- /dev/null +++ b/code_new/Results_Mock.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy import interpolate\n", + "import corner\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator\n", + "from matplotlib import rc\n", + "from configparser import ConfigParser\n", + "import codecs\n", + "from scipy.interpolate import interp1d\n", + "\n", + "#plt.rcParams['font.family'] = 'DejaVu Sans'\n", + "#rc('text', usetex=True)\n", + "plt.rcParams.update({'font.size': 16.5})\n", + "\n", + "import ptemcee\n", + "#from pycbc.pool import choose_pool\n", + "from multiprocessing import Pool\n", + "import h5py\n", + "import inspect\n", + "import pandas as pd\n", + "import json\n", + "import qnm\n", + "import random\n", + "import dynesty\n", + "from dynesty import plotting as dyplot\n", + "import os\n", + "import glob\n", + "import csv\n", + "import re\n", + "from re import match\n", + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "f_fpars= [[2.95845, -2.58697, 0.0533469], [2.12539, -1.78054, \n", + " 0.0865503], [1.74755, -1.44776, 0.123666], [1.78287, -1.53203, \n", + " 0.129475], [2.04028, -1.83224, 0.112497]]\n", + "\n", + "q_fpars=[[0.584077, 1.52053, -0.480658], [0.00561441, \n", + " 0.630715, -0.432664], [-0.197965, 0.515956, -0.369706], [-0.275097, \n", + " 0.455691, -0.331543], [-0.287596, 0.398514, -0.309799]]\n", + "\n", + "def w_fpars_Berti(n):\n", + " return f_fpars[n]\n", + "\n", + "def tau_qpars_Berti(n):\n", + " return q_fpars[n]\n", + "\n", + "def mass_from_wtau(n,w,tau):\n", + " f1,f2,f3 = w_fpars_Berti(n)\n", + " q1,q2,q3 = tau_qpars_Berti(n)\n", + " res=(f1 + f2*(2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3))**f3)/w\n", + " return res\n", + "\n", + "def spin_from_wtau(n,w,tau):\n", + " f1,f2,f3 = w_fpars_Berti(n)\n", + " q1,q2,q3 = tau_qpars_Berti(n)\n", + " res=1 - 2**(-1/q3)*((-2*q1 + w*tau)/q2)**(1/q3)\n", + " return res\n", + "\n", + "def sort_pickles(x):\n", + " try:\n", + " res=np.float(x[-32:-28])\n", + " except ValueError:\n", + " res=np.float(x[-31:-28])\n", + " \n", + " return(res)\n", + "\n", + "def sort_pickles(x):\n", + " m = re.search('tshift_(.+?)_w',x)\n", + " res=np.float(m.group(1))\n", + " return(res)\n", + "\n", + "def select_folders(folders,r): \n", + " #res=glob.glob(case+'/'+pattern) \n", + " res = list(filter(r.match, folders)) \n", + " return res\n", + "\n", + "def QNM_spectrum(mf,af,l,m,n):\n", + " \"\"\" It computes the RD frequencies and damping times in NR units.\n", + " \"\"\" \n", + " omegas_new=[qnm.modes_cache(s=-2,l=2,m=2,n=i)(a=af)[0] for i in range (0,n+1)]\n", + " w_m_a = (np.real(omegas_new))/mf\n", + " tau_m_a=-1/(np.imag(omegas_new))*mf\n", + " \n", + " return (w_m_a[n], tau_m_a[n])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "rootpath='/work/francisco.jimenez/sio/git/rdstackingproject/results_new/'\n", + "metadata_file='/work/francisco.jimenez/sio/git/rdstackingproject/SXS/BBH_SKS_d14.3_q1.22_sA_0_0_0.330_sB_0_0_-0.440/Lev6/metadata.json'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "metadata = {}\n", + "with open(metadata_file) as file:\n", + " metadata = json.load(file)\n", + "\n", + "af = metadata['remnant_dimensionless_spin'][-1]\n", + "mf = metadata['remnant_mass']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['backup_new', 'backup', '0062', '0305', 'RT_0062', '0355', '1107', '0355s', 'GT_0355']\n" + ] + } + ], + "source": [ + "dirs=os.listdir(rootpath)\n", + "print(dirs)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_0_w-tau-nmax0_False_fitnoise_False',\n", + " '/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_2_w-tau-nmax0_False_fitnoise_False',\n", + " '/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_5_w-tau-nmax0_False_fitnoise_False'],\n", + " dtype='<U116')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "index=3\n", + "case= rootpath+dirs[index]\n", + "folders=[x[0] for x in os.walk(case)][1:]\n", + "folders=np.sort(folders)[[1,4,5]]\n", + "folders" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#r = re.compile(\".*w-tau-n.*_True_$\")\n", + "#r = re.compile(\".*__fitnoise_True$\")\n", + "#folders=select_folders(folders,r)\n", + "#folders" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "regular_list = [glob.glob(x+'/summary*.csv') for x in folders]\n", + "sum_files = [item for sublist in regular_list for item in sublist]\n", + "\n", + "pickle_files_v1 = [glob.glob(x+'/*pkl*') for x in folders] \n", + "pickle_files = [sorted(x, key = sort_pickles) for x in pickle_files_v1]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Phase_0_w-tau-nmax0_False_fitnoise_False',\n", + " 'Phase_2_w-tau-nmax0_False_fitnoise_False',\n", + " 'Phase_5_w-tau-nmax0_False_fitnoise_False']" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tags= [\"\" for x in range(len(sum_files))]\n", + "for i in range(len(sum_files)):\n", + " tags[i]=os.path.basename(os.path.dirname(sum_files[i]))\n", + "tags" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "csv_data=[pd.read_csv(x, error_bad_lines=False) for x in sum_files]\n", + "csv_data_new_v1=[csv_data[i].sort_values(by=[\"t_shift\"], ascending=True) for i in range(len(csv_data))]\n", + "csv_data_new=[csv_data_new_v1[i].reset_index(drop=True) for i in range(len(csv_data))]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# to import pkl files. They are too big so use it conveniently. \n", + "#for i in range(len(pickle_files)):\n", + "# with open(results_file,'rb') as f:\n", + "# company1 = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "colors=['red','blue','black','orange','cyan','green','purple','pink','gold','olive','red','blue','black','orange','cyan','green']" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "position_fixed = [i for i, s in enumerate(tags) if 'fixed-n' in s]\n", + "position_fixed_m_af = [i for i, s in enumerate(tags) if 'fixed-m-af' in s]\n", + "\n", + "position_var_cte = [i for i, s in enumerate(tags) if '002' in s]\n", + "position_aux=np.concatenate((position_fixed,position_var_cte))\n", + "\n", + "position_var=(set([i for i in range(len(tags))])-set(position_aux))\n", + "position_var=np.array(list(position_var))\n", + "\n", + "tags_fixed=[tags[i] for i in position_fixed]\n", + "tags_var=[tags[i] for i in position_var]\n", + "tags_var_cte=[tags[i] for i in position_var_cte]\n", + "\n", + "csv_data_var=[csv_data_new[i] for i in position_var]\n", + "csv_data_var_cte=[csv_data_new[i] for i in position_var_cte]\n", + "csv_data_fixed=[csv_data_new[i] for i in position_fixed]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "position_fixed_m_af\n", + "tags_var_m_af = [tags[i] for i in position_fixed_m_af]\n", + "tags_var_m_af" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "tags_var_m_af = [tags[i] for i in position_fixed_m_af]\n", + "position_fixed_m_af_True = [i for i, s in enumerate(tags_var_m_af) if 'True' in s]\n", + "csv_data_var_m_af=[csv_data_new[i] for i in position_fixed_m_af_True]\n", + "tags_var_m_af=[tags[i] for i in position_fixed_m_af_True]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "position_var = [i for i, s in enumerate(tags) if '*_True' in s]\n", + "position_var = [re.match(s,\"_True\" ) for s in tags]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "r = re.compile(\"w-tau-n.*_True$\")\n", + "tags_var = list(filter(r.match, tags)) # Read Note\n", + "position_var = [tags.index(i) for i in tags_var ]\n", + "csv_data_var=[csv_data[i] for i in position_var]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x576 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (12, 8))\n", + "\n", + "[plt.errorbar(csv_data[i]['t_shift'], -csv_data[i]['dlogz'], yerr=csv_data[i]['dlogz_err'], fmt='o',color=colors[i],label =tags[i]) for i in range(len(tags))] \n", + "plt.yscale('log')\n", + "\n", + "plt.legend(loc ='upper right') \n", + "plt.xlabel(r'$t_0/M$')\n", + "plt.ylabel(r'$|evidence|$')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "omegas = [qnm.modes_cache(s=-2,l=2,m=2,n=i)(a=af)[0] for i in range (0,6)]\n", + "w = (np.real(omegas))/mf\n", + "tau=-1/(np.imag(omegas))*mf\n", + "#csv_data_fixed[3]=csv_data_fixed[3][0::2]" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x576 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x576 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (12, 8))\n", + "[plt.errorbar(csv_data[i]['t_shift'],-csv_data[i]['dlogz'], yerr=csv_data[i]['dlogz_err'], fmt='o',color=colors[i],label =tags[i]) for i in range(len(csv_data))] \n", + "plt.yscale('log')\n", + "plt.legend(loc ='upper right') \n", + "plt.xlabel(r'$t_0/M$')\n", + "plt.ylabel(r'$logz$')\n", + "plt.show()\n", + "\n", + "#plt.figure(figsize = (12, 8))\n", + "#[plt.errorbar(csv_data_var[i]['t_shift'],csv_data_var[i]['dlogz'], yerr=csv_data_var[i]['dlogz_err'], fmt='o',color=colors[i],label =tags_var[i]) for i in range(len(csv_data_var))] \n", + "#plt.yscale('log')\n", + "#plt.legend(loc ='upper right') \n", + "#plt.xlabel(r'$t_0/M$')\n", + "#plt.ylabel(r'$logz$')\n", + "#plt.ylim(0,1000)\n", + "#plt.show()\n", + "\n", + "\n", + "plt.figure(figsize = (12, 8))\n", + "\n", + "[plt.errorbar(csv_data_var[i]['t_shift'], (csv_data[i]['dlogz']-csv_data[-1]['dlogz']), yerr=csv_data[i]['dlogz_err']+csv_data[-1]['dlogz_err'], fmt='o',color=colors[i],label =tags[i]) for i in range(len(csv_data_var)-1)] \n", + "plt.legend(loc ='upper right') \n", + "plt.xlabel(r'$t_0/M$')\n", + "plt.xlim(0,24)\n", + "plt.ylim(-50,100)\n", + "plt.axvline(x=tau[0],color=colors[0],linestyle='--')\n", + "plt.axvline(x=tau[1],color=colors[1],linestyle='--')\n", + "plt.axvline(x=tau[2],color=colors[2],linestyle='--')\n", + "plt.axvline(x=tau[3],color=colors[3],linestyle='--')\n", + "plt.axvline(x=tau[4],color=colors[4],linestyle='--')\n", + "plt.axvline(x=tau[5],color=colors[5],linestyle='--')\n", + "plt.hlines(0, 0, 20,colors='k', linestyles='solid')\n", + "plt.hlines(10, 0, 20,colors='k', linestyles='--')\n", + "plt.hlines(-10, 0, 20,colors='k', linestyles='--')\n", + "\n", + "plt.ylabel(r'$log \\mathcal{B}$')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_0_w-tau-nmax0_False_fitnoise_False/best_values_305_w-tau_nmax_0.csv',\n", + " '/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_2_w-tau-nmax0_False_fitnoise_False/best_values_305_w-tau_nmax_0.csv',\n", + " '/work/francisco.jimenez/sio/git/rdstackingproject/results_new/0305/Phase_5_w-tau-nmax0_False_fitnoise_False/best_values_305_w-tau_nmax_0.csv'],\n", + " dtype='<U140')" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "regular_list = np.asarray(sorted(np.asarray([glob.glob(x+'/best*value*.csv') for x in folders])))\n", + "regular_list=(regular_list.flatten())\n", + "regular_list" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "regular_list_var=regular_list" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_vars_n=[pd.read_csv(x, error_bad_lines=False) for x in regular_list]\n", + "len(best_vars_n)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "grav_220 = [qnm.modes_cache(s=-2,l=2,m=2,n=i)(a=af)[0] for i in range (0,6)]\n", + "w = (np.real(omegas))/mf\n", + "tau=-1/(np.imag(omegas))*mf" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([11.74090006, 3.88312743, 2.29980777, 1.62209641, 1.25654938,\n", + " 1.03071732])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tau" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n" + ] + }, + { + "data": { + "text/plain": [ + "[Text(0.5, 0, '$t/M$')]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1152x576 with 4 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index=0\n", + "tshift=best_vars_n[index][r'tshift']\n", + "best_vars_n_w0=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_up=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_low=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "best_vars_n_tau0=np.asarray([x[r'$\\tau_0$'] for x in best_vars_n[index:index+1]])\n", + "best_vars_n_a0=np.asarray([x[r'$A_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "fig, axs = plt.subplots(2, 2,figsize=(16,8))\n", + "axs[0,0].set_title(tags[index])\n", + "axs[0,0].errorbar(tshift[0::3],best_vars_n_w0[0][0::3]/w[0], yerr=np.abs(best_vars_n_w0[0][1::3]-best_vars_n_w0[0][2::3])/w[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[0,0].set(ylabel=r'$\\omega_0$')\n", + "axs[0,0].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[0,1].errorbar(tshift[0::3],best_vars_n_tau0[0][0::3]/tau[0], yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "plt.legend(loc ='upper right') \n", + "axs[0,1].set(ylabel=r'$\\tau_0$')\n", + "axs[0,1].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[1,0].errorbar(tshift[0::3],mass_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/mf, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,0].set(ylabel=r'$mass$')\n", + "axs[1,0].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,0].set(xlabel=r'$t/M$')\n", + "\n", + "axs[1,1].errorbar(tshift[0::3],spin_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/af, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,1].set(ylabel=r'$spin$')\n", + "axs[1,1].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,1].set(xlabel=r'$t/M$')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 0, '$t/M$')]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1152x576 with 4 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index=1\n", + "tshift=best_vars_n[index][r'tshift']\n", + "best_vars_n_w0=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_up=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_low=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "best_vars_n_tau0=np.asarray([x[r'$\\tau_0$'] for x in best_vars_n[index:index+1]])\n", + "best_vars_n_a0=np.asarray([x[r'$A_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "fig, axs = plt.subplots(2, 2,figsize=(16,8))\n", + "axs[0,0].set_title(tags[index])\n", + "axs[0,0].errorbar(tshift[0::3],best_vars_n_w0[0][0::3]/w[0], yerr=np.abs(best_vars_n_w0[0][1::3]-best_vars_n_w0[0][2::3])/w[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[0,0].set(ylabel=r'$\\omega_0$')\n", + "axs[0,0].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[0,1].errorbar(tshift[0::3],best_vars_n_tau0[0][0::3]/tau[0], yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[0,1].set(ylabel=r'$\\tau_0$')\n", + "axs[0,1].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[1,0].errorbar(tshift[0::3],mass_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/mf, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,0].set(ylabel=r'$mass$')\n", + "axs[1,0].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,0].set(xlabel=r'$t/M$')\n", + "\n", + "axs[1,1].errorbar(tshift[0::3],spin_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/af, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,1].set(ylabel=r'$spin$')\n", + "axs[1,1].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,1].set(xlabel=r'$t/M$')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 0, '$t/M$')]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1152x576 with 4 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "index=2\n", + "tshift=best_vars_n[index][r'tshift']\n", + "best_vars_n_w0=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_up=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "err_vars_n_w0_low=np.asarray([x[r'$\\omega_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "best_vars_n_tau0=np.asarray([x[r'$\\tau_0$'] for x in best_vars_n[index:index+1]])\n", + "best_vars_n_a0=np.asarray([x[r'$A_0$'] for x in best_vars_n[index:index+1]])\n", + "\n", + "fig, axs = plt.subplots(2, 2,figsize=(16,8))\n", + "axs[0,0].set_title(tags[index])\n", + "axs[0,0].errorbar(tshift[0::3],best_vars_n_w0[0][0::3]/w[0], yerr=np.abs(best_vars_n_w0[0][1::3]-best_vars_n_w0[0][2::3])/w[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[0,0].set(ylabel=r'$\\omega_0$')\n", + "axs[0,0].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[0,1].errorbar(tshift[0::3],best_vars_n_tau0[0][0::3]/tau[0], yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[0,1].set(ylabel=r'$\\tau_0$')\n", + "axs[0,1].axhline(y=1, color='r', linestyle='-')\n", + "\n", + "axs[1,0].errorbar(tshift[0::3],mass_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/mf, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,0].set(ylabel=r'$mass$')\n", + "axs[1,0].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,0].set(xlabel=r'$t/M$')\n", + "\n", + "axs[1,1].errorbar(tshift[0::3],spin_from_wtau(0,best_vars_n_w0[0][0::3],best_vars_n_tau0[0][0::3])/af, yerr=np.abs(best_vars_n_tau0[0][1::3]-best_vars_n_tau0[0][2::3])/tau[0],fmt='o',label='n=0',color=colors[2])\n", + "axs[1,1].set(ylabel=r'$spin$')\n", + "axs[1,1].axhline(y=1, color='r', linestyle='-')\n", + "axs[1,1].set(xlabel=r'$t/M$')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}