diff --git a/examples/triaxiality/Elliptical_lenses_MCMC.ipynb b/examples/triaxiality/Elliptical_lenses_MCMC.ipynb new file mode 100644 index 000000000..fd8dd570e --- /dev/null +++ b/examples/triaxiality/Elliptical_lenses_MCMC.ipynb @@ -0,0 +1,1181 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8bb95644-7071-4fbb-b970-1049e67fc4d3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "FlatwCDM(H0=71.0 km / (Mpc s), Om0=0.2648, w0=-1.0, Tcmb0=0.0 K, Neff=3.04, m_nu=None, Ob0=0.04479)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import clmm\n", + "from clmm import Cosmology\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import sys\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import random\n", + "import pandas\n", + "from scipy import integrate, signal\n", + "from scipy.stats import binned_statistic\n", + "from scipy.stats import norm\n", + "from scipy.special import erf\n", + "import astropy\n", + "import astropy.constants as const\n", + "import astropy.units as units\n", + "from astropy.io import fits\n", + "from astropy.table import Table\n", + "from astropy.cosmology import FlatLambdaCDM\n", + "from astropy.cosmology import FlatwCDM\n", + "from IPython.display import clear_output\n", + "import os\n", + "import corner\n", + "import emcee\n", + "from multiprocessing import Pool\n", + "from matplotlib.pyplot import cm\n", + "import time as pytime\n", + "\n", + "cosmo = Cosmology(H0=71.0, Omega_dm0=0.3 - 0.045, Omega_b0=0.045, Omega_k0=0.0)\n", + "FlatwCDM(H0=71, Om0=0.2648, Ob0=0.04479, w0=-1.000000)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "66d97ac4-3836-4a11-a7c2-ec92af62c317", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from scipy.interpolate import InterpolatedUnivariateSpline\n", + "def compute_delta_sigma_4theta(ell, r, mdelta, cdelta, z_cl, cosmo, hpmd='nfw', sample_N=10000, delta_mdef=200):\n", + "\n", + " ### DEFINING INTEGRALS:\n", + " r_arr = np.linspace(0.01, 3*np.max(r), sample_N)\n", + " sigma_0_arr = clmm.compute_surface_density(r_arr, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " eta_0_arr = np.gradient(np.log(sigma_0_arr),r_arr)*r_arr\n", + " f = InterpolatedUnivariateSpline(r_arr, (r_arr**3)*sigma_0_arr*eta_0_arr, k=3) # k=3 order of spline\n", + " integral_vec = np.vectorize(f.integral)\n", + " ###\n", + " \n", + " ### ACTUAL COMPUTATION:\n", + " I_1 = (3/(r**4)) * integral_vec(0, r)\n", + " sigma_0 = clmm.compute_surface_density(r, mdelta, cdelta, z_cl, cosmo, delta_mdef=200, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " #eta_0 = np.gradient(np.log(sigma_0),r)\n", + " eta_0_interpolation_func = InterpolatedUnivariateSpline(r_arr, eta_0_arr)\n", + " eta_0 = eta_0_interpolation_func(r) \n", + " \n", + " \n", + " return np.array((ell/4.0)*(2*I_1 - sigma_0*eta_0))\n", + "\n", + "def compute_delta_sigma_const(ell, r, mdelta, cdelta, z_cl, cosmo, hpmd='nfw', sample_N=10000 ,delta_mdef=200):\n", + "\n", + " ### DEFINING INTEGRALS:\n", + " r_arr = np.linspace(0.01, 3*np.max(r), sample_N)\n", + " sigma_0_arr = clmm.compute_surface_density(r_arr, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " eta_0_arr = np.gradient(np.log(sigma_0_arr),r_arr)*r_arr\n", + " f = InterpolatedUnivariateSpline(r_arr, sigma_0_arr*eta_0_arr/r_arr, k=3) # k=3 order of spline\n", + " integral_vec = np.vectorize(f.integral)\n", + " ###\n", + " \n", + " ### ACTUAL COMPUTATION:\n", + " I_2 = integral_vec(r, np.inf)\n", + " sigma_0 = clmm.compute_surface_density(r, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " #eta_0 = np.gradient(np.log(sigma_0), r)*r\n", + " eta_0_interpolation_func = InterpolatedUnivariateSpline(r_arr, eta_0_arr)\n", + " eta_0 = eta_0_interpolation_func(r) \n", + " \n", + " return np.array((ell/4.0)*(2*I_2 - sigma_0*eta_0))\n", + "\n", + "\n", + "def compute_delta_sigma_excess(ell, r, mdelta, cdelta, z_cl, cosmo, hpmd='nfw', sample_N=1000, delta_mdef=200):\n", + " r_arr = np.linspace(0.01, 3*np.max(r), sample_N)\n", + " sigma_0_arr = clmm.compute_surface_density(r_arr, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " eta_0_arr = np.gradient(np.log(sigma_0_arr),r_arr)*r_arr \n", + " eta_0_interpolation_func = InterpolatedUnivariateSpline(r_arr, eta_0_arr)\n", + " eta_0 = eta_0_interpolation_func(r) \n", + " \n", + " \n", + " \n", + " ## e^2 shenanigans:\n", + " d_eta_0_arr_by_d_r = np.gradient(eta_0_arr,r_arr)*r_arr\n", + " d_eta_0_arr_by_d_r_interpolation_func = InterpolatedUnivariateSpline(r_arr, d_eta_0_arr_by_d_r)\n", + " d_eta_0_by_d_r = d_eta_0_arr_by_d_r_interpolation_func(r)\n", + " \n", + " correction_factor_arr = (ell**2*((1/8)*eta_0_arr + (1/16)*d_eta_0_arr_by_d_r + (1/16)*eta_0_arr**2))\n", + " integrand = InterpolatedUnivariateSpline(r_arr, r_arr*sigma_0_arr*correction_factor_arr)\n", + " \n", + " integral_vec = np.vectorize(integrand.integral)\n", + " ##\n", + " \n", + " ### ACTUAL COMPUTATION:\n", + " I = (2/r**2)*integral_vec(0, r)\n", + " \n", + " #q=np.sqrt(2/(1+ell) - 1)\n", + " \n", + " s = clmm.compute_surface_density(r, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + " \n", + " correction_factor = (ell**2*((1/8)*eta_0 + (1/16)*d_eta_0_by_d_r + (1/16)*eta_0**2))\n", + " ds_ell_square_correction = I - s*correction_factor\n", + "\n", + " \n", + " return clmm.compute_excess_surface_density(r, mdelta, cdelta, z_cl, cosmo, delta_mdef=delta_mdef, \n", + " halo_profile_model=hpmd, massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True) + ds_ell_square_correction" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "99e863b1-eb3d-49bb-898e-733c55d8e507", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "## With emcee:\n", + "def log_likelihood_monopole(ds_mono,ds_mono_err, r_mono,params):\n", + " sigma_c = 3.77988e+15\n", + " z_cl=0.47\n", + " z_gal=0.8\n", + " mdelta,cdelta,ell,theta_e = params # km/s\n", + " \n", + " ds_data = ds_mono\n", + " \n", + " #model:\n", + " ds_model = compute_delta_sigma_excess(ell, r_mono, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)#/sigma_c\n", + " \n", + " # Gaussian likelihood:\n", + " #sigma = np.full(len(r_mono), ds_model*0.01) \n", + " sigma = ds_mono_err\n", + " term1 = -0.5*np.sum(np.log(2*np.pi*(sigma**2)))\n", + " chi2 = ((ds_data - ds_model)**2 / (sigma)**2)\n", + " term2 = -0.5*np.sum(chi2)\n", + "\n", + " return term1+term2\n", + "\n", + "def log_likelihood_quadrupole_4theta(ds_quad_4theta,ds_quad_4theta_err, r_quad,params):\n", + " sigma_c = 3.77988e+15\n", + " z_cl=0.47\n", + " z_gal=0.8\n", + " mdelta,cdelta,ell,theta_e = params # km/s\n", + " \n", + " ds_data = ds_quad_4theta\n", + " \n", + " #model:\n", + " ds_model = compute_delta_sigma_4theta(ell, r_quad, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)#/sigma_c\n", + " \n", + " # Gaussian likelihood:\n", + " #sigma = np.full(len(r_quad), ds_model*0.05) \n", + " sigma = ds_quad_4theta_err\n", + " term1 = -0.5*np.sum(np.log(2*np.pi*sigma**2))\n", + " chi2 = ((ds_data - ds_model)**2 / sigma**2)\n", + " term2 = -0.5*np.sum(chi2)\n", + "\n", + " return term1+term2\n", + "\n", + "def log_likelihood_quadrupole_const(ds_quad_const,ds_quad_const_err, r_quad,params):\n", + " sigma_c = 3.77988e+15\n", + " z_cl=0.47\n", + " z_gal=0.8\n", + " mdelta,cdelta,ell,theta_e = params # km/s\n", + " \n", + " ds_data = ds_quad_const\n", + " \n", + " #model:\n", + " ds_model = compute_delta_sigma_const(ell, r_quad, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)#/sigma_c\n", + " \n", + " # Gaussian likelihood:\n", + " #sigma = np.full(len(r_quad), ds_model*0.05) \n", + " sigma = ds_quad_const_err\n", + " term1 = -0.5*np.sum(np.log(2*np.pi*sigma**2))\n", + " chi2 = ((ds_data - ds_model)**2 / sigma**2)\n", + " term2 = -0.5*np.sum(chi2)\n", + "\n", + " return term1+term2\n", + "\n", + "def priors(params, limits):\n", + " \n", + " a,b,c,d = params\n", + " if (a < limits[0][0] or a > limits[0][1]): #mdelta\n", + " return -np.inf\n", + " elif (b < limits[1][0] or b > limits[1][1]): #cdelta\n", + " return -np.inf\n", + " elif (c < limits[2][0] or c > limits[2][1]): #ell\n", + " return -np.inf\n", + " elif (d < limits[3][0] or d > limits[3][1]): #sigma_int\n", + " return -np.inf\n", + "\n", + " else:\n", + " return 0.0\n", + "\n", + "def log_posterior(params,gamma1, gamma2, x_arcsec, y_arcsec, sigma_c = 3.77988e+15):\n", + " \n", + " mdelta,cdelta,ell,theta_e = params\n", + " #rotation:\n", + " theta_e = theta_e*np.pi/180.0 # in radians\n", + " gamma1,gamma2,x_arcsec,y_arcsec = halo_rotation(gamma1,gamma2,x_arcsec,y_arcsec,theta_e)\n", + " \n", + " #Prepare the data vector -> estimate delta sigma expansion terms\n", + " ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.47, sigma_c=3.77988e+15)\n", + " \n", + " #Evaluate the prior:\n", + " prior=priors(params, limits)\n", + " \n", + " #Avoid likelihood evaluation when prior is -infinity:\n", + " if prior == -np.inf:\n", + " lnP = -np.inf\n", + " else:\n", + " lnP = prior + log_likelihood_monopole(ds_mono,ds_mono_err, r_mono,params) + log_likelihood_quadrupole_const(ds_quad_const,ds_quad_const_err, r_quad,params) + log_likelihood_quadrupole_4theta(ds_quad_4theta, ds_quad_4theta_err, r_quad,params)\n", + " #log_likelihood_monopole(ds_mono,ds_mono_err, r_mono,params) +\n", + "\n", + " # safeguard against NaNs:\n", + " if np.isnan(lnP):\n", + " return -np.inf\n", + " else:\n", + " return lnP\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "93909edd-e1c0-4bf0-ba5e-a5e3fbb9f527", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def emcee_wrapper(gamma1, gamma2, x_arcsec, y_arcsec, z_cl, params_key, limits, true_value,\n", + " ndim, nwalkers, nsteps=1000, nburn=350, filename=None): \n", + " \n", + " starting_guess_t=[]\n", + " for i in np.arange(len(params_key)):\n", + " guess=[]\n", + " for j in np.arange(nwalkers):\n", + " guess.append((limits[i][1]-limits[i][0])*np.random.random()+limits[i][0])\n", + " starting_guess_t.append(guess)\n", + " starting_guesses=np.column_stack(starting_guess_t)\n", + " print('Starting guesses for ',nwalkers,' chains:')\n", + " print(starting_guesses)\n", + " \n", + " start=pytime.time()\n", + " \n", + " if filename!=None:\n", + " ## STORING THE CHAINS TO FILE\n", + " backend = emcee.backends.HDFBackend(filename)\n", + " backend.reset(nwalkers, ndim) ## Comment this line out to append steps to a previous run stored in the file\n", + " with Pool() as pool:\n", + " sampler = emcee.EnsembleSampler(nwalkers, ndim, log_posterior, args=[gamma1, gamma2, x_arcsec, y_arcsec],\n", + " vectorize=False, backend=backend, pool=pool)\n", + " pos, prob, state = sampler.run_mcmc(starting_guesses, nsteps, progress=True)\n", + " \n", + " if filename==None: \n", + " ## RETURNING THE CHAINS WITHOUT STORING TO FILE\n", + " with Pool() as pool:\n", + " sampler = emcee.EnsembleSampler(nwalkers, ndim, log_posterior, args=[gamma1, gamma2, x_arcsec, y_arcsec],\n", + " vectorize=False, pool=pool)\n", + " pos, prob, state = sampler.run_mcmc(starting_guesses, nsteps, progress=True)\n", + "\n", + " end=pytime.time()\n", + " print(\"Time taken:{0:.1f} seconds\".format(end-start))\n", + " \n", + " post = np.concatenate(sampler.chain[:, nburn: , :])\n", + " \n", + " #Corner plot:\n", + "\n", + " fig = plt.figure(figsize=[10,10])\n", + " figure = corner.corner(post,labels=params_key, quantiles=[0.16, 0.5, 0.84], \n", + " show_titles=True, title_fmt='.2e', fig=fig)\n", + " figure.patch.set_facecolor('white')\n", + " # Extract the axes\n", + " axes = np.array(figure.axes).reshape((ndim, ndim))\n", + " # Loop over the histograms\n", + " for yi in range(ndim):\n", + " for xi in range(yi):\n", + " ax = axes[yi, xi]\n", + " ax.axvline(true_value[xi], color=\"r\")\n", + " ax.axhline(true_value[yi], color=\"r\")\n", + " ax.plot(true_value[xi], true_value[yi], \"sr\")\n", + " #if yi == 1:\n", + " # ax.set_xlim([2000,2200])\n", + " \n", + " if f!=None:\n", + " plt.savefig(filename[:-3]+\"_corner_plot.png\",facecolor=\"white\", dpi=\"figure\", format=\"png\") \n", + " #Chain plot:\n", + "\n", + " color=iter(cm.rainbow(np.linspace(0,1,nwalkers)))\n", + " # set up a plot with two windows, one for each parameter:\n", + " plt.figure(figsize=(10,5))\n", + " #plt.patch.set_facecolor('white')\n", + " for i in range(len(params_key)):\n", + " plt.subplot(100*len(params_key)+10+i+1)\n", + " plt.ylabel(params_key[i], fontsize=10)\n", + " for j in range(nwalkers):\n", + " c=next(color)\n", + " for i in range(len(params_key)):\n", + " plt.subplot(100*len(params_key)+10+i+1)\n", + " plt.plot(sampler.chain[j,nburn:,i], ',', color=c)\n", + " \n", + " if f!= None:\n", + " plt.savefig(filename[:-3]+\"_chain_plot.png\",facecolor=\"white\", dpi=\"figure\", format=\"png\")\n", + " #A_fit = np.quantile((post[:,0].flatten()), 0.5)\n", + " #A_std_fit = np.std(post[:,0].flatten())\n", + " #A.append(A_fit)\n", + " #A_err.append(A_std_fit)\n", + " #print(A)\n", + " #return np.array(A), np.array(A_err), z_final\n", + " mean=[]\n", + " err_minus=[]\n", + " err_plus=[]\n", + " for i in range(len(params_key)):\n", + " mean.append(np.quantile((post[:,i].flatten()), 0.5))\n", + " err_minus.append(np.quantile((post[:,i].flatten()), 0.16))\n", + " err_plus.append(np.quantile((post[:,i].flatten()), 0.84))\n", + " mean = np.array(mean)\n", + " err_plus = np.array(err_plus) - mean\n", + " err_minus = mean - np.array(err_minus)\n", + "\n", + " return post, mean, err_plus, err_minus" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "c2fe4ab7-3ced-4cbf-99d4-5ce466eaa29c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def Delta_Sigma_const(w, gamma1, Sigma_crit) :\n", + "\t## TODO: sum over clusters\n", + "\treturn w * Sigma_crit * gamma1 / w\n", + "\n", + "def Delta_Sigma_4theta(w1, w2, gamma1, gamma2, theta, Sigma_crit) :\n", + "\t## TODO: sum over clusters\n", + "\treturn Sigma_crit * (w1*gamma1/np.cos(4*theta) + w2*gamma2/np.sin(4*theta)) / (w1 + w2)\n", + "\n", + "def Delta_Sigma_4theta_cross(w1, w2, gamma1, gamma2, theta, Sigma_crit) :\n", + "\t## TODO: sum over clusters\n", + "\treturn Sigma_crit * (w1*gamma1/np.cos(4*theta) - w2*gamma2/np.sin(4*theta)) / (w1 + w2)\n", + "\n", + "def Delta_Sigma_const_cross(w, gamma2, Sigma_crit) :\n", + "\t## TODO: sum over clusters\n", + "\treturn w*Sigma_crit*gamma2 / w\n", + "\n", + "def weights(Sigma_crit, theta, Sigma_shape=0.0001, Sigma_meas=0) :\n", + "\t## EQUATION 35, 32, 33\n", + "\tw = 1 / (Sigma_crit**2 * (Sigma_shape**2 + Sigma_meas**2))\n", + "\tw1 = np.cos(4*theta)**2 * w\n", + "\tw2 = np.sin(4*theta)**2 * w\n", + "\treturn w, w1, w2\n", + "\n", + "def make_radial_bins(x, y, Nbins=10) :\n", + "\tr = np.sqrt(x**2 + y**2)\n", + "\t#r_bins = np.linspace(np.min(r), np.max(r), Nbins+1)\n", + "\trbin_edges = np.logspace(np.log10(0.4), np.log10(2.5), Nbins+1)\n", + "\tinds = np.digitize(r, rbin_edges, right=True) - 1\n", + "\trbin_mean = np.array([np.mean(r[inds==i]) for i in range(Nbins)])\n", + "\treturn r, rbin_edges, rbin_mean, inds\n", + "\n", + "def make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, sigma_c=3.77988e+15, method=1):\n", + " r = np.sqrt((x_arcsec**2 + y_arcsec**2))\n", + " theta = np.arctan2(y_arcsec, x_arcsec)\n", + " #theta = theta - np.pi/2\n", + " r_mpc = r*0.00588784182755241#cosmo.eval_da(z_cl)\n", + " \n", + " w, w1, w2 = weights(sigma_c, theta)\n", + " DS4theta = Delta_Sigma_4theta(w1, w2, gamma1, gamma2, theta, sigma_c)\n", + " DSconst = Delta_Sigma_const(w, gamma1, sigma_c)\n", + " \n", + " bins=10\n", + " if method == 1 :\n", + " ## METHOD 1 ##\n", + " \n", + " bin_edges = np.logspace(np.log10(0.4), np.log10(2.5), bins)\n", + " N_i = []\n", + " for i in np.arange(bins-1):\n", + " N_i.append(len(r_mpc[(r_mpc > bin_edges[i]) & (r_mpc < bin_edges[i+1])]))\n", + " N_i=np.array(N_i)\n", + "\n", + "\n", + " result = binned_statistic(r_mpc, gamma1, statistic='mean', bins=bin_edges)\n", + " gamma1_i = result.statistic\n", + " res = binned_statistic(r_mpc, gamma2, statistic='mean', bins=bin_edges)\n", + " gamma2_i = res.statistic\n", + " res = binned_statistic(r_mpc, DS4theta, statistic='mean', bins=bin_edges)\n", + " DS4theta_i_err = binned_statistic(r_mpc, DS4theta, statistic='std', bins=bin_edges).statistic/np.sqrt(N_i)\n", + " DS4theta_i = res.statistic\n", + " res = binned_statistic(r_mpc, DSconst, statistic='mean', bins=bin_edges)\n", + " DSconst_i = res.statistic\n", + " DSconst_i_err = binned_statistic(r_mpc, DSconst, statistic='std', bins=bin_edges).statistic/np.sqrt(N_i)\n", + "\n", + " r_i = bin_edges + (bin_edges[1]-bin_edges[0])\n", + " \n", + " bins_mono=15\n", + " bin_edges = np.logspace(np.log10(0.4), np.log10(2.5), bins_mono)\n", + " N_i = []\n", + " for i in np.arange(bins_mono-1):\n", + " N_i.append(len(r_mpc[(r_mpc > bin_edges[i]) & (r_mpc < bin_edges[i+1])]))\n", + " N_i=np.array(N_i)\n", + " \n", + " r_mono = bin_edges + (bin_edges[1]-bin_edges[0])\n", + " res = binned_statistic(r_mpc, gamma1*np.cos(2*theta), statistic='mean', bins=bin_edges)\n", + " gammat_mono = -2*res.statistic\n", + " ds_mono_err = 2*binned_statistic(r_mpc, gamma1*np.cos(2*theta), statistic='std', bins=bin_edges).statistic/np.sqrt(N_i)*sigma_c\n", + " ds_mono = gammat_mono*sigma_c\n", + " \n", + " elif method == 2 :\n", + " ## METHOD 2 ## -- DEPRECATED AS WE WANT DIFFERENT NUMBER OF BINS FOR MONOPOLE AND QUADRUPOLE\n", + "\n", + " Nbins = bins-1\n", + " arcsec_to_Mpc = 0.00588784182755241\n", + " r, rbin_edges, r_bins, r_inds = make_radial_bins(x_arcsec*arcsec_to_Mpc, y_arcsec*arcsec_to_Mpc, Nbins)\n", + "\n", + " ds_mono=[]\n", + " ds_mono_err=[]\n", + " delta_sigmas_4theta = []\n", + " delta_sigmas_const = []\n", + " delta_sigmas_4theta_cross = []\n", + " delta_sigmas_const_cross = []\n", + " delta_sigmas_4theta_err = []\n", + " delta_sigmas_const_err = []\n", + " delta_sigmas_4theta_cross_err = []\n", + " delta_sigmas_const_cross_err = []\n", + " for i in range(Nbins):\n", + " select = (r_inds == i)\n", + " theta_i = theta[select]\n", + " gamma1_i = gamma1[select]\n", + " gamma2_i = gamma2[select]\n", + " w_i, w1_i, w2_i = weights(sigma_c, theta_i)\n", + " DS4thetai = Delta_Sigma_4theta(w1_i, w2_i, gamma1_i, gamma2_i, theta_i, sigma_c)\n", + " DSconsti = Delta_Sigma_const(w_i, gamma1_i, sigma_c)\n", + " DS4thetacrossi = Delta_Sigma_4theta_cross(w1_i, w2_i, gamma1_i, gamma2_i, theta_i, sigma_c)\n", + " DSconstcrossi = Delta_Sigma_const_cross(w_i, gamma2_i, sigma_c)\n", + " DSmonoi = gamma1_i*np.cos(2*theta_i)*sigma_c\n", + "\n", + " ds_mono.append(-2*np.mean(DSmonoi))\n", + " ds_mono_err.append(2*np.std(DSmonoi)/np.sqrt(len(DSmonoi)))\n", + " delta_sigmas_4theta.append(np.mean(DS4thetai))\n", + " delta_sigmas_4theta_err.append(np.std(DS4thetai)/np.sqrt(len(DS4thetai)))\n", + " delta_sigmas_const.append(np.mean(DSconsti))\n", + " delta_sigmas_const_err.append(np.std(DSconsti)/np.sqrt(len(DSconsti)))\n", + " #delta_sigmas_4theta_cross.append([np.mean(DS4thetacrossi), np.std(DS4thetacrossi)/np.sqrt(len(DS4thetacrossi))])\n", + " #delta_sigmas_const_cross.append([np.mean(DSconstcrossi), np.std(DSconstcrossi)/np.sqrt(len(DSconstcrossi))])\n", + "\n", + " r_i=np.array(rbin_edges + (rbin_edges[1]-rbin_edges[0]))\n", + " r_mono=r_i\n", + " ds_mono = np.array(ds_mono)\n", + " ds_mono_err = np.array(ds_mono_err)\n", + " DS4theta_i = np.array(delta_sigmas_4theta)\n", + " DS4theta_i_err = np.array(delta_sigmas_4theta_err)\n", + " DSconst_i = np.array(delta_sigmas_const)\n", + " DSconst_i_err = np.array(delta_sigmas_const_err)\n", + "\n", + " return ds_mono,np.abs(ds_mono_err),r_mono[:-1],DS4theta_i,np.abs(DS4theta_i_err),DSconst_i,np.abs(DSconst_i_err),r_i[:-1]\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "32c3a72f-de07-493d-876d-ccfc7d68a385", + "metadata": {}, + "source": [ + "Use rotation as given by equations 33~36 in man_glafic, ooguri et al. " + ] + }, + { + "cell_type": "markdown", + "id": "22007c39-88e8-4d2e-aa41-4ed9ba022cda", + "metadata": { + "tags": [] + }, + "source": [ + "Writing the equations A.19, A.20 from Ooguri et al. (Manual for glafic):\n", + "\n", + "$ \\tilde{x} = x\\cos(\\theta_{e}) + y\\sin(\\theta_{e}) $\\\n", + "$ \\tilde{y} = -x\\sin(\\theta_{e}) + y\\cos(\\theta_{e}) $\n", + "\n", + "And, equations A.33 through A.35:\n", + "\n", + "$ \\phi_{xx} = \\phi_{\\tilde{x}\\tilde{x}} \\cos^{2}(\\theta_{e}) - 2 \\phi_{\\tilde{x}\\tilde{y}}\\sin(\\theta_{e})\\cos(\\theta_{e}) + \\phi_{\\tilde{y}\\tilde{y}} \\sin^{2}(\\theta_{e}) $\\\n", + "$ \\phi_{yy} = \\phi_{\\tilde{x}\\tilde{x}} \\sin^{2}(\\theta_{e}) + 2 \\phi_{\\tilde{x}\\tilde{y}}\\sin(\\theta_{e})\\cos(\\theta_{e}) + \\phi_{\\tilde{y}\\tilde{y}} \\cos^{2}(\\theta_{e}) $\\\n", + "$ \\phi_{xy} = \\phi_{\\tilde{x}\\tilde{x}}\\sin(\\theta_{e})\\cos(\\theta_{e}) + \\phi_{\\tilde{x}\\tilde{y}}(\\cos^{2}(\\theta_{e}) - \\sin^{2}(\\theta_{e})) - \\phi_{\\tilde{y}\\tilde{y}}\\sin(\\theta_{e})\\cos(\\theta_{e}) $\n", + "\n", + "Original co-ordinates are x,y,$\\gamma_{1}$,$\\gamma_{2}$, while the major axis co-ordinates will be rotated by $\\theta_{e}$ to give $\\tilde{x}$,$\\tilde{y}$,$\\tilde\\gamma_{1}$,$\\tilde\\gamma_{2}$ \n", + "\n", + "And, $\\gamma_{1} = \\dfrac{\\phi_{xx} - \\phi_{yy}}{2}$ ; $\\gamma_{2} = \\phi_{xy}$\n", + "\n", + "Then:\\\n", + "$\\gamma_{1} = \\tilde\\gamma_{1}(\\cos^{2}(\\theta_{e}) - \\sin^{2}(\\theta_{e})) - 2\\tilde\\gamma_{2}\\sin(\\theta_{e})\\cos(\\theta_{e})$\\\n", + "$\\gamma_{2} = 2\\tilde\\gamma_{1}\\sin(\\theta_{e})\\cos(\\theta_{e}) + \\tilde\\gamma_{2}(\\cos^{2}(\\theta_{e}) - \\sin^{2}(\\theta_{e}))$\n", + "\n", + "$\\tilde\\gamma_{1} = \\gamma_{1}(\\cos^{2}(\\theta_{e}) - \\sin^{2}(\\theta_{e})) + 2\\gamma_{2}\\sin(\\theta_{e})\\cos(\\theta_{e})$\\\n", + "$\\tilde\\gamma_{2} = - 2\\gamma_{1}\\sin(\\theta_{e})\\cos(\\theta_{e}) + \\gamma_{2}(\\cos^{2}(\\theta_{e}) - \\sin^{2}(\\theta_{e}))$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "9c4d15e7-ca6a-4891-8a9b-cc0d8e2c05b0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def halo_rotation(gamma1,gamma2,x,y, theta_e):\n", + " '''\n", + " theta_e is the absolute rotation of the halo, assuming input halo is aligned along the x-axis\n", + " '''\n", + " x_tilde = x*np.cos(theta_e) + y*np.sin(theta_e)\n", + " y_tilde = -1*x*np.sin(theta_e) + y*np.cos(theta_e)\n", + " \n", + " gamma1_tilde = gamma1*(np.cos(theta_e)**2 - np.sin(theta_e)**2) + 2*gamma2*np.sin(theta_e)*np.cos(theta_e)\n", + " gamma2_tilde = -2*gamma1*np.sin(theta_e)*np.cos(theta_e) + gamma2*(np.cos(theta_e)**2 - np.sin(theta_e)**2)\n", + " return gamma1_tilde,gamma2_tilde,x_tilde,y_tilde" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "ccbe6cc9-ae57-48d3-a0fe-a8d42d4da713", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "dir_loc = \"Elliptical_lenses_data/axis_ratio_9_10/\"\n", + "\n", + "gamma1 = np.load(dir_loc+\"gamma1.npy\").flatten()\n", + "gamma2 = np.load(dir_loc+\"gamma2.npy\").flatten()\n", + "\n", + "x_arcsec = np.load(dir_loc+\"x_arcsec.npy\").flatten()\n", + "y_arcsec = np.load(dir_loc+\"y_arcsec.npy\").flatten()\n", + "\n", + "#ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, sigma_c=3.77988e+15)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "a431f10a-1045-4144-b5fc-f9f73179be97", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, \n", + " sigma_c=3.77988e+15, method=1)\n", + "plt.errorbar(r_quad, ds_quad_4theta, ls='solid', color='blue', label='METHOD 1')\n", + "plt.errorbar(r_quad, ds_quad_const, ls='solid', color='orange')\n", + "\n", + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, \n", + " sigma_c=3.77988e+15, method=2)\n", + "plt.errorbar(r_quad, ds_quad_4theta, ls='dashed', color='blue', label='METHOD 2')\n", + "plt.errorbar(r_quad, ds_quad_const, ls='dashed', color='orange')\n", + "#plt.xlim(0.2,0.5)\n", + "plt.xlabel('r', fontsize=18)\n", + "plt.title('Binned Data -- QUADRUPOLE',fontsize=18)\n", + "plt.ylabel('$\\Delta\\Sigma$ in $M_{\\odot}/Mpc^2$', fontsize=15)\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "262dd5d4-bd95-4f4b-b997-14568e925140", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, \n", + " sigma_c=3.77988e+15, method=1)\n", + "plt.errorbar(r_mono, ds_mono, yerr=ds_mono_err, ls='solid', color='black', label='METHOD 1')\n", + "\n", + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, \n", + " sigma_c=3.77988e+15, method=2)\n", + "plt.errorbar(r_mono, ds_mono, yerr=ds_mono_err, ls='dashed', color='slategray', label='METHOD 2')\n", + "\n", + "#plt.xlim(0.2,0.5)\n", + "plt.xlabel('r', fontsize=18)\n", + "plt.title('Binned Data -- MONOPOLE',fontsize=18)\n", + "plt.ylabel('$\\Delta\\Sigma$ in $M_{\\odot}/Mpc^2$', fontsize=15)\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "3c57c186-bfe4-4574-b378-7d14c42cb7ed", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3824860613936461.0\n", + "0.005816313203836024\n" + ] + } + ], + "source": [ + "#3.77988e+15\n", + "print(cosmo.eval_sigma_crit(0.3,0.63))\n", + "print(cosmo.eval_da(0.47) * np.pi/180.0 * 1/3600)" + ] + }, + { + "cell_type": "markdown", + "id": "ea53fec6-d932-4307-865a-cbe5058f5b59", + "metadata": {}, + "source": [ + " Plotting Shears and their ARBITRARY ROTATION: " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "b9c30f66-420a-4ffc-b063-b4c64150bb0b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "dir_loc_arr = [\"Elliptical_lenses_data/axis_ratio_9_10/\",\"Elliptical_lenses_data/axis_ratio_1/\",\"Elliptical_lenses_data/horizontal_rescale/\", \"transform\"]\n", + "n=len(dir_loc_arr)\n", + "size=5#int(5/(n-2))\n", + "plt.figure(figsize=[n*size,size])\n", + "for i,dir_loc in enumerate(dir_loc_arr):\n", + " if dir_loc == \"transform\":\n", + " plt.subplot(int(10*n)+100+i+1)\n", + " \n", + " theta_e = np.pi/4-np.pi/16 # in radians\n", + " gamma1,gamma2,x_arcsec,y_arcsec = halo_rotation(gamma1,gamma2,x_arcsec,y_arcsec,theta_e)\n", + " q = plt.quiver(x_arcsec, y_arcsec, gamma1, gamma2, headwidth=0)\n", + " plt.xlim([-100,100])\n", + " plt.ylim([-100,100])\n", + " plt.title(\"Horizontal_rescale + \\n theta_e = \"+str(theta_e*180.0/np.pi))\n", + " \n", + " else: \n", + " \n", + " plt.subplot(int(10*n)+100+i+1)\n", + " gamma1 = np.load(dir_loc+\"gamma1.npy\").flatten()\n", + " gamma2 = np.load(dir_loc+\"gamma2.npy\").flatten()\n", + "\n", + " x_arcsec = np.load(dir_loc+\"x_arcsec.npy\").flatten()\n", + " y_arcsec = np.load(dir_loc+\"y_arcsec.npy\").flatten()\n", + "\n", + "\n", + "\n", + " X = np.arange(-10, 10, 1)\n", + " Y = np.arange(-10, 10, 1)\n", + " U, V = np.meshgrid(X, Y)\n", + "\n", + " #plt.figure(figsize=[7,7])\n", + " #fig, ax = plt.subplots()\n", + "\n", + " q = plt.quiver(x_arcsec, y_arcsec, gamma1, gamma2, headwidth=0)\n", + " #ax.quiverkey(q, X=0.3, Y=1.1, U=10,\n", + " # label='Quiver key, length = 10', labelpos='E')\n", + "\n", + "\n", + " plt.xlim([-100,100])\n", + " plt.ylim([-100,100])\n", + " plt.title(dir_loc)\n", + "#plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "bbffefde-fea3-4f57-bef4-e90f471c64e1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting guesses for 12 chains:\n", + "[[ 2.74857938e+14 1.13608912e+01 -7.55816637e-01 2.75443075e+01]\n", + " [ 3.57879494e+14 1.85119328e+01 2.77043622e-01 2.77620299e+01]\n", + " [ 3.01778925e+14 1.42072116e+00 -7.06160491e-01 4.24686635e+01]\n", + " [ 2.72896708e+14 1.74258599e+00 8.80444456e-01 3.06819135e+01]\n", + " [ 2.12403745e+14 4.04367949e-01 4.32596771e-02 1.61778555e+01]\n", + " [ 3.23301162e+14 1.66523969e+01 -1.68969359e-01 1.96664379e+01]\n", + " [ 2.19356018e+14 1.55631350e+01 -4.66179888e-01 3.13934038e+01]\n", + " [ 4.45994727e+14 1.74002430e+01 5.42982705e-01 2.71014622e+00]\n", + " [ 4.81867717e+14 1.95723668e+01 -8.68223422e-02 3.00045022e+01]\n", + " [ 1.92337318e+14 1.59831713e+01 1.35499219e-01 3.01787041e+01]\n", + " [ 3.96070794e+14 9.22958725e+00 -9.52796195e-01 9.46721525e+00]\n", + " [ 2.64918565e+14 1.56105835e+01 2.32918284e-01 5.80168339e+00]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6000/6000 [02:26<00:00, 40.82it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time taken:147.6 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f=None\n", + "\n", + "#MCMC parameters:\n", + "params_key=[\"M200m\",\"c200m\",\"e\",r\"$\\theta_{e}$ in degrees\"]\n", + "ndim = len(params_key)\n", + "nwalkers = ndim*2+4\n", + "nsteps = 6000\n", + "nburns = 3000\n", + "np.random.seed(0)\n", + "\n", + "limits=[[1.0E12,5.0E14], # mdelta\n", + " [0.0,20.0], # cdelta\n", + " [-0.99,0.99], # e\n", + " [0.0, 45.0]] # theta_e #in degrees\n", + "z_cl=0.47\n", + "z_gal=0.8\n", + "q_true=9.0/10.0 #default = 2/3 for the files in the same directory as this notebook\n", + "ell_true= 1*(1-q_true**2)/(1+q_true**2)\n", + "theta_e_true = 0.0\n", + "true_value=[2.5E14, 3.89055, ell_true,theta_e_true]\n", + "\n", + "'''\n", + "Axis ratio q: 0.6666666666666667\n", + "c: 3.890554441834905\n", + "r200_Mpc: 1.026773208537997\n", + "ARCSEC_TO_MPC: 0.00588784182755241\n", + "BOX_WIDTH_ARCSEC*ARCSEC_TO_MPC: 5.88784182755241\n", + "SIGMA_C=3.77988e+15\n", + "arcsec_per_pix: 10.0\n", + "'''\n", + "# PREP DATA:\n", + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.3, \n", + " sigma_c=3.77988e+15, method=1)\n", + "\n", + "\n", + "# CALL EMCEE\n", + "post, mean, err_plus, err_minus = emcee_wrapper(gamma1, gamma2, x_arcsec, y_arcsec,z_cl=0.3,\n", + " params_key=params_key,limits=limits,true_value=true_value, ndim=ndim,nwalkers=nwalkers,nsteps=nsteps, nburn=nburns, filename=f)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "18f842d5-05dc-4712-bac8-5bd53e7641b0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ell_fit = -0.08246518517681337\n", + "[ 6.78285397e+11 4.55906002e+11 2.94390951e+11 1.81167979e+11\n", + " 1.04385183e+11 5.38767776e+10 2.15553007e+10 1.37447301e+09\n", + " -1.09560831e+10]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mdelta_fit = mean[0]#2.5E14#\n", + "cdelta_fit = mean[1]#3.89#\n", + "ell_fit = mean[2]#ell_true#\n", + "print(\"ell_fit = \",ell_fit)\n", + "theta_e_fit = mean[3]-0.2 #in degrees\n", + "dir_loc = \"Elliptical_lenses_data/axis_ratio_9_10/\"\n", + "\n", + "gamma1 = np.load(dir_loc+\"gamma1.npy\").flatten()\n", + "gamma2 = np.load(dir_loc+\"gamma2.npy\").flatten()\n", + "\n", + "x_arcsec = np.load(dir_loc+\"x_arcsec.npy\").flatten()\n", + "y_arcsec = np.load(dir_loc+\"y_arcsec.npy\").flatten()\n", + "\n", + "theta_e_fit = theta_e_fit*np.pi/180.0\n", + "gamma1,gamma2,x_arcsec,y_arcsec = halo_rotation(gamma1,gamma2,x_arcsec,y_arcsec,theta_e_fit)\n", + "ds_mono,ds_mono_err,r_mono,ds_quad_4theta,ds_quad_4theta_err,ds_quad_const,ds_quad_const_err,r_quad = make_estimators(gamma1, gamma2, x_arcsec, y_arcsec, z_cl=0.47, sigma_c=3.77988e+15)\n", + "\n", + "\n", + "\n", + "plt.figure(figsize=[13,5])\n", + "plt.subplot(131)\n", + "plt.errorbar(r_mono, ds_mono, yerr=np.abs(ds_mono_err), label='data', color='orange')\n", + "ds_model = compute_delta_sigma_excess(ell_fit, r_mono, mdelta_fit, cdelta_fit, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)\n", + "ds_model_without_e_square = clmm.compute_excess_surface_density(r_mono, mdelta_fit, cdelta_fit, z_cl, cosmo, delta_mdef=200, \n", + " halo_profile_model='nfw', massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)\n", + "plt.plot(r_mono, ds_model, label='model[FIT]', color='darkblue')\n", + "#plt.plot(r_mono, ds_model_without_e_square-ds_model, label='model*(1+e^2) - model', color='darkblue', ls='dashed')\n", + "#plt.yscale('log')\n", + "plt.xlabel('r (Mpc)')\n", + "plt.title(r'$\\Delta\\Sigma^{mono}$')\n", + "plt.legend()\n", + "\n", + "plt.subplot(132)\n", + "ds_model = compute_delta_sigma_const(ell_fit, r_quad, mdelta_fit, cdelta_fit, z_cl=0.3, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)\n", + "plt.plot(r_quad, ds_model, label='model[FIT]', color='darkblue')\n", + "print(ds_model)\n", + "plt.errorbar(r_quad, ds_quad_const, yerr=ds_quad_const_err, label='data', color='orange')\n", + "plt.yscale('linear')\n", + "plt.xscale('linear')\n", + "plt.title(r'$\\Delta\\Sigma^{quad}_{const}$')\n", + "plt.xlabel('r (Mpc)')\n", + "plt.legend()\n", + "\n", + "plt.subplot(133)\n", + "ds_model = compute_delta_sigma_4theta(ell_fit, r_quad, mdelta_fit, cdelta_fit, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)\n", + "plt.plot(r_quad, ds_model, label='model[FIT]', color='darkblue')\n", + "\n", + "plt.errorbar(r_quad, ds_quad_4theta, yerr=ds_quad_4theta_err, label='data', color='orange')\n", + "plt.yscale('linear')\n", + "plt.xscale('linear')\n", + "plt.title(r'$\\Delta\\Sigma^{quad}_{4\\Theta}$')\n", + "plt.xlabel('r (Mpc)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "08625898-201a-4919-9417-5af0269505df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.0e+13 2.0e+13 3.0e+13 4.0e+13 5.0e+13 6.0e+13 7.0e+13 8.0e+13 9.0e+13\n", + " 1.0e+14 1.1e+14 1.2e+14 1.3e+14 1.4e+14 1.5e+14 1.6e+14 1.7e+14 1.8e+14\n", + " 1.9e+14 2.0e+14 2.1e+14 2.2e+14 2.3e+14 2.4e+14 2.5e+14 2.6e+14 2.7e+14\n", + " 2.8e+14 2.9e+14 3.0e+14 3.1e+14 3.2e+14 3.3e+14 3.4e+14 3.5e+14 3.6e+14\n", + " 3.7e+14 3.8e+14 3.9e+14 4.0e+14 4.1e+14 4.2e+14 4.3e+14 4.4e+14 4.5e+14\n", + " 4.6e+14 4.7e+14 4.8e+14 4.9e+14 5.0e+14 5.1e+14 5.2e+14 5.3e+14 5.4e+14\n", + " 5.5e+14 5.6e+14 5.7e+14 5.8e+14 5.9e+14 6.0e+14 6.1e+14 6.2e+14 6.3e+14\n", + " 6.4e+14 6.5e+14 6.6e+14 6.7e+14 6.8e+14 6.9e+14 7.0e+14 7.1e+14 7.2e+14\n", + " 7.3e+14 7.4e+14 7.5e+14 7.6e+14 7.7e+14 7.8e+14 7.9e+14 8.0e+14 8.1e+14\n", + " 8.2e+14 8.3e+14 8.4e+14 8.5e+14 8.6e+14 8.7e+14 8.8e+14 8.9e+14 9.0e+14\n", + " 9.1e+14 9.2e+14 9.3e+14 9.4e+14 9.5e+14 9.6e+14 9.7e+14 9.8e+14 9.9e+14\n", + " 1.0e+15]\n", + "[-58494.627138733995, -50157.95457360413, -43172.4036943896, -37128.13730970341, -31822.593260328373, -27132.371152183798, -22973.471564914194, -19284.574623792498, -16018.700205673753, -13138.555138860243, -10613.72093294838, -8418.848176615835, -6532.441145466495, -4936.007947357664, -3613.447343733638, -2550.594555813008, -1734.8772292700748, -1155.049774544227, -800.9847613994174, -663.5066856450464, -734.2577636354574, -1005.5883173743372, -1470.466306036423, -2122.401953794235, -2955.3844167891193, -3963.828150985255, -5142.527170907046, -6486.615782724676, -7991.5346718671735, -9653.001451658476, -11466.984953914203, -13429.68267820704, -15537.500923138336, -17787.037207399077, -20175.064655809423, -22698.518079723934, -25354.481525066367, -28140.177097009684, -31052.954899627304, -34090.283953002705, -37249.74397031622, -40529.01789411434, -43925.88510493852, -47438.21522723947, -51063.962467430036, -54801.16042734334, -58647.91734354018, -62602.41170902707, -66662.8882392104, -70827.65414843295, -75095.07570734738, -79463.57505476507, -83931.627240562, -88497.75747878394, -93160.53859233385, -97918.58863258733, -102770.56865900403, -107715.1806653219, -112751.16564026, -117877.30175184221, -123092.40264550109, -128395.31584706031, -133784.9212625208, -139260.12976731878, -144819.8818783857, -150463.14650293582, -156188.91975843807, -161996.22385870258, -167884.10606145486, -173851.63767314368, -179897.91310709107, -186022.0489914041, -192223.18332335728, -198500.47466721144, -204853.10139267778, -211280.26095144608, -217781.1691893909, -224355.0596922541, -231001.1831627581, -237718.8068272606, -244507.21387019128, -251365.7028946406, -258293.58740758235, -265290.19532832375, -272354.86851885874, -279486.96233491204, -286685.84519651945, -293950.898177083, -301281.5146099041, -308677.0997112541, -316137.07021912216, -323660.85404680885, -331247.8899506076, -338897.62721085036, -346609.5253256469, -354383.0537166751, -362217.691446437, -370112.9269464108, -378068.257755573, -386083.1902687991]\n", + "[4.29011449e+14 3.82211609e+14 3.38169880e+14 2.97180628e+14\n", + " 2.59439925e+14 2.25047948e+14 1.94016425e+14 1.66279833e+14\n", + " 1.41708921e+14 1.20125205e+14 1.01315275e+14 8.50440252e+13\n", + " 7.10662189e+13 5.91360676e+13] [1.18149947e+14 9.06761412e+13 9.02986391e+13 7.52074786e+13\n", + " 7.31329890e+13 6.19986360e+13 5.35556406e+13 4.35013778e+13\n", + " 4.00531629e+13 3.31156639e+13 2.84050659e+13 2.37383893e+13\n", + " 1.99862375e+13 1.67306737e+13]\n", + "[-4.83174369e+28 -4.24964644e+28 -3.07200761e+28 -2.46360395e+28\n", + " -1.73551372e+28 -1.32925390e+28 -9.86461596e+27 -7.53727455e+27\n", + " -5.16694661e+27 -3.78533015e+27 -2.65794930e+27 -1.87919050e+27\n", + " -1.30458225e+27 -8.99108716e+26]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mdelta=1.34E13\n", + "cdelta = 12\n", + "ell = 0.0\n", + "l=[]\n", + "\n", + "def log_likelihood_monopole_temp(params, ds_mono,ds_mono_err, r_mono):\n", + " sigma_c = 3.77988e+15\n", + " z_cl=0.3\n", + " z_gal=1.0\n", + " mdelta = params # km/s\n", + " ell=0.0\n", + " cdelta=12.0\n", + " ds_data = ds_mono\n", + " \n", + " #model:\n", + " func = np.vectorize(compute_delta_sigma_excess)\n", + " ds_model = func(ell, r_mono, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)#/sigma_c\n", + " \n", + " # Gaussian likelihood:\n", + " #sigma = np.full(len(r_mono), ds_model*0.01) \n", + " sigma = ds_mono*0.01#np.abs(ds_mono_err)\n", + " term1 = -0.5*np.sum(np.log(2*np.pi*(sigma**2)))\n", + " chi2 = ((ds_data - ds_model)**2 / (sigma)**2)\n", + " term2 = -0.5*np.sum(chi2)\n", + "\n", + " return (term2)\n", + "m_arr=np.linspace(10**13,10**15,10**2)\n", + "for mdelta in m_arr:\n", + " params=mdelta\n", + " l.append(log_likelihood_monopole_temp(params, ds_mono,ds_mono_err, r_mono))\n", + " \n", + "plt.figure(figsize=[10,5])\n", + "plt.subplot(121)\n", + "plt.plot(m_arr,l)\n", + "plt.axvline(m_arr[np.argmax(l)], color='red', label='m_fit = '+str(m_arr[np.argmax(l)]))\n", + "plt.xscale('log')\n", + "plt.legend()\n", + "\n", + "plt.subplot(122)\n", + "plt.errorbar(r_mono, ds_mono, yerr=np.abs(ds_mono*0.1))\n", + "\n", + "mdelta=m_arr[np.argmax(l)]\n", + "print(m_arr)\n", + "cdelta = 12\n", + "ell = 0.0\n", + "\n", + "ds_model = compute_delta_sigma_excess(ell, r_mono, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)\n", + "plt.plot(r_mono, ds_model, label='model')\n", + "plt.yscale('log')\n", + "plt.legend()\n", + "\n", + "print(l)\n", + "mdelta=1E15\n", + "ds_model = compute_delta_sigma_excess(ell, r_mono, mdelta, cdelta, z_cl, cosmo=cosmo, hpmd='nfw', \n", + " sample_N=1000, delta_mdef=200)\n", + "print(ds_model, ds_mono)\n", + "print(-0.5*(ds_model - ds_mono)**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "7b3f7ca6-3f6d-4ce3-81cc-ab030eafab3b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Optimization terminated successfully.\n", + " success: True\n", + " status: 0\n", + " fun: -1751919.354392614\n", + " x: [ 1.400e+15]\n", + " nit: 0\n", + " jac: [-2.129e-09]\n", + " hess_inv: [[1]]\n", + " nfev: 2\n", + " njev: 1\n" + ] + } + ], + "source": [ + "from scipy.optimize import minimize\n", + "res = minimize(log_likelihood_monopole_temp, [14.0E14], args=(ds_mono,ds_mono_err, r_mono), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), \n", + " tol=None, callback=None, options=None)\n", + "\n", + "print(res)" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "id": "b43d440d-43fc-4431-9878-cd72a9b5e1ca", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.02464215, 0.00029106])" + ] + }, + "execution_count": 185, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mdelta=[0.0001]\n", + "r=[0.1,1.0]\n", + "func = np.vectorize(clmm.compute_excess_surface_density)\n", + "func(r, mdelta, cdelta, z_cl, cosmo, delta_mdef=200, \n", + " halo_profile_model='nfw', massdef='mean', alpha_ein=None, \n", + " verbose=False, validate_input=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7524267-19fa-49f9-8786-9eb54d7a5cc6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "conda-clmmenv", + "language": "python", + "name": "conda-clmmenv" + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}