diff options
Diffstat (limited to 'ipynbs/fig2.ipynb')
| -rw-r--r-- | ipynbs/fig2.ipynb | 533 |
1 files changed, 533 insertions, 0 deletions
diff --git a/ipynbs/fig2.ipynb b/ipynbs/fig2.ipynb new file mode 100644 index 0000000..38f9eaa --- /dev/null +++ b/ipynbs/fig2.ipynb @@ -0,0 +1,533 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Figure 2\"\"\"\n", + "import sys\n", + "sys.path.extend(['.', '..'])\n", + "\n", + "import numpy as np\n", + "import matplotlib as mpl\n", + "from matplotlib import rc\n", + "rc('text', usetex='True')\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Circle, Rectangle, Wedge\n", + "import matplotlib.colors as mcolors\n", + "from matplotlib.legend_handler import HandlerPatch\n", + "import matplotlib.gridspec as gridspec\n", + "plt.style.use('./paper.mplstyle')\n", + "\n", + "mpl.rcParams['text.latex.preamble'] = [\n", + " r'\\usepackage{amsmath}',\n", + " r'\\usepackage{amssymb}',\n", + " r'\\usepackage{accents}',\n", + " r'\\DeclareSymbolFont{matha}{OML}{txmi}{m}{it}',\n", + " r'\\DeclareMathSymbol{\\nu}{\\mathord}{matha}{118}']\n", + "mpl.rcParams['text.latex.unicode'] = True\n", + "\n", + "from scipy import interpolate\n", + "from tqdm import tqdm_notebook as tqdm\n", + "import shapely.geometry as sg\n", + "import shapely.ops as so\n", + "\n", + "import warnings\n", + "with warnings.catch_warnings():\n", + " import ternary\n", + "\n", + " warnings.simplefilter(\"ignore\")\n", + " from utils import fr as fr_utils\n", + " from utils import misc as misc_utils\n", + " from utils import plot as plot_utils\n", + "\n", + "from unitarity import calc_unitarity_bounds\n", + " \n", + "tRed = list(np.array([226,101,95]) / 255.)\n", + "tBlue = list(np.array([96,149,201]) / 255.)\n", + "tGreen = list(np.array([170,196,109]) / 255.)\n", + "grey = list(mcolors.to_rgb('grey'))\n", + "fontsize = 23\n", + "nbins = 25" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 0, 0] -> [ 0.550 0.183 0.267] = [ 0.537 0.501]\n", + "[0, 1, 0] -> [ 0.183 0.438 0.379] = [ 0.385 -0.410]\n", + "[1, 2, 0] -> [ 0.305 0.353 0.342] = [ 0.433 -0.072]\n", + "[0, 0, 1] -> [ 0.267 0.379 0.354] = [ 0.418 -0.174]\n", + "-> [ 0.260 0.418 0.322] = [ 0.460 -0.233]\n", + "[0.26, 0.4179999999999999, 0.32200000000000006]\n", + "-> [ 0.533 0.230 0.237] = [ 0.582 0.397]\n", + "-> [ 0.206 0.434 0.361] = [ 0.409 -0.356]\n" + ] + } + ], + "source": [ + "s = [1, 0, 0]\n", + "m = fr_utils.u_to_fr(s, np.array(fr_utils.NUFIT_U, dtype=np.complex128))\n", + "print s, r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "s = [0, 1, 0]\n", + "m = fr_utils.u_to_fr(s, np.array(fr_utils.NUFIT_U, dtype=np.complex128))\n", + "print s, r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "s = [1, 2, 0]\n", + "m = fr_utils.u_to_fr(s, np.array(fr_utils.NUFIT_U, dtype=np.complex128))\n", + "print s, r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "s = [0, 0, 1]\n", + "m = fr_utils.u_to_fr(s, np.array(fr_utils.NUFIT_U, dtype=np.complex128))\n", + "print s, r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "m = [0.26, 0.418, 0.322]\n", + "print r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "print map(float, fr_utils.angles_to_fr(fr_utils.fr_to_angles(m)))\n", + "m = [0.533, 0.230, 0.237]\n", + "print r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))\n", + "m = [0.206, 0.434, 0.361]\n", + "print r'-> [{0:6.3f} {1:6.3f} {2:6.3f}]'.format(*m), r'= [{0:6.3f} {1:6.3f}]'.format(*fr_utils.fr_to_angles(m))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class HandlerCircle(HandlerPatch):\n", + " def create_artists(self, legend, orig_handle,\n", + " xdescent, ydescent, width, height,\n", + " fontsize, trans):\n", + " r = 10\n", + " x = r + width//2 + 10\n", + " y = height//2 - 3\n", + "\n", + " # create \n", + " p = Circle(xy=(x, y), radius=r)\n", + "\n", + " # update with data from oryginal object\n", + " self.update_prop(p, orig_handle, legend)\n", + "\n", + " # move xy to legend\n", + " p.set_transform(trans)\n", + "\n", + " return [p]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def alp(x):\n", + " y = list(x)\n", + " y[-1] = 0.7\n", + " return y\n", + "\n", + "def cmap_discretize(cmap, N):\n", + " colors_i = np.concatenate((np.linspace(0, 1., N), (0.,0.,0.,0.)))\n", + " colors_rgba = cmap(colors_i)\n", + " indices = np.linspace(0, 1., N+1)\n", + " cdict = {}\n", + " for ki,key in enumerate(('red','green','blue')):\n", + " cdict[key] = [ (indices[i], colors_rgba[i-1,ki], colors_rgba[i,ki]) for i in xrange(N+1) ]\n", + " # Return colormap object.\n", + " return mpl.colors.LinearSegmentedColormap(cmap.name + \"_%d\"%N, cdict, 1024)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.48612238851e+38\n", + "6.8279454231019425\n", + "-6.8279454231019425\n" + ] + } + ], + "source": [ + "PS = 1/8.203e-20 # GeV\n", + "PS_D6 = PS**2\n", + "print PS_D6\n", + "\n", + "print np.log10(1e45 / PS_D6)\n", + "print np.log10(1e-45 * PS_D6)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Load chains for NuFIT + BSM textures + HESE contour\n", + "SM_X = np.load('./chains/mc_x.npy')\n", + "\n", + "T13_010 = np.genfromtxt('./frs/fr_DIM6_sfr_0_1_0_mfr_1_1_1_MixingScenario.T13_flat.txt')\n", + "T23_100 = np.genfromtxt('./frs/fr_DIM6_sfr_1_0_0_mfr_1_1_1_MixingScenario.T23_flat.txt')\n", + "\n", + "bc_chains = np.load('./chains/contour_REAL.npy')\n", + "flavour_angles = bc_chains[:,-2:]\n", + "flavour_ratios = np.array(\n", + " map(fr_utils.angles_to_fr, flavour_angles)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Process only n points for plotting\n", + "n = 10000\n", + "T13_010 = np.vstack([T13_010[T13_010[:,2]<0.1][:int(n/5.)], T13_010[T13_010[:,2]>=0.1][:int(4*n/5.)]])\n", + "T23_100 = np.vstack([T23_100[T23_100[:,0]<=0.9][:int(4*n/5.)], T23_100[T23_100[:,0]>0.9][:int(n/5.)]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10000, 4)\n", + "(10000, 4)\n" + ] + } + ], + "source": [ + "print T13_010.shape\n", + "print T23_100.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate unitary boundaries\n", + "f_s_120 = fr_utils.normalise_fr((1, 2, 0))\n", + "f_s_010 = fr_utils.normalise_fr((0, 1, 0))\n", + "f_s_100 = fr_utils.normalise_fr((1, 0, 0))\n", + "\n", + "n_samples = 1000\n", + "f_m_120 = calc_unitarity_bounds(f_s_120, n_samples)\n", + "f_m_010 = calc_unitarity_bounds(f_s_010, n_samples)\n", + "f_m_100 = calc_unitarity_bounds(f_s_100, n_samples)\n", + "\n", + "p1 = sg.Polygon(map(plot_utils.project, f_m_010))\n", + "p2 = sg.Polygon(map(plot_utils.project, f_m_100))\n", + "c = so.cascaded_union([p1,p2])\n", + "f_m_x = np.array(map(\n", + " lambda x: plot_utils.project_toflavour(x, nbins), zip(*c.exterior.xy)\n", + "))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min_scale -52.0\n", + "max_scale -40.0\n", + "min_scale -13.827945423101944\n", + "max_scale -1.8279454231019443\n" + ] + } + ], + "source": [ + "# Work out upper and lower axis\n", + "d = [T13_010, T23_100]\n", + "min_scale = 1E100\n", + "max_scale = -1E100\n", + "\n", + "for i in d:\n", + " min_scale = min_scale if min_scale < np.min(i[:,-1]) else np.min(i[:,-1])\n", + " max_scale = max_scale if max_scale > np.max(i[:,-1]) else np.max(i[:,-1])\n", + "\n", + "print 'min_scale', min_scale\n", + "print 'max_scale', max_scale\n", + "\n", + "min_scale += np.log10(PS_D6)\n", + "max_scale += np.log10(PS_D6)\n", + "\n", + "print 'min_scale', min_scale\n", + "print 'max_scale', max_scale" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# Colouring\n", + "cmap_g = mpl.colors.LinearSegmentedColormap.from_list(\"\", [\"lime\", \"gold\", \"darkorange\"])\n", + "cmap_b = mpl.colors.LinearSegmentedColormap.from_list(\"\", [\"blue\", \"fuchsia\", \"darkmagenta\"])\n", + "cmap_010 = cmap_discretize(cmap_g, 10)\n", + "cmap_100 = cmap_discretize(cmap_b, 10)\n", + "cmap_001 = cmap_discretize(cmap_b, 10)\n", + "\n", + "norm = mpl.colors.Normalize(vmin=min_scale, vmax=max_scale)\n", + "\n", + "color_010 = map(alp, map(cmap_010, map(norm, T13_010[:,-1]+np.log10(PS_D6))))\n", + "color_100 = map(alp, map(cmap_100, map(norm, T23_100[:,-1]+np.log10(PS_D6))))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "../utils/plot.py:297: RuntimeWarning: divide by zero encountered in double_scalars\n", + " circum_r = a*b*c/(4.0*area)\n", + "../utils/plot.py:296: RuntimeWarning: invalid value encountered in sqrt\n", + " area = np.sqrt(s*(s-a)*(s-b)*(s-c))\n", + "/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/scipy/interpolate/_fitpack_impl.py:226: RuntimeWarning: Setting x[0][300]=x[0][0]\n", + " (i, m, i)))\n", + "/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/scipy/interpolate/_fitpack_impl.py:226: RuntimeWarning: Setting x[1][300]=x[1][0]\n", + " (i, m, i)))\n" + ] + } + ], + "source": [ + "# Calculate nufit boundary\n", + "polys = []\n", + "for x in (SM_X[SM_X[:,0]>=(1/3.)], SM_X[SM_X[:,0]<(1/3.)]):\n", + " polys.append(plot_utils.flavour_contour(\n", + " frs = x,\n", + " plot = False,\n", + " nbins = nbins,\n", + " coverage = 95,\n", + " oversample = 15,\n", + " delaunay = True,\n", + " d_alpha = 0.04,\n", + " d_gauss = 0.02,\n", + " smoothing = 4,\n", + " hist_smooth = 0.03\n", + " ))\n", + "p1 = sg.Polygon(polys[0])\n", + "p2 = sg.Polygon(polys[1])\n", + "nufit_bound = so.cascaded_union([p1,p2]).exterior.xy" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Figure\n", + "fig = plt.figure(figsize=(12, 12))\n", + "gs = gridspec.GridSpec(2, 1, height_ratios=[40, 1])\n", + "gs.update(hspace=0.3, wspace=0.15)\n", + "\n", + "# Axis\n", + "ax = fig.add_subplot(gs[0])\n", + "ax_labels = [r'$\\nu_e\\:\\:{\\rm fraction}\\:\\left( f_{e,\\oplus}\\right)$',\n", + " r'$\\nu_\\mu\\:\\:{\\rm fraction}\\:\\left( f_{\\mu,\\oplus}\\right)$',\n", + " r'$\\nu_\\tau\\:\\:{\\rm fraction}\\:\\left( f_{\\tau,\\oplus}\\right)$']\n", + "tax = plot_utils.get_tax(ax, scale=nbins, ax_labels=ax_labels, rot_ax_labels=True)\n", + "\n", + "# Plot HESE contour\n", + "coverages = {68: 'grey', 90: 'darkgrey'}\n", + "for cov in coverages.iterkeys():\n", + " plot_utils.flavour_contour(\n", + " frs = flavour_ratios,\n", + " ax = ax,\n", + " nbins = nbins,\n", + " coverage = cov,\n", + " linewidth = 2.5,\n", + " color = coverages[cov],\n", + " alpha = 1,\n", + " zorder = 6,\n", + " oversample = 1.5\n", + " )\n", + "# Text\n", + "ax.text(0.34*nbins, 0.233*nbins, r'$68\\%$', fontsize=fontsize, rotation=7, zorder=6)\n", + "ax.text(0.34*nbins, 0.13*nbins, r'$90\\%$', fontsize=fontsize, rotation=3, zorder=6)\n", + "\n", + "# # Plot BSM scatter\n", + "tax.scatter(T13_010[:,:-1]*nbins, marker='.', s=2, alpha=0.5, color=color_010, zorder=8)\n", + "tax.scatter(T23_100[:,:-1]*nbins, marker='.', s=2, alpha=0.5, color=color_100, zorder=8)\n", + "\n", + "# Plot unitary regions\n", + "for f_m, col in reversed(zip((f_m_120, f_m_x), (tRed, grey))):\n", + " plot_utils.tax_fill(\n", + " ax=ax,\n", + " points=f_m,\n", + " nbins=nbins,\n", + " linewidth = 0.5,\n", + " facecolor = col+[0.3],\n", + " edgecolor = col,\n", + " zorder = 3\n", + " )\n", + "\n", + "# Plot NuFIT boundary\n", + "ax.fill(\n", + " nufit_bound[0], nufit_bound[1],\n", + " linewidth = 1.5,\n", + " edgecolor = 'None',\n", + " facecolor = 'white',\n", + " alpha = 1,\n", + " zorder = 4,\n", + ")\n", + "ax.fill(\n", + " nufit_bound[0], nufit_bound[1], \n", + " linewidth = 1.5,\n", + " edgecolor = 'k',\n", + " facecolor = 'None',\n", + " alpha = 1,\n", + " zorder = 5,\n", + " hatch = 'XXX'\n", + ")\n", + "\n", + "# Legend Right\n", + "l_size = fontsize\n", + "legend_elements = []\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor=grey+[0.8], edgecolor='k',\n", + " linewidth=2., label=r'$\\rm New\\:Physics\\:Territory$')\n", + ")\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor=tRed, edgecolor='k',\n", + " linewidth=2., label=r'$(1:2:0\\smash{)_{\\rm S}}$')\n", + ")\n", + "legend = plt.legend(\n", + " handles=legend_elements,\n", + " loc=(0.65, 0.8),\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()}\n", + ")\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "ax.add_artist(legend)\n", + "\n", + "# Legend Left\n", + "legend_elements = []\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='none', hatch='XXX', edgecolor='k',\n", + " linewidth=2., label=r'$\\rm Standard\\:Model$')\n", + ")\n", + "legend = plt.legend(\n", + " handles=legend_elements,\n", + " loc=(-0.05, 0.85),\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()}\n", + ")\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "\n", + "# Colorbar Left\n", + "gs00 = gridspec.GridSpecFromSubplotSpec(1, 2, subplot_spec=gs[1])\n", + "ax0 = fig.add_subplot(gs00[0])\n", + "cb = mpl.colorbar.ColorbarBase(\n", + " ax0, cmap=cmap_010, norm=norm, orientation='horizontal'\n", + ")\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax0.text(\n", + " 0.5, 2, r'$(0:1:0\\smash{)_{\\rm S}}\\:{\\rm w}/\\:\\mathcal{O}_{e\\tau}\\:{\\rm texture}$',\n", + " fontsize=fontsize, rotation=0, verticalalignment='center', horizontalalignment='center'\n", + ")\n", + "\n", + "# Colorbar Right\n", + "ax1 = fig.add_subplot(gs00[1])\n", + "cb = mpl.colorbar.ColorbarBase(\n", + " ax1, cmap=cmap_100, norm=norm, orientation='horizontal'\n", + ")\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax1.text(\n", + " 0.5, 2, r'$(1:0:0\\smash{)_{\\rm S}}\\:\\:{\\rm w}/\\:\\mathcal{O}_{\\mu\\tau}\\:{\\rm texture}$',\n", + " fontsize=fontsize, rotation=0, verticalalignment='center', horizontalalignment='center'\n", + ")\n", + "\n", + "# Figure text\n", + "fig.text(\n", + " 0.5, 0.038, r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{6}\\,\\cdot\\,{\\rm M}^{2}_{\\rm Planck})\\: ]$',\n", + " fontsize=fontsize+5, horizontalalignment='center'\n", + ")\n", + "fig.text(\n", + " 0.75, 0.86, r'${\\rm\\bf IceCube\\:Preliminary}$', fontsize=fontsize,\n", + " horizontalalignment='center', color='r'\n", + ")\n", + "\n", + "# Save\n", + "fig.savefig('./plots/fig2.png', bbox_inches='tight', dpi=150)\n", + "fig.savefig('./plots/fig2.pdf', bbox_inches='tight', dpi=150)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |
