diff options
| author | Shivesh Mandalia <shivesh.mandalia@outlook.com> | 2020-02-28 18:39:45 +0000 |
|---|---|---|
| committer | Shivesh Mandalia <shivesh.mandalia@outlook.com> | 2020-02-28 18:39:45 +0000 |
| commit | 402f8b53dd892b8fd44ae5ad45eac91b5f6b3750 (patch) | |
| tree | b619c6efb0eb303e164bbd27691cdd9f8fce36a2 /ipynbs/trajectory.ipynb | |
| parent | 3a5a6c658e45402d413970e8d273a656ed74dcf5 (diff) | |
| download | GolemFlavor-402f8b53dd892b8fd44ae5ad45eac91b5f6b3750.tar.gz GolemFlavor-402f8b53dd892b8fd44ae5ad45eac91b5f6b3750.zip | |
reogranise into a python package
Diffstat (limited to 'ipynbs/trajectory.ipynb')
| -rw-r--r-- | ipynbs/trajectory.ipynb | 1099 |
1 files changed, 1099 insertions, 0 deletions
diff --git a/ipynbs/trajectory.ipynb b/ipynbs/trajectory.ipynb new file mode 100644 index 0000000..3f9f644 --- /dev/null +++ b/ipynbs/trajectory.ipynb @@ -0,0 +1,1099 @@ +{ + "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": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "../utils/plot.py:24: UserWarning: \n", + "This call to matplotlib.use() has no effect because the backend has already\n", + "been chosen; matplotlib.use() must be called *before* pylab, matplotlib.pyplot,\n", + "or matplotlib.backends is imported for the first time.\n", + "\n", + "The backend was *originally* set to 'module://ipykernel.pylab.backend_inline' by the following code:\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/runpy.py\", line 174, in _run_module_as_main\n", + " \"__main__\", fname, loader, pkg_name)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/runpy.py\", line 72, in _run_code\n", + " exec code in run_globals\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel_launcher.py\", line 16, in <module>\n", + " app.launch_new_instance()\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/traitlets/config/application.py\", line 658, in launch_instance\n", + " app.start()\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/kernelapp.py\", line 499, in start\n", + " self.io_loop.start()\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/tornado/ioloop.py\", line 1073, in start\n", + " handler_func(fd_obj, events)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n", + " return fn(*args, **kwargs)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/zmq/eventloop/zmqstream.py\", line 450, in _handle_events\n", + " self._handle_recv()\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/zmq/eventloop/zmqstream.py\", line 480, in _handle_recv\n", + " self._run_callback(callback, msg)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/zmq/eventloop/zmqstream.py\", line 432, in _run_callback\n", + " callback(*args, **kwargs)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/tornado/stack_context.py\", line 300, in null_wrapper\n", + " return fn(*args, **kwargs)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/kernelbase.py\", line 283, in dispatcher\n", + " return self.dispatch_shell(stream, msg)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/kernelbase.py\", line 233, in dispatch_shell\n", + " handler(stream, idents, msg)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/kernelbase.py\", line 399, in execute_request\n", + " user_expressions, allow_stdin)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/ipkernel.py\", line 208, in do_execute\n", + " res = shell.run_cell(code, store_history=store_history, silent=silent)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/zmqshell.py\", line 537, in run_cell\n", + " return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/IPython/core/interactiveshell.py\", line 2724, in run_cell\n", + " self.events.trigger('post_run_cell')\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/IPython/core/events.py\", line 74, in trigger\n", + " func(*args, **kwargs)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/ipykernel/pylab/backend_inline.py\", line 164, in configure_once\n", + " activate_matplotlib(backend)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/IPython/core/pylabtools.py\", line 315, in activate_matplotlib\n", + " matplotlib.pyplot.switch_backend(backend)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 231, in switch_backend\n", + " matplotlib.use(newbackend, warn=False, force=True)\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/matplotlib/__init__.py\", line 1422, in use\n", + " reload(sys.modules['matplotlib.backends'])\n", + " File \"/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/matplotlib/backends/__init__.py\", line 16, in <module>\n", + " line for line in traceback.format_stack()\n", + "\n", + "\n", + " mpl.use('Agg')\n" + ] + } + ], + "source": [ + "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\n", + "from matplotlib.legend_handler import HandlerPatch\n", + "import matplotlib.gridspec as gridspec\n", + "plt.style.use('./paper.mplstyle')\n", + "\n", + "from scipy import interpolate\n", + "\n", + "from tqdm import tqdm_notebook as tqdm\n", + "import ternary\n", + "\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", + "#from utils.enums import MixingScenario" + ] + }, + { + "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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> [ 0.000 0.000 1.000] = [ 0.000 0.000]\n", + "[0.0, 0.0, 1.0]\n", + "-> [ 0.000 0.010 0.990] = [ 0.000 -1.000]\n", + "[0.0, 0.010000000000000009, 0.99]\n", + "-> [ 0.010 0.000 0.990] = [ 0.000 1.000]\n", + "[0.01, 8.88178419700126e-18, 0.99]\n", + "[4.999999999999449e-07, 0.0099995, 0.99]\n" + ] + } + ], + "source": [ + "m = [0, 0, 1]\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, 0.01, 0.99]\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.01, 0, 0.99]\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", + "\n", + "print map(float, fr_utils.angles_to_fr([0.0001, -0.9999]))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "SM_120 = np.load('./chains/fr_INJ_1_2_0.npy')\n", + "SM_100 = np.load('./chains/fr_INJ_1_0_0.npy')\n", + "SM_010 = np.load('./chains/fr_INJ_0_1_0.npy')\n", + "\n", + "SM_X = np.load('./chains/mc_x.npy')\n", + "SM_U = np.load('./chains/mc_unitary.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", + "#T13_010 = np.genfromtxt('./frs/fr_DIM4_sfr_0_1_0_mfr_1_1_1_MixingScenario.T13_flat.txt')\n", + "#T23_100 = np.genfromtxt('./frs/fr_DIM4_sfr_1_0_0_mfr_1_1_1_MixingScenario.T23_flat.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(200000, 3) (200000, 3) (69648, 4) (69023, 4)\n" + ] + } + ], + "source": [ + "print SM_120.shape, SM_100.shape, T13_010.shape, T23_100.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "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", + ")\n", + "\n", + "nbins = 25" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "T13_010_an = np.array(map(fr_utils.fr_to_angles, T13_010[:,:-1]))\n", + "T23_100_an = np.array(map(fr_utils.fr_to_angles, T23_100[:,:-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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": 10, + "metadata": {}, + "outputs": [], + "source": [ + "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": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.7289209e-39\n" + ] + } + ], + "source": [ + "PS = 8.203e-20 # GeV^{-1}\n", + "PS_D6 = PS**2\n", + "print PS_D6" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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": [ + "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\n", + "\n", + "#min_scale = -10\n", + "#max_scale = 8" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "fontsize = 23\n", + "\n", + "def alp(x):\n", + " y = list(x)\n", + " y[-1] = 0.7\n", + " return y\n", + "\n", + "#cmap_010 = plt.get_cmap('jet', 10)\n", + "#cmap_100 = plt.get_cmap('jet', 10)\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": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.36384429 0.33097686 0.30517885]\n", + " [0.3642224 0.33090046 0.30487714]\n", + " [0.3642224 0.33090046 0.30487714]\n", + " ...\n", + " [0.40636667 0.35579595 0.23783738]\n", + " [0.40636667 0.35579595 0.23783738]\n", + " [0.40636667 0.35579595 0.23783738]]\n", + "(200000, 3)\n", + "\n", + "[[0.54269219 0.226958 0.23034981]\n", + " [0.54269219 0.226958 0.23034981]\n", + " [0.54269219 0.226958 0.23034981]\n", + " ...\n", + " [0.34185681 0.29456371 0.36357948]\n", + " [0.34185681 0.29456371 0.36357948]\n", + " [0.34185681 0.29456371 0.36357948]]\n" + ] + } + ], + "source": [ + "print SM_120\n", + "print SM_120.shape\n", + "print\n", + "print SM_100" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 4.625 15.65 4.725]\n", + " [ 0.2 24.6 0.2 ]\n", + " [ 5.275 10.175 9.55 ]\n", + " ...\n", + " [ 0.8 23.3 0.9 ]\n", + " [ 7.1 10.55 7.35 ]\n", + " [ 5.45 13.55 5.975]]\n" + ] + } + ], + "source": [ + "print T13_010[:,:-1]*nbins" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/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", + "../utils/plot.py:255: RuntimeWarning: divide by zero encountered in double_scalars\n", + " circum_r = a*b*c/(4.0*area)\n", + "/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/matplotlib/font_manager.py:1331: UserWarning: findfont: Font family [u'serif'] not found. Falling back to DejaVu Sans\n", + " (prop.get_family(), self.defaultFamily[fontext]))\n" + ] + }, + { + "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'$f_{e}^{\\oplus}$', r'$f_{\\mu}^{\\oplus}$', r'$f_{\\tau}^{\\oplus}$']\n", + "tax = plot_utils.get_tax(ax, scale=nbins, ax_labels=ax_labels)\n", + "\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.3,\n", + " color = coverages[cov],\n", + " alpha=0.6,\n", + " zorder=5\n", + " )\n", + "\n", + "# Trajectories\n", + "tax.scatter(T13_010[:,:-1]*nbins, marker='o', s=0.03, color=color_010, zorder=10)\n", + "tax.scatter(T23_100[:,:-1]*nbins, marker='o', s=0.03, color=color_100, zorder=10)\n", + "\n", + "# SM\n", + "#tax.scatter(SM_120*nbins, marker='o', s=0.03, alpha=0.06, color='red', zorder=2)\n", + "\n", + "#SM_010100 = np.concatenate([SM_100, SM_010])\n", + "plot_utils.flavour_contour(\n", + " frs = SM_120,\n", + " ax = ax,\n", + " fill = True,\n", + " nbins = nbins,\n", + " coverage = 100,\n", + " linewidth = 2,\n", + " color = 'red',\n", + " alpha = 0.2,\n", + " zorder = 1\n", + ")\n", + "plot_utils.flavour_contour(\n", + " frs = SM_100,\n", + " ax = ax,\n", + " fill = True,\n", + " nbins = nbins,\n", + " coverage = 100,\n", + " linewidth = 2,\n", + " color = 'gainsboro',\n", + " alpha = 1,\n", + " zorder = 0\n", + ")\n", + "plot_utils.flavour_contour(\n", + " frs = SM_010,\n", + " ax = ax,\n", + " fill = True,\n", + " nbins = nbins,\n", + " coverage = 100,\n", + " linewidth = 2,\n", + " color = 'gainsboro',\n", + " alpha = 1,\n", + " zorder = 0\n", + ")\n", + "\n", + "# plot_utils.flavour_contour(\n", + "# frs = SM_U,\n", + "# ax = ax,\n", + "# fill = True,\n", + "# nbins = nbins,\n", + "# coverage = 100,\n", + "# linewidth = 2,\n", + "# color = 'gainsboro',\n", + "# alpha = 1,\n", + "# zorder = 0\n", + "# )\n", + "# plot_utils.flavour_contour(\n", + "# frs = SM_U,\n", + "# ax = ax,\n", + "# fill = True,\n", + "# nbins = nbins,\n", + "# coverage = 100,\n", + "# linewidth = 2,\n", + "# color = 'gainsboro',\n", + "# alpha = 1,\n", + "# zorder = 0,\n", + "# oversample = 4,\n", + "# delaunay = True,\n", + "# d_alpha = 1.2,\n", + "# smoothing = 4\n", + "# )\n", + "#tax.scatter(SM_U*nbins, marker='o', s=0.9, alpha=0.12, color='red', zorder=3)\n", + "\n", + "#tax.scatter(SM_100*nbins, marker='o', s=0.09, alpha=0.12, color='lightgrey', zorder=0)\n", + "#tax.scatter(SM_010*nbins, marker='o', s=0.09, alpha=0.12, color='lightgrey', zorder=0)\n", + "\n", + "plot_utils.flavour_contour(\n", + " frs = SM_X,\n", + " ax = ax,\n", + " fill = True,\n", + " nbins = nbins,\n", + " coverage = 90,\n", + " linewidth = 1.2,\n", + " edgecolor = 'k',\n", + " facecolor = 'none',\n", + " alpha = 0.8,\n", + " zorder = 2,\n", + " oversample = 10,\n", + " delaunay = True,\n", + " d_alpha = 0.1,\n", + " smoothing = 4,\n", + " hatch = 'XXX'\n", + ")\n", + "\n", + "# Text\n", + "#ax.text(0.63, 0.46, r'$\\mathcal{O}_{e\\mu}$', fontsize=fontsize,\n", + "# rotation=0, verticalalignment='center')\n", + "ax.text(0.34*nbins, 0.14*nbins, r'$68\\%$', fontsize=fontsize, rotation=3)\n", + "ax.text(0.34*nbins, 0.035*nbins, r'$90\\%$', fontsize=fontsize, rotation=0)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "legend_elements = []\n", + "# legend_elements.append(\n", + "# Circle((0., 0.), 0.1, facecolor='lime', alpha=0.7, edgecolor='k',\n", + "# linewidth=2., label=r'$\\left (0:1:0\\right )\\:w/\\:{\\rm New\\:Physics}$')\n", + "# )\n", + "# legend_elements.append(\n", + "# Circle((0., 0.), 0.1, facecolor='blue', alpha=0.7, edgecolor='k',\n", + "# linewidth=2., label=r'$\\left (1:0:0\\right )\\:w/\\:{\\rm New\\:Physics}$')\n", + "# )\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='grey', alpha=0.7, edgecolor='k',\n", + " #linewidth=2., label=r'$\\left (0:1:0\\right ) + \\left (1:0:0\\right )$')\n", + " linewidth=2., label=r'$\\rm New\\:Physics\\:Territory$')\n", + ")\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='red', alpha=0.8, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (1:2:0\\right )\\:{\\rm subset}$')\n", + ")\n", + "legend = plt.legend(handles=legend_elements, loc=(0.65, 0.8),\n", + " #title='Maximum New Physics',\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "ax.add_artist(legend)\n", + "\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(handles=legend_elements, loc=(-0.05, 0.85),\n", + " #title='Standard Model',\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "\n", + "# Colorbar\n", + "gs00 = gridspec.GridSpecFromSubplotSpec(1, 2, subplot_spec=gs[1])\n", + "ax0 = fig.add_subplot(gs00[0])\n", + "cb = mpl.colorbar.ColorbarBase(ax0, cmap=cmap_010, norm=norm, orientation='horizontal')\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax0.text(0.5, 2, r'$\\left (0:1:0\\right )\\:{\\rm w}/\\:\\mathcal{O}_{e\\tau}\\:{\\rm texture}$', fontsize=fontsize,\n", + " rotation=0, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "\n", + "ax1 = fig.add_subplot(gs00[1])\n", + "cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap_100, norm=norm, orientation='horizontal')\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "#cb.set_label(r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{d=6}\\:/\\:{\\rm GeV}^{-2})\\: ]$',\n", + "# fontsize=fontsize+5, labelpad=20, horizontalalignment='left')\n", + "ax1.text(0.5, 2, r'$\\left (1:0:0\\right )\\:\\:{\\rm w}/\\:\\mathcal{O}_{\\mu\\tau}\\:{\\rm texture}$', fontsize=fontsize,\n", + " rotation=0, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "fig.text(0.5, 0.038, r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda_{6}\\:/\\:{\\rm M}^{2}_{\\rm Planck})\\: ]$',\n", + " fontsize=fontsize+5, horizontalalignment='center')\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "IOError", + "evalue": "[Errno 2] No such file or directory: 'kf.npy'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIOError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m<ipython-input-16-95425441735f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mtax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplot_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnbins\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max_labels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max_labels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mKF_FR\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'kf.npy'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m plot_utils.flavour_contour(\n\u001b[1;32m 9\u001b[0m \u001b[0mfrs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mKF_FR\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/home/shivesh/programs/anaconda2/lib/python2.7/site-packages/numpy/lib/npyio.pyc\u001b[0m in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding)\u001b[0m\n\u001b[1;32m 382\u001b[0m \u001b[0mown_fid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 383\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbasestring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 384\u001b[0;31m \u001b[0mfid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"rb\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 385\u001b[0m \u001b[0mown_fid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 386\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mis_pathlib_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIOError\u001b[0m: [Errno 2] No such file or directory: 'kf.npy'" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x432 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nbins = 25\n", + "\n", + "fig = plt.figure(figsize=(6, 6))\n", + "ax = fig.add_subplot(111)\n", + "tax = plot_utils.get_tax(ax, scale=nbins, ax_labels=ax_labels)\n", + "\n", + "KF_FR = np.load('kf.npy')\n", + "plot_utils.flavour_contour(\n", + " frs = KF_FR,\n", + " ax = ax,\n", + " nbins = nbins,\n", + " coverage = 68,\n", + " linewidth = 1,\n", + " color = 'black'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Figure\n", + "fig = plt.figure(figsize=(10, 10))\n", + "gs = gridspec.GridSpec(1, 2, width_ratios=[40, 1])\n", + "gs.update(hspace=0.3, wspace=0.15)\n", + "\n", + "ax = fig.add_subplot(gs[0])\n", + "\n", + "ax.set_xlim(0, 1)\n", + "ax.set_ylim(-1, 1)\n", + "\n", + "ax.tick_params(axis='x', labelsize=fontsize)\n", + "ax.tick_params(axis='y', labelsize=fontsize)\n", + "\n", + "ax.set_xlabel(r'$sin^4\\phi$', fontsize=fontsize+5)\n", + "ax.set_ylabel(r'$cos\\left (2\\psi\\right )$', fontsize=fontsize+5)\n", + "\n", + "for ymaj in ax.yaxis.get_majorticklocs():\n", + " ax.axhline(y=ymaj, ls='--', color='gray', alpha=0.4, linewidth=0.5)\n", + "for xmaj in ax.xaxis.get_majorticklocs():\n", + " ax.axvline(x=xmaj, ls='--', color='gray', alpha=0.4, linewidth=0.5)\n", + "\n", + "# HESE data\n", + "ax.plot(contour_68_upper_an[:,0], contour_68_upper_an[:,1], linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_68_lower_an[:,0], contour_68_lower_an[:,1], linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_90_upper_an[:,0], contour_90_upper_an[:,1], linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_90_lower_an[:,0], contour_90_lower_an[:,1], linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "\n", + "# Plot\n", + "ax.scatter(T13_010_an[:,0], T13_010_an[:,1], marker='o', s=0.03, color=color_010)\n", + "ax.scatter(T23_100_an[:,0], T23_100_an[:,1], marker='o', s=0.03, color=color_100)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "legend_elements = []\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='lime', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (0:1:0\\right )$')\n", + ")\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='blue', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (1:0:0\\right )$')\n", + ")\n", + "legend = plt.legend(handles=legend_elements, loc=(0.03, 0.78),\n", + " title='Source composition',\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "\n", + "# Colorbar\n", + "gs00 = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[1])\n", + "ax0 = fig.add_subplot(gs00[0])\n", + "cb = mpl.colorbar.ColorbarBase(ax0, cmap=cmap_010, norm=norm)\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax0.text(-1.5, 0.5, r'$\\mathcal{O}_{e\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=90, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "\n", + "ax1 = fig.add_subplot(gs00[1])\n", + "cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap_100, norm=norm)\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax1.text(-1.5, 0.5, r'$\\mathcal{O}_{\\mu\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=90, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "fig.text(0.98, 0.5, r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{d=6}\\:/\\:{\\rm GeV}^{-2})\\: ]$',\n", + " fontsize=fontsize+5, horizontalalignment='center', verticalalignment='center', rotation=-90)\n", + "\n", + "# Text\n", + "ax.text(0.34, 0.12, r'$68\\%$', fontsize=fontsize, rotation=12)\n", + "ax.text(0.33, 0.26, r'$90\\%$', fontsize=fontsize, rotation=18)\n", + "\n", + "fig.savefig('./plots/fr_an_trajectory.png', bbox_inches='tight', dpi=150)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sc = np.linspace(-52, -40, 1000)\n", + "energy = 1e6\n", + " \n", + "s = [0, 1, 0]\n", + "frs_010 = []\n", + "for x in sc:\n", + " u = fr_utils.params_to_BSMu(x, fix_mixing=MixingScenario.T13, dim=6, energy=energy)\n", + " frs_010.append(fr_utils.u_to_fr(s, np.array(u, dtype=np.complex128)))\n", + "frs_010 = np.vstack(frs_010)\n", + "\n", + "s = [1, 0, 0]\n", + "frs_100 = []\n", + "for x in sc:\n", + " u = fr_utils.params_to_BSMu(x, fix_mixing=MixingScenario.T23, dim=6, energy=energy)\n", + " frs_100.append(fr_utils.u_to_fr(s, np.array(u, dtype=np.complex128)))\n", + "frs_100 = np.vstack(frs_100)\n", + "\n", + "s = [0, 0, 1]\n", + "frs_001 = []\n", + "for x in sc:\n", + " u = fr_utils.params_to_BSMu(x, fix_mixing=MixingScenario.T12, dim=6, energy=energy)\n", + " frs_001.append(fr_utils.u_to_fr(s, np.array(u, dtype=np.complex128)))\n", + "frs_001 = np.vstack(frs_001)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "frs_010_an = np.array(map(fr_utils.fr_to_angles, frs_010))\n", + "frs_100_an = np.array(map(fr_utils.fr_to_angles, frs_100))\n", + "frs_001_an = np.array(map(fr_utils.fr_to_angles, frs_001))\n", + "\n", + "norm = mpl.colors.Normalize(vmin=-52, vmax=-40)\n", + "\n", + "color_fe_010 = map(alp, map(cmap_010, map(norm, sc)))\n", + "color_fe_100 = map(alp, map(cmap_100, map(norm, sc)))\n", + "color_fe_001 = map(alp, map(cmap_001, map(norm, sc)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print frs_001[-20:]\n", + "print frs_001_an[-20:]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Figure\n", + "fig = plt.figure(figsize=(10, 10))\n", + "gs = gridspec.GridSpec(1, 2, width_ratios=[40, 1])\n", + "gs.update(hspace=0.3, wspace=0.15)\n", + "\n", + "ax = fig.add_subplot(gs[0])\n", + "\n", + "ax.set_xlim(0, 1)\n", + "ax.set_ylim(-1, 1)\n", + "\n", + "ax.tick_params(axis='x', labelsize=fontsize)\n", + "ax.tick_params(axis='y', labelsize=fontsize)\n", + "\n", + "ax.set_xlabel(r'$sin^4\\phi$', fontsize=fontsize+5)\n", + "ax.set_ylabel(r'$cos\\left (2\\psi\\right )$', fontsize=fontsize+5)\n", + "\n", + "for ymaj in ax.yaxis.get_majorticklocs():\n", + " ax.axhline(y=ymaj, ls='--', color='gray', alpha=0.4, linewidth=0.5)\n", + "for xmaj in ax.xaxis.get_majorticklocs():\n", + " ax.axvline(x=xmaj, ls='--', color='gray', alpha=0.4, linewidth=0.5)\n", + "\n", + "# HESE data\n", + "ax.plot(contour_68_upper_an[:,0], contour_68_upper_an[:,1], linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_68_lower_an[:,0], contour_68_lower_an[:,1], linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_90_upper_an[:,0], contour_90_upper_an[:,1], linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "ax.plot(contour_90_lower_an[:,0], contour_90_lower_an[:,1], linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "\n", + "# Plot\n", + "ax.scatter(frs_010_an[:,0], frs_010_an[:,1], marker='o', s=3, color=color_fe_010)\n", + "ax.scatter(frs_100_an[:,0], frs_100_an[:,1], marker='o', s=3, color=color_fe_100)\n", + "ax.scatter(frs_001_an[:,0], frs_001_an[:,1], marker='o', s=3, color=color_fe_001)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "legend_elements = []\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='lime', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (0:1:0\\right )$')\n", + ")\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='blue', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (1:0:0\\right )$')\n", + ")\n", + "legend = plt.legend(handles=legend_elements, loc=(0.03, 0.78),\n", + " title='Source composition',\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "\n", + "# Colorbar\n", + "gs00 = gridspec.GridSpecFromSubplotSpec(2, 1, subplot_spec=gs[1])\n", + "ax0 = fig.add_subplot(gs00[0])\n", + "cb = mpl.colorbar.ColorbarBase(ax0, cmap=cmap_010, norm=norm)\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax0.text(-1.5, 0.5, r'$\\mathcal{O}_{e\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=90, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "\n", + "ax1 = fig.add_subplot(gs00[1])\n", + "cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap_100, norm=norm)\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax1.text(-1.5, 0.5, r'$\\mathcal{O}_{\\mu\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=90, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "fig.text(0.98, 0.5, r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{d=6}\\:/\\:{\\rm GeV}^{-2})\\: ]$',\n", + " fontsize=fontsize+5, horizontalalignment='center', verticalalignment='center', rotation=-90)\n", + "\n", + "# Text\n", + "ax.text(0.45, 0.185, r'$68\\%$', fontsize=fontsize, rotation=5)\n", + "ax.text(0.45, 0.52, r'$90\\%$', fontsize=fontsize, rotation=-4)\n", + "\n", + "fig.savefig('./plots/fr_an_fe_trajectory.png', bbox_inches='tight', dpi=150)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(60000, 3)\n", + "(60000, 3)\n" + ] + } + ], + "source": [ + "MCMC_010_sc = np.load('./chains/mcmc_chain_DIM6_sfr_0_1_0_mfr_1_1_1_MixingScenario.T13.npy')[:,-1]\n", + "MCMC_010_frs = np.load('./chains/mcmc_chain_DIM6_sfr_0_1_0_mfr_1_1_1_MixingScenario.T13_proc.npy')\n", + "print MCMC_010_frs.shape\n", + "\n", + "MCMC_100_sc = np.load('./chains/mcmc_chain_DIM6_sfr_1_0_0_mfr_1_1_1_MixingScenario.T23.npy')[:,-1]\n", + "MCMC_100_frs = np.load('./chains/mcmc_chain_DIM6_sfr_1_0_0_mfr_1_1_1_MixingScenario.T23_proc.npy')\n", + "print MCMC_100_frs.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#min_scale = np.min(MCMC_100_sc)\n", + "#max_scale = np.max(MCMC_100_sc)\n", + "min_scale = -52\n", + "max_scale = -40\n", + "norm = mpl.colors.Normalize(vmin=min_scale, vmax=max_scale)\n", + "\n", + "color_MCMC_100 = map(alp, map(cmap_100, map(norm, MCMC_100_sc)))\n", + "color_MCMC_010 = map(alp, map(cmap_010, map(norm, MCMC_010_sc)))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 3 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure\n", + "fig = plt.figure(figsize=(12, 12))\n", + "#gs = gridspec.GridSpec(1, 2, width_ratios=[40, 1])\n", + "gs = gridspec.GridSpec(2, 1, height_ratios=[40, 1])\n", + "gs.update(hspace=0.3, wspace=0.15)\n", + "\n", + "ax = fig.add_subplot(gs[0])\n", + "ax.set_aspect('equal')\n", + "\n", + "# Boundary and Gridlines\n", + "scale = 1\n", + "fig, tax = ternary.figure(ax=ax, scale=scale)\n", + "\n", + "# Draw Boundary and Gridlines\n", + "tax.boundary(linewidth=2.0)\n", + "tax.gridlines(color='grey', multiple=scale/5., linewidth=1.0, alpha=0.4, ls='--')\n", + "tax.gridlines(color='grey', multiple=scale/10., linewidth=0.5, alpha=0.4, ls=':')\n", + "\n", + "# Set Axis labels and Title\n", + "fontsize = 23\n", + "tax.left_axis_label(r\"$f_{\\tau}^{\\oplus}$\", fontsize=fontsize+8, offset=0.2, rotation=0)\n", + "tax.right_axis_label(r\"$f_{\\mu}^{\\oplus}$\", fontsize=fontsize+8, offset=0.2, rotation=0)\n", + "tax.bottom_axis_label(r\"$f_{e}^{\\oplus}$\", fontsize=fontsize+8, position=(0.55, -0.20/2, 0.5), rotation=0)\n", + "\n", + "# Remove default Matplotlib axis\n", + "tax.get_axes().axis('off')\n", + "tax.clear_matplotlib_ticks()\n", + "\n", + "# Plot\n", + "#tax.scatter(SM_120, marker='o', s=0.03, alpha=0.3, color='red')\n", + "#tax.scatter([[0, 1, 0]], marker='*', s=500, alpha=1.0, color='green', zorder=100)\n", + "#tax.scatter([[1, 0, 0]], marker='*', s=500, alpha=1.0, color='blue', zorder=100)\n", + "\n", + "# Contour\n", + "tax.plot(contour_68_upper, linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "tax.plot(contour_68_lower, linewidth=2.3, color='grey', zorder=0, alpha=0.6)\n", + "tax.plot(contour_90_upper, linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "tax.plot(contour_90_lower, linewidth=2.3, color='darkgrey', zorder=0, alpha=0.6)\n", + "\n", + "# Lines\n", + "marker_style = dict(\n", + " linestyle=' ', color='darkorange', linewidth=1.2,\n", + " markersize=14, zorder=0\n", + ")\n", + "\n", + "# Trajectories\n", + "tax.scatter(MCMC_010_frs, marker='o', s=0.03, color=color_MCMC_010)\n", + "tax.scatter(MCMC_100_frs, marker='o', s=0.03, color=color_MCMC_100)\n", + "\n", + "# Text\n", + "#ax.text(0.63, 0.46, r'$\\mathcal{O}_{e\\mu}$', fontsize=fontsize,\n", + "# rotation=0, verticalalignment='center')\n", + "ax.text(0.34, 0.2, r'$68\\%$', fontsize=fontsize, rotation=5)\n", + "ax.text(0.34, 0.1, r'$90\\%$', fontsize=fontsize, rotation=5)\n", + "\n", + "# Legend\n", + "l_size = fontsize\n", + "legend_elements = []\n", + "#legend_elements.append(\n", + "# Circle((0., 0.), 0.1, facecolor='red', alpha=0.7, edgecolor='k',\n", + "# linewidth=2., label=r'$\\left (1:2:0\\right )$')\n", + "#)\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='lime', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (0:1:0\\right )$')\n", + ")\n", + "legend_elements.append(\n", + " Circle((0., 0.), 0.1, facecolor='blue', alpha=0.7, edgecolor='k',\n", + " linewidth=2., label=r'$\\left (1:0:0\\right )$')\n", + ")\n", + "legend = plt.legend(handles=legend_elements, loc=(0.65, 0.8),\n", + " title='Source composition',\n", + " fontsize=l_size,\n", + " handler_map={Circle: HandlerCircle()})\n", + "plt.setp(legend.get_title(), fontsize=l_size)\n", + "legend.get_frame().set_linestyle('-')\n", + "\n", + "# Colorbar\n", + "gs00 = gridspec.GridSpecFromSubplotSpec(1, 2, subplot_spec=gs[1])\n", + "ax0 = fig.add_subplot(gs00[0])\n", + "cb = mpl.colorbar.ColorbarBase(ax0, cmap=cmap_010, norm=norm, orientation='horizontal')\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "ax0.text(0.5, 2, r'$\\mathcal{O}_{e\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=0, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "\n", + "ax1 = fig.add_subplot(gs00[1])\n", + "cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap_100, norm=norm, orientation='horizontal')\n", + "cb.ax.tick_params(labelsize=fontsize-5)\n", + "#cb.set_label(r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{d=6}\\:/\\:{\\rm GeV}^{-2})\\: ]$',\n", + "# fontsize=fontsize+5, labelpad=20, horizontalalignment='left')\n", + "ax1.text(0.5, 2, r'$\\mathcal{O}_{\\mu\\tau}\\:texture$', fontsize=fontsize,\n", + " rotation=0, verticalalignment='center', horizontalalignment='center')\n", + "\n", + "fig.text(0.5, 0.038, r'${\\rm New\\:Physics\\:Scale}\\:[\\:{\\rm log}_{10} (\\Lambda^{-1}_{d=6}\\:/\\:{\\rm GeV}^{-2})\\: ]$',\n", + " fontsize=fontsize+5, horizontalalignment='center')\n", + "\n", + "# Set ticks\n", + "tax.ticks(axis='blr', multiple=scale/5., linewidth=1, offset=0.03,\n", + " fontsize=fontsize, tick_formats='%.1f')\n", + "\n", + "tax._redraw_labels()\n", + "\n", + "# save\n", + "#fig.savefig('./plots/fr_trajectory.png', bbox_inches='tight', dpi=150)\n", + "#fig.savefig('./plots/fr_trajectory.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 +} |
