GC-Fish-EFT-zeq0p5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EFT Fisher at z=0.5: full P(k,μ) method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the science packages/libraries\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "import scipy, scipy.interpolate, scipy.misc, scipy.integrate\n",
    "\n",
    "import os.path as op\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set plotting and printing\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "font = {'size'   : 16, 'family':'STIXGeneral'}\n",
    "axislabelfontsize='x-large'\n",
    "plt.rc('font', **font)\n",
    "plt.rcParams['text.usetex'] = True\n",
    "\n",
    "np.set_printoptions(precision=3,linewidth=200,suppress=False)\n",
    "\n",
    "from matplotlib.patches import Ellipse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main question for the Fisher matrix calculation: which parameters are we varying?\n",
    "# Note that this list determines the order in the output FM as well\n",
    "\n",
    "#NB: the cs0, cs2, cs4 params here are actually the cs squared (like in the MCMC)\n",
    "varypars = ['b','b2','N','cs0','cs2','cs4','f']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the fiducial model for the Fisher matrix calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ps column names: ('k', 'pl', 'pdd', 'pdt', 'ptt', 'sv', 'plnw', 'pddres', 'pdtres', 'pttres', 'ANW')\n",
      "abc column names: ('k', 'bu2f2nw', 'bu2f3nw', 'bu4f2nw', 'bu4f3nw', 'bu6f3nw', 'b2u2f1nw', 'b2u2f2nw', 'b2u2f3nw', 'b2u2f4nw', 'b2u4f2nw', 'b2u4f3nw', 'b2u4f4nw', 'b2u6f3nw', 'b2u6f4nw', 'b2u8f4nw', 'u2f4nw', 'u4f3nw', 'u4f4nw', 'u6f3nw', 'u6f4nw', 'u8f4nw')\n",
      "bias column names: ('k', 'ddb0b2nw', 'ddb02nw', 'ddb0nw', 'ddb22nw', 'ddb2nw', 'ddnonenw', 'dtb2nw', 'dtb0nw', 'dtnonenw')\n"
     ]
    }
   ],
   "source": [
    "#k values are the same in all files ### Paths to input files\n",
    "PATHTOINPUTFILES = op.abspath('./inputs/')\n",
    "\n",
    "# Function to read the output files from MG-COPTER\n",
    "def read_copter(path,suffix=''):\n",
    "    \n",
    "    #naming files (following the Mathematica notebook)\n",
    "    psfile = ('eft_ps_components_nw'+suffix+'.dat')\n",
    "    abcfile = ('eft_abc_components'+suffix+'.dat')\n",
    "    biasfile = ('eft_bias_components'+suffix+'.dat')\n",
    "    \n",
    "    # set the names of the columns (following the Mathematica notebook)\n",
    "    pscolnames = 'k', 'pl', 'pdd', 'pdt', 'ptt', 'sv', 'plnw', 'pddres', 'pdtres', 'pttres','ANW'\n",
    "    abccolnames = 'k', 'bu2f2nw', 'bu2f3nw', 'bu4f2nw', 'bu4f3nw', 'bu6f3nw', 'b2u2f1nw', 'b2u2f2nw', 'b2u2f3nw',\\\n",
    "    'b2u2f4nw', 'b2u4f2nw', 'b2u4f3nw', 'b2u4f4nw', 'b2u6f3nw', 'b2u6f4nw', 'b2u8f4nw', 'u2f4nw', 'u4f3nw', 'u4f4nw',\\\n",
    "    'u6f3nw', 'u6f4nw', 'u8f4nw' \n",
    "    biascolnames = 'k', 'ddb0b2nw', 'ddb02nw', 'ddb0nw', 'ddb22nw', 'ddb2nw', 'ddnonenw', 'dtb2nw', 'dtb0nw', 'dtnonenw'\n",
    "    \n",
    "    return np.genfromtxt(op.join(path,psfile), names=pscolnames),\\\n",
    "           np.genfromtxt(op.join(path,abcfile), names=abccolnames),\\\n",
    "           np.genfromtxt(op.join(path,biasfile), names=biascolnames)\n",
    "\n",
    "# use numpy to read the whole files, the options will make the\n",
    "# resulting object act a bit like a dictionary (a structured array)\n",
    "# so we can query columns by name\n",
    "ps_fid, abc_fid, bias_fid = read_copter(op.join(PATHTOINPUTFILES,'data_fid'),'_fid')\n",
    "print ('ps column names:', ps_fid.dtype.names )# let's print the names to check\n",
    "print ('abc column names:', abc_fid.dtype.names) # let's print the names to check\n",
    "print ('bias column names:', bias_fid.dtype.names) # let's print the names to check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38.83043\n",
      "76.11283\n"
     ]
    }
   ],
   "source": [
    "#Fiducial (GR-COLA) cosmology \n",
    "#from cos.rtf file (changed some params names here)\n",
    "\n",
    "zbin = 0.5\n",
    "\n",
    "c=3e5\n",
    "hubble = 0.697\n",
    "H00 = 100*hubble\n",
    "Tcmb = 2.726\n",
    "ns = 0.971\n",
    "om0 = 0.281\n",
    "omb = 0.046\n",
    "sigma80_fid = 0.844 #this is sigma8 at z=0\n",
    "\n",
    "sv_fid = ps_fid['sv'][0] \n",
    "ANW = ps_fid['ANW'][0]\n",
    "\n",
    "b_fid = 1.471\n",
    "b2_fid = -0.393\n",
    "N_fid = 676.0 \n",
    "#NB: the cs0, cs2, cs4 params here are actually the cs squared (like in the MCMC)\n",
    "cs0_fid = 2.718\n",
    "cs2_fid = 23.218\n",
    "cs4_fid = 19.540\n",
    "\n",
    "#kmax at z=0.5 \n",
    "kmax = 0.245\n",
    "\n",
    "print(sv_fid)\n",
    "print(ANW)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the survey properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Set up survey with volume ~4 Gpc^3/h^3\n",
    "Area = 15000.0*1.06 #deg^2 \n",
    "Dzbin = 0.2\n",
    "z_vals = np.array([zbin]) \n",
    "Nzbin = len(z_vals)\n",
    "\n",
    "#set kmin \n",
    "kmin = 0.006"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#construct array of mu values between -1 and 1 (inclusive)\n",
    "mu_step = 0.005\n",
    "mu = mu_step*np.arange((2/mu_step)+1)-1.\n",
    "#print ('mu array', mu)\n",
    "#len(mu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define cosmology functions: background and perturbations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.733197112933542 0.7784487714884997\n"
     ]
    }
   ],
   "source": [
    "# Functions for DE later\n",
    "def w_integrand(z,w0=-1.,wa=0.):\n",
    "    return (1 + w0+wa*z/(z+1)) / (1+z)\n",
    "def DE_evo(zc,w0=-1.,wa=0.): \n",
    "    return np.exp(3*scipy.integrate.romberg(lambda z: w_integrand(z,w0,wa), 0, zc))\n",
    "\n",
    "# Define E(z) = H(z)/H0\n",
    "def Ez(zc,w0=-1.,wa=0.):\n",
    "    return np.sqrt((1-om0)*DE_evo(zc,w0,wa) + om0*pow(1+zc,3))\n",
    "\n",
    "# LCDM growth rate and growth factor\n",
    "def fg(zz,w0=-1.,wa=0.,gamma=0.55):\n",
    "    omz=om0*pow(1+zz,3)/pow(Ez(zz,w0,wa),2)\n",
    "    return pow(omz,gamma)\n",
    "\n",
    "def Dg_dz(zz,w0=-1.,wa=0.,gamma=0.55):\n",
    "    return -fg(zz,w0,wa)/(1+zz)\n",
    "\n",
    "def Dgz(zz,w0=-1.,wa=0.,gamma=0.55):\n",
    "    start_z = 0.0\n",
    "    ans = scipy.integrate.romberg(lambda z: Dg_dz(z,w0,wa), start_z, zz)\n",
    "    return np.exp(ans)\n",
    "\n",
    "nz = 100\n",
    "fg_fid_interp = np.zeros(nz)\n",
    "Dg_fid_interp = np.zeros(nz)\n",
    "z_for_interp = np.linspace(0,2,nz)\n",
    "for i,z in enumerate(z_for_interp):\n",
    "    fg_fid_interp[i] = fg(z)\n",
    "    Dg_fid_interp[i] = Dgz(z)\n",
    "\n",
    "fg_fid_i = scipy.interpolate.interp1d(z_for_interp,fg_fid_interp,kind='cubic')\n",
    "Dg_fid_i = scipy.interpolate.interp1d(z_for_interp,Dg_fid_interp,kind='cubic')\n",
    "del z_for_interp, Dg_fid_interp, fg_fid_interp, i, z\n",
    "print (fg_fid_i(zbin), Dg_fid_i(zbin))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.994\n"
     ]
    }
   ],
   "source": [
    "#Define E(z)=H(z)/H0\n",
    "def Ez(zc):\n",
    "    return np.sqrt(1-om0+om0*pow(1+zc,3))\n",
    "\n",
    "#Define the comoving distance\n",
    "def drdz(zp):\n",
    "    return (c/H00)/Ez(zp)\n",
    "def rcom(zc):\n",
    "    return scipy.integrate.romberg(drdz,0,zc)\n",
    "def DA(zc):\n",
    "    return rcom(zc)/(1+zc)\n",
    "\n",
    "def Vsur(zc): #  (the hubble**3 factor is for units consistency)\n",
    "    z_min = zc-Dzbin/2\n",
    "    DA_min = DA(z_min)\n",
    "    z_max = zc+Dzbin/2\n",
    "    DA_max = DA(z_max)\n",
    "    \n",
    "    F = (4.*np.pi/3.) / (4.*np.pi*(180./np.pi)**2)   \n",
    "    return F * (DA_max**3 *(1+z_max)**3 - DA_min**3 *(1+z_min)**3) * hubble**3 * Area\n",
    "\n",
    "print(round(Vsur(zbin)/1e9,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#construct Peft function\n",
    "def Peft(mu_array,f,\n",
    "         b=b_fid,b2=b2_fid,N=N_fid,\n",
    "         cs0=cs0_fid,cs2=cs2_fid,cs4=cs4_fid,sv=sv_fid,\n",
    "         sig8_z=sigma80_fid*Dg_fid_i(zbin),\n",
    "         ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu_array**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    D = sig8_z/sigma80_fid #every term that contains D, contains the same power of sigma80_fid\n",
    "    \n",
    "    #resummation part\n",
    "    pddresum = D**2 * ps['plnw'] + D**4 * ps['pddres']\\\n",
    "    + np.exp(-0.5*ps['k']**2*D**2*ANW) * ( D**2 * ps['pl'] + D**4 * ps['pdd'] - (D**2*ps['plnw'] + D**4*ps['pddres'])\\\n",
    "                                         +0.5*ps['k']**2*D**2*ANW*(D**2*(ps['pl']-ps['plnw'])))\n",
    "   \n",
    "    pdtresum = D**2 * f * ps['plnw'] + D**4 * f * ps['pdtres']\\\n",
    "    + np.exp(-0.5*ps['k']**2*D**2*ANW) * ( D**2 * f * ps['pl'] + D**4 * f * ps['pdt'] - (D**2*f*ps['plnw'] + D**4*f*ps['pdtres'])\\\n",
    "                                         +0.5*ps['k']**2*D**2*ANW*(f*D**2*(ps['pl']-ps['plnw'])))\n",
    "    \n",
    "    pttresum = D**2 * f**2 * ps['plnw'] + D**4 * f**2 * ps['pttres']\\\n",
    "    + np.exp(-0.5*ps['k']**2*D**2*ANW) * ( D**2 * f**2 * ps['pl'] + D**4 * f**2 * ps['ptt'] - (D**2*f**2*ps['plnw'] + D**4*f**2*ps['pttres'])\\\n",
    "                                         +0.5*ps['k']**2*D**2*ANW*(f**2*D**2*(ps['pl']-ps['plnw'])))\n",
    "    \n",
    "    #total power spectrum\n",
    "    FoG = (1 - f**2*np.outer(k_array**2,mu_array**2)*D**2*sv_fid)\\\n",
    "             \n",
    "    res = FoG\\\n",
    "    *((b**2*np.outer(pddresum,muones)\\\n",
    "    + D**4*(b*b2*np.outer(bias['ddb0b2nw'],muones) + b**2*np.outer(bias['ddb02nw'],muones)\\\n",
    "    + b*np.outer(bias['ddb0nw'],muones) + b2**2*np.outer(bias['ddb22nw'],muones)\\\n",
    "    + b2*np.outer(bias['ddb2nw'],muones) + np.outer(bias['ddnonenw'],muones)) + N \n",
    "    + 2*(b*np.outer(pdtresum,mu_array**2))\\\n",
    "    - 2*D**4*f*(b2*np.outer(bias['dtb2nw'],mu_array**2) + b*np.outer(bias['dtb0nw'],mu_array**2) + np.outer(bias['dtnonenw'],mu_array**2)))\\\n",
    "    + np.outer(pttresum,mu_array**4))\\\n",
    "    + D**4*( b*f**2*np.outer(abc['bu2f2nw'],mu_array**2) + b*f**3*np.outer(abc['bu2f3nw'],mu_array**2)\\\n",
    "    + b*f**2*np.outer(abc['bu4f2nw'],mu_array**4)+b*f**3*np.outer(abc['bu4f3nw'],mu_array**4)\\\n",
    "    + b*f**3*np.outer(abc['bu6f3nw'],mu_array**6)+b**2*f*np.outer(abc['b2u2f1nw'],mu_array**2)\\\n",
    "    + b**2*f**2*np.outer(abc['b2u2f2nw'],mu_array**2)+b**2*f**3*np.outer(abc['b2u2f3nw'],mu_array**2)\\\n",
    "    + b**2*f**4*np.outer(abc['b2u2f4nw'],mu_array**2) + b**2*f**2*np.outer(abc['b2u4f2nw'],mu_array**4)\\\n",
    "    + b**2*f**3*np.outer(abc['b2u4f3nw'],mu_array**4) + b**2*f**4*np.outer(abc['b2u4f4nw'],mu_array**4)\\\n",
    "    + b**2*f**3*np.outer(abc['b2u6f3nw'],mu_array**6) + b**2*f**4*np.outer(abc['b2u6f4nw'],mu_array**6)\\\n",
    "    + b**2*f**4*np.outer(abc['b2u8f4nw'],mu_array**8) + f**4*np.outer(abc['u2f4nw'],mu_array**2)\\\n",
    "    + f**3*np.outer(abc['u4f3nw'],mu_array**4) + f**4*np.outer(abc['u4f4nw'],mu_array**4)\\\n",
    "    + f**3*np.outer(abc['u6f3nw'],mu_array**6) + f**4*np.outer(abc['u6f4nw'],mu_array**6)\\\n",
    "    + f**4*np.outer(abc['u8f4nw'],mu_array**8) )\\\n",
    "    - 2.*D**2*( np.outer(k_array**2*ps['plnw'],muones)*cs0 + np.outer(k_array**2*ps['plnw'],cs2*mu_array**2)\\\n",
    "    + np.outer(k_array**2*ps['plnw'],cs4*mu_array**4) + np.outer(k_array**2*ps['plnw'],muones)\\\n",
    "    *(f**3*cs0 - f**2*cs2 + f*cs4)*mu_array**6)\n",
    "        \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Effective volume\n",
    "nbar = 1e-3 #h^3/Mpc^3\n",
    "def Veff(mu_array,zc):\n",
    "    n = nbar\n",
    "    P = Peft(mu_array,fg_fid_i(zc)) \n",
    "    return Vsur(zc) / (P+1./n)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define how to calculate the derivatives with respect to parameters we wish to vary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Construct the derivatives wrt the bias and EFT parameters\n",
    "\n",
    "#choose the step (convergent derivatives)\n",
    "params_step = 1e-5\n",
    "\n",
    "#Derivative wrt b\n",
    "def dPeft_db(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "             ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    P_bp = Peft(mu,fg_fid_i(zbin),b_fid*(1+params_step),b2_fid,N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "    P_bm = Peft(mu,fg_fid_i(zbin),b_fid*(1-params_step),b2_fid,N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "    \n",
    "    deriv_b = (P_bp - P_bm)/(2*b_fid*params_step)\n",
    "    \n",
    "    return deriv_b\n",
    "    \n",
    "    \n",
    "#Derivative wrt b2\n",
    "def dPeft_db2(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "              ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    P_b2p = Peft(mu,fg_fid_i(zbin),b_fid,b2_fid*(1+params_step),N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "    P_b2m = Peft(mu,fg_fid_i(zbin),b_fid,b2_fid*(1-params_step),N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "    \n",
    "    deriv_b2 = (P_b2p - P_b2m)/(2*b2_fid*params_step)\n",
    "    \n",
    "    \n",
    "    return deriv_b2\n",
    "\n",
    "#Derivative wrt N\n",
    "def dPeft_dN(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "             ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    deriv_N = (1 - f**2*np.outer(k_array**2,mu_array**2)*D**2*sv_fid)\n",
    "    \n",
    "    return deriv_N\n",
    "\n",
    "#Derivative wrt cs0 \n",
    "def dPeft_dcs0(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "               ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    deriv_cs0 = - 2.*D**2*( np.outer(k_array**2*ps['plnw'],muones) + np.outer(k_array**2*ps['plnw'],muones)*f**3*mu_array**6)\n",
    "    \n",
    "    return deriv_cs0\n",
    "\n",
    "#Derivative wrt cs2\n",
    "def dPeft_dcs2(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "               ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    deriv_cs2 = - 2.*D**2*( np.outer(k_array**2*ps['plnw'],mu_array**2) - np.outer(k_array**2*ps['plnw'],muones)*f**2*mu_array**6)\n",
    "        \n",
    "    return deriv_cs2\n",
    "\n",
    "#Derivative wrt cs4\n",
    "def dPeft_dcs4(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "               ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "\n",
    "    deriv_cs4 = - 2.*D**2*( np.outer(k_array**2*ps['plnw'],mu_array**4) + np.outer(k_array**2*ps['plnw'],muones)*f*mu_array**6)\n",
    "        \n",
    "    return deriv_cs4\n",
    "\n",
    "#Derivative wrt f\n",
    "def dPeft_df(mu_array,f,D,b,b2,N,cs0,cs2,cs4,sv,\n",
    "              ps=ps_fid,abc=abc_fid,bias=bias_fid):\n",
    "    muones = mu**0.\n",
    "    k_array = ps['k']\n",
    "    \n",
    "    P_fp = Peft(mu,fg_fid_i(zbin)*(1+params_step),b_fid,b2_fid,N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "    P_fm = Peft(mu,fg_fid_i(zbin)*(1-params_step),b_fid,b2_fid,N_fid,\n",
    "                 cs0_fid,cs2_fid,cs4_fid,sv_fid,\n",
    "                 sigma80_fid*Dg_fid_i(zbin),ps=ps_fid,abc=abc_fid,bias=bias_fid) \n",
    "\n",
    "    deriv_f = (P_fp - P_fm)/(2*fg_fid_i(zbin)*params_step)\n",
    "    \n",
    "    return deriv_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the Fisher matrix calculation and run to loop to calculate its elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for i in range(1,299):\n",
    "#    print(ps_fid['k'][i+1]-ps_fid['k'][i])\n",
    "\n",
    "k_step = ps_fid['k'][6] - ps_fid['k'][5]\n",
    "dkdmu = k_step*mu_step\n",
    "\n",
    "# k values range to include in the constraints calculation\n",
    "k_index = (ps_fid['k']<kmax)*(ps_fid['k']>kmin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "# This dictionary contains all the parameters that can be varied in this code.\n",
    "derivs = {\n",
    "    'b'  : lambda z,m: dPeft_db(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'b2' : lambda z,m: dPeft_db2(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'N'  : lambda z,m: dPeft_dN(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'cs0': lambda z,m: dPeft_dcs0(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'cs2': lambda z,m: dPeft_dcs2(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'cs4': lambda z,m: dPeft_dcs4(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid),\n",
    "    'f'  : lambda z,m: dPeft_df(m,fg_fid_i(z),Dg_fid_i(z),b_fid,b2_fid,N_fid,cs0_fid,cs2_fid,cs4_fid,sv_fid)\n",
    "}\n",
    "            \n",
    "# Which should depend on redshift\n",
    "zdep = 'b','b2','N','cs0','cs2','cs4','f'\n",
    "\n",
    "# Which ones are independent of redshift and should appear in the FM once (summ over z contributions)\n",
    "zidep = [i for i in derivs.keys() if i not in zdep]\n",
    "print (zidep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Auxiliary bits needed for Fisher matrix calculation\n",
    "\n",
    "# Create array of zeros for the final FM\n",
    "Nzdep = len(set(zdep)&set(varypars))\n",
    "Npar = len(varypars)\n",
    "s = Nzdep*Nzbin + (Npar-Nzdep)\n",
    "Fishermat = np.zeros([s,s])\n",
    "\n",
    "# Fisher matrix integrand - to be integrated over k and mu arrays\n",
    "def dF(mu_array,zc):\n",
    "    k_array = ps_fid['k']\n",
    "    tmp = deriv_i(mu_array,zc)*deriv_j(mu_array,zc)*Veff(mu_array,zc)\n",
    "    return (1./(8*np.pi*np.pi))*pow(k_array,2)*tmp.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%%time \n",
    "\n",
    "# Save the indexing for posterity\n",
    "fm_index = {'b' :[],'b2':[],'N' :[],'cs0':[],'cs2':[],'cs4':[],'f' :[]}\n",
    "\n",
    "fm_head = []\n",
    "\n",
    "# Loop over redshift bins\n",
    "for iz, zc in enumerate(z_vals):\n",
    "    \n",
    "    # First loop over parameters (rows of the FM)\n",
    "    for i, pi in enumerate(varypars): \n",
    "        \n",
    "        # Calculate row index for the Fisher matrix\n",
    "        if pi in zdep:\n",
    "            zind = iz*Nzdep + i\n",
    "        else:\n",
    "            zind = Nzbin*Nzdep + (i-Nzdep)\n",
    "                \n",
    "        # Set the i derivative in dF to correspond to the row parameter\n",
    "        def deriv_i(mu_array,zc): return derivs[pi](zc,mu_array)\n",
    "\n",
    "        # Second loop over parameters (columns of the FM)\n",
    "        for j, pj in enumerate(varypars):\n",
    "            \n",
    "            # Calculate column index for the Fisher matrix\n",
    "            if pj in zdep:\n",
    "                zjnd = iz*Nzdep + j\n",
    "            else:\n",
    "                zjnd = Nzbin*Nzdep + (j-Nzdep)\n",
    "            \n",
    "            # If not done yet, set the j derivative in dF to correspond to the column parameter\n",
    "            if j>=i:\n",
    "                \n",
    "                def deriv_j(mu_array,zc): return derivs[pj](zc,mu_array)\n",
    "                \n",
    "                fm = dF(mu,zc)[:,k_index]\n",
    "                Fishermat[zind,zjnd] += np.sum(np.sum(fm))*dkdmu\n",
    "            \n",
    "            # Otherwise just take the symmetric value\n",
    "            else: \n",
    "                Fishermat[zind,zjnd] = Fishermat[zjnd,zind]\n",
    "        \n",
    "        # Finally, save the index in the FM (same redshift order as z_vals)\n",
    "        fm_index[pi].append(zind) # Only doing i, since it is symmetric\n",
    "        \n",
    "        # Save also the order of the colmns/rows\n",
    "        headstr = pi\n",
    "        if pi in zdep: headstr+='_'+str(zc)\n",
    "        fm_head.append(headstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cs0 index 3\n",
      "cs2 index 4\n",
      "cs4 index 5\n",
      "combined marged [3.273e-02 5.824e-01 9.260e+02 1.965e+00 2.617e+00 2.279e+00 2.448e-02]\n",
      "\n",
      "Correlation coefficients after adding EFT parameters priors:\n",
      "[[ 1.     0.97  -0.985 -0.098  0.903  0.149 -0.588]\n",
      " [ 0.97   1.    -0.972  0.061  0.841  0.055 -0.607]\n",
      " [-0.985 -0.972  1.     0.174 -0.931 -0.255  0.483]\n",
      " [-0.098  0.061  0.174  1.    -0.439 -0.88  -0.542]\n",
      " [ 0.903  0.841 -0.931 -0.439  1.     0.456 -0.27 ]\n",
      " [ 0.149  0.055 -0.255 -0.88   0.456  1.     0.68 ]\n",
      " [-0.588 -0.607  0.483 -0.542 -0.27   0.68   1.   ]]\n"
     ]
    }
   ],
   "source": [
    "# Very conservative priors for the \"no priors\" case\n",
    "# Just want to ensure your cs2s are not negative etc.\n",
    "\n",
    "cPriormat = Fishermat*0.\n",
    "cPrior_errors = {\n",
    "    'cs0': (cs0_fid/100)*100, \n",
    "    'cs2': (cs2_fid/100)*100,\n",
    "    'cs4': (cs4_fid/100)*100\n",
    "}\n",
    "for p in cPrior_errors.keys():\n",
    "    if p not in varypars: continue\n",
    "    print (p, 'index', fm_index[p][0])\n",
    "    cPriormat[fm_index[p][0],fm_index[p][0]] = 1./cPrior_errors[p]**2\n",
    "\n",
    "priorfactor = 0.0    \n",
    "    \n",
    "Fishermat = Fishermat+priorfactor*cPriormat\n",
    "CovMat = scipy.linalg.pinv(Fishermat)\n",
    "print ('combined marged',  np.sqrt(np.diag(CovMat)))\n",
    "\n",
    "print ('\\nCorrelation coefficients after adding EFT parameters priors:')\n",
    "print (CovMat/np.sqrt(np.outer(np.diag(CovMat),np.diag(CovMat))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print out results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
       "    return false;\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
    "    return false;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a fiducial value dictionary\n",
    "fids = {\n",
    "    'b'  : b_fid*np.ones(Nzbin),   \n",
    "    'b2' : b2_fid*np.ones(Nzbin),  \n",
    "    'N'  : N_fid*np.ones(Nzbin),   \n",
    "    'cs0': cs0_fid*np.ones(Nzbin), \n",
    "    'cs2': cs2_fid*np.ones(Nzbin), \n",
    "    'cs4': cs4_fid*np.ones(Nzbin), \n",
    "    'f'  : fg_fid_i(z_vals)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Order of columns/rows:\n",
      "['b_0.5', 'b2_0.5', 'N_0.5', 'cs0_0.5', 'cs2_0.5', 'cs4_0.5', 'f_0.5']\n",
      "\n",
      "Correlation matrix for parameters:\n",
      "\n",
      "[[ 1.     0.97  -0.985 -0.098  0.903  0.149 -0.588]\n",
      " [ 0.97   1.    -0.972  0.061  0.841  0.055 -0.607]\n",
      " [-0.985 -0.972  1.     0.174 -0.931 -0.255  0.483]\n",
      " [-0.098  0.061  0.174  1.    -0.439 -0.88  -0.542]\n",
      " [ 0.903  0.841 -0.931 -0.439  1.     0.456 -0.27 ]\n",
      " [ 0.149  0.055 -0.255 -0.88   0.456  1.     0.68 ]\n",
      " [-0.588 -0.607  0.483 -0.542 -0.27   0.68   1.   ]]\n",
      "\n",
      "Correlation matrix diagonal:\n",
      "\n",
      "[1.071e-03 3.391e-01 8.574e+05 3.862e+00 6.849e+00 5.193e+00 5.991e-04]\n"
     ]
    }
   ],
   "source": [
    "print ('Order of columns/rows:')\n",
    "print (fm_head)\n",
    "#print 'Fisher matrix:\\n',\n",
    "#print Fishermat\n",
    "\n",
    "# Invert the Fisher matrix to get the parameter covariance\n",
    "CovMat = np.linalg.inv(Fishermat)\n",
    "print ('\\nCorrelation matrix for parameters:\\n', )\n",
    "print (CovMat/np.sqrt(np.outer(np.diag(CovMat),np.diag(CovMat))))\n",
    "\n",
    "print ('\\nCorrelation matrix diagonal:\\n', )\n",
    "print( np.diag(CovMat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.matmul(Fishermat,CovMat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "varying zdep = \n",
      "\t ['b', 'b2', 'N', 'cs0', 'cs2', 'cs4', 'f']\n",
      "at z = 0.5 : zdep fiducials = \n",
      "\t [ 1.471e+00 -3.930e-01  6.760e+02  2.718e+00  2.322e+01  1.954e+01  7.332e-01]\n",
      "at z = 0.5 : marged err = \n",
      "\t [3.273e-02 5.824e-01 9.260e+02 1.965e+00 2.617e+00 2.279e+00 2.448e-02]\n",
      "at z = 0.5 : unmarged err = \n",
      "\t [1.109e-03 5.981e-03 8.136e+00 6.765e-02 2.389e-01 1.558e-01 1.815e-03]\n",
      "at z = 0.5 : marged % err = \n",
      "\t [  2.225 148.182 136.975  72.307  11.272  11.662   3.338]\n",
      "at z = 0.5 : unmarged % err = \n",
      "\t [0.075 1.522 1.204 2.489 1.029 0.797 0.248]\n"
     ]
    }
   ],
   "source": [
    "# Print the errors nicely\n",
    "Nvar  = len(varypars)\n",
    "\n",
    "varyshape = list(set(zidep)&set(varypars))\n",
    "if len(varyshape)>0:\n",
    "    shapeind = [fm_index[p][0] for p in varyshape]\n",
    "    shapefid = np.array([fids[p] for p in varyshape])\n",
    "    print ('\\nvarying shape = \\n\\t', varyshape)\n",
    "    print ('shape fiducials = \\n\\t', shapefid)\n",
    "    print ('unmarged err = \\n\\t', np.sqrt(1./np.diag(Fishermat))[shapeind])\n",
    "    print ('marged err = \\n\\t', np.sqrt(np.diag(CovMat))[shapeind])\n",
    "    print ('unmarged % err = \\n\\t', np.sqrt(1./np.diag(Fishermat))[shapeind]/np.abs(shapefid)*100)\n",
    "    print ('marged % err = \\n\\t', np.sqrt(np.diag(CovMat))[shapeind]/np.abs(shapefid)*100)\n",
    "\n",
    "#varyzdep = list(set(varypars)&set(zdep))\n",
    "varyzdep = varypars\n",
    "\n",
    "zdepfid = np.array([fids[p] for p in varyzdep])\n",
    "print ('\\nvarying zdep = \\n\\t', varyzdep)\n",
    "if len(varyzdep)>0:\n",
    "    for iz, z in enumerate(z_vals):\n",
    "        zdepind = np.array([fm_index[p] for p in varyzdep])\n",
    "        print ('at z =',z,': zdep fiducials = \\n\\t', zdepfid[:,iz])\n",
    "        merrs = np.sqrt(np.diag(CovMat))[zdepind[:,iz]]\n",
    "        print ('at z =',z,': marged err = \\n\\t', merrs)\n",
    "        uerrs = np.sqrt(1./np.diag(Fishermat))[zdepind[:,iz]]\n",
    "        print ('at z =',z,': unmarged err = \\n\\t', uerrs)\n",
    "        print ('at z =',z,': marged % err = \\n\\t', merrs/np.abs(zdepfid[:,iz])*100.)\n",
    "        print ('at z =',z,': unmarged % err = \\n\\t', uerrs/np.abs(zdepfid[:,iz])*100.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns; sns.set()\n",
    "sns.set(font_scale=1.6)\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))\n",
    "df = pd.DataFrame(CovMat/np.sqrt(np.outer(np.diag(CovMat),np.diag(CovMat))))\n",
    "df.rename(columns={0:'$b_1$',1:'$b_2$',2:'$N$',3:'$c^2_{s,0}$',4:'$c^2_{s,2}$',5:'$c^2_{s,4}$',6:'$f$',7:'$\\sigma_8$',8:'$D_A$',9:'$H$'}, inplace=True)\n",
    "df.rename(index={0:'$b_1$',1:'$b_2$',2:'$N$',3:'$c^2_{s,0}$',4:'$c^2_{s,2}$',5:'$c^2_{s,4}$',6:'$f$',7:'$\\sigma_8$',8:'$D_A$',9:'$H$'}, inplace=True)\n",
    "ax = sns.heatmap(df, cmap=\"PiYG\", vmin=-1, vmax=1, annot = True, fmt='.2f')\n",
    "\n",
    "ax.set_title('$\\mathrm{EFTofLSS}, z=0.5$')\n",
    "#plt.savefig('corr-mat-eft-zeq0p5.pdf', format=\"pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$b_1$</th>\n",
       "      <th>$b_2$</th>\n",
       "      <th>$N$</th>\n",
       "      <th>$c^2_{s,0}$</th>\n",
       "      <th>$c^2_{s,2}$</th>\n",
       "      <th>$c^2_{s,4}$</th>\n",
       "      <th>$f$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$b_1$</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.970448</td>\n",
       "      <td>-0.984994</td>\n",
       "      <td>-0.097940</td>\n",
       "      <td>0.902749</td>\n",
       "      <td>0.149178</td>\n",
       "      <td>-0.587712</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$b_2$</th>\n",
       "      <td>0.970448</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.971925</td>\n",
       "      <td>0.060683</td>\n",
       "      <td>0.840675</td>\n",
       "      <td>0.055401</td>\n",
       "      <td>-0.607203</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$N$</th>\n",
       "      <td>-0.984994</td>\n",
       "      <td>-0.971925</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.173853</td>\n",
       "      <td>-0.931434</td>\n",
       "      <td>-0.255080</td>\n",
       "      <td>0.483129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$c^2_{s,0}$</th>\n",
       "      <td>-0.097940</td>\n",
       "      <td>0.060683</td>\n",
       "      <td>0.173853</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.439409</td>\n",
       "      <td>-0.879713</td>\n",
       "      <td>-0.541544</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$c^2_{s,2}$</th>\n",
       "      <td>0.902749</td>\n",
       "      <td>0.840675</td>\n",
       "      <td>-0.931434</td>\n",
       "      <td>-0.439409</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.456002</td>\n",
       "      <td>-0.270229</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$c^2_{s,4}$</th>\n",
       "      <td>0.149178</td>\n",
       "      <td>0.055401</td>\n",
       "      <td>-0.255080</td>\n",
       "      <td>-0.879713</td>\n",
       "      <td>0.456002</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.679678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$f$</th>\n",
       "      <td>-0.587712</td>\n",
       "      <td>-0.607203</td>\n",
       "      <td>0.483129</td>\n",
       "      <td>-0.541544</td>\n",
       "      <td>-0.270229</td>\n",
       "      <td>0.679678</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                $b_1$     $b_2$       $N$  $c^2_{s,0}$  $c^2_{s,2}$  \\\n",
       "$b_1$        1.000000  0.970448 -0.984994    -0.097940     0.902749   \n",
       "$b_2$        0.970448  1.000000 -0.971925     0.060683     0.840675   \n",
       "$N$         -0.984994 -0.971925  1.000000     0.173853    -0.931434   \n",
       "$c^2_{s,0}$ -0.097940  0.060683  0.173853     1.000000    -0.439409   \n",
       "$c^2_{s,2}$  0.902749  0.840675 -0.931434    -0.439409     1.000000   \n",
       "$c^2_{s,4}$  0.149178  0.055401 -0.255080    -0.879713     0.456002   \n",
       "$f$         -0.587712 -0.607203  0.483129    -0.541544    -0.270229   \n",
       "\n",
       "             $c^2_{s,4}$       $f$  \n",
       "$b_1$           0.149178 -0.587712  \n",
       "$b_2$           0.055401 -0.607203  \n",
       "$N$            -0.255080  0.483129  \n",
       "$c^2_{s,0}$    -0.879713 -0.541544  \n",
       "$c^2_{s,2}$     0.456002 -0.270229  \n",
       "$c^2_{s,4}$     1.000000  0.679678  \n",
       "$f$             0.679678  1.000000  "
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add Gaussian priors on parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b index 0\n",
      "N index 2\n",
      "combined marged [6.111e-03 1.431e-01 6.741e+01 1.935e+00 9.688e-01 2.203e+00 2.144e-02]\n",
      "\n",
      "Correlation coefficients after adding EFT parameters priors:\n",
      "[[ 1.     0.396 -0.383  0.393 -0.142 -0.557 -0.698]\n",
      " [ 0.396  1.    -0.288  0.945 -0.658 -0.805 -0.651]\n",
      " [-0.383 -0.288  1.     0.013 -0.183 -0.02   0.04 ]\n",
      " [ 0.393  0.945  0.013  1.    -0.763 -0.877 -0.724]\n",
      " [-0.142 -0.658 -0.183 -0.763  1.     0.614  0.547]\n",
      " [-0.557 -0.805 -0.02  -0.877  0.614  1.     0.947]\n",
      " [-0.698 -0.651  0.04  -0.724  0.547  0.947  1.   ]]\n"
     ]
    }
   ],
   "source": [
    "# Play with priors on nuisance parameters\n",
    "EFTmat = Fishermat*0.\n",
    "EFT_errors = {\n",
    "#    'cs0': (cs0_fid/100)*10, \n",
    "#    'cs2': (cs2_fid/100)*10,\n",
    "#    'cs4': (cs4_fid/100)*10,\n",
    "    'b'  : (b_fid/100)*10,\n",
    "    'N' : (N_fid/100)*10\n",
    "}\n",
    "for p in EFT_errors.keys():\n",
    "    if p not in varyzdep: continue\n",
    "    print (p, 'index', fm_index[p][0])\n",
    "    EFTmat[fm_index[p][0],fm_index[p][0]] = 1./EFT_errors[p]**2\n",
    "\n",
    "Fishermat_comb = Fishermat+EFTmat\n",
    "CovMat_comb = scipy.linalg.pinv(Fishermat_comb)\n",
    "print ('combined marged',  np.sqrt(np.diag(CovMat_comb)))\n",
    "\n",
    "print ('\\nCorrelation coefficients after adding EFT parameters priors:')\n",
    "print (CovMat_comb/np.sqrt(np.outer(np.diag(CovMat_comb),np.diag(CovMat_comb))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns; sns.set()\n",
    "sns.set(font_scale=1.6)\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))\n",
    "df = pd.DataFrame(CovMat_comb/np.sqrt(np.outer(np.diag(CovMat_comb),np.diag(CovMat_comb))))\n",
    "df.rename(columns={0:'$b_1$',1:'$b_2$',2:'$N$',3:'$c^2_{s,0}$',4:'$c^2_{s,2}$',5:'$c^2_{s,4}$',6:'$f$',7:'$\\sigma_8$',8:'$D_A$',9:'$H$'}, inplace=True)\n",
    "df.rename(index={0:'$b_1$',1:'$b_2$',2:'$N$',3:'$c^2_{s,0}$',4:'$c^2_{s,2}$',5:'$c^2_{s,4}$',6:'$f$',7:'$\\sigma_8$',8:'$D_A$',9:'$H$'}, inplace=True)\n",
    "ax = sns.heatmap(df, cmap=\"PiYG\", vmin=-1, vmax=1, annot = True, fmt='.2f')\n",
    "\n",
    "ax.set_title('$\\mathrm{EFTofLSS}, z=0.5$')\n",
    "#plt.savefig('corr-mat-eft-priors-zeq0p5.pdf', format=\"pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "varying zdep = \n",
      "\t ['b', 'b2', 'N', 'cs0', 'cs2', 'cs4', 'f']\n",
      "at z = 0.5 : zdep fiducials = \n",
      "\t [ 1.471e+00 -3.930e-01  6.760e+02  2.718e+00  2.322e+01  1.954e+01  7.332e-01]\n",
      "at z = 0.5 : marged err = \n",
      "\t [6.111e-03 1.431e-01 6.741e+01 1.935e+00 9.688e-01 2.203e+00 2.144e-02]\n",
      "at z = 0.5 : unmarged err = \n",
      "\t [1.109e-03 5.981e-03 8.078e+00 6.765e-02 2.389e-01 1.558e-01 1.815e-03]\n",
      "at z = 0.5 : marged % err = \n",
      "\t [ 0.415 36.404  9.972 71.203  4.173 11.275  2.924]\n",
      "at z = 0.5 : unmarged % err = \n",
      "\t [0.075 1.522 1.195 2.489 1.029 0.797 0.248]\n"
     ]
    }
   ],
   "source": [
    "# Print the errors nicely\n",
    "Nvar  = len(varypars)\n",
    "\n",
    "#varyzdep = list(set(varypars)&set(zdep))\n",
    "varyzdep = varypars\n",
    "\n",
    "zdepfid = np.array([fids[p] for p in varyzdep])\n",
    "print ('\\nvarying zdep = \\n\\t', varyzdep)\n",
    "if len(varyzdep)>0:\n",
    "    for iz, z in enumerate(z_vals):\n",
    "        zdepind = np.array([fm_index[p] for p in varyzdep])\n",
    "        print ('at z =',z,': zdep fiducials = \\n\\t', zdepfid[:,iz])\n",
    "        merrs = np.sqrt(np.diag(CovMat_comb))[zdepind[:,iz]]\n",
    "        print ('at z =',z,': marged err = \\n\\t', merrs)\n",
    "        uerrs = np.sqrt(1./np.diag(Fishermat_comb))[zdepind[:,iz]]\n",
    "        print ('at z =',z,': unmarged err = \\n\\t', uerrs)\n",
    "        print ('at z =',z,': marged % err = \\n\\t', merrs/np.abs(zdepfid[:,iz])*100.)\n",
    "        print ('at z =',z,': unmarged % err = \\n\\t', uerrs/np.abs(zdepfid[:,iz])*100.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Draw Ellipses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"ticks\")\n",
    "\n",
    "# Choose what to plot\n",
    "zi = 0; par0 = 'f'; par1 = 'N';\n",
    "\n",
    "# Get the indices in the Covariance Matrix of the two parameters we want to plot\n",
    "p0i = varyzdep.index(par0); index0 = zdepind[:,zi] # change this to shapeind if using shape!\n",
    "p1i = varyzdep.index(par1); index1 = zdepind[:,zi] # change this to shapeind if using shape!\n",
    "\n",
    "# Get the fiducial values for the ellipse centre\n",
    "c0 = fids[par0][zi] # remove the [zi] if par0 is a shape parameter!\n",
    "c1 = fids[par1][zi] # remove the [zi] if par1 is a shape parameter!\n",
    "\n",
    "# Marginalise out everything else and make a new 2x2 Covariance Matrix\n",
    "marg_all = True\n",
    "if marg_all:\n",
    "    covmat_2D = np.zeros((2,2))\n",
    "    covmat_2D[0,0] = CovMat[index0[p0i],index0[p0i]]\n",
    "    covmat_2D[1,1] = CovMat[index1[p1i],index1[p1i]]\n",
    "    covmat_2D[0,1] = CovMat[index0[p0i],index1[p1i]]\n",
    "    covmat_2D[1,0] = covmat_2D[0,1]\n",
    "    \n",
    "    \n",
    "else:\n",
    "    fishmat_2D = np.zeros((2,2))\n",
    "    fishmat_2D[0,0] = Fishermat[index0[p0i],index0[p0i]]\n",
    "    fishmat_2D[1,1] = Fishermat[index1[p1i],index1[p1i]]\n",
    "    fishmat_2D[0,1] = Fishermat[index0[p0i],index1[p1i]]\n",
    "    fishmat_2D[1,0] = fishmat_2D[0,1]\n",
    "    covmat_2D = np.linalg.inv(fishmat_2D)\n",
    "    del fishmat_2D\n",
    "\n",
    "def get_ellipses(centre,CM_2D):\n",
    "    # We will need coefficients for the ellipse depending on the number of sigma level we want\n",
    "    CL_alpha = {\n",
    "        1: 1.52, \n",
    "        2: 2.48,\n",
    "        3: 3.44\n",
    "    }\n",
    "\n",
    "    # Get the errors\n",
    "    FM_2D = np.linalg.inv(CM_2D)\n",
    "    em0 = np.sqrt(CM_2D[0,0])\n",
    "    eu0 = np.sqrt(1./FM_2D[0,0])\n",
    "    em1 = np.sqrt(CM_2D[1,1])\n",
    "    eu1 = np.sqrt(1./FM_2D[1,1])\n",
    "\n",
    "    #print par0, eu0, em0\n",
    "    #print par1, eu1, em1\n",
    "\n",
    "    # Now calculate the ellipse parameters\n",
    "    a = np.sqrt(0.5*(CM_2D[0,0]+CM_2D[1,1]) + np.sqrt(0.25*(CM_2D[0,0]-CM_2D[1,1])**2 + CM_2D[0,1]**2))\n",
    "    b = np.sqrt(0.5*(CM_2D[0,0]+CM_2D[1,1]) - np.sqrt(0.25*(CM_2D[0,0]-CM_2D[1,1])**2 + CM_2D[0,1]**2))\n",
    "    theta = 180./np.pi * 0.5*np.arctan(2.*CM_2D[0,1] / (CM_2D[0,0]-CM_2D[1,1])) # should be in degrees\n",
    "\n",
    "    if CM_2D[0,0]<CM_2D[1,1]:\n",
    "        width=2.*b\n",
    "        height=2.*a\n",
    "    else:\n",
    "        width=2.*a\n",
    "        height=2.*b\n",
    "\n",
    "    # Create all the ellipses\n",
    "    ellipse1 = Ellipse([centre[0],centre[1]], width*CL_alpha[1], height*CL_alpha[1], theta, \n",
    "                       linewidth=0, fill=True, zorder=2, alpha=0.7, color='green')\n",
    "    ellipse2 = Ellipse([centre[0],centre[1]], width*CL_alpha[2], height*CL_alpha[2], theta, \n",
    "                       linewidth=0, fill=True, zorder=2, alpha=0.2, color='green')\n",
    "\n",
    "    return ellipse1, ellipse2, CL_alpha[1]*em0, CL_alpha[1]*em1, CL_alpha[1]*eu0, CL_alpha[1]*eu1\n",
    "\n",
    "# Make a test plot\n",
    "ell1, ell2, errm0, errm1, erru0, erru1 = get_ellipses([c0,c1],covmat_2D)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7,7))\n",
    "\n",
    "ax.axhline(c1,ls='--',c='k',lw=1); ax.axvline(c0,ls='--',c='k',lw=1) # Centre lines\n",
    "#ax.axvline(c0-errm0,ls=':',c='g',lw=1); ax.axvline(c0+errm0,ls=':',c='g',lw=1) # Marginalised error lines par0\n",
    "#ax.axvline(c0-erru0,ls=':',c='c',lw=1); ax.axvline(c0+erru0,ls=':',c='c',lw=1) # Marginalised error lines par0\n",
    "#ax.axhline(c1-errm1,ls=':',c='g',lw=1); ax.axhline(c1+errm1,ls=':',c='g',lw=1) # Marginalised error lines par1\n",
    "#ax.axhline(c1-erru1,ls=':',c='c',lw=1); ax.axhline(c1+erru1,ls=':',c='c',lw=1) # Marginalised error lines par1\n",
    "\n",
    "ax.add_artist(ell1)\n",
    "ax.add_artist(ell2)\n",
    "ax.set_xlim(c0-errm0*2.1, c0+errm0*2.1)\n",
    "ax.set_ylim(c1-errm1*2.1, c1+errm1*2.1)\n",
    "ax.tick_params(color='black')\n",
    "ax.set_facecolor('none')\n",
    "#ax.axis('off')\n",
    "\n",
    "plt.xlabel(par0+'(z='+str(z_vals[zi])+')')\n",
    "plt.ylabel(par1+'(z='+str(z_vals[zi])+')')\n",
    "\n",
    "#plt.savefig('test.png', format=\"png\", bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"ticks\")\n",
    "\n",
    "# Choose what to plot\n",
    "zi = 0; par0 = 'f'; par1 = 'N';\n",
    "\n",
    "# Get the indices in the Covariance Matrix of the two parameters we want to plot\n",
    "p0i = varyzdep.index(par0); index0 = zdepind[:,zi] # change this to shapeind if using shape!\n",
    "p1i = varyzdep.index(par1); index1 = zdepind[:,zi] # change this to shapeind if using shape!\n",
    "\n",
    "# Get the fiducial values for the ellipse centre\n",
    "c0 = fids[par0][zi] # remove the [zi] if par0 is a shape parameter!\n",
    "c1 = fids[par1][zi] # remove the [zi] if par1 is a shape parameter!\n",
    "\n",
    "# Marginalise out everything else and make a new 2x2 Covariance Matrix\n",
    "marg_all = True\n",
    "if marg_all:\n",
    "    covmat_2D_comb = np.zeros((2,2))\n",
    "    covmat_2D_comb[0,0] = CovMat_comb[index0[p0i],index0[p0i]]\n",
    "    covmat_2D_comb[1,1] = CovMat_comb[index1[p1i],index1[p1i]]\n",
    "    covmat_2D_comb[0,1] = CovMat_comb[index0[p0i],index1[p1i]]\n",
    "    covmat_2D_comb[1,0] = covmat_2D_comb[0,1]\n",
    "    \n",
    "else:\n",
    "    fishmat_2D_comb = np.zeros((2,2))\n",
    "    fishmat_2D_comb[0,0] = Fishermat_comb[index0[p0i],index0[p0i]]\n",
    "    fishmat_2D_comb[1,1] = Fishermat_comb[index1[p1i],index1[p1i]]\n",
    "    fishmat_2D_comb[0,1] = Fishermat_comb[index0[p0i],index1[p1i]]\n",
    "    fishmat_2D_comb[1,0] = fishmat_2D_comb[0,1]\n",
    "    covmat_2D_comb = np.linalg.inv(fishmat_2D_comb)\n",
    "    del fishmat_2D_comb\n",
    "\n",
    "def get_ellipses(centre,CM_2D,sty={'w':0,'s':'-','f':True,'a':0.7,'c':'green'}):\n",
    "    # We will need coefficients for the ellipse depending on the number of sigma level we want\n",
    "    CL_alpha = {\n",
    "        1: 1.52, \n",
    "        2: 2.48,\n",
    "        3: 3.44\n",
    "    }\n",
    "\n",
    "    # Get the errors\n",
    "    FM_2D = np.linalg.inv(CM_2D)\n",
    "    em0 = np.sqrt(CM_2D[0,0])\n",
    "    eu0 = np.sqrt(1./FM_2D[0,0])\n",
    "    em1 = np.sqrt(CM_2D[1,1])\n",
    "    eu1 = np.sqrt(1./FM_2D[1,1])\n",
    "\n",
    "    #print par0, eu0, em0\n",
    "    #print par1, eu1, em1\n",
    "\n",
    "    # Now calculate the ellipse parameters\n",
    "    a = np.sqrt(0.5*(CM_2D[0,0]+CM_2D[1,1]) + np.sqrt(0.25*(CM_2D[0,0]-CM_2D[1,1])**2 + CM_2D[0,1]**2))\n",
    "    b = np.sqrt(0.5*(CM_2D[0,0]+CM_2D[1,1]) - np.sqrt(0.25*(CM_2D[0,0]-CM_2D[1,1])**2 + CM_2D[0,1]**2))\n",
    "    theta = 180./np.pi * 0.5*np.arctan(2.*CM_2D[0,1] / (CM_2D[0,0]-CM_2D[1,1])) # should be in degrees\n",
    "\n",
    "    if CM_2D[0,0]<CM_2D[1,1]:\n",
    "        width=2.*b\n",
    "        height=2.*a\n",
    "    else:\n",
    "        width=2.*a\n",
    "        height=2.*b\n",
    "\n",
    "    # Create all the ellipses   linestyles = ['-', '--'\n",
    "    ellipse1 = Ellipse([centre[0],centre[1]], width*CL_alpha[1], height*CL_alpha[1], theta, \n",
    "                       linewidth=sty['w'], ls = sty['s'], fill=sty['f'], zorder=2, alpha=sty['a'], color=sty['c'])\n",
    "    leg1 = ellipse1.set(clip_box=ax.bbox, alpha=sty['a'], facecolor=sty['c'], edgecolor = 'black')\n",
    "    ellipse2 = Ellipse([centre[0],centre[1]], width*CL_alpha[2], height*CL_alpha[2], theta, \n",
    "                       linewidth=sty['w'], ls = sty['s'], fill=sty['f'], zorder=2, alpha=sty['a']/2, color=sty['c'])\n",
    "    leg2 = ellipse2.set(clip_box=ax.bbox, alpha=sty['a']/2, facecolor=sty['c'], edgecolor = 'black')\n",
    "\n",
    "    return ellipse1, ellipse2, CL_alpha[1]*em0, CL_alpha[1]*em1, CL_alpha[1]*eu0, CL_alpha[1]*eu1, leg1, leg2\n",
    "\n",
    "# Make a test plot\n",
    "ell1, ell2, errm0, errm1, erru0, erru1, leg1, leg2 = get_ellipses([c0,c1],covmat_2D,\n",
    "                                                    {'w':2,'s':'-','f':True,'a':0.4,'c':'tab:green'}) #without priors\n",
    "ell1_p, ell2_p, errm0_p, errm1_p, erru0_p, erru1_p, leg1_p, leg2_p = get_ellipses([c0,c1],covmat_2D_comb,\n",
    "                                                    {'w':2,'s':'--','f':True,'a':0.9,'c':'tab:purple'}) #with priors\n",
    "ells = [ell1,ell2,ell1_p,ell2_p]\n",
    "fig, ax = plt.subplots(figsize=(7,7))\n",
    "\n",
    "#ax.axhline(c1,ls='--',c='k',lw=1); ax.axvline(c0,ls='--',c='k',lw=1) # Centre lines\n",
    "#ax.axvline(c0-errm0,ls=':',c='g',lw=1); ax.axvline(c0+errm0,ls=':',c='g',lw=1) # Marginalised error lines par0\n",
    "#ax.axvline(c0-erru0,ls=':',c='c',lw=1); ax.axvline(c0+erru0,ls=':',c='c',lw=1) # Marginalised error lines par0\n",
    "#ax.axhline(c1-errm1,ls=':',c='g',lw=1); ax.axhline(c1+errm1,ls=':',c='g',lw=1) # Marginalised error lines par1\n",
    "#ax.axhline(c1-erru1,ls=':',c='c',lw=1); ax.axhline(c1+erru1,ls=':',c='c',lw=1) # Marginalised error lines par1\n",
    "\n",
    "ax.add_artist(ell1)\n",
    "ax.add_artist(ell2)\n",
    "ax.add_artist(ell1_p)\n",
    "ax.add_artist(ell2_p)\n",
    "ax.set_xlim(c0-errm0*2.1, c0+errm0*2.1)\n",
    "ax.set_ylim(c1-errm1*2.1, c1+errm1*2.4)\n",
    "ax.tick_params(color='black')\n",
    "ax.set_facecolor('none')\n",
    "#ax.axis('off')\n",
    "\n",
    "#plt.xlabel(par0+'(z='+str(z_vals[zi])+')')\n",
    "#plt.ylabel(par1+'(z='+str(z_vals[zi])+')')\n",
    "plt.xlabel('$f(z=0.5)$')\n",
    "plt.ylabel('$N(z=0.5)$')\n",
    "\n",
    "ax.legend([ell1,ell1_p], [r'no prior',r'with $10\\%$ prior on $\\{b_1,N\\}$'],loc='upper left',frameon=False)\n",
    "\n",
    "#plt.savefig('contour-EFT-zeq0p5.pdf', format=\"pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Alkistis & Dida, 2019"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}