test_Fisher.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from importlib import reload\n",
    "\n",
    "import universe\n",
    "reload(universe)\n",
    "from universe import *\n",
    "\n",
    "import projection_kernel\n",
    "reload(projection_kernel)\n",
    "from projection_kernel import *\n",
    "\n",
    "import p2d\n",
    "reload(p2d)\n",
    "from p2d import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 20.0, 3000.0\n"
     ]
    }
   ],
   "source": [
    "dss = 1.\n",
    "lMin = 20.   \n",
    "lMax = 3.e3  \n",
    "nL = 101\n",
    "fsky = 1.\n",
    "L, dL, Nmodes, Le = generateEllBins(lMin, lMax, nL, fsky) \n",
    "paramsUnivPlanck15 = {\n",
    "                    'output': 'dTk vTk mPk',#'lCl tCl pCl mPk',\n",
    "            #       'l_max_scalars': 2000,\n",
    "            #       'lensing': 'yes',\n",
    "                    'A_s': 2.3e-9,\n",
    "                    'n_s': 0.9624,\n",
    "                    'h': 0.6712,\n",
    "                    'N_ur': 3.046,\n",
    "                    'Omega_b': 0.0493,\n",
    "                    'Omega_cdm': 0.267,\n",
    "                    'Omega_k': 0.,\n",
    "                    'P_k_max_1/Mpc': 10.,\n",
    "                    'non linear': 'halofit',\n",
    "                    'z_max_pk': 100.\n",
    "                    }\n",
    "paramsHigh = {\n",
    "                    'output': 'dTk vTk mPk',#'lCl tCl pCl mPk',\n",
    "                    #'l_max_scalars': 2000,\n",
    "                    #'lensing': 'yes',\n",
    "                    'A_s': 2.3e-9 + dss*1.e-10,\n",
    "                    'n_s': 0.9624 + dss*0.01,\n",
    "                    'h': 0.6712 + dss*0.1,\n",
    "                    #'N_ur': 3.046,\n",
    "                    'Omega_b': 0.0493 + dss*0.0018,\n",
    "                    'Omega_cdm': 0.267 + dss*0.0066,\n",
    "                    'Omega_k': 0.,\n",
    "                    'P_k_max_1/Mpc': 10.,\n",
    "                    'non linear': 'halofit',\n",
    "                    'z_max_pk': 100.\n",
    "            }\n",
    "paramsLow = {\n",
    "                    'output': 'dTk vTk mPk',#'lCl tCl pCl mPk',\n",
    "                    #'l_max_scalars': 2000,\n",
    "                    #'lensing': 'yes',\n",
    "                    'A_s': 2.3e-9 - dss*1.e-10,\n",
    "                    'n_s': 0.9624 - dss*0.01,\n",
    "                    'h': 0.6712 - dss*0.1,\n",
    "                    #'N_ur': 3.046,\n",
    "                    'Omega_b': 0.0493 - dss*0.0018,\n",
    "                    'Omega_cdm': 0.267 - dss*0.0066,\n",
    "                    'Omega_k': 0.,\n",
    "                    'P_k_max_1/Mpc': 10.,\n",
    "                    'non linear': 'halofit',\n",
    "                    'z_max_pk': 100.\n",
    "            }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDerivative(param, binedges, L):\n",
    "    # high\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsHigh[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[0], zphMax=binedges[1])\n",
    "    w_other = WeightTracerLSSTSourcesDESCSRDV1(u) \n",
    "    p2d_high = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "    dataHigh = p2d_high.P1h+p2d_high.P2h+p2d_high.Pnoise\n",
    "    # low\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsLow[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[0], zphMax=binedges[1])\n",
    "    w_other = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "    p2d_low = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "    dataLow = p2d_low.P1h+p2d_low.P2h+p2d_low.Pnoise\n",
    "    \n",
    "    result = (dataHigh - dataLow) / (paramsHigh[param]-paramsLow[param])\n",
    "    return result\n",
    "\n",
    "def getCov(p_gg, Nmodes):\n",
    "    nData = nL\n",
    "    covMat = np.zeros((nData, nData))\n",
    "    cov = lambda Pac, Pbd, Pad, Pbc, Npairs: np.diagflat((Pac * Pbd + Pad * Pbc) / Npairs)\n",
    "    i1=0\n",
    "    i2=0 \n",
    "    p = p_gg.P1h+p_gg.P2h+p_gg.Pnoise \n",
    "    covBlock = cov(p, p, p, p, Nmodes)\n",
    "    covMat[i1*nL:(i1+1)*nL, i2*nL:(i2+1)*nL] = covBlock\n",
    "    return covMat \n",
    "\n",
    "def getFisher(p_gg, params, binedges, L, Nmodes):\n",
    "    nPar=len(params)\n",
    "    fisherData = np.zeros((nPar, nPar))\n",
    "    cov = getCov(p_gg, Nmodes)\n",
    "    invCov = np.linalg.inv(cov)\n",
    "    for i in range(nPar):\n",
    "        for j in range(nPar):\n",
    "            di = getDerivative(params[i], binedges, L)\n",
    "            dj = getDerivative(params[j], binedges, L)\n",
    "            fisherData[i,j] = np.dot(di.transpose(), np.dot(invCov, dj))\n",
    "    return fisherData\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this code, the Fisher analysis is done for a single observable $C_{\\ell}^{gg}$. This first test will be to run the analysis for the cross-product between the first redshift bin and the larger distribution of dn/dz, over the $\\Omega_b$ and $\\Omega_{CDM}$ parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.30434926e-05 1.97477444e-05]\n",
      " [1.97477444e-05 2.99037539e-05]]\n"
     ]
    }
   ],
   "source": [
    "u = UnivPlanck15()\n",
    "\n",
    "# computing the binedges for WeightTracerLSSTBins\n",
    "w = WeightTracerLSSTSourcesDESCSRDV1(u) \n",
    "nBins = 10\n",
    "binedges = w.splitBins(nBins)\n",
    "\n",
    "params = ['Omega_b', 'Omega_cdm']\n",
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[0], zphMax=binedges[1])\n",
    "w_other = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "p2d = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "fisher = getFisher(p2d, params, binedges, L, Nmodes)\n",
    "\n",
    "#calculating the covariance matrix\n",
    "print(np.linalg.inv(fisher))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking $\\sigma(f_{sky})$ behavior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will now check the behavior of the errors as we change the fraction of the sky being used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n",
      "generate: 20.0, 3000.0\n"
     ]
    }
   ],
   "source": [
    "fskies = np.arange(0.005, 1., 0.1)\n",
    "sigma_b = np.zeros(len(fskies))\n",
    "sigma_cdm = np.zeros(len(fskies))\n",
    "for i in range(len(fskies)):\n",
    "    L_new, dL, Nmodes_new, Le = generateEllBins(lMin, lMax, nL, fskies[i])\n",
    "    p2d_f = P2dCross(u, u, w_bin, w_other, lBins=L_new, nProc=3, save=True)\n",
    "    fisher_f = getFisher(p2d_f, params, binedges, L_new, Nmodes_new)\n",
    "    cov_f = np.linalg.inv(fisher_f)\n",
    "    sigma_b[i]=np.sqrt(cov_f[0][0])\n",
    "    sigma_cdm[i]=np.sqrt(cov_f[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(fskies, sigma_b, color='seagreen', label=r'$\\sigma_{bb}$')\n",
    "plt.plot(fskies, sigma_cdm, color='palevioletred', label=r'$\\sigma_{CDMCDM}$')\n",
    "plt.ylabel(r'$\\sigma$')\n",
    "plt.xlabel(r'$f_{sky}$')\n",
    "plt.legend(loc='upper right')\n",
    "plt.grid()\n",
    "plt.savefig('/Users/anacarolinaoliveira/Downloads/fsky_sigma.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing Fisher for other $C_{\\ell}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's go back to the fsky=1 cases, and the test will now be done for other power spectra. I modify the derivative function to get the fisher matrix for the cross-cross for 2 adjacent redshift bins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.59729706e-06 3.85266391e-06]\n",
      " [3.85266391e-06 5.71836339e-06]]\n"
     ]
    }
   ],
   "source": [
    "def getDerivative(param, binedges, L):\n",
    "    # high\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsHigh[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin1 = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "    w_bin2 = WeightTracerLSSTBins(u, zphMin=binedges[4], zphMax=binedges[5])\n",
    "    p2d_high = P2dCross(u, u, w_bin1, w_bin2, lBins=L, nProc=3, save=True)\n",
    "    dataHigh = p2d_high.P1h+p2d_high.P2h+p2d_high.Pnoise\n",
    "    # low\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsLow[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin1 = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "    w_bin2 = WeightTracerLSSTBins(u, zphMin=binedges[4], zphMax=binedges[5])\n",
    "    p2d_low = P2dCross(u, u, w_bin1, w_bin2, lBins=L, nProc=3, save=True)\n",
    "    dataLow = p2d_low.P1h+p2d_low.P2h+p2d_low.Pnoise\n",
    "    result = (dataHigh - dataLow) / (paramsHigh[param]-paramsLow[param])\n",
    "    return result\n",
    "\n",
    "w_bin1 = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "w_bin2 = WeightTracerLSSTBins(u, zphMin=binedges[4], zphMax=binedges[5])\n",
    "\n",
    "p2d_crossbins = P2dCross(u, u, w_bin1, w_bin2, lBins=L, nProc=3, save=True)\n",
    "fisher = getFisher(p2d_crossbins, params, binedges, L, Nmodes)\n",
    "\n",
    "print(np.linalg.inv(fisher))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the auto-auto for 1 bin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.85136533e-06 4.25397026e-06]\n",
      " [4.25397026e-06 6.35017281e-06]]\n"
     ]
    }
   ],
   "source": [
    "def getDerivative(param, binedges, L):\n",
    "    # high\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsHigh[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "    p2d_high = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "    dataHigh = p2d_high.P1h+p2d_high.P2h+p2d_high.Pnoise\n",
    "    # low\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsLow[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "    p2d_low = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "    dataLow = p2d_low.P1h+p2d_low.P2h+p2d_low.Pnoise\n",
    "    result = (dataHigh - dataLow) / (paramsHigh[param]-paramsLow[param])\n",
    "    return result\n",
    "\n",
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[3], zphMax=binedges[4])\n",
    "\n",
    "p2d_auto = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "fisher = getFisher(p2d_auto, params, binedges, L, Nmodes)\n",
    "\n",
    "print(np.linalg.inv(fisher))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test different parameters "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = UnivPlanck15()\n",
    "# computing the binedges for WeightTracerLSSTBins\n",
    "w = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "nBins = 10\n",
    "binedges = w.splitBins(nBins)\n",
    "\n",
    "params = ['A_s', 'Omega_b']\n",
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[0], zphMax=binedges[1])\n",
    "w_other = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "p2d = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "fisher = getFisher(p2d, params, binedges, L, Nmodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.58176125e-20 1.49904067e-12]\n",
      " [1.49904067e-12 8.70562231e-05]]\n",
      "[[ 1.88886264e+23 -3.25247503e+15]\n",
      " [-3.25247503e+15  5.60165855e+07]]\n"
     ]
    }
   ],
   "source": [
    "print(np.linalg.inv(fisher))\n",
    "print(fisher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\sigma_{A_sA_s}^2$ is pretty low. Let's take a look at the derivative of the data vector wrt to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDerivativedebug(param, binedges, L):\n",
    "    #original \n",
    "    parameters = paramsUnivPlanck15\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6])\n",
    "    w_other = WeightTracerLSSTSourcesDESCSRDV1(u) \n",
    "    p2d_ori = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "    dataOriginal = p2d_ori.P1h+p2d_ori.P2h+p2d_ori.Pnoise\n",
    "    # high\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsHigh[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6])\n",
    "    w_other = WeightTracerLSSTSourcesDESCSRDV1(u) \n",
    "    p2d_high = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "    dataHigh = p2d_high.P1h+p2d_high.P2h+p2d_high.Pnoise\n",
    "    # low\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsLow[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w_bin = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6])\n",
    "    w_other = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "    p2d_low = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "    dataLow = p2d_low.P1h+p2d_low.P2h+p2d_low.Pnoise\n",
    "    # print(dataOriginal/dataHigh)\n",
    "    # print(dataOriginal/dataLow)\n",
    "    print(dataHigh/dataOriginal - dataLow/dataOriginal)\n",
    "    result = (dataHigh - dataLow) / (paramsHigh[param]-paramsLow[param])\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0861938  0.0859967  0.08605928 0.08639093 0.08692227 0.08744257\n",
      " 0.08784288 0.08817906 0.08854667 0.08899928 0.08953836 0.09012715\n",
      " 0.09071211 0.09124821 0.0917159  0.09212275 0.09249297 0.09285434\n",
      " 0.09322908 0.09362984 0.09405948 0.09451304 0.09498019 0.09544843\n",
      " 0.09590618 0.09634441 0.09675861 0.09714767 0.09751464 0.09786413\n",
      " 0.09820216 0.09853434 0.0988654  0.09919892 0.09953639 0.09987868\n",
      " 0.1002246  0.10057273 0.10092089 0.10126678 0.10160807 0.10194327\n",
      " 0.10227083 0.10258995 0.10290071 0.10320314 0.10349794 0.10378602\n",
      " 0.10406843 0.10434627 0.10462031 0.10489146 0.10516059 0.10542792\n",
      " 0.1056937  0.10595818 0.10622121 0.10648261 0.10674223 0.10699962\n",
      " 0.10725448 0.10750665 0.10775588 0.10800179 0.10824428 0.10848336\n",
      " 0.10871898 0.10895107 0.10917982 0.10940535 0.10962776 0.10984714\n",
      " 0.11006376 0.11027786 0.11048952 0.11069883 0.11090596 0.11111111\n",
      " 0.11131431 0.11151559 0.111715   0.11191263 0.11210854 0.11230264\n",
      " 0.11249491 0.11268535 0.11287401 0.11306088 0.11324589 0.113429\n",
      " 0.11361022 0.11378959 0.11396713 0.11414281 0.11431661 0.11448854\n",
      " 0.11465867 0.11482707 0.11499374 0.11515869 0.11532194]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([697.0083458 , 410.3660265 , 335.49046748, 268.23254893,\n",
       "       217.69652861, 188.16238526, 171.89783273, 160.72534961,\n",
       "       150.18254515, 139.19597582, 128.41000009, 118.76206102,\n",
       "       110.79884613, 104.56366948,  99.75490477,  95.93302302,\n",
       "        92.67976156,  89.68479663,  86.77020829,  83.87334281,\n",
       "        81.00933631,  78.23180224,  75.60295454,  73.17119708,\n",
       "        70.96284653,  68.98198961,  67.21189002,  65.62622648,\n",
       "        64.19039484,  62.87157048,  61.63963595,  60.47079328,\n",
       "        59.34854717,  58.26156701,  57.20595697,  56.1796329 ,\n",
       "        55.18492888,  54.22455331,  53.30143477,  52.41807493,\n",
       "        51.57653047,  50.77636298,  50.01725878,  49.29750778,\n",
       "        48.61408845,  47.9642272 ,  47.34457153,  46.75193691,\n",
       "        46.18306996,  45.63510137,  45.10601975,  44.59373633,\n",
       "        44.09643471,  43.61325611,  43.14337203,  42.68607868,\n",
       "        42.24108858,  41.80811351,  41.38687907,  40.97745136,\n",
       "        40.5796634 ,  40.19318559,  39.81779862,  39.45340223,\n",
       "        39.09961916,  38.75600758,  38.42221423,  38.09787417,\n",
       "        37.7824365 ,  37.47546138,  37.17656968,  36.88537821,\n",
       "        36.60138439,  36.32417296,  36.05345367,  35.78894422,\n",
       "        35.53031879,  35.27725702,  35.02957934,  34.78710718,\n",
       "        34.54964271,  34.31698099,  34.08895731,  33.86549563,\n",
       "        33.64648887,  33.43179388,  33.22127314,  33.01481599,\n",
       "        32.81235412,  32.61381071,  32.41905341,  32.22796308,\n",
       "        32.04044081,  31.85640503,  31.6757803 ,  31.49846475,\n",
       "        31.32433051,  31.15327274,  30.98521251,  30.82007404,\n",
       "        30.65777556])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getDerivativedebug('A_s', binedges, L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cross check plotting "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 1.0, 1000.0\n"
     ]
    }
   ],
   "source": [
    "u = UnivPlanck15()\n",
    "\n",
    "# computing the binedges for WeightTracerLSSTBins\n",
    "w = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "lMin = 1.   \n",
    "lMax = 1.e3 \n",
    "nBins = 10\n",
    "binedges = w.splitBins(nBins)\n",
    "params = ['Omega_b', 'Omega_cdm', 'Omega_k', 'A_s', 'h', 'n_s']\n",
    "L, dL, Nmodes, Le = generateEllBins(lMin, lMax, nL, fsky)\n",
    "\n",
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[0], zphMax=binedges[1])\n",
    "w_other = WeightTracerLSSTSourcesDESCSRDV1(u)\n",
    "P = P2dCross(u, u, w_bin, w_other, lBins=L, nProc=3, save=True)\n",
    "Cl = P.P1h+P.P2h+P.Pnoise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### $\\frac{dlnC_{\\ell}}{dln(param)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 1.0, 1000.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anacarolinaoliveira/miniconda3/envs/LIMenv/lib/python3.6/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "dlnCl = np.zeros((len(params), 101))\n",
    "for i in range(len(params)): \n",
    "    deriv = getDerivative(params[i], binedges, L)\n",
    "    frac = paramsUnivPlanck15[params[i]] / Cl\n",
    "    dlnCl[i] = frac * deriv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(L[1:], dlnCl[0][1:], color='palevioletred', label=r'$\\Omega_b^0$')\n",
    "plt.plot(L[1:], dlnCl[1][1:], color='seagreen', label=r'$\\Omega_{CDM}^0$')\n",
    "plt.plot(L[1:], dlnCl[3][1:], color='cornflowerblue', label=r'$A_s$')\n",
    "plt.plot(L[1:], dlnCl[4][1:], color='darkorange', label=r'$h^0$')\n",
    "plt.plot(L[1:], dlnCl[5][1:], color='slateblue', label=r'$n_s$')\n",
    "plt.xscale('log')\n",
    "plt.legend(frameon=False, ncol=len(params))\n",
    "plt.ylim(bottom=-1.5)\n",
    "plt.xlim(left=100)\n",
    "plt.xlabel(r'$\\ell$')\n",
    "plt.ylabel(r'$d ln C_{\\ell} / d ln Param.$')\n",
    "plt.savefig('/Users/anacarolinaoliveira/Downloads/dlnCl_check.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### $\\ell C_{\\ell}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[8], zphMax=binedges[9])\n",
    "Pauto = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "Cl_auto = Pauto.P1h+Pauto.P2h+Pauto.Pnoise\n",
    "lCl = L*Cl_auto\n",
    "fig = plt.figure(figsize=(10, 2))\n",
    "plt.plot(L, lCl)\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.xlim(left=100, right=1000)\n",
    "plt.ylim(bottom=1e-05, top=0.01)\n",
    "plt.xlabel(r'$\\ell$')\n",
    "plt.ylabel(r'$\\ell C_{\\ell}$')\n",
    "plt.savefig('/Users/anacarolinaoliveira/Downloads/lCl_check.pdf')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\frac{\\sigma_{\\ell}}{C_{\\ell}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Pauto = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "Cl_auto = Pauto.P1h+Pauto.P2h+Pauto.Pnoise\n",
    "covMatrix = getCov(Pauto, Nmodes)\n",
    "sigmas = np.array([np.sqrt(covMatrix[i][i]) for i in range(len(covMatrix))])\n",
    "plt.figure(figsize=(10,7))\n",
    "plt.plot(L, sigmas/Cl_auto)\n",
    "plt.xscale('log')\n",
    "plt.xlim(left=100, right=1000)\n",
    "plt.xlabel(r'$\\ell$')\n",
    "plt.ylabel(r'$\\sigma_{\\ell} / C_{\\ell}$')\n",
    "plt.savefig('/Users/anacarolinaoliveira/Downloads/sigmalCl_check.pdf')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the noiseless power spectrum, the relative uncertainty is independent of $\\ell$, which I think goes back to the fact that we have the same number of modes per $\\ell$ bin. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SNR\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "707.1064276330685\n"
     ]
    }
   ],
   "source": [
    "w_bin = WeightTracerLSSTBins(u, zphMin=binedges[8], zphMax=binedges[9])\n",
    "Pauto = P2dAuto(u, u, w_bin, lBins=L, nProc=3, name='bin', save=True)\n",
    "Cl_auto = Pauto.P1h+Pauto.P2h+Pauto.Pnoise\n",
    "covMatrix = getCov(Pauto, Nmodes)\n",
    "invertedCov = np.linalg.inv(covMatrix)\n",
    "snr = np.sqrt(np.dot(Cl_auto.transpose(), np.dot(invertedCov, Cl_auto)))\n",
    "print(snr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducing noise "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, all the power spectra calculated were noiseless (they had the P.Pnoise term added, but since I didn't pass that argument in the P2d function, the term was just zero). Now, let's introduce the noise term. For that, we are (for now) limited to doing just auto-spectrum calculations, that have simple expressions for the noise power spectrum. The cross-spectrum noise term is a bit trickier and depends on which observables we're dealing with, so let's set them aside for the moment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will do the Fisher analysis for the auto-spectrum for an arbitrary redshift bin distribution. For this case, it's interesting to see how the sigmas behave as we increase the number of galaxies in the bin, so I will be running the calculation for multiple ngal cases. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining new functions to enable change of ngal\n",
    "def getDerivative_diff_ngal(param, binedges, L, ngal):\n",
    "    # high\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsHigh[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6], ngal=ngal)\n",
    "    p2d_high = P2dAuto(u, u, w, lBins=L, pNoise=lambda l: 1./w.ngal, nProc=3, name='bin', save=True)\n",
    "    dataHigh = p2d_high.P1h+p2d_high.P2h+p2d_high.Pnoise\n",
    "    # low\n",
    "    parameters = paramsUnivPlanck15.copy()\n",
    "    parameters[param] = paramsLow[param]\n",
    "    u = Universe(params=parameters)\n",
    "    w = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6], ngal=ngal)\n",
    "    p2d_low = P2dAuto(u, u, w, lBins=L, pNoise=lambda l: 1./w.ngal, nProc=3, name='bin', save=True)\n",
    "    dataLow = p2d_low.P1h+p2d_low.P2h+p2d_low.Pnoise\n",
    "    \n",
    "    result = (dataHigh - dataLow) / (paramsHigh[param]-paramsLow[param])\n",
    "    return result\n",
    "\n",
    "def getFisher_diff_ngal(p_gg, params, binedges, L, Nmodes, ngal):\n",
    "    nPar=len(params)\n",
    "    fisherData = np.zeros((nPar, nPar))\n",
    "    cov = getCov(p_gg, Nmodes)\n",
    "    invCov = np.linalg.inv(cov)\n",
    "    for i in range(nPar):\n",
    "        for j in range(nPar):\n",
    "            di = getDerivative_diff_ngal(params[i], binedges, L, ngal)\n",
    "            dj = getDerivative_diff_ngal(params[j], binedges, L, ngal)\n",
    "            fisherData[i,j] = np.dot(di.transpose(), np.dot(invCov, dj))\n",
    "    return fisherData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = UnivPlanck15()\n",
    "\n",
    "lMin = 20.   \n",
    "lMax = 3.e3  \n",
    "nL = 101\n",
    "fsky = 1.\n",
    "L, dL, Nmodes, Le = generateEllBins(lMin, lMax, nL, fsky) \n",
    "\n",
    "# computing the binedges for WeightTracerLSSTBins\n",
    "w = WeightTracerLSSTSourcesDESCSRDV1(u) \n",
    "nBins = 10\n",
    "binedges = w.splitBins(nBins)\n",
    "\n",
    "params = ['Omega_b', 'Omega_cdm', 'A_s', 'n_s']\n",
    "ngals = np.arange(20, 101, 5)\n",
    "\n",
    "# dictionary to store covariance matrices \n",
    "covs = {}\n",
    "\n",
    "for ngal in ngals:\n",
    "    w = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6], ngal=ngal)\n",
    "    p2d = P2dAuto(u, u, w, lBins=L, pNoise=lambda l: 1./w.ngal, nProc=3, name='bin', save=True)\n",
    "    fisher = getFisher_diff_ngal(p2d, params, binedges, L, Nmodes, ngal)\n",
    "    covMatrix = np.linalg.inv(fisher)\n",
    "    covs[ngal]=covMatrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "omega_b = [np.sqrt(covs[i][0][0]) for i in covs]\n",
    "omega_cdm = [np.sqrt(covs[i][1][1]) for i in covs]\n",
    "a_s = [np.sqrt(covs[i][2][2]) for i in covs]\n",
    "n_s = [np.sqrt(covs[i][3][3]) for i in covs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x648 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(2, 2, figsize=(12, 9), sharex=True)\n",
    "axs[0, 0].plot(ngals, omega_b, color='#2ca02c')\n",
    "axs[0, 0].set_title(r'$\\Omega_b$')\n",
    "axs[0, 0].set_ylabel(r'$\\sigma$')\n",
    "\n",
    "axs[0, 1].plot(ngals, omega_cdm, color='#2ca02c')\n",
    "axs[0, 1].set_title(r'$\\Omega_{CDM}$')\n",
    "\n",
    "axs[1, 0].plot(ngals, a_s, color='#2ca02c')\n",
    "axs[1, 0].set_title(r'$A_s$')\n",
    "axs[1, 0].set_xlabel(r'$n_{gal}$ per $arcmin^2$')\n",
    "axs[1, 0].set_ylabel(r'$\\sigma$')\n",
    "\n",
    "axs[1, 1].plot(ngals, n_s, color='#2ca02c')\n",
    "axs[1, 1].set_title(r'$n_s$')\n",
    "axs[1, 1].set_xlabel(r'$n_{gal}$ per $arcmin^2$')\n",
    "\n",
    "plt.savefig('/Users/anacarolinaoliveira/Downloads/ngal_check.pdf')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2D Contour plots "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will use the same data calculated above to produce the 2D contour plots, choosing the 30 ngal sample. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 20.0, 3000.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pygtc\n",
    "\n",
    "params_label = [r'$\\Omega_b$', r'$\\Omega_{cdm}$', r'$A_s/A_s^{fid}$', r'$n_s$']\n",
    "mus=[0.0493, 0.267, 2.3e-9, 0.9624]\n",
    "\n",
    "# taking a look at the power spectrum we're using for the contour plots\n",
    "lMin = 20.   \n",
    "lMax = 3.e3  \n",
    "nL = 101\n",
    "fsky = 1.\n",
    "L, dL, Nmodes, Le = generateEllBins(lMin, lMax, nL, fsky) \n",
    "w = WeightTracerLSSTBins(u, zphMin=binedges[5], zphMax=binedges[6], ngal=30)\n",
    "p2d = P2dAuto(u, u, w, lBins=L, pNoise=lambda l: 1./w.ngal, nProc=3, name='bin', save=True)\n",
    "p2d.plotP()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/anacarolinaoliveira/miniconda3/envs/LIMenv/lib/python3.6/site-packages/ipykernel_launcher.py:13: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  del sys.path[0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# generating distribution of samples with the mus and covariance \n",
    "# of the parameters to create the 2D contour plots\n",
    "\n",
    "num_samples = 10000  # number of samples to generate\n",
    "samples = np.random.multivariate_normal(mus, covs[30], size=num_samples)\n",
    "samples[:, 2] /= 2.3e-9 # to have A_s rescaled by the fiducial A_s\n",
    "truths = (0.0493, 0.267, 1, 0.9624) # x for each parameter mu \n",
    "gtc = pygtc.plotGTC(chains=[samples],\n",
    "                    paramNames=params_label,\n",
    "                    truths=truths,\n",
    "                    colorsOrder='blues',\n",
    "                    panelSpacing='loose')\n",
    "\n",
    "gtc.set_size_inches(10, 10) \n",
    "gtc.show()\n",
    "gtc.savefig('/Users/anacarolinaoliveira/Downloads/2dcontour.pdf')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "LIMenv",
   "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}