diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index dd4cf3fe..811d89df 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -8,7 +8,7 @@ jobs: runs-on: ${{ matrix.os }} defaults: run: - shell: bash -l {0} + shell: bash -l {0} strategy: fail-fast: false matrix: @@ -27,10 +27,11 @@ jobs: - name: install reqs run: | - conda install pip compilers pytest pyccl cython + conda install pip compilers pytest pyccl cython gsl + pip install gsl pip install cobaya - env: + env: MATRIX_OS: ${{ matrix.os }} - name: Install classy @@ -44,6 +45,17 @@ jobs: env: MATRIX_OS: ${{ matrix.os }} + - name: Install classy_sz + run: | + if [[ ${MATRIX_OS} == "macos-latest" ]]; then + . ci_scripts/install_class_sz_osx.sh + else + . ci_scripts/install_class_sz_linux.sh + fi + python -c "import classy_sz; print(classy_sz)" + env: + MATRIX_OS: ${{ matrix.os }} + - name: install run: | pip install . diff --git a/.gitignore b/.gitignore index 894a44cc..fee25a78 100644 --- a/.gitignore +++ b/.gitignore @@ -102,3 +102,42 @@ venv.bak/ # mypy .mypy_cache/ + +# ymap +.DS_Store +soliket/ymap/chains/* +soliket/ymap/run_scripts/* +soliket/ymap/notebooks/* +#soliket/ymap/input_files/ +soliket/ymap/input_files/total-planck-collab-15_benchmark_montepython-3.3_evaluate_trispectrum.input.yaml +soliket/ymap/input_files/total-planck-collab-15_benchmark_montepython-3.3.input.yaml +soliket/ymap/input_files/sz_ps_template_evaluate_trispectrum_and_sz_template.yaml + +#cluster counts +dndzdm_bins_m_center.txt +dndzdy.txt +dndzdy_bins_y_center.txt +dndzdy_bins_z_center.txt +soliket/sz_binned_cluster_counts/chains +soliket/sz_binned_cluster_counts/data + +soliket/binned_clusters/data + +soliket/clusters/data +soliket/binned_clusters/data/so/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/MFMF_WebSkyHalos_A10tSZ_3freq_tiles_mass.fits +soliket/binned_clusters/data/so/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/tileAreas.txt +soliket/cosmopower/chains +soliket/binned_clusters/chains/test.updated.yaml +soliket/binned_clusters/chains/test_camb.updated.yaml + +soliket/binned_clusters/chains/* +soliket/clusters/chains/* +soliket/clusters/notebooks/* + +soliket/cosmopower/data +*.yaml +soliket/cosmopower/covmats/desy1_joint_cosmopower_301122.covmat +soliket/cosmopower/covmats/lensing_H0wide_harlap_emunotauzpk_omcwide.covmat +soliket/cosmopower/covmats/desy1_joint_plancklensing2018_lenspriors_BAO_cosmopower.covmat + +yg* diff --git a/README.md b/README.md index 942d1ab6..d72f2caa 100644 --- a/README.md +++ b/README.md @@ -12,96 +12,6 @@ git clone https://github.com/simonsobs/soliket cd soliket pip install -e . ``` -You will also need to either run -``` -pip install camb -``` -or, for a fuller cobaya install: -``` -cobaya-install cosmo -p /your/path/to/cobaya/packages -``` -To run tests, you will also need the original LAT_MFlike package: -``` -pip install git+https://github.com/simonsobs/lat_mflike -``` -Then, you can run tests with -``` -pip install pytest -pytest -v . -``` - -Please raise an issue if you have trouble installing or any of the tests fail. - -## Contains - -This repo currently implements the following specific likelihoods: - -* `MFLike`: the SO LAT multi-frequency TT-TE-EE power spectrum likelihood. (Adapted from, and tested against, the original implementation [here](https://github.com/simonsobs/lat_mflike)). -* `ClusterLikelihood`: An SZ-cluster count likelihood based on the original ACT SZ clusters likelihood. -* `LensingLikelihood`: Lensing power-spectrum likelihood, adapted from [here](https://github.com/simonsobs/so-lenspipe/blob/6abdc185764894cefa76fd4666243669d7e8a4b0/bin/SOlikelihood/cobayalike.py#L80). -* `LensingLiteLikelihood`: A no-frills, simple $\chi^2$ lensing power spectrum. - -## Extending - -Please see [these guidelines](guidelines.md) for instructions on bringing a new likelihood into **soliket**. - -## Usage - -These likelihoods are designed for direct use with **cobaya**. This means that -they may be specified directly when creating a **cobaya** `Model`. E.g., if -you wanted to compute the likelihood of the simulated lensing data, you could do the following: - -```python - -from cobaya.yaml import yaml_load -from cobaya.model import get_model - -info_yaml = """ -debug: True - -likelihood: - soliket.LensingLiteLikelihood: - sim_number: 1 - stop_at_error: True - -params: - # Sampled - logA: - prior: - min: 2.6 - max: 3.5 - proposal: 0.0036 - drop: True - latex: \log(10^{10} A_\mathrm{s}) - As: - value: "lambda logA: 1e-10*np.exp(logA)" - latex: A_\mathrm{s} - ns: - prior: - min: 0.9 - max: 1.1 - proposal: 0.0033 - latex: n_\mathrm{s} - - -theory: - camb: - stop_at_error: False - extra_args: - lens_potential_accuracy: 1 - -""" - -info = yaml_load(info_yaml) -model = get_model(info) -``` -The likelihood could then be either directly computed as -```python -model.loglike(dict(logA=3.0, ns=0.98)) -``` -and used outside of **cobaya** (e.g., directly passed to **emcee** or some other -sampler or optimizer), or this same YAML setup (with an additional 'sampler' block specified) -could be used as input to `cobaya-run` to have **cobaya** manage the sampling. -For more information on how to use **cobaya**, check out its [documentation](http://cobaya.readthedocs.io). +This is a minimal soliket version to run with cosmopower emulators. diff --git a/ci_scripts/install_class_sz_linux.sh b/ci_scripts/install_class_sz_linux.sh new file mode 100644 index 00000000..72a48a9a --- /dev/null +++ b/ci_scripts/install_class_sz_linux.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +sudo apt-get install libgsl-dev +cd /home/runner/work/SOLikeT/SOLikeT/ +wget ftp://ftp.gnu.org/gnu/gsl/gsl-2.6.tar.gz +tar -zxvf gsl-2.6.tar.gz +cd gsl-2.6 +./configure --prefix=/home/runner/work/SOLikeT/SOLikeT/gsl-2.6 +make +make install +LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/runner/work/SOLikeT/SOLikeT/gsl-2.6/lib/ +export LD_LIBRARY_PATH +cd .. +ls /home/runner/work/SOLikeT/SOLikeT/gsl-2.6/lib +git clone https://github.com/borisbolliet/class_sz.git +cd class_sz +make -j4 + +# at this point the make file leaves you in the python dir +cd .. diff --git a/ci_scripts/install_class_sz_osx.sh b/ci_scripts/install_class_sz_osx.sh new file mode 100644 index 00000000..88a216b0 --- /dev/null +++ b/ci_scripts/install_class_sz_osx.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +export CONDA_BUILD_SYSROOT=/ + +rm -rf class_sz +git clone --depth=1000 https://github.com/borisbolliet/class_sz.git +cd class_sz + +sed -i.bak -e 's/^CC/#CC/g' Makefile +sed -i.bak -e 's/^OPTFLAG =/OPTFLAG = ${CFLAGS} ${LDFLAGS}/g' Makefile +sed -i.bak -e 's/^#CCFLAG +=/CCFLAG +=/g' Makefile +sed -i.bak -e 's/^#CCFLAG =/CCFLAG =/g' Makefile + +make -j4 + +# at this point the make file leaves you in the python dir +cd .. diff --git a/setup.py b/setup.py index 06a934c4..7f47bfa8 100644 --- a/setup.py +++ b/setup.py @@ -8,15 +8,17 @@ version="0.0", description="SO Likelihoods & Theories", zip_safe=False, - packages=["soliket", "soliket.tests", "soliket.clusters"], + # packages=["soliket", "soliket.tests", "soliket.clusters", "soliket.ymap"], + packages=["soliket"],#, "soliket.tests","soliket.clusters","soliket.ymap"], package_data={ "soliket": [ "*.yaml", "*.bibtex", # "data/simulated*/*.txt", - "clusters/data/*", - "clusters/data/selFn_equD56/*", - "lensing/data/*.txt", + # "clusters/data/*", + # "clusters/data/selFn_equD56/*", + # "ymap/data/*.txt" + ] }, install_requires=[ @@ -24,9 +26,9 @@ "scikit-learn", "cobaya", "sacc", - "pyccl", - "fgspectra @ git+https://github.com/simonsobs/fgspectra@master#egg=fgspectra", - "mflike @ git+https://github.com/simonsobs/lat_mflike" + # "pyccl", + # "fgspectra @ git+https://github.com/simonsobs/fgspectra@master#egg=fgspectra", + # "mflike @ git+https://github.com/simonsobs/LAT_MFLike" ], test_suite="soliket.tests", ) diff --git a/soliket/__init__.py b/soliket/__init__.py index d74d421b..ffc80987 100644 --- a/soliket/__init__.py +++ b/soliket/__init__.py @@ -1,12 +1,12 @@ from .lensing import LensingLiteLikelihood, LensingLikelihood from .gaussian import GaussianLikelihood, MultiGaussianLikelihood -from .ps import PSLikelihood, BinnedPSLikelihood -from .clusters import ClusterLikelihood -from .mflike import MFLike -try: - import pyccl as ccl - from .ccl import CCL - from .cross_correlation import CrossCorrelationLikelihood -except ImportError: - print('Skipping CCL module as pyCCL is not installed') - pass \ No newline at end of file +# from .ps import PSLikelihood, BinnedPSLikelihood +# from .clusters import ClusterLikelihood +# from .mflike import MFLike +# from .ccl import CCL +# from .ymap.ymap_ps import SZLikelihood, SZForegroundTheory +## from .sz_binned_cluster_counts.binned_cc import binned_cc_likelihood +# from .classy_cibxkappa import classy_cibxkappa +from .cibxlensing import CIBxKAPPA_Likelihood +# from .yg.galaxy_x_galaxy import GXG_Likelihood +# from .yg.y_x_galaxy import YXG_Likelihood diff --git a/soliket/binned_clusters/notebooks/Nz_szcountsf90_vs_class_sz_vs_nemo_comparison.ipynb b/soliket/binned_clusters/notebooks/Nz_szcountsf90_vs_class_sz_vs_nemo_comparison.ipynb new file mode 100644 index 00000000..b01b630f --- /dev/null +++ b/soliket/binned_clusters/notebooks/Nz_szcountsf90_vs_class_sz_vs_nemo_comparison.ipynb @@ -0,0 +1,1251 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "%pylab inline\n", + "import matplotlib.pyplot as plt\n", + "from soliket import BinnedClusterLikelihood\n", + "from cobaya.model import get_model\n", + "import camb\n", + "font = {'size' : 16, 'family':'STIXGeneral'}\n", + "axislabelfontsize='large'\n", + "matplotlib.rc('font', **font)\n", + "matplotlib.mathtext.rcParams['legend.fontsize']='medium'\n", + "plt.rcParams[\"figure.figsize\"] = [8.0,6.0]\n", + "\n", + "data_path = \"/Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/binned_clusters/data/so/\"\n", + "params = {\n", + " 'cosmomc_theta': 0.0104135,\n", + " 'ns': 0.965,\n", + " 'ombh2': 0.0226576, \n", + " 'omch2': 0.1206864, \n", + " 'As': 2.022662e-9,\n", + " 'tenToA0': 4.35e-5,\n", + " 'B0': 0.08,\n", + " 'scatter_sz': 0.,\n", + " 'bias_sz': 1.,\n", + " 'tau': 0.055,\n", + " 'mnu': 0.0,\n", + " 'nnu': 3.046,\n", + " 'omnuh2': 5.691895645933333e-06,\n", + " 'w': -1\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "snrcut = 5\n", + "from classy_sz import Class\n", + "\n", + "cluster_settings = {\n", + "\n", + " '100*theta_s':1.04135,\n", + " 'omega_b':0.0226576,\n", + " 'omega_cdm':0.1206864,\n", + " 'A_s':2.022662e-9,\n", + " 'tau_reio':0.055,\n", + " 'n_s': 0.96605,\n", + "\n", + "'output' : 'sz_cluster_counts',\n", + "'mass function' : 'T08',\n", + "'concentration parameter': 'B13',\n", + "\n", + "'has_selection_function' : 1,\n", + "'experiment' : 1, # 1: simons observatory, 0: planck\n", + "'y_m_relation' : 1, # 1: Hasselfield et al, 0: Planck\n", + " \n", + "'SO_thetas_file':'/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz/sz_auxiliary_files/so_3freqs_191121_thetas.txt',\n", + "'SO_skyfracs_file':'/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz/sz_auxiliary_files/so_3freqs_191121_skyfracs.txt',\n", + "'SO_ylims_file':'/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz/sz_auxiliary_files/so_3freqs_191121_ylims.txt',\n", + "# X ray mass bias (if applicable - default 1)\n", + "# 'B' : 1.,\n", + " \n", + "'signal-to-noise cut-off for survey cluster completeness' : 5.,\n", + "\n", + "# scaling law parameter\n", + "\n", + "'B_ym': 0.08,\n", + "'A_ym': 4.35e-5,\n", + "'C_ym' : 0.,\n", + "'sigmaM_ym' : 0.0,\n", + "\n", + "'M_min' : 1e13,\n", + "'M_max' : 5e15,\n", + "\n", + "\n", + "'YHe': 'BBN',\n", + "\n", + "# 1 massive neutrino (planck 2018 baseline)\n", + "'N_ur': 2.0328,\n", + "'N_ncdm': 1,\n", + "'m_ncdm': 0.0,\n", + "'T_ncdm': 0.71611,\n", + "\n", + "\n", + "# #3 massive neutrinos\n", + "# N_ur : 0.00641\n", + "# N_ncdm : 1\n", + "# deg_ncdm : 3\n", + "# m_ncdm : 0.02\n", + "# T_ncdm : 0.71611\n", + "\n", + "\n", + "\n", + "\n", + "# Prescription for HMF to be used with massive neutrinos\n", + "# HMF_prescription_NCDM: 'CDM'\n", + "\n", + "\n", + "'bin_z_min_cluster_counts' : 0.,\n", + "'bin_z_max_cluster_counts' : 2.,\n", + "'bin_dz_cluster_counts' : 0.1,\n", + " \n", + "'bin_dlog10_snr': 0.25,\n", + "'log10_snr_min':0.6,\n", + "'log10_snr_max':2.0,\n", + "\n", + "'dlny' : 0.01,\n", + "'lnymin' : -11.,\n", + "'lnymax' : 10.,\n", + "\n", + "'dlnM_cluster_count_completeness_grid' : 0.01,\n", + "\n", + "\n", + "'cluster_count_completeness_grid_z_cutoff_low' : 0.5,\n", + "'cluster_count_completeness_grid_z_cutoff_mid' : 1.5,\n", + "\n", + "'dz_cluster_count_completeness_grid_low_z' : 5e-3,\n", + "'dz_cluster_count_completeness_grid_mid_z' : 1e-1,\n", + "'dz_cluster_count_completeness_grid_high_z' : 1e-1,\n", + "\n", + "'mass_epsrel_cluster_counts' : 1e-3,\n", + "'mass_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "'redshift_epsrel_cluster_counts' : 1e-3,\n", + "'redshift_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "# # tabulation of mass function:\n", + "'n_z_dndlnM' : 150,\n", + "'n_m_dndlnM' : 150,\n", + "\n", + "# # computation of mass function\n", + "# # (grid in mass and redshifts for sigma and dsigma)\n", + "'ndim_masses' : 250,\n", + "'ndim_redshifts' : 250,\n", + "\n", + "# pk setup for computation of sigma and dsigma\n", + "'k_per_decade_class_sz' : 20.,\n", + "'k_min_for_pk_class_sz' : 1e-3,\n", + "'k_max_for_pk_class_sz' : 1e1,\n", + "\n", + "'P_k_max_h/Mpc' : 1e0,\n", + "'non linear': 'halofit'\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# try:\n", + "# cluster_settings.pop('non linear')\n", + "# except KeyError:\n", + "# print('fine')\n", + "# cluster_settings['output'] = 'sz_cluster_counts'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n" + ] + } + ], + "source": [ + "M = Class()\n", + "M.set(cluster_settings)\n", + "M.set({\n", + "'output':'dndlnM,m200m_to_m500c',\n", + "'mass function' : 'T08',\n", + "'mass function': 'm200m_to_m500c'\n", + "})\n", + "M.compute()\n", + "print('h : %f'%M.h())\n", + "print('sigma8 : %f'%M.sigma8())\n", + "print('Omega_m : %f'%M.Omega_m())\n", + "print('n_s : %f'%M.n_s())\n", + "\n", + "# szcountsf90:\n", + "#[evaluate] sigma8 = 0.810188\n", + "#[evaluate] omegam = 0.309952\n", + "#[evaluate] H0 = 68.0053" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "m500c = np.vectorize(M.get_m200m_to_m500c_at_z_and_M)\n", + "m = np.geomspace(1e13,1e15,100)\n", + "plt.plot(m,m500c(1.,m),label='z=%.2f'%0.)\n", + "m200me,m500ce = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/M200m_M500c_z1.txt',unpack=True)\n", + "plt.plot(m200me,m500ce,label='szcountsf90')\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.grid()\n", + "plt.xlabel('M200m [Msun/h]')\n", + "plt.ylabel(r'M500c [Msun/h]')\n", + "plt.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n" + ] + } + ], + "source": [ + "M = Class()\n", + "M.set(cluster_settings)\n", + "M.set({\n", + "'output':'dndlnM',\n", + "'mass function': 'M500'\n", + "})\n", + "M.compute()\n", + "print('h : %f'%M.h())\n", + "print('sigma8 : %f'%M.sigma8())\n", + "print('Omega_m : %f'%M.Omega_m())\n", + "print('n_s : %f'%M.n_s())\n", + "\n", + "# szcountsf90:\n", + "#[evaluate] sigma8 = 0.810188\n", + "#[evaluate] omegam = 0.309952\n", + "#[evaluate] H0 = 68.0053" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'T08@M500c')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "z = np.linspace(0.,4,5)\n", + "m = np.geomspace(1e13,1e15)\n", + "dn = np.vectorize(M.get_dndlnM_at_z_and_M) # mass in Msun/h and dndlnM in [Mpc/h]^-3\n", + "# for zz in z:\n", + "# plt.plot(m,dn(zz,m),label='z=%.2f'%zz)\n", + "plt.plot(m,dn(0.,m),label='class_sz z=0')\n", + "me,dne = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/m_dndlnmdz_z0.txt',unpack=True)\n", + "plt.plot(exp(me),np.abs(dne),label='szcountsf90 z=0')\n", + "\n", + "plt.plot(m,dn(1.,m),label='class_sz z=1',ls='--')\n", + "me,dne = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/m_dndlnmdz_z1.txt',unpack=True)\n", + "plt.plot(exp(me),np.abs(dne),label='szcountsf90 z=1',ls='--')\n", + "plt.loglog()\n", + "plt.grid()\n", + "plt.xlabel('M [Msun/h]')\n", + "plt.ylabel(r'dn/dlnm [Mpc/h]$^{-3}$')\n", + "plt.legend()\n", + "plt.ylim(1e-11,1e-2)\n", + "plt.xlim(1e13,1e15)\n", + "plt.title('T08@M500c')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n" + ] + } + ], + "source": [ + "M = Class()\n", + "M.set(cluster_settings)\n", + "M.set({\n", + "'mass function': 'T08'\n", + "})\n", + "M.compute()\n", + "print('h : %f'%M.h())\n", + "print('sigma8 : %f'%M.sigma8())\n", + "print('Omega_m : %f'%M.Omega_m())\n", + "print('n_s : %f'%M.n_s())" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'T08@M200m')" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "z = np.linspace(0.,4,5)\n", + "m = np.geomspace(1e13,1e15)\n", + "dn = np.vectorize(M.get_dndlnM_at_z_and_M) # mass in Msun/h and dndlnM in [Mpc/h]^-3\n", + "# for zz in z:\n", + "# plt.plot(m,dn(zz,m),label='z=%.2f'%zz)\n", + "plt.plot(m,dn(1.,m),label='class_sz z=1',ls='--')\n", + "me,dne = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/m_dndlnm_M200m_z1_bis.txt',unpack=True)\n", + "plt.plot(me,np.abs(dne),label='szcountsf90 z=1',ls='--')\n", + "\n", + "plt.loglog()\n", + "plt.grid()\n", + "plt.xlabel('M [Msun/h]')\n", + "plt.ylabel(r'dn/dlnm [Mpc/h]$^{-3}$')\n", + "plt.legend()\n", + "plt.ylim(1e-9,1e-3)\n", + "plt.xlim(1e13,1e15)\n", + "plt.title('T08@M200m')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n" + ] + } + ], + "source": [ + "M = Class()\n", + "M.set(cluster_settings)\n", + "M.set({\n", + "\n", + " \n", + "})\n", + "M.compute()\n", + "print('h : %f'%M.h())\n", + "print('sigma8 : %f'%M.sigma8())\n", + "print('Omega_m : %f'%M.Omega_m())\n", + "print('n_s : %f'%M.n_s())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "k_arr = np.geomspace(1e-4,1e1,1000)\n", + "z_arr = np.asarray([0.,1.,2.])\n", + "# the total matter pk (in Mpc**3) for a given k (in 1/Mpc) and z\n", + "matter_pk = np.vectorize(M.pk)\n", + "plt.plot(k_arr,matter_pk(k_arr,1.),label='class_sz')\n", + "ke,pke = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/k_pks_z1.txt',unpack=True)\n", + "plt.plot(ke,pke*M.h()**-3,label='szcountsf90')\n", + "plt.loglog()\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAFtCAYAAACTJsmaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABCWUlEQVR4nO3dd3RVVeL28e++6RAIJIQiHaSqqAiOg5UiUgzSBASkCiLSFHsZZn6jDghKkQ4KAhaQ3ouAVEGDICqI9BIg9ECA9P3+QeQlkEASkpyb5PmsdZeL0+4T1pb75Nxz9jHWWkRERET+5nI6gIiIiLgXlQMRERFJQuVAREREklA5EBERkSRUDkRERCQJlQMRERFJwtPpAO6iUKFCtkyZMk7HEBERyTJbtmw5Za0Nvn65ykGiMmXKEBoa6nQMERGRLGOMOZjccn2tICIiIkmoHIiIiEgSKgciIiKShMqBiIiIJKFyICIiIkmoHIiIiEgSupVRRCQHiIqK4uTJk0RFRREXF+d0HHGQp6cnvr6+BAcH4+vrm75jZHAmERHJYhEREYSHhxMcHEzRokXx9PTEGON0LHGAtZa4uDgiIyM5dOgQRYoUISAgIM3HUTkQEcnmTp06RYkSJciTJ4/TUcRhxhi8vLwoWLAgPj4+HD9+PF3lQNcciIhkczExMfj5+TkdQ9yMn58f0dHR6dpX5UBEJAfQ1whyvdsZE7m+HBhjQowx4yMiIjL0uNbaDD2eiIhIVsn15cBau8Ba2z0938mk5MCpi9QfupYFvx4lIUElQUREspdcXw4yQ8TlWDxchp0zBjB6yDus3nFEZxJERDJATEwMP/zwg9MxcjyVg0xwb8kCLO79MJ2KHaLXpdGU/bYOw4b9j5/2nXI6mohItrVt2zYaNmxI7dq1nY6S46kcZBKXhweFX15KXJtvCcifn1ciBpFncl0+GT2KHWEZe32DiEhucN9999GuXTunY+QKKgeZyRg8Kzek4KubiWkyllJ5Yuh/4h0ixjbg0y+mcfD0RacTiohkKy6XPraygiZBygouD7yrP4d3tRZc3vQ51dYM4p+HXmb58EnMq9qPNo2fpHC+9E1xKSKSkv8s+IMdR887mqHqHfkZEHJXmvc7fPgwo0ePpnDhwmzYsIHy5cvz0Ucf3bDduXPnePPNN6levTphYWEcO3aMsWPH4uHhQUREBP/617+oVasWGzdu5NChQ8yZMweA999/n4oVKxIeHs6wYcM4cuRIqnJ9/fXXhIeHExAQwMCBA5kxYwb33XcfzzzzDNWqVSMgIIDz58/zwQcf0Lx5c2bOnJnmn90dqBxkJU9v/B55CWo+T+SaETy26TPq7nyeuTse51SNV3mufi3y+3o5nVJExFHnzp2jQYMGrFy5kqJFi9KoUSOqVq1KixYtbth2zJgxhIaGMm7cOACKFClCkyZNCAkJYcqUKcTGxtK6dWtat27N6NGjAfjtt9+YNWsWO3bsAEjTzJK9e/dm586dFC5cmMqVK19d3r17dxo3bgxA165dKVSo0NX3y5astXpZywMPPGCzXOQpe27O6zbm30E26l+BdsqA5+yXK0Lt5Zi4rM8iItnWjh07nI6QoYYOHWpDQkKSLDt9+rS11tpJkybZKx9dV5w8edLu2LHDxsXF2RUrVthChQrZyZMnW2utXbx4sfX09LQDBw60UVFRNi7uyr+t4eHh1t/f37Zv394eP3786vLUePDBB23NmjXt1q1brbX2hn0XLlxoATtnzpy0/tiZ4lZjAwi1yXwm6ssbJ+UNIqDpx3j13cqlSs1pxxKarWvMlIE9mf3jLuLiE5xOKCKS5f78888bZvcLDAxMdtvAwECWL1/O//73PypVqkTevHmv3jresGFDRo8ezYcffkiVKlVYvXo1AIULF2bZsmVs3LiRChUqMHLkyFRnmzt3Lv7+/jzwwAO8+OKLREVFXV139uxZunXrRseOHWnatGkaf2r3onLgDgqUpGDbCbh6/khMqUfpHv8tjy6tx9jBb/L9b4c1R4KI5CrFihVjw4YNXLhw4eoyay1//fXXDdv279+fFStW8N5771GyZMkk6/bv30+3bt3Yu3cvTzzxBI0aNeLw4cMcO3aM6tWrs2PHDgYMGMDrr7/Ot99+m6psUVFRrFq1irlz5zJ//nz69+9/dV2vXr3w8vJixIgRAERHRxMfH5+evwLHqRy4k8KVCer6HbbrClyFK9MrajyVvqvNZ8M+ZMuB006nExHJEs899xwXLlygadOm/PTTT+zatYt33nmHoKAgEhKunFH9+5em5cuXXz0V/tdff3Hy5EnOnDlDbGwsX3/9NYcPHyY4OJjPP/+cPHnycOnSJXbt2sWcOXPw8fGhf//+NGjQgNROoT9w4EAAQkJCeP3116/uN3v2bL755hsmT55M/vz5Afjuu+/S/eAjp+mCRDdkSj5IUM/lxO3+nrwL36NPxGB2fDGDYcV78nSz9txZ2N/piCIimaZixYrMnz+fN954g9q1a/Pggw8ycuRIjh07dvU3/HHjxtGuXTt69uzJ22+/zX333UePHj1o3bo1w4cP59577yU2NpbGjRvTq1cvTp8+zb///W8qVarEsWPH6NWrF2FhYeTLl49SpUrRuXPnVGWbOHEi/v7+VKtWjZ07dzJw4EDOnj1Ljx49qFixIlu2bCE0NJQTJ06wcOFC2rdvn5l/VZnG6JT1FTVq1LChoaFOx7hRQgJR274jevl/CIgKY13CPWyt9CptQhpROL9ufxQR2LlzJ1WqVHE6hrihW40NY8wWa22N65frzIG7c7nwrd4a32pNidwwjgfWDubhv7qwYMgjhNd4jefqP0w+3f4oInLbnn32WY4dO5bi+pkzZ1K0aNEsTOQclYPswtMH/8f7wIMdiFjxMQ23TsBuacm3Wxvh/cRrtHj4brw9dQmJiEh6fffdd05HcBv6NMlu/AoQ0OQjvPtt5WLFpjxv59NwVQMmfvwKS7cd0J0NIiJy21QOsquAEgS2m4jpsY74Ox6gZ8xk7p5Tl2FDPyR0v57+KCIi6adykM2ZovcQ9OIC4tvPJW9AMK+cH4zvpLoMHTeevScjnY4nIiLZkMpBDuFxZ20K9ttIdJOxlPKL5pVjr3Pks0aM/GYupyKz5322IiLiDJWDnMTlwqf6c+R/bRuRT/yHml776PlnJ9YPfpbJi9dxOSZ7ztQlIiJZK9eXA2NMiDFmfGpnx8oWvHzxf6IfeV77jYjqPWjs2kibzc34bmBX5vy4g4QEXbQoIiIpy/XlwFq7wFrbPSAgwOkoGc+vIAWfGYhX31+ILP80HRLm8NjS+owe8g4b/zrudDoREXFTub4c5AoFSlGow2QSXvgBW6gyvS6NJnhaHYaNHsme8Au33l9ERHIVlYNcxFXifgr1WkFMy2kE5/Wg34l3OTaqISO/mctpXbQoIiKJVA5yG2PwvjuEAv23cLH2BzzgdYCX/uzE6sFtmLxsM1GxumhRRCS30/TJuZWnN3kf7w0123Fu2Uc0/XUS0Rs3MOXnFpRo+BoNq5fDGON0ShGRHGnt2rVs3LiR3377jT/++INly5Yxb948Dh8+jJ+fH7/++itvvfUW999//9V9li9fzsKFC6lWrRobN26kTZs21K9fP1Py6amMidz2qYxZ5fReTs19m0KHl3HUBjIjf2cea/ky1UsHOZ1MRG5BT2V0Dx9//DFvvPHGLbe7cOECpUuX5qeffqJs2bIMGzaM4OBgJk+ezKpVqwDYtm0btWvX5rfffqNEiRKsX7+e5s2bs2fPHvLnz8/Zs2epXLkyq1at4q677krxvdL7VEaVg0S5vhwkit+/noi5rxMYsYPtCWVZVbofLZu3okTBPE5HE5EUpPgBsOQtOP5b1ge6VtF7oOFAZzNkgYEDBzJ27FgOHDhwy21//PFHatWqxf79+ylTpgwANWrUoEGDBnzwwQdXt7v77rt56qmn+OSTT6hXrx5BQUFMnz796vr27dsDMG3atBTfK73lQNccSBIeZR8hsO8GokLGUNb3Iv0O92XH0CZMmLuCyOg4p+OJSC4ybNgwJkyYwOjRoylatCjnzp3j4Ycf5r///S9DhgyhT58+GGN47bXXAEhISGDo0KEMGjSI9957j3r16rF3714A4uPjGTZsGIMHD2bw4ME0aNCAGTNmAHDo0CFq16599YP64MGDtGvX7upXq2FhYfTv358qVarw/fffU6dOHQIDA/n0008B2LdvH8uXLyciIoIPPviA9evXA/D+++8zdepUhgwZQokSJQBYsWIFEydOBGDkyJF88MEHXL58mT///JM8eZL+ElauXDnWrl1LbGws69ev5957702y/p577mHRokUZ/dd+hbVWL2t54IEHrFwn+qI9t+wjG/Xvwjb6XwXttP+0tbM3/Gbj4hOcTiYi19ixY4fTETJcRESEDQgIsLGxsdZaa7/66it79uxZu3DhQmuttQkJCbZu3bq2cuXK9tKlS9Zaa3v16mVHjRp19RgPP/ywfemll6y11r7//vv2hRdeuLruzz//tJ6ennbmzJnWWmsHDBhgS5cufXX9pEmT7JWPyCtGjx5tXS6XXbp0qbXW2iFDhlgfHx8bFRWV7P7bt2+3VapUufrna3OtXr3aAnb//v1Xl5UtW9a2a9cuyd9Bhw4dbIUKFeyxY8csYMeMGZNk/fjx4y1gz507l+Lf463GBhBqk/lM1JkDSZl3HgLqv43Pq9s5X+lZ2iQspvay+kwY/AabdmsSJRHJPH5+fvj7+xMSEsK+ffto06YNAQEBNG7cGIDRo0ezZs0apk6dip+fH6dOnWLMmDG0adPm6jGWL1/O0KFDsdYydOhQateufXVdpUqVaNSoEZ988kmq8yQkJPDUU08BcP/99xMdHU14eHiy2xcpUoTDhw/z/PPPEx4ezosvvnjT43fv3p1Zs2bx888/A3Dy5ElCQ0MpXLgwPj4+AHh5eSXZJyEhAbjyS35GUzmQW8tXhEJtx+HqsZbYwtXocXk8QVPrMGzsGA6cuuh0OhHJgby8vFixYgXHjx+nSpUqvP/++1c/DPfu3cubb77Ju+++S40aV74u37NnD/Hx8UnussqTJw8+Pj6cPn2ayMhILlxIOulbxYoVOXToULryuVxXPj7/znS9woULs2zZMjZu3EiFChUYOXLkTY/35ptv8vHHH/Pmm2/SvXt3vv76ayIiInjkkUcoWLAg/v7+nD17Nsk+p0+fJn/+/BQoUCBdP8PNqBxIqpmi9xDccwkxz35FcF4X/Y6/xf4RjRk3exkXomKdjiciOUhkZCTBwcFs2bKF8ePH89lnnzF48GASEhLo1KkTVapU4b333gPg0qVLFCtWDIAlS5YkOc6uXbsoVKgQBQoU4I8//kiy7vLly1SqVCnZ97/d38aPHTtG9erV2bFjBwMGDOD111/n22+/TXF7Ywy9e/dm1apVjB8/ntKlS3Py5Em6d+8OQMOGDdmxY0eSfbZv306jRo1uK2dKVA4kbYzB+66nKdB/CxceG8A/PXfR5dfnmDeoM3M2/qGHOolIhjh16hQTJkzA5XLRsWNHOnXqREREBMOGDSM0NJQpU6bg6Xllqp5p06ZRunRpnnjiCfr06cM333zD/v37mTJlCjt37gTgrbfe4ssvv+T06dMAxMXFsWzZsqsFIzg4mPDwcI4cOUJUVBTr1q0DuHq24fozBPHxVyaM+7tE+Pv7c+bMGeLi4jh69Ci7du1izpw5+Pj40L9/fxo0aMDfD/j7e9+//3u9gwcP0r17d4YPH065cuUA6NOnD4sWLbqaJyIigu+//54+ffrc7l918pK7ECE3vnRBYjpdCLenvupu4wcE2JP/KmFHfPyO/WnvCadTieQqOfGCxP3791s/Pz87YMAA+/nnn9tu3brZ0NBQ6+vrax966CE7ePBgO2jQINu7d2/7+OOPW2utPX78uG3RooUNCAiwZcqUsePHj796vISEBDt8+HD7zDPP2IEDB9pevXrZWbNmXV1/7tw5+/jjj9uCBQvaVq1a2SlTptg6derYzz//3B47dsw2bdrUAvbzzz+3586dsx07drSA/c9//mOjo6Pt7t27bYkSJezDDz9sly9fblevXm0DAwPt4MGD7dixY+3LL79so6Oj7c6dO22nTp0sYF977TX7xx9/JPm558+fb++7776rF0pea86cOfaFF16wo0ePtl26dLGzZ8++5d9jei9I1DwHiTTPwe2xR7dxetarFDq9hR0JpVleqh/PtnyO4gX8nI4mkuNpEqTs7+9ZEosXL05ISMgNtzWmlyZBuk0qBxnAWqK3zyZ68Tvkjz7O0oR/cKTmO7R76lH8vD2cTieSY6kcSEo0CZI4zxh87m1B/te2cf6fb1Lb41eeD23JjEHdWLxld6bcbiMiIhlP5UAynpcf+Z96B59XtnKhfGM6xs/igfn1GDXsA34/cvbW+4uIiKNUDiTz5L+DQh2+JL7LCjwKlKRXxBDixtdlzLRvOHMxxul0IiKSApUDyXQepR6kUN+1XGo8mvI+Eby0pwcbBjdn+srNxMUnP4GIiKSNvraT693OmFA5kKzhcpGnZjvyvfYrZ6r34Sk20XhtEyYPfoUfdx11Op1Itubt7c3ly5edjiFu5vLly1enXk4rlQPJWj7+BDb5L159fuZS8Vq8EDWZwl/VYcS4sRw+c8npdCLZUqFChThy5AhnzpwhNjZWZxFyMWstsbGxnDlzhiNHjhAUFJSu4+T6WxmNMSFAyJ133tlt9+7dTsfJdWJ2LuXi/NcpePkQKxJqcqjmu7R96jHd+iiSRlFRUZw8eZKoqCji4vR49dzM09MTX19fgoOD8fX1vem2mufgFjTPgYPiojm/ejg+Gz/BJsTztWczSjZ5h3rVyiR5iIqIiGQszXMg7svTh/xPvoHPK1uJLNuALvEzqDK7Hp+N+pS9Jy7cen8REclQKgfiPvLfQaFO04jrsJA8+QrS59T/cWxkQ8bPXsrFaJ0mFRHJKioH4nY8yz1K4CubuFD7Ix7w3E/nX9syd1BnFof+pQutRESygMqBuCcPT/I9/jJ+r24jomJL2iXMp8aCJxk1/EP+On7e6XQiIjmayoG4N/9gCrUbT3zXlbgKlKDXucGcH12PCTPmcCEq1ul0IiI5ksqBZAseJWtQqO86Ip8aSmWv43T5ozPLP27Los1/6KsGEZEMpnIg2YfLhf8/u+D/2q+cuasjTRO+55+L6zNu2L/563iE0+lERHIMlQPJfvwKEtxqOObFtcQFVqBHxDAiR9dl4ndzidRdDSIit03lQLItV7F7KNx7FZENR1DR6wSdf+/EwkEdWKK7GkREbovKgWRvLhf+/+iIf/9tnKnSllYJi3lgwZOM+mwge8I1gZKISHqoHEjOkCeQ4DajsV1X4hFwB73ODOTEqKeYMGcpl2L0VYOISFqoHEiO4lHyAYL6rSey3iDu9zxIx21tmTmoOyt/3ed0NBGRbEPlQHIelwf+j/TA79WtnL/zGTrEz6LS7CcZOXoYh09fdDqdiIjbUzmQnMu/MIWen3TlWQ3+AfQ6MYA9I55m6pI1xMQlOJ1ORMRtqRxIjudZ7lECX91MxKP/4p+uHTy7qQVfDe7F5t1HnY4mIuKWVA4kd/DwIqBuf3z7/cL5UnXpHP0VwVNrM/aLCZyKjHY6nYiIW1E5kNwloDiFu04nus13FMzjSY9Dr7FlyDPMXfszCQmaG0FEBHJJOTDGBBpjyjudQ9yHT+X6FOy/hdMPvkZtQqm7MoTPP32bnWFnnY4mIuK4HF8OjDGVgJVAbaeziJvx8iWo0ft49d7MpeD76RY5hphxdZn43TzNjSAiuVqOLwfW2l3Ar07nEPdlgspT5OXFRD49jnJeZ+j0eyfmDurCD9s1N4KI5E5pKgfGGF9jTGdjzDvGmBbGGI+MDGOMKZaRxxNJNWPwr9GGfK9t5Uyl1rSNn8eds55k1LiRHI+IcjqdiEiWSnU5MMY8CGwH/IH/WWtnWWvjMyKEMaaWMWY+sCiZdf7GmGHGmF7GmLeMMaOMMXkz4n1FbuBXkMJtxxLbcQl+eQN4+di7bP+0CTNWbiJeFyyKSC6RqnJgjLkfWM2VUvCZzcBH3hlj8gF7Ac8U8swATltrR1prBwKngPGJ+9Y0xmxK7pVR+SR38ipbi6BXN3H2n2/zhGsrDdc2ZeInb/H74TNORxMRyXS3LAfGGANMArZaayfdZLsixpgtyd0VYIzJY4xZYoypd/06a+0Fa204cCKZ/R4BGgIzr1k8FWhjjKlkrf3ZWvtQcq9b/Vwit+TpTcGn3sKr12YuF6nOixfHEj+hLuOmzyUyWhcsikjOlZozB/8A7gUuGmPGGGO2GmM2GmNqXLtR4gf8FGCtMabq38uNMfmBZVz5jX91GvPVBmKstTuveZ89QAzQIDUHMMZUAKoBtYwxwWl8fxFMUDkKv7SISyHjKO99lq47OjP/486s+U0XLIpIzpSaclAz8b8fWGtfAqoDfwKLjTEFrt3QWjscGACsNsZUN8YEAauAnUDHdFyjUBxI7sbzM0CZ1BzAWrvbWlvdWtvFWnvy+vXGmBBjzPiIiIg0RpNcxRjyPNAG//5bOVupNW3j53PnzHqMGT+SExd0waKI5CypKQd5gShr7TqAxOsNhgDBJDN3gLV2ItAPWA6sBzYAL1pr0/Okm2ggNoXcJh3Hu4G1doG1tntAQEBGHE5yOr+CBCdesOibN4CXjr7L9k9CNMOiiOQoqSkHRwBfY4zXNcv+Pp9aKIV91gOXgLLA/Nu4gPEwUCCZ5YHAwXQeU+S2XblgcTOnH3qbx9hG3ZUhTB72NnuO6wyUiGR/qSkHq4F44K5rluVJ/O9f12+ceEHiOmAU0BiYboxpnM58iwF/Y0ypa45fGfBOXCfiHE9vghq8hVefn4gsXJ0u58dwYXRdpsxbQnRchtzlKyLiiFuWA2ttGDAd6HrN4vrAFmDttdsmXoi4BhhkrR1krV0JNAEmGWOevcVb3TChkrV2B1e+nmh3zeJWwJLEmQ9FHGcCy1Ks5yLONxpNBa9w2vzSjukf9+SXfcecjiYiki4mNWf8E+ci+BS4wJVbDisC7ycWh7+3KQJsA1631k67bv/7gSVAu8TCcO06P+BpYDgQAHQHVlhrTySuLwAM4spXGQYon/ge59L8095EjRo1bGhoaEYeUnKji6c4/t2rFD0wj90JxVld6X2ea9GSfL5et95XRCSLGWO2WGtr3LA8A+czwhhT0Vp7w1cNievKAGHW2uQuMHScyoFkpKgdS4ma25f80eHM8mhA0DMfUudePRhURNxLSuUgQx+8lFIxSFx3wF2LgUhG863agAL9t3D6rk60SFhK5dn1GD1+FCcvRDsdTUTklnL8UxlFHOPjT3CrYcR3WoZP3gL0PPoOoZ80Y/6GbWTkGTsRkYymciCSybzK/OPKbY81X+NJNvPo8saMG/Ehh05ddDqaiEiyVA5EsoKnN0GN38f10npiC95Jj7ODOfRZA75Ztp64+PTMDyYiknlUDkSykKtIFQr3Wc252h9Rw7WbZzY2Z/Knb7AzLLlZwkVEnKFyIJLVXC4KPP4yPn1/5kKxh3jh4gRixtVlypyFmjxJRNyCyoGIQ0yBkhR5cR6RT4+nnNdpntvWgZmDe/Dr/uNORxORXE7lQMRJxuBfozX5+m/lVNkQ2kXPIO+k2kyePp3LMTqLICLOUDkQcQd5AinW6UsutppBkE88HXa8yPyPO/HzX0ecTiYiuZDKgYgbyVv1KQr2D+VEpba0jptPoWl1mDhtGpHRcU5HE5FcROVAxN345qdo29FEtZ1LgK8HL+x5maUfP8/6Pw44nUxEcgmVAxE35VuxNoGvhRJetTPN45dQeno9Jkz+gojLmoVcRDKXyoGIO/POS5FWw4jtsIg8efzoduAVVg9+jjXb9zidTERyMJUDkWzAp9zDBPX/iRP3vEhIwkoqzHqS8Z+PJeKSziKISMZTORDJLrz8KNziY+I7L8M7TwDdD7/JusEt+WFbig9DFRFJF5UDkWzGu/SDFOq/mRP39aahXUvVOU/y+cSRnLsU43Q0EckhVA5EsiNPHwo3/YCEF1aDfzBdj7zL5sFN+WHrTqeTiUgOoHIgko15lbiPwq9sJPyB/tSxm7lrbn0+nzCCsxd1FkFE0k/lQCS78/SmSMi/oNtqrH9Ruoa9z49DWrBq6y6nk4lINqVyIJJDeBWvRuFXNnCy+ivUtxu4a259JkwcozsaRCTNVA5EchJPb4Kb/BvbdSUeeYPoduQt1g5pxdrte51OJiLZiMqBSA7kVfJ+Cr36IyfufZlGCT9w56x6TJw0kQtROosgIremciCSU3n6ULjZR8R1WoqPXz5eONiflYPbsmnnAaeTiYibUzkQyeF8yvyDoP6bOX5XN5rEr6D4N/X4YuqXXIrRkx5FJHm5vhwYY0KMMeMjIiKcjiKSebz8KPrsEGKfX0QePx+67O3D0o+fZ8vuI04nExE3lOvLgbV2gbW2e0BAgNNRRDKdT/krz2g4VrkTzeMWEzStDlOmf0NUbLzT0UTEjeT6ciCS63jnpVib4VxuO4/8Pi7a73iJhYM78/uBcKeTiYibUDkQyaX8Kj5BYP9QjlVoQ8uYefh8UZuv5y4gNj7B6Wgi4jCVA5HczMef4u3HcvHZGRT2juLZrR2Z/kkf9hw/53QyEXGQyoGIkPeupwh4NZQTJZ+i/aWpRI6py8xlP5CQYJ2OJiIOUDkQkSvyBFL8hW+IaDyWOz3CabzxWSYPf48jZy46nUxEspjKgYgkEVDzOfL23cy5wjXpEjGSg8MbsmBdKNbqLIJIbqFyICI3MAHFKdZzEWeeGMgDrj959PsmTBgzmFOR0U5HE5EsoHIgIskzhsAnXsK750aiA8rR/cSH/PJJU9Zs06OgRXI6lQMRuSlX8J0U6fsDJ2u+QR27mcpz6jPpywlcjNb0yyI5lcqBiNyahyfBjd8l4YWVuPIUpPP+11gxuB3b9oY5nUxEMoHKgYikmneJ+wl+dRPHqnalSdwyCkypwzezZ2niJJEcRuVARNLGy5dirT7l8nNzyO8Nz/76AjOHvMze8HNOJxORDKJyICLpkrdSbQL7/8Tx0iE8d/lrLoyux9xV63XLo0gOoHIgIunnG0CJLlM413gcFVzHqLemBZNGfsDJ81FOJxOR26ByICK3rUDNNvj12cSFwLvpcnoI2z9twpqtfzodS0TSSeVARDKEq2BJivVewcmH3uUxtlBpbgO+mPIFl2J0y6NIdqNyICIZx+UiuMEb2BdW4ukXQJd9r7B4cCd+PxDudDIRSQOVAxHJcN4l7qNQ/00cq/Q8LWMX4PlFXaYvXEq8nvIoki2oHIhI5vDyo9hzI4ls+Q13eEXS9Of2TBv2JmFn9ZRHEXenciAimcr/7kbke+VnThV9hI7nx3FweAOWb9rmdCwRuQmVAxHJdMY/mOI95nC69sdUZxc1lzRm0oQRXIiKdTqaiCRD5UBEsoYxBD3+Ih491xOdrySdw95nzeA2/KrnM4i4HZUDEclSXoUrUvSVdRyt1pNG8Svxn1KP6fMX6mJFETeiciAiWc/Dizua/49LbWYT5BlD0y0d+WrYGxw7p4sVRdyByoGIOMa/ch0CXv2JU0Ufo8P58ewd1ojVW353OpZIrqdyICKOMnmDKN5jNqce+5Ca7ODu+Y2Y9OVEomLjnY4mkmupHIiI84yhUJ1euLqvhjxBdN7fn4WDO7Mr7KTTyURyJZUDEXEbXnfcTfCrGzlaoR0tY+YRO/5J5n7/gx4DLZLFVA5ExL14+XFHu9Gcb/olZTxOUX9dKyaP+oCzkdFOJxPJNVQORMQt5b+vKXn7buZcYDU6nxpC6KdN+WnnfqdjieQKuaIcGGMCjTHlnc4hImljAopzR+9lHK/5BnUSNnHHt/X4ZuZ3xMUnOB1NJEfL8eXAGFMJWAnUdjqLiKSDy4Oijd8lpsMS/Ly9ePa37swa2pujZyKdTiaSY+X4cmCt3QX86nQOEbk9fuUeIqj/Txwr2YjWkdM4MqI+P4Tqf22RzOBW5cAYU8zpDCLixnzzU7LrNE7WHUo19nD3gqeZMlVzIohktDSXA2PM3caY8xkZwhhTyxgzH1iUzDp/Y8wwY0wvY8xbxphRxpi8Gfn+IpKNGEPwo11w9VhDQp5CdNjbn/lDurHn2Fmnk4nkGGkqB8aYwsDHQL6MCmCMyQfsBTxTyDMDOG2tHWmtHQicAsYn7lvTGLMpuVdG5RMR9+RdtAqFX91IWPk2tIqeReTYJ1m4dpPmRBDJAKkuB8YYH+AtYEQK64sYY7Ykd1eAMSaPMWaJMabe9eustResteHAiWT2ewRoCMy8ZvFUoI0xppK19mdr7UPJvVL7c4lINublR/Hnx3Hu6QlUdIXx6MpmTJ74GRej45xOJpKtpeXMwb+5ctYgKrmViR/wU4C1xpiqfy83xuQHlnHlN/7VacxXG4ix1u685n32ADFAg9QcwBhTAagG1DLGBCezPsQYMz4iIiKN0UTEXRSo0QqfXhuJyleGzmHvs3xIB3YeuuH3DRFJpVSVA2NMP2CGtfb4zbaz1g4HBgCrjTHVjTFBwCpgJ9DRWpvWq4aKA8l9kXgGKJOaA1hrd1trq1tru1hrb5io3Vq7wFrbPSAgII3RRMSdeASVpUi/NRyt0pVmsYuwnz/JvJVr9DWDSDrcshwYY5oBB621W1NzQGvtRKAfsBxYD2wAXrTWpmfWkmggNpnlLsCk43gikpN5enNH60+JaDaNUh6nqbu2FV+O+5gLUcn9MyIiKUnNmYOXgW+MMVHGmCiufOiT+OcpKeyzHrgElAXm2/RX98NAgWSWBwIH03lMEcnhAu4NIU+fTZwvUIVOxz9i3ZDW/L7/mNOxRLKNW5YDa209a63v3y+gfuJyX2tth+u3T7wgcR0wCmgMTDfGNE5nvsWAvzGm1DXHrwx4J64TEUmWq0AJ7ujzPUer9aJB3Cp8J9dl3rIV+ppBJBUydBKkxAsR1wCDrLWDrLUrgSbAJGPMs7fY3eP6BdbaHVw5U9HumsWtgCWJMx+KiKTMw5M7mn/IxVYzCfa4xFMbn+Or0f/H+csxTicTcWsZVg6MMUW48gyDt6y1Y/5ebq3dCDwFfGaMqZvMfn6JxaEuUMEY0y5xPoW/tQbKGGPeNMa8BZQE2mZUbhHJ+fJVrUe+fps5FfgA7U9+yo9DWvL7/jCnY4m4LZORp9iMMRWttX+lsK4MEGatdcsrg2rUqGFDQ0OdjiEimSkhgbAF/6Xo1mHst8X4vdZwnqlfD2N0fbPkTsaYLdbaGtcvz9CvFVIqBonrDrhrMRCRXMLlovgzA7iU+DVD/Y3tmDJ2IOd1N4NIEm714CURkayQr2pd8vX9kXMF76Zj+EDWDWnDjkPhTscScRsqByKSK7kCinFH7+UcrfYyjeO+x/V5PRauWqu7GURQORCR3MzDkzuaf8T55t9Q3OMcj69pxZSJQ/VsBsn1VA5EJNfLX60ReXpvJDJ/BTqG/YcVQzqw++gpp2OJOEblQEQE8ChYkmL9VhFWpStNYxcRNe5JlqzT098ld1I5EBH5m4cXxVt/yrkmkynrOkGt75sxZdIoomLT+sw4kexN5UBE5DoFqjfD9+X1XPIvTYeD77D4k64cOqHHukvuoXIgIpIMz0JlKfbKGg7f2Z7mUXM4M7oea0O3OR1LJEuoHIiIpMTTh5LtR3GqwTgqcpi7FjzNN99OJS4+PU+gF8k+VA5ERG6h0ENt8OjxA3G+QbTa2ZuZw17h5PnLTscSyTQqByIiqeBTtDJFXt1AWImGtLkwmZ1Dn+aXXQecjiWSKVQORERSy8efUi98zfGH/0stu5Wgr59k9uIlmlVRchyVAxGRtDCGok/2Ifr5heT3TKDR5ueZMvZ/XNDDmyQHUTkQEUmHvOVrUeCVHzld8F46hg/ih0/asTvspNOxRDKEyoGISDoZ/8IU772MsLt7EBK7jKjx9Vm+4SenY4ncNpUDEZHb4eFJ8ZaDONdkMuVdx6m5vBnTpn1OrG53lGxM5UBEJAMUqN4Mr57riM5TlLa7+zN7aG9ORFxyOpZIuqgciIhkEK/gOyn6yjrCSoXQOnIae4Y14pede52OJZJmKgciIhnJOw8lu0zh+KP/o4b9jcLf1mfe4kW63VGyFZUDEZGMZgxF6/YkpsNi/DxdNNjckW/GfcSlmDink4mkisqBiEgm8S/3Dwq+8iMnClan7fGPWTWkPfvDzzodS+SWVA5ERDKRy78QJXsv5nDV7jwds4Rzo59i3S/bnY4lclMqByIimc3Dk5KtBnO64Tgqm4NUmhfC9FnfkZCg6xDEPakciIhkkaB/tMHV7XuMT16ab3+Rr0e+T8SlGKdjidxA5UBEJAv5FL+HQq9sIDy4Fu3PfMaGT9to2mVxOyoHIiJZzPgVpETP+YTd24dGcSuJHl+fH37a4nQskatUDkREnOByUbzZfznb5EvKuY5xz6Jn+HbGNOJ1HYK4AZUDEREHFazeFM8ePxDnG0jLP3ozfcRbRFzUdQjiLJUDERGHeRepTJFXN3C0aG3anhvLz58256/DJ5yOJbmYyoGIiDvwyUepHrMIe+B16sSvJ2FiXVb/qMc/izNUDkRE3IUxFA95j4hmX1PcdYb7lzZlxreTdR2CZDmVAxERN1Pw3kZ491zLZb+itNjZj5kjXtd8CJKlVA5ERNyQT3B5ir26jsPF6tP63AR++rQle49qPgTJGioHIiLuyjsvZV6czuH7X6Nu3FqixtVn/ZZfnU4luUCuKAfGmEBjTHmnc4iIpJkxlHzmfc42+ZKyrmNUmh/CzDnfYa2uQ5DMk+PLgTGmErASqO10FhGR9Aqq/gwe3VeBtz9Ntr3IV2P+y8XoOKdjSQ6V48uBtXYXoPNwIpLt+RSreuW5DEH/oP2JT1j5SQcOn4xwOpbkQG5VDowxxZzOICLizkyegpTstZDDVbrRJGYRx0c15KffdzkdS3KYVJUDY0xRY8wMY8xBY0y4MebfGRnCGFPLGDMfWJTMOn9jzDBjTC9jzFvGmFHGmLwZ+f4iItmKy4OSrYdw8snPuJe/uOO7RixYtkzXIUiGuWU5MMYY4A2gv7W2NNASeN8YUycjAhhj8gF7Ac8U8swATltrR1prBwKngPGJ+9Y0xmxK7pUR2URE3Fnwwx2I7biYPJ5Qd+PzfD1pBDFxCU7HkhwgNWcOCgAfWGsPA1hr1wGngSQV1RhTxBizJbm7AowxeYwxS4wx9a5fZ629YK0NB26YSNwY8wjQEJh5zeKpQBtjTCVr7c/W2oeSe6Xi5xIRyfbyln2QgL4bOJOvEu0O/YsFQ3ty6sJlp2NJNnfLcmCtPWutPfP3n40xTwJTrLWrr9suHJgCrDXGVL1m+/zAMq78xp9kn1SoDcRYa3de8z57gBigQWoOYIypAFQDahljgpNZH2KMGR8RoYt6RCR78shflBL9vudg6Ra0uPgNfw4N4c8DYU7Hkmws1RckGmMqGmNGAguBysaYQtdvY60dDgwAVhtjqhtjgoBVwE6go7U2Po35igNnk1l+BiiTmgNYa3dba6tba7tYa2+YXsxau8Ba2z0gICCN0URE3IinD6U7fU5Yrf/joYQteE16krU/6htWSZ+03K2wG3gHaAXUAAYmt5G1diLQD1gOrAc2AC9aa9PzRVg0EJvMchdg0nE8EZGcyxiK1+/LhWdnEuy6QLWlzZk962tdqChplupyYK84b62dB7wP3Ox7/fXAJaAsMN+mf2Qe5so1D9cLBA6m85giIjlawbvq4vPSD0T5BBOyvRffjvkPl2PSeuJWcrP0znMQTgofzokXJK4DRgGNgenGmMbpfJ/FgL8xptQ1x68MeCeuExGRZPgULk+RV9dyNOifPHdiKN9/2oFjZy84HUuyidTcypjPGNPGGOOX+GfDldsZ/5vMtlWBNcAga+0ga+1KoAkwyRjz7C3eyuP6BdbaHVz5eqLdNYtbAUsSZz4UEZEUGN8ASveaz8FKXQiJWsjBEY35dfcBp2NJNmBudcbfGFORK3cbuIBJXLkYcL219pfrtisCbANet9ZOu27d/cASoF1iYbh2nR/wNDAcCAC6AyustScS1xcABgH7uHKdQfnE9ziX5p/2JmrUqGFDQ0Mz8pAiIm7j+A8TCPrhLQ7bYPbWm8iTjz7idCRxA8aYLdbaGjcsz8gLVYwxFa21f6WwrgwQZq1N7gJDx6kciEhOd2HXGuz057HxsSy962Oebdkel0vXdudmKZWDDH22QkrFIHHdAXctBiIiuUG+So/j+9IaLvsWocUffZg+egCXYvRkR7mRWz14SUREMpd3cFmKvLKGo8EP89yp4az8RBcqyo1UDkREchnjG0CpnvM4VLkrIdGLODSiEb/t0d3h8v+pHIiI5EYuD0q1+ZTjtT+lut2B/9SnWLl+g9OpxE2oHIiI5GJFH+/KpTazCXJdpMaKlsz8bioJCZpRMbdTORARyeUCKj+Oz8trueRbhKa/9+G7sf8iKlYzKuZmKgciIoJPobIUfWUtYYUepvWJEXz/SUdOREQ6HUsconIgIiIAGN/8lH55HvsrduHpqAXsGd6EXQePOh1LHKByICIi/5/Lg7JthxL2yEc8mLAVvniKDVu2Op1KspjKgYiI3KB4vZc53/xbSrhOUWF+UxYsXuB0JMlCKgciIpKswGpP4XphBS4vX+pt7sK3X44kLj7B6ViSBVQOREQkRX7F76Zg33Wc9q9Im/3vMuuz17lwOcbpWJLJVA5EROSmPPIVpkS/7zlYrAGtz01k/dB2hJ0+73QsyUQqByIicmtefpTu9g2H7n6ZhjHLCRvZiN815XKOpXIgIiKp43JRquVHHK8zjPvtTvymNmDNps1Op5JMoHIgIiJpUvSxzlxsPYvCrgvcvaQFc+fNwlpNuZyTqByIiEiaFajyBN49VhHvHUDDX7oz/YtPdSdDDqJyICIi6eJTpCKF+q0jPH812hz+P+aP6Ks7GXIIlQMREUk3V95ASvVdxv7iTWgeMYWfP32WY6fPOR1LbpPKgYiI3B5Pb8q+MIUD975KndgfODqyETv26U6G7EzlQEREbp8xlGk2gKN1P+MeuwufLxvyY+gvTqeSdFI5EBGRDHPHox2IfPY7irjOceeCpixausjpSJIOKgciIpKhAu+qg+uFFeDlR+0fOzP9q/EkJOhWx+xE5UBERDJcnuJ3EdhnDWfzlKHlX28wfcwAomLjnY4lqaRyICIimcIjf1Hu6LeKI8GP8tzJ4Swd2p0zkVFOx5JUUDkQEZFMY3z8Kd1zLgfLtaXppZn8Oqw5B8NPOx1LbkHlQEREMpfLg9LPj+ZIjbepHbeBM2Ma8etf+5xOJTehciAiIpnPGEo8/RbhDcZRlb3k/6oR6zb/5HQqSYHKgYiIZJkiD7Xh8nOzCXJFUmVxCxYvme90JEmGyoGIiGSpApUew6v79yR45aX2pq7M+mqMbnV0MyoHIiKS5fyKVSawz1pO5b2TZn+9zZyx7xEdp1sd3YXKgYiIOMIzf2FK9PueA8FP0OLESFYO7UrEpWinYwkqByIi4iDjnZdyPWext1x7Gl2cw9ahzQk7dc7pWLmeyoGIiDjL5UH550dy4P43eSJ2PcdHNeLPA0ecTpWrqRyIiIjzjKHMM+9wtM4I7rV/4prUkNDtvzudKtdSORAREbdxx2MdiWj2NSXMSe6Y1YRV69Y6HSlXUjkQERG3EnRvA+I7LcLPI4Hq37dhwYJZTkfKdVQORETE7eQr8wB5XlpFtHdBngx9ke+mjtZcCFlI5UBERNyST3A5CvVdw0n/irTY8w4zx/5bcyFkEZUDERFxWx7+hSjRdwWHCj1CqxPDWDysJ+cvxzgdK8dTORAREbdmvPNSpudc9pduSbPIb9n8aWvCz15wOlaOpnIgIiLuz8OTsp0mcuCePjwZu4p9n4WwLyzc6VQ5lsqBiIhkD8ZQpsV/OfLIQB5M+JXLExry267dTqfKkVQOREQkWylR7yVONZ5EeQ6T/+vGbAr92elIOY7KgYiIZDtFajbl8nNzKeC6TIUFzVm5cqnTkXIUlQMREcmWClZ6GM9uK4j39OMfazuycM7XTkfKMVQOREQk28p7R2UCeq3ivE8xntzWm1lTP9NkSRlA5UBERLI1n4IlKNp3Ncf9q9Jsz/vMHv8fYuMTnI6VrakciIhItufKW5BSfZdyMOgRWh4fyoIRfbkUHet0rGxL5UBERHIE452Xsi/PYV/xJjSPmMIPwzpxNjLK6VjZksqBiIjkHB5elHthCvsrdqHR5YVsG9aSo6cjnE6V7agciIhIzmIMZdsO5WD1t6gdt47DI0PYG3bc6VTZisqBiIjkSKWbvE3Y40N4wP7G5QmN+G33PqcjZRsqByIikmMVr92Ns42/oAKHyTutMT9v2+50pGxB5UBERHK04JrNuNTqOwqbCErOeYZ1G9Y5Hcnt5YpyYIwJNMaUdzqHiIg4o2DVJ7CdFuPjYbl7eRuWL1vgdCS3luPLgTGmErASqO10FhERcU6+Mvfh12MV0V75eWRjVxbMmoK1mk0xOTm+HFhrdwG/Op1DRESc51u4HEG9V3PatxQNtvdj3tThKgjJcKtyYIwp5nQGERHJ2bwCilK830oO57uXpvsGMHfcv4nTdMtJpKocGGOqGGOWG2MijDFhxpghxhivjAphjKlljJkPLEpmnb8xZpgxppcx5i1jzChjTN6Mem8REcl9XH4BlO27mL2Bj9Ps+DAWjOxPVEyc07Hcxi3LgTEmAPi/xNejwFSgP/BuRgQwxuQD9gKeKeSZAZy21o601g4ETgHjE/etaYzZlNwrI7KJiEjOZbz8KP/ybPYWe5pmZ79gxfAXiYzS8xggdWcOGgP9rLXrrbXbrbVvARuButduZIwpYozZktxdAcaYPMaYJcaYetevs9ZesNaGAyeS2e8RoCEw85rFU4E2xphK1tqfrbUPJfdKxc8lIiK5nYcn5btNZV/ZtoRcnMnGoe04e+Gy06kcd8tyYK392lobdt3io1z5bf/a7cKBKcBaY0zVv5cbY/IDy7jyG//qNOarDcRYa3de8z57gBigQWoOYIypAFQDahljgtP4/iIiktO5XJTrMJp9VXpSP3oZ24e34PiZ806nclSaL0g0xriA+4Gh16+z1g4HBgCrjTHVjTFBwCpgJ9DRWhufxrcrDpxNZvkZoExqDmCt3W2trW6t7WKtPXn9emNMiDFmfESEHswhIpJrGUO51v/jwAPv8HjcBg6MbMLBYzd8ZOQa6blboTswzFqb7O2B1tqJQD9gObAe2AC8aK1Nz6Wg0UByXwC5AJOO493AWrvAWts9ICAgIw4nIiLZWJmQNzn86CBqJmzjzPgQdh+8/sR57pCmcmCMeQzwtdaOvMWm64FLQFlgvk3/TaSHgQLJLA8EDqbzmCIiIikqWbcHJ+qP4W67m7hJjfn9rz1OR8pyqS4HiRcHVrLWDrtmmU8y25UH1gGjuHIx43RjTON05lsM+BtjSl1z/MqAd+I6ERGRDFes1nOca/IlZQkj71dPE7o9dz2wKbXzHNThygf9OmNM5cRXCyDkuu2qAmuAQdbaQdbalUATYJIx5tlbvI3H9QustTu48vVEu2sWtwKWJM58KCIikimCqz/NpdYzCTbnKTarGRs355675M2tzvgnFoOFgN91q84Bxa21lxK3KwJsA1631k677hj3A0uAdomF4dp1fsDTwHAggCvXNKyw1p5IXF8AGATs48p1BuUT3+Ncmn7SW6hRo4YNDQ3NyEOKiEgOcH7fFhKmNiMuwfJb7UnUfuKGu/KzLWPMFmttjRuWZ+Sc0saYitbav1JYVwYIs9a65QwTKgciIpKSyLAdRH3eBO/4i2z65xjqN2jqdKQMkVI5yNBnK6RUDBLXHXDXYiAiInIz/sWr4t9zJZe8Annkx+4snDPt1jtlY2714CURERF35VuoNEF9VnHatyT1t/Vh3tdjcuwTHVUOREREUskrfxHu6Ps9R/NW5eldbzP3y09zZEFQORAREUkDjzwFKd13KQfzP8Az+//LnIkfEp+QswqCyoGIiEgaGR9/yvZZyP6CtWgeNph5Y98lLj49EwG7J5UDERGRdDBefpTvNZc9herS/MQoFo7sT3RcWh8h5J5UDkRERNLL05s7X5rBnmJP0/TsFywb0ZPL0XFOp7ptKgciIiK3w8OTO7tNZW+pZ2ly/ltWD+9CZFT2vnNf5UBEROR2uVyU7zyBveU70OjSPDYMa8+5yMtOp0o3lQMREZGMYAzl249gX5WXeCpqKb+MaMPp8xedTpUuKgciIiIZxRjKtR7I/nv7UyfmB3aMaMGJs+edTpVmKgciIiIZrGyzf3Gg5vs8Gvcj+0Y+Q9ipM05HShOVAxERkUxQpvFrHKz1Px6M38rx0SEcOnbC6UippnIgIiKSSUrX70nYE0O5N2EH58Y/zf4jR52OlCoqByIiIpmo5BOdCa8/hip2L5cnPs2eg4ecjnRLKgciIiKZrHitNpxs/DnlOYSd1Jhde3Y7HemmVA5ERESywB01m3Km6VeUIBzvaU34489dTkdKkcqBiIhIFil231OcbzmdIpzB/5smbP/jD6cjJUvlQEREJAsVubs2F1vNJMicp+CMpmzd/qvTkW6gciAiIpLFgqs+Skzb2RQwFyk8qzk///KL05GSUDkQERFxQGDFfxL3/HzyuaIpOa8Fm37+yelIV6kciIiIOKRg+RrQYQF+rjjKLmzFxk0bnI4EqByIiIg4Kn/Z+3F1Xoy3y1JxSRs2blzrdCSVAxEREaflK3UPnl2XYDy8qLysLRvWr3Y0j8qBiIiIG8hXoio+3ZYQ7+HLXSvasW7NCseyqByIiIi4Cf9ilcjz4jJiPPJy76oOrF212JEcKgciIiJuJG+R8vj3WM4lzwDuX9OFNSsXZHkGlQMRERE3k6dwWQJeWkakZyA11nZl+epVWfr+KgciIiJuyK9QaQq8vIIf8oXw8vILzPj5cJa9t8qBiIiIm/ILLE7dvuN56M6ivDPnNw6fuZQl7+uZJe8iIiIi6eLr5cGEDjUIPXCWkoF5suQ9deZARETEzfl6efBIhUJZ9n4qByIiIpKEyoGIiIgkoXIgIiIiSagciIiISBIqByIiIpKEyoGIiIgkoXIgIiIiSagciIiISBIqByIiIpKEyoGIiIgkoXIgIiIiSagciIiISBLGWut0BrdgjDkJHExhdQAQkcZ1hYBTGRAtM93s53KX46fnGGnZJzXb3mqbnDg+NDY0Nm7G3cdHevdP7X45aWyUttYG37DUWqvXLV7A+LSuA0Kdzn07P5e7HD89x0jLPqnZ9lbb5MTxobGhsZGdx0d690/tfrlhbOhrhdRZkM517i6zs2fE8dNzjLTsk5ptb7VNThwfGhsaGzfj7uMjvfundr8cPzb0tUImMcaEWmtrOJ1D3JPGh6REY0NSkpVjQ2cOMs94pwOIW9P4kJRobEhKsmxs6MyBiIiIJKEzByIiIpKEykEWMsYEGmPKO51D3I/GhtzMzcaHMaZAFscRN5Lc2DDGlDbGdDfG1E7vcVUOsogxphKwEqid+GeXMeZdY8xXxpifEtdLLnT92LhmuY8xZr0xpowjwcQtJDc+jDFPG2P2GGP2AK86Fk4clcLYCAGGAd9aa1en99iet51OUsVau8sY8+s1iyoBI621EcaY/kAjYJcz6cRJyYyNv3VCBT7XS2F8NAdqWWtPOJFJ3MP1Y8MYUxz4AqhkrT1/O8fWPzzpYIwpdrvHsNbuTCwGvkApYMrtJxOnZcTYSDxOO2A2EJMRxxP3kBHjwxhTEigI/GqMmWuMyXf7ycRpGfRvR3vgJNDeGLPQGNMvvQfSmYM0MMbUAt4CSgDVr1vnD3wA7AH8gZLAG9baizc5Xl6gG9AAOAwMyZzkktkycmwYY54CtllrTxpjMjW3ZI2MHB/W2sNAM2OMHzAS+C/QL9PCS6bK4M+VcsAX1toRxpgJwBFjzHRr7bG05tKZg1RKbOd7uVKokvt7mwGcttaOtNYO5Mr81ze9J9Vae9FaOwyoCTybsYklq2TC2OgGfGiMmQvcDYw3xtyfsaklq2TGvx0A1trLwJtA5QyMK1koE8bGaSABro6PfVwpHWmmcpBK1toL1tpw4Ibv+IwxjwANgZnXLJ4KtEnlhYbRwG8ZElSyXEaPDWttS2ttU2ttU+B3oLu1dmvGJ5eskNHjI/FC1b//7S4KbMrgyJJFMuFzZSHw4DV/9gH+Sk82lYOMURuIsdbu/HuBtXYPV74vbgBgjKkAVANqGWOCjTGNjTGhxpjWwHPAOw7klsyX5rHhSEpxSnrGRx8g1BjTEXgU+CjLU0tWSPPYsNZuBP40xvQ1xnQH3rPWpuvplrrmIGMUB84ms/wMUAbAWrubpN8nLUp8Sc6WnrFxlbX2icwKJm4hPeNjcOJLcrZ0/dthrf13Rry5zhxkjGggNpnlLkBXlOVuGhtyMxofkhJHx4bKQcY4DBRIZnkgcDBro4ib0diQm9H4kJQ4OjZUDjLGYsDfGFPq7wXGmMqAd+I6yb00NuRmND4kJY6ODZWDtPO4foG1dgewHGh3zeJWwBJrrWY9zD00NuRmND4kJW43NvTI5lRKnHDkaWA4EAB0B1b8PX1p4sNPBnHlvlIDlAdet9aecyKvZB2NDbkZjQ9JiTuPDZUDERERSUJfK4iIiEgSKgciIiKShMqBiIiIJKFyICIiIkmoHIiIiEgSKgciIiKShMqBiIiIJKFyICIiIkmoHIiIiEgSKgciIiKSxP8Dfj4pCob88scAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "m_arr = np.geomspace(1e13,1e16,100)\n", + "get_sigma_at_z_and_m = np.vectorize(M.get_sigma_at_z_and_m)\n", + "plt.plot(m_arr,get_sigma_at_z_and_m(1.,m_arr),label='class_sz')\n", + "me,se = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/m_sigma_z1.txt',unpack=True)\n", + "plt.plot(exp(me),se,label='szcountsf90')\n", + "plt.loglog()\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[CAMB] Importing *auto-installed* CAMB (but defaulting to *global*).\n", + "[camb] Initialized!\n", + " :::::: this is initialisation in binned_clusters.py\n", + " :::::: reading catalogue\n", + " Number of mass bins : 138\n", + " SO for a full map\n", + " 2D likelihood as a function of redshift and signal-to-noise\n", + " Total number of clusters in catalogue = 62475\n", + " SNR cut = 5.0\n", + " Number of clusters above the SNR cut = 43232\n", + " The highest redshift = 2.62\n", + " Number of redshift bins = 27\n", + " Catalogue N\n", + "0 316.0\n", + "1 2175.0\n", + "2 4000.0\n", + "3 5081.0\n", + "4 5369.0\n", + "5 5253.0\n", + "6 4587.0\n", + "7 3992.0\n", + "8 3233.0\n", + "9 2565.0\n", + "10 1912.0\n", + "11 1418.0\n", + "12 1104.0\n", + "13 734.0\n", + "14 526.0\n", + "15 341.0\n", + "16 226.0\n", + "17 155.0\n", + "18 101.0\n", + "19 60.0\n", + "20 40.0\n", + "21 22.0\n", + "22 11.0\n", + "23 4.0\n", + "24 6.0\n", + "25 0.0\n", + "26 1.0\n", + "27 0.0\n", + "43232.0\n", + " The lowest SNR = 5.00\n", + " The highest SNR = 93.46\n", + " Number of SNR bins = 6\n", + " Edges of SNR bins = [ 3.98107171 7.07945784 12.58925412 22.38721139 39.81071706\n", + " 70.79457844 125.89254118]\n", + " Catalogue N in SNR bins\n", + " 0 24950.0\n", + " 1 14092.0\n", + " 2 3454.0\n", + " 3 642.0\n", + " 4 90.0\n", + " 5 4.0\n", + " 6 0.0\n", + " :::::: loading files describing selection function\n", + " :::::: reading Q as a function of theta\n", + " Number of Q functions = 1\n", + " Using one averaged Q function for optimisation\n", + " :::::: reading noise data\n", + " Number of tiles = 346\n", + " Noise map is downsampled to speed up a completeness compuation by 50\n", + " Number of sky patches = 451\n", + " Entire survey area = 17884.527800569285 deg2\n", + " Total predicted 2D N = 43193.12756602195\n", + " ::: theory N calculation took 26.4 seconds\n", + " ::: 2D ln likelihood = 494.42687934682164\n" + ] + }, + { + "data": { + "text/plain": [ + "array([-494.42687935])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# info = {\n", + "# 'params': params,\n", + "# 'likelihood': {'soliket.BinnedClusterLikelihood': {\n", + "# 'single_tile_test': \"no\",\n", + "# 'choose_dim': \"1D\",\n", + "# 'Q_optimise': \"yes\",\n", + "# 'stop_at_error': True,\n", + "# 'data_path': data_path,\n", + "# 'cat_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/MFMF_WebSkyHalos_A10tSZ_3freq_tiles_mass.fits\",\n", + "# 'Q_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/quick_theta_Q.npz\",\n", + "# 'tile_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/tileAreas.txt\",\n", + "# 'rms_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/downsampled.txt\"}},\n", + "# 'theory': {'camb': {'extra_args': {'num_massive_neutrinos': 0}}}\n", + "# }\n", + "# 2D N calculation \n", + "\n", + "info = {\n", + " 'params': params,\n", + " 'likelihood': {'soliket.BinnedClusterLikelihood': {\n", + " 'single_tile_test': \"no\",\n", + " 'choose_dim': \"2D\", # change option here \n", + " 'Q_optimise': \"yes\",\n", + " 'stop_at_error': True,\n", + " 'data_path': data_path,\n", + " 'cat_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/MFMF_WebSkyHalos_A10tSZ_3freq_tiles_mass.fits\",\n", + " 'Q_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/quick_theta_Q.npz\",\n", + " 'tile_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/tileAreas.txt\",\n", + " 'rms_file': \"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/downsampled.txt\"}},\n", + " 'theory': {'camb': {'extra_args': {'num_massive_neutrinos': 0}}}\n", + "}\n", + "\n", + "# initialisation \n", + "model = get_model(info)\n", + "like = model.likelihood['soliket.BinnedClusterLikelihood']\n", + "model.loglikes({})[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# # initialisation \n", + "# model = get_model(info)\n", + "# like = model.likelihood['soliket.BinnedClusterLikelihood']\n", + "# model.loglikes({})[0]\n", + "pk_intp = like.theory.get_Pk_interpolator((\"delta_nonu\", \"delta_nonu\"), nonlinear=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r", + " Total predicted 2D N = 43193.12756602195\n", + "\r", + " ::: theory N calculation took 27.3 seconds\n" + ] + } + ], + "source": [ + "\n", + "SZparams = {\n", + " 'tenToA0': 4.35e-5,\n", + " 'B0': 0.08,\n", + " 'scatter_sz': 0.,\n", + " 'bias_sz': 1. \n", + "}\n", + "Nz = like._get_theory(pk_intp, **SZparams)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "z, catNz = like.delNcat" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.plot(z, Nz.sum(axis=1), 'r-', label='prediction')\n", + "plt.errorbar(z, catNz, yerr=np.sqrt(catNz), color='black', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='mock catalogue')\n", + "plt.xlabel('redshift $z$', fontsize=14)\n", + "plt.ylabel('$N$', fontsize=14)\n", + "plt.title('WebSkyHalos A10tSZ cat comparison', fontsize=14)\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.legend(fontsize=14)\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# Nzq = like._get_theory(pk_intp, **SZparams)\n", + "z, q, catNzq = like.delN2Dcat" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Nq = np.zeros(len(q))\n", + "catNq = np.zeros(len(q))\n", + "for i in range(len(q)):\n", + " Nq[i] = Nz[:,i].sum() \n", + " catNq[i] = catNzq[:,i].sum()\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "plt.plot(10**q, Nq, 'r-', label='prediction')\n", + "plt.errorbar(10**q, catNq, yerr=np.sqrt(catNq), color='black', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='mock catalogue')\n", + "plt.xlabel('signal-to-noise $q$', fontsize=14)\n", + "plt.ylabel('$N$', fontsize=14)\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.title('WebSkyHalos A10tSZ cat comparison', fontsize=14)\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "plt.legend(fontsize=14)\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "quick_theta_Q = np.load(data_path+\"MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/quick_theta_Q.npz\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n", + "h : 0.677322\n", + "sigma8 : 0.809711\n", + "Omega_m : 0.312457\n", + "n_s : 0.966050\n" + ] + } + ], + "source": [ + "snrcut = 5\n", + "from classy_sz import Class\n", + "M = Class()\n", + "M.set(cluster_settings)\n", + "M.set({\n", + "'apply_relativistic_correction_to_y_m':0,\n", + "\n", + "'dlny' : 0.1, #HW used to be 0.01, #step in y integral\n", + "'lnymin' : -11., #HW no impact\n", + "'lnymax' : 10., #HW no impact\n", + "\n", + "'dlnM_cluster_count_completeness_grid' : 0.07, #HW used to be 0.01, try bigger, big impact on speed\n", + "\n", + "\n", + "'cluster_count_completeness_grid_z_cutoff_low' : 0.5, #HW good value, #integrating over redshift, different regeims\n", + "'cluster_count_completeness_grid_z_cutoff_mid' : 1.5, #HW no change\n", + "\n", + "'dz_cluster_count_completeness_grid_low_z' : 0.015, #HW used to be 0.001\n", + "'dz_cluster_count_completeness_grid_mid_z' : 0.12, #HW used to be 0.1\n", + "'dz_cluster_count_completeness_grid_high_z' : 0.2, #HW used to be 1e-1, #try taking bigger steps\n", + "\n", + "'mass_epsrel_cluster_counts' : 1e-3, #leave as is\n", + "'mass_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "'redshift_epsrel_cluster_counts' : 1e-3, #leave as is\n", + "'redshift_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "# # tabulation of mass function:\n", + "'n_z_dndlnM' : 80, #HW previously 150\n", + "'n_m_dndlnM' : 50, #HW previously 150\n", + "\n", + "# # computation of mass function\n", + "# # (grid in mass and redshifts for sigma and dsigma)\n", + " #HW these are extremely high, try 80 or 100\n", + "'ndim_masses' : 100, #HW previoulsy 250, big impact on speed\n", + "'ndim_redshifts' : 80, #HW previously 250, big impact on speed\n", + "\n", + "# pk setup for computation of sigma and dsigma\n", + "'k_per_decade_class_sz' : 18., #HW previously 20, last one I can change\n", + "'k_min_for_pk_class_sz' : 1e-3, #Don't change below this\n", + "'k_max_for_pk_class_sz' : 1e1,\n", + "\n", + "'P_k_max_h/Mpc' : 1e0,\n", + "'non linear': 'halofit'\n", + "\n", + "\n", + "})\n", + "M.compute()\n", + "print('h : %f'%M.h())\n", + "print('sigma8 : %f'%M.sigma8())\n", + "print('Omega_m : %f'%M.Omega_m())\n", + "print('n_s : %f'%M.n_s())\n", + "\n", + "M_with_rel = Class()\n", + "M_with_rel.set(cluster_settings)\n", + "M_with_rel.set({\n", + "'apply_relativistic_correction_to_y_m':1,\n", + "\n", + "'dlny' : 0.1, #HW used to be 0.01, #step in y integral\n", + "'lnymin' : -11., #HW no impact\n", + "'lnymax' : 10., #HW no impact\n", + "\n", + "'dlnM_cluster_count_completeness_grid' : 0.07, #HW used to be 0.01, try bigger, big impact on speed\n", + "\n", + "\n", + "'cluster_count_completeness_grid_z_cutoff_low' : 0.5, #HW good value, #integrating over redshift, different regeims\n", + "'cluster_count_completeness_grid_z_cutoff_mid' : 1.5, #HW no change\n", + "\n", + "'dz_cluster_count_completeness_grid_low_z' : 0.015, #HW used to be 0.001\n", + "'dz_cluster_count_completeness_grid_mid_z' : 0.12, #HW used to be 0.1\n", + "'dz_cluster_count_completeness_grid_high_z' : 0.2, #HW used to be 1e-1, #try taking bigger steps\n", + "\n", + "'mass_epsrel_cluster_counts' : 1e-3, #leave as is\n", + "'mass_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "'redshift_epsrel_cluster_counts' : 1e-3, #leave as is\n", + "'redshift_epsabs_cluster_counts' : 1e-30,\n", + "\n", + "# # tabulation of mass function:\n", + "'n_z_dndlnM' : 80, #HW previously 150\n", + "'n_m_dndlnM' : 50, #HW previously 150\n", + "\n", + "# # computation of mass function\n", + "# # (grid in mass and redshifts for sigma and dsigma)\n", + " #HW these are extremely high, try 80 or 100\n", + "'ndim_masses' : 100, #HW previoulsy 250, big impact on speed\n", + "'ndim_redshifts' : 80, #HW previously 250, big impact on speed\n", + "\n", + "# pk setup for computation of sigma and dsigma\n", + "'k_per_decade_class_sz' : 18., #HW previously 20, last one I can change\n", + "'k_min_for_pk_class_sz' : 1e-3, #Don't change below this\n", + "'k_max_for_pk_class_sz' : 1e1,\n", + "\n", + "'P_k_max_h/Mpc' : 1e0,\n", + "'non linear': 'halofit'\n", + "\n", + "\n", + "})\n", + "M_with_rel.compute()\n", + "print('h : %f'%M_with_rel.h())\n", + "print('sigma8 : %f'%M_with_rel.sigma8())\n", + "print('Omega_m : %f'%M_with_rel.Omega_m())\n", + "print('n_s : %f'%M_with_rel.n_s())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "dNdzdy_theoretical = M.dndzdy_theoretical()['dndzdy']\n", + "dNdzdy_theoretical_with_rel = M_with_rel.dndzdy_theoretical()['dndzdy']\n", + "z_center = M.dndzdy_theoretical()['z_center']\n", + "z_edges = M.dndzdy_theoretical()['z_edges']\n", + "log10y_center = M.dndzdy_theoretical()['log10y_center']\n", + "log10y_edges = M.dndzdy_theoretical()['log10y_edges']\n", + "# M.struct_cleanup()\n", + "# M.empty()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "N_z,N_y = np.shape(dNdzdy_theoretical)\n", + "N_clusters_z_theory = []\n", + "N_clusters_z_theory_with_rel = []\n", + "for iz in range(N_z):\n", + " N_clusters_z_theory.append(np.sum(dNdzdy_theoretical[iz]))\n", + " N_clusters_z_theory_with_rel.append(np.sum(dNdzdy_theoretical_with_rel[iz]))\n", + "N_clusters_y_theory = []\n", + "N_clusters_y_theory_with_rel = []\n", + "for iy in range(N_y):\n", + " N_clusters_y_theory.append(np.sum(np.asarray(dNdzdy_theoretical)[:,iy]))\n", + " N_clusters_y_theory_with_rel.append(np.sum(np.asarray(dNdzdy_theoretical_with_rel)[:,iy]))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sky fraction: 0.4335327806600558\n" + ] + } + ], + "source": [ + "\n", + "# here puth the path to the directory : e.g. MFMF_SOSim_3freq_tiles\n", + "path_to_catalogue = '/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/'\n", + "from astropy.io import fits\n", + "tcat = path_to_catalogue+'MFMF_WebSkyHalos_A10tSZ_3freq_tiles_mass.fits'\n", + "list = fits.open(tcat)\n", + "data = list[1].data\n", + "zc = data.field(\"redshift\")\n", + "snr = data.field(\"SNR\")\n", + "tile = data.field(\"tileName\")\n", + "\n", + "zc = zc[snr > snrcut]\n", + "snr = snr[snr > snrcut]\n", + "sf = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz/sz_auxiliary_files/so_3freqs_191121_skyfracs.txt')\n", + "print('sky fraction:',sf.sum())\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "N_clusters_z, xedges = np.histogram(zc, bins=z_edges)\n", + "#plt.errorbar(z_center,N_clusters_z,yerr=np.sqrt(N_clusters_z),marker='o',markersize=3.,ls='none',label='mock catalogue',capsize=5,c='r')\n", + "# 41253./599.?\n", + "sf = 41253./599.\n", + "# n, bins, patches = plt.hist(x=np.repeat(z_center,N_clusters_z_theory), bins=z_edges, color='orange',alpha=0.7, rwidth=0.95,label='class_sz')\n", + "plt.errorbar(z_center,N_clusters_z_theory,yerr=np.sqrt(N_clusters_z_theory),marker='o',markersize=3.,ls='none',label='class_sz',capsize=5,c='orange')\n", + "plt.errorbar(z_center,N_clusters_z_theory_with_rel,yerr=np.sqrt(N_clusters_z_theory),marker='o',markersize=3.,ls='none',label='class_sz (rel. corr.)',capsize=5,c='k')\n", + "# ze,nze = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/z_N.txt',unpack=True)\n", + "# plt.plot(ze,nze,label='szcountsf90')\n", + "# plt.errorbar(z, catNz, yerr=np.sqrt(catNz), color='blue', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='mock catalogue')\n", + "# plt.errorbar(z_nemo,Nz_selfn,yerr=np.sqrt(Nz_selfn),marker='o',markersize=3.,ls='none',label=r'Nemo (Matt H)',capsize=5,c='b')\n", + "#plt.errorbar(z+0.05, Nz.sum(axis=1), yerr=np.sqrt(Nz.sum(axis=1)), color='blue', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='szcountsf90')\n", + "\n", + "\n", + "\n", + "\n", + "plt.grid()\n", + "plt.legend(loc=1)\n", + "plt.xlabel(r'$z$')\n", + "plt.ylabel(r'$N$')\n", + "# plt.yscale('log')\n", + "# plt.ylim(1e0,6.e7)\n", + "plt.xlim(0.,2.)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 2.0)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhUAAAF6CAYAAACurqpsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABNwElEQVR4nO3deXxU5dn/8c+dwGCQRaBBKAqiLKKYInZxIpXBiCJK3Vr1EbfaAo8/ccUFUczwqIA7KEVFpbihRaxURQsYGRUS64M+EBVkjYLIvgRQYEJy/f6YMCQhkG2SWfJ9v17nFebcZ85c98wccuU+9+LMDBEREZGaSop2ACIiIpIYlFSIiIhIRCipEBERkYhQUiEiIiIRoaRCREREIkJJhYiIiEREg2gHECuOOuoo69SpU7TDqDU//fQTRx55ZLTDqDWqX3xL5Polct1A9Yt3X3zxxWYzS43U+ZRUFDv66KNZsGBBtMOoNYFAAJ/PF+0wao3qF98SuX6JXDdQ/eKdc+77SJ5Ptz9EREQkIpRUiIiISEQoqRAREZGIUFIhIiIiEaGkQkRERCJCSYWIiIhEhIaUioiUsWPHDjZu3EhBQUGNz9W8eXOWLFkSgahik+oXmxo2bEjr1q1p1qxZnb6ukgoRkRJ27NjBhg0baNeuHSkpKTjnanS+nTt30rRp0whFF3tUv9hjZuzevZu1a9cC1GliodsfIiIlbNy4kXbt2tG4ceMaJxQi0eCco3HjxrRr146NGzfW6WsrqRARKaGgoICUlJRohyFSYykpKRG5hVcVSipERMqISAuF3w/O0bRZM3Du0JvfX/PXEilHNFralFSIiNQGvx/M2LljB5hB796hzaz0pqRCEoiSChEREYkIjf6Q2JDrh69HVXxc90xI89dyMCJSHbt37+bLL7/kjDPOiHYopQSDQbKzsxN6tdFYoaRCYkOav3Sy8KEv9PPsQN3HIiJV9s0333DTTTexatUqvvvuu2iHE7Zw4UKGDRvGRx99hJlFO5yEp9sfEhPK9l3z3jCGe54+F2/nnFL7RSQ2nXzyyVx99dV19nqPPPJIpY7r0aMHAwcOrOVoZD8lFRJzTu+UQ9aIDB7440iyRmRweqecaIckUnP5+bB6NeQk7ve5rkYbjB07lokTJ1b6+KQk/aqrK7r9ITGhVKvkNwEK/28vyUlFNGgQJGdGAE72Ris0kZrLyYHcXCgqgowMyMoCb+1/p+fPn88TTzxBSkoKp556KrNnz+bLL79k4sSJHHnkkbzwwgvMmzePv/zlL4wZMwaAwsJCnn766fD8BllZWVx//fVcdtllABQVFTF+/HiCwSA7d+5k/vz5vPDCC5xwwgmlXnvLli1cfvnlHHfccVx55ZWcddZZB8W3e/duHn/8cRo3bkxeXh5r167lueeeIzU1la+++oqnn36a008/nXnz5vGb3/yGG264gVWrVjF79mzy8/N58MEH8fl89OrVi4kTJ7J27VqOO+44/vWvf/HII49w0kknHfK9eeWVV8jLy6Np06bMnTuXfv36ccMNN4QTo3fffZfs7GwKCgoYN24crVu35g9/+AP33nsvjz/+OOPHjycvL48WLVowadIk7rrrLubOnRvut/H000+zadMmcnNz2bNnDy+++CLt2rWr8Wca88xMmxldunSxRDZ37txoh1B5G7Nt7n1n2oN/GmHZ/9PbbGN2hU+Jq/pVg+pXdxYvXhzR8+3YscNs9OgDg0iTk0OP68jFF19sxx9/vK1Zs8bMzG677TZr0qSJffrpp2ZmNmPGDEtKSrL169ebmdnIkSPtr3/9a/j53377rTVo0MCmT59uZmZDhw61v/3tb+Hy008/3W644QYzM/v73/9uHTp0MDOzCRMm2Ntvv33Y2AYMGGAzZ840M7N9+/ZZ+/bt7eGHHzYzs3POOcduv/12MzP75ptvLDk52bZt22ZmZpmZmeHXMTP78ccfDbDc3FwzM7vzzjvtkksuCZf//e9/t9Cvu5AXX3zRzj777PDjzZs321FHHWWPPfaYmZmtXLnSPB6P5efn244dO+ymm26yFi1ahI+fO3euAZaXl2dmZnl5eQaEv8eTJ0+2559/Pnx8Wlqa9e/f/7DvRW2p6PsMLLAI/i5VS4XEnJwVXvqOzqLQHA+9C1lnJ+NNjXZUIjXg80FSUqilwuMJPa4jzZo149hjj+WYY44BQn0fdu3aRa9evQDo3r07RUVFrFq1itatW/Pkk0/y3HPPhZ/ftWtX+vfvz+OPP07v3r155plnSk39PGPGDI466qjw48LCQoYMGcLFF19Mv379DhnXwoULCQQCvPPOOwAkJyfz1VdfceSRRwLw1FNP0aJFC3bt2sW8efMoLCwkPz+/1Gvt17ZtWz799FO6d+/OihUrWLlyJVu3bj3kaz/++OOl+lm0atWKa665hscff5xhw4bxxRdfEAwG2bdvHw0bNuTss8/mjTfeOMy7XNqTTz7Jueeey9ixYwFIS0sjPz+/0s+PZ0oqJOYEArCvKBlwBAtCj+ugpVik9ni9kJYW6lfx2mtR/UInJyeX+3jv3r1s2bKFXbt2sXPnzlLHdOnShS+++IIVK1ZQWFhYqu9E48aNadSoUfjxnj17WLJkCWvWrOGcc845ZH+Gb7/99qA+GCUXvjr66KN5+OGH6dixI97i98sOM3qjYcOG3HbbbVx44YWccsopBAKBQx77/fffl1vH9evXU1BQwG9/+1uaNm3KG2+8wdVXX822bduq1Al1xYoVvP7665x88smVfk6iUO8ViQ25fpjqYKrDF/SS4tlNclIBnuSf8QW94TJy/dGNU6S6mjeH9u1jOkP+xS9+wVFHHcU333xTav/u3bvp2rUrbdu2BeCDDz4oVb506dLwv5OTk5k2bRoLFy5k5MiRh3yttm3bsmPHDrKzsw86l5mRkZFBq1atGDx4cIWrhC5YsACfz8eIESPo06dPhfXs1KlTuXXs2LEjDRs2pEOHDrz//vvMmjWLyZMn06BBg8OONimb7LRu3ZqPPvqo1L7Vq1ezevXqCmOLd0oqJCa4X/lxAw030Ej357A72JjCoobsDjYm3Z8TLuOf0Y5UJL4c6q/7oqKicsuHDx/OSy+9xJYtWwDYt28fs2bN4r777qNDhw74fD5uvvlmXn/9dfLy8pg6dSpLliwpdY42bdowbdo0HnvsMd56661yX9/r9dKlSxeuvPJKZs6cSV5eHk8//TSbN29m8+bNfPnll+EY582bB8DWrVspKCigSZMmbN26lX379vHjjz8yd+5cCgoK2LdvH3v37mXBggVs27Yt3Nm0bF3vueceZs6cybfffhuO57333gsnQevWrePhhx/G7/dz+umn06NHj1K3U1JTQ/djFyxYAMCcOXMAwq0fV1xxBffeey+vvPIKGzZs4NNPP8Xv93PssceW+14klEh20IjnTR01o6vsggink23DGW2nk11q/6HEev1qSvWrO7XSUdPMrHfv0FaHPv/8c+vSpYu1a9fO5s+fb2vWrLGrrrrKAHvmmWds27ZtlpmZaYDddNNNtmHDBisqKrLx48fbhRdeaGPHjrWhQ4faW2+9FT7n+vXr7dJLL7XmzZvbcccdZ0899ZSZhTpTXnzxxZacnGxvv/22bd++3c4991xr1KiRjRkzxjZu3HhQfMuXL7e+fftakyZNrFu3bqU6dl511VWWkpJiPp/PPvzwQ+vSpYt5vV777rvvbPny5XbMMcfYGWecYbNnz7Zly5ZZly5d7Be/+IVdf/319o9//MOaNm1qt99+u3311VfWt2/fcJ33fx5Tp0618847z0aPHm3Dhg2zZ555Jvza69ats9/85jfWoUMHO+KII8w5Z845u+OOO8LH/L//9/+sadOmduaZZ9rHH39s3bt3t4ceesi2b99uP//8sw0dOtRat25tLVq0sIEDB9rmzZsj/fFWSl131HR2mHtU9UnXrl2tZBNeogkEAvEzRW1ODvTqFerUlpJSqeF3cVW/alD96s6SJUvo1q1bxM63c+fOUPP9/vod5l5/PArXL4FMnjwZj8fDVVddxc6dO2nSpAn5+fncfffdpTqxxoOKvs/OuS/M7NeRej3d/pDYEwiEEgqAYDDh/hMWkdh25513kp+fH75tArB48WJ+97vfRTGq+KCkQiov13+gw+Thtlx/zV5n//A7qPPhdyIR4/eDczRt1iw0x/zHH4e2snPSa+nzmDNp0iRefPFF2rRpw1lnncUf//hHtm3bxvXXXx/t0GKehpRK5dXVol8RHH5X2VmDbZFfq59KZPn94Pcn5O2BRHfppZdy6aWXAol5e6c2qaVCqq8gH35aDZtqYS2Duh5+p1ElIiI1pqRCqmdTDmzLhZ/y4KOMmicWxU3F4S1CTcVlx5Xc0PtZnrtuCLYxp9R+NUGLiNSckgqpno0BoLgTU1Gw+HEN+P0HZwDlbTX55b8phyt6vcbmn1qRM3F47bSwiIjUY+pTIdXT2kcoJy2CJE/x49iW88qn9Ht0FsF9Hjz/CpLVdALe22N3dkMRkXijpEKqJ9ULLdIgmA/pr4Uex7jAh10IFngotAYE9xmBD7vgvT3aUUnCyvXD16OosItf90x1EpaEoaRCKu3gkRT/V+5xsTqfmu+iE/D8O0gQw2MF+C46IdohSSIrHi0VHj1QW6OlRGKI+lRI5OX6ox1BubyDT6Ffq1kMOOI9sp5diXfwKdEOSUQkoSipkEor22eyRw/o2BGys0vvj6Wm3LKDR97efDEz9lxM+pBTSu3naV+0QxWpc8Fg8LBLhItUlZIKqZacHMjNhbw8yMgIPY5rNwWiHYFInVq4cCHnnXdepZYKF6ksJRVSeSXmkgik34Mr2gdAcHcBgfR7YnLa4cqMUo3VPiAitalHjx4MHDgw2mFIglFSIZVXYi4JX/YYjCTA8KQ0xJc9JjJzSYgkqtqcgbaakpL0K0AiK2ZGfzjnjjOz76Idh1SO1wsXHvFvrGAfd43riNerTo8ih7R/BlqKQjPQnpVVp8Ow16xZw8SJE2ndujXz58/nhBNOYPTo0Qcdt337du6++2569uzJ2rVrWbduHc8++yzJycnk5+dz//33k56eTnZ2NqtXr+btt98GYOTIkXTp0oUNGzYwbtw4fvjhh0rFNXXqVDZs2EDz5s0ZO3Ys06ZNo0ePHlx44YWkpaXRvHlzduzYwYMPPsgll1zC9OnTI/q+SORFLalwzo0BhpfYNRG40TnXBrgfyAXaAh7gPjMrLH5ejcql+koOKT2dHLL4Ix6CBId48A7J4jNC/0lW53aC3+9n1KhRFR6XmZmJXy0hEm/Km4G2jpKK7du3069fP7KysmjTpg39+/fnpJNOCi+YVdIzzzzDggULeO655wA4+uij+cMf/sCAAQN4+eWXKSgo4PLLL+fyyy9n4sSJAHzzzTe89dZbLF68GIDGjRtXOrabbrqJJUuW0Lp1a0488cTw/sGDB3P++ecD8Je//IVf/OIX4deT2BaVti/nXCugA/Cb4u3XwDDnXENgFpBjZs+aWSbwS+B/ip9Xo3KJHB8BPARpQCENCeIjUKPz+f1+zCy89e7dm969e5faZ2ZKKCQ+hWegpc5noJ0yZQonnHACbdq0AaBr165s2rSJ3/72twcdO2jQIF599VUKCwv58MMPKSoqYuvWrQB06tSJ559/nocffpi9e/cyZMgQAFq3bs2aNWu4+uqr2bBhQ3h/ZXTq1IkLLriAhQsXkp6ezimnhFo89ycUM2fOZPLkyUyaNInWrVvX6H2QuhGtG2q3A7uBo4BFZvaFme0BLgdOAv5V4thXgJudcy0iUC41ULJj45hsHw2SQk0SDVM8jMn2RbTTY35+PqtXryYn7oeViHBgBtojO9b5rY9vv/0WV2bmupYtW5Z7bMuWLZk9ezZjxoyha9euHHnkkVjxRX3eeecxceJEHnroIbp168bcuXMBSE1NZdasWWRnZ9O5c2cmTJhQ6dhmzJhBkyZNOO200xgyZAh79uwJl23bto1BgwZx7bXXctFFF1Wx1hIt0UoqOgO/B+YAPzrnLive3wfIM7MdJY79CmgCnBmBcokUrxfS0kITVWRlRXSJ8pycHHJzc8nLyyMjI0OJhSSGhs3hyPZ1PqV927ZtmT9/Pjt37gzvMzOWLVt20LHDhg1jzpw53HfffRx77LGlyvLy8hg0aBArV67E5/PRv39/1qxZw/r16+nZsyeLFy8mMzOTO++8kzfeeKNSse3Zs4ePPvqIGTNm8M477zBs2LBw2dChQ2nYsCFPPfUUAHv37qWwUHexY11Ukgozu8zMugDdgAXA6845H9AO2Frm8P2Pj4tAudRE2eXJFy4MTVSRnl6j5cnLCgQCFBWF7j9rch6Rmvmv//ovdu7cyUUXXcTnn3/O0qVLGTFiBK1atQpfZ/tbI2bPnh2+1bhs2TI2bdrE1q1bKSgoYOrUqaxZs4bU1FRefPFFGjduzM8//8zy5ct5++23adSoEcOGDaNfv37k5+dXKraxY8cCMGDAAO68887w8/75z3/y+uuvM2XKFJo1awbAm2++yd69eyP99kiERXX0h5l965w7H/gEGATsBQrKHLY/8XERKC/FOTcYGAyhJrxE/uW1a9eumtfP5wttlVGD12rWrBnOOcyMBg0a0KxZswpjj0j9YpjqV3eaN29e6q/6miosLGTnzp2kFP+VvTuC566Mtm3b8sYbb3D//ffTp08fTjvtNB577DFWrFjBq6++CsD48eO57LLLuP766xk1ahRpaWlcf/31XHLJJYwbN47OnTuza9cuzjvvPAYPHszWrVsZPnw4v/zlL1m+fDk33ngjq1atokmTJrRp04Y//vGPlXoPX3jhBTweDyeffDK5ubncd999rF69miFDhtCpUyeys7OZP38+mzZt4t///jcXXnhhRD+bytj/+cWrPXv21Om15SwGZv5xzt0E9AdWAj4z616i7JfAWuASIKMm5Wb29qFi6Nq1qy1dujSi9YolgUAAX2UTghhw6qmnkp+fz2uvvYa3ErdW4q1+VaX61Z0lS5bQrVu3iJ0v0RcUC9cvQcV7/Sr6PjvnvjCzX0fq9WJlnopmhPo+BIC/OOc8ZhYsLksD9gBzCbVE1KRc4kTz5s1p3rx5pRIKEYk9f/rTn1i3bt0hy6dPnx4ekSKJo86TCudcT6A3MNnM8p1zqcAfgIuATcAq4FLg9eKnXAb83cy2O+dm16S8tusm1XeoeSrK9lrXPBUSN3L98PUoDvobd2qZO7HdM2NqEb5IefPNN6MdgkRBNFoqjgZuBW5xzv2dUB+IS8xsHYBz7lzgweJJrI4CtgMjAMxsX03KJXb5/X4lC5JY0vyQ5o/75nORqqjzpMLMPiA08dWhyn8ArqutchEREakdWk1GREREIkJJhYiIiESEkgqpNL/fj3Ouwi2W+kbEY8wiIvFKSYVUWjwu+hWPMUti2J/Q7p/MTQmt1AdKKqTa4nHRr3iMWeLT/oR2x44dSmil3lBSIdUSj4t+xWPMIiLxREmFVEs8LvoVyZhLrp92uE0klsXLtVtZZsbWrWXXlKz8cxctWsTGjRsjHFXkFBUVsWXLlmiHcVhKKqRafD4fSUmhr4/H44mZdRsOJx5jFqktCxcu5LzzzqNPnz7RDiUi1q5dy0MPPUSDBlWffmnt2rXccsst9OjRg8WLF9dCdJGRlJTE+++/z9y5sbvqhJIKqRav10taWhodO3YkKysrLtboiGTMZqW33r1DW9n9IrGqR48eDBw4MNphRMTmzZsZNGgQt956a3ip9Kpo164dt956a+QDqwVXX301H374IZ999lm0QymXkgqptLLDMxcuXEheXh7p6ekx25u91mLO9YfWcCjexvTxcu7R95AzyltqP7lVPK8krFjsJLy/5S7eXXnlldx44400adKk2ueIp/dixIgR/OUvfyE/Pz/aoRwkVlYplTgQj+tz1FrMxes6AOTkwJlX76PQHEc0gqyPkomDhhupQ/s7CRcVFZGRkVGnrXtr1qxh4sSJtG7dmvnz53PCCScwevRokpOTDzp2+/bt3H333fTs2ZO1a9eybt06nn32WZKTk8nPz+f+++8nPT2d7OxsVq9ezdtvvw3AyJEj6dKlCxs2bGDcuHH88MMPlYpt6tSpbNiwgebNmzN27FimTZtGjx49uPDCC0lLS6N58+bs2LGDBx98kEsuuYTp06cfdI4FCxYwf/583nvvvfC+6dOn849//INevXqxcOFC3nnnHebPn0+LFi0YP348BQUFfPLJJ/Tr16/chQwra/78+cycOZNWrVrxwQcfcM0113DNNdcA8J///Ifp06fTsWNHPv/8c5o3b85DDz1Eo0aNmDp1Kv/4xz+48soref311/nyyy+ZMWMGL7/8Mnv27OHUU09l5MiRjB8/Pny+ko488kg6d+7MhAkTuPfee6sdf60oO7ypvm5dunSxRDZ37txoh1Crolm/0fd+Z8muwMAsOSloo+/9LuKvoc+v7ixevDii59uxY4eNHj3aAAMsOTnZRo8eHdHXOJRt27bZSSedZOvWrTMzs2+//daSkpLsP//5j5mZ/f3vf7fQr4GQ0aNHW8+ePcOPW7dube+8846ZmT311FN2ww03hMv+9re/mZlZTk6OdevW7aD9ldGyZUvbsGGDmZnNnz/f/u///s/MzN57773wMddff72lpqaGjyvrrrvustNOO63Uvp9//tlatWplGRkZtnHjRps8ebJt377dBgwYYFu2bDEzsy+++MIAmzZtmpmZ5eXlGXDQd3HHjh3lvm52dradeeaZVlhYaGZmzz//vB155JFWWFhoixcvtrZt21p+fr6ZmRUVFVnv3r1twIABVlRUZBs3bjTABg4caJs3b7ZJkybZnj177IILLrAOHTrYN998Y++8885hv4t+v9+6d+9+yPL9Kvo+Awssgr9L46e9RySW+P3hIR6+j6/A0zBIclIBngYF+D6+4sDwjzhr2ZHaEa1OwlOmTOGEE06gTZs2AHTt2pVNmzbx29/+ttzjBw0axKuvvkphYSEffvghRUVF4dEUnTp14vnnn+fhhx9m7969DBkyBIDWrVuzZs0arr76ajZs2BDeXxmdOnXiggsuYOHChaSnp3PKKacAcP755wMwc+ZMJk+ezKRJk2jdunW551i1ahUtW7YstS8lJYUmTZpwxhlnkJqayp///GdWrlxJbm4ukyZNYuzYscyaNYuzzz6bDRs2VDrekh5++GEuvPDC8Of617/+lTVr1pCUlMSECRPo3r17uH+Hc45bbrmFd999l+XLl5OamgpARkYGrVq1YtCgQTRq1IhWrVrRoUMHTjrpJAYMGEC3bt0O+fotW7Zk8eLFFBYWViv+2qKkQqQ6/P5wb0zvP5/g/TvPY9SlmWTd1x/vP5840FNTSYUQvY7N3377La7M2Oayv4DLls2ePZsxY8bQtWtXjjzySKy4x/F5553HxIkTeeihh+jWrVt4BEJqaiqzZs0iOzs73CRfWTNmzKBJkyacdtppDBkyhD179oTLtm3bxqBBg7j22mu56KKLDnmO/Pz8Q474KFn3FStWkJqayvDhwxk+fDj33HMPc+bMYejQoZWOt6Ty3tsWLVoA8P3337Nz585SZV26dAFg9erV5cZ3uH3lOeKIIzAzJRUiiaDUfBStvbz2j4GctvcLJr98Ja61V/NUyEGaN29O+/bt63SkVNu2bZk/f36pX3BmxrJly8o9ftiwYcyZM4f77ruPY489tlRZXl4egwYNYuXKlfh8Pvr378+aNWtYv349PXv2ZPHixWRmZnLnnXfyxhtvVCq+PXv28NFHHzFjxgzeeecdhg0bFi4bOnQoDRs25KmnngJg79695f4CPfbYYys1N0Xr1q35+uuv2bRpU6n98+bNq1SsZbVt25YPPvig1L6tW7eyadMmOnXqxLJlyygoKAiX7d69Gwi1FkXC9u3badu2LR6PJyLnixQlFSI1dDo5jF9xK2e/k8X4FbdyOrHTu1/qt//6r/9i586dXHTRRXz++ecsXbqUESNG0KpVK4DwZHD7WyNmz54dvje+bNkyNm3axNatWykoKGDq1KmsWbOG1NRUXnzxRRo3bszPP//M8uXLefvtt2nUqBHDhg2jX79+lR6VMHbsWAAGDBjAnXfeGX7eP//5T15//XWmTJkSvoXw5ptvsnfv3oPOkZGRQV5e3kH799djP6/Xy9FHH82AAQNYsGABGzZsYPz48Sxfvrzc96KwsJChQ4fyySeflBv7tddey5w5c7j11ltZvHgxn3/+OU888QSpqanccsst7NmzhylTpoSPf/fdd7n22ms59thjw69RMr7yYoZQy8Z1113H2rVrS+3/4YcfSE9PLze2qIpkB4143tRRM77Vef0WZZq9Rmi7DLOk4hseScWP95ctyozIy+nzqzu10VHTzKx3797Wu3fviJ67Mv79739bWlqaNW7c2Hw+n3399ddmZvbVV19Z3759DbBnnnnGduzYYRMmTLCmTZtaWlqaTZw40f785z9b+/bt7cMPP7TMzEw75ZRT7LnnnrPRo0fbk08+aWZmM2fOtJYtW9qjjz5qzz77rN144422d+/eSsWWlJRkt99+u02ZMsX++te/2nfffWdbt2611NRU69q1qz366KP2yCOP2B133GEnnnhiuefYvXu3/fKXv7RFixaF97300kvWsGFD+81vfmOBQCC8/6uvvrIzzzzTjjzySDv++OPDnUrXrVtnt956qwF2ww032HfffWc7duywDh06HLJTbVFRkT366KPWoUMHa9asmV199dW2ffv2cPkXX3xh5557ro0cOdIefPBBu+OOO+znn3+23bt32xNPPGGA9e/f3/73f//XzMwCgYB17tzZWrRoYdOnT7c9e/aYmdmnn35qbdq0sfnz55d6/e7du9snn3xS4Xtc1x01o/7LPFY2JRXxLar1y842S0oKXU4pKaHHEabPr+4kWlJR2w41OqIuzZ4926677rpaOXcs1K+s2bNn29ChQyt1bF0nFZqnQqSmvF5IS4P8fHjtNTRJhQj86U9/Yt26dYcsnz59enhUSk317duXVatWMWXKFK677rqInDNWLVu2jDlz5jBu3Lhoh1IuJRUi1eH3Q3mT5pS9x5mZqREg9ZTf7y93YqWyvfszMzPjblK5ynjzzTfr9PWGDBnCl19+yXfffcdxxx1Xp69dV4qKisjLy+ORRx6JdiiHpKRCpDr8fiULclj7Z3PduXMnTZs2jXY49ULPnj2jHUKtSkpK4txzz412GIel0R8iIiISEUoqREREJCKUVIiIiEhEqE+FiEgtONAf8/D9KcwOWywSV9RSISIiIhGhpEJEpBZY8ZpyO3bsxAx69w5t+/fv30QSiZIKERERiQglFSIiIhIRSipEREQkIjT6Q0RE4tYnn3xCdnY2X331Fd988w2zZs3iX//6F2vWrCElJYVFixYxfPhwTj311PBzZs+ezXvvvUdaWhrZ2dlcccUVnHPOOVGsReJQS4VINfj9fpxzFW6JuKaDVE9+PqxeDTk50Y4k9lV2bYudO3dy0UUX8cc//pGXX36Zq6++mlmzZvHGG2/wwAMPMGLECO655x7OOussfvjhBwDmzZvHVVddxYMPPshf//pXHn/8ca6++mq++eab2qxSvaGkQqQa/H5/qeV+e/fuTe/evQ9aBlhJhUAokcjNhbw8yMhQYnE4Y8eOZeLEiZU69uuvv2bbtm00aNCA5ORkhg0bxlNPPUV6iYX9evToQbt27XjyySeB0LXbp08fmjVrBkCLFi3o27cvY8aMiXxl6iElFSIRkJ+fz+rVq8nRbwspRyAARUWhfweDocd1ady4cTz//PNMnDiRNm3asH37ds444wweeOABHnvsMW6++Wacc9xxxx1AaDXMJ598kocffpj77ruPs88+m5UrVwJQWFjIuHHjePTRR3n00Ue5+OKLmTZtGgCrV6+mT58+4VVCv//+ewYOHBhemXXt2rUMGzaMbt268eGHH3LWWWfRsmVLnnjiCQBWrVrF7Nmzyc/P58EHH2TevHkAjBw5kldeeYXHHnuMY445BoA5c+bwwgsvADBhwgQefPBBdu/ezbfffkvjxo1L1f/444/nk08+oaCggHnz5vGrX/2qVPkpp5zCzJkzI/2210vqU5GIcv3wdekll30AU8sc1z0T0vx1EVFCy8nJITc3l6KiIjIyMsjKysLr9UY7LIkhPh8kJYUSC48n9Liu7NixA7/fz+bNm2nQoAFHHXUUACNGjOD888/HzOjbty8nnngiDzzwAAC33HIL3bp147bbbgOgV69ePP7440ycOJFRo0axbt06nn/+eQAyMjL43e9+R3JyMpdeeim9e/cmLy8PgA4dOtC3b1+mTg3959OuXTs6derEsmXLKCws5KOPPuLxxx9nxIgR3HjjjRx//PGceeaZrFq1ivvuuw+Ar776irfeeovFixcDhBOGvn370rBhQyZPnszQoUPDiUzr1q3Dx+7XokULvv32W7Zs2cLevXtp2bJlqfKWLVuyfft28vPzad68eSTf/npHLRWJKM0PV9qBrUUPdie3gb7ZpfcroYiIQCBAUfGfocFgkEBd/xkqMc/rhbQ06NgRsrJCj+tKSkoKTZo0YcCAAaxatYorrriC5s2bc/755wMwceJEPv74Y1555RVSUlLYvHkzzzzzDFdccUX4HLNnz+bJJ5/EzHjyySfp06dPuKxz587079+fxx9/vNLxFBUVhZfwPvXUU9m7dy8bNmwo9/ijjz6aNWvWcPXVV7NhwwaGDBly2PMPHjyYt956i//93/8FYNOmTSxYsIDWrVvTqFEjABo2bFjqOfuvX9NsZDWmpCLRbcqBbbkcUbgePsoIPZaI8vl8JCWFLiWPx4OvLv8MlbjRvDm0b1+3CQWEfoHOmTOH9evX061bN0aOHBn+Jbpy5Uruvvtu7r33Xn79618DsGLFCgoLC8O3LCDUOtCoUSO2bNnCrl272LlzZ6nX6NKlC6tXr65WfPuvnf0xldW6dWtmzZpFdnY2nTt3ZsKECYc93913380jjzzC3XffzeDBg5k6dSr5+fn06tWLFi1a0KRJE7Zt21bqOVu2bKFZs2bhVhypPiUViW5jACjCARQFix9LJHm9XtLS0ujYsaNufUjM2bVrF6mpqXzxxRdMmjSJp59+mkcffZSioiKuu+46unXrFr7V8PPPP9O2bVsAPvjgg1LnWbp0Kb/4xS846qijDhopsXv3brp27Vru69f0r/9169bRs2dPFi9eTGZmJnfeeSdvvPHGIY93znHTTTfx0UcfMWnSJDp06MCmTZsYPHgwAOedd95Bt0dyc3Pp379/jeKUECUVia61D0jCAJI8xY8l0po3b0779u2VUEjM2bx5M88//zxJSUlce+21XHfddeTn5zNu3DgWLFjAyy+/TIMGoe51r776Kh06dMDn83HzzTfz+uuvk5eXx8svv8ySJUsAGD58OC+99BJbtmwBYN++fcyaNSucmKSmprJhwwZ++OEH9uzZw6effgoQbt0o2yJRWFgIHEg+mjRpwtatW9m3bx8//vgjS5cu5e2336ZRo0YMGzaMfv36kZ+fX+q5+3+W9f333zN48GDGjx/P8ccfD8DNN9/MzJkzw/Hk5+fz4YcfcvPNN9f0rRbUUTPxpXqhRRp7dqwn5ax/hh5Ljfn9fkaNGnXQ/pJNxgCZmZkaVipR98ADD7B3717at2/Pnj17uPbaa+nVqxc9evRg5syZvPvuu/zwww/k5uYyePBg3njjDW688UZuuOEGWrRowYgRI7jooosAuOuuu0hJSeEvf/kLXq+XVatW8fDDD4f7WVx11VW8+eabpKWl0bdvXy644AK+//573nzzTfr378+7774LwOTJk7n00kt55ZVXAHjllVcYPnw4F110EePHj8fn85GZmUnDhg0ZOnQoa9eupWnTprRv354///nPfPvtt7z66qsAPPvss/z5z3/mpJNOCtf53Xff5f777+eZZ57h0ksvDe/v1asXzz33HLfffjs9e/ZkwYIFPP/88/qDIEKcOqaEdO3a1ZYuXRrtMGrHhz62b9/OUX9cGO1Iak0gEEjovgyqX91ZsmQJ3bp1q/F5yuSXhxTv/wXv3LmTpk2bRjuMsP2zarZr144BAwYcNLy0qmKtflVV0ffZOfeFmf06Uq+nlooEdPB/ZoFyj7NFfo0AEZGEcvLJJ3PyySdHO4x6K6pJhXOuO5BtZs2KHzcAMoEdwD6gOzDczDZFolzKUEIhUmv2t0DE+1+6IlURtY6azrnWwCNAyavtaeCXZvaomT0JzAPejmB5vWCZfgxX4Ybu9YuISARFJalwzjUChgNPldjXHhgMTC9x6BvAb51zZ9e0vHZqEqP8/tCfScXbqUcu5biGa8jJtlL7lVTEKL8/dA+rxObr0+egffr8RCTWRKulwk+olWJPiX29CcWzaP8OM9sNrATOj0B5vZSTA1//dDyrC9qS0adQCxnFATfKX6pNyUs29zAaL9ml9iupqD3qwC6JIBrf4zpPKpxztwLTzGx9maJ2xT+3ltm/FTguAuX1UuDl7zHASCa4t4jAy99HOySpgtPJIYsMHmAkWWRwOsoKa1vDhg3ZvXt3tMMQqbHdu3cfNCV5bavTjprOuYuB783s/8op3lv8s6DM/iTARaC8vHgGE7plQmpqakKu2dB5bQ4ebiGI4aGAzmunEggk3njsXbt2JcznN3fugX+3f+01vnjhVOZxJme6T3jtL5NZPTD0VU+Q6gKx9fklJyfz008/0a5dOzwez0Fzj1RVYWHhQdNaJxLVL/aYGcFgkLVr17Jjxw5++OGHOnvtuh79cSPQq8RFmgTgnNsD7J9mrQWwucRzWgGfA2tqWH4QM5sETILQPBWxMk6+pkr+H3g6jZhJf+ZzBmcwnxHvjuGzd0NJRSK18MbSPAc1lusPrzKbY6dzLlkE8eCxIFmWge/H4sWcEmiV2Vj7/Hbs2MHGjRspKCj7N0rV7dmzhyOOOCICUcUm1S82NWzYkI4dO9KsWbM6fd06TSrMrFSHSeecD5hrZkc451oA64CTgE+Ky5sSunXxPqHEYG8Nyuulz/AygjH4CDCCMXxG4rVSJJw0fzhZCHwPeyjCSCKYlEzghBy8V0Y1unqhWbNmEfvPOBAIcOqpp0bkXLFI9ZOSYmbtDzPbBrwEDCyx+2JgGTCnpuW1GHrMKTukNId0xjCCHNI1pDTO+HyQnFRIkivE4ykihv6YFxE5SMwkFcVuBnY65zKdc7cDZwP9zKwoQuX1Q5khpZgRmDv3oH1KKmJUiSGl3mscnww/kwf/eB9Zt/fCe42GlIpI7IrqjJpmFqBEJ0oz2wvccZjja1QuEg/cKD+hUdcw/KQxPHDiSLwnf0ZBYTL3nDSasSvuAcD80YpQRKR8WvtDJIYFFvsI7vNgBCnY5yGw2BftkEREDinWbn+I1Hsl71DlLPfSuE1X9nlSaXxBFjnLveEyEZFYo5YKkViT6w8PKd0vBWBOeunjEmhIqYgkBrVUJCC/349zrtTWp0+fg/b51dEvNqX54UortQV+OfegfUooRCTWKKlIQH6/HzMLbz169KBNmzZkZ2eX2q+kQkREIklJRYLLyckhNzeX9evXk5GRQY5WFBMRkVqipCLBBQIBiopC03QEg8GYWV9BREQSj5KKBOfz+UhKCn3MHo8nptZXEBGRxKKkIsF5vV7S0tJo06YNWVlZeL1a+0NERGqHhpTWA82bN8fMlFCIiEitUktFAio7pPTjjz9m0aJFGlIqIiK1SklFAio7pNTMmDt37kH7lFSIiEgkKakQERGRiFBSISIiIhGhpEJEREQiQkmFSIzR2i0iEq+UVIjEGK3dIiLxSkmFSAzT2i0iEk+UVIjEMK3dIiLxREmFSAzT2i0iEk+UVIjEMK3dIiLxREmFSIwpO/pj4cKFrF+/nvT0dI3+EJGYpqRCJMZomnURiVdKKkRERCQilFSIiIhIRCipEBERkYhQUiEiIiIRoaRCREREIkJJhYiIiESEkgoRERGJCCUVIiIiEhFKKkTqC78fnKt406RaIlJNDaIdgIjUDTfKD/jDj08nBx8BAvj4jANripi/7DNFRCpHSYVIPXQ6OWSRgYcgQTxkkFUqsRARqQ7d/hCpJ8wObDmjA3zJqTzKnSxK6knO6EC4TESkutRSIVIP5bS6gHO4hSAePEVBslqtVDuFiNSYWipE6otcP0x1MNURyJpK0HkopAFB15BA1tRwGbn+6MYpInFLLRUi9cU/gVGhf/oI4HFBghgeCvBNC8C04uMygbTohCgi8U1JhUg9UXL0x+mdcph5WX+yl59Beuf53D7tCT5bEboBotEfIlJdSipE6iHfSQF+f+I8+pz8MQWFyfhOCoSTChGR6lJSIVJPlBrZsckHc0I7Gno8jHnBx5jUqIQlIglESYVIfZTqhRZpEMyH9NdCj0VEaigqSYVzrg3wFPA74AjgGbPQnVznXBPgQWAF0AQ4FrjLzH6KRLlIvZXrh69HHbx/Tnrpx90zIc1fBwGJSKKp86TCOeeAu4BhZrbGOfd7IOCc+8TMPiLUBz3HzCYUHz8KmAQMLD5FTctF6qc0v5IFEalV0Zin4ijgQTNbA2BmnwJbAHPO9QLOA6aXOP4V4ArnXNealtdWhURERCQKLRVmtq3kY+dcX+BlM5vrnBsJBM1sSYnjVzjngkA/oFkNy5fWZt1ERETqs6jNqOmc6+KcmwC8B5zonPsF0A7YVs7hW4HjIlAuIiIitcRZlFYQKu5b0RToAzxHKLn4CbjEzI4tc+w64B+Aq0m5md1aZv9gYDBAamrqadOmTSNR7dq1iyZNmkQ7jFqj+sW3RK5fItcNVL9416dPny/M7NeROl/UhpRaKJvZAfzLOdcauAWYQqjPRVktge+B5BqWl41hEqFOnHTt2tV8Pl+V6hBPAoEAql/8Uv3iVyLXDVQ/KS1WFhTbQOiX/vtAE+dc+/0FzrkTAU9xWU3LRUREpJbUeVLhnGvqnLvCOZdS/NgBfwQeMLPFwGxKD/+8DPjAzJbWtLz2aiUiIiLRuP3RFhgDPOyc+zuhTpTjzOzL4vLLi8vuJtRH4ljgyhLPr2m5iIiI1ILDJhXOuduA/wMWmtn2SLygmS0DOh6mfDswpLbKReorv9/PqFHlzKhZRmZmJn6/v/YDEpGEU9Htj8eBLGCLcy7POfdP59z9zrkBzrlj6iA+EYkQv9+PmYW3Hj160LFjR7Kzs0vtV0IhItVV0e2PtsCpxVuP4p8XErqtYM65rcBCDrRmTK21SEUkYnJycsjNzaWoqIiMjAyysrLwerWomIjUzGGTCjPbAPy7eAPCC3b14ECS0YPQcNBkQEmFSBwIBAIUFRUBEAwGCQQCSipEpMaq3FHTzHYB85xz24DmwK+AhsCeCMcmIrXE5/ORlJREUVERHo9H4/BFJCKqNKTUOZfunHvEObcMyAVuBxYDfwJSayE+EakFXq+XtLQ0OnbsqFsfIhIxh00qnHMe51x/59yk4qmu51E87wNwNtDazK4xs7fM7Kc6iFdEqsnv9+OcC28LFy4kLy+P9PT0UvvVUVNEqqui2x+bgCbAIuBZ4F9mtrC2gxKRyPP7/UoYRKRWVZRUNAX2ElqjowXwK+dcEbDYzPbVdnAiIiISPypKKgZxYITH9YRaLQwocM4toXgo6f7NzHbUVqAiIiIS2yoaUvpiycfOuc6UHk7aD7hu/+GEhpWKiIhIPVSlIaVmthxYDry5f1/xsuU9CQ0tFRERkXqqxguKmdlGykyQJSIiIvVPnS99LiIiIolJSYWIiIhEhJIKEakZvx+cq3jTHBkiCU9JhYjUjN8PZge2Hj2gY0fIzi69X0mFSMJTUiEikZOTA7m5kJcHGRmhxyJSbyipEJEaKXmH4570APuKHAAFu4Pckx4Il4lI4qvxkFIRkf0C+AjiwQhSgIcAvmiHJCJ1SC0VIlIjlunHcBiOHNJZxK94jDtZxK/IIT1cpj4VIolPLRUiUjOXAF1C/8xZfjoZo7MI7vPgaRAka0QG3s6fhQq7Ry1CEakjSipEpGbS/KENCIyBPcEijCSChckEPDl4r4xqdCJSh3T7Q0RqpGRHzdf+9hVHNNxDclIBnqTdvPa3r9RRU6QeUUuFiETMgNPeo/+vZjJv6e/p1fVT3l90Pt+sPSXaYYlIHVFSISI1YlbiwSYfzLmP3584H5JT+P1NjzImNVqRiUhdU1IhIpGT6oUWaRDMh/TXQo9FpN5QUiEiNZPrh69HHbx/Tnrpx90zwx06RSQxKakQkZopMfpDROo3jf4QERGRiFBSISIiIhGhpEJEREQiQkmFiIiIRISSChEREYkIJRXRlOuHqa7iLdcf3ThFDsPv9+Ocq3Dza5VSkYSnIaXRVHYo3genatIgiTt+vz+cMOTk5NCrVy+KiopISUkhKysLr1ffZZH6Qi0V0eT3H1iJqbOD9QthRx68lx56vL9Mf+FJnAgEAhQVFQEQDAYJBALRDUhE6pSSimjy+0MLJ5jBU/8dajdKJvTzqf8+UKakQuKEz+cjKSn034rH48Hn80U3IBGpU0oqoqjkktHP3Ay2DygM/XzmZrRktMQdr9dLWloaHTt21K0PkXpISUWMeHnFNewd7aFwumPvaA8vr7jmQGGuP1phiVSobEfNhQsXkpeXR3p6ujpqitQz6qgZRaWWjMbLJSlvY3n7uGtiR3IGn1KizF+3gYlUQcmOmiJSv6mlIppKdNTMcV7+vcfHu4X9yRhyAjnOq46aIiISV5RURFOJjpqB0TnspjGFNCCY3JjA6Bx11BQRkbgSldsfzrluwHjgd8Au4HXgHjMrcM41AR4EVgBNgGOBu8zsp+Ln1qg8lhyqE2ZhIYwYEdqg7G0SERGR2FTnLRXOuebA/xRvvwdeAYYB9xYfMg3YYmYTzGwssBmYVOIUNS0XERGRWhCN2x/nA7ea2TwzyzWz4UA2kOGc6wWcB0wvcfwrwBXOua41La/FOlXL/rsbFW0iIiLxoM5vf5jZ1HJ2/wj8BPQBgma2pMTxK5xzQaAf0KyG5Utro04iIiICzqL8p7BzLglYBlwK3ABcZGZtyhyzltBtjZSalJvZbWX2DwYGA6Smpp42bdq0SFatQlOmTOGll16q8Lhrr72W6667rkavtWvXLpo0aVKjc8Qy1S++JXL9ErluoPrFuz59+nxhZr+O1PliYZ6KwcA4M1vknNsLFJRzTBLggJqWl2Jmkyjub9G1a1er6ymFfT4fU6ZMAWp/IaZAIJDQUyarfvEtkeuXyHUD1U9Ki+qQUufcmcARZjaheNca4KhyDm0JfB+B8pilhZhERCTeRS2pKO5U2dXMxpXYPQdo4pxrX+K4EwEP8H7xVpPymKWFmEQOVnJ9HOfA63K4x43B63JK7ddcLiKxIVrzVJwF9AVeKv6lD3AyoVsUs4GBwJji/ZcBH5jZ0uLn1qg8Vu1fiCk/P5/XXntNCzGJlHE6OWSRgYcgQTxkkMVnFF8nSipEYkI05qk4C3gPGA4sKbG9QKg14XLgOOfc3c654YQmr7qyxClqWh4ztBCTyOGVHFqdMzrAl5zKo9zJoqSe5IwOaNi1SIyJxpDSj4DGhznkZ2DIYZ6/vSblsUQLMYlUINcPX48CIGfl6ZzjsgiaB48FyVqZgXdq8bSz3TMhzR+tKEWkWCyM/hARKd8/gVBOQaCljyCe0Po4zgi87cP74mehwkwgLVpBish+WlBMRGKWG+XHYTiMJSd1w9MwSHJSAZ4GBSw5qVu4TH0qRGKDWipEJC4sX9+ZmXf0Z/7yMzij83xGTBtT8ZNEpE4pqRCRmFW6E6YXPsinz29fh/TXyHlII6REYo2SChGJXbn+cEfNUuakl36sjpoiMUFJhYjErjS/kgWROKKOmiIiIhIRSipEREQkIpRUiIiISEQoqRCRmFV2KvtDbZqZViQ2KKkQkZjl9/sxM8yM7Ozs8Eq+KSkpZGdnh8uUVIjEBiUVIhIXAoEARUVFAASDQQKBQHQDEpGDKKkQkbjg8/nCLRUejwefzxfdgETkIEoqRCRmlexTkZ6eHm6p2L17N+np6epTIRJjNPmViMQsv9+vhEEkjqilQkRERCJCSYWIiIhEhJIKERERiQglFSIiIhIRSipEREQkIpRUiIiISEQoqRAREZGIUFIhIvWP3w/OVbxpjgyRKlFSISL1jhvlx2E4DC/Z/EwK+0jmZ1Lwkh0uU1IhUjVKKkSkXvMR4At68ih38gU98RGIdkgicUvTdItIvWN24N85ky4gY8gtBPHgIUjWcysZMzh6sYnEM7VUiEj987QPpjqY6ghkTSXoPBTSgKBrSCBrariMp33RjlQkrqilQkTqHXdzIPzvk9t9hadBkGCh4Uku4LX5VzJi2higdIuGiFRMSYWI1GsDTnuP/r+aybylv6dX1095f9H5fLP2lGiHJRKXlFSISL1TqgVikw/m3MfvT5wPySn8/qZHGZMarchE4puSChGpf3L98PWog/cX7oY56Qced8+ENH8dBSUS/5RUiEj9k+ZXsiBSCzT6Q0RERCJCSYWI1Dt+vx/nXIWbXzNqilSJkgoRqXf8fj9mhpmRnZ1NUlLov8KUlBSys7PDZUoqRKpGSYWI1GuBQICioiIAgsEggUAgugGJxDElFSJSr/l8vnBLhcfjwefzRTcgkTimpEJE6p2SfSrS09PDLRW7d+8mPT1dfSpEqklDSkWk3vH7/UoYRGqBWipERCLF7wfnSm2+Pn0O2ocSGklQSipERCLF7w/NAW4G2dmQlIQBpKSEHu8vU1IhCSrqSYVzrm20YxARibhAAIqKcADBYOixSIKLWp8K51w6MBw4BuhZYn8T4EFgBdAEOBa4y8x+ikS5iEid8PlCLRVFRTiPJ/RYJMFFpaXCOdcUWEkoqSkbwzRgi5lNMLOxwGZgUgTLRURqR8k+FenpB1oqdu8OPVafCklwUUkqzGynmW0ANpbc75zrBZwHTC+x+xXgCudc15qW10JVRETC3Cg/DqtwU1IhiSrWhpT2AYJmtmT/DjNb4ZwLAv2AZjUsX1pH9RAREal3Yi2paAdsK2f/VuA4IKWG5aU45wYDgwFSU1MTenreXbt2qX5xTPWLD3n/msJxu14CYMy/hjNy+gMUFjUgOamAB/54P/dcOBaA7965lu+aXRfFSCMnUT67Q0n0+kVarCUVe4GCcvYnAS4C5aWY2SSK+1t07drVEnl63kAgkNDTD6t+8S1R6uecD5gCwMntvsKTHCSI4Uku4LX5VzJi2hggNKr0uCjFGGmJ8tkdSqLXL9JiLalYAxxVzv6WwPdAcg3LRUTqxIDT3qP/r2Yyb+nv6dX1U95fdD7frD0l2mGJ1KpYSyreBx51zrU3s9UAzrkTAU9xWXINy0VEao0t8sPXo0rt+/2J88M/x1w+IrQzNxPS/HUbnEgdiHZSkVzygZktds7NBgYCY4p3XwZ8YGZLAWpaLiJSa9L8pZOFTTms+mwyx59+PaR6oxWVSJ2J1jwVKc65PwEZQGfn3EDnXOvi4suB45xzdzvnhhOavOrKEk+vabmISK0oufqpcw7XOp0T/vACrnV6qf1azEwSVVRaKsxsN/Bm8Va2bDsw5DDPrVG5iEhtKbn6aU5ODr169aKoqIiUlBSysrLwetVaIYkt6mt/iIgkokAgQFFREQDBYFDDEqVeUFIhIlILfD4fSUmh/2I9Ho+GJUq9oKRCRCRCSvapSE9PD7dU7N69m/T0dPWpkISnpEJEJEL8fj9mVmqbO3fuQfuUVEiiUlIhIiIiEaGkQkQkHuXkwJgxoZ8iMUJJhYhIPPD7wbkDW3o6jBgR+llyv26tSBQpqRARiQNulB+H4TDuYTSfcgZjGM6nnME9jA6XKamQaIr2NN0iIlJF73IB490tBM2DxwU53lYeKMz1a10RiRq1VIiIxAHL9Be3RTgGtpxKEA+FNCDoGjKw5dRwGf+MdqRSnympEBGJAyVvfyw5qRuehkGSkwrwNChgyUnddPtDYoKSChGROLN8fWdm3tEf/6V+Zt7Rn+XrOx8ozPVHKywRJRUiIvEgM9MPOMDx2Yp0bnrpYz78ejQ3vfQxn61ID5f5dftDokhJhYhIHCg5W2d2djZL1iXx8RJYtTWF7OxszdYpMUFJhYhInNEKqBKrlFSIiMSBkouVjRgxIry/sLCQESNGaLEyiQlKKkRE4kDZxcqys7MZPXp0qVsfEbn9oem/pQY0+ZWISBzyer14vd6an8jvh1GjKj4uM1PDVaVCaqmoQMkp9Q+3iYjEo7LTf+8jGYACkjX9t1SZWipERASAAD7mtUtnfrNenLFjHoG1vmiHJHFGSYWISD1mT/mg1ccA5Cw/nYzRWQTXefA0CJLlz8Db+bPQgU/3hpsCUYtT4oOSChGReszdHAj/u3e3AMF9HgqLGhDcZ9zzjzF8vMQHgFl04pP4oj4VFTArvWVnw+jRoZ8l94uIxLvNO1rRICmIo4AGSQVs3tHqQGGuP1phSRxRUlFFXi/cc0/op4hIvCs5/fc3a9MI7svAuJ/gvgy+WZuGpv+WqlBSISJSj5Wc/2L06NEYnwFjSUr+39BjTf8tVaCkQkSkHtNMnRJJSipEROoxzdQpkaSkQkREwrxeL/fcc0+NZ+ssOTmg1+UQ+NPdPPTKTgJ/uhuvyzkwcaBaQBKKhpRWVU4OBALg86m3pohIJfRq9yn9N/47NP9FcpAb203gs7XF/39eEt3YJLLUUlERv790yn1NOnw2IvSz5H5l2yIi5VrWrAt7i+e/2LuvIcuadTlQqFElCUUtFRVpFYDXiv/9CfA7Qu/aPuA/wJnFZVsCdR2ZiEhc+GoTFFkQMIqsgK82HSjzbwjgj1ZgEnFqqajITQG40kLbhf9NTh6MeQ9y8oAL//tAmaavFREJKzk54KDblwAZwP0kJfVl0O1LwmX+ZwJRjlQiSUlFBfw3+MJDqroPepaMsTByOmSMhe6Dnj0w3OoGX7RDFRGJGQcPVQ3Nf1FUlB35oaoaWRIzlFRUwP9MIDykauCNo9lTAIVFECxKYuCNJSaGUbYtIhJWm0NVNbIkdimpqEDZbHv/Mh+FhUWaGEZEpJIiNVS1rF7tPqXfhn8zcsn/0G/Dv+nV7tMDhRpZUueUVFSgziaGERGRKvtPg7bs3efBCI0s+U+DtuEyf4kVWKVuaPRHFXm93ohn2iIiUnm2yA9fjwLghhdP59PvLwUMKODkEybyyehrQgd2z6zZC+Xk0P6116BRI81LVElqqRARkbji/ye4gaHt2Y8+wxWPLHFkhB4Xl1V1ZdXy+mq8Pj9VfTWqQC0VIiISV/x+f6lbzjk5OQQCAXy+JyLWkry/r0ZwrQdPgyA3aRbQSlFSISIica02bkvv76sBDdi7z0r31bh7Cv4P/NU+d86EGQRmb8V3Tku8Qy+qcayxRLc/REREgMxMP+AAx9KtE4EgUAAUFD8OlfG766p03pK3Vf5wzAz63HYO9757DX1uO4c/HDMjoW6rKKkQERGh9Gi/GbOewOM5D+cy8XjOY8asJyIy2q+wwY+lRqsUNvjxwOv/Z0qN65AzYQZj/jCZnAkzanyu6kjI2x/OuSbAg8AKoAlwLHCXmf0U1cBERCQueL1eAoGxTJ48meuvHxux2yurtq4m1AISGq0SelzsuOOqfD7nDvx7QLsZzN5wDsF9HjwfBDln7AzeXXsREJoSvS4kZFIBTANyzGwCgHNuFDAJGBjVqEREJG54vV727t1b44Si5C/0nJwL8fU+l4J9vWjYYB6TZz1SYrRqoEavs78VZH8/kFKtIN6j8Odsr9H5KyPhbn8453oB5wHTS+x+BbjCOdc1OlGJiIgUt4B8/AgPPdSMwMePRLSD6YFWkFA/kFKtID16ROx1DicRWyr6AEEzW7J/h5mtcM4FgX7A0qhFJiIi9V4kR6vUVStIZTmrqxstdcQ59yxwkZm1KbN/LTDNzG4rsW8wMBggNTX1tGnTptVprHVp165dNGnSJNph1BrVL74lcv0SuW6g+sWab775hoULF9KjRw9OPvnkCo/v06fPF2b260i9fiK2VOwl1PZTVhKh8UBhZjaJUF8Lunbtaj6fr9aDi5bQxDC+aIdRa1S/+JbI9UvkuoHqF2uiHWvC9akA1gBHlbO/JfB93YYiIiJSfyRiUvE+0MQ5137/DufciYCnuExERERqQcIlFWa2GJhN6eGjlwEfmJk6aYqIiNSSROxTAXA58LBz7m5C/SiOBa6MbkgiIiKJLSGTCjPbDgyJdhwiIiL1ScLd/hAREZHoUFIhIiIiEaGkQkRERCJCSYWIiIhEhJIKERERiQglFSIiIhIRSipEREQkIpRUiIiISEQk3NLn1eWc2wkk8jTevwA2RzuIWqT6xbdErl8i1w1Uv3jX1cyaRupkCTmjZjUtjeSa8rHGObdA9Ytfql/8SuS6geoX75xzCyJ5Pt3+EBERkYhQUiEiIiIRoaTigEnRDqCWqX7xTfWLX4lcN1D94l1E66eOmiIiIhIRaqkQERGRiFBSIeVyzh0X7RiqK55jj4RYqr9zrm20Y6hNtVG/eP/8Yin+iiT65xcNCZtUOOeaOOfGOeeGOueGO+f+5pw7sjrHVuVcdaWK9evmnJvtnMt3zq11zj3mnGtY5pgxzjnbvwF31klFylHV9/twsTvn2jjnJjrn/ts5N6r42OQ6qcghVLZ+zrmmxZ+Zldn2OuealjguZj67EjGlO+feAWZWcFzcXXvFcVW2fnF17ZWIqVL1Kz42rq6/4rgqrF88Xn+V+b6VOLZ2rj0zS8gNeB8YWeLxKOC16hxblXPFWv2A5sCbQC8gDRgLGOAvcUwrYCrw6+LtNOCIWK9bRbEDDYFFwNUljn8JeChOPrvBwFXA8cBxxdv1wIxY/eyKY2oKHF1cz4U1eS9i9NqrVP3i8dqrxucXj9dfZT+/uLr+KvN9K3N8rVx7Uftga/nN7VX8ZnYrsa8TUEho9rBKH1uVc8Vo/a4E2pXZNx/4tMTjh4AXgbOBhvHy2VUUe/F/CAVAsxL7zgZ2Ai1ivX7AMeU8/2Xg8lj87MqJdUoF/2nH3bVXxfrF1bVX1fpVFH8sXn9V/Pzi6vqrzPetxP5au/YS9fZHHyBoZkv27zCzFUAQ6FfFY6tyrrpS6ZjMbKqZrS3z/B+BlSUedwZ+D8wBfnTOXVYrUVdOVd/vw8XeB8gzsx0l9n0FNAHOjHTglVSVz+6Hko+dc42BvsC7JXbH0mdXVfF47VVaHF571RFv11+lxdv1V8nv2361du0lalLRDthWzv6thJqwqnJsVc5VV6odk3MuCTgVeHL/PjO7zMy6AN2ABcDrzjlfhGKtqirVrYLY2xU/r+x5KO9cdaQm36cLgY/M7Of9O2Lss6uqeLz2qi0Orr0qi8Prrybi6vor7/tWQq1de4maVOwl1OxWVhLgqnhsVc5VV2oS02BgnJktKltgZt8C5wM5wKCaBllN1arbIWIv71z7v/Px+NldBbxeXkGMfHZVFY/XXk3E+rVXbXF0/dVEvF1/h/y+UYvXXqImFWuAo8rZ3xL4vorHVuVcdaVaMTnnziTUiWjCoY4xsyLgH8XnioZqv9/lxL4GaFHmsFbFP+Pts0sl1BFs1qGOiYHPrqri8dqrlji59mokTq6/aom3668S37dau/YSNal4H2jinGu/f4dz7kTAU1xWlWOrcq66UuWYnHO9CHWwGVdiX6NDnL8ZoXuf0VDT97tk7O8DJzjnPCXK04A9wNzIhFtl1a3f5cC/zKy8vx5KiuZnV1XxeO1VWRxde5EQ69dfdcXN9VfJ71utXXsJmVSY2WJgNjCwxO7LgA/MbKlz7mbn3I2VObai8tqsx6FUpX4AzrmzCDXNfeqcO7F4uxQY4Jzr6Zy7zTnXvPjYVOAPlH8frtZVpW6ViH02sAq4tMy5/m5m22u3JuWr6mdXwkDKNL3G2mdXjoPmI4j3a6+Mw9av+HHcXHvlOGz94vH6K6PCz6+EuLj+Kvi+1cm1l7BrfzjnjgIeJvSldsAJwJ1mtt05NwMoMrNLKjq2MuXRUNn6FX/J3gNSypxiO6HOOL2BZwkNH/o7oftoL5XTi7jOVKFu51FB7M65Y4AHCY2XP4rQGPURZranzipURlW+m8XHnwB8Ahxb3MS6f3+F9Y8G51wKcAEwntDY+cHAHDPbmCDXXqXqF4/XHlSpfvF6/VX6+1l8fFxcf5X4vk2lDq69hE0qREREpG4l5O0PERERqXtKKkRERCQilFSIiIhIRCipEBERkYhQUiEiIiIRoaRCREREIkJJhYiIiESEkgoRqXPOuTOcc3aI7dloxyci1dMg2gGISL30LeAts2840I/QokwiEoeUVIhInTOzLcCW/Y+dc/8DnAtcZGbxttiUiBRTUiEiUeWcGwvcBAwwsw+jHY+IVJ+SChGJGufcE4QWdOpvZh9HOx4RqRklFSISFc65p4FrgXPNbH604xGRmlNSISJ1yjnngGeAK4C+ZvafKIckIhGipEJE6tp44K/ALYRyjNNLlC02sx3RCUtEasqZWbRjEJF6oriVYjvQ7BCHdDWzZXUXkYhEkpIKERERiQjNqCkiIiIRoaRCREREIkJJhYiIiESEkgoRERGJCCUVIiIiEhFKKkRERCQilFSIiIhIRCipEBERkYhQUiEiIiIR8f8BvsjRVUaKdO4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "N_clusters_z, xedges = np.histogram(zc, bins=z_edges)\n", + "plt.errorbar(z_center,N_clusters_z,yerr=np.sqrt(N_clusters_z),marker='o',markersize=3.,ls='none',label='mock catalogue',capsize=5,c='r')\n", + "# 41253./599.?\n", + "sf = 41253./599.\n", + "# n, bins, patches = plt.hist(x=np.repeat(z_center,N_clusters_z_theory), bins=z_edges, color='orange',alpha=0.7, rwidth=0.95,label='class_sz')\n", + "plt.errorbar(z_center,N_clusters_z_theory,yerr=np.sqrt(N_clusters_z_theory),marker='o',markersize=3.,ls='none',label='class_sz',capsize=5,c='orange')\n", + "plt.errorbar(z_center,N_clusters_z_theory_with_rel,yerr=np.sqrt(N_clusters_z_theory),marker='o',markersize=3.,ls='none',label='class_sz (rel. corr.)',capsize=5,c='k')\n", + "# ze,nze = np.loadtxt('/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/z_N.txt',unpack=True)\n", + "# plt.plot(ze,nze,label='szcountsf90')\n", + "# plt.errorbar(z, catNz, yerr=np.sqrt(catNz), color='blue', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='mock catalogue')\n", + "# plt.errorbar(z_nemo,Nz_selfn,yerr=np.sqrt(Nz_selfn),marker='o',markersize=3.,ls='none',label=r'Nemo (Matt H)',capsize=5,c='b')\n", + "plt.errorbar(z+0.05, Nz.sum(axis=1), yerr=np.sqrt(Nz.sum(axis=1)), color='blue', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='szcountsf90')\n", + "\n", + "\n", + "\n", + "\n", + "plt.grid()\n", + "plt.legend(loc=1)\n", + "plt.xlabel(r'$z$')\n", + "plt.ylabel(r'$N$')\n", + "# plt.yscale('log')\n", + "# plt.ylim(1e0,6.e7)\n", + "plt.xlim(0.,2.)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.0, 50000.0)" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "N_clusters_y, xedges = np.histogram(np.log10(snr), bins=log10y_edges)\n", + "plt.errorbar(log10y_center,N_clusters_y,yerr=np.sqrt(N_clusters_y),marker='o',markersize=3.,ls='none',label='mock catalogue',capsize=5,c='r')\n", + "# n, bins, patches = plt.hist(x=np.repeat(log10y_center,N_clusters_y_theory), bins=log10y_edges, color='orange',alpha=0.7, rwidth=0.95, label='class_sz')\n", + "plt.errorbar(log10y_center,N_clusters_y_theory,yerr=np.sqrt(N_clusters_y_theory),marker='o',markersize=3.,ls='none',label='class_sz',capsize=7,c='orange')\n", + "plt.errorbar(log10y_center,N_clusters_y_theory_with_rel,yerr=np.sqrt(N_clusters_y_theory_with_rel),marker='o',markersize=3.,ls='none',label='class_sz (rel. corr.)',capsize=5,c='k')\n", + "\n", + "\n", + "\n", + "plt.errorbar(q, Nq, yerr=np.sqrt(Nq), color='blue', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='szcountsf90')\n", + "\n", + "# plt.errorbar(10**q, catNq, yerr=np.sqrt(catNq), color='black', fmt='o', ms=3, capsize=5, capthick=2, ls='none', label='mock catalogue')\n", + "\n", + "\n", + "\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.xlabel(r'$\\log_{10}(SNR)$')\n", + "plt.ylabel(r'$N$')\n", + "plt.yscale('log')\n", + "plt.xlim(0.6,2.1)\n", + "plt.ylim(1.,5e4)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# from nemo import *\n", + "# path_to_selfn = '/Users/boris/Work/CLASS-SZ/SO-SZ/so_cluster_counts/MFMF_WebSkyHalos_A10tSZ_3freq_tiles/selFn/'\n", + "\n", + "\n", + "# configFileName=path_to_selfn+'config.yml'\n", + "# selFnDir=path_to_selfn\n", + "# SNRCut=5.\n", + "# zStep=0.1\n", + "# footprintLabel=None\n", + "\n", + "# print(\">>> Setting up SNR > %.2f selection function ...\" % (SNRCut))\n", + "# selFn=completeness.SelFn(selFnDir, SNRCut, configFileName = configFileName, \n", + "# footprintLabel = footprintLabel, zStep = zStep)\n", + "\n", + "# scalingRelationDict=selFn.scalingRelationDict\n", + "# H0, Om0, Ob0, sigma8, ns = M.h()*100., M.Omega_m(),M.Omega_b()*M.h()**2., M.sigma8(), M.n_s()\n", + "# h=H0/100.0\n", + "# selFn.update(H0, Om0, Ob0, sigma8, ns, scalingRelationDict = scalingRelationDict)\n", + "# print(\"Total area = %.3f square degrees\" % (selFn.totalAreaDeg2))\n", + "\n", + "# # N(z) with M500c > 5e13 MSun - no selection function applied\n", + "# countsByRedshift=selFn.mockSurvey.clusterCount[:, np.greater(selFn.mockSurvey.log10M, np.log10(5e13/h))].sum(axis = 1)\n", + "# z_nemo = []\n", + "# Nz_noselfn = []\n", + "# Nz_selfn = []\n", + "\n", + "# # with open(\"NzCheck_noSelFn.csv\", \"w\") as outFile:\n", + "# for i in range(len(selFn.mockSurvey.z)):\n", + "# z_nemo.append((selFn.mockSurvey.zBinEdges[i]+selFn.mockSurvey.zBinEdges[i+1])/2.)\n", + "# Nz_noselfn.append(countsByRedshift[i])\n", + "# # print(\"%.1f <= z < %.1f\\t%.3f\\n\" % (selFn.mockSurvey.zBinEdges[i], selFn.mockSurvey.zBinEdges[i+1], countsByRedshift[i]))\n", + "\n", + "# # N(z) with M500c > 5e13 MSun - with S/N > 5 selection function applied\n", + "# predMz=selFn.compMz*selFn.mockSurvey.clusterCount\n", + "# countsByRedshift=predMz[:, np.greater(selFn.mockSurvey.log10M, np.log10(5e13*h))].sum(axis = 1)\n", + "# # with open(\"NzCheck_withSelFn.csv\", \"w\") as outFile:\n", + "# for i in range(len(selFn.mockSurvey.z)):\n", + "# # z.append(selFn.mockSurvey.zBinEdges[i]+selFn.mockSurvey.zBinEdges[i+1])/2.)\n", + "# Nz_selfn.append(countsByRedshift[i])\n", + "# # print(\"%.1f <= z < %.1f\\t%.3f\\n\" % (selFn.mockSurvey.zBinEdges[i], selFn.mockSurvey.zBinEdges[i+1], countsByRedshift[i]))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/soliket/cibxkappa.yml b/soliket/cibxkappa.yml new file mode 100644 index 00000000..50ff4d22 --- /dev/null +++ b/soliket/cibxkappa.yml @@ -0,0 +1,193 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa + +likelihood: + soliket.cib_likelihood.CIB_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + soliket.classy_cibxkappa: + extra_args: + output : 'lens_cib_1h, lens_cib_2h' + + A_s: 2.2e-09 + Dust temperature today in Kelvins: 24.4 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD: 10000000000.0 + Most efficient halo mass in Msun: 3981071705534.969 + N_ncdm: 1 + N_ur: 0.00641 + Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + Omega_cdm: 0.2685008554866952 + Power law index of SED at high frequency: 1.7 + Redshift evolution of L - M normalisation: 3.6 + # Redshift evolution of dust temperature: 0.36 + Size of of halo masses sourcing CIB emission: 0.5 + T_ncdm: 0.71611 + # cib_frequency_list_num: 3 + cib_frequency_list_num: 1 + # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + cib_Snu_cutoff_list [mJy]: 350 + # cib_frequency_list_in_GHz: 857, 353, 545 + cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + deg_ncdm: 3 + dell: 64 + delta for cib: 200m + ell_max: 3968.0 + ell_min: 2.0 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9624 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.005 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 and n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + + + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + + +params: + alpha: + prior: + min: 0 + max: 2 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + latex: \alpha + # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + # gamma: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 0.36 + # scale: 0.05 + # latex: \gamma + # drop: True + + # Power law index of SED at high frequency: + # value: 'lambda gamma: gamma' + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : True +verbose: True \ No newline at end of file diff --git a/soliket/cibxlensing/__init__.py b/soliket/cibxlensing/__init__.py new file mode 100644 index 00000000..defa24fb --- /dev/null +++ b/soliket/cibxlensing/__init__.py @@ -0,0 +1 @@ +from .cibxlensing_likelihood import CIBxKAPPA_Likelihood \ No newline at end of file diff --git a/soliket/cibxlensing/cibxlensing_likelihood.py b/soliket/cibxlensing/cibxlensing_likelihood.py new file mode 100644 index 00000000..d8641cdc --- /dev/null +++ b/soliket/cibxlensing/cibxlensing_likelihood.py @@ -0,0 +1,144 @@ +""" +.. module:: cib x kappa cross spectrum likelihood (in progress) + +""" + +# Acronyms: +# ps: power spectrum +# fg: foregrounds +# cib: cosmic infrared background +# rs: radio sources +# ir: infrared sources +# f_sky: sky fraction + + +from turtle import position +from cobaya.theory import Theory +# from cobaya.conventions import _packages_path +_packages_path = 'packages_path' +# from cobaya.likelihoods._base_classes import _InstallableLikelihood +from soliket.gaussian import GaussianLikelihood +import numpy as np +import os +from scipy.ndimage.interpolation import shift +from typing import Optional, Sequence +from pkg_resources import resource_filename +from myfuncs import alm as yalm, io as yio +from mpi4py import MPI + + + +class CIBxKAPPA_Likelihood(GaussianLikelihood): + cib_spectra_directory: Optional[str] = '/project/r/rbond/ymehta3/output/param-fitting/' + cib_spectra_file: Optional[str] = 'toy_data.npy' + cib_cov_directory: Optional[str] = '/project/r/rbond/ymehta3/output/param-fitting/' + # cib_cov_file: Optional[str] = 'covCl_avg_v3.npy' + cib_cov_file: Optional[str] = 'toy_cov.npy' + project_directory: Optional[str] = '/project/r/rbond/ymehta3/' + cross_mcms_names_file: Optional[str] = 'input_data/names_mcms_dr6_cross.txt' + cov_ell_info_file: Optional[str] = 'input_data/bandpower_ell_info.txt' + + def initialize(self): + self.data_directory = self.cib_spectra_directory + self.data_file = self.cib_spectra_file + self.cov_directory = self.cib_cov_directory + self.cov_file = self.cib_cov_file + + #Load the Data + Dpoints = np.load(self.data_directory + self.data_file) + self.cov = np.load(os.path.join(self.cov_directory, self.cov_file)) + self.mcms_paths_list = yio.readTxt( os.path.join(self.project_directory, self.cross_mcms_names_file) ) + + #Get Ell Info + self.lmax, self.binsize = np.loadtxt(os.path.join(self.project_directory, self.cov_ell_info_file)) + + #Extract the Data + self.datavector = Dpoints[:,1] + self.ellsvector = Dpoints[:,0] # for mock data, this is binned class_sz theory ells + # np.save('/scratch/r/rbond/ymehta3/'+'actual_mock_data.npy', np.stack([self.ellsvector, self.datavector, np.sqrt(np.diag(self.cov))], axis=-1) ) + + self.debug_index = 1 + comm = MPI.COMM_WORLD + self.rank = comm.Get_rank() + self.debug_theoryvector = [] + self.debug_unbinned_theory = [] + + super().initialize() + + + def get_requirements(self): + return {"cl_cib_kappa": {}} + + def _get_data(self): + ell = self.ellsvector + Cl = self.datavector + return ell, Cl + + def _get_cov(self): + return self.cov + + + def _get_theory(self, **params_values): + # theory = self.theory.get_Cl_kappa_cib() + theory = self.theory.get_cl_cib_kappa() + theoryvector_unbinned = [] + + #Extract All Cross Spectra + freq_list = np.sort(np.array(list(theory.keys())).astype(int)) + freq_list = [str(nu) for nu in freq_list] + for nu in freq_list: + Dl_1h_theory = np.array(theory[str(nu)]['1h']) + Dl_2h_theory = np.array(theory[str(nu)]['2h']) + ells_theory = np.array(theory[str(nu)]['ell']) + + fac = ells_theory * (ells_theory+1) / 2/np.pi + Dl_tot_theory = Dl_1h_theory + Dl_2h_theory + Cl_kappa_cib = Dl_tot_theory / fac + theoryvector_unbinned.append(Cl_kappa_cib) + + #Bin Theory + theoryvector_binned = [] + for iCl, Cls_unbinned in enumerate(theoryvector_unbinned): + #Interpolate the Theory Vector + full_ells = np.arange(self.lmax+1) + interp_Cls_unbinned = np.interp(full_ells, ells_theory, Cls_unbinned) + + #Get Mode-Coupling Matrix + mcm_path = '' + for possible_mcm_path in self.mcms_paths_list: + if freq_list[iCl] not in possible_mcm_path: + continue + else: + mcm_path = possible_mcm_path + + #Confirm Mode-Coupling Matrix + if not mcm_path: + raise ValueError(f"I need the mcm for {freq_list[iCl]} GHz but it's not in the provided path names, which are '{self.mcms_paths_list}'.") + + #Bin Theory Vector + # for mock data, the data ells are the binned theory ells, so there's already perfect syncronization with the theory Cl's + theoryvector_binned.append( yalm.binTheory(interp_Cls_unbinned, mcm_path) ) + + #Create large, Multifreq Theory Vector + theoryvector = np.array(theoryvector_binned).flatten() + + #Debugging + self.debug_theoryvector.append(theoryvector) + if not self.debug_index % 100: + debugfname = self.data_directory + 'mcmcresults/steps/' + f'steps_Cls_delta_{self.rank}_{self.debug_index}.npy' + np.save(debugfname, np.array(self.debug_theoryvector)) + + # # if not os.path.isfile(debugfname): + # # np.savetxt(debugfname, [theoryvector]) + # # else: + # # # import pdb; pdb.set_trace() + # # all_theoryCls = np.loadtxt(debugfname) + # # if all_theoryCls.ndim == 1: + # # np.savetxt(debugfname, np.stack( (all_theoryCls, theoryvector) )) + # # elif all_theoryCls.ndim == 2: + # # np.savetxt(debugfname, np.concatenate( (all_theoryCls, theoryvector[None, :]) )) + # # else: + # # raise ValueError('something has gone horribly wrong with saving the previous spectra!') + self.debug_index += 1 + + return theoryvector diff --git a/soliket/cibxlensing/classy_cibxkappa_theory.py b/soliket/cibxlensing/classy_cibxkappa_theory.py new file mode 100644 index 00000000..67415c0a --- /dev/null +++ b/soliket/cibxlensing/classy_cibxkappa_theory.py @@ -0,0 +1,78 @@ +from cobaya.theories.classy import classy +from copy import deepcopy +from typing import NamedTuple, Sequence, Union, Optional +from cobaya.tools import load_module +import logging +import os + +class classy_cibxkappa(classy): + def initialize(self): + """Importing CLASS from the correct path, if given, and if not, globally.""" + self.classy_module = self.is_installed() + if not self.classy_module: + raise NotInstalledError( + self.log, "Could not find CLASS_SZ. Check error message above.") + from classy_sz import Class, CosmoSevereError, CosmoComputationError + global CosmoComputationError, CosmoSevereError + self.classy = Class() + super(classy,self).initialize() + # Add general CLASS stuff + self.extra_args["output"] = self.extra_args.get("output", "") + if "sBBN file" in self.extra_args: + self.extra_args["sBBN file"] = ( + self.extra_args["sBBN file"].format(classy=self.path)) + # Derived parameters that may not have been requested, but will be necessary later + self.derived_extra = [] + self.log.info("Initialized!") + + + # # class_sz default params for lkl + # self.extra_args["output"] = 'tSZ_1h' + # self.extra_args["multipoles_sz"] = 'P15' + # self.extra_args['nlSZ'] = 18 + + + # # here modify if you want to bypass stuff in the class computation + # def calculate(self, state, want_derived=True, **params_values_dict): + # print("Bypassing class_sz") + + # def calculate(self, state, want_derived=True, **params_values_dict): + # #Adjust class_sz CIB Parameter Names + # if 'Redshift_evolution_of_dust_temperature' in params_values_dict: + # params_values_dict['Redshift evolution of dust temperature'] = params_values_dict.pop('Redshift_evolution_of_dust_temperature') + # print('\nRenamed parameter successfully\n') + # import ipdb; ipdb.set_trace() + # super().calculate(state, want_derived= want_derived, **params_values_dict) + + + def must_provide(self, **requirements): + if "Cl_kappa_cib" in requirements: + # make sure cobaya still runs as it does for standard classy + requirements.pop("Cl_kappa_cib") + # specify the method to collect the new observable + self.collectors["Cl_kappa_cib"] = Collector( + method="cl_lens_cib", # name of the method in classy.pyx + args_names=[], + args=[]) + + super().must_provide(**requirements) + + # get the required new observable + def get_Cl_kappa_cib(self): + cls = {} + cls = deepcopy(self._current_state["Cl_kappa_cib"]) + return cls + + @classmethod + def is_installed(cls, **kwargs): + return load_module('classy_sz') + + +# this just need to be there as it's used to fill-in self.collectors in must_provide: +class Collector(NamedTuple): + method: str + args: Sequence = [] + args_names: Sequence = [] + kwargs: dict = {} + arg_array: Union[int, Sequence] = None + post: Optional[callable] = None diff --git a/soliket/cibxlensing/input_files/cibxkappa.yml b/soliket/cibxlensing/input_files/cibxkappa.yml new file mode 100644 index 00000000..dcdef14d --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa.yml @@ -0,0 +1,264 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + Dust_temperature_today_in_Kelvins: 24.4 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + Normalisation_of_L_-_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + omega_cdm: 0.1203058 + Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_-_M_normalisation: 3.6 + # Redshift evolution of dust temperature: 0.36 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + # cib_frequency_list_num: 3 + cib_frequency_list_num: 1 + # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + cib_Snu_cutoff_list [mJy]: 350 + # cib_frequency_list_in_GHz: 857, 353, 545 + cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # Most efficient halo mass in Msun: 3981071705534.969 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.1 + max: 0.6 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.05 + latex: \alpha + # drop: True + + # Normalisation_of_L_-_M_relation_in_[JyMPc2/Msun]: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 6.4e-08 + # scale: 1.28e-08 + # proposal: 1.28e-08 + # latex: L_{o} + # # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + # gamma: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 0.36 + # scale: 0.05 + # latex: \gamma + # drop: True + + # Power law index of SED at high frequency: + # value: 'lambda gamma: gamma' + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : True +verbose: True +timing: True \ No newline at end of file diff --git a/soliket/cibxlensing/input_files/cibxkappa_1param.yml b/soliket/cibxlensing/input_files/cibxkappa_1param.yml new file mode 100644 index 00000000..bbeff597 --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa_1param.yml @@ -0,0 +1,292 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa_job_cross_1param + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.cibxlensing.classy_cibxkappa_theory.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + omega_cdm: 0.1203058 + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + Dust_temperature_today_in_Kelvins: 24.4 + # Redshift_evolution_of_dust_temperature: 0.36 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + Emissivity_index_of_sed: 1.75 + Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_M_normalisation: 3.6 + # Most_efficient_halo_mass_in_Msun: 10**12.6 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.20 + max: 0.45 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.01 + latex: \alpha + # drop: True + + # Normalisation_of_L_-_M_relation_in_[JyMPc2/Msun]: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 6.4e-08 + # scale: 1.28e-08 + # proposal: 1.28e-08 + # latex: L_{o} + # # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + # Emissivity_index_of_sed: + # prior: + # min: 1 + # max: 2.5 + # ref: + # dist: norm + # loc: 1.75 + # scale: 0.06 + # latex: \beta + + # Power_law_index_of_SED_at_high_frequency: + # prior: + # min: 0.9 + # max: 2.5 + # ref: + # dist: norm + # loc: 1.7 + # scale: 0.2 + # latex: \gamma + + # # Redshift_evolution_of_L_-_M_normalisation: + # # prior: + # # min: 2.8 + # # max: 4.4 + # # ref: + # # dist: norm + # # loc: 3.6 + # # scale: 0.2 + # # latex: \delta + + # Dust_temperature_today_in_Kelvins: + # prior: + # min: 16 + # max: 32 + # ref: + # dist: norm + # loc: 24.4 + # scale: 1.9 + # latex: T_{o + + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : False +verbose: False +timing: True \ No newline at end of file diff --git a/soliket/cibxlensing/input_files/cibxkappa_2param.yml b/soliket/cibxlensing/input_files/cibxkappa_2param.yml new file mode 100644 index 00000000..eb279f6b --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa_2param.yml @@ -0,0 +1,274 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa_job_cross_2param + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + omega_cdm: 0.1203058 + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + Dust_temperature_today_in_Kelvins: 24.4 + # Redshift_evolution_of_dust_temperature: 0.36 + # Emissivity_index_of_sed: 1.75 + Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_M_normalisation: 3.6 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # Most efficient halo mass in Msun: 3981071705534.969 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.10 + max: 0.85 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.05 + latex: \alpha + # drop: True + + # Normalisation_of_L_-_M_relation_in_[JyMPc2/Msun]: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 6.4e-08 + # scale: 1.28e-08 + # proposal: 1.28e-08 + # latex: L_{o} + # # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + Emissivity_index_of_sed: + prior: + min: 1 + max: 2.5 + ref: + dist: norm + loc: 1.75 + scale: 0.06 + latex: \beta + + # Power_law_index_of_SED_at_high_frequency: + # prior: + # min: 0.9 + # max: 2.5 + # ref: + # dist: norm + # loc: 1.7 + # scale: 0.2 + # latex: \gamma + + # Power law index of SED at high frequency: + # value: 'lambda gamma: gamma' + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : False +verbose: False +timing: True \ No newline at end of file diff --git a/soliket/cibxlensing/input_files/cibxkappa_3param.yml b/soliket/cibxlensing/input_files/cibxkappa_3param.yml new file mode 100644 index 00000000..3aee6504 --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa_3param.yml @@ -0,0 +1,274 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa_job_cross_3param + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + omega_cdm: 0.1203058 + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + Dust_temperature_today_in_Kelvins: 24.4 + # Redshift_evolution_of_dust_temperature: 0.36 + # Emissivity_index_of_sed: 1.75 + # Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_M_normalisation: 3.6 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # Most efficient halo mass in Msun: 3981071705534.969 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.10 + max: 0.85 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.05 + latex: \alpha + # drop: True + + # Normalisation_of_L_-_M_relation_in_[JyMPc2/Msun]: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 6.4e-08 + # scale: 1.28e-08 + # proposal: 1.28e-08 + # latex: L_{o} + # # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + Emissivity_index_of_sed: + prior: + min: 1 + max: 2.5 + ref: + dist: norm + loc: 1.75 + scale: 0.06 + latex: \beta + + Power_law_index_of_SED_at_high_frequency: + prior: + min: 0.9 + max: 2.5 + ref: + dist: norm + loc: 1.7 + scale: 0.2 + latex: \gamma + + # Power law index of SED at high frequency: + # value: 'lambda gamma: gamma' + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : False +verbose: False +timing: True \ No newline at end of file diff --git a/soliket/cibxlensing/input_files/cibxkappa_4param.yml b/soliket/cibxlensing/input_files/cibxkappa_4param.yml new file mode 100644 index 00000000..a126bf2c --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa_4param.yml @@ -0,0 +1,292 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa_job_cross_4param + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + omega_cdm: 0.1203058 + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + Dust_temperature_today_in_Kelvins: 24.4 + # Redshift_evolution_of_dust_temperature: 0.36 + # Emissivity_index_of_sed: 1.75 + # Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_M_normalisation: 3.6 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # Most efficient halo mass in Msun: 3981071705534.969 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.10 + max: 0.85 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.05 + latex: \alpha + # drop: True + + # Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: + # prior: + # min: 0 + # max: 2 + # ref: + # dist: norm + # loc: 6.4e-08 + # scale: 1.28e-08 + # proposal: 1.28e-08 + # latex: L_{o} + # # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + Emissivity_index_of_sed: + prior: + min: 1 + max: 2.5 + ref: + dist: norm + loc: 1.75 + scale: 0.06 + latex: \beta + + Power_law_index_of_SED_at_high_frequency: + prior: + min: 0.9 + max: 2.5 + ref: + dist: norm + loc: 1.7 + scale: 0.2 + latex: \gamma + + Redshift_evolution_of_L_M_normalisation: + prior: + min: 2.8 + max: 4.4 + ref: + dist: norm + loc: 3.6 + scale: 0.2 + latex: \delta + + # Dust_temperature_today_in_Kelvins: + # prior: + # min: 16 + # max: 32 + # ref: + # dist: norm + # loc: 24.4 + # scale: 1.9 + # latex: T_{o + + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : False +verbose: False +timing: True diff --git a/soliket/cibxlensing/input_files/cibxkappa_6param.yml b/soliket/cibxlensing/input_files/cibxkappa_6param.yml new file mode 100644 index 00000000..d19fb27b --- /dev/null +++ b/soliket/cibxlensing/input_files/cibxkappa_6param.yml @@ -0,0 +1,292 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/cibxkappa_job_cross_6param + +likelihood: + soliket.CIBxKAPPA_Likelihood: + # cib_spectra_directory: + # cib_spectra_file: + # cib_cov_directory: "/scratch/r/rbond/ymehta3/output/param-fitting/" + # cib_cov_file: "big_Cov.npy" + + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + stop_at_error: True + + + +theory: + # soliket.classy_cibxkappa: + class_sz.python.classy_szfast.classy_szfast.classy_sz: + use_class_sz_no_cosmo_mode: 1 + use_class_sz_fast_mode: 1 + extra_args: + cosmo_model: 0 + skip_background_and_thermo: 0 + skip_chi: 1 + skip_hubble: 1 + skip_pkl: 0 + skip_pknl: 1 + skip_sigma8_and_der: 0 + skip_sigma8_at_z: 1 + + output : 'lens_cib_1h, lens_cib_2h' + A_s: 2.15086031154146e-9 + L_sat_epsabs: 1.0e-40 + L_sat_epsrel: 0.001 + M_max: 6711000000000000.0 + M_min: 67110000.0 + M_min_HOD_cib: 10000000000.0 + N_ncdm: 1 + omega_ncdm: 0.00064 + N_ur: 2.0328 + omega_cdm: 0.1203058 + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: 6.4e-08 + # Dust_temperature_today_in_Kelvins: 24.4 + # Redshift_evolution_of_dust_temperature: 0.36 + # Emissivity_index_of_sed: 1.75 + # Power_law_index_of_SED_at_high_frequency: 1.7 + Redshift_evolution_of_L_M_normalisation: 3.6 + Most_efficient_halo_mass_in_Msun: 3981071705534.969 + Size_of_halo_masses_sourcing_CIB_emission: 0.5 + # T_ncdm: 0.71611 + cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + concentration parameter: D08 + damping_1h_term: 0 + # deg_ncdm: 3 + dell: 128 + delta for cib: 200m + ell_max: 4000 + ell_min: 2 + freq_max: 50000.0 + freq_min: 10.0 + h: 0.6711 + has_cib_flux_cut: 1 + hm_consistency: 1 + k_max_tau0_over_l_max: 5.0 + k_pivot: 0.05 + m_ncdm: 0.02 + mass function: T10 + mass_epsabs: 1.0e-40 + mass_epsrel: 0.0001 + n_s: 0.9625356 + ndim_masses: 150 + ndim_redshifts: 150 + non_linear: halofit + omega_b: 0.022068 + perturb_sampling_stepsize: 0.2 + pressure_profile_epsabs: 1.0e-08 + pressure_profile_epsrel: 0.001 + redshift_epsabs: 1.0e-40 + redshift_epsrel: 0.0001 + tau_reio: 0.0925 + z_max: 6.0 + z_max_pk: 6.0 + z_min: 0.07 + # A_s: 2.2e-09 + # Dust temperature today in Kelvins: 24.4 + # L_sat_epsabs: 1.0e-40 + # L_sat_epsrel: 0.001 + # M_max: 6711000000000000.0 + # M_min: 67110000.0 + # M_min_HOD: 10000000000.0 + # Most efficient halo mass in Msun: 3981071705534.969 + # N_ncdm: 1 + # omega_ncdm: 0.00064 + # N_ur: 2.0328 + # Normalisation of L - M relation in [Jy MPc2/Msun]: 6.4e-08 + # Omega_cdm: 0.2685008554866952 + # Power law index of SED at high frequency: 1.7 + # Redshift evolution of L - M normalisation: 3.6 + # # Redshift evolution of dust temperature: 0.36 + # Size of of halo masses sourcing CIB emission: 0.5 + # T_ncdm: 0.71611 + # # cib_frequency_list_num: 3 + # cib_frequency_list_num: 1 + # # cib_Snu_cutoff_list [mJy]: 710, 315, 350 + # cib_Snu_cutoff_list [mJy]: 350 + # # cib_frequency_list_in_GHz: 857, 353, 545 + # cib_frequency_list_in_GHz: 545 + # concentration parameter: D08 + # damping_1h_term: 0 + # # deg_ncdm: 3 + # dell: 64 + # delta for cib: 200m + # ell_max: 3968.0 + # ell_min: 2.0 + # freq_max: 50000.0 + # freq_min: 10.0 + # h: 0.6711 + # has_cib_flux_cut: 1 + # hm_consistency: 1 + # k_max_tau0_over_l_max: 5.0 + # k_pivot: 0.05 + # m_ncdm: 0.02 + # mass function: T10 + # mass_epsabs: 1.0e-40 + # mass_epsrel: 0.0001 + # n_s: 0.9624 + # ndim_masses: 150 + # ndim_redshifts: 150 + # non_linear: halofit + # omega_b: 0.022068 + # perturb_sampling_stepsize: 0.2 + # pressure_profile_epsabs: 1.0e-08 + # pressure_profile_epsrel: 0.001 + # redshift_epsabs: 1.0e-40 + # redshift_epsrel: 0.0001 + # tau_reio: 0.0925 + # z_max: 6.0 + # z_max_pk: 6.0 + # z_min: 0.07 + # #M_min_HOD is the threshold above which nc = 1: + # M_min_HOD : 10.**10, + # M_min : 1e10*common_settings['h'], + # M_max : 1e16*common_settings['h'], + # z_min : 0.06, + # z_max : 15, + # ### Precision + # #redshift_epsabs : 1.0e-40 + # #redshift_epsrel : 0.0005 + # #mass_epsabs : 1.0e-40 + # #mass_epsrel : 0.0005 + # dell : 64, + # #multipoles_sz : 'ell_mock' + # ell_max : 3968.0, + # ell_min : 2.0, + # ndim_masses : 100, + # ndim_redshifts : 100, + # # z_min : 0.005 + # # z_max : 3.0 + # # M_min : 1.0e10 + # # M_max : 3.5e15 + # # z_max_pk : 4. + # cib_frequency_list_num : 3, + # cib_frequency_list_in_GHz : '353, 545, 857' + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + # perturbations_verbose: 10 + # thermodynamics_verbose: 10 + # background_verbose: 10 + # class_sz_verbose: 10 + # spectra_verbose: 10 + # mass function : 'T10' + # # harmonic_verbose: 0 + # # fourier_verbose : 0 + # input_verbose : 10 + # # lensing_verbose : 0 + # # The base model features two massless + # # and one massive neutrino with m=0.06eV. + # # The settings below ensures that Neff=3.046 + # # and m/omega = 93.14 eV + # N_ur : 2.0328 + # N_ncdm : 1 + # m_ncdm : 0.06 + # T_ncdm : 0.71611 + # YHe: 'BBN' + # # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 nd n_arraySZ=1000 + # # [relevant for tabulation of sigma(R,z)] + # # ndimSZ: 50 + # # n_arraySZ: 50 + # #write parameters : 'yeap' + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + +params: + Redshift_evolution_of_dust_temperature: + prior: + min: 0.10 + max: 0.85 + ref: + dist: norm + loc: 0.36 + scale: 0.05 + proposal: 0.05 + latex: \alpha + # drop: True + + Normalisation_of_L_M_relation_in_[JyMPc2/Msun]: + prior: + min: 0 + max: 2 + ref: + dist: norm + loc: 6.4e-08 + scale: 1.28e-08 + proposal: 1.28e-08 + latex: L_{o} + # drop: True + + # Redshift evolution of dust temperature: + # value: 'lambda alpha: alpha' + + Emissivity_index_of_sed: + prior: + min: 1 + max: 2.5 + ref: + dist: norm + loc: 1.75 + scale: 0.06 + latex: \beta + + Power_law_index_of_SED_at_high_frequency: + prior: + min: 0.9 + max: 2.5 + ref: + dist: norm + loc: 1.7 + scale: 0.2 + latex: \gamma + + Redshift_evolution_of_L_M_normalisation: + prior: + min: 2.8 + max: 4.4 + ref: + dist: norm + loc: 3.6 + scale: 0.2 + latex: \delta + + Dust_temperature_today_in_Kelvins: + prior: + min: 16 + max: 32 + ref: + dist: norm + loc: 24.4 + scale: 1.9 + latex: T_{o} + + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # 'Redshift_evolution_of_dust_temperature': 0.36 + + +debug : False +verbose: False +timing: True \ No newline at end of file diff --git a/soliket/clusters/__init__.py b/soliket/clusters/__init__.py deleted file mode 100644 index 1dfbb1c3..00000000 --- a/soliket/clusters/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from .clusters import ClusterLikelihood diff --git a/soliket/clusters/clusters.py b/soliket/clusters/clusters.py deleted file mode 100644 index fc25b630..00000000 --- a/soliket/clusters/clusters.py +++ /dev/null @@ -1,190 +0,0 @@ -""" -requires extra: astlib - -""" -import numpy as np -import pandas as pd -from scipy.interpolate import interp1d -from pkg_resources import resource_filename -import pyccl as ccl - -from ..poisson import PoissonLikelihood -from . import massfunc as mf -from .survey import SurveyData -from .sz_utils import szutils - -C_KM_S = 2.99792e5 - - -class SZModel: - pass - - -class ClusterLikelihood(PoissonLikelihood): - name = "Clusters" - columns = ["tsz_signal", "z", "tsz_signal_err"] - data_path = resource_filename("soliket", "clusters/data/selFn_equD56") - data_name = resource_filename("soliket", "clusters/data/ACTPol_Cond_scatv5.fits") - - def initialize(self): - self.zarr = np.arange(0, 2, 0.05) - self.k = np.logspace(-4, np.log10(5), 200) - # self.mdef = ccl.halos.MassDef(500, 'critical') - - super().initialize() - - def get_requirements(self): - return { - "Pk_interpolator": { - "z": self.zarr, - "k_max": 5.0, - "nonlinear": False, - "hubble_units": False, # cobaya told me to - "k_hunit": False, # cobaya told me to - "vars_pairs": [["delta_nonu", "delta_nonu"]], - }, - "Hubble": {"z": self.zarr}, - "angular_diameter_distance": {"z": self.zarr}, - "comoving_radial_distance": {"z": self.zarr} - # "CCL": {"methods": {"sz_model": self._get_sz_model}, "kmax": 10}, - } - - def _get_sz_model(self, cosmo): - model = SZModel() - model.hmf = ccl.halos.MassFuncTinker08(cosmo, mass_def=self.mdef) - model.hmb = ccl.halos.HaloBiasTinker10(cosmo, mass_def=self.mdef, mass_def_strict=False) - model.hmc = ccl.halos.HMCalculator(cosmo, model.hmf, model.hmb, self.mdef) - model.szk = SZTracer(cosmo) - return model - - def _get_catalog(self): - self.survey = SurveyData(self.data_path, self.data_name, szarMock=True) - - self.szutils = szutils(self.survey) - - df = pd.DataFrame( - { - "z": self.survey.clst_z.byteswap().newbyteorder(), - "tsz_signal": self.survey.clst_y0.byteswap().newbyteorder(), - "tsz_signal_err": self.survey.clst_y0err.byteswap().newbyteorder(), - } - ) - return df - - def _get_om(self): - return (self.theory.get_param("omch2") + self.theory.get_param("ombh2")) / ( - (self.theory.get_param("H0") / 100.0) ** 2 - ) - - def _get_ob(self): - return (self.theory.get_param("ombh2")) / ((self.theory.get_param("H0") / 100.0) ** 2) - - def _get_Ez(self): - return self.theory.get_Hubble(self.zarr) / self.theory.get_param("H0") - - def _get_Ez_interpolator(self): - return interp1d(self.zarr, self._get_Ez()) - - def _get_DAz(self): - return self.theory.get_angular_diameter_distance(self.zarr) - - def _get_DAz_interpolator(self): - return interp1d(self.zarr, self._get_DAz()) - - def _get_HMF(self): - h = self.theory.get_param("H0") / 100.0 - - Pk_interpolator = self.theory.get_Pk_interpolator(("delta_nonu", "delta_nonu"), nonlinear=False).P - pks = Pk_interpolator(self.zarr, self.k) - # pkstest = Pk_interpolator(0.125, self.k ) - # print (pkstest * h**3 ) - - Ez = self._get_Ez() # self.theory.get_Hubble(self.zarr) / self.theory.get_param("H0") - om = self._get_om() - - hmf = mf.HMF(om, Ez, pk=pks * h ** 3, kh=self.k / h, zarr=self.zarr) - - return hmf - - def _get_param_vals(self): - B0 = 0.08 - scat = 0.2 - massbias = 1.0 - H0 = self.theory.get_param("H0") - ob = self._get_ob() - om = self._get_om() - param_vals = {"om": om, "ob": ob, "H0": H0, "B0": B0, "scat": scat, "massbias": massbias} - return param_vals - - def _get_rate_fn(self, **kwargs): - HMF = self._get_HMF() - param_vals = self._get_param_vals() - - Ez_fn = self._get_Ez_interpolator() - DA_fn = self._get_DAz_interpolator() - - dn_dzdm_interp = HMF.inter_dndmLogm(delta=500) - - h = self.theory.get_param("H0") / 100.0 - - def Prob_per_cluster(z, tsz_signal, tsz_signal_err): - c_y = tsz_signal - c_yerr = tsz_signal_err - c_z = z - - Pfunc_ind = self.szutils.Pfunc_per( - HMF.M, c_z, c_y * 1e-4, c_yerr * 1e-4, param_vals, Ez_fn, DA_fn - ) - - dn_dzdm = 10 ** np.squeeze(dn_dzdm_interp(c_z, np.log10(HMF.M))) * h ** 4.0 - - ans = np.trapz(dn_dzdm * Pfunc_ind, dx=np.diff(HMF.M, axis=0), axis=0) - # import pdb - - # pdb.set_trace() - return ans - - return Prob_per_cluster - # Implement a function that returns a rate function (function of (tsz_signal, z)) - - def _get_dVdz(self): - """dV/dzdOmega - """ - DA_z = self.theory.get_angular_diameter_distance(self.zarr) - - dV_dz = DA_z ** 2 * (1.0 + self.zarr) ** 2 / (self.theory.get_Hubble(self.zarr) / C_KM_S) - - # dV_dz *= (self.theory.get_param("H0") / 100.0) ** 3.0 # was h0 - return dV_dz - - def _get_n_expected(self, **kwargs): - # def Ntot_survey(self,int_HMF,fsky,Ythresh,param_vals): - - HMF = self._get_HMF() - param_vals = self._get_param_vals() - Ez_fn = self._get_Ez_interpolator() - DA_fn = self._get_DAz_interpolator() - - z_arr = self.zarr - - h = self.theory.get_param("H0") / 100.0 - - Ntot = 0 - dVdz = self._get_dVdz() - dn_dzdm = HMF.dn_dM(HMF.M, 500.0) * h ** 4.0 # getting rid of hs - - for Yt, frac in zip(self.survey.Ythresh, self.survey.frac_of_survey): - Pfunc = self.szutils.PfuncY(Yt, HMF.M, z_arr, param_vals, Ez_fn, DA_fn) - N_z = np.trapz(dn_dzdm * Pfunc, dx=np.diff(HMF.M[:, None] / h, axis=0), axis=0) - Ntot += np.trapz(N_z * dVdz, x=z_arr) * 4.0 * np.pi * self.survey.fskytotal * frac - - # To test Mass function against Nemo. - # Pfunc = 1. - # N_z = np.trapz(dn_dzdm * Pfunc, dx=np.diff(HMF.M[:, None]/h, axis=0), axis=0) - # Ntot = np.trapz(N_z * dVdz, x=z_arr) * 4.0 * np.pi * (600./(4*np.pi * (180/np.pi)**2)) - # print("Ntot", Ntot) - - return Ntot - - # def logp(self, *args, **kwargs): - # return super().logp(*args, **kwargs) diff --git a/soliket/clusters/data/ACTPol_Cond_scatv5.fits b/soliket/clusters/data/ACTPol_Cond_scatv5.fits deleted file mode 100644 index b48f2dc0..00000000 Binary files a/soliket/clusters/data/ACTPol_Cond_scatv5.fits and /dev/null differ diff --git a/soliket/clusters/data/E-D56Clusters.fits b/soliket/clusters/data/E-D56Clusters.fits deleted file mode 100644 index 3ffcba81..00000000 --- a/soliket/clusters/data/E-D56Clusters.fits +++ /dev/null @@ -1,165 +0,0 @@ -SIMPLE = T / conforms to FITS standard BITPIX = 8 / array data type NAXIS = 0 / number of array dimensions EXTEND = T END XTENSION= 'BINTABLE' / binary table extension BITPIX = 8 / array data type NAXIS = 2 / number of array dimensions NAXIS1 = 348 / length of dimension 1 NAXIS2 = 182 / length of dimension 2 PCOUNT = 0 / number of group parameters GCOUNT = 1 / number of groups TFIELDS = 40 / number of table fields TTYPE1 = 'name ' TFORM1 = '19A ' TTYPE2 = 'RADeg ' TFORM2 = 'D ' TTYPE3 = 'decDeg ' TFORM3 = 'D ' TTYPE4 = 'SNR ' TFORM4 = 'D ' TTYPE5 = 'SNR2p4 ' TFORM5 = 'D ' TTYPE6 = 'y0tilde ' TFORM6 = 'D ' TTYPE7 = 'y0tilde_err' TFORM7 = 'D ' TTYPE8 = 'H13Match' TFORM8 = 'K ' TTYPE9 = 'PSZ2Match' TFORM9 = 'K ' TTYPE10 = 'RMMatch ' TFORM10 = 'K ' TTYPE11 = 'AltName ' TFORM11 = '29A ' TTYPE12 = 'BCG_RADeg' TFORM12 = 'D ' TTYPE13 = 'BCG_decDeg' TFORM13 = 'D ' TTYPE14 = 'z ' TFORM14 = 'D ' TTYPE15 = 'zErr ' TFORM15 = 'D ' TTYPE16 = 'zType ' TFORM16 = '4A ' TTYPE17 = 'zSource ' TFORM17 = '8A ' TTYPE18 = 'deltaSDSS' TFORM18 = 'D ' TTYPE19 = 'deltaSDSS_err' TFORM19 = 'D ' TTYPE20 = 'deltaS82' TFORM20 = 'D ' TTYPE21 = 'deltaS82_err' TFORM21 = 'D ' TTYPE22 = 'deltaCFHT' TFORM22 = 'D ' TTYPE23 = 'deltaCFHT_err' TFORM23 = 'D ' TTYPE24 = 'deltaSOAR' TFORM24 = 'D ' TTYPE25 = 'deltaSOAR_err' TFORM25 = 'D ' TTYPE26 = 'M500cUPP' TFORM26 = 'D ' TTYPE27 = 'M500cUPP_errPlus' TFORM27 = 'D ' TTYPE28 = 'M500cUPP_errMinus' TFORM28 = 'D ' TTYPE29 = 'M500cUnc' TFORM29 = 'D ' TTYPE30 = 'M500cUnc_errPlus' TFORM30 = 'D ' TTYPE31 = 'M500cUnc_errMinus' TFORM31 = 'D ' TTYPE32 = 'M200mUPP' TFORM32 = 'D ' TTYPE33 = 'M200mUPP_errPlus' TFORM33 = 'D ' TTYPE34 = 'M200mUPP_errMinus' TFORM34 = 'D ' TTYPE35 = 'M200mUnc' TFORM35 = 'D ' TTYPE36 = 'M200mUnc_errPlus' TFORM36 = 'D ' TTYPE37 = 'M200mUnc_errMinus' TFORM37 = 'D ' TTYPE38 = 'M500cCal' TFORM38 = 'D ' TTYPE39 = 'M500cCal_errPlus' TFORM39 = 'D ' TTYPE40 = 'M500cCal_errMinus' TFORM40 = 'D ' END ACT-CL J0001.4-0306?×@í$Ì`ÀЫM§‡@\. c;ú@cæ¾ét?寣f o?Å+Óz!™?×[}8BÀ°ÝKÄj?º¬1&éspecSDSS@Ò½Ó:2?ÎBÿ "ë@$…RÛ ;?êa|+tÑÿ?ãß© ÷Ñ%@¸3r–z?ñs}^c(?éËé»Ûe@ëé­*nA?úX|ùN?ó§Îíòû‘@•éÉ­„@[H¥€"?ù¨!¤p0@ Ÿjɨ’?õ¢ÈÐo?ñy¥¤z<ÿACT-CL J0003.1-0605?é“ã‡àŽÀYÙ_?:Ã@ òKC´¨f@ FãÕ½ •@4B\%ú?ÏÛ_UKƒñABELL 2697?é‹bqƒýÀ]熾†Ó?ÍÒñ©ûçmspecSDSS@+ÀüIØ?ë\µ2‰Ë @‰ˆðüv?ôöÒëQÿ?ñ%nÄa¿úQÝ­Å ‰?ï\(õÂ\?©™™™™™šphotzC_SOAR@2 -ìÛO²@ÞN/¤€@jj0N+?ßñe@œÏS?Ûkün`@ R¯¾ç?â‡6Ð.bä?ßE¯Pƒ×4@%ÜÎä…?ëII8ϵ?ç)#h¦SÇ@q°Ÿ³ ?ï» ðbõ€?êÇL6ê @{l2“Å?ïº00cÿ?í26>¡°ACT-CL J0006.0-0231?øM¯c!»À:u¤_¸@$E¶IÒð@üÀsÆ -?éAÓ›Hâ?Æwt§zsŸ?ø{Lê ¬À3"Ú=Š‹?ãƧï²-specSDSS@Ÿ½Yë?áÖäwdI?ÝT  ø[u@`‹v®u?å׌äDJ?á2£Ï¥x@Ö!>ûüŸ?îÙ¼¤›m?é]ÂÁ6ò@Eæöë·.?òF€i°†?íÔM5K½@TSu,–?ða‰øä?í(¼ˆOgACT-CL J0006.9-0041?û¡/‘„€¿å÷T°’¶@ÌôKNÂ@Èþ²Zª?çƒùÖpAe?ÁèEúÔ¹ GMBCG J001.72541-00.68874?û½ÿÖTfj¿åËF?Lü?áxÔýó¶FspecSDSS@ÄVËô*s?ëˆò(’ÊR@AHm)ùW?Ú,Ú£Xê?@\¤­Ì?àŠZ±@K:?Ûpa.“ù¼@^ø ºÐþ?ãüáqbR?ßmø@v M@‡:¤‹Þ2?ìÕ0ˆ«CŽ?çêUøËÚD@‹N 0´£?ð§Yb—ä?ëuF€À«Q@ “Ô¤ž?îó„t]?ëÎÅ -œ¥ACT-CL J0007.3+0341?ýZ  Ì@ …N²±È‰@¶qáœiË@Œ$Á¼ð?îüLm$'?Ê»Ø$·k?ý}t”Ící@ ‚ÊÊ-œÓ?à9XbMÓspecSDSS@~!'ûÏ?ð¨ñd@%\ùJJ?å{X³mË?á’À"ü£á@ ˆ"¡-Z?é¡,mFrž?äÊ|aFµ?@?·W8j$?òç‡SèM -?îíø{4{@MXl±Í?öŸF7©u ?òYï²Ê™_@Á·M6x?óˆQ½ö`?ñJ9ó9Q©ACT-CL J0008.1+0201@Z,¸^g@0×~%JP@&s¾ÜØ÷@%X*EL ü?úa>µ ?Ã~r€bÜWHL J000810.4+020112@X¿%‹òX@)!s^ä?×l‹C•specSDSS@/«?>Ñ?âðL±@÷u€?ì¬"»ó9?èˆì8FÎ@×ßFm?ðž“ =þ?ëÆ™-ι‹@!X†_"?ú81ºN¨8?ö gâ$Xª@#^™ä4]?í£Ry%ɹ?ê¸û>öÓACT-CL J0012.1-0046@4ÒUÿÿ@¿èªèh¼\@¯d¢~"@óЦ`N?ãÌÚ8OŒ?Äw˜ù€@\(õ¿è× -=p£Ø?õÂ\(õÃ?®¸Që…¸photM13?ü( Ë?×@ý(U?Ó#'ïÎKë@[ óÉrû?Ü)k•íJÏ?×,³í‰-@.úVܶ;?ãÍDÍmz?àoåg õñ@ 0º½ð3U?èD(ØÓ…Í?ãø ©[·@´LA:ï?å›2Öˆ;·?ãm±Q)×ãACT-CL J0012.8-0855@ ›H ¢OÀÀ!Û —`@5ÙåV@ ,îOgî=?ñ!‚ÑzŽ?ÓtÊ«Mß´WHL J001248.9-085535@ ¡1ô -u=À!Ú]æ²'Æ?Õ‘hr° ÅspecSDSS@&Â] -¤»:?ïx‘ I’J@ /ÒÔ$Rã?ë×/û…?åÐ6e@Cl* á3?ñÞS%—s?ë— }ÐÆ@øV›šlò?ùcèûA"?óäœùG.@¹<妃P@^&B¡v½?ùFK‰àt@… öVñ§?÷¸sµ@Š?ôgh.ACT-CL J0013.3+0013@ -›)ƒ÷3€?Ì?Ήô -(wî?èj~ùÛ"ÑspecSDSS?óYª—÷ˆL?Ñw0=:ås@PQ0Pâ?Ý •‰2ÛË?ؘ=Æ?ê©w½@Rºi­A?ñâbÏR6>?î6ïÍNã—@#V -¿º©6?ûM¿„Mä?÷5aàÉÆ@%­ -ÙÞ -E?ÿà1æú‚?úíèjø@þŠë==?þ£ö’ñ’?ü<-Ò(ë"ACT-CL J0018.2-0022@=°›ÅFÀ¿Ø|®oÊ ¨@LÃÕ)*-@iáÈ¡Ê?ñ^?_ÂQ?ÆÃå™dsŸ@N´èN¿ØGèU–j?é¡ÊÀƒospecSALT@ ÔØ$ìÔ?èH1ÀE3¹@ "öuþI?â«ÉJ© ?ß~j-.—d@ /ÿ» P?åÃ튢U¿?â>B»'w7@’\ñ+ ?ðëi3­?ëæÓ|ú@?rD²¶\?ò¹Çų?ïd&³v£@{—Î:ù?ò5Zÿ¼?ð¥fD\~ ACT-CL J0019.6+0336@Ÿ‘ï§à@ Ûݧe:õ@)ÚÞqsÉ@)g!”ú‚>@è)¯?Îe ±•ƒNSCS J001937+033655@¤ðk‘û@ ËF½}mà?Ñ7KƧïžspecSDSS@!$-Öw?âÌb%™Êp@ 0p% ËW?ú_S«éè?õé'÷èñã@"Û†í'sØ@UeÒõ·3?úÚ@lmk@.ßIsÙU@ %C@`ªÜ@ä9wÏ/¬@2Œ`ÎKÒ@Gµ9"‡ê@ ¶]Þßq @'Îà M”p@ÄnÛÑ@Jg)áACT-CL J0019.8+0210@Ù˜›´`@dQU†Œ@€£¯ë;~@€£¯ë;~?êzÒƒQA?Źeõ«Ôè@àU2a|@b¬2"‘û?æ¸Që…¸?©™™™™™šphotzC_SOAR@Ö @ƒ$?ᓤÜÆ«@S }?áEÞ¢Þ2 -?Ü­¼U{@Åþ©?äE5ôÌ??àµPzÎ×@ÀÐ4C?íªí´#?è dÿ+¸@wcr-*õ?ñt¸ß^?ìŶq¦é@§l2ß?ð0 qÃ?í±µ¼š¥ACT-CL J0020.5+0239@“]/wb @:º#$h@»„_ùê@«ò[“ñ?ê5ŠS½ ?É<Ö%´uWHL J002035.5+023908@—K“ý@7íüÚ§?ã;dZ¬specSDSS@ꯞ×?âþ€w·a?Þü–Ì®@lÁŽæ?æÅAü)æÃ?âiËìn¿Ü@6Û²/ÑL?ðvh‘ˆH}?êÛL¼,µž@é…µAÚA?óË`ŽrM?ð´Ãì ª@磀z¼i?ñ-*?ÍÑ?îP´¯|éACT-CL J0022.2-0036@3Ú‘?þ ¿ã6òä€ à@%ãy` ûX@%¶Õ±wV¡@'³+ÎíM?Çν|à'e@7wwwww¿ã€ ŠZ‘?éÀëíúCþspecS16@(ñ<—ç?ñ}Qn]@œSÿ®:?éåIäçÅ?æ:ȽŸS@èn>3š?î ®‚æpc?éµZx@ þòI¾íÌ?öqa¼ê½Â?óCf[Æ@#  ß$ý?ú-r¾ I?öVr‹B@ÖÔpÃK‚?ú©{”žÏ?øÎB.%›ACT-CL J0024.6+0002@š©ÓQ@?¡!8­@¦ž‹×@}ð^¶ì?ç*øà#”?Æz ªÊ¢¥SDSS CE J006.158203+00.022075@¥QÌ[J+?ž÷ΩžF?Ø1&éxÔþspecSDSS@Ϙ¢ä:?ß-¡‘‹…@p4¤±Å"?âý„â1Þâ?Þ†sO­‹@3ÂÇ÷Ù?æ³G»š8?âàÈÈ@qqŒáz?ñ -†á}ãÙ?ëd]¤j#V@ü«Ì½?ônª¢âø?ðEáìN@ •óP¸}?ð¿˜ýÕšÒ?íV?ACT-CL J0026.2+0120@=,&{b@?õm/QÐD@ F7ÅÍDv@ F7ÅÍDv?ùDVv4U3?È×QØÜf«ACT-CL J0026.2+0120@C× -=p¤?õn]L;*?äzáG®{specSDSS@A3V@ -(?èÏþºÜg?å-ôÌ@I_`u;à?ìÚkŠ0?èN¿¦´Ùd@ €å‚?õ©W<T(?ò\n*¯†P@ áx?« ?ùAþ©?õF - ]ü@_âm<?ø‹lQvVÎ?öŽÉÔ‚×ACT-CL J0027.1-0843@,†äÀ!o`*-@óÀktóå@Èøm?õž¼l„µ*?Ôœú8£MGWHL J002706.2-084337@†²¸þÁÀ!t;1n±?Öffffff?”záG®{photzC_SDSS@£%øÜýF?á‹£'ùZ:@»IŠ1ˆ—?ï'zúà¹k?èÚâ+ö,@<ì°ñ–?󯹮‚± ?ï{¹Ñ@ƒã‘V?ütUþÆ?ö³{P[ë@ ºs…l½@ PÖ;?üpsðêa*@˜Å!Ù «?û-ÿøÓ¡?÷g§9ër|ACT-CL J0027.1-0456@2>´0ô€ÀÂ#Ÿ/¥Q@NïÙ¥ÚË@YZ4Ó'?õ®Ç@À?Ð@ŠÌß©@8P:…ËÀÊT€Ã?ç®záG®?ž¸Që…¸photzC_SDSS@']¥ú|œ@ 8œ-Ë¿@ Rl(GÖ?çcWˆ f?ãêË—¢ò@Åý/Sš?ì -Ýlåd?ç1»Y‡Ô@Q˜P_ÝŒ?ô1èØ[@’?ðÖc ´F0@ Z­Ò$³?øI…Ô6V„?ô˜ à&ü@m¤ý¥Ã?ö$çÖ› ?ôJ¿Y’ACT-CL J0031.4-0144@xD¯÷i`¿ûÍÇYÊuP@6›¥Ø.b@ï6¼<ß?ê¡´>'?Ȣʧ¨do@{2ÏÚc¿û¼L'þ6?á‘hr° ÅspecSDSS@ÿ‹Ïh8§?é,¡þT^­@$›­.Ö?ã;"žlÙß?ßV}k¾Ô@HUQÒœ?æìk•bo?â…¨ÄB²"@pâ•6Ü?ðÅ÷QÎÖ²?ëTäôK’ƒ@!«BcÐ?ô ’µ ú•?ð3ÎŒƒiB@·Âr ˆ?ñZ}¦ù¨·?î–¹®Q+úACT-CL J0033.6+0243@ ÏZòÛ;ð@½Ó^”@Ù2G @˜|Ãý$€?ñåÇäÄ •?ÎÌyÞ -@ Ó¦,ËT@ÇÁO®ùî?ÞzáG®specSDSS@ olŒÿ?àL‰zÍ°@ -Ó¶Ùœð?èLŒê5[ˆ?ãÏñšÙsc@×€Ý{òw?íTuþƒ(á?ç²>0”Ì9@ÎpŒ]´ÿ?õ§é{õÏ?ñ•Ha3²ã@vmžt?úe„×?õE 5@¹RB¯ƒ?õôýEÉtä?ó^y×ACT-CL J0033.8-0751@ îÐчÆ@Àvrг†1@¯"$Ãeb@úôAF#q?ù"­`ä;?Ðq_Ò—è@ ñ_)4³Àzi¹aÚ§?Ó…¸Që…specSDSS@'Ï2Ýø?ìW*=ÊG.@2T1¨6?ð;UÐ’†\?ê‹H™nÂ@뙩š…?󬈼fϲ?ïÛ¡~»@{@ åoÉHØ?þ$Æ&þe?ø¥­û…‚4@#~¼²úR@UgÕ©,?ý°: -5ú@Â{ÐÄÖ?ý}0;“2ú?ú\W ACT-CL J0034.4+0225@!6Ÿ•ejP@`OÐQòÝ@(ûçd©{3@(ûU J¥@Ǧ# Ð?ϽaZ´v@!<‰\Ò @b36‚ˆ?Ør° Ä›¦specSDSS@ ™™ï?à€8ÌÍÕÙ@CüO á‘?÷¯óD›?ó駀IΨ@!õ8èODs?üÁ[ÎZ?÷õz“±sÕ@,ؾ †ª7@Ùò9WÖ:@_CÊA@0¡Á×K@ - nƒÃfb@/¥wuá @&ýH”‰T@ç&%ˆÙ…@ßYc²ACT-CL J0034.9+0233@!yþ¹…=p@‡=7DÏå@]óS@#¾Jôì?ò1Ø3¹?Îk‚Z¦«@!{Qt¯k?@x}}ùwt?Ø“t¼j~úspecSDSS@z`_è ?Ûšã•|kŸ@ tÀ¦07?é€ÐÈU• ?ä²lÎï @”,kVÕ÷?î×qÔ'©?èÉÁO(]R@ÍÛv ’?÷ -5uÜP(?ò²¨×>^ÿ@Ÿú¶¨«?ûô”£ãá?öx,8¿è@032'_°?öÚOÃì?ôQùÔ^ACT-CL J0038.5+0044@#L(:·0?çÛÎ,$(Í@‡„I†×@{½ÈË? ?ðâ{R˜¬—?Èþâ‡@#QàËìö#?ç‹ù²ŒŸ|?æ=p£× -=specSDSS@Vî˳–¸?ãã´ü{J@ 9˜àæŸ?ã¶mƒ•Ã.?à}§#»_@ ]éar—å?çÓ„"ùÊ?ã)ä×@Åd¾„d?ñ(%-‡´?ìv¸çë2@‹€¿Îv?óó‡{ßê?ð”颕‘N@Œ;´lõu?òÑ|z/S -?ñˆinŇACT-CL J0040.9-0328@$w'2ââÀ Ö¢og -@—¬.„@vÛ]ŠÛ?ðݾ§æ¬?Îæ: Tj@$s -+ùAÀ ½hëÿÃG?åxÔýó¶FspecSDSS@°Ìuè…P?åœñQÕª?áºè¥­Ñ/@ ~{} øÓ?ê/î©ìÁo?åKi×u}@V)çØ×?ò¬Œ>SgS?RˆÓž@³®êhô»?ö³ºAÑ?òuçµ l@'¥eÁ3?ó£Lµ0?ñŒyÿ‰mACT-CL J0044.4+0113@&5ÀJD?óx4š!|@‰%£Åò@­ oú?óHÒ¯ÞØN?Å„¦¹¤,@&6iÐ6?ójœe}b?ñÂ\(õÃ?ž¸Që…¸photM13@‡(âP¬¥?àŠEþ??ÜODiŠê£@ { ²¢Ê?ãDÅýŠ5g?àe»´@ ‰?ΣK?ìe;Oä‹*?èL{¿$i3@¥ëKm)?ð””e°`÷?ì7 âeœ@ y;QÄ?ðÛ@$º?ïF”MãÌACT-CL J0044.4+0150@&:u$€?ýg,q+̉@ ûýå]@^ùÔ–Ü?ðùùÉ×’?Ì Z}Ðø@&<=hGŒ?ýa‚Ñyµ?ÖéxÔýó¶specSDSS@6ѵ Æ*?ã²× ¦8@ -$ Nx©¨?èe™[«”2?ãÈ 7©m»@ ø ¯T_m?íY£g±ã“?ç“Öqš@»þ ÿ?ö&£´ªdŒ?ñõÜD@LÖ×{Þ?ú¼ˆ%¯fy?õzTÉÈ­@8 _X¸û?õÔø‡·í?ó#8ÀÞrACT-CL J0045.2-0152@&šÚ 尿þ®Š¿´Ú@#<º¥;gâ@"æÓÁ ÎÌ?ü§ô0?ÈAÈQ@€@&šªªªªª¿þÒ¥©?ዬq ²–specS16@¢Vtº4?暪”>@uk)t2??ëûY-½—Y?ç·éjìÊç@¾ê˜çi?ðHú¶_x?ënìØÈ@!6F†¥ö%?øÀHßÑ{Ë?ôúÜ㪺T@#H|ؾ>?üâLJªxé?øT"¼Åé@—P† ?û®‚nÎ?ùo¦ÓC‹ACT-CL J0046.0-0358@'Ó m:ÀÛÿ¡oÚ @¼óÏ°kL@ºÚ}/8?ðõWèï?Ð7ï[`”E@'¿­WLÀâë†/Sÿ?á‘hr° ÅspecSDSS@ -Pt:m?öGDœÐýÚ@ =™‰‚Qu?çSRô-?âòª}ʇù@ Hœ#¢?ì— ­?æëñÄ8W@%^+X?ôlÓú »?ð—„íáW@º«¼¿?ù - Ñ7?ô#°Àà¤@-!XJô?ôïøò6‚÷?òdÁ-8I’ACT-CL J0051.7+0242@)á*7‚ @²Št1É@M[¹ÿñW@%ØŒ[ÌÎ?óW§(¿?Ëñ„§ï£WHL J005147.0+024237@)ä+Vs'„@®ªSQ#»?ã¶E¡ÊÀƒspecSDSS@?!ê²>ë?ôm“«õÁ4@ $¤p}?æ²ò4 d…?âãÙ®íòÒ@Ø\´oß+?êÑ”‹No?æ'&ûêàF@ƒ+ÄÆ!?óÅFŒ¹NÙ?ðsúb4@Ð’P{§?÷l2êéN|?óYd[¤)û@±‡ø[ýI?õeÍð‰H?óJøc#ÝéACT-CL J0053.5+0329@*ı g @ ûâÕ|6@6é›.l@ÜéâúW?ñwdQ Ÿ»#?öbA  ù?ózÃ* ò…ACT-CL J0058.0+0030@- # L`?à‡ª›œ¢y@ ¬¼½…¯ë@ «Zòý¯ø?ö3é™f!_?ÅO¬íiîACT-CL J0058.0+0030@- (õÂ]?à„5³ÿü?éG®záHspecSALT@1xæâüìˆ?û Ko0_@IÓmäMM?äÓ‚+™¯ò?áÅuª›b@Ίö¨Ì?çðraÝ?äR5dJ‰[@g¿‡º™?ñô-‹çú?î£û);·Ê@ £üx"É?ô¯”á¼R½?ñ8QBu*@EW²¯f?õ?úã³?ósðV8ËACT-CL J0059.1-0049@-¾P|€¿ê‹°¡PÉ@@(ŽÖðäbs@('¾nn4;@ª¿Š•¥,?Çg’µfv@@-’"""""¿ê·£(FÿR?é/Ÿ¾vÉspecS16@8¢¤þƒÞ?åÙîäoRu@ ëÅ=Ýi?ë”=‚UÁ?ç²%?陫*)nJ@ÜúbÏ=ê?ù&ÒÞ×\?ó¹÷Ͷ·@ØBÕß?ÿ¨i÷@!÷?ø€b‰‰¹V@¤uþIÝ?öƒÒ¶S\ò?ó†$XÙACT-CL J0106.1-0619@0‹$6ï‰0ÀHÜÊ4@ý]­Ã­@@ômÖBS2?÷chëðƒG?ÐM[&D4@0‰‰HøÀ?åy¡Ù?à?ž¸Që…¸photzC_SDSS?æ7ÂV{ªb?Ôº™9Çö@ME×o?ëwD9h t?æ¼ïKZX@Ó'öe#*?ðp·F-&?êü®']÷@GXDÜ?ø_/ˆÔß*?ô,kî‹Ÿç@ Á§‚ÑnZ?ýCo2̨Â?øM 8þ@B¼í<Ð?ù”=¨Ô¦à?öî– ² ACT-CL J0106.7+0103@0²ÓÍwÑ?ðÛå.ÌðÍ@’BǪ@w[­$v?ç!Š°ÀD?Æyà`6¦}MaxBCG J016.70077+01.05926@0´ª¤?ÅA?ðæeÎu„??Ð1&éxÔþspecSDSS?ÿj o5Ä?Åâ¡¿‹Ôî@,ƘúŽY?É×Љ´b@&ÀNnT¨?ä<í?@:?àä?ã9ÏŽÞd@É sÔ‹[?òËbü9?í»×m›Ó†@š _c²?öåEºÍÉ?ñêàÄ ‚@ )í „"$?ñrîßæ?íÅ|¡í5mACT-CL J0108.0+0251@1ÚvàH @ê›ô·/ @*)Ÿ#@Ëé…Á.c?í4¬×T×M?ËÒûH0WHL J010803.2+025200@1q+±G<@îǶE@?Ô›¥ãS÷ÏspecSDSS@ʶ·üÁ?áz1~A„@ÿ¯þ£AÐ?ç:O'EÁF?â‹—ã±hC@ -¤n5‚\??ìTŽÊ(„?æaqûUùø@N6ÛÆ?õ8ÝŽ4)#?ðñ§—³G@m¿‰[¯(?ùùøÃ(ì/?ô…h•˜Ÿ@é.•–(Ü?ôH«"jAj?ñ{×â&ÔACT-CL J0111.0-0058@1Áø=Â#¨¿ïa%ØYd@ÞÊ=­‡@wæaßà’?è¹ûX­Í?Æ¥åÎÏ'SDSS CE J017.754179-00.974395@1ÀMQ¿Z¿ï aß™]9?Û¶E¡ÊÀƒspecSDSS@Ó+ßÆv?áfjÊ,;@”!2ðP?àBJ½"u@< l÷Ð?ãñü›=?ßÒ"˜Ü«@Y"ôŒ?欔¹³f?â>¡»…ˆÊ@@‰Ã$©?ðüL€6Æ?ëŽöRe@ËÙ†èL«?ô2(<Œ2?ð@%3ªÂ¶@9 Ü{}?ñ ´U<ùÉ?î óqº˜QACT-CL J0115.8-0206@2óf`¡š ÀÞ×y%g@ÜJ…‹÷@ 0‡añj?ë;=yt›?Ê4Üö‚þØ@2òö6m@-ÀÇjû×fý?àÄ›¥ãSøspecSDSS?ÿ -CxžjÏ?æ•‹ç­@Ãk×2í?ä'¦H!±I?à]—¸®É@÷±þ5:?è8œÍU?ã~SE²@ܸø]?ñ¦™ºx7_?ìª!ÞW¥š@îáK“`?õGu‘¼?ñÔ 1Ú@VÏKi5?òxTã¶?ï¿Ûþ®_,ACT-CL J0119.9+0055@3ÿÀ˜ˆ£P?í™SW;à@þ<%t›J@û¸Øté^?먡tè„}?Æ%=Í@ßACT-CL J0119.9+0055@3ýù,_’Æ?í¡ÊÀƒn?çdZ¬1specS16@$ž Lï1Ù@³˜ßþâ0@³¨Ó¾Rå?à‡ˆÐÝ@ª‡¤ ‘?á{kqÒ:?ÝX­¶mk@mFVZŸx?ä…Xà­ÒÚ?àõ†+v@—ö^ˆÞt?î€DóõÔ?èøu©6N@,iuÑ?ñ¨!dG±?í/$‹¡¥·@ܨ–ãÕ?ðz*“ô%?íµì¿¨é´ACT-CL J0120.4-0019@4Óɤkˆ¿ÔDKW÷Ò@áZ3¢Ÿ@Í¢ù"h?è£yü”EÎ?ÇuóÁÞ6úSDSS CE J020.121334-00.319887@4 ÜùªŽ¿Õ*TŸÀö?ÖvÈ´9XspecSDSS@ ½Ö‹Ðæc?ߘ zn£@SôkÙ´.?äGAoø?à^Ì•a§@CÅÁßßL?çþµô-Ud?ãƒ=Á2@`ûIéþ8?ò -k8ð¶?í -PÙ¤B·@ÜÈѳ‡?õÃj+ ö®?ñMS’ÿw]@ äßéå̼?ñ›í?O?î‡'Ž|m¦ACT-CL J0124.9-0440@5?—OJ—€À¯¬ÍATc@ññ/ @\G[2-4?øˆ-ë(›?̱Q&‚@5?b0vÀQÀ².ä¬?ï -=p£× -?©™™™™™šphotzC_SOAR@ ¤wé-²Í?íöŠÈËã}@­ÊO©`?å.i b?â9‘9å@þ3D4Ã?éÃA%ñ?å.a¡GÞ@Í9ijÃF?ò5W8Ý8]?îô“ðÆ@L'JµO%?õ ¹ #?òB»2Jò@Ã:“ ?õ!Ycã?óy _ˆ¡(ACT-CL J0125.0-0531@5B¨¨³#ÈÀ?ÂÈÙ@3ÿ‚J@äEÉ ”?õ—Á’!?ÌëÁQ¥v–@5E[ðT-Àu¡™d?ÞffffffspecSDSS@+öí¼¾%?ù§V M@mÜR„–õ?éé{äÜ@?å{à)=™@Ë‘.÷éJ?d?é>:w¬@øÚÊn\?÷ÓÓQG[?óééá{Ã@ÄàâQm8?ûc«8÷“Z?öˆaé t @ña~?ø8]ªcµ?õÀ}ØbACT-CL J0125.2-0802@5RõWç2HÀ  »<³@Âc¯ G@¯L8%çO?ú€u3–ÑÄ?ÏÇÔˆ‰Ü!@5UüÁr&À GG„#?ñë…¸Qì?©™™™™™šphotzC_SOAR@A±iŽ˜x@|2äNH+@ »‹¹C ž?ä½èÔG_0?á©^`ÔEÕ@ûlû)#?è×Bû¸¹â?åAL^Mµ@£uj5Œ?ñâÀ4$Ž¶?îu”RG:@`a«ÛŠž?õ|,ˆÜÑ?ò)öÌìö@ܹÀ\?ôÍEªä»L?ó4rzYºACT-CL J0127.2+0020@5Ñ—“™H?ÖVò'.@ Ekü³_O@ ³׀Š?õÐCÙ¡Ž,?Å­].WØÐWHL J012716.7+002036@5Ñ´èN?ÖyI€ ?ØSŽóMjspecS16@!–uä¨rÙ?çÇÍym¥Ø@#»°ºØ?ÕQÊœá@^HÆ/Œª?éÄK”9?凙ɨ -@@È“ëÔJ?íäK—Ø&?èÐs¸`1@º,…¤G°?÷e¿V]Ñ\?óŒïéDKç@ ž™_]u8?û7vª§”?ö—Œvã@.É¿Ì?ø†¬£,ì -?ö5H¹ãuQACT-CL J0127.5-0606@5âöN`ÀnÒ9&ω@¡“ä>¡@‰p7óí?ñÌ€ûQT?Í'9&Ï÷ -@5äˆu­æ¾ÀoÒÖÓ'Õ?à9XbMÓspecSDSS@{ÌŽ -†?ëì7æê©@ -ȯël?çq +”Hx?ã;¹B(³@‹Ä5HË?ëúÜè`©œ?æÄ5ðçe.@ HªË’?ô­†àpãŽ?ð÷7们@Èﺋw?øÁ‘Eù†?ô$±t> -Ã@±­ÛÞ‡u?õoƒì<û'?ó Y±~ÓACT-CL J0129.0-0845@6@ß ÀÀ!ýÇ6É@¯ì-sÞA@K1ž¸?ü¨U½g­?Õˆ§»Ö°WHL J012900.7-084520@6@¹yÝ À!‚Þ¾¦U?ÖéxÔýó¶specSDSS@0%Ù¾§h?ôø¢€Õ@ŽÜÉX²ˆ?ò°ÉTEû?íI !@²‡@íSßB?öhKYªCÜ?ò÷ý·X@!ï%Œñ@„È©Nµ?úÚ’ÂØb@%ë©’þÁ@¡:jü@”APÔéR@ÃsdQÖ@0¦7ô}?üv qACT-CL J0130.0-0305@6‚ËHà¾èÀºFë Ç@91îBÈÊ@Ñß`c&?ô€ñÄ}ðŸ?Ë‹ˆ’Q—E@6„Š€‚¹ÀÄ ´\ -?ê$Ý/Ÿ¾specSDSS@ ãv±ž¦?äøj•£ð]?á¦î'ˆ£¤@†E`’ˆ$?è½C+4d??䮆ëáQ@ù³Æ.°?ò'sbu?îY¹¡·o+@,Û÷{X?õSkþ?ñÔjyŒ@› -!¹®?ôW®ë Ç?ò¹¹WÆBACT-CL J0130.9+0406@6¼+”–¸À@to¤uw†@Ô x±O;@ÜÜF;xã?óäïlIÂJ?΃¹=²´WH J013056.6+040729@6¼R$àï±@ÕêË?æáG®záspecSDSS@ ÐQì±?æj9sK?â§üÝƬi@Áa☀?êËD/^ù?æ iyò{Œ@ õÛ½´?ó\Iøé?ð,è¨M@‚~}«?÷60’¢J?ó+½ªÓ@s‡j:µ6?õ"ý{°[9?óoé¡»ACT-CL J0137.4-0827@8Z!º`úXÀ ëiا=@&Ê1£‰Õ@&Ãw: @¡Q¢mÄ?ÑOß‚ØÉ@8Z§Ú¾TOÀ é¡È"³f?â-V“specSDSS@-Ä•v:Ð?áQEl óû@ÍÜÔ‹Ð?ônnÃ?ñZZk¸¶2@ q·ÙêÚ?ø‰R  þx¢@&—5Ú¯s¯@a¢GìÉ?ÎI{ÚL‡@9ÚóùàìÀ«u'Î Ì?ÝV“uspecSDSS@5eáR—?ÿ ÆœÔW@ «$ܼÞ?óëܱk\?ðÒÈù‚üë@ÀÑyEZ­?÷Ç¥hº¨?óíxMÎ`@«Óšp'?þuxJÙmî@+î'ª[@˜Ëw¹½·@&„F»@#âîÈGôH@L-‹@Ùl±t¶ûACT-CL J0144.4-0738@:ë/ íˆÀŠu*—†@ˆ<˜øÖK@ÜÇÑÙÛ¾?ï!]Äؤã?ËâpçÒ$í@:ÞQýÀ•Òl„wµ?ÙxÔýó¶FspecSDSS@'²‚X¶K…?ò,/^ÅË@J6Qõ±?æõ?#Æ ×?â‘éYéœ@ æiÚ¦Ø?ë«1ùÏ U?æ+÷Øu,@Ï»òѹ)?ô­Ìæ®-?ð¬ðßK÷š@"Ïb×" ?øíuhž2«?óù¥|é @ÜsXÕ>fàÀ©Èùân?Ç -=p£× -?”záG®{photzC_SDSS@bÑ ¤H®?×ø†]D¸~@pJR?ëjþ¸N‘?åi‹pèÌÔ@ Aaõ{?ñiúìTNâ?êÉÚo+ß¿@t 1?úP”±´Ïû?ôŒý¬–Œ@øÌLA¦z@Ê !]y?ùÓÒÔ¹h@ø6n!Ü?÷EâSŽ?ó’Š5XzfACT-CL J0146.1-0315@:†–ÎVÚxÀ -¨¬98c@]VŠ™QD@ûj• ƒ ?ósõÜŠ}?ͪa.Xý¶@:‡n}ž‡:À -(ºÄ?âáG®záspecSDSS@ …ÙÍæÉ@?ê6©ËÐ@ @y.T7“?çqU¡¹ù»?ãjGÿœ?@\TK&?ëíÏQɶ?æò-g€/@­¶Üzà?Þø/máo§@®ŸˆŽû?åÈÓáŸ?áØ»€º C@¨¦k y?ð¶Dàò?ëÊ-‹@’Öu‡‘?ópœ¯*§?ïÚ²0ü@=lç$F?ñYÔh¤J?îüÚZYÄéACT-CL J0149.6+0440@;iÐ6p@´#Žÿy@G Öî%\@Cé2éÇ?ïz¿ëÞ1?Í,+ |ñ@;n¬"·@½ôu°ê?àspecSDSS@ô5Ø:eâ?ò-ì8üÒ @; -´?æ\pss?â+±9…a@ àƒÙÞg?ëf`œIc?å½…pþ«@Y3Žµô?ó³Lnt}?ðÉ’òÿÆ@£Æ©zðñ?÷Þ’ $Uû?ó77´c~@ÑiA*?ô{Ü… ?ñ¥J“G,jACT-CL J0152.6+0100@<,X=(òÈ?ðýaÚ@'ëfj@'ëfj@Qƒ<¹D^?ÅÕ ¾hú¨RXC J0152.7+0100@<,±~Kå?ðiÐ6?ÍS&Á½¥specS16@0 ƒ€?Ù«íMï[@/‚DK0°?Ì礇¹™@0ó÷`øÇ?ô+|Ÿ}-Î?ð°Ø™XÐN@©Oší€ð?øOÌŠ.Ü?ó€!ê@'3ÄkUaQ@Xc|_¹È@(ìø„@* öHq±@gvÝËÊ@0"áã_@!ɤT‰¿@ÅáÀŒ¹ @ÓF‰ ACT-CL J0153.5-0118@&*§Ì@|FEv#?ïø,X?ë%&w?@ß@,`ý§¬?ò“9¡B…?ï\èko]@GåY“?òˆÂÄ| ?ñ½ÊÊŽ@ACT-CL J0154.2-0737@<’¼ÊA¨À{Ö8?Öi@ &°ýñ@ÐV“²ˆ?ïù‹¼í:õ?ÉÑ÷ñv.Ž@<”n¹xÇÀ‡iøcŸ0?ã+ Iº^specSDSS@¹Ää°ºn?öÕîí÷Ô@…ÜçûºH?ä¢_eD-?á O#Ä4K@ Êpn{d;?èe¿;×j@?ä«ìã¤<@TÜGÈl?ñòìjòx\?í¨¬ŠA}Ù@=ñp´/?õH.Fi+á?ñs¥žÃv3@_H'?ó#ÁÙÊf?ñþÊ`fACT-CL J0154.4-0321@<œ·`åÙðÀ -Ó7 Žt@!{:ó)œ@!z÷ $/@?þZôKô§?ËÈݱ¾yº@<œ²ñq.PÀ -Ø€HÒa?Üj~ùÛ"ÑspecSDSS@#Iø$ÑÕ?ï $ªEÌ@ÄJ»£Ðp?ï¦÷âÚÃG?ê–; ÐÌ•@i³±È/û?ò¦Ð)1$‡?ï™[pž]@"¶I¿~œ‰?ü…>ؾm?÷ôÏM2>Ò@%(©ø( @Û\¤«z?üé<þs@ŠŒi_³?þ‡úß~a?ûËôôÞVíACT-CL J0156.3-0123@=:Ëůȿö.mÆcKK@ݧë…ÛŽ@Ú'óD•?îÎ(•ò®?ÃÅl.p«ACT-CL J0156.4-0123@=ë…¸R¿ö5Ñ¡V>?Üýó¶E¡ËspecSDSS@¿>ó/b?Üò"¿Cý@Ô•y'®l?ãÅ̹z…»?à}iÉõ ø@ jó¡é„?æ¿îƪb®?âÛ¬Ó)gÍ@sÐ?cw?ñ‘è¨.Ü?íNHñ„x@Œ ¦l?ôC®GO9?ðÌBãÙ)@Aõo¬<|?ò»¾ØAü?ðí»¯öö ACT-CL J0159.8-0849@=ôC¯ÝÀ!¨fçX‰B@!by©=ŸŽ@!´ÁÈá¨@#dÙJ”}?Ñçûó{GMBCG J029.95560-08.83299@=ôŸ/“œÀ!ªƒdÂ4Ê?Ú¬1&éspecSDSS@¾±ê2ó?åöí­D÷U@ô´ -ØÀ•?ó¦x - …?ðk ÏA@™ÁÊb™9?÷¶‡¯?ó¤KóV –@&ÁËT”ý@ë;èMΞ?ýñ‚ÐÆÓ @*+Úƒ­E‚@²ìƒÓÐß@ù2œÔ=<@"Y“qc$1@³“‰øGô@î˨TyPACT-CL J0201.6-0211@>k¢º7PÀ˜àœb á@-+†j‡@+}á+±?êÜm'†?ç¾}fo(ABELL 0291@>mù SÀ’ÏÐ]Ð[?ÈõÂ\(öspecSDSS@ -ŒÑÒØ?ÊÈõä¢ @º–á÷Y¢?åÚõ¦°‘S?ávì/? @ÑõfpFM?ê(È×?ä´;:ñÝw@ªí†9’¦?ôÉ·–ýU%?ðœl­V×<@°cL§Üð?ø÷–bÚ£I?ó®µíœ°@ôGLM¡î?ó´à:?û?ð|HÏ« -ACT-CL J0202.0+0440@>v,íVP@³G)„è@~Χfµ@ c=!ð?ò -ÌÔHÄ?ÌÌÒñÄór@>ñð3ßt@—–Ç÷7×?Ý?|í‘hsspecSDSS@"+²Ïj×?ðÀÕf™L@ BšÂË?è˜õnð?ã®Sbx…@tÌ4e?ì´ZÁÔMÇ?çR€Vœ+@Bï%ÿ¾g¸@+è·®ð @$:7Ú½™@   ,V¥É?èCM¾Ê ?Ê55FC®@>ìÛ!¸ä@Î#ß?Öffffff?”záG®{photzC_SDSS@ -a:\Dº?Û›…¤—ÏC@Â|lT?äÄåV?àrm:|ŸÀ@üÙÅÖLN?éuO¶ïŠ2?ãð#U}ÞQ@Û0}^PŠ?òÅ€¸Ï…?íºG© -­@Ù[Ï"†?÷ú™å´?òGf´ÿM@ Uó6PÆ?ñîËuá?>?î¢oˆÜœÆACT-CL J0204.8-0303@?5 ?=Ü°À|AÌTkT@ÜÐÕÓW@^pÒï˱?îˆõ-ä¹?Á—†WNRI@?5ž8e¸†À{X|ü¤m?á‘hr° ÅspecSDSS@F¥³M ?âYl$·`Û?ÞݱêÜR`@ -Ëý(Ç!¯?äó$Τ]?á†Káä.@=!^,>C?ð ¹áR†ô?ëaÝwí@"3ß)?ò^¢ƒC¿?:À@Ù—ôøm[?ñ¸{Ø?ð1µÖØACT-CL J0205.2-0439@?Põо³¸À›»öºœ@ ¤HÇ/Áz@ 1ÛfÃ?ò%I‹`¬?Áíl¹G{@?QÌ1œZ>ÀŸF°¾yM?îùÛ"Ðå`specVIPERS?èÛ«Ý" ?¶®QªFç£@úÅËÉãÐ?à˜ÍAdX?Üw+ð6Ù…@ ¡æ†âš?âÿþdrŒ?à6…Ÿ’² @båx}hJ?ìk=*–mµ?è^ìçº\á@µÊ0a•e?ðM‘ð齋?ëҾΥä@^ è« d?ñÖB…u¦?ï«ßJøACT-CL J0205.9-0307@?}iÐ6˜Àú<vÔ_@óc·Ñv¿@7õ{¬ ¶?â0îvÇ]ß?ÀçZ432Ž@?rÍÉN7Àèh‡z˜É?ß²-VspecSDSS@–Ûàæô?Ý÷ΙŽ_?Ør vûð@˜cÑlo»?án7H‡ü?Ü>‹þ¶F@ ’pc[Ë?ê46–L?å`’¦Hö@MGWÁè?îÂ/¡Î?èÂhò ž@eavšÛ*?ë½Ôá©£?çì {²äLACT-CL J0206.2-0114@?Žü ¦8¿óÝ=¢¤Ñ&@%p‚"_Ù@$Ňü´¡É?øÝÑêQ?Ã'zo_RÊ@?ŽKä±~¿óÏW›à%?å 'RT`ªspecS16@(ÌK¾†ƒ9?ó÷7D¸Ÿç@i$F¥?ç!säC{¯?ãÇ©ÿ‚@5@ÜÉ ?qÛ?ê€Ø ?抱.Ø%Ç@³òž{Ì?ô up=S?ñ6EØrÔ@ sY¹q2”?÷©íqNZ?ó¨ÑLç@šžÂ˜?÷„Qq_mi?õÍ0@™NþACT-CL J0206.4-0118@?šáœ¾ÿ¿ôÞ£b¹8ª@6·ëûL -@¡ª®?ãèVÒ mÏ?Ã'zo_RÊWHL J020622.9-011832@?˜a éÔ·¿ôð¼…]ß¼?ÈõÂ\(öspecSDSS@ta¬T?ÒãÖskn@…?â»õÔJv?Ý`ÝŠ¨$Û@¨µñÓ-ì?æËbxå»?á«Íq<º+@êàÊx‚?ñµ­ÓF?ëÅjðº@¦Ä‘9ä?õŸýø_Æ?ðÃñ]ºLM@ ýs-*¬?ïóÃ_#¢H?êýçõïäACT-CL J0207.7+0021@?ï[ž È(?Ö…—Ožxy@4ÿìÉ@uQ6^1?æï |1Þ4?Ãá5ú|FB@?ðËЮÚ?Ö~0‡‡H^?ñ™™™™™š?”záG®{photzC_S82@O¥¼R-?ûBÝ8¾¹œ@*°º9„X?Ú½‚P¡–­?ÖaÚ÷G@}•ÆtgÙ?߯Šõ¤~?ÚU“)ÕµA@ ;ÕþQ7?æijK V'?ãÂG÷E@£òm?ë _%œæó?æ{¼ÏÏh<@ >Ǩr³?éñTpm*?ç0&R·´ACT-CL J0208.2-0237@@¿ÖkÉ(Àö\_€Áª@òêYÐB‰@Ó0c‚?à;ÆK ä?ÀÚ1ƒ™Â¥@@˜ÀÀüÆdç5¥?àr° Ä›¦specSDSS@5*'Pá?ðÌÙšìM?þUwÑé!©?ÜžœP«¼f?×(KvÊvI@"Ô§Òn?àÕÊdÓ"?Ûø—¹@ -eD±»?èç&p¥5ü?ä&l»°¨B@ æi(®¿ ?í_üÙø„?ç•1Òº–à@Mç)g§Ï?é„jtÖ¶?æR(ÚÞ6ACT-CL J0209.6+0223@@3Iž”@y³Bu@qk†¦ã@˜19“ÖÌ?í<<“®xä?Ê•úXÚF@@6l.ñª @Ö—v-?Ùûçl‹C–specSDSS@͸"¼¾I?æÑi1iÃ@,r"Ѓ¥?åçFê’,?á·Š¿í @ -U¹µ?êRIÆÒ=?åS^7¾ @À@üJ”ü?ó5¾ý?ïºÅrrp@Ûÿ6+Á?÷¥(§ò#?òó<Ô¤@ -°/èS?ó„“æÓü?ñ hfACT-CL J0211.2-0343@@g«À ÀýÆï@Ù‡§¦çí@äšAëT?ç¨ÛÆKø™?ÃŽûÖš@@gëO:äÀ ȉWýKñ?çe+ÓÃaspecSALT@Ý@d{>?ÔO.Þ÷þ@Œ`àÁ,Ì?ßd3•'‘„?Ú$ÄkgJº@åC"ZÙ?âA}.¨q?Þ6»ø¼ÁS@½2é(/,?êáQ…B%r?æbóß´ó@Ëo^ízê?ïW> -ÊÄñ?éïSÓØÕ©@ ¿aJ…~?í¤ò®ùé?ê¿éúPÙHACT-CL J0212.5-0300@@‘Y”ä‘`ÀTÞ´Êß@‘U9Ç[.@MEkªtí?áQêµá[?ÀÿÑÒMr@@‘)–ÅèÜÀ‘°ý(?ØbMÒñªspecSDSS@-ÿ˜Xq?àÄÈš©£?ÿ‚Ò‘l2?Þ‰aÍÚ¥?ؔқ„÷Ì@Çm-}P?áëSvP=?Ü )Q­–@ '¨Cnõ?ëHÈ ü…"?åö™_§d@Ûšæð\?ð ÷cpw?饖ÂýBó@+|µõ|»?êÿ£îÞ‹ø?ç{¬¾mìZACT-CL J0213.3-0605@@©¶+üµpÀaÑQz@rJb¶ó@›ñôC{E?áÖ0l/a?Â¥«±˜ÄJCFHTLS:[DAC2011] W1-1207@@«ÝÝ!u Àec̳R?æ=p£× -=specSDSS@!ñ UmP@1#Єá¼@ D¥t­ž?Òª”Àcáõ?ÿÓÁ¯ID’?ÜߪAya?׉'ëðÿ:@fqm¦Ò?á²³ðÔ?Û­ÔUÔb@ 2t‹&o?è¬[Sy÷ô?ä¤A Q@±×aŒ?íSæí–Ü?ç·c› Sá@fÿ[=g ?êÞ15á?æþÒ¸â¶6ACT-CL J0214.6-0433@@Õù,_’ÈÀ3Üè³aÍ@go¿RgÁ@TkAØzM?âÃkü9Ÿ?Âbl|ãÈABELL 0329@@Õê£~´ÀDø¦Gü2?ÁÔ•*™1specLit (1)@mì\¬*î?Ö¬^32È@‚p体?ãÊØ79?Þså²»°@uXéÚÄš?轋ÉÉoL?âÅëË|Ø@ëOÐgqë?ó!Cœ+Ý?íp6*´@ãüœfëq?øºÓªÏ?ò9­ûʼ@GZ¹ÊÎ2?ð‰qìà…?ëZ\¯<·ÛACT-CL J0215.3-0343@@ì¦gE/ŒÀ ÕratÚ¦@ÝZÏwK@qã‹a?ê/,1δ*?ÁÞ—§öœÀSpARCS J021524-034331@@ìÎX%[À ÍìÊ™æ?ðbMÒñªspecLit (2)@ ïu ª?ÎáD(û|ý@¦¡×Åeœ?ÜH¨Û+J?×ø˜ƒØž&@輌t‹Ò?àXf?òà?ÛFC•çŽ@¾Pð1ª?èZ/R ÿ?äl¥’ï@¶ ú .?ëë<â ˆ?燼FÝ@ åý"J!?ë÷˜ÿÖàÐ?é²YügbACT-CL J0215.4+0030@@îÜÉsú€?àTÑì“D@"›Àà"ˆH@!ö‡K!)?öñÅ”¯?ÄoEÌÊ}ACT-CL J0215.4+0030@@ï33333?àTàÓ+ë?ë•$Ý/specS16@O³G]Ž/?ä<œ«†?áW›‘úì@Ôx©fGš?çN¸–E d?ãÞ=· =@Õ€£Õ?ñhýg9F?íÖùøk¼3@Çù3&ˆ?ô_çúëD?ñ"ÄìzÈ@I©x=Bæ?ô¸Çzp·ö?ó@#0ØqãACT-CL J0215.5-0355@@ðjÛÙÀeç†EÜQ@ç ˜…”Ñ@Þi•.¶¹?á<á_D™?ÁÞ—§öœÀCFHT-W CL J021533.8-035718@@ðÙ/±žsÀ–lmçd(?ç®záG®?”záG®{photCAMIRA?þðoN‡B3?Û©7þp9?Ö›žÉpÓ@4S”ëF?àXJ[ÀLÿ?Ú„4SØ£s@ -YˆÐaÁ?çŽÍîn¯‚?ãAש´…@ ùYúe?ëê -Éwår?椉¥ÁËï@¿Ù_ctp?é`HÕ~”?æ4B!¢ACT-CL J0215.5-0113@@òÅù,_”¿ó©àˆw°k@l6Ž¤S8@ê(Êð?ày¹M?¿*„<­@@ò‚¥aMù¿ó¨Z’Í–?ó®záG®?”záG®{photzC_S82@St>ÊÓË—@?0Ú&]›?ú­B°#j?Õo]6?ÑŽ€WÃW?þA¶/G0?ØØM3:9ƒ?Ô9!h@·O']e?áäµ(³}:?Ýæÿ{JË@ Ô×c"Ë°?å6çˆL?á™5R‡\@ƒÛÝÍý?ãÿ*4?⊥¦ACT-CL J0217.8-0048@A9´ý÷*´¿é¼)zØId@% -mfÞ@L=unXH?ߌð$Êæ?À©[’2A@A:&<ð ¿éÜ>X|È\?é7KƧïžspecSDSS?ÿ!Q+sp¦?Ó ¶eæ?ü쯳nh?ÙÈ(ªû»?Õiî´eV@eqWv?Þm;ø2Gâ?زäâ£K@‹ŽYÒ¨ý?åàקd´”?áä3ÖgÿÐ@ æYô“B?éãZ™Áü?åDÓè$©@Džß©”ò?çl÷ãIÂÕ?äºÈ»í#ACT-CL J0218.2-0041@AHgÞIX¿æC—œ é‘@!pjmçà@ô@¡Ñ?í€ÛHve?Áƒƒ$þŸ@AHõÂ\(¿æ<ü!­Ÿù?å†Â&€IspecS16@(¾ËñÆGò@NÎâÞë@Y~åÓ@_?ã•ó4ij@nû¥slÈ?á3C¼A?ÝÜÀb…@ à5£î7Z?ã Z`G‡?à}†¨;•@9k»y2Þc4/@¡:_'H?ÝêCxˆ¸?Ø­Cq.ñ@¿ú´Hd?áiP¹‹ƒù?܈°£Î¢›@F»:.É$?éµ'Mgñ?å4ÃÏ}@…9»þ?íÿ—mºXÜ?è”±r´÷ƒ@ çÎû|ßi?ë§Å5v;¹?è³Ïéâ îACT-CL J0219.0+0303@Aa‹Ø2h@v­}E¯@`ÄZ8è¶@‚Ãb]?í…6mS0?ÈÛL‰UÙàNSCS J021902+030419@A`ͯ9@ r¦Öœ?Þ§ï²-specSDSS@‹\f5A?ç¢\}„@zŠC?äÓ4f¤{ï?á šÄüüþ@ -žT+kB??è§&OÔݲ?ä™èní @½Ôy -â?òe­WN N?îÃí'b®@•:Æ>ä?õ×n¸*j?ñ¼2cæ -´@C‡F^"7?òô>¹”s?ðÉøŒÒACT-CL J0219.8+0022@Az ¸•BÄ?×ê¥Údÿ@Ý®aŸ@ CÇ?ïj¬Î'‰×?Äq#¤KWHL J021949.9+002225@AzáG®z?×»G9’Qw?á7KƧïžspecSDSS@24!?æ;twç@°¬¾L-?Þñvå©¿Ï@ëaÀAaf?ã{g¥&­¼?àKý+¡·@ µåŒË£1?æz6µ¼?â°D/ê@ØÌ˯²??ñtdnMð?ì“(ûÛß@Z9ÛàG?óÁ%5Ýü’?ðl|:9™@R¸Ñ!Ú?ò˜S_d`?ðÛf™mˆ¿ACT-CL J0219.8+0129@A{‰º ?÷ìgSg]@úñ‹bj‰@úñ‹bj‰?ê¥Ú´¯}Å?Ƕˆ&êd@ACT-CL J0219.9+0129@A{Ébü–0?÷÷ ØgÄ?×\(õÂ\specS16@%6Ö»uqZ?èýëd0/Â@µþà#l?äöP#ˆk?à©YÈå³@½nkçQA?è•û“ŬÜ?ã±wjU÷Õ@—žEwù?òšé2NEc?î;Œi*@eT -XÁ?öAQØ ¼?ñÓŠjVªž@í…à€?òX$f<?ðQŒÉ ACT-CL J0220.9-0332@Aùr#·tÀ b›(@8‰@§5ÍKÁÛ@™‘™Lü=?à¯{(Rô?¿Ñõ©ˆU¹RCS J0220.9-0333?ðzáG®{specLit (3)?üTPŽü^g?×(¯QÔEî?Ó:¢Ÿšøó@áÜN:?Û?꽸f4?Öxkq·­@û¨¶ Ü¤?ã›û¢™à?àGfšŸ‰R@ /7…ZéF?ç ²Na‚Ì?ãEåÉU@Ô•–P'K?å·¥$Á!?㈻=ù}ACT-CL J0221.6-0012@A³N.¨|¿Êª®„…@é¼ô“@$~ct©?âiÅÛP——?Â@%]x.@A³…¸Që¿ÊMÒñ©ûè?âùÛ"Ðå`specSDSS@Œ<-Æ?õÉáiž-ø@`(¶?àwÆÿ(åt@‘N¡–­B?Þ •C´7?Ø~ßÝ%qý@³WBëÑb?áŸæÐÈuˆ?܇9cQB@ ˜¼‘GP?éîêÐÜZ?å#ñBQúE@.Z“ƒÉ"?î€ 5†Ó¦c(I?âüOsAlj?ßÒzè²å@ -#»›¾d?埰œÒê?âäSΚ-@è¡0.¼?ðï±4ϳ?ìbŽzIÆ@+Û§ú&{?óSáÜÂû_?ð‘ª9‹E@µ˜v?ò4ƒÔóÜ?ð‰UþÚ>IACT-CL J0221.9-0340@A¼èÑ߈À Zxîž@ÿ……mÇ@㩤. ?âdœ9– -!?ÀsTÜ»Ñ@A¾È%ž:À UÒµD ?ð£× -=p¤?”záG®{photCAMIRA?þn®ái?ØtÈ•R?Ôú½8ò@%ÚêC?Ü7íáÙ2?×g{'£&@ ÍøìaÔ½?ägSä[|?á 9—ÒòR@ 'Æ7‘U”?çý.aIAò?ãåusÀ§c@`Óië?æÜ\sÝõ?ä¯ç~QACT-CL J0223.1-0056@AäÙ72”¼¿îbœ£.@#©61Ÿ@"’ùô£?õÞïÆé¥?ÃkåüiIACT-CL J0223.1-0056@AåUUUUU¿îz§™_X?å8ï4Ö¡bspecS16@Œ'Æ’Ó?ñUYƒ¯@¨&cÇî?á«°‡2ð@0ËÔ -F?媋¹v?âuÊ|ÙÉÌ@:6là?èË­'GVé?åÇ.j˜y@øÚEC#?òÕ7{GMÛ?ð ËNPb@a-´x?õš–!?òNáPI@î¡wÁ?õÅacg«ê?ô:KŠƒdACT-CL J0223.2-0711@Aæ£4ÀÀÂ`ÈòÏc@æuªïc@NÀ¸ƒï?â3˜sê ?Á¯(°²˜´@Aå£@, À¸}ÍÁT?ç -=p£× -specLit (4)@Þ¸N›?Ãx˜­*OÚ@oŽ¨ÎÄ?ÜòK8?×`½ô0°@'°Ôzy ?à€?Å=¹?Úä=Š1=@ tË ¼Ôî?çþ>†Y"£?ã°õ­R/—@>¾IõÑú^ÛACT-CL J0223.9-0835@AþÂÊE”À!1zܸéH@50áf@50áf?êÓzÈ¡®?Åe¶ÀŠ^ABELL 0348@Aÿ‰A§ÜÀ!0r¦Ïê -?ч+ JspecSDSS@ Ê’gˆB?âËã%ä’?ò“WD‘´?«Ej…j@ù]–šœn?å#³Öa?á -#P…ñ@÷@`‰p=?饉iÈÄ?ä.ÛN`@aý -|ï?ó›-¤÷*™?ïœY¸ƒŒ@;'‘1?÷_Ï‚ûäÎ?ò­'ƒGx@(LX&cö?ò»"î|k‚?ðQg3NÖAACT-CL J0224.5-0730@B´èN„À·ûõt@LÛ‡½›(@ô\ŒXÔ?ãšÔNì³?áø£`WHL J022434.0-072807@By¶=¼ˆÀs8Ô%?Ѻ^5?|îspecSDSS@¡ C­y?Ú ÕLììì?úëCÉÝ?°í³¦Ÿ‰ú@àJ‚ Cç?ášÖo>æ?Ûí3nrÕ@RÔ5µý+?åÊC±U?à”œûü9Ç@*œ×n.?ð,üèD?é¨ÙØP¦‡@ÏøÌõü?óu2Îi¼?î‘WÕ6â@Ñ^ƒúq?îw'3ç5M?ê_ùàCACT-CL J0226.4+0426@BO¥F:-¨@¾"ïXŸb@%‚W}„¿@6øF=È?ìÏéà|º"?Ìn<ª…O{@BP_ås’F@Ưk¶{K?ßKƧï²specSDSS@+µƒ¦Î>?å¦ì cu¯@Ÿ™©È1Ü?凤Dç?ád[nxÊß@ -«7ÿu?êÒ·WU?ää²{øI¾@ï©íà3]?òøõeí |?î¦ÿ&Ê{8@/«kdx?÷øåS~©?òxÏáTµ¡@¢‡“mŽ?ó$¸ãv›?ð·´HËACT-CL J0227.6-0317@Bt$ó·,À -b°Ìö»@¬ú¥ cí@™PxðǬ?ä•—yßôo?¿ú7‰0äRzCS 530@Btb¾àdÀ -dÞ•”õ%?êÐå`A‰7specLit (5)@~g §û?Úû«™'O_?ÖŸ N¿X@q“„ %+?ßÏ”c?ÙÞ§ïOõ¸@  -}¯F?æóžà,(û?ã=Ó~UÝ@“Y«£9b?êt -p¿C?æ Å Þ&ð@ ¹f[PQb?éåàÏ£È?çˆOeÈ¢ACT-CL J0228.4+0030@BŽô•Ž4?à*¤VýÉ@©wA$åî@4˜ÿ&‚?èÀhgÞ{?Äžü¶ -ACT-CL J0228.5+0030@B6iÐ?àQ<Áà˜ë?ç -=p£× -?”záG®{photM13@Ä?m¿.?äÊ%}ð±î@\¤­Ì?àyDGÐr?ÛXÙïÔ>]@¤ÉC‘‡_?ãMj‚ô†”?ßÒ°•Œþš@>16Í8?ì?‡¯6Ñ?çrTÉNÖ6@v¼µ`z=?ð—|Ò#WÐ?ëZ¤%~d@ “Ô¤ž?îßY(ò±Ž?ëÂ:Bíþ—ACT-CL J0229.6-0337@B³«¿.ÚØÀ ñ6n­t²@§“ÒS^=@—i_5›?æKü=íõÒ?ÁS:& Ú½WHL J022944.0-033654@B·rà›˜À ë?‚Òê™?Ô¬1&éyspecSDSS@_%Â.ªl?ßOÆ_>Q@8UÀŒ° ?ájÀî(¦?Üfj+g3@|ƒ„”´—?ä:mxFÞ¬?à_ÕLè@{!cy• -?ï® Ø»6Z?éÔ‘¥lb@˜ç,P?òrO¡´«ß?íÝ;d<^@ CÉftŠk?ïxüý³Ï?ëÂLïÓ¤ÿACT-CL J0231.7-0452@B÷D¦2§¼À‡pÝ™O¬@PTaï7@h6Ì¿?íZ½‡mÔú?Á"Ñ 2#CFHT-W CL J023140.9-045348@BõõS9‡DÀ‡ÎK™ê2?ÇÎÙ‡+specSDSS@&©µNsBý?ߦ&¯7‹?þB›|`ñ?¥‘Rí†2@¦Ì.«‰L?ç -ZÅém8?â­-·2z%@ Ö±ò ¿?ë7TîÕÒ?åÞç‘Xï@›™ª¼ó?öž¶0l?ñ⾯üÏŠ@¾È®ó‰?ú%­¹§Óå?õÿá´«O@ Jר¸?ôšòÂcä?òAäÜh“ACT-CL J0233.6-0530@C3W|Y´À ѸT´m@ ÔVN@¢ºƒ_u1?àö]?âG|77_@¡±©ƒÉ¨?îC¾á+ê¬?é(DÁø+@(Ý«·l+?ó;:¯Ej?ïšÓ‚^ÄY@ÐP3ö§?ð„¢ww?í¿îœ&iACT-CL J0238.1+0305@CÄèN´@Çzqÿ·@04‡ìÓj@áôö]?ïȾªHð?Í)CœÓÂN@CÃÏ,ù]O@Ñ ¢@1?æffffff?©™™™™™šphotzC_SOAR@VóÔJ¿?ë¾´Ttè@, ”iÐW?äW¸=Q ?à®vviÿ#@ -°¦|3ñ7?蚥Ó(w?ãþ‚pÚ®@ô)  Ê?ñ„q3ô¸|?캶­xQH@‘‡„ï?õ@0Û#*V?ñEXfß›@ ÊÏ‚š?ò”îvuü?ð~«¥µTACT-CL J0238.2+0245@CÈJ'f@@ˆeÙ h@t‹ö è@: -ð\?ðuÆL'í±?Ê ÏšUuî@CÆÒµ*P¾@ö£Û‹ð?ÑxÔýó¶FspecSDSS@ªà|W?Ñ Ò1=Ö@ ¡³jI?èÝè»?äLmh;@ ’BQo?îÒH«a?çñNPQâ@ñ -‚ü'?÷çFÁU?òž–RS @”¼ý÷M¾@ úß•gd?îYÔ¨Nž]?ê`|7íACT-CL J0239.8-0134@CûÄ5Ýo ¿ù@2Ú -þ@0É¡–Ló­@0É¡–Ló­@) ÏÅ‚?Ä*ä—m…ABELL 0370@CüQë…¸¿ùPÈ?·.¦?ØspecS16@3ƒ0¥TÓå?ô“ßq;b@æ"<ô?ôpÃUˆ?ñF«™GF @‰*E%-È?øB½‡tŠ£?ôXìЕ@)µ”¤±@Õ·™£à6?ÿÖ…m@-&Í:Œøñ@m/ÓÐP@Ï þ5@$ƒ|ûJ@ K¹õM@_b;*Ø”ACT-CL J0240.0+0115@D²Ï"Â?ô5<«gd@5·­scù@-æt‹AË?ò±º4ÅÖ?Å:š/YgÖ@DèNµ?ôKŒfÚè?ã;dZ¬specSDSS@(W¼û^ @uóX£°ß@~fÞ­Ö?ç‚BEŸS0@ -f¢†JR?äæÁщ€ã?ážE‡CU@(êB:)\?è#‹×ê?ä0ìR­NN@u¤¦OÊ+?ò;h§Nf?=oÚ@>ßýEk?õP ´ÖÎ?ñ§®WDÒ@žqì¡@Ñýöô?ð®7‚wÔå?Å‚>U0ûµ@D(6iÑ¿ÓíË©‡eC?åûçl‹C–specS16@µ Êi7_?ùŸ„éd±@ >}SFÆw?ㆇØe.?à j+§¿•@ ,•GþY?æ Y§ïñ?âvÚkC=G@̉m+È?ðvw¯t½Q?ë²F·µÏz@cvÏä'?ózÅÔH“?ï÷urdÂæ@ÔŸsÐ?òu®<~{?ðÔÞ¶ôÞACT-CL J0242.7-0226@DW -=p£ÔÀ›¡³@o—–³½@YºÕr$?ãÔv=àÖ2?ÃÐPÂ_A@DXC­Ð—À‰Ýoêc ?á¸Që…specSDSS@géãea?éÓ¦%óp@ur—¢¬X?à1{Z4ÞÅ?ÚJW ŒD@ÊnÓäÆè?ã&Öo€µ?Þׇ”¯}@b|OÛL?ì.ªpî.?æࢽºìx@DÐ.·13?𶤢­?êéeQñbŸ@ ¬·“²ýr?í 01Æ·E?é}, y¥ÇACT-CL J0242.9-0250@D^¦bdàÀ¿Ñûët±@^4üw1,@8p€Œ¹,?èû1cW±ˆ?ÃÄ_FÃg;@D^†^*4À´5™{?ã•$Ý/specSDSS@ØDDbÍ?çJeNá¾@@¹?2>¨.?áf,î‡?Ü?)ò ·@6A¥˜óQ?ãÏ`ƒU‡¶?àSœ¥‹8Ü@ïs§þ¦,?íw{´Š²?èr>0ÞZ@@#Žÿ’߇?ñ/ùªI~?ìTŠéP)·@yÕhÊ%?ïÞj]jºN?ì£ÑêUâìACT-CL J0245.8-0042@DºaP,œ¿æ³ ¬ëy@éÑ t¥@ŒÃLèÛû?çù^ɳIõ?Ä­ºáÛ¢WHL J024551.7-004216@D»’Åù,`¿æ‹¸ªpi?Ç+ Iº^specSDSS@îž•« ?ÕG¿Ì9ø@ǧŒïa?妑EäÂ?án " @Nqr|'ó?êq¦‡–MX?䙺Ë7æ&@3ÆaDÚ?ôª¶š5g!?ðHùšŸô@Tú²ÍØø?ùVš†Êkï?ó½:œzM@ •4«4?ò“<¥¦%µ?ïŽáèºACT-CL J0247.4-0156@Dìé¾èuH¿ÿ–÷,^Þ@ -»®9ê@#K +W?æ–¨Òãp?Æ“¤‘x?1NSCS J024722-015637@DìÖW‚Èp¿ÿ9`û2?Î5?|í‘hspecSDSS@ …D¡DW?àø¥ŽŒ$q@µ¦ t s?äQáí…ËD?ßö+÷µÉ@²+œo€†?èÔèàjL?ãN§†Ô”h@w ûN° ?ò÷ÙÕä??íÕâî.Wp@S· ³w˜?÷CÌóÚ§/?òÈʉ£(@ ƒ™Ô›™Ö?ñdL“–•?í{³­/‚ACT-CL J0248.1-0216@EþÄSßðÀ3(òMÜW@*b׆¿w0@*Tà\îñ@¡Iª{pË?ÊIOç@:êWHL J024808.3-021637@Er÷W{À7H ¹?ÎvÈ´9XspecSDSS@“ž'h?Ýð.,Oüü@’Ws†/ÿ?ù[‚Šeç•?õœc¥Â@!Éoô'ùç?ÿ\ŽHßA?ù²¢Øå¿@-j»,îÖ @fQT#ó@5‡n~G@10-›$}ü@NTÖ¼^ @Õ6†,üV@&z©¶Ó›Ã@¥Êc+<¶@6ã N[“ACT-CL J0248.1+0238@E<š¡ Ø@"y{¸‹@!ÎÍþÞ@!ÁÞ`ƒ@D-[„Ž??Ð'°d¾NSCS J024818+023644@Eêl=.@ íЕ?áÊÀƒn˜specSDSS@ qGº$?ðÎGŽè@økÜ,¬?ðWq‹¿‹G?ë–Z)&Ú.@ -JÔb9o?ó^ÛHÖM?ð;A~¡W@#šiy},r?ü÷àýS‚"?øsŸ++lü@&B´©AÄ@8cl?ûèùI-žD?ö×ÆË‚ƒ@mê›\]Ý?÷óK TSÇ?õd4ôÿACT-CL J0259.8-0037@F{ôßøÿ¿ãôv!Ýf@'þ€æH5@9m¢ ?ð™H”iµÎ?ÎÖz%¸"WH J025956.1-003800@F}ì¹ñ(¿äD,ºËC?ä(õÂ\)?”záG®{photzC_S82?óxzͱ÷?á,ê Nö†@€ðˆŠ§?Ó,6=×”²@ HžUwB?åêÓµÌÈC?áí¡¡a^§@ eê`·V³?꺷k‹À?å‡á:Q–R@´O'؆?÷„Ë’G‚?ïø#Ú^ø@ÞÉ$[¡Œ?úéÞlõóÝ?ô”ä¤Û@!Sžækfw@¸næa½?þ´MC×:Ä@%púqSwƒ@ -b½b@-ŽIWÉ@#üØb æ@®«è?ü®,PÁ©ÄACT-CL J0303.3+0155@Fêo°>Jô?þÔHMCõ@eWkóò@ïaäÅw\?õs¯Óú?ÔDt{‘ÍABELL 0409@Fë@Út ¨?þÑë…¸Q?Õ$Ý/specLit (7)@Â{IEÓP?Ò—)¯¯‡@£ÍíœG?ô51‚ÖÛ?ï¿Îh™Å@àêÿω(?ûš½"í÷®?ô¿3‚fD@ Ja Dñ@È,?¹’2?þY}8òÓS@$‘Ž°‡@ 1Òîù@pX¼ójy@xk"Ì@Ö. à?ûÁu¢LACT-CL J0320.5+0032@I$a««”?á3°\&@É caãx@  Î’Øï?íNFŸ?Ê+Êü·NžSDSS CE J050.120594+00.533045@I× -=p¤?á» ø}?؞쿱[WspecS16@UƒbvÖ?Ùêù‘]ÃW@s[‚é¨s?Ñ¥_¿þM@e(çÁÞ?æ°l¥¤Š?áÞÖ?‘Jô@ -ÆRÝ*ñÏ?ê\ú `ó?å=ó3ÖõŸ@ I$“‘X?óàbnÒ \?ð­TÔ_/@+“ê]wž?÷ë…:7»?ó,úéEw@3»ÿõ´2?ó°çM·f?ñ8ƒ¶‰ÏjACT-CL J0326.8-0043@IÛAK¥T¿çutqi@!wr“È¡Þ@!wr“È¡Þ@Zðhô?Í|ÆN÷WHL J032650.0-004351@IÚiÐ8¿çd”]À½T?Ü›¥ãS÷ÏspecS16@ ’ãtaâ…?à1l4†@'WñUžª?ã®j}&¥@¬æÁe4?ðŒzë/¯?ëÊK”Ò~­@ƒ\%ë\?ó—ƶ–œC?ðTpŽÑ¥û@#ŠAŽ³õ³?ýÕq¿Üg?ù pv@&*f(ÕY@·pˆ7?ýˆ2Ç9Z@à%4ï:y?ÿæv?X3?ýïEè—ACT-CL J0341.9+0105@K¿îyBÁ?ñwÛðˆ@\€¬?@¥­ƒI?ò†)ûe|?̵£cíLACT-CL J0342.0+0105@KÁ¸Që…?ñ]ÝÝÝÝÞ?ñ¸Që…?®¸Që…¸photM13@ìãì?áöæwxÕ?Þ/û…‹Ýº@ í߫ƹ?å¡®-B%¨?â`Ûj»È@:²Èûo?îÆœ™T³ë?éÛ™÷g@H -­•?ò•×JÚŽ&?îü§rŽÈ@\Ûæ6¦?ñW8ïàÁ?ï•‘LÿåúACT-CL J0342.7-0017@Kו/qÙ¿Òð°PJ„ù@Õ”ˆç5@­ëkñ‰?ë—\Òy¼®?ËÞÙÌúSÄSDSS CE J055.683678-00.286974@KÖ¸Që…¿ÒGèU–j?Ó× -=p£×specSDSS@œy‚=Õ?Þ Q©Å{ @×4žA>?ѧ«J˜¦³@ÚÚ1ï2¾?æÔ4sõ¾©?â½¹‰w@ w±3s™=?ì”ÿ^?槽5^ö@ƒ¿J:Y?ôæÐâш?ð’Õk `„@gpM/ +?ùËÄÄé3ö?ô916é/[@ܬ>ðš?ó¾àlh:?ðãæfyŠÄACT-CL J0345.4+0100@L-ü}µ¬?ð5>8,@Îjëäs@L4'0$?ë²fÀJ§a?Í} -zRtWHL J034523.9+010110@L,»ûå·õ?ðPZç@øìçAé?ù8žG -ì?ócÂ1 Ó3@p¸Ñ´2@e þû1_?øÌ•3@!x jl$?öB;†œb?ò4<7œŠ´ACT-CL J0347.0-0043@L`]ž»ð¿æï A:@òèúß1×@Žù“äé?í{|¿Á„÷?Ì|ì‘;Uô@L_ß*b|¿æõŽ!–R½?ß\(õÂ\?”záG®{photzC_S82@&¹™7ì¥?ÓÑ£nÜu@ ¬S¨ÿ?å¹-­Îç¾?á”»‹•Ý¢@ -‘4…ŽÑ5?êJËjra½?åÎÐqŠ@Q!Ö€ÓÆ?ó%â¯~,?îþQОó@~\Ï’±?÷@“­?ò£ŽÖïH¬@òºò8Y?ó`¶YD?ðóÀ•ŠZACT-CL J0348.6+0029@L”~C„?ß\™pedF@_†Ù­ÅÐ@_˜ˆ—–?òe!¹=K?ÐSöܵWHL J034837.9+002900@L“’Åù,`?ß…¸Që…?Ö×süPspecS16@&3² Ø¢­?îu+Y‡‹ -@ œ‹–M7p?ꮡþÕ@y?å}ŠQˆ't@±¦íÌ‹?ðPK#úÁn?êÜò±‚@/ŒC;E%?øV‰rÂ'×?óš5ÃÐ&´@Pd§­yV?ýÞxÕãg÷?÷΢ù@Mu²GÕð?÷œî©Û?ôŒ¡}ÜkACT-CL J0353.8-0025@M;©ê85 ¿ÚÅj@£µ@·w„Á @|§…C?õòÃR%8?Ðÿj§‰@M:U2a|¿Úÿ**¾ð?éë…¸Qì?”záG®{photzC_S82@œm`Ô?åÃMv,¥@ ­VyÜžä?æî7Ê,Íè?ã>ˆQ÷@xž˜r“?ë¡|ZÔ '?æ×YÔÅJ:@¬Ê£Vü?óºË‘Å•t?ðqV2´R^@n“k9Ão?÷ØÿX4dµ?ó¶¾wŠ@ -á"8˜?õ°‹ÝJI?ó•þaí9^ACT-CL J2015.3-0126@rýbºÄ¯ ¿÷$†>rš -@˜€ë |B@Áh€›>}?ÿÄÀµý Í?Ó¼Hºÿ @rýw¼]ê¿÷&ûL<µ?ØõÂ\(ö?¹™™™™™šphotzC_PS1@Q–Ï3‰7?òYäN4°ù?î3áý„5“@¿³Ý -£š?÷9Q}3¤v?òÏ™Jbxn@#pú‡þÞò@¼.²r“w?ûŠýß‹[â@&§Œ@u£@B2ùÙa @8ÛwØ„@YÝÇKÉÉ@án;É32?þˆ3•xACT-CL J2029.2+0029@s5%ÝÝBU?ßüá=Š\@¼+d×êl@;ä‡ÿŽ?õÚxËþ#?ÑoYT0WHL J202917.5+003019@s5+Ú¶Î?à*ü ±J?θQë…¸?”záG®{photzC_SDSS@|ä3 ?ÙÑŒU½¼†@Fû=™c?ðX ñ.?ê!SgØ@#u<?ôqm{#<®?ð"^Ñ#ùí@ÆQ¼*ùZ?þæ—zU{%?ø³JùžW´@"+y§¹|@heª%xW?þ¢fÅ+Ã…@ïéñ,Ý ?ü—õLš¼?ø­¥ä‚¤5ACT-CL J2050.5-0055@sŠ ÷uÓþ¿íΦCäŠ,@„ð03€D@pÉ5V?ú=39ÕYK?ΚbÀ‚ACT-CL J2050.5-0055@s‰úáG®¿í±¸Œ,™Ô?ãìVÕϪÎspecS16@ b|ÿ`?ÓzC«–V¤@ŸÞDÆKU?ê¶pÛåd?æu6Uwã,@ïŽ Yþ?ï—«ÆtlÁ?ê^}ˆ“ê@ÖÏ…±åI?÷^辉ÿ8?ó¥ó)€V}@!}í¦­ßQ?û¸%étÕ¶?÷"æYJOZ@ë°nç@?ùÓÌieé?÷‰2ʨÚ0ACT-CL J2050.7+0122@sŠöµÍ ?öxºen@(P2×Þ@ÎŽµÌ?øí ɽ|?ѧŸ‘É ôMCXC J2050.7+0123@sŠß’Åù,?öC[?ño»?Õ^žšspecS16@*‰X¿ ?ðÍ.hì±@Cð<]^9?ï°=•?ü‚‹â¹v?ùõ{Àû¾ACT-CL J2051.1+0057@sŒ¿%‹òZ?î‡è2ò!ñ@I3\ÛÉ@‹’f6?ðc¿/™³À?ϲúÓÚsWHL J205111.1+005646@sŒ»»»»¼?îFÅ( ¾?ÕOß;dZspecSDSS@!ùÌ@‡Hæ?ëâ¥=±n@(Ÿ;®Ãp?ÕVª?Âå‹@ Bõê‚?én4ˆjÊ?äF¨ä0¯•@ 7öÅN“?ïdvƒ #Ó?è¾À,€@Óò/ùq†?÷6yyÿ¾¾?ò‚Íåý°@ÄÀu±4°?üÃt”%ºˆ?ö¬@eõø/@c‹–³ö/?ö)ã¬ig ?ó,M¹µACT-CL J2055.4+0105@s®O)ÜU?ñˆó)fU@ª²éyÌh@3µp”±G?òqzád>õ?Ð6Lhuz·GMBCG J313.84687+01.10212@s‹òX¿&?ñ¢""""#?Ú+jçÕfÏspecS16@mmNr5Š?è{,PJ @.ü÷ TÛ?îIiÚÎE@ ‚PŽºOø?éÙø^yÃz?äîõ]Uþ@Ïò†ÁÞP?ï{¢Æ°ý?é=(ü x@·Ÿ¼ÍÊ?÷:XµôË?òÏ~e@®ãhE4è?übÞ°RçØ?öÁŽÓR,@:,,¶+½?÷F÷›o?ô4Zi3R6ACT-CL J2058.8+0122@s«‹·ùr?öÙéTü@ÍÃÙÌ#@±®¤ù†û?÷Æ÷dW±?Òb?ßÅÉÛWHL J314.721+01.40299@s«ÝÝÝÝÞ?õ÷ ØgÄ?Õ$Ý/ specS16@&‚DÅ¡Û\?êùð*@Ë~ºõ‹?ïÿ6¢;â?éé\ƃõþ@ÒˆÛõU?ó±.½x×?2™f@]‘EîÂ?ýw7ð?÷ÜnßÁ·U@"RèîUE©@4FÖåW?ý)ðË8@ v1½?ü‘wd4=?ù+"®tyACT-CL J2121.7+0040@t%‹òXÀ?åw ‡ž²4@Üʪ®Â@¥ü.)¬ä?ð¨b(—é?ÐN ŠÕ@tH¶{i?å‹ÉTbŽ?à‹C•%specSDSS@Ê¢eu?æ£Ð¨Ý^@ô»¤?Þ®—£æîp@ o|Üð?çnREcÄ?âüßRÖ|ë@ Õò -Í©?ì›I*5X?æó£=t?é@­ÿ$KF?ô›Ñ)?ð²ºg<¤Q@œöá+âÎ?ù>EÁ´7?ô@¨ãi·@h½°à¿?ôñÒíÐþ°?òYüyçN`ACT-CL J2128.4+0135@t!ª6w½?ù—°¨¨)´@¸%\—ûx@ØÌ°n(™?ü&îùýó»?Ö²Ä5}tWHL J212823.4+013536@t!\(õÂ?ù~¿šÄ?Ø­«ŸU›=specS16@)­?E>ï ?ëgiö¹d@€P¥‘?ñ¼/a´IÎ?ìà -*ŽÐ$@i´ñÿ¡?ö8)Ë=T?ñÎg³Ë@!MÅPɲz@$½+Ó‘À?ú.C±ÒD©@$|QÝ¡|Æ@O Xw¡˜@Fl¥O@ôž“æŠ?ÿ½p ¨\?ûÔF {ƒÄACT-CL J2129.6+0005@t&•Zø±®?·Ž“Y¦½@¶Úû,@à¢P£Û ?ûÚ’ª¥z ?ÎÝš)3oACT-CL J2129.6+0005@t&¨õÂ\?¶Õru߯æ?Íéá°‰ 'specS16@Õ…Ìl?Ú!±qŠ!?ø4€Õìm?ÂÊSèXÿ@Œ9%oqY?ò®Àº„° -?îqåQ@Øz¯o’à?öö&YËŠä?ò¦‚ÜÀø@#–‡@zU@Ï\æ°?ýÛh†M×@&ÒÓèifz@ú3.!.@¶•’Rf6@7ŸU+js@ÜZeô“S?ý¸ôBú°ACT-CL J2130.1+0046@t(®A¦Á‹?èªó£ôÚ@êç®/!’@B½uJâ?ò/TÕÑ0?ÏÝý§bæëACT-CL J2130.1+0045@t(–/Ébü?èöqRšH]?æ¸Që…¸?¤záG®{photM13@ Üá*o¡?æYùS?â/5¶*+½@ Ê;©‹ Õ?ê¯ ¼ù`?åÍ8í4hš@Oü 0?ón8s¨?ï_T‰öC—@Ç@aÉs?÷#½ A;?òÝ¡7µÜÃ@pÛp2?ô\jÂÛ }?ò+ºˆ¸—ACT-CL J2135.2+0125@t<ÿu©è?ö½û@Õ¨[ƒv@kwóu>.@ZÇâ+ÕÞ?ÑÉù7£m8@t=?%‹òX?öÉbü–/Ê?Íp£× -=qspecSDSS@%iOåþ"ˆ?åø©Øaáp@™Xtþ[Ø?õ£ùXªò?ñšÈgbžz@±¥©h?û MÒŒ×Ô?õ¼¬ ü¥=@&œ‡o;£U@¼#†8sJ@Þ/,†À»@*¦lü[Úc@ -Ú 2¨¥@ëUM¨÷‚@!Z*t$pµ@yƒ>ïÚ@"´±‰£BACT-CL J2154.5-0049@tŠ3Ô¼¿êI&Dý¯c@v£?Ïá -@cc•=9&?õTÔ{Û?Ïê7²ÎÎ!WHL J215432.2-004905@tŠ'@Út ¿ê# &tö«?ßb¶®}VmspecS16@WfŽÉ ç?çòŘòJ@K™&D#?Ý+﯌@¿g¨™ñ?ê@%ÛÐöû?墶™Rë@“Ň ?ï}&”ã?éºE-‘¯x@G ™•^K?÷JvôÃ|?ó1ªÌ½¶@JnK¦¡?üßõE?öæ%¹±x@›ìé©?ø8 -x"ýÊ?õœLˆžbCACT-CL J2156.1+0123@t¢â{Â?ö$ƒ›Âg@âuŸâVä@"WÆÇF?öõ—Ò´ƒ?Ñz¹ž.ùÖWHL J215608.6+012327@t‘?öA1Õ¬¶ô?ÍV“uspecSDSS@%±i&ºK?Þÿ%¤V.R@,½WÞ?ñ7~¡«´K?ëê;+\3@&^¸Gü?õŸ—k6EG?ñ £@—9¼@ ;mvRQ,@_¾‡|?ú&:8_<ì@#>ÉÛXŽ@§+¹E@H°¶(„à@}#­¾?þÕÃ>ì?ùïÉì§3ACT-CL J2220.7-0042@tóiÐ6ž¿æˆà쌺@gXo¤Å@ ÊoR?ðrP'yŽä?ÐPßæ£ô¾CFHT-W CL J222047.6-004130@tó"""""¿æY¨)ÞÆâ?ã+ Iº^specSDSS@ ëÙ72Ç?Ù;VvÔ~??ê‚E/ -!?²…äÑ°@fcà[ï?æŸ(£Ú?â]®µTàÓ@ _ieMI–?ë°‹ÓôEð?æBF#aˆ@8à=€N‰?ó­;Å;ù@?ïò±¸køß@ÂÜCÿ?ø*@Úó¶Þ?ólò€pÖ@ðï蛂?ôHñ\ÕA?ñÎîmž\HACT-CL J2302.5+0002@uš\ÃDz?¦ä4‹¶è=@Ó¯¾nô@€¿axÚÎ?ñƒ’½Ü?ÎJ%Vì²WHL J230235.1+000234@ušUUUUV?¥î@+°Ïˆ?à£S&ÂspecS16@]a;îR?îËyk¯Î@#¹›Âg¸?ãcƒDƒ,@ -@­µ÷/o?çh¼4¶?ã$WÂÓÈ(@<‰AZ?ì,ñ¹@A?æÕž°ˆ@$ë¼w?ô™&ŽàÞ?ðØCZŒ^£@—K–}cË?øß‚g"C?ô(_ŸØÛ@M¬ç®9w?õDXÖŒér?òÑfÊ›¿ ACT-CL J2307.6+0130@u®iÐ8?ø44™§>@û%>wÃ@™ge,¤y?ö³*yvéÚ?ÕáaÜiwðWHL J230739.9+013056@u®¨õÂ\?ø?|í‘hs?Øå`A‰7LspecSDSS@$z!²l/?êQæ°D³@ mr•Ï½?ï¢ëò5??éN¼ø¹pB@ÏÖßàÐ?ô [Õ†p?ï¥|kw¼ú@¢ý'àg?ü¥?J7øg?öê<öõ«@!NQ[h@80ôÒG”?üÆÉîŒø@AAjב8?û´`“»æ?÷î\b»ACT-CL J2308.8-0003@u³X¸‡¿ø¿©š2y½@¼dE0Úæ@j¯‹³»÷?í‚'ØñNÖ?ÎfwH¹5WHL J230856.0-000234@u³ Úé57¿¯q4H ö?ݲ-VspecSDSS?õ¸g}Å‘~?Òî…Ê kß@ù‰\lY?ÑMÛª”ˆ4@ö_&—•p?æpè?§š3?âãô¿Ü@ -¥ÖàÔJã?ëißÐ?åͳôNM@SÙµ€ð?óݲÀŽ¦þ?ïî<<¡þ@«¿ÞJ5b?øY)ÄËÓ?ó^'Ñ&$@âUÉÏÃ?óÊ(¬=%?ñ.y¿;³YACT-CL J2319.7+0030@uß.Œ‚Ú?àßÁ†@7tú* —@ë7þgd?îOÅ’¶·?É¢”ÕóÃRCS J2319+00 NED02@ußU%ÌB?à |€„?ìàuöý!ÿspecLit (8)@Øí;0;?á…ÅâÞ‡?Ý0/¯W@é/©|´µ?äà²_õ 0?áB×½6ÿV@¦½/U“Ê?íé÷hÏÙ­?èëŠûîŸ@SÅ&Cï?ñßÐ2%Â?íŽM·˜éª@r3 (Q?ðÔ?T’?íá5=5©éACT-CL J2320.0+0033@uà\ˆ7œ?áš^¤6ÇE@°ëä@‹@¢3p@L?ëmÒÚñ2©?É¢”ÕóÃœRCS J2319+00 NED03@uà'ç:6]?áêÌ’j?ìàuöý!ÿspecLit (8)@F[œñ^?àú¸k±?Ü7» €@CÅÁßßL?äbŽÀ+ª?à¸ÒÑI@Gú«•…Ñ?ìñŒMÖ¶?çîØ®Ë<@ãh”´¸?ñm/18\;?ì—¯Ÿ@ ÐáR½M?ïÉÏDtõ?ìAà{ü£VACT-CL J2325.9-0246@u÷ÿ›ÑõÀ*HÑFe@â'u¢ç@«2®‚b?ô{Hî€?ɈŒ”šÿ @uøçÀnÀ;!>>)0?èýó¶E¡ËspecSALT@ [é{ã× ?äô*a¢ý?á¯ÁßX.@Ñ¡/#ä?èoÊaª]'?ä€'R=$@k·¬Ñ?ò 00¯úÛ?îuöLÞ Õ@x|ö½fÆ?õç¶åa¿?ñ²÷„ŽÎ@Ú+­ëKM?ôzÜ(’?ò½\n oâACT-CL J2327.4-0204@uýÊô„õˆÀœ*ìÖh@7¼˜+ æ2@7†¯Q¢<È@ñî¢? ?ÈhŸ¶KgRCS2 J2327-0204@uý× -=p¤ÀÏM˜°–?æ^5?|í‘specLit (9)@;y£þ‚?÷}¤_6¦@"걃?÷¡ûJó?ôQÊ -Ñ@$ѤÊúØ?ü¨üÙ§µ?øsoÿpO@0GLwßÐ@åõ¼ *7@÷èÉŸ|@2y/dz’×@ m§[õ"¹@²Ld\5@*¤vj×ÞØ@zAà-K@Ð £mLACT-CL J2330.2-0012@v %vË€R¿Ë3Ïææ`@aúzg¦@ ï¸ÖÎLº?ãeµƒ/ªà?ļ»œ*@v C;3<_¿Ê\â ¨§?ÛS÷ÎÙ‡specSDSS@°Œºþ?äJJ§Ïý(?àÚÛ¯a‹@J=è?î—š:ÕÛ?èò;¿Ô@EÑQ>QL?ò¿:gT?ì•4ë¬ðú@ÿçªç_¿?í·Ú“Ö´?é°"$±9ÍACT-CL J2332.8+0109@vnQ^?ò§S¬KU†@$|”Ⱥf@i‚VQ\?çb÷÷ÀÖ?®¦¯àà#WHL J233252.8+011006@v…‰Ûê?ò²y*ò?ß+ Iº^specSDSS@>VÆû?çû¬ð4H@,¦rê óD?éþÛTšö@œ\6¶?á"l7`?Ü,@Ðæ§@^ø ºÐþ?ãÕ½Ìΰ?àÊò?ðÍÅf@æl?ÎVâº(Tå@vœ(Rf×@`Û¬vùû?åº^5?|îspecSDSS@ÊfM“A?æUZ@9ø@¢ão÷hù?å_5ݪ%È?áð;@ _ék_á?éÑz, ©?å›Ìé @F+­;?òtÒžbÙ?îUŒ+ð@”©çÀc½?ö]»“™ð?ò8£&M– @jÿ6™?óšÉ+ßþ?ñp²oäACT-CL J2333.9-0237@vŸ‘UFJÀüá â.@ìUG'“V@È·Ù•¬Þ?í }Ññ??È¿'(ŒßÔWHL J233349.4-023737@vK9‚f"ÀÛ¨ÆOÔ?Ú\(õÂspecSDSS@v0:Œ?伶°GþW@>q¾·Ä?å8t?cËm?áF÷¾ îY@ -jêº@¹Ô?é8ÔŸh?ä\š üü@Æ¶Ñ ¢á?ò÷·i  ?îâÎ €ˆÞ@¯POÎd?öœŒº^Ò”?òA&rU/¯@S¢Ñðù?óýáF´?ð×Ñ—nŒ=ACT-CL J2334.7-0104@vÐ(C„p¿ñ3uXWªì@¤F=qž˜@ºÒK¹t”?äú¤ éê?Â‡n@vÎÂÝš¿ñ/“U†ÿº?áp£× -=qspecSDSS@a¥,ì??áÐ Ž1ú@(‡î)?ÒˆîT¸WÂ@UÿdCT??à*1âw?Ú}¶^Ô‡N@šJrE5ó?âæ\Ü]?Þ¿¥ @æýÃ8=w?ìö¤('?ç ®‘ði -@ø -º¬ãm?ð{×nýH?êÑ;¢7Ã@ -öð êŠó?í|Õ #Q”?ê&5ÇõACT-CL J2336.1-0111@v ‘›£D¿òúŽaßµƒ@¤p€x‡@@¤ ©WY?ã aœœ?ÂP‚úôQ_MaxBCG J354.03652-01.18345@v •–ç&¿òï€rù_(?ÐõÂ\(öspecSDSS@蜰’2?ÚÙWcè@ºY®f?ÚS‡Î†@Íö[L?á‹Ù9é?Û±Þ¨E@Ü·ïÉ_Ò?äI¤Sñî‡?ßú¸öÃy@….Ä#Ð?ïgzß¡¬Ö?èúŠÓ:sÁ@qBG¿Þµ?ò¶း¡?í‘ìÿZ±@XĤ`?í—qÍ¥N?éfÏ]³ôACT-CL J2337.6-0856@v&j;î.À!áTdòÐ@wo‰À W@]QÉ’ç?÷È`ÊýiY?ÕÕBé“WHL J233736.7-085700@v&sœ¸%À!æsZs -Ì?éG®záH?ž¸Që…¸photzC_SDSS@Þn´XL@àÚs`Ê@ ÔOÓÐc?éŸE¤S?å!8Õ4!Ï@§T`(Y?ï»åײ?éé2£,Ñ@øF›û!`?öïÒL«?ò6ž÷êG?@ŠþÆN?ûsm3ŽIµ?öjm×v.@'2³*Íî?÷¬Lå?õ#™º‰6PACT-CL J2337.6+0016@v&Œ+Mr?ÑY`S[ó@(—hD4Yˆ@'øá/ïÔ9?ûi-þ°ð÷?ÂKŒ/¸Ú;WHL J233739.7+001616@v&¥‹òX¿?Ñ]úþh8o?ѸºÇË)specS16@©Aá~ É?ßð«F‡àá@$c?fæ?Ëóκн@Y 4^àË?ð}JЛ?êÛ’0;é:@Ö*ÎÉòi?òÙÀS=3?ï@})ì]Û@#&©N?þ5¾ËëÇÄ?ù9¿%}Ë@%ƒ2y¾-@ÂJ._μ?ýq-ªÀ_R@ì]=ôð9?þ´ƒt~?û¨eœ`ŸACT-CL J2341.2-0901@v5 ¥øs À" ’á ¾G@;H× -Â@4 ™,¹í?ü²¾*­‡?Ú°á7baABELL 2645@v5"~~ùÕÀ" -5 8Æ7?ÐbMÒñªspecSDSS@mQQ¢‘À?àZ“¯]°Ž@ yC /?õ`Â;-?ðÍs}ˆÔ@(nq;åÎ?üwéöZ?õüêYU@"“EÃì5@;Ož|³?ÿÍžK–‘ @&ýkÎ_ @ ·¡J@ìì²@ÜîÅ'-@H—‚盇?þù:ÇÄ0ACT-CL J2341.8-0743@v7X×áAÛÀíW'þá@6Ø÷dm@aQZ?î>~rúDD?ÏÛº/—WHL J234148.6-074349@v7=Ÿb5FÀëÛRƒ¯Æ?ØõÂ\(ö?”záG®{photzC_SDSS@'!Œ›­%W?ò¥v6z¿P@GßÔ!‰í?çê-qwÔ3‘”?Ó˜aGw2_@«kGMG@&5Š¾2Û?审`}?Ä:§áðNSCS J234339+001747@v>`À(Ý/?Õ-ùŠ‹p°?ÑG®záHspecSDSS@!ÉœxÛë›?å¯NãÆ @ ‰ù2˜‘?ØñùfºÉ@Xè6ù?â¬öÉFÆ„?ÝÆB­ý=³@ô¿Ý6e?æU¾ÌiŠ?á¢Ç× ‡@í  0u?ñ;.F-h-?ëx·¦¤˜&@eÀ†HðB?ô¬}ÏÐ"?ðRÿ¬Xÿ”@ -û7^šk›?ðE‘Ë]­?ìw"rjACT-CL J2344.6+0305@vBˆ.à–Þ@¬¤¿ËðÜ@!ÏN³ã“@!uIyÍØÏ?ô¶ŸF-8?Âû»”2wqNSCS J234433+030506@vBƒßÈ.å@¬¯&ïõ?ÖvÈ´9XspecSDSS@éÊn?äDg–²N@²×è|½ñ?èÊ܉Q*?ä¼ÐÍ°yÛ@œ$eèŒÚ?ìšãŠí/?çÆô¦,'@÷`K?ö§Éˆp/?òó7‚@\e@ "OHäÃ?ú5&6?o;?õÈÍ}?_@NËî¶1?÷¨ÙV#Ç®?õrYq‡ã•ACT-CL J2345.2-0041@vDϸ‘¥‰¿æ"E]ÖÛù@ ‘kŸ a@ ³NäKv?äé»ÝfŠ¡?Ä×âßTM@vDðµq’¿æ)$Û±2ó?â=p£× -=?”záG®{photzC_S82@vf½%ãY?çº -š¥Q@ -©ÈG[?à”¾Jh·š?Ú÷]Ó‰ -@„Œ\™c…?ã® -5éõ?ß¿I›ó@GÌw‘7?ì¿屩²?ç`´†ø–@Ö, 7/Y?ñ¸š¢Ây?ë™@Å5wt@ -ˆ&Û;a…?íÒ7‚êóS?ê:@*0:ÇACT-CL J2345.2-0302@vEIà@0À`T6nÅ@e+®?@`!jaÌŽ?ô8†N%?Æͼãóž÷WHL J234517.1-030239@vE#•C3éÀZ_ðõ½M?Ôj~ùÛ"ÑspecSDSS@¾®ƒäs?âE»-¿•à@ðŒRuEB?éø¼Ékn?åwy!.@_i)º&V?îhÙ])À?èóJ¡K@UdJ ?÷ëê Ì¢?óÅ®ïfô£@ D•Ïô?ü4¤¶qv?÷ 8xgÖÝ@¿îµþ8?ø«X¸?õ•NˆèAACT-CL J2345.5+0324@vFÛõ-Ö@ ;…zšçú@æ®Òv@Uë>¨Ò?í#ÝáµÏô?Âg~ÇžÒ@vEòfi0½@ =í¬ìw™?á‰7KƧðspecSDSS@ }ÎÎ4µ?õŽÇêöŠ¾@¡•X³å¼?âIÏÖ¦?Þ¥ªZ#*&@ -+㘒q?äö*Dš?ávïP]–¶@ª8Ò›?ïüDÂ1yõ?êÌÚÃ2B@ðaç*Ù5?ò_c,£Õ4?îtsë„ì@`9“V?ñ‡;"_¹Ä?ïÕ°©'¡ÚACT-CL J2347.5+0116@vN[ (-_?ôJ ·_K@Â2ø—Q¶@ÄX5kr?ì.¶¸Óì?Â4܇Þ~\@vNc^J8?ôFÙ8C?î¸Që…¸?©™™™™™šphotzC_SOAR@ß[¦xo­?ðhô‹ðBD@ð°)€Ý¨?Ýòõî^i ?Ùh)¾Æ‘ã@Nqr|'ó?áIîörÒP?Ý+apk‹@ÛÜx%*³?éŠÃØ%G?å«Í£Sú@ì=M¶V¹?íŽÂsø®?èïv³„X@Ë]j5ú«?í²·GBÿ?ëPL¼²?¼ACT-CL J2349.1-0227@vT–êçØÀ¬›HUò@n*Ý1‹p@$Æ.'Í?äÀhVŽåö?ÂLÀÞZ -u@vTµ9…´À½¦«[hö?ÜÝ/Ÿ¾wspecSDSS@H÷;¤«Í?ÛO0*Ç@=Òyõµ?àh7@ŽæÃ?ÚÊH ˆ@{ƒïòmÐ?ã(cJ•?ß ÚV4Ýœ@3J±Ïv?ì÷S횉U?ç¦ëÊ:@@ ¨’¦7k?ðô…f­Kc?ë{×Þ}Ј@ -Ób³ZFp?í¹o{c?êANØy[ ACT-CL J2351.7+0009@v^æLùË?Ã[›«FTŸ@iIÊEµ@¾G§sÏ?ç“ß­iO,?Â/ÒÐÔÑ@v^ù,_’Æ?ÃƧï²-?ï®záG®?ž¸Që…¸photM13@H, -py?Û“½¯gID?×3Ÿ·îÇ@|éè`›?à ¬6Ÿ ?ÚÖ ‹@@»µ÷¨i?çtò¦iŽ”?ã¼M’ŸÖà@zVÂû²Ã?ë\ëÕnHõ?æâpö-ý&@ -âˆ1´ÿÀ?ê·‡÷Ø?è]˜~“aACT-CL J2351.7-0859@v_&gÅÀ!ùY)ðá+@\ÜÒïP@â,‰¯¨˜@žï1÷”?ÓȽ^Rõ5WHL J357.962-08.99151@v_e” »OÀ!û¦q11ý?Ù‡+ JspecSDSS@) -K2+?Ù¸à+à•b@+=Xò?ò›õâ;ý8?îÃ>w ºX@ŸhæZÃ?ö·Ïû?ò˜•sã¿ò@$:-&°•š@ú¶,eÉ?ü~ŽyV“@'vß*ü/ò@ÍéÜe£%@’é.@ Løg Wn@FÏ1â!m?þíÿZV€ACT-CL J2354.1+0240@vh¯¦Î Ì@W`Èì¹@p§ñì½@…÷°@‹Å?ìYVøó +?ÃHE^ÂŽ=NSCS J235412+023756@vhÂãWæ@YI¸È¾@?ÍV“uspecSDSS@ -@Hã~è‰?Ïà3O(j@Un2£ð?åãVWFHÅ?áºé³ÇWØ@ -cï²!A?éßcÄqÒ?äÇ•ÆLü@ø‹Oªr?ôœæQÞ?ð±ÏÂ`ú.@íOgæ„8?øp äÇL?ó ›KÍ$@(:p‡å?ó;â ³?ñÏ”aACT-CL J2354.5-0729@vjzáG®ÀïPTî@m©5¥ò@$‰rl@Ý?ñ"÷­No?ÏØ l­yR@vj 22$fÀôsFS»?àA‰7KƨspecSDSS@ aÉ?檧ÔÓßñ@ •Õöœ‹(?綡\x[?ã@ŸoŠŽ @ ”Ý]ÎÂ?ìÔ,êh?ç.VÌû…@Š¯¾:ï‚?ôä|cúWø?ðöTM·k@&OþÚK -?ù{ùÎo¤-?ô}à|B±u@ÐDd ÷?õC߀R¸ì?ò«•¹¥P‚ACT-CL J2359.5+0208@v~¤cˆ.@)G?®õî@[•›@1% ?æ«Ÿ*QóØ?Ãðu÷§Ó@v~= qmin)[0] - return z[ind], zerr[ind], Y0[ind], Y0err[ind] - - -def read_mock_cat(fitsfile, qmin): - list = fits.open(fitsfile) - data = list[1].data - SNR = data.field("fixed_SNR") - z = data.field("redshift") - zerr = data.field("redshiftErr") - Y0 = data.field("fixed_y_c") - Y0err = data.field("err_fixed_y_c") - ind = np.where(SNR >= qmin)[0] - return z[ind], zerr[ind], Y0[ind], Y0err[ind] - - -def read_matt_mock_cat(fitsfile, qmin): - list = fits.open(fitsfile) - data = list[1].data - ra = data.field("RADeg") - dec = data.field("decDeg") - z = data.field("redshift") - zerr = data.field("redshiftErr") - Y0 = data.field("fixed_y_c") - Y0err = data.field("fixed_err_y_c") - SNR = data.field("fixed_SNR") - M = data.field("true_M500") - ind = np.where(SNR >= qmin)[0] - return z[ind], zerr[ind], Y0[ind], Y0err[ind] - - -def loadAreaMask(extName, DIR): - """Loads the survey area mask (i.e., after edge-trimming and point source masking, produced by nemo). - Returns map array, wcs - """ - areaImg = pyfits.open(os.path.join(DIR, "areaMask%s.fits.gz" % (extName))) - areaMap = areaImg[0].data - wcs = astWCS.WCS(areaImg[0].header, mode="pyfits") - areaImg.close() - - return areaMap, wcs - - -def loadRMSmap(extName, DIR): - """Loads the survey RMS map (produced by nemo). - Returns map array, wcs - """ - areaImg = pyfits.open(os.path.join(DIR, "RMSMap_Arnaud_M2e14_z0p4%s.fits.gz" % (extName))) - areaMap = areaImg[0].data - wcs = astWCS.WCS(areaImg[0].header, mode="pyfits") - areaImg.close() - - return areaMap, wcs - - -def loadQ(source, tileNames=None): - """Load the filter mismatch function Q as a dictionary of spline fits. - Args: - source (NemoConfig or str): Either the path to a .fits table (containing Q fits for all tiles - this - is normally selFn/QFit.fits), or a NemoConfig object (from which the path and tiles to use will - be inferred). - tileNames (optional, list): A list of tiles for which the Q function will be extracted. If - source is a NemoConfig object, this should be set to None. - Returns: - A dictionary (with tile names as keys), containing spline knots for the Q function for each tile. - """ - if type(source) == str: - combinedQTabFileName = source - else: - # We should add a check to confirm this is actually a NemoConfig object - combinedQTabFileName = os.path.join(source.selFnDir, "QFit.fits") - tileNames = source.tileNames - tckDict = {} - if os.path.exists(combinedQTabFileName): - combinedQTab = atpy.Table().read(combinedQTabFileName) - for key in combinedQTab.keys(): - if key != "theta500Arcmin": - tckDict[key] = interpolate.splrep(combinedQTab["theta500Arcmin"], combinedQTab[key]) - else: - if tileNames is None: - raise Exception( - "If source does not point to a complete QFit.fits file, you need to supply tileNames." - ) - for tileName in tileNames: - tab = atpy.Table().read(combinedQTabFileName.replace(".fits", "#%s.fits" % (tileName))) - tckDict[tileName] = interpolate.splrep(tab["theta500Arcmin"], tab["Q"]) - return tckDict - - -class SurveyData: - def __init__(self, nemoOutputDir, ClusterCat, qmin=5.6, szarMock=False, tiles=False, num_noise_bins=20): - self.nemodir = nemoOutputDir - - self.tckQFit = loadQ(self.nemodir + "/QFit.fits") - self.qmin = qmin - self.tiles = tiles - self.num_noise_bins = num_noise_bins - - if szarMock: - print("mock catalog") - self.clst_z, self.clst_zerr, self.clst_y0, self.clst_y0err = read_mock_cat(ClusterCat, self.qmin) - else: - print("real catalog") - self.clst_z, self.clst_zerr, self.clst_y0, self.clst_y0err = read_clust_cat( - ClusterCat, self.qmin - ) - - if tiles: - self.filetile = self.nemodir + "tileAreas.txt" - self.tilenames = np.loadtxt(self.filetile, dtype=np.str, usecols=0, unpack=True) - self.tilearea = np.loadtxt(self.filetile, dtype=np.float, usecols=1, unpack=True) - - self.fsky = [] - self.mask = [] - self.mwcs = [] - self.rms = [] - self.rwcs = [] - self.rmstotal = np.array([]) - - for i in range(len(self.tilearea)): - self.fsky.append(self.tilearea[i] / 41252.9612) - tempmask, tempmwcs = loadAreaMask("#" + self.tilenames[i], self.nemodir) - self.mask.append(tempmask) - self.mwcs.append(tempmwcs) - temprms, temprwcs = loadRMSmap("#" + self.tilenames[i], self.nemodir) - self.rms.append(temprms) - self.rwcs.append(temprwcs) - self.rmstotal = np.append(self.rmstotal, temprms[temprms > 0]) - - self.fskytotal = np.sum(self.fsky) - else: - self.rms, self.rwcs = loadRMSmap("", self.nemodir) - self.mask, self.mwcs = loadAreaMask("", self.nemodir) - self.rmstotal = self.rms[self.rms > 0] - self.fskytotal = 987.5 / 41252.9612 - - count_temp, bin_edge = np.histogram(np.log10(self.rmstotal), bins=self.num_noise_bins) - - self.frac_of_survey = count_temp * 1.0 / np.sum(count_temp) - self.Ythresh = 10 ** ((bin_edge[:-1] + bin_edge[1:]) / 2.0) - - @property - def Q(self): - if self.tiles: - return self.tckQFit["Q"] - else: - return self.tckQFit["PRIMARY"] diff --git a/soliket/clusters/sz_utils.py b/soliket/clusters/sz_utils.py deleted file mode 100644 index 828abb64..00000000 --- a/soliket/clusters/sz_utils.py +++ /dev/null @@ -1,401 +0,0 @@ -import numpy as np -from scipy import interpolate -from astropy.cosmology import FlatLambdaCDM - -# from nemo import signals -from .massfunc import MPC2CM as Mpc_in_cm -from .massfunc import MSUN_CGS as MSun_in_g -from .massfunc import G_CGS as G_in_cgs - -# from .clusters import C_KM_S as C_in_kms - -rho_crit0H100 = (3. / (8. * np.pi) * (100. * 1.e5) ** 2.) / G_in_cgs * Mpc_in_cm / MSun_in_g - - -def gaussian(xx, mu, sig, noNorm=False): - if noNorm: - return np.exp(-1.0 * (xx - mu) ** 2 / (2.0 * sig ** 2.0)) - else: - return 1.0 / (sig * np.sqrt(2 * np.pi)) * np.exp(-1.0 * (xx - mu) ** 2 / (2.0 * sig ** 2.0)) - - -class szutils: - def __init__(self, Survey): - self.LgY = np.arange(-6, -2.5, 0.01) - self.Survey = Survey - - # self.rho_crit0H100 = (3. / (8. * np.pi) * (100. * 1.e5)**2.) / G_in_cgs * Mpc_in_cm / MSun_in_g - - def P_Yo(self, LgY, M, z, param_vals, Ez_fn, Da_fn): - H0 = param_vals["H0"] - - Ma = np.outer(M, np.ones(len(LgY[0, :]))) - - Ytilde, theta0, Qfilt = y0FromLogM500( - np.log10(param_vals["massbias"] * Ma / (H0 / 100.0)), - z, - self.Survey.Q, - sigma_int=param_vals["scat"], - B0=param_vals["B0"], - H0=param_vals["H0"], - Ez_fn=Ez_fn, - Da_fn=Da_fn - ) - Y = 10 ** LgY - - # Ytilde = np.repeat(Ytilde[:, :, np.newaxis], LgY.shape[2], axis=2) - - # ind = 20 - # print ("M,z,y~",M[ind],z,Ytilde[ind,0]) - - numer = -1.0 * (np.log(Y / Ytilde)) ** 2 - ans = ( - 1.0 / (param_vals["scat"] * np.sqrt(2 * np.pi)) * np.exp(numer / (2.0 * param_vals["scat"] ** 2)) - ) - return ans - - def P_Yo_vec(self, LgY, M, z, param_vals, Ez_fn, Da_fn): - H0 = param_vals["H0"] - # Ma = np.outer(M, np.ones(len(LgY[0, :]))) - - Ytilde, theta0, Qfilt = y0FromLogM500( - np.log10(param_vals["massbias"] * M / (H0 / 100.0)), - z, - self.Survey.Q, - sigma_int=param_vals["scat"], - B0=param_vals["B0"], - H0=param_vals["H0"], - Ez_fn=Ez_fn, - Da_fn=Da_fn, - ) - Y = 10 ** LgY - - Ytilde = np.repeat(Ytilde[:, :, np.newaxis], LgY.shape[2], axis=2) - - numer = -1.0 * (np.log(Y / Ytilde)) ** 2 - ans = ( - 1.0 / (param_vals["scat"] * np.sqrt(2 * np.pi)) * np.exp(numer / (2.0 * param_vals["scat"] ** 2)) - ) - return ans - - def Y_erf(self, Y, Ynoise): - qmin = self.Survey.qmin - ans = Y * 0.0 - ans[Y - qmin * Ynoise > 0] = 1.0 - return ans - - def P_of_gt_SN(self, LgY, MM, zz, Ynoise, param_vals, Ez_fn, Da_fn): - Y = 10 ** LgY - - sig_tr = np.outer(np.ones([MM.shape[0], MM.shape[1]]), self.Y_erf(Y, Ynoise)) - sig_thresh = np.reshape(sig_tr, (MM.shape[0], MM.shape[1], len(self.Y_erf(Y, Ynoise)))) - - LgYa = np.outer(np.ones([MM.shape[0], MM.shape[1]]), LgY) - LgYa2 = np.reshape(LgYa, (MM.shape[0], MM.shape[1], len(LgY))) - - P_Y = np.nan_to_num(self.P_Yo_vec(LgYa2, MM, zz, param_vals, Ez_fn, Da_fn)) - - ans = np.trapz(P_Y * sig_thresh, x=LgY, axis=2) * np.log(10) - return ans - - def PfuncY(self, YNoise, M, z_arr, param_vals, Ez_fn, Da_fn): - LgY = self.LgY - - P_func = np.outer(M, np.zeros([len(z_arr)])) - M_arr = np.outer(M, np.ones([len(z_arr)])) - - P_func = self.P_of_gt_SN(LgY, M_arr, z_arr, YNoise, param_vals, Ez_fn, Da_fn) - return P_func - - def P_of_Y_per(self, LgY, MM, zz, Y_c, Y_err, param_vals): - P_Y_sig = np.outer(np.ones(len(MM)), self.Y_prob(Y_c, LgY, Y_err)) - LgYa = np.outer(np.ones(len(MM)), LgY) - - LgYa = np.outer(np.ones([MM.shape[0], MM.shape[1]]), LgY) - LgYa2 = np.reshape(LgYa, (MM.shape[0], MM.shape[1], len(LgY))) - - P_Y = np.nan_to_num(self.P_Yo(LgYa2, MM, zz, param_vals)) - ans = np.trapz(P_Y * P_Y_sig, LgY, np.diff(LgY), axis=1) * np.log(10) - - return ans - - def Y_prob(self, Y_c, LgY, YNoise): - Y = 10 ** (LgY) - - ans = gaussian(Y, Y_c, YNoise) - return ans - - def Pfunc_per(self, MM, zz, Y_c, Y_err, param_vals, Ez_fn, Da_fn): - LgY = self.LgY - LgYa = np.outer(np.ones(len(MM)), LgY) - - P_Y_sig = self.Y_prob(Y_c, LgY, Y_err) - P_Y = np.nan_to_num(self.P_Yo(LgYa, MM, zz, param_vals, Ez_fn, Da_fn)) - ans = np.trapz(P_Y * P_Y_sig, LgY, np.diff(LgY), axis=1) - - return ans - - def Pfunc_per_parallel(self, Marr, zarr, Y_c, Y_err, param_vals, Ez_fn, Da_fn): - # LgY = self.LgY - # LgYa = np.outer(np.ones(Marr.shape[0]), LgY) - - # LgYa = np.outer(np.ones([Marr.shape[0], Marr.shape[1]]), LgY) - # LgYa2 = np.reshape(LgYa, (Marr.shape[0], Marr.shape[1], len(LgY))) - - # Yc_arr = np.outer(np.ones(Marr.shape[0]), Y_c) - # Yerr_arr = np.outer(np.ones(Marr.shape[0]), Y_err) - - # Yc_arr = np.repeat(Yc_arr[:, :, np.newaxis], len(LgY), axis=2) - # Yerr_arr = np.repeat(Yerr_arr[:, :, np.newaxis], len(LgY), axis=2) - - # P_Y_sig = self.Y_prob(Yc_arr, LgYa2, Yerr_arr) - # P_Y = np.nan_to_num(self.P_Yo(LgYa2, Marr, zarr, param_vals, Ez_fn)) - - P_Y_sig = self.Y_prob(Y_c, self.LgY, Y_err) - P_Y = np.nan_to_num(self.P_Yo(self.LgY, Marr, zarr, param_vals, Ez_fn, Da_fn)) - - ans = np.trapz(P_Y * P_Y_sig, x=LgY, axis=2) - - return ans - - def Pfunc_per_zarr(self, MM, z_c, Y_c, Y_err, int_HMF, param_vals): - LgY = self.LgY - - # old was z_arr - # P_func = np.outer(MM, np.zeros([len(z_arr)])) - # M_arr = np.outer(MM, np.ones([len(z_arr)])) - # M200 = np.outer(MM, np.zeros([len(z_arr)])) - # zarr = np.outer(np.ones([len(M)]), z_arr) - - P_func = self.P_of_Y_per(LgY, MM, z_c, Y_c, Y_err, param_vals) - - return P_func - - -### -"""Routines from nemo (author: Matt Hilton ) to limit dependencies""" - - -# ------------------------------------------------------------------------------------------------------------ -def calcR500Mpc(z, M500, Ez_fn, H0): - """Given z, M500 (in MSun), returns R500 in Mpc, with respect to critical density. - - """ - - if type(M500) == str: - raise Exception( - "M500 is a string - check M500MSun in your .yml config file: use, e.g., 1.0e+14 (not 1e14 or 1e+14)" - ) - - Ez = Ez_fn(z) - - criticalDensity = rho_crit0H100 * (H0 / 100.) ** 2 * Ez ** 2 - R500Mpc = np.power((3 * M500) / (4 * np.pi * 500 * criticalDensity), 1.0 / 3.0) - - return R500Mpc - - -# ------------------------------------------------------------------------------------------------------------ -def calcTheta500Arcmin(z, M500, Ez_fn, Da_fn, H0): - """Given z, M500 (in MSun), returns angular size equivalent to R500, with respect to critical density. - - """ - - R500Mpc = calcR500Mpc(z, M500, Ez_fn, H0) - DAz = Da_fn(z) - - theta500Arcmin = np.degrees(np.arctan(R500Mpc / DAz)) * 60.0 - - return theta500Arcmin - - -# ------------------------------------------------------------------------------------------------------------ -def calcQ(theta500Arcmin, tck): - """Returns Q, given theta500Arcmin, and a set of spline fit knots for (theta, Q). - - """ - - # Q=np.poly1d(coeffs)(theta500Arcmin) - Q = interpolate.splev(theta500Arcmin, tck) - - return Q - - -# ------------------------------------------------------------------------------------------------------------ -def calcFRel(z, M500, obsFreqGHz=148.0, Ez_fn=None): - """Calculates relativistic correction to SZ effect at specified frequency, given z, M500 in MSun. - - This assumes the Arnaud et al. (2005) M-T relation, and applies formulae of Itoh et al. (1998) - - As for H13, we return fRel = 1 + delta_SZE (see also Marriage et al. 2011) - """ - - # NOTE: we should define constants somewhere else... - h = 6.63e-34 - kB = 1.38e-23 - sigmaT = 6.6524586e-29 - me = 9.11e-31 - e = 1.6e-19 - c = 3e8 - TCMB = 2.72548 - - # Using Arnaud et al. (2005) M-T to get temperature - A = 3.84e14 - B = 1.71 - # TkeV=5.*np.power(((cosmoModel.efunc(z)*M500)/A), 1/B) # HMF/Astropy - Ez = Ez_fn(z) - TkeV = 5.0 * np.power(((Ez * M500) / A), 1 / B) # Colossus - TKelvin = TkeV * ((1000 * e) / kB) - - # Itoh et al. (1998) eqns. 2.25 - 2.30 - thetae = (kB * TKelvin) / (me * c ** 2) - X = (h * obsFreqGHz * 1e9) / (kB * TCMB) - Xtw = X * (np.cosh(X / 2.0) / np.sinh(X / 2.0)) - Stw = X / np.sinh(X / 2.0) - - Y0 = -4 + Xtw - - Y1 = ( - -10.0 - + (47 / 2.0) * Xtw - - (42 / 5.0) * Xtw ** 2 - + (7 / 10.0) * Xtw ** 3 - + np.power(Stw, 2) * (-(21 / 5.0) + (7 / 5.0) * Xtw) - ) - - Y2 = ( - -(15 / 2.0) - + (1023 / 8.0) * Xtw - - (868 / 5.0) * Xtw ** 2 - + (329 / 5.0) * Xtw ** 3 - - (44 / 5.0) * Xtw ** 4 - + (11 / 30.0) * Xtw ** 5 - + np.power(Stw, 2) - * (-(434 / 5.0) + (658 / 5.0) * Xtw - (242 / 5.0) * Xtw ** 2 + (143 / 30.0) * Xtw ** 3) - + np.power(Stw, 4) * (-(44 / 5.0) + (187 / 60.0) * Xtw) - ) - - Y3 = ( - (15 / 2.0) - + (2505 / 8.0) * Xtw - - (7098 / 5.0) * Xtw ** 2 - + (14253 / 10.0) * Xtw ** 3 - - (18594 / 35.0) * Xtw ** 4 - + (12059 / 140.0) * Xtw ** 5 - - (128 / 21.0) * Xtw ** 6 - + (16 / 105.0) * Xtw ** 7 - + np.power(Stw, 2) - * ( - -(7098 / 10.0) - + (14253 / 5.0) * Xtw - - (102267 / 35.0) * Xtw ** 2 - + (156767 / 140.0) * Xtw ** 3 - - (1216 / 7.0) * Xtw ** 4 - + (64 / 7.0) * Xtw ** 5 - ) - + np.power(Stw, 4) - * (-(18594 / 35.0) + (205003 / 280.0) * Xtw - (1920 / 7.0) * Xtw ** 2 + (1024 / 35.0) * Xtw ** 3) - + np.power(Stw, 6) * (-(544 / 21.0) + (992 / 105.0) * Xtw) - ) - - Y4 = ( - -(135 / 32.0) - + (30375 / 128.0) * Xtw - - (62391 / 10.0) * Xtw ** 2 - + (614727 / 40.0) * Xtw ** 3 - - (124389 / 10.0) * Xtw ** 4 - + (355703 / 80.0) * Xtw ** 5 - - (16568 / 21.0) * Xtw ** 6 - + (7516 / 105.0) * Xtw ** 7 - - (22 / 7.0) * Xtw ** 8 - + (11 / 210.0) * Xtw ** 9 - + np.power(Stw, 2) - * ( - -(62391 / 20.0) - + (614727 / 20.0) * Xtw - - (1368279 / 20.0) * Xtw ** 2 - + (4624139 / 80.0) * Xtw ** 3 - - (157396 / 7.0) * Xtw ** 4 - + (30064 / 7.0) * Xtw ** 5 - - (2717 / 7.0) * Xtw ** 6 - + (2761 / 210.0) * Xtw ** 7 - ) - + np.power(Stw, 4) - * ( - -(124389 / 10.0) - + (6046951 / 160.0) * Xtw - - (248520 / 7.0) * Xtw ** 2 - + (481024 / 35.0) * Xtw ** 3 - - (15972 / 7.0) * Xtw ** 4 - + (18689 / 140.0) * Xtw ** 5 - ) - + np.power(Stw, 6) - * (-(70414 / 21.0) + (465992 / 105.0) * Xtw - (11792 / 7.0) * Xtw ** 2 + (19778 / 105.0) * Xtw ** 3) - + np.power(Stw, 8) * (-(682 / 7.0) + (7601 / 210.0) * Xtw) - ) - - deltaSZE = ( - ((X ** 3) / (np.exp(X) - 1)) - * ((thetae * X * np.exp(X)) / (np.exp(X) - 1)) - * (Y0 + Y1 * thetae + Y2 * thetae ** 2 + Y3 * thetae ** 3 + Y4 * thetae ** 4) - ) - - fRel = 1 + deltaSZE - - return fRel - - -# ------------------------------------------------------------------------------------------------------------ -def y0FromLogM500( - log10M500, - z, - tckQFit, - tenToA0=4.95e-5, - B0=0.08, - Mpivot=3e14, - sigma_int=0.2, - fRelWeightsDict={148.0: 1.0}, - H0=70., - Ez_fn=None, - Da_fn=None -): - """Predict y0~ given logM500 (in MSun) and redshift. Default scaling relation parameters are A10 (as in - H13). - - Use cosmoModel (astropy.cosmology object) to change/specify cosmological parameters. - - fRelWeightsDict is used to account for the relativistic correction when y0~ has been constructed - from multi-frequency maps. Weights should sum to 1.0; keys are observed frequency in GHz. - - Returns y0~, theta500Arcmin, Q - - """ - - if type(Mpivot) == str: - raise Exception( - "Mpivot is a string - check Mpivot in your .yml config file: use, e.g., 3.0e+14 (not 3e14 or 3e+14)" - ) - - # Filtering/detection was performed with a fixed fiducial cosmology... so we don't need to recalculate Q - # We just need to recalculate theta500Arcmin and E(z) only - M500 = np.power(10, log10M500) - theta500Arcmin = calcTheta500Arcmin(z, M500, Ez_fn, Da_fn, H0) - Q = calcQ(theta500Arcmin, tckQFit) - - Ez = Ez_fn(z) - - # Relativistic correction: now a little more complicated, to account for fact y0~ maps are weighted sum - # of individual frequency maps, and relativistic correction size varies with frequency - fRels = [] - freqWeights = [] - for obsFreqGHz in fRelWeightsDict.keys(): - fRels.append(calcFRel(z, M500, obsFreqGHz=obsFreqGHz, Ez_fn=Ez_fn)) - freqWeights.append(fRelWeightsDict[obsFreqGHz]) - fRel = np.average(np.array(fRels), axis=0, weights=freqWeights) - - # UPP relation according to H13 - # NOTE: m in H13 is M/Mpivot - # NOTE: this goes negative for crazy masses where the Q polynomial fit goes -ve, so ignore those - y0pred = tenToA0 * np.power(Ez, 2) * np.power(M500 / Mpivot, 1 + B0) * Q * fRel - - return y0pred, theta500Arcmin, Q diff --git a/soliket/clusters/tinker.py b/soliket/clusters/tinker.py deleted file mode 100644 index 6a63a7f4..00000000 --- a/soliket/clusters/tinker.py +++ /dev/null @@ -1,165 +0,0 @@ -from builtins import zip -import numpy as np -from scipy.interpolate import InterpolatedUnivariateSpline as iuSpline -from scipy.integrate import simps - -# Tinker stuff - -tinker_data = np.transpose([[float(x) for x in line.split()] - for line in - """200 0.186 1.47 2.57 1.19 - 300 0.200 1.52 2.25 1.27 - 400 0.212 1.56 2.05 1.34 - 600 0.218 1.61 1.87 1.45 - 800 0.248 1.87 1.59 1.58 - 1200 0.255 2.13 1.51 1.80 - 1600 0.260 2.30 1.46 1.97 - 2400 0.260 2.53 1.44 2.24 - 3200 0.260 2.66 1.41 2.44""".split('\n')]) - -tinker_splines = None - - -def tinker_params_spline(delta, z=None): - global tinker_splines - if tinker_splines is None: - tinker_splines = [] - D, data = np.log(tinker_data[0]), tinker_data[1:] - for y in data: - # Extend to large Delta - p = np.polyfit(D[-2:], y[-2:], 1) - x = np.hstack((D, D[-1] + 3.)) - y = np.hstack((y, np.polyval(p, x[-1]))) - tinker_splines.append(iuSpline(x, y, k=2)) - A0, a0, b0, c0 = [ts(np.log(delta)) for ts in tinker_splines] - if z is None: - return A0, a0, b0, c0 - - z = np.asarray(z) - A = A0 * (1 + z) ** -.14 - a = a0 * (1 + z) ** -.06 - alpha = 10. ** (-(((.75 / np.log10(delta / 75.))) ** 1.2)) - b = b0 * (1 + z) ** -alpha - c = np.zeros(np.shape(z)) + c0 - return A, a, b, c - - -def tinker_params_analytic(delta, z=None): - alpha = None - if np.asarray(delta).ndim == 0: # scalar delta. - A0, a0, b0, c0 = [p[0] for p in - tinker_params(np.array([delta]), z=None)] - if z is not None: - if delta < 75.: - alpha = 1. - else: - alpha = 10. ** (-(((.75 / np.log10(delta / 75.))) ** 1.2)) - - else: - log_delta = np.log10(delta) - A0 = 0.1 * log_delta - 0.05 - a0 = 1.43 + (log_delta - 2.3) ** (1.5) - b0 = 1.0 + (log_delta - 1.6) ** (-1.5) - c0 = log_delta - 2.35 - A0[delta > 1600] = .26 - a0[log_delta < 2.3] = 1.43 - b0[log_delta < 1.6] = 1.0 - c0[c0 < 0] = 0. - c0 = 1.2 + c0 ** 1.6 - if z is None: - return A0, a0, b0, c0 - A = A0 * (1 + z) ** -.14 - a = a0 * (1 + z) ** -.06 - if alpha is None: - alpha = 10. ** (-(((.75 / np.log10(delta / 75.))) ** 1.2)) - alpha[delta < 75.] = 1. - b = b0 * (1 + z) ** -alpha - c = np.zeros(np.shape(z)) + c0 - return A, a, b, c - - -tinker_params = tinker_params_spline - - -def tinker_f(sigma, params): - A, a, b, c = params - return A * ((sigma / b) ** -a + 1) * np.exp(-c / sigma ** 2) - - -# Sigma-evaluation, and top-hat functions. - -def radius_from_mass(M, rho): - """ - Convert mass M to radius R assuming density rho. - """ - return (3. * M / (4. * np.pi * rho)) ** (1 / 3.) - - -def top_hatf(kR): - """ - Returns the Fourier transform of the spherical top-hat function - evaluated at a given k*R. - Notes: - ------- - * This is called many times and costs a lot of runtime. - * For small values, use Taylor series. - """ - out = np.nan_to_num(3 * (np.sin(kR) - (kR) * np.cos(kR))) / ((kR) ** 3) - return out - - -def sigma_sq_integral(R_grid, power_spt, k_val): - """ - Determines the sigma^2 parameter over the m-z grid by integrating over k. - Notes: - ------- - * Fastest python solution I have found for this. There is probably a - smarter way using numpy arrays. - """ - to_integ = np.array( - [top_hatf(R_grid * k) ** 2 * np.tile( - power_spt[:, i], - (R_grid.shape[0], 1), - ) * k ** 2 for k, i in zip(k_val, np.arange(len(k_val)))] - ) - - return simps(to_integ / (2 * np.pi ** 2), x=k_val, axis=0) - - -def dn_dlogM(M, z, rho, delta, k, P, comoving=False): - """ - M is (nM) or (nM, nz) - z is (nz) - rho is (nz) - delta is (nz) or scalar - k is (nk) - P is (nz,nk) - - Somewhat awkwardly, k and P are comoving. rho really isn't. - return is (nM,nz) - """ - - if M.ndim == 1: - M = M[:, None] - # Radius associated to mass, co-moving - R = radius_from_mass(M, rho) - if not comoving: # if you do this make sure rho still has shape of z. - R = R * np.transpose(1 + z) - # Fluctuations on those scales (P and k are comoving) - sigma = sigma_sq_integral(R, P, k) ** .5 - # d log(sigma^-1) - # gradient is broken. - if R.shape[-1] == 1: - dlogs = -np.gradient(np.log(sigma[..., 0]))[:, None] - else: - dlogs = -np.gradient(np.log(sigma))[0] - # Evaluate Tinker mass function. - tp = tinker_params(delta, z) - tf = tinker_f(sigma, tp) - # dM; compute as M * dlogM since it is likely log-spaced. - if M.shape[-1] == 1: - dM = np.gradient(np.log(M[:, 0]))[:, None] * M - else: - dM = np.gradient(np.log(M))[0] * M - # Return dn / dlogM - return tf * rho * dlogs / dM diff --git a/soliket/cosmopower/cosmopower.py b/soliket/cosmopower/cosmopower.py new file mode 100644 index 00000000..6d28c445 --- /dev/null +++ b/soliket/cosmopower/cosmopower.py @@ -0,0 +1,406 @@ +from cobaya.theories.classy import classy +from copy import deepcopy +from typing import NamedTuple, Sequence, Union, Optional +from cobaya.tools import load_module +import logging +import os +import numpy as np +from cobaya.theory import Theory +from pkg_resources import resource_filename +import cosmopower as cp +import scipy +from cobaya.conventions import Const +H_units_conv_factor = {"1/Mpc": 1, "km/s/Mpc": Const.c_km_s} + +class cosmopower(classy): + path_to_trained_models: Optional[str] = resource_filename( + "cosmopower", "trained_models/CP_paper/CMB/" + ) + TT_emulator_name: Optional[str] = "Null_TT" + TE_emulator_name: Optional[str] = "Null_TE" + EE_emulator_name: Optional[str] = "Null_EE" + PP_emulator_name: Optional[str] = "Null_PP" + S8Z_emulator_name: Optional[str] = "Null_S8Z" + DAZ_emulator_name: Optional[str] = "Null_DAZ" + HZ_emulator_name: Optional[str] = "Null_HZ" + DER_emulator_name: Optional[str] = "Null_DERZ" + PKNL_emulator_name: Optional[str] = "Null_PKNL" + tt_emu = None + te_emu = None + ee_emu = None + s8z_emu = None + daz_emu = None + hz_emu = None + pp_emu = None + der_emu = None + pknl_emu = None + tt_spectra = None + te_spectra = None + ee_spectra = None + pp_spectra = None + + lensing_lkl = "SOLikeT" + ell_factor = False # True for pyactlite and bplike, False for clik + + # pkslice = 10 + # pp_spectra = None + + def initialize(self): + """Importing CLASS from the correct path, if given, and if not, globally.""" + self.classy_module = self.is_installed() + if not self.classy_module: + raise NotInstalledError( + self.log, "Could not find class. Check error message above.") + from classy_sz import Class, CosmoSevereError, CosmoComputationError + global CosmoComputationError, CosmoSevereError + self.classy = Class() + super(classy,self).initialize() + # Add general CLASS stuff + self.extra_args["output"] = self.extra_args.get("output", "") + if "sBBN file" in self.extra_args: + self.extra_args["sBBN file"] = ( + self.extra_args["sBBN file"].format(classy=self.path)) + # Derived parameters that may not have been requested, but will be necessary later + self.derived_extra = [] + # print(self.likelihood) + # exit(0) + if 'Null' not in self.TT_emulator_name: + self.tt_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.TT_emulator_name) + if 'Null' not in self.TE_emulator_name: + self.te_emu = cp.cosmopower_PCAplusNN(restore=True, + restore_filename=self.path_to_trained_models+self.TE_emulator_name) + if 'Null' not in self.EE_emulator_name: + self.ee_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.EE_emulator_name) + if 'Null' not in self.S8Z_emulator_name: + self.s8z_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.S8Z_emulator_name) + if 'Null' not in self.DAZ_emulator_name: + self.daz_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.DAZ_emulator_name) + if 'Null' not in self.HZ_emulator_name: + self.hz_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.HZ_emulator_name) + if 'Null' not in self.PP_emulator_name: + self.pp_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.PP_emulator_name) + # print(self.DER_emulator_name) + if 'Null' not in self.DER_emulator_name: + # print(self.DER_emulator_name) + # exit(0) + self.der_emu = cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.DER_emulator_name) + if 'Null' not in self.PKNL_emulator_name: + self.pknl_emu= cp.cosmopower_NN(restore=True, + restore_filename=self.path_to_trained_models+self.PKNL_emulator_name) + + + + self.log.info("Initialized!") + # self.log.info("using " + self.PP_emulator_name ) + # self.log.info("using " + self.PP_emulator_name + " and " + 'DER_cp_NN_Oct22B') + + # exit(0) + + # # here modify if you want to bypass stuff in the class computation + def calculate(self, state, want_derived=True, **params_values_dict): + # print("[calculate] Bypassing class computation") + # Set parameters + params_values = params_values_dict.copy() + params_values['ln10^{10}A_s'] = params_values.pop("logA") + + params_dict = {} + for k,v in zip(params_values.keys(),params_values.values()): + params_dict[k]=[v] + # print('\n') + # print('new params:') + # print(params_dict) + # exit(0) + if self.tt_emu is not None: + self.tt_spectra = self.tt_emu.ten_to_predictions_np(params_dict) + if self.te_emu is not None: + self.te_spectra = self.te_emu.predictions_np(params_dict) + if self.ee_emu is not None: + self.ee_spectra = self.ee_emu.ten_to_predictions_np(params_dict) + + params_dict_pp = params_dict.copy() + params_dict_pp.pop('tau_reio') + + if self.pp_emu is not None: + self.pp_spectra = self.pp_emu.ten_to_predictions_np(params_dict) + # print('pp spetrum ',self.pp_spectra) + # params_dict['z_pk_save_nonclass'] = [1.] + if self.der_emu is not None: + self.der_params = self.der_emu.ten_to_predictions_np(params_dict) + + if self.hz_emu is not None: + self.hz = self.hz_emu.ten_to_predictions_np(params_dict_pp) + + self.hz_interp = scipy.interpolate.interp1d( + np.linspace(0.,20.,5000), + self.hz[0], + kind='linear', + axis=-1, + copy=True, + bounds_error=None, + fill_value=np.nan, + assume_sorted=False) + if self.daz_emu is not None: + self.daz = self.daz_emu.predictions_np(params_dict_pp) + + self.daz_interp = scipy.interpolate.interp1d( + np.linspace(0.,20.,5000), + self.daz[0], + kind='linear', + axis=-1, + copy=True, + bounds_error=None, + fill_value=np.nan, + assume_sorted=False) + + if self.s8z_emu is not None: + self.s8z = self.s8z_emu.predictions_np(params_dict_pp) + # print(self.s8z) + self.s8z_interp = scipy.interpolate.interp1d( + np.linspace(0.,20.,5000), + self.s8z[0], + kind='linear', + axis=-1, + copy=True, + bounds_error=None, + fill_value=np.nan, + assume_sorted=False) + + for product, collector in self.collectors.items(): + arg_array = self.collectors[product].arg_array + + if product == 'fsigma8': + # print('dealing with fsigma8') + + method = getattr(self, collector.method) + # print(method) + arg_array = self.collectors[product].arg_array + if isinstance(arg_array, int): + arg_array = np.atleast_1d(arg_array) + if arg_array is None: + print('dealing with arg_array none case... calling method') + elif isinstance(arg_array, Sequence) or isinstance(arg_array, np.ndarray): + arg_array = np.array(arg_array) + if len(arg_array.shape) == 1: + # print('dealing with arg_array shape 1 case... calling method') + # if more than one vectorised arg, assume all vectorised in parallel + n_values = len(self.collectors[product].args[arg_array[0]]) + state[product] = np.zeros(n_values) + args = deepcopy(list(self.collectors[product].args)) + args.append(params_values_dict) + for i in range(n_values): + for arg_arr_index in arg_array: + args[arg_arr_index] = \ + self.collectors[product].args[arg_arr_index][i] + state[product][i] = method(*args) + # print('fs8: ',state[product][i]) + else: + raise LoggedError(self.log, "Variable over which to do an array call " + f"not known: arg_array={arg_array}") + if ('Pk_grid' in product) or ('comoving_radial_distance') in product: + method = getattr(self, collector.method) + args = deepcopy(list(self.collectors[product].args)) + args.append(params_values_dict) + state[product] = method(*args) + if collector.post: + state[product] = collector.post(*state[product]) + + + # get the required new observable + def get_Cl(self,ell_factor=True,units="FIRASmuK2"): + ell_factor=self.ell_factor + + cls = {} + cls['ell'] = np.arange(20000) + # print(cls['ell']) + cls['tt'] = np.zeros(20000) + cls['te'] = np.zeros(20000) + cls['ee'] = np.zeros(20000) + cls['pp'] = np.zeros(20000) + if self.tt_spectra is not None: + nl = len(self.tt_spectra[0]) + # print('nl:',nl) + cls['tt'][2:nl+2] = (2.7255e6)**2.*self.tt_spectra[0].copy() + if ell_factor==False: + lcp = np.asarray(cls['ell'][2:nl+2]) + cls['tt'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi) + + if self.te_spectra is not None: + cls['te'][2:nl+2] = (2.7255e6)**2.*self.te_spectra[0].copy() + if ell_factor==False: + lcp = np.asarray(cls['ell'][2:nl+2]) + cls['te'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi) + if self.ee_spectra is not None: + cls['ee'][2:nl+2] = (2.7255e6)**2.*self.ee_spectra[0].copy() + if ell_factor==False: + lcp = np.asarray(cls['ell'][2:nl+2]) + cls['ee'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi) + if self.pp_spectra is not None: + nl = len(self.pp_spectra[0]) + if self.lensing_lkl == "SOLikeT": + cls['pp'][2:nl+2] = self.pp_spectra[0].copy()/4. ## this is clkk... works for so lensinglite lkl + else: + # here for the planck lensing lkl, using lfactor option gives: + lcp = np.asarray(cls['ell'][2:nl+2]) + cls['pp'][2:nl+2] = self.pp_spectra[0].copy()/(lcp*(lcp+1.))**2. + cls['pp'][2:nl+2] *= (lcp*(lcp+1.))**2./2./np.pi + + + + return cls + + def get_param(self, p): + translated = self.translate_param(p) + if translated == 'rs_drag': + return self.rs_drag() + + if p == 'omegam': + return self.Omega_m() + + @classmethod + def is_installed(cls, **kwargs): + return load_module('cosmopower') + + + ################################# + # gives an estimation of f(z)*sigma8(z) at the scale of 8 h/Mpc, computed as (d sigma8/d ln a) + def effective_f_sigma8(self, z, z_step=0.1,params_values_dict={}): + """ + effective_f_sigma8(z) + + Returns the time derivative of sigma8(z) computed as (d sigma8/d ln a) + + Parameters + ---------- + z : float + Desired redshift + z_step : float + Default step used for the numerical two-sided derivative. For z < z_step the step is reduced progressively down to z_step/10 while sticking to a double-sided derivative. For z< z_step/10 a single-sided derivative is used instead. + + Returns + ------- + (d ln sigma8/d ln a)(z) (dimensionless) + """ + + s8z_interp = self.s8z_interp + # we need d sigma8/d ln a = - (d sigma8/dz)*(1+z) + + # if possible, use two-sided derivative with default value of z_step + if z >= z_step: + result = (s8z_interp(z-z_step)-s8z_interp(z+z_step))/(2.*z_step)*(1+z) + # return (s8z_interp(z-z_step)-s8z_interp(z+z_step))/(2.*z_step)*(1+z) + else: + # if z is between z_step/10 and z_step, reduce z_step to z, and then stick to two-sided derivative + if (z > z_step/10.): + z_step = z + result = (s8z_interp(z-z_step)-s8z_interp(z+z_step))/(2.*z_step)*(1+z) + # return (s8z_interp(z-z_step)-s8z_interp(z+z_step))/(2.*z_step)*(1+z) + # if z is between 0 and z_step/10, use single-sided derivative with z_step/10 + else: + z_step /=10 + result = (s8z_interp(z)-s8z_interp(z+z_step))/z_step*(1+z) + # return (s8z_interp(z)-s8z_interp(z+z_step))/z_step*(1+z) + # print('fsigma8 result : ',result) + return result + + def rs_drag(self): + return self.der_params[0][13] + + def Omega_m(self): + params_values = self.current_state['params'].copy() + result = (params_values['omega_b']+params_values['omega_cdm'])*(100./params_values['H0'])**2. + return result + + def get_angular_diameter_distance(self, z): + return np.array(self.daz_interp(z)) + + + def get_Hubble(self, z,units="km/s/Mpc"): + return np.array(self.hz_interp(z)*H_units_conv_factor[units]) + + + def get_pk_and_k_and_z(self,params_values_dict={}): + nz = 15 # number of z-points in redshift data [21oct22] --> set to 80 + zmax = 4. # max redshift of redshift data [21oct22] --> set to 4 because boltzmannbase.py wants to extrapolate + z_arr = np.linspace(0.,zmax,nz) # z-array of redshift data [21oct22] oct 26 22: nz = 1000, zmax = 20 + + nk = 5000 + ndspl = 10 + k_arr = np.geomspace(1e-4,50.,nk)[::ndspl] # oct 26 22 : (1e-4,50.,5000), jan 10: ndspl + # k_arr = np.geomspace(1e-4,50.,nk) # test + + # scaling factor for the pk emulator: + ls = np.arange(2,5000+2)[::ndspl] # jan 10 ndspl + # ls = np.arange(2,5000+2) # test + + dls = ls*(ls+1.)/2./np.pi + # params_values = self.current_state['params'].copy() + params_values = params_values_dict.copy() + params_values['ln10^{10}A_s'] = params_values.pop("logA") + + + # # naive implementation... this is way slower: + # params_dict = {} + # for k,v in zip(params_values.keys(),params_values.values()): + # params_dict[k]=np.repeat(v, nz) + # params_dict_pp = params_dict.copy() + # params_dict_pp.pop('tau_reio') + # params_dict_pp['z_pk_save_nonclass'] = z_arr + # predicted_pknl_spectrum = self.pknl_emu.predictions_np(params_dict_pp) + # print(np.shape(predicted_pknl_spectrum)) + + params_dict = {} + for k,v in zip(params_values.keys(),params_values.values()): + params_dict[k]=[v] + predicted_pknl_spectrum_z = [] + # def get_pk_cp(zz): + # params_dict_pp = params_dict.copy() + # params_dict_pp.pop('tau_reio') + # params_dict_pp['z_pk_save_nonclass'] = [zz] + # return self.pknl_emu.predictions_np(params_dict_pp)[0] + for zp in z_arr: + params_dict_pp = params_dict.copy() + params_dict_pp.pop('tau_reio') + params_dict_pp['z_pk_save_nonclass'] = [zp] + predicted_pknl_spectrum_z.append(self.pknl_emu.predictions_np(params_dict_pp)[0]) + # if zp>4.: + # predicted_pknl_spectrum_z.append(0.*k_arr) + # predicted_pknl_spectrum_z.append(get_pk_cp(zp)) + # get_pk_cp = np.vectorize(get_pk_cp) + # predicted_pknl_spectrum_z = get_pk_cp([0.1,0.3]) + # print(np.shape(predicted_pknl_spectrum_z)) + # exit(0) + predicted_pknl_spectrum = np.asarray(predicted_pknl_spectrum_z) + + # print(np.shape(predicted_pknl_spectrum)) + # print(predicted_pknl_spectrum[0][:10]) + # exit(0) + + + pknl = 10.**predicted_pknl_spectrum + pknl_re = ((dls)**-1*pknl) + pknl_re = np.transpose(pknl_re) + + + # return pknl_re[0:k_arr.size:self.pkslice][:], k_arr[0:k_arr.size:self.pkslice], z_arr + return pknl_re, k_arr, z_arr + + + def z_of_r (self,z_array,params_values_dict={}): + return np.array(self.daz_interp(z_array))*(1.+z_array), np.array(self.hz_interp(z_array)) + + +# this just need to be there as it's used to fill-in self.collectors in must_provide: +class Collector(NamedTuple): + method: str + args: Sequence = [] + args_names: Sequence = [] + kwargs: dict = {} + arg_array: Union[int, Sequence] = None + post: Optional[callable] = None diff --git a/soliket/cosmopower/covmats/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip_R0p01.covmat b/soliket/cosmopower/covmats/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip_R0p01.covmat new file mode 100644 index 00000000..c16cf432 --- /dev/null +++ b/soliket/cosmopower/covmats/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip_R0p01.covmat @@ -0,0 +1,8 @@ +# logA n_s theta_s_1e2 omega_b omega_cdm tau_reio yp2 +9.438899913894056295e-04 -1.577945686230644606e-04 -8.990440637417477615e-07 1.502179325446373719e-06 7.799574015903187115e-06 3.942041617741810148e-04 -1.149140546726826998e-05 +-1.577945686230644606e-04 2.330696463090182406e-04 3.179434093697125381e-06 -1.881816736761044138e-06 -3.032607420668092797e-05 2.360180840731857462e-05 1.097274165667060521e-06 +-8.990440637417477615e-07 3.179434093697125381e-06 4.670999767401897062e-07 -8.020680346416899429e-09 -9.028080234506492128e-07 7.565136966932839764e-07 -4.606008227262992523e-07 +1.502179325446373719e-06 -1.881816736761044138e-06 -8.020680346416899429e-09 9.444788498232016534e-08 -1.328459876895211121e-07 3.164994464923873037e-07 1.971712057760629038e-07 +7.799574015903187115e-06 -3.032607420668092797e-05 -9.028080234506492128e-07 -1.328459876895211121e-07 1.382575019521161139e-05 -1.282415304602769554e-05 4.557649072888552299e-06 +3.942041617741810148e-04 2.360180840731857462e-05 7.565136966932839764e-07 3.164994464923873037e-07 -1.282415304602769554e-05 2.134615687795045282e-04 -1.846421851606203035e-06 +-1.149140546726827506e-05 1.097274165667062850e-06 -4.606008227262992523e-07 1.971712057760628773e-07 4.557649072888552299e-06 -1.846421851606203035e-06 2.013334639882760960e-05 diff --git a/soliket/cosmopower/covmats/CLASS2p8_planck2018_DCDMSR_logpriors_lowTEB_plikHM_TTTEEE_FIRAS.covmat b/soliket/cosmopower/covmats/CLASS2p8_planck2018_DCDMSR_logpriors_lowTEB_plikHM_TTTEEE_FIRAS.covmat new file mode 100644 index 00000000..c0e248de --- /dev/null +++ b/soliket/cosmopower/covmats/CLASS2p8_planck2018_DCDMSR_logpriors_lowTEB_plikHM_TTTEEE_FIRAS.covmat @@ -0,0 +1,31 @@ +# T_cmb log10_omega_ini_dcdm_hat log10_Gamma_dcdm logA_hat n_s theta_s_1e2 omega_b_hat omega_cdm_hat tau_reio A_planck calib_100T calib_217T A_cib_217 xi_sz_cib A_sz ksz_norm gal545_A_100 gal545_A_143 gal545_A_143_217 gal545_A_217 ps_A_100_100 ps_A_143_143 ps_A_143_217 ps_A_217_217 galf_TE_A_100 galf_TE_A_100_143 galf_TE_A_100_217 galf_TE_A_143 galf_TE_A_143_217 galf_TE_A_217 +2.607419793346337769e-04 -1.838585246949395397e-03 8.379634310446842232e-03 -7.608461196889739007e-06 3.447842266113031097e-06 2.208734433709738958e-07 -1.129978870037982587e-07 -7.193824866744326650e-07 -3.218330415049037242e-07 -1.550327391626463184e-06 4.331391207343305650e-08 2.379410923294166611e-07 1.393833698589722286e-04 5.245586762523435804e-05 4.819428282975991032e-05 -6.982134492588343625e-05 4.769238377022664145e-04 -7.112174319492529137e-05 3.898125382277024115e-05 4.202559250540834171e-05 -7.490506045213288916e-03 -7.981677644467838860e-04 1.286154800156819348e-03 -1.459876448584029656e-03 -1.275264764082872148e-05 -7.104551360759291641e-06 2.578415467860546730e-05 -7.314135248256528376e-08 2.481525512091307194e-05 8.140115115676190049e-05 +-1.838585246949395397e-03 1.426894652325838564e-01 9.432948169381585868e-02 6.604895043581611089e-05 5.739617672675689629e-07 6.341137793297138235e-07 -4.535340669268015251e-06 -3.825545261152243134e-05 1.030202054583378460e-05 2.697183122038837054e-05 1.253797926692549448e-06 -5.129951003544683948e-06 2.574366399886384923e-02 -4.049805973556932733e-04 -1.111044323142939064e-02 2.892090196640005606e-02 -2.733682224743252519e-03 3.469486928077243452e-03 -4.023141006789502272e-04 -7.895876910756728304e-03 2.212583492982347078e-01 4.682730540878833614e-02 -2.522726079865233312e-02 -3.162352730279006235e-02 1.393999589278152845e-04 2.436737909408384552e-04 -9.519045635410713370e-05 -1.380908716005546709e-04 -4.732384493015351975e-05 1.334844225812307399e-03 +8.379634310446842232e-03 9.432948169381585868e-02 5.964180810344708039e-01 -5.809557046322557251e-04 2.304777391521236859e-04 1.549009172575493049e-05 -8.553399186962156093e-06 -1.111148624311252198e-04 -1.460409497505196080e-04 -2.758941936175442842e-05 3.654853638452961565e-06 4.452889047810339416e-06 2.719747149557811758e-02 -1.541248243537262242e-03 -1.283405849216691201e-02 1.497686842193501552e-02 1.635522843246239866e-02 1.169424687783120052e-04 -5.310386401389274522e-03 -7.158294398111708472e-03 -7.038306434781707588e-02 -9.639716317943164414e-03 -6.549049711266090312e-02 -9.984585353968454535e-02 -1.623908569842944774e-04 6.704513612383248113e-05 8.605469016526251860e-04 -3.234266886754017835e-04 5.228974249175695867e-04 5.688933092407535801e-03 +-7.608461196889739007e-06 6.604895043581609734e-05 -5.809557046322557251e-04 2.561942541726057671e-04 4.202160409326884451e-06 2.805191795868114288e-08 3.420499350346962147e-07 2.492961115292670184e-07 1.140126825009638310e-04 1.168029688012179943e-05 3.453727236526132162e-07 -1.527726158738440486e-07 -6.397822641822838857e-03 1.331998660786452122e-04 6.839223285523087338e-04 -3.458308274643300938e-03 -1.013086626303737669e-03 -1.693633502071551595e-03 -1.487605536909317704e-03 2.193280921322591278e-03 -1.414501566520047146e-02 -5.616823127903242639e-03 2.861569664553903665e-03 1.271399622624146304e-02 5.790219145695019702e-06 -1.452274233520074917e-06 -5.964357086743257426e-06 -1.180501168724205850e-05 -1.188963313418659095e-05 -9.291691292066429236e-05 +3.447842266113031097e-06 5.739617672675590103e-07 2.304777391521236859e-04 4.202160409326884451e-06 1.839847885066316777e-05 3.743645043240909570e-07 2.923310539691147795e-07 -4.368478405103176332e-06 7.639117066723947327e-06 3.778804279573673068e-07 -6.893590923345471125e-08 -4.583785260106377336e-08 -3.770760411996272338e-03 8.363762721829491966e-05 7.351804730342869710e-04 -1.698640425713811384e-03 3.298002946305112794e-04 -3.219830707107985144e-04 -4.691311177787305261e-04 8.541824133830925019e-04 -2.028088738705087490e-02 -6.880242362746927069e-03 2.178298597069990082e-04 3.071016056244083373e-03 -2.461080139747981854e-06 -1.055808493356125118e-07 6.267844571190336296e-06 -2.292550599239286305e-06 -3.294368052958894136e-06 -2.930216308853999572e-05 +2.208734433709738958e-07 6.341137793297132941e-07 1.549009172575493049e-05 2.805191795868114288e-08 3.743645043240909570e-07 8.759339847405053543e-08 1.094422343503078991e-08 -1.110197915347317346e-07 1.255884247348047632e-07 -5.239948655752724628e-09 9.221525694078517338e-10 2.737375538322799798e-09 6.765194004186426253e-05 -8.791255999569881815e-07 -8.561587411715202515e-07 1.397138050510529433e-05 1.138153760811717965e-05 2.695215577196036471e-07 -6.380963909640421100e-06 -3.582435559973891256e-05 -2.274034793978535384e-05 -3.954948278381327661e-05 -8.172667383717416561e-05 -1.435333188495259069e-04 -1.359824685540792802e-07 5.232481033607049880e-08 -8.707878268095018630e-09 8.708442812444505316e-09 -3.929322516084711716e-07 -6.916858085454095528e-07 +-1.129978870037982587e-07 -4.535340669268016098e-06 -8.553399186962152705e-06 3.420499350346962147e-07 2.923310539691147795e-07 1.094422343503078991e-08 2.212680770667600610e-08 -1.175601934064581702e-07 2.574903270676539838e-07 1.657452131009961964e-08 2.481064532757597060e-09 -3.991695959529654529e-10 -6.517697504161454694e-05 6.759483890835801758e-07 1.632432606609053854e-05 -3.115484371140672925e-05 -6.111497144336874183e-07 -7.754351432144180925e-06 -8.715070372146812295e-06 1.211656163791920675e-05 -3.524725813187003123e-04 -2.217045118031631405e-04 -9.831714275718512932e-05 -2.807356010781461811e-05 -7.527032896870078538e-10 -2.484113438377948819e-08 -1.248320895190398410e-07 -3.504718240532528953e-07 -5.062881666947524974e-07 -2.753640580321990276e-06 +-7.193824866744327709e-07 -3.825545261152243134e-05 -1.111148624311252198e-04 2.492961115292670184e-07 -4.368478405103176332e-06 -1.110197915347317346e-07 -1.175601934064581702e-07 1.917160630150739418e-06 -2.060308416982644221e-06 -1.105244896094235871e-07 -3.528983773022332143e-10 -5.745911547031858146e-09 7.472780915169525008e-05 1.570760749456065073e-06 -1.897543624060555974e-05 -2.116977223458323896e-05 -4.004678577609733603e-05 3.471057515847194988e-06 6.225735122499157881e-05 4.972648240009075064e-05 9.679652368133610145e-04 1.020976039157610576e-03 8.054199004628819197e-04 6.316594129012522698e-04 8.864477275068186833e-07 6.760176720232817992e-08 -3.314512768142908256e-07 1.720229415619267629e-06 3.868922600482007652e-06 1.770920888770700013e-05 +-3.218330415049044124e-07 1.030202054583380154e-05 -1.460409497505196080e-04 1.140126825009638310e-04 7.639117066723947327e-06 1.255884247348047367e-07 2.574903270676539838e-07 -2.060308416982644221e-06 5.927515244380260096e-05 -6.373077198447203336e-09 1.074553180055081697e-07 -7.180724783470829861e-08 -3.422876751979354697e-03 4.045671059994975275e-05 4.130111962261094377e-04 -1.251437162430820522e-03 -3.296353512786264644e-04 -4.709869122827531991e-04 -4.498642592414428890e-04 5.998885811276741123e-04 -9.462217015468397593e-03 -4.697719508176079715e-03 -6.153791318519999040e-04 3.390830881498038251e-03 5.989436949133371194e-08 -1.469916826292368612e-06 -1.883548944477976334e-07 -6.449405220962029016e-06 -9.682235954784561730e-06 -6.703728017033542001e-05 +-1.550327391626463184e-06 2.697183122038836715e-05 -2.758941936175441148e-05 1.168029688012179943e-05 3.778804279573673068e-07 -5.239948655752724628e-09 1.657452131009961964e-08 -1.105244896094235871e-07 -6.373077198447119791e-09 5.941251581733969922e-06 -1.290656981421503882e-08 6.892315733018577105e-09 8.914961690435960467e-04 2.522992193638544022e-06 -5.616891261183870778e-05 -4.109858997383452120e-05 1.056885443265014905e-05 -8.484364499739491803e-05 -1.281938094774420507e-04 4.638715477254852786e-04 3.960573744036764710e-03 7.039771921580873469e-04 2.802617399897652838e-04 7.857053239811466385e-04 1.670307297654667127e-06 7.304536545118823913e-07 -4.862883889820471646e-07 -5.845250454673002213e-07 3.460922484235379135e-07 4.926200974183551073e-06 +4.331391207343305650e-08 1.253797926692549237e-06 3.654853638452961565e-06 3.453727236526132162e-07 -6.893590923345471125e-08 9.221525694078517338e-10 2.481064532757597060e-09 -3.528983773022323354e-10 1.074553180055081962e-07 -1.290656981421503882e-08 3.762818708723688531e-07 1.222823445080563994e-10 -1.643347740458708317e-04 2.313714325696861790e-06 9.544991892393824484e-05 -7.774238639166797173e-05 1.769500342512204765e-04 -1.808495159259060716e-04 -4.456906460256616193e-05 2.521367907900168699e-05 3.923654739608191909e-03 4.924019765413846121e-05 3.461330888424072141e-04 3.906686780915353901e-04 2.323216660766414867e-07 -7.756405566527786804e-08 -6.175645425053021015e-07 -1.173301808599385896e-07 -1.342857951839696134e-07 7.250456490755037130e-07 +2.379410923294166611e-07 -5.129951003544682254e-06 4.452889047810338569e-06 -1.527726158738440486e-07 -4.583785260106377336e-08 2.737375538322799798e-09 -3.991695959529654529e-10 -5.745911547031858146e-09 -7.180724783470828538e-08 6.892315733018577105e-09 1.222823445080563994e-10 3.893127289176713453e-07 7.461971196885590699e-04 -8.617947290853393023e-07 -6.032295267573154542e-05 1.901362512981612254e-05 9.874241581646252475e-06 -8.413649119837698847e-06 4.180067933408052223e-04 9.109311518684462278e-04 7.919934588781497300e-04 1.034820348311152425e-04 -4.544877716412840194e-04 -1.409889054958436564e-03 -3.614521081786299520e-07 1.006119706735768371e-07 -1.382608072902446913e-07 7.818659169209708844e-07 -4.112952292739861888e-07 -2.219170101118694020e-06 +1.393833698589724997e-04 2.574366399886384923e-02 2.719747149557812799e-02 -6.397822641822838857e-03 -3.770760411996272338e-03 6.765194004186426253e-05 -6.517697504161454694e-05 7.472780915169526363e-05 -3.422876751979354697e-03 8.914961690435962635e-04 -1.643347740458708588e-04 7.461971196885590699e-04 4.394522965391754354e+01 -3.921263121435786814e-01 -7.644927022071278389e-01 -3.435098658896998947e-01 2.851278385166224338e-01 6.157930814472751813e-01 -5.663026535024488162e+00 -3.254249968108506863e+01 3.499190639844456285e+01 1.681425402974543459e+00 -1.290729791789551406e+01 -5.421257321599549073e+01 -3.133031429132461868e-03 -9.478523791747628271e-05 3.399770583053790887e-03 6.247898510038091399e-04 -1.198339786601597748e-02 -1.382543635782802587e-02 +5.245586762523435126e-05 -4.049805973556934902e-04 -1.541248243537262242e-03 1.331998660786452122e-04 8.363762721829491966e-05 -8.791255999569884991e-07 6.759483890835802817e-07 1.570760749456062320e-06 4.045671059994975953e-05 2.522992193638544022e-06 2.313714325696862214e-06 -8.617947290853391964e-07 -3.921263121435786814e-01 8.146029537451703051e-02 -5.556757061442154505e-02 5.409979063260489385e-02 -7.564805727058359665e-03 1.166607734462111329e-02 1.088007385661362569e-01 1.450426514667262357e-01 -5.117172704819311635e-01 9.421480137213266159e-01 1.688141921510121213e+00 6.333961690873342043e-01 4.594320368489162947e-05 -6.069492122441977646e-06 -2.038355476148321247e-05 -1.249416402388626264e-04 5.889415876642458770e-04 1.471342094948494645e-03 +4.819428282975999841e-05 -1.111044323142939411e-02 -1.283405849216691201e-02 6.839223285523088423e-04 7.351804730342869710e-04 -8.561587411715222632e-07 1.632432606609053854e-05 -1.897543624060555296e-05 4.130111962261093293e-04 -5.616891261183871455e-05 9.544991892393824484e-05 -6.032295267573154542e-05 -7.644927022071278389e-01 -5.556757061442153117e-02 3.827928576479410427e+00 -2.697623880017569142e+00 -2.124188101186070543e-01 1.506965067273634551e-01 2.583896831789073367e+00 3.204336028816334725e+00 -2.979601599421018676e+01 -3.430319759243565247e+00 7.196696364088744247e+00 5.110548622284960096e+00 4.736966908710892456e-04 1.040994270292277548e-04 1.163390611501595603e-04 -1.219687650720361607e-03 -1.589495085828692474e-03 -1.019677787670044203e-02 +-6.982134492588363953e-05 2.892090196640005259e-02 1.497686842193501379e-02 -3.458308274643300938e-03 -1.698640425713811384e-03 1.397138050510529433e-05 -3.115484371140673603e-05 -2.116977223458323896e-05 -1.251437162430820522e-03 -4.109858997383449410e-05 -7.774238639166795818e-05 1.901362512981611915e-05 -3.435098658896998947e-01 5.409979063260489385e-02 -2.697623880017569142e+00 5.795619757290334739e+00 1.033014113842215392e-01 -1.997938063629267902e-01 -2.090796519916175988e+00 -2.272628690691974374e+00 1.338640285149540254e+01 -4.834625943257463199e+00 -1.140695531189551204e+01 -8.790121205133983651e+00 -3.394517934078139488e-04 -1.131886129476291638e-04 7.503879829677713442e-04 6.741014206283459315e-04 1.705565280917610170e-03 6.239970513379096244e-03 +4.769238377022664145e-04 -2.733682224743252519e-03 1.635522843246239866e-02 -1.013086626303737669e-03 3.298002946305113336e-04 1.138153760811718473e-05 -6.111497144336867831e-07 -4.004678577609732925e-05 -3.296353512786264644e-04 1.056885443265015414e-05 1.769500342512204765e-04 9.874241581646250781e-06 2.851278385166224894e-01 -7.564805727058359665e-03 -2.124188101186070543e-01 1.033014113842215254e-01 3.292000155178555154e+00 4.801082812752942575e-01 4.542642730832241460e-02 -7.352938202090203434e-02 -6.374491005724857828e+00 -3.460142345677736375e-01 -7.436801538072593809e-01 -6.386811762624843292e-01 6.227158008486415020e-05 4.062506640336406094e-04 8.996417581685944896e-04 4.450036894530117935e-04 -7.259734815890760010e-04 1.596900643618770748e-03 +-7.112174319492533202e-05 3.469486928077243452e-03 1.169424687783079123e-04 -1.693633502071551595e-03 -3.219830707107985144e-04 2.695215577196017413e-07 -7.754351432144182619e-06 3.471057515847181859e-06 -4.709869122827530365e-04 -8.484364499739490448e-05 -1.808495159259060716e-04 -8.413649119837698847e-06 6.157930814472751813e-01 1.166607734462111502e-02 1.506965067273634551e-01 -1.997938063629267624e-01 4.801082812752942575e-01 3.144674688169224464e+00 2.732081521908611421e+00 2.743865331282221209e+00 6.038162165256543368e+00 -1.232438391158571234e+00 -6.660140231117885889e-01 -1.302699236231551483e+00 -4.829125344335758992e-04 -7.039551364571624420e-04 -2.937130846335116500e-04 -1.043314127768948246e-03 3.655497159687135521e-06 2.255224702991351447e-03 +3.898125382277024115e-05 -4.023141006789512572e-04 -5.310386401389265848e-03 -1.487605536909317270e-03 -4.691311177787305261e-04 -6.380963909640419406e-06 -8.715070372146812295e-06 6.225735122499159236e-05 -4.498642592414428890e-04 -1.281938094774420236e-04 -4.456906460256616193e-05 4.180067933408052223e-04 -5.663026535024488162e+00 1.088007385661362569e-01 2.583896831789073367e+00 -2.090796519916175988e+00 4.542642730832240766e-02 2.732081521908610977e+00 1.081349828867016960e+01 1.922749233854389672e+01 -1.112286093659575315e+01 3.468352199366042221e+00 4.619202331921761662e+00 5.099477174632628618e+00 1.579879327755010811e-03 3.174065694934199273e-04 -7.053926718544520618e-04 -1.172399929411028791e-03 -1.893590812108204152e-03 2.559209448461288727e-03 +4.202559250540786737e-05 -7.895876910756738712e-03 -7.158294398111711074e-03 2.193280921322591278e-03 8.541824133830923935e-04 -3.582435559973891256e-05 1.211656163791920675e-05 4.972648240009075742e-05 5.998885811276741123e-04 4.638715477254853328e-04 2.521367907900168699e-05 9.109311518684462278e-04 -3.254249968108506863e+01 1.450426514667262357e-01 3.204336028816334725e+00 -2.272628690691974374e+00 -7.352938202090206210e-02 2.743865331282221653e+00 1.922749233854389672e+01 5.290683742505487430e+01 -2.236837067009869529e+01 4.027460774490444706e+00 7.505265767415625788e+00 3.212557273350655151e+01 3.767338295660678082e-03 1.858033846575819683e-03 -3.562964267109364203e-03 1.245003326628393771e-03 9.270212471733725492e-05 6.991892997284403265e-04 +-7.490506045213288916e-03 2.212583492982347078e-01 -7.038306434781697873e-02 -1.414501566520047666e-02 -2.028088738705087490e-02 -2.274034793978536062e-05 -3.524725813187003123e-04 9.679652368133610145e-04 -9.462217015468397593e-03 3.960573744036763842e-03 3.923654739608191909e-03 7.919934588781497300e-04 3.499190639844456285e+01 -5.117172704819311635e-01 -2.979601599421017966e+01 1.338640285149540254e+01 -6.374491005724857828e+00 6.038162165256543368e+00 -1.112286093659575315e+01 -2.236837067009869529e+01 7.847690066885199940e+02 6.752822645489996489e+01 -5.337623916060034901e+01 -5.924657548187286693e+01 1.620315827860668162e-02 7.078951926727600034e-03 3.089284016434301269e-02 1.275494604934817450e-02 1.198874437527087077e-02 1.280567561636669349e-01 +-7.981677644467836692e-04 4.682730540878835002e-02 -9.639716317943183496e-03 -5.616823127903240905e-03 -6.880242362746927069e-03 -3.954948278381326983e-05 -2.217045118031631405e-04 1.020976039157610576e-03 -4.697719508176079715e-03 7.039771921580872385e-04 4.924019765413848154e-05 1.034820348311152425e-04 1.681425402974543015e+00 9.421480137213266159e-01 -3.430319759243565247e+00 -4.834625943257463199e+00 -3.460142345677736930e-01 -1.232438391158571234e+00 3.468352199366041333e+00 4.027460774490444706e+00 6.752822645489996489e+01 6.173773169215798617e+01 4.020353342422079379e+01 1.497388704186092845e+01 4.285503479471598244e-03 1.077985611806009337e-03 -1.867934465019077520e-04 1.055357834974828251e-03 9.141695890535142185e-03 6.107128263358176101e-02 +1.286154800156818915e-03 -2.522726079865234006e-02 -6.549049711266093088e-02 2.861569664553903665e-03 2.178298597069990082e-04 -8.172667383717415206e-05 -9.831714275718516998e-05 8.054199004628820281e-04 -6.153791318519999040e-04 2.802617399897653380e-04 3.461330888424072141e-04 -4.544877716412840194e-04 -1.290729791789551406e+01 1.688141921510121213e+00 7.196696364088744247e+00 -1.140695531189551026e+01 -7.436801538072593809e-01 -6.660140231117884779e-01 4.619202331921761662e+00 7.505265767415625788e+00 -5.337623916060034901e+01 4.020353342422079379e+01 8.404878326190056725e+01 5.225303816325442341e+01 2.801481943255165578e-03 4.957359341213004623e-04 -2.764283035243297187e-03 -2.935955209370118973e-03 1.611175278866697202e-02 3.384759167451983908e-02 +-1.459876448584029440e-03 -3.162352730279006235e-02 -9.984585353968450372e-02 1.271399622624146304e-02 3.071016056244083373e-03 -1.435333188495258527e-04 -2.807356010781461133e-05 6.316594129012522698e-04 3.390830881498038251e-03 7.857053239811464217e-04 3.906686780915353901e-04 -1.409889054958436781e-03 -5.421257321599549073e+01 6.333961690873342043e-01 5.110548622284960985e+00 -8.790121205133983651e+00 -6.386811762624844402e-01 -1.302699236231551261e+00 5.099477174632628618e+00 3.212557273350654441e+01 -5.924657548187286693e+01 1.497388704186092845e+01 5.225303816325442341e+01 1.020907247769059722e+02 4.727987516901940857e-03 -1.713093590189938376e-04 -9.760579147400584923e-03 -1.074252391877387894e-03 2.108466228257857913e-02 3.639752786742044000e-02 +-1.275264764082872148e-05 1.393999589278153387e-04 -1.623908569842942877e-04 5.790219145695022243e-06 -2.461080139747980584e-06 -1.359824685540792537e-07 -7.527032896870105421e-10 8.864477275068187892e-07 5.989436949133320901e-08 1.670307297654667339e-06 2.323216660766414338e-07 -3.614521081786299520e-07 -3.133031429132461000e-03 4.594320368489157526e-05 4.736966908710885408e-04 -3.394517934078139488e-04 6.227158008486415020e-05 -4.829125344335760618e-04 1.579879327755011028e-03 3.767338295660678082e-03 1.620315827860667815e-02 4.285503479471597377e-03 2.801481943255163844e-03 4.727987516901939989e-03 1.450310708890116106e-03 2.680780799771016461e-04 1.027941042478092566e-04 -3.833262286794940376e-04 -7.908107317508508846e-05 -4.468432791596462633e-05 +-7.104551360759294182e-06 2.436737909408384010e-04 6.704513612383245402e-05 -1.452274233520075553e-06 -1.055808493356128294e-07 5.232481033607045910e-08 -2.484113438377950142e-08 6.760176720232819315e-08 -1.469916826292368612e-06 7.304536545118822854e-07 -7.756405566527789451e-08 1.006119706735768107e-07 -9.478523791747724494e-05 -6.069492122441953929e-06 1.040994270292275786e-04 -1.131886129476295026e-04 4.062506640336405010e-04 -7.039551364571624420e-04 3.174065694934193852e-04 1.858033846575819032e-03 7.078951926727599167e-03 1.077985611806009337e-03 4.957359341213010044e-04 -1.713093590189922926e-04 2.680780799771016461e-04 8.611284757075335448e-04 3.937717666348952770e-05 7.228789309507445936e-04 6.247096804850576644e-05 -6.778851174105638344e-04 +2.578415467860545714e-05 -9.519045635410730989e-05 8.605469016526251860e-04 -5.964357086743259120e-06 6.267844571190336296e-06 -8.707878268095127817e-09 -1.248320895190398410e-07 -3.314512768142913550e-07 -1.883548944477979510e-07 -4.862883889820474823e-07 -6.175645425053019956e-07 -1.382608072902447442e-07 3.399770583053787851e-03 -2.038355476148325313e-05 1.163390611501588555e-04 7.503879829677715611e-04 8.996417581685948149e-04 -2.937130846335114873e-04 -7.053926718544514113e-04 -3.562964267109364203e-03 3.089284016434301269e-02 -1.867934465019070744e-04 -2.764283035243303259e-03 -9.760579147400586658e-03 1.027941042478092837e-04 3.937717666348954126e-05 7.193763893187391824e-03 -3.318575588196079557e-04 6.627639707114785618e-04 4.743293850133083710e-03 +-7.314135248256261031e-08 -1.380908716005547793e-04 -3.234266886754018919e-04 -1.180501168724205681e-05 -2.292550599239287576e-06 8.708442812444483809e-09 -3.504718240532528953e-07 1.720229415619268052e-06 -6.449405220962029016e-06 -5.845250454673000095e-07 -1.173301808599384308e-07 7.818659169209710962e-07 6.247898510038093567e-04 -1.249416402388626264e-04 -1.219687650720361607e-03 6.741014206283459315e-04 4.450036894530113598e-04 -1.043314127768948029e-03 -1.172399929411028791e-03 1.245003326628392904e-03 1.275494604934816929e-02 1.055357834974828251e-03 -2.935955209370120274e-03 -1.074252391877387894e-03 -3.833262286794939292e-04 7.228789309507445936e-04 -3.318575588196079557e-04 2.894885254390176278e-03 4.943112624681570083e-04 -1.118969710756599449e-03 +2.481525512091307194e-05 -4.732384493015347909e-05 5.228974249175696951e-04 -1.188963313418658587e-05 -3.294368052958892018e-06 -3.929322516084711716e-07 -5.062881666947524974e-07 3.868922600482007652e-06 -9.682235954784563424e-06 3.460922484235379135e-07 -1.342857951839696928e-07 -4.112952292739864535e-07 -1.198339786601597748e-02 5.889415876642458770e-04 -1.589495085828693775e-03 1.705565280917610170e-03 -7.259734815890765431e-04 3.655497159686878870e-06 -1.893590812108203285e-03 9.270212471733725492e-05 1.198874437527087077e-02 9.141695890535142185e-03 1.611175278866697202e-02 2.108466228257857913e-02 -7.908107317508510201e-05 6.247096804850576644e-05 6.627639707114785618e-04 4.943112624681570083e-04 6.332995110554095509e-03 7.982637877764606552e-03 +8.140115115676188693e-05 1.334844225812307182e-03 5.688933092407536668e-03 -9.291691292066429236e-05 -2.930216308853999572e-05 -6.916858085454094469e-07 -2.753640580321990700e-06 1.770920888770700013e-05 -6.703728017033542001e-05 4.926200974183555308e-06 7.250456490755033954e-07 -2.219170101118694443e-06 -1.382543635782802934e-02 1.471342094948494645e-03 -1.019677787670044203e-02 6.239970513379098846e-03 1.596900643618769664e-03 2.255224702991352748e-03 2.559209448461289595e-03 6.991892997284364234e-04 1.280567561636669349e-01 6.107128263358176795e-02 3.384759167451984602e-02 3.639752786742045387e-02 -4.468432791596461278e-05 -6.778851174105639428e-04 4.743293850133083710e-03 -1.118969710756599232e-03 7.982637877764606552e-03 7.252482574014217087e-02 diff --git a/soliket/cosmopower/covmats/base_mnu_plikHMTTTEE_lowl_lowe_cosmopower.covmat b/soliket/cosmopower/covmats/base_mnu_plikHMTTTEE_lowl_lowe_cosmopower.covmat new file mode 100644 index 00000000..d7228f5e --- /dev/null +++ b/soliket/cosmopower/covmats/base_mnu_plikHMTTTEE_lowl_lowe_cosmopower.covmat @@ -0,0 +1,9 @@ +# omega_b omega_cdm H0 n_s logA tau_reio m_ncdm A_planck + 2.8648997E-08 -1.4767621E-07 1.9314488E-04 5.4851016E-07 7.4132027E-07 4.6817878E-07 -1.4269375E-05 1.3093039E-08 + -1.4767621E-07 2.1373415E-06 -1.2557402E-03 -5.5720859E-06 -8.7864932E-06 -6.8647323E-06 4.1705025E-05 -3.7764438E-08 + 1.9314488E-04 -1.2557402E-03 3.3971452E+00 7.1996600E-03 -4.7521484E-03 -1.5942919E-03 -3.5361562E-01 -7.6603542E-06 + 5.4851016E-07 -5.5720859E-06 7.1996600E-03 3.0823563E-05 2.5203036E-05 1.9231748E-05 -6.0818893E-04 -5.6018781E-08 + 7.4132027E-07 -8.7864932E-06 -4.7521484E-03 2.5203036E-05 9.3000226E-04 4.6797197E-04 1.0802142E-03 8.4517714E-06 + 4.6817878E-07 -6.8647323E-06 -1.5942919E-03 1.9231748E-05 4.6797197E-04 2.4581451E-04 5.6628968E-04 -2.1390049E-06 + -1.4269375E-05 4.1705025E-05 -3.5361562E-01 -6.0818893E-04 1.0802142E-03 5.6628968E-04 4.2238020E-02 4.0811355E-06 + 1.3093039E-08 -3.7764438E-08 -7.6603542E-06 -5.6018781E-08 8.4517714E-06 -2.1390049E-06 4.0811355E-06 6.4450698E-06 diff --git a/soliket/cosmopower/covmats/desy1_joint_plancklensing2018_lenspriorsyes_BAO_cosmopower.covmat b/soliket/cosmopower/covmats/desy1_joint_plancklensing2018_lenspriorsyes_BAO_cosmopower.covmat new file mode 100644 index 00000000..0a2e5496 --- /dev/null +++ b/soliket/cosmopower/covmats/desy1_joint_plancklensing2018_lenspriorsyes_BAO_cosmopower.covmat @@ -0,0 +1,26 @@ +# DES_DzL1 DES_DzL2 DES_DzL3 DES_DzL4 DES_DzL5 DES_b1 DES_b2 DES_b3 DES_b4 DES_b5 DES_DzS1 DES_DzS2 DES_DzS3 DES_DzS4 DES_m1 DES_m2 DES_m3 DES_m4 DES_AIA DES_alphaIA omega_b omega_cdm H0 n_s logA + 5.4334219E-05 -1.6674906E-07 1.4441334E-07 8.2027727E-07 -9.8093344E-09 1.3651901E-04 -6.2783312E-06 4.5017411E-07 1.0321158E-06 3.8377489E-06 2.9336526E-06 -9.1113752E-07 2.7421714E-06 7.8186128E-08 3.2885252E-08 -3.5837461E-07 -1.2244996E-06 2.7190620E-07 -4.1222279E-05 1.3733625E-03 -3.2338288E-08 -1.0487950E-06 -1.0739427E-05 1.6864727E-06 9.0897165E-06 + -1.6674906E-07 4.2697718E-05 3.5783255E-07 2.1807319E-07 9.0040988E-07 7.1445361E-06 6.7786718E-05 4.2730440E-06 4.6137287E-06 1.0251473E-06 1.6676604E-07 3.2078451E-06 8.8628429E-07 -1.0655525E-07 4.3799440E-07 1.6775446E-06 2.2461057E-06 -2.1427384E-06 -6.7009742E-05 5.4338927E-04 4.1744997E-09 -1.4129370E-06 -1.8022605E-05 2.3384126E-06 1.1853489E-05 + 1.4441334E-07 3.5783255E-07 4.2004613E-05 -2.7301854E-07 1.0292922E-06 9.5298920E-06 3.5658880E-06 5.4807061E-05 -1.3133782E-06 2.7639878E-06 -1.0334116E-06 4.9865622E-06 4.6179788E-06 -7.1243588E-07 4.1959985E-06 -2.9928243E-07 2.2847038E-06 -2.5560790E-07 2.9981325E-05 2.8944497E-04 8.2523673E-09 -7.7984792E-07 -4.1874300E-05 1.9437943E-06 1.0925873E-05 + 8.2027727E-07 2.1807319E-07 -2.7301854E-07 7.8335646E-05 6.0153359E-07 1.1635701E-05 2.2016314E-06 -1.0648166E-06 1.0074452E-04 -2.0888674E-06 8.1984620E-07 3.8849788E-07 6.5448473E-06 1.1464621E-05 -2.8906039E-06 -5.0352744E-07 -2.5576433E-06 -2.5994379E-06 -1.7286586E-04 -8.7530728E-04 -1.6242236E-08 -2.0775506E-06 -1.9657560E-05 2.8363048E-06 2.3422829E-05 + -9.8093344E-09 9.0040988E-07 1.0292922E-06 6.0153359E-07 9.4062530E-05 -1.1754088E-05 3.8531335E-06 6.4411464E-06 2.7537299E-06 1.2301525E-04 2.2921401E-06 -1.1406582E-06 -1.7296011E-07 6.7616886E-06 1.0697258E-06 5.1481327E-07 6.7262428E-07 -2.8910792E-06 -4.6730561E-05 -8.1295885E-04 1.9230811E-09 2.7976000E-08 2.3039314E-04 -4.9881703E-06 -3.7193865E-06 + 1.3651901E-04 7.1445361E-06 9.5298920E-06 1.1635701E-05 -1.1754088E-05 5.4974444E-03 6.2689811E-04 6.4157401E-04 8.9812396E-04 9.1705550E-04 -5.2458512E-06 1.5010257E-05 2.3733085E-05 3.4988840E-05 3.9200100E-06 1.4029277E-05 1.0648634E-04 4.0602931E-05 -6.4162146E-04 9.0792230E-03 -6.1655457E-07 6.1942243E-05 -3.3299003E-03 -2.0881611E-04 -1.2290011E-03 + -6.2783312E-06 6.7786718E-05 3.5658880E-06 2.2016314E-06 3.8531335E-06 6.2689811E-04 3.2029279E-03 8.5119051E-04 1.0197134E-03 1.0371893E-03 -8.3307987E-06 2.9061614E-05 3.8370496E-05 5.1215590E-05 -2.0195552E-06 -2.0787769E-06 8.1834150E-05 6.9999895E-05 -5.5488684E-04 3.8363952E-03 -2.0584309E-07 4.0901286E-05 -4.9893948E-03 -2.3761340E-04 -1.1164743E-03 + 4.5017411E-07 4.2730440E-06 5.4807061E-05 -1.0648166E-06 6.4411464E-06 6.4157401E-04 8.5119051E-04 2.4693413E-03 1.0378286E-03 1.0930460E-03 3.7539203E-06 2.0823960E-05 2.6624222E-05 5.5337908E-05 9.4854730E-06 -2.6028765E-06 8.2185696E-05 5.5580362E-05 -4.3432534E-04 1.5547970E-03 -3.3383686E-07 4.0989752E-05 -4.6999347E-03 -2.0725155E-04 -1.1056379E-03 + 1.0321158E-06 4.6137287E-06 -1.3133782E-06 1.0074452E-04 2.7537299E-06 8.9812396E-04 1.0197134E-03 1.0378286E-03 3.4514430E-03 1.4111046E-03 9.1560151E-06 1.7617721E-05 3.5555505E-05 7.9452979E-05 1.6907734E-07 -1.6514014E-05 6.7349079E-05 5.5905083E-05 -9.5431288E-04 -2.3740460E-03 -4.2003885E-07 5.5278370E-05 -4.7413973E-03 -2.4908717E-04 -1.4056363E-03 + 3.8377489E-06 1.0251473E-06 2.7639878E-06 -2.0888674E-06 1.2301525E-04 9.1705550E-04 1.0371893E-03 1.0930460E-03 1.4111046E-03 6.5340169E-03 9.1142406E-06 1.3149252E-05 1.7851035E-05 3.4114038E-05 2.0372585E-05 -1.8407068E-05 2.4490686E-05 3.7440866E-05 -6.1351496E-04 -3.8149330E-03 -5.3170188E-07 8.8390849E-05 -7.6908050E-04 -2.1844631E-04 -1.7601696E-03 + 2.9336526E-06 1.6676604E-07 -1.0334116E-06 8.1984620E-07 2.2921401E-06 -5.2458512E-06 -8.3307987E-06 3.7539203E-06 9.1560151E-06 9.1142406E-06 1.9050382E-04 1.8026209E-05 3.3262269E-06 -7.7648059E-07 -2.7955509E-05 1.6050964E-05 7.3255368E-06 5.7886532E-06 2.2476321E-04 -1.0143227E-02 -2.4041249E-08 4.4155912E-07 6.3091838E-05 3.2090977E-06 -3.7685762E-06 + -9.1113752E-07 3.2078451E-06 4.9865622E-06 3.8849788E-07 -1.1406582E-06 1.5010257E-05 2.9061614E-05 2.0823960E-05 1.7617721E-05 1.3149252E-05 1.8026209E-05 1.1418133E-04 6.5622630E-06 6.3300114E-06 8.6684756E-06 -3.0887644E-05 1.4649572E-05 9.8005702E-06 2.2711885E-04 -2.1363309E-03 9.1873633E-09 -2.9656894E-06 -2.0614497E-04 -4.7194683E-07 2.1763356E-05 + 2.7421714E-06 8.8628429E-07 4.6179788E-06 6.5448473E-06 -1.7296011E-07 2.3733085E-05 3.8370496E-05 2.6624222E-05 3.5555505E-05 1.7851035E-05 3.3262269E-06 6.5622630E-06 8.8645481E-05 1.7837911E-05 3.3461923E-06 3.1765261E-06 -3.3443792E-05 1.3012717E-05 1.6939949E-04 2.0982955E-03 7.0767715E-08 -5.6262864E-06 -2.9425168E-04 9.4590513E-07 4.2116020E-05 + 7.8186128E-08 -1.0655525E-07 -7.1243588E-07 1.1464621E-05 6.7616886E-06 3.4988840E-05 5.1215590E-05 5.5337908E-05 7.9452979E-05 3.4114038E-05 -7.7648059E-07 6.3300114E-06 1.7837911E-05 3.2439155E-04 -2.2151999E-06 4.6890606E-06 3.1903453E-05 -7.9977473E-05 -1.5490684E-04 1.6239319E-03 2.5919044E-08 -1.3112344E-05 -7.9716898E-04 2.2155588E-06 9.4572818E-05 + 3.2885252E-08 4.3799440E-07 4.1959985E-06 -2.8906039E-06 1.0697258E-06 3.9200100E-06 -2.0195552E-06 9.4854730E-06 1.6907734E-07 2.0372585E-05 -2.7955509E-05 8.6684756E-06 3.3461923E-06 -2.2151999E-06 4.8971844E-04 4.1104295E-06 7.8176436E-06 7.7794225E-06 9.7025161E-05 -3.2354687E-03 -1.6743249E-08 -2.6462879E-07 2.0067438E-04 -5.3705082E-07 1.3409801E-06 + -3.5837461E-07 1.6775446E-06 -2.9928243E-07 -5.0352744E-07 5.1481327E-07 1.4029277E-05 -2.0787769E-06 -2.6028765E-06 -1.6514014E-05 -1.8407068E-05 1.6050964E-05 -3.0887644E-05 3.1765261E-06 4.6890606E-06 4.1104295E-06 4.7559534E-04 1.7216776E-05 1.0268212E-05 2.7124238E-04 -1.6210113E-03 1.8459062E-08 -4.5062196E-06 -2.7233625E-04 1.5279585E-06 4.6543054E-05 + -1.2244996E-06 2.2461057E-06 2.2847038E-06 -2.5576433E-06 6.7262428E-07 1.0648634E-04 8.1834150E-05 8.2185696E-05 6.7349079E-05 2.4490686E-05 7.3255368E-06 1.4649572E-05 -3.3443792E-05 3.1903453E-05 7.8176436E-06 1.7216776E-05 4.0404698E-04 4.4394127E-05 -4.6399682E-05 2.0020023E-03 8.5944926E-08 -2.1813332E-05 -9.8719085E-04 1.3030232E-05 1.6613984E-04 + 2.7190620E-07 -2.1427384E-06 -2.5560790E-07 -2.5994379E-06 -2.8910792E-06 4.0602931E-05 6.9999895E-05 5.5580362E-05 5.5905083E-05 3.7440866E-05 5.7886532E-06 9.8005702E-06 1.3012717E-05 -7.9977473E-05 7.7794225E-06 1.0268212E-05 4.4394127E-05 4.3667905E-04 -3.3634794E-05 1.8583844E-03 3.7922627E-08 -1.4863389E-05 -1.1293974E-03 2.5382163E-06 1.0790702E-04 + -4.1222279E-05 -6.7009742E-05 2.9981325E-05 -1.7286586E-04 -4.6730561E-05 -6.4162146E-04 -5.5488684E-04 -4.3432534E-04 -9.5431288E-04 -6.1351496E-04 2.2476321E-04 2.2711885E-04 1.6939949E-04 -1.5490684E-04 9.7025161E-05 2.7124238E-04 -4.6399682E-05 -3.3634794E-05 3.1639005E-02 1.2964933E-01 8.1821819E-07 2.3102059E-05 2.7555823E-03 5.6786010E-05 6.4858578E-05 + 1.3733625E-03 5.4338927E-04 2.8944497E-04 -8.7530728E-04 -8.1295885E-04 9.0792230E-03 3.8363952E-03 1.5547970E-03 -2.3740460E-03 -3.8149330E-03 -1.0143227E-02 -2.1363309E-03 2.0982955E-03 1.6239319E-03 -3.2354687E-03 -1.6210113E-03 2.0020023E-03 1.8583844E-03 1.2964933E-01 5.3281047E+00 6.8548910E-06 -1.2844009E-03 -3.6940759E-02 6.2786223E-04 1.1716971E-02 + -3.2338288E-08 4.1744997E-09 8.2523673E-09 -1.6242236E-08 1.9230811E-09 -6.1655457E-07 -2.0584309E-07 -3.3383686E-07 -4.2003885E-07 -5.3170188E-07 -2.4041249E-08 9.1873633E-09 7.0767715E-08 2.5919044E-08 -1.6743249E-08 1.8459062E-08 8.5944926E-08 3.7922627E-08 8.1821819E-07 6.8548910E-06 2.7731233E-07 4.5681550E-07 2.0721940E-04 -6.0451442E-08 -1.9657892E-06 + -1.0487950E-06 -1.4129370E-06 -7.7984792E-07 -2.0775506E-06 2.7976000E-08 6.1942243E-05 4.0901286E-05 4.0989752E-05 5.5278370E-05 8.8390849E-05 4.4155912E-07 -2.9656894E-06 -5.6262864E-06 -1.3112344E-05 -2.6462879E-07 -4.5062196E-06 -2.1813332E-05 -1.4863389E-05 2.3102059E-05 -1.2844009E-03 4.5681550E-07 3.0781156E-05 3.7684885E-03 -6.2830842E-05 -3.5461527E-04 + -1.0739427E-05 -1.8022605E-05 -4.1874300E-05 -1.9657560E-05 2.3039314E-04 -3.3299003E-03 -4.9893948E-03 -4.6999347E-03 -4.7413973E-03 -7.6908050E-04 6.3091838E-05 -2.0614497E-04 -2.9425168E-04 -7.9716898E-04 2.0067438E-04 -2.7233625E-04 -9.8719085E-04 -1.1293974E-03 2.7555823E-03 -3.6940759E-02 2.0721940E-04 3.7684885E-03 1.0710198E+00 -5.5332301E-03 -3.4907585E-02 + 1.6864727E-06 2.3384126E-06 1.9437943E-06 2.8363048E-06 -4.9881703E-06 -2.0881611E-04 -2.3761340E-04 -2.0725155E-04 -2.4908717E-04 -2.1844631E-04 3.2090977E-06 -4.7194683E-07 9.4590513E-07 2.2155588E-06 -5.3705082E-07 1.5279585E-06 1.3030232E-05 2.5382163E-06 5.6786010E-05 6.2786223E-04 -6.0451442E-08 -6.2830842E-05 -5.5332301E-03 4.0697784E-04 9.0722629E-04 + 9.0897165E-06 1.1853489E-05 1.0925873E-05 2.3422829E-05 -3.7193865E-06 -1.2290011E-03 -1.1164743E-03 -1.1056379E-03 -1.4056363E-03 -1.7601696E-03 -3.7685762E-06 2.1763356E-05 4.2116020E-05 9.4572818E-05 1.3409801E-06 4.6543054E-05 1.6613984E-04 1.0790702E-04 6.4858578E-05 1.1716971E-02 -1.9657892E-06 -3.5461527E-04 -3.4907585E-02 9.0722629E-04 4.9064797E-03 diff --git a/soliket/cosmopower/input_files/ACTPol_lite_DR4_EDEshoot_taup_hip.yaml b/soliket/cosmopower/input_files/ACTPol_lite_DR4_EDEshoot_taup_hip.yaml new file mode 100644 index 00000000..083fc44c --- /dev/null +++ b/soliket/cosmopower/input_files/ACTPol_lite_DR4_EDEshoot_taup_hip.yaml @@ -0,0 +1,220 @@ +likelihood: + act: + external: import_module('JCH_Cobaya_stable_ACTlike_hip').external_act_like + speed: 5 +modules: /home/chill/cobaya_analyses/modules +params: + fEDE: + prior: + min: 1.e-3 + max: 0.5 + ref: + min: 2.e-3 + max: 0.25 + latex: f_\mathrm{EDE} + proposal: 0.03 + log10z_c: + prior: + min: 3. + max: 4.3 + ref: + min: 3.1 + max: 4.2 + latex: \mathrm{log}_{10}(z_c) + proposal: 0.3 + z_c: + derived: 'lambda log10z_c: np.power(10.,log10z_c)' + latex: z_c + thetai_scf: + prior: + min: 0.1 + max: 3.1 + ref: + min: 0.1 + max: 3.1 + latex: \theta_i + proposal: 0.25 + log10f_scf: + latex: \mathrm{log}_{10}(f/{\mathrm{eV}}) + f_scf: + derived: 'lambda log10f_scf: np.power(10.,log10f_scf)' + latex: f/\mathrm{eV} + log10m_scf: + latex: \mathrm{log}_{10}(m/{\mathrm{eV}}) + m_scf: + derived: 'lambda log10m_scf: np.power(10.,log10m_scf)' + latex: m/\mathrm{eV} + logA: + prior: + min: 1.61 + max: 3.91 + ref: + dist: norm + loc: 3.05 + scale: 0.001 + proposal: 0.001 + latex: \log(10^{10} A_\mathrm{s}) + drop: true + A_s: + value: 'lambda logA: 1e-10*np.exp(logA)' + latex: A_\mathrm{s} + n_s: + prior: + min: 0.8 + max: 1.2 + ref: + dist: norm + loc: 0.965 + scale: 0.004 + proposal: 0.002 + latex: n_\mathrm{s} + theta_s_1e2: + prior: + min: 0.5 + max: 10 + ref: + dist: norm + loc: 1.0416 + scale: 0.0004 + proposal: 0.0002 + latex: 100\theta_\mathrm{s} + drop: true + 100*theta_s: + value: 'lambda theta_s_1e2: theta_s_1e2' + derived: false + H0: + latex: H_0 + omega_b: + prior: + min: 0.005 + max: 0.1 + ref: + dist: norm + loc: 0.0224 + scale: 0.0001 + proposal: 0.0001 + latex: \Omega_\mathrm{b} h^2 + omega_cdm: + prior: + min: 0.001 + max: 0.99 + ref: + dist: norm + loc: 0.12 + scale: 0.001 + proposal: 0.0005 + latex: \Omega_\mathrm{c} h^2 + Omega_m: + latex: \Omega_\mathrm{m} + omegamh2: + derived: 'lambda Omega_m, H0: Omega_m*(H0/100)**2' + latex: \Omega_\mathrm{m} h^2 + m_ncdm: + value: 0.06 + renames: mnu + Omega_Lambda: + latex: \Omega_\Lambda + YHe: + latex: Y_\mathrm{P} + #tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.055 + # scale: 0.006 + # proposal: 0.003 + # latex: \tau_\mathrm{reio} + # USE tau prior matching Erminia's choice + # email from Jo 6-14-20: prior is tau = 0.065 \pm 0.015 + tau_reio: + prior: + dist: norm + loc: 0.065 + scale: 0.015 + ref: + dist: norm + loc: 0.065 + scale: 0.002 + proposal: 0.002 + latex: \tau_\mathrm{reio} + yp2: + prior: + min: 0.9 + max: 1.1 + ref: + dist: norm + loc: 1.01 + scale: 0.005 + z_reio: + latex: z_\mathrm{re} + sigma8: + latex: \sigma_8 + s8h5: + derived: 'lambda sigma8, H0: sigma8*(H0*1e-2)**(-0.5)' + latex: \sigma_8/h^{0.5} + s8omegamp5: + derived: 'lambda sigma8, Omega_m: sigma8*Omega_m**0.5' + latex: \sigma_8 \Omega_\mathrm{m}^{0.5} + s8omegamp25: + derived: 'lambda sigma8, Omega_m: sigma8*Omega_m**0.25' + latex: \sigma_8 \Omega_\mathrm{m}^{0.25} + A: + derived: 'lambda A_s: 1e9*A_s' + latex: 10^9 A_\mathrm{s} + clamp: + derived: 'lambda A_s, tau_reio: 1e9*A_s*np.exp(-2*tau_reio)' + latex: 10^9 A_\mathrm{s} e^{-2\tau} + age: + latex: '{\rm{Age}}/\mathrm{Gyr}' + rs_drag: + latex: r_\mathrm{drag} + #chi2__CMB: + # derived: 'lambda chi2__planck_2018_lowl_TT, chi2__planck_2018_lowl_EE, chi2__planck_2018_highl_plik_TTTEEE: + # sum([chi2__planck_2018_lowl_TT, chi2__planck_2018_lowl_EE, chi2__planck_2018_highl_plik_TTTEEE])' + # latex: \chi^2_\mathrm{CMB} +sampler: + mcmc: + covmat: auto + #covmat: /mnt/sdceph/users/chill/chains/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_EDEshoot_taup.covmat + Rminus1_stop: 0.03 + #drag: true #only possible when doing a multi-likelihood run with different speed for each likelihood + proposal_scale: 1.9 + burn_in: 0 + max_tries: 5000 + check_every: 20 + learn_proposal: true +theory: + classy: + extra_args: + non linear: halofit + N_ncdm: 1 + N_ur: 2.0328 + P_k_max_h/Mpc: 100. + z_pk: 1. + Omega_Lambda: 0.0 + Omega_fld: 0 + Omega_scf: -1 + n_scf: 3 + CC_scf: 1 + scf_parameters: '1, 1, 1, 1, 1, 0.0' + scf_tuning_index: 3 + attractor_ic_scf: 'no' + l_max_scalars: 11000 #specified in the ACT likelihood Cobaya interface itself as well, but repeat here just in case + neglect_CMB_sources_below_visibility: 1.e-30 + transfer_neglect_late_source: 3000. + halofit_k_per_decade: 3000. + l_switch_limber: 40. + accurate_lensing: 1 + num_mu_minus_lmax: 1000. + delta_l_max: 1000. + k_min_tau0: 0.002 + k_max_tau0_over_l_max: 3. + k_step_sub: 0.015 + k_step_super: 0.0001 + k_step_super_reduction: 0.1 + +# update 7-6-20: have to re-run b/c I forgot to sample yp2 +# update 12-27-20: high-precision run to see if our chi^2 was sufficiently accurate +output: /mnt/sdceph/users/chill/chains/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_EDEshoot_taup_hip diff --git a/soliket/cosmopower/input_files/ACTPol_lite_DR4_baseLCDM_taup_hip.yaml b/soliket/cosmopower/input_files/ACTPol_lite_DR4_baseLCDM_taup_hip.yaml new file mode 100644 index 00000000..73b814c5 --- /dev/null +++ b/soliket/cosmopower/input_files/ACTPol_lite_DR4_baseLCDM_taup_hip.yaml @@ -0,0 +1,172 @@ +likelihood: + act: + external: import_module('JCH_Cobaya_stable_ACTlike_hip').external_act_like + speed: 5 +modules: /home/chill/cobaya_analyses/modules +params: + logA: + prior: + min: 1.61 + max: 3.91 + ref: + dist: norm + loc: 3.05 + scale: 0.001 + proposal: 0.001 + latex: \log(10^{10} A_\mathrm{s}) + drop: true + A_s: + value: 'lambda logA: 1e-10*np.exp(logA)' + latex: A_\mathrm{s} + n_s: + prior: + min: 0.8 + max: 1.2 + ref: + dist: norm + loc: 0.965 + scale: 0.004 + proposal: 0.002 + latex: n_\mathrm{s} + theta_s_1e2: + prior: + min: 0.5 + max: 10 + ref: + dist: norm + loc: 1.0416 + scale: 0.0004 + proposal: 0.0002 + latex: 100\theta_\mathrm{s} + drop: true + 100*theta_s: + value: 'lambda theta_s_1e2: theta_s_1e2' + derived: false + H0: + latex: H_0 + omega_b: + prior: + min: 0.005 + max: 0.1 + ref: + dist: norm + loc: 0.0224 + scale: 0.0001 + proposal: 0.0001 + latex: \Omega_\mathrm{b} h^2 + omega_cdm: + prior: + min: 0.001 + max: 0.99 + ref: + dist: norm + loc: 0.12 + scale: 0.001 + proposal: 0.0005 + latex: \Omega_\mathrm{c} h^2 + Omega_m: + latex: \Omega_\mathrm{m} + omegamh2: + derived: 'lambda Omega_m, H0: Omega_m*(H0/100)**2' + latex: \Omega_\mathrm{m} h^2 + m_ncdm: + value: 0.06 + renames: mnu + Omega_Lambda: + latex: \Omega_\Lambda + YHe: + latex: Y_\mathrm{P} + #tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.055 + # scale: 0.006 + # proposal: 0.003 + # latex: \tau_\mathrm{reio} + # USE tau prior matching Erminia's choice + # email from Jo 6-14-20: prior is tau = 0.065 \pm 0.015 + tau_reio: + prior: + dist: norm + loc: 0.065 + scale: 0.015 + ref: + dist: norm + loc: 0.065 + scale: 0.002 + proposal: 0.002 + latex: \tau_\mathrm{reio} + yp2: + prior: + min: 0.9 + max: 1.1 + ref: + dist: norm + loc: 1.01 + scale: 0.005 + z_reio: + latex: z_\mathrm{re} + sigma8: + latex: \sigma_8 + s8h5: + derived: 'lambda sigma8, H0: sigma8*(H0*1e-2)**(-0.5)' + latex: \sigma_8/h^{0.5} + s8omegamp5: + derived: 'lambda sigma8, Omega_m: sigma8*Omega_m**0.5' + latex: \sigma_8 \Omega_\mathrm{m}^{0.5} + s8omegamp25: + derived: 'lambda sigma8, Omega_m: sigma8*Omega_m**0.25' + latex: \sigma_8 \Omega_\mathrm{m}^{0.25} + A: + derived: 'lambda A_s: 1e9*A_s' + latex: 10^9 A_\mathrm{s} + clamp: + derived: 'lambda A_s, tau_reio: 1e9*A_s*np.exp(-2*tau_reio)' + latex: 10^9 A_\mathrm{s} e^{-2\tau} + age: + latex: '{\rm{Age}}/\mathrm{Gyr}' + rs_drag: + latex: r_\mathrm{drag} + #chi2__CMB: + # derived: 'lambda chi2__planck_2018_lowl_TT, chi2__planck_2018_lowl_EE, chi2__planck_2018_highl_plik_TTTEEE: + # sum([chi2__planck_2018_lowl_TT, chi2__planck_2018_lowl_EE, chi2__planck_2018_highl_plik_TTTEEE])' + # latex: \chi^2_\mathrm{CMB} +sampler: + mcmc: + covmat: /mnt/sdceph/users/chill/chains/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip.covmat + #covmat: auto + Rminus1_stop: 0.01 + #drag: true #only possible when doing a multi-likelihood run with different speed for each likelihood + proposal_scale: 1.9 + burn_in: 0 + max_tries: 5000 + learn_proposal: true + check_every: 30 #120 +theory: + classy: + extra_args: + non linear: halofit + N_ncdm: 1 + N_ur: 2.0328 + P_k_max_h/Mpc: 100. + z_pk: 1. + l_max_scalars: 11000 #specified in the ACT likelihood Cobaya interface itself as well, but repeat here just in case + neglect_CMB_sources_below_visibility: 1.e-30 + transfer_neglect_late_source: 3000. + halofit_k_per_decade: 3000. + l_switch_limber: 40. + accurate_lensing: 1 + num_mu_minus_lmax: 1000. + delta_l_max: 1000. + k_min_tau0: 0.002 + k_max_tau0_over_l_max: 3. + k_step_sub: 0.015 + k_step_super: 0.0001 + k_step_super_reduction: 0.1 + +# update 7-6-20: have to re-run b/c I forgot to sample yp2 +# update 12-27-20: high-precision run to see if our chi^2 was sufficiently accurate +output: /mnt/sdceph/users/chill/chains/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip_R0p01 diff --git a/soliket/cosmopower/input_files/cosmopower_evaluate.yaml b/soliket/cosmopower/input_files/cosmopower_evaluate.yaml new file mode 100644 index 00000000..0e841a5d --- /dev/null +++ b/soliket/cosmopower/input_files/cosmopower_evaluate.yaml @@ -0,0 +1,111 @@ +# cobaya-run /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/cosmopower/input_files/cosmopower_evaluate.yaml -f + +output: /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/cosmopower/chains/ + +likelihood: + pyactlike.ACTPol_lite_DR4: + + + +theory: + soliket.cosmopower.cosmopower: + +params: + omega_b: + prior: + min: 0.02 + max: 0.03 + ref: + dist: norm + loc: 0.022 + scale: 0.005 + proposal: 0.005 + latex: omega_b + omega_cdm: + prior: + min: 0.10 + max: 0.14 + ref: + dist: norm + loc: 0.11 + scale: 0.01 + proposal: 0.01 + latex: omega_cdm + h: + prior: + min: 0.55 + max: 0.90 + ref: + dist: norm + loc: 0.6727 + scale: 0.006 + proposal: 0.006 + latex: h + tau_reio: + prior: + min: 0.05 + max: 0.09 + ref: + dist: norm + loc: 0.06 + scale: 0.01 + proposal: 0.01 + latex: tau_reio + n_s: + prior: + min: 0.93 + max: 0.99 + ref: + dist: norm + loc: 0.96 + scale: 0.01 + proposal: 0.01 + latex: n_s + logA: + prior: + min: 2.5 + max: 3.5 + ref: + dist: norm + loc: 3.05 + scale: 0.01 + proposal: 0.01 + latex: ln10^{10}A_s + + + # pyactlike param + yp2: + prior: + min: 0.9 + max: 1.1 + ref: + dist: norm + loc: 1.01 + scale: 0.005 + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + # mcmc: + # covmat: #auto + # Rminus1_stop: 0.01 + # drag: true + # proposal_scale: 2.4 + # learn_proposal: True + # learn_proposal_Rminus1_max: 2. + + evaluate: + override: + omega_b: 0.0223 + omega_cdm: 0.115 + h: 0.7 + tau_reio: 0.06 + n_s: 0.96 + logA: 3.07 + + yp2 : 1.02 + + + + +debug : True diff --git a/soliket/cosmopower/input_files/cosmopower_run.yaml b/soliket/cosmopower/input_files/cosmopower_run.yaml new file mode 100644 index 00000000..afb9b605 --- /dev/null +++ b/soliket/cosmopower/input_files/cosmopower_run.yaml @@ -0,0 +1,132 @@ +# cobaya-run /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/cosmopower/input_files/cosmopower_evaluate.yaml -f + +output: /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/cosmopower/chains/new_mac + +likelihood: + pyactlike.ACTPol_lite_DR4: + stop_at_error: True + + + +theory: + soliket.cosmopower.cosmopower: + path_to_trained_models: /Users/boris/Work/CLASS-SZ/SO-SZ/trained_emulators/cp_oct22_A/ + TT_emulator_name: TT_cp_NN_example + TE_emulator_name: TE_cp_PCAplusNN_example + EE_emulator_name: EE_cp_NN_example +params: + omega_b: + prior: + min: 0.02 + max: 0.03 + ref: + dist: norm + loc: 0.022 + scale: 0.001 + proposal: 0.005 + latex: omega_b + omega_cdm: + prior: + min: 0.10 + max: 0.14 + ref: + dist: norm + loc: 0.11 + scale: 0.01 + proposal: 0.01 + latex: omega_cdm + # h: + # prior: + # min: 0.55 + # max: 0.90 + # ref: + # dist: norm + # loc: 0.6727 + # scale: 0.006 + # proposal: 0.006 + # latex: h + theta_s_1e2: + prior: + min: 0.5 + max: 10 + ref: + dist: norm + loc: 1.0416 + scale: 0.0004 + proposal: 0.0002 + latex: 100\theta_\mathrm{s} + drop: true + 100*theta_s: + value: 'lambda theta_s_1e2: theta_s_1e2' + derived: false + tau_reio: + prior: + dist: norm + loc: 0.065 + scale: 0.015 + ref: + dist: norm + loc: 0.065 + scale: 0.002 + proposal: 0.002 + latex: \tau_\mathrm{reio} + n_s: + prior: + min: 0.8 + max: 1.2 + ref: + dist: norm + loc: 0.96 + scale: 0.01 + proposal: 0.01 + latex: n_s + logA: + prior: + min: 2.5 + max: 3.5 + ref: + dist: norm + loc: 3.05 + scale: 0.01 + proposal: 0.01 + latex: ln10^{10}A_s + + + # pyactlike param + yp2: + prior: + min: 0.9 + max: 1.1 + ref: + dist: norm + loc: 1.01 + scale: 0.005 + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/cosmopower/covmats/CLASS2p8_ACTPol_lite_DR4_leakfix_yp2_baseLCDM_taup_hip_R0p01.covmat + #covmat: auto + Rminus1_stop: 0.01 + #drag: true #only possible when doing a multi-likelihood run with different speed for each likelihood + proposal_scale: 1.9 + burn_in: 0 + max_tries: 5000 + learn_proposal: true + # check_every: 30 #120 + # evaluate: + # override: + # omega_b: 0.0223 + # omega_cdm: 0.115 + # h: 0.7 + # tau_reio: 0.06 + # n_s: 0.96 + # logA: 3.07 + # + # yp2 : 1.02 + + + + +# debug : True diff --git a/soliket/gaussian.py b/soliket/gaussian.py index 7f9de5ef..af679c1f 100644 --- a/soliket/gaussian.py +++ b/soliket/gaussian.py @@ -4,7 +4,8 @@ from cobaya.likelihood import Likelihood from cobaya.input import merge_info from cobaya.tools import recursive_update -from cobaya.conventions import empty_dict +# from cobaya.conventions import empty_dict +empty_dict = 'empty_dict' from .gaussian_data import GaussianData, MultiGaussianData from .utils import get_likelihood diff --git a/soliket/lensing.py b/soliket/lensing.py new file mode 100644 index 00000000..687f35bd --- /dev/null +++ b/soliket/lensing.py @@ -0,0 +1,183 @@ +import os +from pkg_resources import resource_filename + +import numpy as np + +from cobaya.likelihoods._base_classes import _InstallableLikelihood +from cobaya.conventions import _packages_path +from cobaya.model import get_model +from cobaya.log import LoggedError +# from cobaya.install import NotInstalledError + +from .ps import BinnedPSLikelihood + + +class LensingLikelihood(BinnedPSLikelihood, _InstallableLikelihood): + _url = "https://portal.nersc.gov/project/act/jia_qu/likelihood-data/likelihood.tar.gz" + install_options = {"download_url": _url} + data_folder = "LensingLikelihood" + data_filename = "binnedauto.txt" + cov_filename = "binnedcov.txt" + + kind = "pp" + lmax = 3000 + theory_lmax = 10000 + + fiducial_params = { + "ombh2": 0.02219218, + "omch2": 0.1203058, + "H0": 67.02393, + "tau": 0.6574325e-01, + "nnu": 3.046, + "num_massive_neutrinos": 1, + "As": 2.15086031154146e-9, + "ns": 0.9625356e00, + } + + def initialize(self): + self.log.info("Initialising.") + # Set path to data + if (not getattr(self, "path", None)) and (not getattr(self, _packages_path, None)): + raise LoggedError( + self.log, + "No path given to LensingLikelihood data. " + "Set the likelihood property " + "'path' or the common property '%s'.", + _packages_path, + ) + + # If no path specified, use the modules path + data_file_path = os.path.normpath( + getattr(self, "path", None) or os.path.join(self.packages_path, "data") + ) + + self.data_folder = os.path.join(data_file_path, self.data_folder) + if not os.path.exists(self.data_folder): + if not getattr(self, "path", None): + self.install(path=self.packages_path) + else: + raise LoggedError( + self.log, + "The 'data_folder' directory does not exist. " "Check the given path [%s].", + self.data_folder, + ) + + # Set files where data/covariance are loaded from + self.datapath = os.path.join(self.data_folder, self.data_filename) + self.covpath = os.path.join(self.data_folder, self.cov_filename) + + # Initialize fiducial PS + Cls = self._get_fiducial_Cls() + + # same bin edges to the one used for auto bandpowers + # TODO: make this information part of the data product! + self.bin_edges = np.linspace(20, 3000, 10) + + # Set the fiducial spectra + self.ls = np.arange(0, self.lmax) + self.fcltt = Cls["tt"][0 : self.lmax] + self.fclpp = Cls["pp"][0 : self.lmax] + self.fclee = Cls["ee"][0 : self.lmax] + self.fclte = Cls["te"][0 : self.lmax] + self.fclbb = Cls["bb"][0 : self.lmax] + self.thetaclkk = self.fclpp * (self.ls * (self.ls + 1)) ** 2 * 0.25 + + # load the correction terms generate from the script n1so.py + + self.N0cltt = np.loadtxt(os.path.join(self.data_folder, "n0mvdcltt1.txt")).transpose() + self.N0clte = np.loadtxt(os.path.join(self.data_folder, "n0mvdclte1.txt")).transpose() + self.N0clee = np.loadtxt(os.path.join(self.data_folder, "n0mvdclee1.txt")).transpose() + self.N0clbb = np.loadtxt(os.path.join(self.data_folder, "n0mvdclbb1.txt")).transpose() + self.N1clpp = np.loadtxt(os.path.join(self.data_folder, "n1mvdclkk1.txt")).transpose() + self.N1cltt = np.loadtxt(os.path.join(self.data_folder, "n1mvdcltte1.txt")).transpose() + self.N1clte = np.loadtxt(os.path.join(self.data_folder, "n1mvdcltee1.txt")).transpose() + self.N1clee = np.loadtxt(os.path.join(self.data_folder, "n1mvdcleee1.txt")).transpose() + self.N1clbb = np.loadtxt(os.path.join(self.data_folder, "n1mvdclbbe1.txt")).transpose() + self.n0 = np.loadtxt(os.path.join(self.data_folder, "n0mv.txt")) + + super().initialize() + + def _get_fiducial_Cls(self): + + info_fiducial = { + "params": self.fiducial_params, + "likelihood": {"soliket.utils.OneWithCls": {"lmax": self.theory_lmax}}, + "theory": {"camb": {"extra_args": {"kmax": 0.9}}}, + # "modules": modules_path, + } + + model_fiducial = get_model(info_fiducial) + model_fiducial.logposterior({}) + + Cls = model_fiducial.provider.get_Cl(ell_factor=False) + return Cls + + def get_requirements(self): + return { + "Cl": { + "pp": self.theory_lmax, + "tt": self.theory_lmax, + "te": self.theory_lmax, + "ee": self.theory_lmax, + "bb": self.theory_lmax, + } + } + + def _get_data(self): + bandpowers = np.loadtxt(self.datapath) + bin_centers = (self.bin_edges[:-1] + self.bin_edges[1:]) / 2 + + return bin_centers, bandpowers + + def _get_theory(self, **params_values): + cl = self.provider.get_Cl(ell_factor=False) + + Cl_theo = cl["pp"][0 : self.lmax] + Cl_tt = cl["tt"][0 : self.lmax] + Cl_ee = cl["ee"][0 : self.lmax] + Cl_te = cl["te"][0 : self.lmax] + Cl_bb = cl["bb"][0 : self.lmax] + + ls = self.ls + Clkk_theo = (ls * (ls + 1)) ** 2 * Cl_theo * 0.25 + + _, Clkk_binned = self.binner(ls, Clkk_theo, self.bin_edges) + _, Cltt_binned = self.binner(ls, Cl_tt, self.bin_edges) + + correction = ( + 2 + * (self.thetaclkk / self.n0) + * ( + np.dot(self.N0cltt, Cl_tt - self.fcltt) + + np.dot(self.N0clee, Cl_ee - self.fclee) + + np.dot(self.N0clbb, Cl_bb - self.fclbb) + + np.dot(self.N0clte, Cl_te - self.fclte) + ) + + np.dot(self.N1clpp, Clkk_theo - self.thetaclkk) + + np.dot(self.N1cltt, Cl_tt - self.fcltt) + + np.dot(self.N1clee, Cl_ee - self.fclee) + + np.dot(self.N1clbb, Cl_bb - self.fclbb) + + np.dot(self.N1clte, Cl_te - self.fclte) + ) + + # put the correction term into bandpowers + _, correction = self.binner(ls, correction, self.bin_edges) + + return Clkk_binned + correction + + +class LensingLiteLikelihood(BinnedPSLikelihood): + kind = "pp" + dataroot = resource_filename( + "soliket", "data/simulated_clkk_SO_Apr17_mv_nlkk_deproj0_SENS1_fsky_16000_iterOn_20191109" + ) + cl_file = ( + "simulated_clkk_SO_Apr17_mv_nlkk_deproj0_SENS1_fsky_16000_iterOn_20191109_sim_{:02d}_bandpowers.txt" + ) + cov_file = "simulated_clkk_SO_Apr17_mv_nlkk_deproj0_SENS1_fsky_16000_iterOn_20191109_binned_covmat.txt" + sim_number = 0 + + def initialize(self): + self.datapath = os.path.join(self.dataroot, self.cl_file.format(self.sim_number)) + self.covpath = os.path.join(self.dataroot, self.cov_file) + super().initialize() diff --git a/soliket/lensing/lensing.py b/soliket/lensing/lensing.py index 6712d593..1b486f3f 100644 --- a/soliket/lensing/lensing.py +++ b/soliket/lensing/lensing.py @@ -3,8 +3,9 @@ import numpy as np -from cobaya.likelihoods._base_classes import _InstallableLikelihood -from cobaya.conventions import _packages_path +from cobaya.likelihoods.base_classes import InstallableLikelihood +# from cobaya.conventions import _packages_path +_packages_path = 'packages_path' from cobaya.model import get_model from cobaya.log import LoggedError # from cobaya.install import NotInstalledError @@ -12,7 +13,7 @@ from ..ps import BinnedPSLikelihood -class LensingLikelihood(BinnedPSLikelihood, _InstallableLikelihood): +class LensingLikelihood(BinnedPSLikelihood, InstallableLikelihood): _url = "https://portal.nersc.gov/project/act/jia_qu/lensing_like/likelihood.tar.gz" install_options = {"download_url": _url} data_folder = "LensingLikelihood" @@ -171,4 +172,3 @@ class LensingLiteLikelihood(BinnedPSLikelihood): datapath: str = resource_filename("soliket", "lensing/data/binnedauto.txt") covpath: str = resource_filename("soliket", "lensing/data/binnedcov.txt") binning_matrix_path: str = resource_filename("soliket", "lensing/data/binningmatrix.txt") - diff --git a/soliket/param_to_yaml.py b/soliket/param_to_yaml.py new file mode 100644 index 00000000..9f5e6eb5 --- /dev/null +++ b/soliket/param_to_yaml.py @@ -0,0 +1 @@ +from myfuncs import util as yutil \ No newline at end of file diff --git a/soliket/sz_binned_cluster_counts/binned_cc.py b/soliket/sz_binned_cluster_counts/binned_cc.py new file mode 100644 index 00000000..9c9ecdfb --- /dev/null +++ b/soliket/sz_binned_cluster_counts/binned_cc.py @@ -0,0 +1,404 @@ +""" +.. module:: sz cluster counts (in progress) + +""" + + +from cobaya.theory import Theory +# from cobaya.conventions import _packages_path +_packages_path = 'packages_path' +from cobaya.likelihood import Likelihood +# from cobaya.likelihoods._base_classes import _InstallableLikelihood +import numpy as np +import os +from scipy.ndimage.interpolation import shift +from typing import Optional, Sequence +from pkg_resources import resource_filename +from astropy.io import fits + +# path_to_catalogue = '/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz_external_data_and_scripts/MFMF_SOSim_3freq_tiles/' +# +# #"fits_image_filename = fits.util.get_testdata_filepath(path_to_catalogue+'MFMF_SOSim_3freq_tiles_M500.fits') +# tcat = path_to_catalogue+'MFMF_SOSim_3freq_tiles_M500.fits' +# list = fits.open(tcat) +# data = list[1].data +# z = data.field("redshift") +# snr = data.field("SNR") + + + +class binned_cc_likelihood(Likelihood): + data_directory: Optional[str] = resource_filename( + "soliket", "sz_binned_cluster_counts/data/" + ) + # ylims_file: Optional[str] = 'so_3freqs_020621_ylims.txt' + # skyfracs_file: Optional[str] = 'so_3freqs_020621_skyfracs.txt' + # thetas_file: Optional[str] = 'so_3freqs_020621_thetas.txt' + tcat_file: Optional[str] = 'MFMF_SOSim_3freq_tiles_M500.fits' + snrcut: Optional[str] = 5. + experiment: Optional[str] = 'Planck' + debug: Optional[str] = True + + + bin_z_min_cluster_counts: Optional[str] = 0. + bin_z_max_cluster_counts: Optional[str] = 0. + bin_dz_cluster_counts: Optional[str] = 0. + bin_dlog10_snr: Optional[str] = 0. + + + + def initialize(self): + if self.experiment == 'SO': + tcat = os.path.join(self.data_directory, self.tcat_file) + list = fits.open(tcat) + data = list[1].data + z = data.field("redshift") + snr = data.field("SNR") + self.z = z[snr > self.snrcut] + self.snr = snr[snr > self.snrcut] + elif self.experiment == 'Planck': + SZ_catalog = np.loadtxt(os.path.join(self.data_directory, self.tcat_file)) + if self.debug: + print("starting setting up catalogue data") + # print(self.theory.extra_args['M_min']) + print(self.bin_z_min_cluster_counts) + + # exit(0) + + z_0 = self.bin_z_min_cluster_counts; + z_max = self.bin_z_max_cluster_counts; + dz = self.bin_dz_cluster_counts; + Nbins_z = int((z_max - z_0)/dz) + z_center = np.zeros(Nbins_z) + + + # class_alloc(pcsz->z_center,pcsz->Nbins_z*sizeof(double),pcsz->error_message); + # int index_z; + for index_z in range(Nbins_z): + z_center[index_z] = z_0 + 0.5*dz + index_z*dz; + if self.debug: + print("z_center:",z_center[index_z]) + # print("index_z=%d, z_center=%e\n"%(index_z,z_center[index_z])) + + logy_min = 0.7 # set for planck + logy_max = 1.5 # set for planck + dlogy = self.bin_dlog10_snr + # + Nbins_y = int((logy_max - logy_min)/dlogy)+1 + if self.debug: + print('Nbins_y:',Nbins_y,self.bin_dlog10_snr) + logy = np.zeros(Nbins_y) + y_i = logy_min + dlogy/2. + for index_y in range(Nbins_y): + logy[index_y] = y_i + y_i += dlogy + if self.debug: + print("y_center:",index_y,Nbins_y,10**logy[index_y]) + + self.dNdzdy_catalog = np.zeros([Nbins_z,Nbins_y]) + + nrows = len(SZ_catalog[:,0]) + if self.debug: + print('number of rows in catalogue:',nrows) + + + zmin = z_0 + zmax = zmin +dz + # Count the number of clusters in each (z,y) bin + for i in range (Nbins_z): + for j in range (Nbins_y): + y_min = logy[j]-dlogy/2. + y_max = logy[j]+dlogy/2. + y_min = 10**y_min + y_max = 10**y_max + # if j == Nbins_y: + # y_max = 1e100 + + for ii in range(0,nrows): + if (SZ_catalog[ii][0]>=zmin) and (SZ_catalog[ii][0]=y_min): + self.dNdzdy_catalog[i][j] += 1. + # Count the number of clusters in the last y bin for each z bin + # j = Nbins_y + # y_min =y_max + # for ii in range(0,nrows): + # if (SZ_catalog[ii][0]>=zmin) and (SZ_catalog[ii][0]=y_min): + # self.dNdzdy_catalog[i][j] += 1. + # Change edges of the redshift bin + zmin += dz + zmax += dz + + # Count the number of clusters in each y bin with missing redshifts and apply normalization + for j in range(0,Nbins_y): + y_min = logy[j]-dlogy/2. + y_max = logy[j]+dlogy/2. + y_min = 10**y_min + y_max = 10**y_max + for ii in range(0,nrows): + if (SZ_catalog[ii][0]==-1) \ + and (SZ_catalog[ii][2]=y_min): + norm = 0 + for jj in range(0,Nbins_z): + norm += self.dNdzdy_catalog[jj][j] + self.dNdzdy_catalog[:,j] *= (1.+norm)/norm + + # # Count the number of clusters in the last y bin with missing redshifts and apply normalization + # j = Nbins_y + # y_min =y_max + # for ii in range(0,nrows): + # if (SZ_catalog[ii][0]==-1) and (SZ_catalog[ii][2]>=y_min): + # norm = 0. + # for jj in range(0,Nbins_z): + # norm += self.dNdzdy_catalog[jj][j] + # self.dNdzdy_catalog[:,j] *= (1.+norm)/norm + if self.debug: + print("Ntot cat:",np.sum(self.dNdzdy_catalog[:,:])) + # exit(0) + + + super().initialize() + + + def get_requirements(self): + return {"sz_binned_cluster_counts": {}} + + def _get_data(self): + snr = self.snr + z = self.z + return snr, z + + + + def _get_theory(self, **params_values): + theory = self.theory.get_sz_binned_cluster_counts() + # print(theory) + dNdzdy_theoretical = theory['dndzdy'] + # z_center = M.dndzdy_theoretical()['z_center'] + z_edges = theory['z_edges'] + # log10y_center = M.dndzdy_theoretical()['log10y_center'] + log10y_edges = theory['log10y_edges'] + return dNdzdy_theoretical,z_edges,log10y_edges + + def logp(self, **params_values): + theory = self._get_theory(**params_values) + dNdzdy_theoretical,z_edges,log10y_edges = theory + if self.experiment == 'SO': + dNdzdy_catalog, zedges, yedges = np.histogram2d(self.z,np.log10(self.snr), bins=[z_edges,log10y_edges]) + elif self.experiment == 'Planck': + dNdzdy_catalog = self.dNdzdy_catalog + + SZCC_Cash = 0. + N_z,N_y = np.shape(dNdzdy_theoretical) + if self.debug == True: + print('N_z,N_y',N_z,N_y) + for index_z in range(N_z): + for index_y in range(N_y): + if not dNdzdy_theoretical[index_z][index_y] == 0.: + ln_factorial = 0. + if not dNdzdy_catalog[index_z,index_y] == 0.: + if dNdzdy_catalog[index_z,index_y] > 10.: + # Stirling approximation only for more than 10 elements + ln_factorial = 0.918939 + (dNdzdy_catalog[index_z,index_y] + 0.5) * np.log(dNdzdy_catalog[index_z,index_y]) - dNdzdy_catalog[index_z,index_y] + else: + # Direct computation of factorial + ln_factorial = np.log(np.math.factorial(int(dNdzdy_catalog[index_z,index_y]))) + SZCC_Cash += (dNdzdy_catalog[index_z,index_y] * np.log(dNdzdy_theoretical[index_z][index_y]) - dNdzdy_theoretical[index_z][index_y] - ln_factorial) + if self.debug == True: + print("theory: %.5e, catalogue: %.5e"%(dNdzdy_theoretical[index_z][index_y],dNdzdy_catalog[index_z,index_y])) + if self.debug == True: + print("Ntot cat:",np.sum(dNdzdy_catalog[:,:])) + print("Ntot theory:",np.sum(dNdzdy_theoretical[:][:])) + # return ln(L) + loglkl = SZCC_Cash + return loglkl + + + + +class unbinned_cc_likelihood(Likelihood): + data_directory: Optional[str] = resource_filename( + "soliket", "sz_binned_cluster_counts/data/" + ) + # ylims_file: Optional[str] = 'so_3freqs_020621_ylims.txt' + # skyfracs_file: Optional[str] = 'so_3freqs_020621_skyfracs.txt' + # thetas_file: Optional[str] = 'so_3freqs_020621_thetas.txt' + tcat_file: Optional[str] = 'MFMF_SOSim_3freq_tiles_M500.fits' + snrcut: Optional[str] = 5. + experiment: Optional[str] = 'Planck' + debug: Optional[str] = True + + + bin_z_min_cluster_counts: Optional[str] = 0. + bin_z_max_cluster_counts: Optional[str] = 0. + bin_dz_cluster_counts: Optional[str] = 0. + bin_dlog10_snr: Optional[str] = 0. + + + + def initialize(self): + if self.experiment == 'SO': + tcat = os.path.join(self.data_directory, self.tcat_file) + list = fits.open(tcat) + data = list[1].data + z = data.field("redshift") + snr = data.field("SNR") + self.z = z[snr > self.snrcut] + self.snr = snr[snr > self.snrcut] + elif self.experiment == 'Planck': + SZ_catalog = np.loadtxt(os.path.join(self.data_directory, self.tcat_file)) + if self.debug: + print("starting setting up catalogue data") + # print(self.theory.extra_args['M_min']) + print(self.bin_z_min_cluster_counts) + + # exit(0) + + z_0 = self.bin_z_min_cluster_counts; + z_max = self.bin_z_max_cluster_counts; + dz = self.bin_dz_cluster_counts; + Nbins_z = int((z_max - z_0)/dz) + z_center = np.zeros(Nbins_z) + + + # class_alloc(pcsz->z_center,pcsz->Nbins_z*sizeof(double),pcsz->error_message); + # int index_z; + for index_z in range(Nbins_z): + z_center[index_z] = z_0 + 0.5*dz + index_z*dz; + if self.debug: + print("z_center:",z_center[index_z]) + # print("index_z=%d, z_center=%e\n"%(index_z,z_center[index_z])) + + logy_min = 0.7 # set for planck + logy_max = 1.5 # set for planck + dlogy = self.bin_dlog10_snr + # + Nbins_y = int((logy_max - logy_min)/dlogy)+1 + if self.debug: + print('Nbins_y:',Nbins_y,self.bin_dlog10_snr) + logy = np.zeros(Nbins_y) + y_i = logy_min + dlogy/2. + for index_y in range(Nbins_y): + logy[index_y] = y_i + y_i += dlogy + if self.debug: + print("y_center:",index_y,Nbins_y,10**logy[index_y]) + + self.dNdzdy_catalog = np.zeros([Nbins_z,Nbins_y]) + + nrows = len(SZ_catalog[:,0]) + if self.debug: + print('number of rows in catalogue:',nrows) + + + zmin = z_0 + zmax = zmin +dz + # Count the number of clusters in each (z,y) bin + for i in range (Nbins_z): + for j in range (Nbins_y): + y_min = logy[j]-dlogy/2. + y_max = logy[j]+dlogy/2. + y_min = 10**y_min + y_max = 10**y_max + # if j == Nbins_y: + # y_max = 1e100 + + for ii in range(0,nrows): + if (SZ_catalog[ii][0]>=zmin) and (SZ_catalog[ii][0]=y_min): + self.dNdzdy_catalog[i][j] += 1. + # Count the number of clusters in the last y bin for each z bin + # j = Nbins_y + # y_min =y_max + # for ii in range(0,nrows): + # if (SZ_catalog[ii][0]>=zmin) and (SZ_catalog[ii][0]=y_min): + # self.dNdzdy_catalog[i][j] += 1. + # Change edges of the redshift bin + zmin += dz + zmax += dz + + # Count the number of clusters in each y bin with missing redshifts and apply normalization + for j in range(0,Nbins_y): + y_min = logy[j]-dlogy/2. + y_max = logy[j]+dlogy/2. + y_min = 10**y_min + y_max = 10**y_max + for ii in range(0,nrows): + if (SZ_catalog[ii][0]==-1) \ + and (SZ_catalog[ii][2]=y_min): + norm = 0 + for jj in range(0,Nbins_z): + norm += self.dNdzdy_catalog[jj][j] + self.dNdzdy_catalog[:,j] *= (1.+norm)/norm + + # # Count the number of clusters in the last y bin with missing redshifts and apply normalization + # j = Nbins_y + # y_min =y_max + # for ii in range(0,nrows): + # if (SZ_catalog[ii][0]==-1) and (SZ_catalog[ii][2]>=y_min): + # norm = 0. + # for jj in range(0,Nbins_z): + # norm += self.dNdzdy_catalog[jj][j] + # self.dNdzdy_catalog[:,j] *= (1.+norm)/norm + if self.debug: + print("Ntot cat:",np.sum(self.dNdzdy_catalog[:,:])) + # exit(0) + + + super().initialize() + + + def get_requirements(self): + return {"sz_unbinned_cluster_counts": {}} + + def _get_data(self): + snr = self.snr + z = self.z + return snr, z + + + + def _get_theory(self, **params_values): + theory = self.theory.get_sz_unbinned_cluster_counts() + # print(theory) + # dNdzdy_theoretical = theory['dndzdy'] + # # z_center = M.dndzdy_theoretical()['z_center'] + # z_edges = theory['z_edges'] + # # log10y_center = M.dndzdy_theoretical()['log10y_center'] + # log10y_edges = theory['log10y_edges'] + # print(theory) + return theory + + def logp(self, **params_values): + theory = self._get_theory(**params_values) + # dNdzdy_theoretical,z_edges,log10y_edges = theory + # if self.experiment == 'SO': + # dNdzdy_catalog, zedges, yedges = np.histogram2d(self.z,np.log10(self.snr), bins=[z_edges,log10y_edges]) + # elif self.experiment == 'Planck': + # dNdzdy_catalog = self.dNdzdy_catalog + # + # SZCC_Cash = 0. + # N_z,N_y = np.shape(dNdzdy_theoretical) + # if self.debug == True: + # print('N_z,N_y',N_z,N_y) + # for index_z in range(N_z): + # for index_y in range(N_y): + # if not dNdzdy_theoretical[index_z][index_y] == 0.: + # ln_factorial = 0. + # if not dNdzdy_catalog[index_z,index_y] == 0.: + # if dNdzdy_catalog[index_z,index_y] > 10.: + # # Stirling approximation only for more than 10 elements + # ln_factorial = 0.918939 + (dNdzdy_catalog[index_z,index_y] + 0.5) * np.log(dNdzdy_catalog[index_z,index_y]) - dNdzdy_catalog[index_z,index_y] + # else: + # # Direct computation of factorial + # ln_factorial = np.log(np.math.factorial(int(dNdzdy_catalog[index_z,index_y]))) + # SZCC_Cash += (dNdzdy_catalog[index_z,index_y] * np.log(dNdzdy_theoretical[index_z][index_y]) - dNdzdy_theoretical[index_z][index_y] - ln_factorial) + # if self.debug == True: + # print("theory: %.5e, catalogue: %.5e"%(dNdzdy_theoretical[index_z][index_y],dNdzdy_catalog[index_z,index_y])) + # if self.debug == True: + # print("Ntot cat:",np.sum(dNdzdy_catalog[:,:])) + # print("Ntot theory:",np.sum(dNdzdy_theoretical[:][:])) + # return ln(L) + loglkl = theory + return loglkl diff --git a/soliket/sz_binned_cluster_counts/data/SZ_cat.txt b/soliket/sz_binned_cluster_counts/data/SZ_cat.txt new file mode 100644 index 00000000..f7afcb48 --- /dev/null +++ b/soliket/sz_binned_cluster_counts/data/SZ_cat.txt @@ -0,0 +1,438 @@ + 0.171000 0.00000 9.25669 + 0.165100 0.00000 8.57995 + 0.341600 0.00000 6.58179 + 0.141100 0.00000 9.19606 + 0.152100 0.00000 8.91013 + 0.151000 0.00000 16.1120 + 0.380000 0.00000 6.75999 + 0.540000 0.00000 8.16570 + 0.0766000 0.00000 23.1709 + 0.0894000 0.00000 11.8515 + 0.312000 0.00000 10.9195 + 0.148600 0.00000 10.0536 + 0.0936000 0.00000 6.28531 + 0.306600 0.00000 14.0864 + 0.154400 0.00000 7.29635 + -1.00000 -0.00000 6.10572 + 0.352000 0.00000 6.09351 + 0.0355000 0.00000 6.63073 + 0.251500 0.00000 6.35725 + 0.280000 0.00000 7.52636 + 0.0620000 0.00000 8.03174 + 0.151400 0.00000 16.3186 + 0.0300000 0.00000 7.67286 + 0.202000 0.00000 8.05722 + 0.0916000 0.00000 6.53194 + 0.147500 0.00000 8.73780 + 0.153000 0.00000 7.36470 + 0.0353000 0.00000 13.9095 + 0.0724000 0.00000 7.46826 + 0.0943000 0.00000 10.3530 + 0.0622000 0.00000 18.3200 + 0.226400 0.00000 12.2667 + 0.0411000 0.00000 6.87962 + 0.480965 0.00000 7.40165 + 0.176000 0.00000 10.2150 + 0.0612000 0.00000 7.05563 + 0.0748000 0.00000 6.61125 + 0.178000 0.00000 9.26549 + 0.0723000 0.00000 12.3287 + 0.141000 0.00000 8.21764 + 0.0894000 0.00000 28.3861 + 0.0829000 0.00000 6.40890 + 0.502700 0.00000 8.27208 + 0.219100 0.00000 6.62170 + 0.389000 0.00000 8.87802 + 0.0846000 0.00000 12.4137 + 0.114500 0.00000 11.2715 + 0.122100 0.00000 6.33390 + 0.0777000 0.00000 8.74499 + 0.164400 0.00000 11.7539 + 0.0972000 0.00000 7.02019 + 0.0980000 0.00000 7.28974 + 0.321100 0.00000 7.59538 + 0.164000 0.00000 6.79750 + 0.330000 0.00000 8.49372 + 0.113000 0.00000 12.7059 + 0.392000 0.00000 6.34905 + 0.229000 0.00000 7.78817 + 0.224000 0.00000 13.4922 + 0.231000 0.00000 8.76194 + 0.0953000 0.00000 12.3723 + 0.447000 0.00000 11.6387 + 0.248000 0.00000 6.52803 + 0.397000 0.00000 11.7841 + 0.0802000 0.00000 11.5966 + 0.0654000 0.00000 6.76431 + 0.0231000 0.00000 28.7962 + 0.0757000 0.00000 7.74409 + 0.387000 0.00000 6.53476 + 0.224000 0.00000 6.76988 + 0.0436045 0.00000 10.6513 + 0.0906000 0.00000 7.99745 + 0.161500 0.00000 6.54060 + 0.0299000 0.00000 15.7793 + 0.422033 0.00000 6.35144 + 0.0852000 0.00000 6.12284 + 0.576000 0.00000 8.79017 + 0.163008 0.00000 6.92915 + 0.171200 0.00000 17.3438 + 0.175400 0.00000 8.11161 + 0.0567000 0.00000 7.79547 + 0.308300 0.00000 8.52252 + 0.317000 0.00000 6.83329 + 0.192000 0.00000 6.38533 + 0.366000 0.00000 9.32113 + 0.291700 0.00000 8.57915 + 0.156500 0.00000 8.71285 + 0.0940000 0.00000 6.51801 + 0.228000 0.00000 26.3205 + 0.277300 0.00000 7.53794 + 0.296600 0.00000 6.96300 + 0.232900 0.00000 17.7658 + 0.250000 0.00000 7.22880 + 0.0557000 0.00000 48.9851 + 0.169000 0.00000 6.01971 + 0.147000 0.00000 10.0346 + 0.450000 0.00000 7.69521 + 0.0878000 0.00000 7.84710 + 0.0980000 0.00000 6.86334 + 0.107200 0.00000 8.68015 + 0.0420000 0.00000 7.29452 + 0.299800 0.00000 9.20580 + 0.0765000 0.00000 7.09870 + 0.412000 0.00000 8.77445 + 0.183200 0.00000 7.10270 + 0.313700 0.00000 6.15549 + 0.0786000 0.00000 8.53143 + 0.367000 0.00000 6.05770 + 0.179000 0.00000 8.47350 + 0.277900 0.00000 11.1870 + 0.0700774 0.00000 6.14362 + 0.361735 0.00000 6.63069 + 0.822000 0.00000 10.4881 + 0.232000 0.00000 7.81321 + 0.227900 0.00000 16.4033 + 0.0428000 0.00000 6.20786 + 0.0809000 0.00000 26.1764 + 0.352000 0.00000 7.32940 + 0.0422000 0.00000 7.56725 + 0.331500 0.00000 13.0609 + 0.539200 0.00000 7.48314 + 0.162300 0.00000 7.61243 + 0.300000 0.00000 6.25610 + 0.139773 0.00000 6.32096 + 0.317900 0.00000 7.17519 + 0.300000 0.00000 7.59788 + 0.170900 0.00000 18.7904 + 0.0770000 0.00000 8.02970 + 0.131838 0.00000 6.62761 + 0.0928000 0.00000 7.49663 + 0.170600 0.00000 6.00362 + 0.105100 0.00000 7.80004 + 0.630500 0.00000 6.93897 + 0.210300 0.00000 6.21979 + 0.233900 0.00000 7.62626 + 0.485000 0.00000 6.61458 + 0.0877000 0.00000 6.75914 + 0.369455 0.00000 6.11180 + 0.0726000 0.00000 6.17091 + 0.0309000 0.00000 6.98729 + 0.0720000 0.00000 6.93177 + 0.316000 0.00000 6.03458 + 0.139400 0.00000 6.57885 + 0.292400 0.00000 11.4663 + 0.279900 0.00000 15.5745 + 0.267000 0.00000 7.48198 + -1.00000 -0.00000 7.09463 + 0.457000 0.00000 6.71901 + 0.325900 0.00000 7.14043 + 0.304487 0.00000 6.86662 + 0.0581000 0.00000 39.8161 + 0.545600 0.00000 8.59628 + 0.183000 0.00000 8.31206 + 0.0701000 0.00000 12.2761 + 0.0812000 0.00000 6.13514 + 0.107300 0.00000 7.87702 + 0.225000 0.00000 10.0305 + 0.371187 0.00000 8.15114 + 0.283600 0.00000 9.71106 + 0.0940000 0.00000 9.27841 + 0.225900 0.00000 10.0430 + 0.0555000 0.00000 22.6419 + 0.395647 0.00000 6.86233 + 0.254600 0.00000 7.99497 + 0.478000 0.00000 7.26189 + 0.396700 0.00000 7.50665 + 0.220000 0.00000 7.37397 + 0.196100 0.00000 6.33898 + 0.344000 0.00000 8.07951 + 0.318225 0.00000 6.07388 + 0.197100 0.00000 11.3821 + 0.0442000 0.00000 15.1605 + 0.301900 0.00000 10.2878 + 0.119261 0.00000 7.58598 + 0.200000 0.00000 6.03331 + 0.341000 0.00000 8.98558 + 0.254000 0.00000 8.05749 + 0.116000 0.00000 8.54828 + 0.345000 0.00000 6.36438 + 0.543612 0.00000 6.05837 + 0.0163000 0.00000 6.79008 + 0.496000 0.00000 6.82664 + 0.322000 0.00000 9.82099 + 0.267000 0.00000 9.45555 + 0.214900 0.00000 6.54833 + 0.0533000 0.00000 6.20110 + 0.363353 0.00000 9.97480 + 0.206000 0.00000 6.80132 + 0.0970000 0.00000 7.56017 + 0.0172000 0.00000 6.89515 + 0.136900 0.00000 14.7208 + 0.170000 0.00000 7.16540 + 0.0569000 0.00000 10.4099 + 0.181800 0.00000 17.5199 + 0.470000 0.00000 8.58441 + 0.289487 0.00000 6.61387 + 0.289825 0.00000 6.23088 + 0.566000 0.00000 7.78204 + 0.450000 0.00000 8.43200 + 0.377025 0.00000 6.30027 + 0.430000 0.00000 6.13379 + 0.206000 0.00000 17.0687 + -1.00000 -0.00000 6.30433 + 0.0381000 0.00000 9.74722 + 0.220300 0.00000 7.46318 + 0.210800 0.00000 6.24308 + 0.158000 0.00000 9.65552 + 0.342000 0.00000 6.10910 + 0.144000 0.00000 11.1665 + 0.217200 0.00000 12.2791 + 0.232250 0.00000 7.29216 + 0.405000 0.00000 6.00670 + 0.174000 0.00000 12.0897 + 0.139300 0.00000 6.33906 + 0.537638 0.00000 7.18336 + 0.126700 0.00000 6.44106 + 0.0794000 0.00000 6.95923 + 0.331000 0.00000 6.34719 + 0.373000 0.00000 7.56411 + 0.230000 0.00000 8.08555 + 0.236000 0.00000 8.25116 + 0.137200 0.00000 7.50829 + 0.546000 0.00000 12.7733 + 0.213800 0.00000 9.66025 + 0.206000 0.00000 8.75062 + 0.391900 0.00000 6.09233 + 0.288000 0.00000 6.75058 + 0.282000 0.00000 18.8636 + 0.378000 0.00000 6.78205 + 0.171000 0.00000 8.14396 + 0.125900 0.00000 6.44867 + 0.124000 0.00000 7.82347 + 0.295200 0.00000 7.56083 + 0.203000 0.00000 11.7844 + 0.299462 0.00000 6.26546 + 0.220000 0.00000 6.19541 + 0.537700 0.00000 7.10882 + 0.334900 0.00000 6.81213 + 0.122000 0.00000 6.68551 + 0.344000 0.00000 6.10697 + 0.310000 0.00000 8.18853 + 0.447400 0.00000 7.29649 + 0.443000 0.00000 13.3371 + 0.381000 0.00000 7.30373 + 0.353000 0.00000 9.63880 + 0.219500 0.00000 9.24743 + 0.247500 0.00000 9.47738 + 0.0326000 0.00000 12.2079 + 0.677000 0.00000 8.49845 + 0.322000 0.00000 6.69564 + 0.480000 0.00000 7.55613 + 0.227500 0.00000 7.48511 + 0.239900 0.00000 8.31131 + 0.249188 0.00000 6.54620 + 0.382600 0.00000 9.78994 + 0.135700 0.00000 7.01676 + 0.189000 0.00000 7.77638 + 0.137100 0.00000 6.93270 + 0.175100 0.00000 8.35920 + 0.0720000 0.00000 6.51679 + 0.232813 0.00000 7.89559 + 0.700000 0.00000 6.27261 + 0.0670000 0.00000 6.56846 + 0.369000 0.00000 6.86519 + 0.232300 0.00000 8.40556 + 0.253700 0.00000 8.37159 + 0.190400 0.00000 8.22761 + 0.460000 0.00000 11.8971 + 0.0989000 0.00000 9.52230 + 0.142700 0.00000 13.4914 + 0.224500 0.00000 6.74062 + 0.545000 0.00000 11.2752 + 0.425000 0.00000 6.69042 + 0.270100 0.00000 6.30990 + 0.171000 0.00000 9.64418 + 0.269000 0.00000 11.1236 + 0.0704000 0.00000 17.1231 + 0.321184 0.00000 6.03830 + 0.299400 0.00000 7.68369 + 0.199400 0.00000 6.07467 + 0.0214000 0.00000 9.91127 + 0.148300 0.00000 9.30455 + -1.00000 -0.00000 7.39847 + 0.169000 0.00000 6.83600 + 0.430000 0.00000 12.1648 + 0.0542000 0.00000 36.2437 + 0.285000 0.00000 7.44870 + 0.580000 0.00000 6.07745 + 0.420000 0.00000 9.01615 + 0.270800 0.00000 9.91471 + 0.139200 0.00000 14.4733 + 0.168700 0.00000 13.8643 + 0.0536000 0.00000 6.45085 + 0.410000 0.00000 10.3221 + 0.0834000 0.00000 11.0630 + 0.103000 0.00000 6.73029 + 0.283900 0.00000 11.1848 + 0.153500 0.00000 10.1323 + 0.172900 0.00000 7.65222 + 0.0468000 0.00000 10.4119 + 0.152000 0.00000 8.33042 + 0.166900 0.00000 8.53443 + 0.150100 0.00000 7.07684 + 0.400000 0.00000 6.23586 + 0.200000 0.00000 11.2541 + 0.0752000 0.00000 10.4837 + 0.0586000 0.00000 7.47610 + 0.229300 0.00000 6.58375 + 0.191300 0.00000 8.91534 + 0.274400 0.00000 6.60610 + 0.423513 0.00000 9.09555 + 0.116400 0.00000 7.12433 + 0.152752 0.00000 6.07164 + 0.219500 0.00000 11.3794 + 0.349900 0.00000 7.12694 + 0.202600 0.00000 9.49579 + 0.283600 0.00000 12.6616 + 0.600900 0.00000 7.19310 + 0.295200 0.00000 22.8774 + 0.0514000 0.00000 10.3138 + 0.421000 0.00000 12.7031 + 0.226600 0.00000 12.5125 + 0.0506000 0.00000 12.2589 + 0.300000 0.00000 6.40279 + 0.164400 0.00000 21.6702 + 0.240000 0.00000 8.20430 + 0.440000 0.00000 8.83018 + 0.0590000 0.00000 19.8439 + 0.296500 0.00000 26.9509 + 0.972000 0.00000 6.42368 + 0.254200 0.00000 10.8936 + 0.191200 0.00000 6.44437 + 0.0853000 0.00000 9.14395 + 0.313000 0.00000 7.72419 + 0.278000 0.00000 8.57011 + 0.370000 0.00000 14.0847 + 0.300000 0.00000 9.40788 + 0.0977370 0.00000 6.40548 + 0.0589000 0.00000 39.9947 + 0.141600 0.00000 7.24736 + 0.0110540 0.00000 8.05733 + 0.345370 0.00000 7.00537 + 0.133900 0.00000 12.5349 + 0.438000 0.00000 13.9706 + 0.120000 0.00000 7.34364 + 0.307500 0.00000 11.4087 + 0.290000 0.00000 6.58924 + 0.155700 0.00000 12.7185 + 0.126800 0.00000 9.14448 + 0.0852000 0.00000 7.41024 + 0.441400 0.00000 13.2791 + 0.116800 0.00000 9.25063 + 0.350000 0.00000 9.00035 + 0.165000 0.00000 10.8855 + 0.213000 0.00000 6.10789 + 0.307000 0.00000 8.03574 + 0.210000 0.00000 11.2415 + 0.470000 0.00000 7.14638 + 0.390000 0.00000 22.2733 + 0.155000 0.00000 8.23349 + 0.0730000 0.00000 7.40834 + 0.363000 0.00000 7.20884 + 0.0697000 0.00000 6.54596 + 0.250000 0.00000 11.0489 + 0.199200 0.00000 12.7063 + 0.127000 0.00000 21.2624 + 0.229000 0.00000 8.14828 + 0.180500 0.00000 6.05496 + -1.00000 -0.00000 6.66498 + 0.0238000 0.00000 6.50109 + 0.274200 0.00000 14.3691 + 0.119000 0.00000 9.76087 + 0.333000 0.00000 8.69176 + 0.0613000 0.00000 9.50203 + 0.870000 0.00000 11.5716 + 0.0114000 0.00000 9.50365 + 0.112500 0.00000 6.59417 + 0.0544000 0.00000 10.4724 + 0.0554000 0.00000 12.4003 + 0.193400 0.00000 6.51703 + 0.410000 0.00000 10.2089 + 0.0473000 0.00000 16.1160 + 0.300000 0.00000 8.63036 + 0.0845000 0.00000 11.1619 + 0.0845000 0.00000 14.4794 + 0.255300 0.00000 7.10029 + 0.350000 0.00000 6.13910 + 0.243900 0.00000 7.28753 + 0.0480000 0.00000 14.6081 + 0.0458000 0.00000 8.31696 + 0.183200 0.00000 16.7412 + 0.0490000 0.00000 6.38705 + 0.282500 0.00000 6.38954 + 0.153000 0.00000 15.6728 + 0.126400 0.00000 6.20434 + 0.233000 0.00000 7.88685 + 0.105000 0.00000 16.8628 + 0.0391000 0.00000 16.9440 + 0.0940000 0.00000 13.3131 + 0.211200 0.00000 7.79604 + 0.0852000 0.00000 7.82536 + 0.259000 0.00000 8.50470 + 0.451600 0.00000 11.2422 + 0.0951000 0.00000 8.12888 + 0.580000 0.00000 6.02785 + 0.315500 0.00000 8.74540 + 0.115000 0.00000 6.38054 + -1.00000 -0.00000 6.16602 + 0.0980000 0.00000 19.6415 + 0.147000 0.00000 12.1692 + 0.318000 0.00000 6.93620 + 0.0760000 0.00000 13.1297 + 0.0965000 0.00000 13.4800 + 0.0760000 0.00000 6.00108 + 0.547261 0.00000 7.45101 + 0.260000 0.00000 7.53872 + 0.596000 0.00000 8.84926 + 0.252800 0.00000 14.4232 + 0.0556000 0.00000 25.7945 + 0.235700 0.00000 10.4868 + 0.284000 0.00000 6.11325 + 0.232000 0.00000 8.15297 + 0.0600000 0.00000 7.75241 + 0.279734 0.00000 6.03881 + 0.270000 0.00000 6.45262 + 0.0448310 0.00000 6.83755 + 0.222600 0.00000 12.5512 + 0.237100 0.00000 8.89971 + 0.250000 0.00000 7.00197 + 0.358000 0.00000 8.21365 + 0.347500 0.00000 20.7304 + 0.610000 0.00000 6.55383 + 0.114700 0.00000 9.29650 + 0.215300 0.00000 8.69539 + 0.0475000 0.00000 9.79206 + 0.209000 0.00000 8.87111 + 0.108200 0.00000 8.85900 + 0.178600 0.00000 9.21071 diff --git a/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts.yaml b/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts.yaml new file mode 100644 index 00000000..8558cf93 --- /dev/null +++ b/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts.yaml @@ -0,0 +1,219 @@ +output: /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/sz_binned_cluster_counts/chains/so_sz_binned_cluster_counts_test + +likelihood: + soliket.sz_binned_cluster_counts.binned_cc.binned_cc_likelihood: + tcat_file: 'MFMF_SOSim_3freq_tiles_M500.fits' + snrcut: 5. + +theory: + soliket.ymap.classy_sz: + # classy: + # path: '/Users/boris/Work/CLASS-SZ/SO-SZ/class_sz' + extra_args: + non linear: 'halofit' + output : 'sz_cluster_counts' + mass function : 'M500' + integrate_wrt_m500c : 1 + has_selection_function : 1 + experiment : 1 # simons observatory + y_m_relation : 1 + signal-to-noise cut-off for survey cluster completeness : 5. + + # scaling law parameter + # Hilton et al 2020 + A_ym : 4.95e-5 + B_ym : 0.08 + + + + M1SZ : 5e13 + M2SZ : 5e15 + + # bin_z_min_cluster_counts : 0. + # bin_z_max_cluster_counts : 2. + # bin_dz_cluster_counts : 0.1 + # + # + tau_reio: 0.054 # planck 2018 value (in abstract of 1807.06209) + YHe: BBN + + # 1 massive neutrino (planck 2018 baseline) + N_ur: 2.0328 + N_ncdm: 1 + m_ncdm: 0.06 + T_ncdm: 0.71611 + + # + # #3 massive neutrinos + # N_ur : 0.00641 + # N_ncdm : 1 + # deg_ncdm : 3 + # m_ncdm : 0.02 + # T_ncdm : 0.71611 + + + + # + # HMF_prescription_NCDM: 'CDM' + + # verbose parameters for debugging + input_verbose : 0 + background_verbose: 0 + perturbations_verbose: 0 + sz_verbose : 0 + + # X ray mass bias (if applicable) + B : 1. + + + bin_z_min_cluster_counts : 0. + bin_z_max_cluster_counts : 2. + bin_dz_cluster_counts : 0.1 + bin_dlog10_snr: 0.1 + + dlny : 0.03 + lnymin : -11. + lnymax : -5. + sigmaM_ym : 0.075 + dlnM_cluster_count_completeness_grid : 0.03 + + + cluster_count_completeness_grid_z_cutoff_low : 0.5 + cluster_count_completeness_grid_z_cutoff_mid : 1.5 + dz_cluster_count_completeness_grid_low_z : 5e-3 + dz_cluster_count_completeness_grid_mid_z : 1e-1 + dz_cluster_count_completeness_grid_high_z : 1e-1 + + mass_epsrel_cluster_counts : 1e-3 + mass_epsabs_cluster_counts : 1e-30 + + redshift_epsrel_cluster_counts : 1e-3 + redshift_epsabs_cluster_counts : 1e-30 + + + + # + # + # # tabulation of mass function: + n_z_dndlnM : 80 + n_m_dndlnM : 80 + # + # # computation of mass function + # # (grid in mass and redshifts for sigma and dsigma) + ndim_masses : 80 + ndim_redshifts : 80 + # + # pk setup for computation of sigma and dsigma + k_per_decade_class_sz : 20. + k_min_for_pk_class_sz : 1e-3 + k_max_for_pk_class_sz : 1e1 + + P_k_max_h/Mpc : 1e1 + + +params: + theta_MC_100: + prior: + min: 0.5 + max: 10 + ref: + dist: norm + loc: 1.04109 + scale: 0.0004 + proposal: 0.0002 + latex: 100\theta_\mathrm{MC} + drop: true + renames: theta + 100*theta_s: + value: 'lambda theta_MC_100: theta_MC_100' + derived: false + logA: + prior: + min: 2 + max: 4 + ref: + dist: norm + loc: 3.1 + scale: 0.001 + proposal: 0.001 + drop: true + latex: \log(10^{10} A_\mathrm{s}) + A_s: + value: 'lambda logA: 1e-10*np.exp(logA)' + latex: A_\mathrm{s} + n_s: + prior: + min: 0.8 + max: 1.2 + ref: + dist: norm + loc: 0.96 + scale: 0.004 + proposal: 0.002 + latex: n_\mathrm{s} + omega_b: + prior: + min: 0.005 + max: 0.1 + ref: + dist: norm + loc: 0.0221 + scale: 0.0001 + proposal: 0.0001 + latex: \Omega_\mathrm{b}h^2 + omega_cdm: + prior: + min: 0.001 + max: 0.99 + ref: + dist: norm + loc: 0.12 + scale: 0.001 + proposal: 0.0005 + latex: \Omega_\mathrm{c}h^2 + # tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.065 + # scale: 0.01 + # proposal: 0.005 + # latex: \tau_\mathrm{reio} + H0: + latex: H_0 + sigma8: + latex: \sigma_8 + Omega_m: + latex: \Omega_\mathrm{m} + + # F_sz: + # derived: 'lambda sigma8, Omega_m, B, H0: (sigma8/0.8)*(Omega_m/0.3)**0.35*(B/1.25)**-0.35*(H0/70.)**-0.20' + # latex: F_\mathrm{sz} + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # omega_cdm: 0.125 + # omega_b: 0.0224 + # logA: 2.95 + # n_s: 0.96 + # # H0: 69. + # theta_MC_100: 1.043612 + + + +# debug : True +timing: true diff --git a/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts_planck.yaml b/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts_planck.yaml new file mode 100644 index 00000000..f4b15d61 --- /dev/null +++ b/soliket/sz_binned_cluster_counts/input_files/sz_binned_cluster_counts_planck.yaml @@ -0,0 +1,222 @@ +output: /Users/boris/Work/CLASS-SZ/SO-SZ/SOLikeT/soliket/sz_binned_cluster_counts/chains/so_sz_binned_cluster_counts_planck_test + +likelihood: + soliket.sz_binned_cluster_counts.binned_cc.binned_cc_likelihood: + tcat_file: 'SZ_cat.txt' + snrcut: 6. + experiment: 'Planck' + + bin_z_min_cluster_counts : 0. + bin_z_max_cluster_counts : 1. + bin_dz_cluster_counts : 0.1 + bin_dlog10_snr: 0.25 + debug: False + + + + +theory: + soliket.ymap.classy_sz: + extra_args: + non linear: 'halofit' + output : 'sz_cluster_counts' + mass function : 'M500' + + has_selection_function : 1 + experiment : 0 # Planck + y_m_relation : 0 + signal-to-noise cut-off for survey cluster completeness : 6. + use_planck_binned_proba : 1 + + M_min : 5e13 + M_max : 5e15 + + # bin_z_min_cluster_counts : 0. + # bin_z_max_cluster_counts : 2. + # bin_dz_cluster_counts : 0.1 + # + # + tau_reio: 0.054 # planck 2018 value (in abstract of 1807.06209) + YHe: BBN + + # 1 massive neutrino (planck 2018 baseline) + N_ur: 2.0328 + N_ncdm: 1 + m_ncdm: 0.06 + T_ncdm: 0.71611 + + # + # #3 massive neutrinos + # N_ur : 0.00641 + # N_ncdm : 1 + # deg_ncdm : 3 + # m_ncdm : 0.02 + # T_ncdm : 0.71611 + + + + # + # HMF_prescription_NCDM: 'CDM' + + # verbose parameters for debugging + input_verbose : 0 + background_verbose: 0 + perturbations_verbose: 0 + class_sz_verbose : 0 + + # X ray mass bias (if applicable) + B : 1.71 + + + bin_z_min_cluster_counts : 0. + bin_z_max_cluster_counts : 1. + bin_dz_cluster_counts : 0.1 + bin_dlog10_snr: 0.25 + + dlny : 0.03 + lnymin : -11. + lnymax : -5. + sigmaM_ym : 0.173 + dlnM_cluster_count_completeness_grid : 0.03 + + + cluster_count_completeness_grid_z_cutoff_low : 0.5 + cluster_count_completeness_grid_z_cutoff_mid : 1.5 + dz_cluster_count_completeness_grid_low_z : 5e-3 + dz_cluster_count_completeness_grid_mid_z : 1e-1 + dz_cluster_count_completeness_grid_high_z : 1e-1 + + mass_epsrel_cluster_counts : 1e-3 + mass_epsabs_cluster_counts : 1e-30 + + redshift_epsrel_cluster_counts : 1e-3 + redshift_epsabs_cluster_counts : 1e-30 + + + + # + # + # # tabulation of mass function: + n_z_dndlnM : 80 + n_m_dndlnM : 80 + # + # # computation of mass function + # # (grid in mass and redshifts for sigma and dsigma) + ndim_masses : 80 + ndim_redshifts : 80 + # + # pk setup for computation of sigma and dsigma + k_per_decade_class_sz : 20. + k_min_for_pk_class_sz : 1e-3 + k_max_for_pk_class_sz : 1e1 + + P_k_max_h/Mpc : 1e1 + + +params: + theta_MC_100: + prior: + min: 0.5 + max: 10 + ref: + dist: norm + loc: 1.04109 + scale: 0.0004 + proposal: 0.0002 + latex: 100\theta_\mathrm{MC} + drop: true + renames: theta + 100*theta_s: + value: 'lambda theta_MC_100: theta_MC_100' + derived: false + logA: + prior: + min: 2 + max: 4 + ref: + dist: norm + loc: 3.1 + scale: 0.001 + proposal: 0.001 + drop: true + latex: \log(10^{10} A_\mathrm{s}) + A_s: + value: 'lambda logA: 1e-10*np.exp(logA)' + latex: A_\mathrm{s} + n_s: + prior: + min: 0.8 + max: 1.2 + ref: + dist: norm + loc: 0.96 + scale: 0.004 + proposal: 0.002 + latex: n_\mathrm{s} + omega_b: + prior: + min: 0.005 + max: 0.1 + ref: + dist: norm + loc: 0.0221 + scale: 0.0001 + proposal: 0.0001 + latex: \Omega_\mathrm{b}h^2 + omega_cdm: + prior: + min: 0.001 + max: 0.99 + ref: + dist: norm + loc: 0.12 + scale: 0.001 + proposal: 0.0005 + latex: \Omega_\mathrm{c}h^2 + # tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.065 + # scale: 0.01 + # proposal: 0.005 + # latex: \tau_\mathrm{reio} + H0: + latex: H_0 + sigma8: + latex: \sigma_8 + Omega_m: + latex: \Omega_\mathrm{m} + + # F_sz: + # derived: 'lambda sigma8, Omega_m, B, H0: (sigma8/0.8)*(Omega_m/0.3)**0.35*(B/1.25)**-0.35*(H0/70.)**-0.20' + # latex: F_\mathrm{sz} + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + mcmc: + covmat: #auto + Rminus1_stop: 0.01 + # drag: true + proposal_scale: 2.4 + learn_proposal: True + learn_proposal_Rminus1_max: 2. + + # evaluate: + # override: + # # #parameter values: + # omega_cdm: 0.125 + # omega_b: 0.0224 + # logA: 2.95 + # n_s: 0.96 + # # H0: 69. + # theta_MC_100: 1.043612 + + + + +debug : True +timing: true diff --git a/soliket/tests/__init__.py b/soliket/tests/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/soliket/tests/test_ccl.ipynb b/soliket/tests/test_ccl.ipynb deleted file mode 100644 index 8aa6623d..00000000 --- a/soliket/tests/test_ccl.ipynb +++ /dev/null @@ -1,426 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from cobaya.model import get_model\n", - "from soliket.ccl import CCL\n", - "from soliket.cross_correlation import CrossCorrelationLikelihood\n", - "import pyccl as ccl" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "cosmo_params = {\n", - " \"Omega_c\": 0.25,\n", - " \"Omega_b\": 0.05,\n", - " \"h\": 0.67,\n", - " \"n_s\": 0.96\n", - "}\n", - "\n", - "info = {\"params\": {\"omch2\": cosmo_params['Omega_c'] * cosmo_params['h'] ** 2.,\n", - " \"ombh2\": cosmo_params['Omega_b'] * cosmo_params['h'] ** 2.,\n", - " \"H0\": cosmo_params['h'] * 100,\n", - " \"ns\": cosmo_params['n_s'],\n", - " \"As\": 2.2e-9,\n", - " \"tau\": 0,\n", - " \"b1\": {'prior':{'min': 0.9, 'max': 1.1}, 'latex': 'b_1'},\n", - " \"s1\": 0.4},\n", - " \"likelihood\": {\"soliket.cross_correlation.CrossCorrelationLikelihood\": {\n", - " \"auto_file\": \"../soliket/data/xcorr_simulated/clgg_noiseless.txt\",\n", - " \"cross_file\": \"soliket/data/xcorr_simulated/clkg_noiseless.txt\",\n", - " \"dndz_file\": \"soliket/data/xcorr_simulated/dndz.txt\",\n", - " }},\n", - " \"theory\": {\n", - " \"camb\": None,\n", - " \"ccl\": {\"external\": CCL, \"nonlinear\": False}\n", - " },\n", - " \"debug\": False, \"stop_at_error\": True,\n", - " \"sampler\": {\"evaluate\": None},\n", - " }\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[camb] Importing *auto-installed* CAMB (but defaulting to *global*).\n", - "[camb] Initialized!\n" - ] - }, - { - "ename": "OSError", - "evalue": "soliket/data/xcorr_simulated/dndz.txt not found.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mcobaya\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mupdated_info\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msampler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/run.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(info)\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_prior\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkinds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtheory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 89\u001b[0m \u001b[0mpackages_path\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_packages_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtiming\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_timing\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 90\u001b[0;31m allow_renames=False, stop_at_error=info.get(\"stop_at_error\", False)) \\\n\u001b[0m\u001b[1;32m 91\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 92\u001b[0m \u001b[0;31m# Re-dump the updated info, now containing parameter routes and version info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/model.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info_params, info_likelihood, info_prior, info_theory, packages_path, timing, allow_renames, stop_at_error, post, prior_parameterization)\u001b[0m\n\u001b[1;32m 150\u001b[0m \u001b[0minfo_likelihood\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_updated_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkinds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlikelihood\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 151\u001b[0m self.likelihood = LikelihoodCollection(info_likelihood, theory=self.theory,\n\u001b[0;32m--> 152\u001b[0;31m packages_path=packages_path, timing=timing)\n\u001b[0m\u001b[1;32m 153\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstop_at_error\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcomponent\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomponents\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/likelihood.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info_likelihood, packages_path, timing, theory)\u001b[0m\n\u001b[1;32m 279\u001b[0m self.add_instance(name, like_class(info, packages_path=packages_path,\n\u001b[1;32m 280\u001b[0m \u001b[0mtiming\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtiming\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstandalone\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 281\u001b[0;31m name=name))\n\u001b[0m\u001b[1;32m 282\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 283\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_LikelihoodInterface\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/likelihood.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info, name, timing, packages_path, initialize, standalone)\u001b[0m\n\u001b[1;32m 83\u001b[0m super().__init__(info, name=name, timing=timing,\n\u001b[1;32m 84\u001b[0m \u001b[0mpackages_path\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpackages_path\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minitialize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 85\u001b[0;31m standalone=standalone)\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;31m# Make sure `types` is a list of data types, for aggregated chi2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr_to_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"type\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/theory.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info, name, timing, packages_path, initialize, standalone)\u001b[0m\n\u001b[1;32m 61\u001b[0m super().__init__(info, name=name, timing=timing,\n\u001b[1;32m 62\u001b[0m \u001b[0mpackages_path\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpackages_path\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minitialize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m standalone=standalone)\n\u001b[0m\u001b[1;32m 64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprovider\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;31m# set to Provider instance before calculations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/cobaya/component.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info, name, timing, packages_path, initialize, standalone)\u001b[0m\n\u001b[1;32m 90\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 91\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 93\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'_params'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/soliket-0.0-py3.7.egg/soliket/cross_correlation.py\u001b[0m in \u001b[0;36minitialize\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mCrossCorrelationLikelihood\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mGaussianLikelihood\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minitialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdndz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloadtxt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdndz_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/numpy/lib/npyio.py\u001b[0m in \u001b[0;36mloadtxt\u001b[0;34m(fname, dtype, comments, delimiter, converters, skiprows, usecols, unpack, ndmin, encoding, max_rows)\u001b[0m\n\u001b[1;32m 959\u001b[0m \u001b[0mfname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos_fspath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 960\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_is_string_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 961\u001b[0;31m \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_datasource\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rt'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 962\u001b[0m \u001b[0mfencoding\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'encoding'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'latin1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 963\u001b[0m \u001b[0mfh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfh\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/numpy/lib/_datasource.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(path, mode, destpath, encoding, newline)\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 194\u001b[0m \u001b[0mds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDataSource\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdestpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 195\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnewline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnewline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 196\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 197\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/cosmo/lib/python3.7/site-packages/numpy/lib/_datasource.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(self, path, mode, encoding, newline)\u001b[0m\n\u001b[1;32m 533\u001b[0m encoding=encoding, newline=newline)\n\u001b[1;32m 534\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 535\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mIOError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"%s not found.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 536\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 537\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mOSError\u001b[0m: soliket/data/xcorr_simulated/dndz.txt not found." - ] - } - ], - "source": [ - "from cobaya.run import run\n", - "\n", - "updated_info, sampler = run(info)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 2021-03-18 12:27:20,789 [outputdummy] No output requested. Doing nothing.\n", - " 2021-03-18 12:27:20,818 [run] Input info updated with defaults (dumped to YAML):\n", - "theory:\n", - " camb:\n", - " version: null\n", - " path: null\n", - " speed: 0.3\n", - " stop_at_error: false\n", - " extra_args: null\n", - " use_renames: false\n", - " external_primordial_pk: false\n", - " renames:\n", - " omegabh2: ombh2\n", - " omegach2: omch2\n", - " omegal: omega_de\n", - " omegak: omk\n", - " yhe: YHe\n", - " yheused: YHe\n", - " YpBBN: Y_p\n", - " zrei: zre\n", - " soliket.ccl.CCL:\n", - " kmax: 0\n", - " nonlinear: true\n", - " z: []\n", - " extra_args: {}\n", - " logz:\n", - " - -3.0\n", - " - -2.9389758314630483\n", - " - -2.8779516629260966\n", - " - -2.8169274943891445\n", - " - -2.7559033258521928\n", - " - -2.694879157315241\n", - " - -2.6338549887782894\n", - " - -2.5728308202413377\n", - " - -2.511806651704386\n", - " - -2.4507824831674343\n", - " - -2.389758314630482\n", - " - -2.3287341460935305\n", - " - -2.2677099775565788\n", - " - -2.206685809019627\n", - " - -2.1456616404826754\n", - " - -2.0846374719457232\n", - " - -2.0236133034087715\n", - " - -1.9625891348718199\n", - " - -1.9015649663348682\n", - " - -1.8405407977979162\n", - " - -1.7795166292609645\n", - " - -1.7184924607240128\n", - " - -1.657468292187061\n", - " - -1.5964441236501092\n", - " - -1.5354199551131575\n", - " - -1.4743957865762056\n", - " - -1.413371618039254\n", - " - -1.3523474495023022\n", - " - -1.2913232809653503\n", - " - -1.2302991124283986\n", - " - -1.169274943891447\n", - " - -1.108250775354495\n", - " - -1.0472266068175433\n", - " - -0.9862024382805914\n", - " - -0.9251782697436397\n", - " - -0.864154101206688\n", - " - -0.8031299326697363\n", - " - -0.7421057641327846\n", - " - -0.6810815955958325\n", - " - -0.6200574270588808\n", - " - -0.5590332585219291\n", - " - -0.4980090899849774\n", - " - -0.4369849214480257\n", - " - -0.375960752911074\n", - " - -0.31493658437412186\n", - " - -0.25391241583717017\n", - " - -0.19288824730021847\n", - " - -0.13186407876326678\n", - " - -0.07083991022631508\n", - " - -0.009815741689363389\n", - " - 0.05120842684758875\n", - " - 0.11223259538454045\n", - " - 0.17325676392149214\n", - " - 0.23428093245844384\n", - " - 0.29530510099539553\n", - " - 0.3563292695323472\n", - " - 0.41735343806929937\n", - " - 0.47837760660625106\n", - " - 0.5394017751432028\n", - " - 0.6004259436801545\n", - " - 0.6614501122171061\n", - " - 0.7224742807540578\n", - " - 0.78349844929101\n", - " - 0.8445226178279617\n", - " - 0.9055467863649134\n", - " - 0.9665709549018651\n", - " - 1.0275951234388172\n", - " - 1.0886192919757685\n", - " - 1.1496434605127206\n", - " - 1.2106676290496718\n", - " - 1.271691797586624\n", - " - 1.3327159661235761\n", - " - 1.3937401346605274\n", - " - 1.4547643031974795\n", - " - 1.5157884717344308\n", - " - 1.576812640271383\n", - " - 1.637836808808335\n", - " - 1.6988609773452863\n", - " - 1.7598851458822384\n", - " - 1.8209093144191897\n", - " - 1.8819334829561418\n", - " - 1.942957651493093\n", - " - 2.003981820030045\n", - " - 2.0650059885669974\n", - " - 2.1260301571039486\n", - " - 2.1870543256409007\n", - " - 2.248078494177852\n", - " - 2.309102662714804\n", - " - 2.3701268312517563\n", - " - 2.4311509997887075\n", - " - 2.4921751683256597\n", - " - 2.553199336862611\n", - " - 2.614223505399563\n", - " - 2.6752476739365143\n", - " - 2.7362718424734664\n", - " - 2.7972960110104186\n", - " - 2.85832017954737\n", - " - 2.919344348084322\n", - " - 2.9803685166212732\n", - " - 3.041392685158225\n", - " speed: -1\n", - " stop_at_error: false\n", - " version: null\n", - " external: !!python/name:soliket.ccl.CCL ''\n", - "likelihood:\n", - " Tester:\n", - " auto_file: /Users/Pablo/Code/SOLikeT/input/clgg.txt\n", - " cross_file: /Users/Pablo/Code/SOLikeT/input/clkg.txt\n", - " dndz_file: /Users/Pablo/Code/SOLikeT/input/dndz.txt\n", - " params:\n", - " b1: 1\n", - " s1: 1\n", - " type: []\n", - " speed: -1\n", - " stop_at_error: false\n", - " version: null\n", - " external: !!python/name:__main__.Tester ''\n", - "params:\n", - " ombh2:\n", - " value: 0.024499999999999997\n", - " renames:\n", - " - omegabh2\n", - " H0:\n", - " value: 70\n", - " ns:\n", - " value: 0.965\n", - " logA:\n", - " value: 3\n", - " latex: \\log(10^{10} A_\\mathrm{s})\n", - " drop: true\n", - " As:\n", - " value: true\n", - " latex: A_\\mathrm{s}\n", - " derived: true\n", - " omegam:\n", - " value: 0.3\n", - " latex: \\Omega_\\mathrm{m}\n", - " drop: true\n", - " omch2:\n", - " value: true\n", - " latex: \\Omega_\\mathrm{c} h^2\n", - " derived: true\n", - " renames:\n", - " - omegach2\n", - " tau:\n", - " value: 0.05\n", - " mnu:\n", - " value: 0.0\n", - " b1:\n", - " prior:\n", - " min: 0.99\n", - " max: 1.01\n", - " latex: b_1\n", - " s1:\n", - " value: 0.4\n", - "sampler:\n", - " evaluate:\n", - " N: 1\n", - " override: null\n", - " seed: null\n", - " version: null\n", - "debug: true\n", - "stop_at_error: true\n", - "\n", - " 2021-03-18 12:27:20,829 [camb] Importing *auto-installed* CAMB (but defaulting to *global*).\n", - " 2021-03-18 12:27:20,830 [camb] Initialized!\n", - " 2021-03-18 12:27:20,843 [model] Parameters were assigned as follows:\n", - " 2021-03-18 12:27:20,844 [model] - Tester:\n", - " 2021-03-18 12:27:20,844 [model] Input: ['b1', 's1']\n", - " 2021-03-18 12:27:20,845 [model] Output: []\n", - " 2021-03-18 12:27:20,845 [model] - camb.transfers:\n", - " 2021-03-18 12:27:20,846 [model] Input: ['ombh2', 'H0', 'omch2', 'tau', 'mnu']\n", - " 2021-03-18 12:27:20,846 [model] Output: []\n", - " 2021-03-18 12:27:20,847 [model] - camb:\n", - " 2021-03-18 12:27:20,848 [model] Input: ['ns', 'As']\n", - " 2021-03-18 12:27:20,849 [model] Output: []\n", - " 2021-03-18 12:27:20,850 [model] - soliket.ccl.CCL:\n", - " 2021-03-18 12:27:20,850 [model] Input: []\n", - " 2021-03-18 12:27:20,851 [model] Output: []\n", - " 2021-03-18 12:27:20,857 [model] Components will be computed in the order:\n", - " 2021-03-18 12:27:20,858 [model] - [camb.transfers, camb, soliket.ccl.CCL, Tester]\n", - " 2021-03-18 12:27:20,859 [model] Requirements will be calculated by these components:\n", - " 2021-03-18 12:27:20,860 [model] - CCL: soliket.ccl.CCL\n", - " 2021-03-18 12:27:20,860 [model] - Pk_grid: camb\n", - " 2021-03-18 12:27:20,861 [model] - Hubble: camb\n", - " 2021-03-18 12:27:20,862 [model] - comoving_radial_distance: camb\n", - " 2021-03-18 12:27:20,863 [model] - fsigma8: camb\n", - " 2021-03-18 12:27:20,863 [model] - sigma8_z: camb\n", - " 2021-03-18 12:27:20,864 [model] - CAMB_transfers: camb.transfers\n", - " 2021-03-18 12:27:20,868 [evaluate] Initialized!\n", - " 2021-03-18 12:27:20,869 [evaluate] Looking for a reference point with non-zero prior.\n", - " 2021-03-18 12:27:20,869 [prior] Reference values or pdf's for some parameters were not provided. Sampling from the prior instead for those parameters.\n", - " 2021-03-18 12:27:20,870 [prior] Evaluating prior at array([1.00044478])\n", - " 2021-03-18 12:27:20,871 [prior] Got logpriors = [3.912023005428145]\n", - " 2021-03-18 12:27:20,872 [evaluate] Reference point:\n", - " b1 = 1.00044\n", - " 2021-03-18 12:27:20,873 [evaluate] Evaluating prior and likelihoods...\n", - " 2021-03-18 12:27:20,873 [model] Posterior to be computed for parameters {'b1': 1.0004447762914368}\n", - " 2021-03-18 12:27:20,874 [prior] Evaluating prior at array([1.00044478])\n", - " 2021-03-18 12:27:20,875 [prior] Got logpriors = [3.912023005428145]\n", - " 2021-03-18 12:27:20,876 [model] Got input parameters: {'ombh2': 0.024499999999999997, 'H0': 70, 'ns': 0.965, 'As': 2.008553692318767e-09, 'omch2': 0.12249999999999997, 'tau': 0.05, 'mnu': 0.0, 'b1': 1.0004447762914368, 's1': 0.4}\n", - " 2021-03-18 12:27:20,876 [camb.transfers] Got parameters {'ombh2': 0.024499999999999997, 'H0': 70, 'omch2': 0.12249999999999997, 'tau': 0.05, 'mnu': 0.0}\n", - " 2021-03-18 12:27:20,877 [camb.transfers] Computing new state\n", - " 2021-03-18 12:27:20,878 [camb] Setting parameters: {'ombh2': 0.024499999999999997, 'H0': 70, 'omch2': 0.12249999999999997, 'tau': 0.05, 'mnu': 0.0} and {'kmax': 10, 'redshifts': array([1.10000000e+03, 9.55803280e+02, 8.30509009e+02, 7.21639305e+02,\n", - " 6.27041104e+02, 5.44843586e+02, 4.73421169e+02, 4.11361370e+02,\n", - " 3.57436860e+02, 3.10581203e+02, 2.69867757e+02, 2.34491352e+02,\n", - " 2.03752367e+02, 1.77042892e+02, 1.53834706e+02, 1.33668833e+02,\n", - " 1.16146463e+02, 1.00921064e+02, 8.76915308e+01, 7.61962298e+01,\n", - " 6.62078240e+01, 5.75287776e+01, 4.99874494e+01, 4.34346983e+01,\n", - " 3.77409337e+01, 3.27935529e+01, 2.84947141e+01, 2.47594011e+01,\n", - " 2.15137425e+01, 1.86935506e+01, 1.62430518e+01, 1.41137838e+01,\n", - " 1.22636371e+01, 1.06560224e+01, 9.25914648e+00, 8.04538416e+00,\n", - " 6.99073143e+00, 6.07433094e+00, 5.27805949e+00, 4.58616961e+00,\n", - " 3.98497814e+00, 3.46259562e+00, 3.00869114e+00, 2.61428805e+00,\n", - " 2.27158645e+00, 1.97380889e+00, 1.71506638e+00, 1.49024188e+00,\n", - " 1.29488916e+00, 1.12514482e+00, 9.77651922e-01, 8.49493558e-01,\n", - " 7.38135208e-01, 6.41374594e-01, 5.57298128e-01, 4.84243072e-01,\n", - " 4.20764651e-01, 3.65607485e-01, 3.17680758e-01, 2.76036646e-01,\n", - " 2.39851574e-01, 2.08409928e-01, 1.81089903e-01, 1.57351203e-01,\n", - " 1.36724360e-01, 1.18801447e-01, 1.03228012e-01, 8.96960655e-02,\n", - " 7.79379942e-02, 6.77212641e-02, 5.88438240e-02, 5.11301091e-02,\n", - " 4.44275690e-02, 3.86036511e-02, 3.35431785e-02, 2.91460728e-02,\n", - " 2.53253745e-02, 2.20055237e-02, 1.91208652e-02, 1.66143506e-02,\n", - " 1.44364098e-02, 1.25439708e-02, 1.08996077e-02, 9.47080068e-03,\n", - " 8.22929305e-03, 7.15053208e-03, 6.21318365e-03, 5.39871029e-03,\n", - " 4.69100455e-03, 4.07607048e-03, 3.54174685e-03, 3.07746660e-03,\n", - " 2.67404788e-03, 2.32351249e-03, 2.01892805e-03, 1.75427096e-03,\n", - " 1.52430722e-03, 1.32448894e-03, 1.15086443e-03, 0.00000000e+00])}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 2021-03-18 12:27:20,894 [camb] Setting attributes of CAMBparams: {'Want_CMB': False, 'Want_cl_2D_array': False, 'WantCls': False, 'NonLinear': 'NonLinear_pk'}\n", - " 2021-03-18 12:27:21,112 [camb] Got parameters {'ns': 0.965, 'As': 2.008553692318767e-09}\n", - " 2021-03-18 12:27:21,113 [camb] Computing new state\n", - " 2021-03-18 12:27:21,710 [soliket.ccl.ccl] Got parameters {}\n", - " 2021-03-18 12:27:21,711 [soliket.ccl.ccl] Computing new state\n", - " 2021-03-18 12:27:21,721 [tester] Got parameters {'b1': 1.0004447762914368, 's1': 0.4}\n", - " 2021-03-18 12:27:21,722 [tester] Computing new state\n", - " 2021-03-18 12:27:21,731 [tester] Computed log-likelihood = -41.6874\n", - " 2021-03-18 12:27:21,731 [model] Computed derived parameters: {'As': 2.008553692318767e-09, 'omch2': 0.12249999999999997}\n", - " 2021-03-18 12:27:21,732 [evaluate] log-posterior = -37.7754\n", - " 2021-03-18 12:27:21,733 [evaluate] log-prior = 3.91202\n", - " 2021-03-18 12:27:21,734 [evaluate] logprior_0 = 3.91202\n", - " 2021-03-18 12:27:21,734 [evaluate] log-likelihood = -41.6874\n", - " 2021-03-18 12:27:21,735 [evaluate] chi2_Tester = 83.3748\n", - " 2021-03-18 12:27:21,736 [evaluate] Derived params:\n", - " 2021-03-18 12:27:21,736 [evaluate] As = 2.00855e-09\n", - " 2021-03-18 12:27:21,737 [evaluate] omch2 = 0.1225\n" - ] - } - ], - "source": [ - "from cobaya.run import run\n", - "\n", - "updated_info, sampler = run(info)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Cosmo", - "language": "python", - "name": "cosmo" - }, - "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.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/soliket/tests/test_cluster.ipynb b/soliket/tests/test_cluster.ipynb deleted file mode 100644 index d8d0e2f7..00000000 --- a/soliket/tests/test_cluster.ipynb +++ /dev/null @@ -1,712 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# REFERENCE FOR CCL, from https://github.com/cmbant/SZCl_like/blob/methods/szcl_like/szcl_like.py\n", - "\n", - "import pyccl as ccl\n", - "from .theory import HaloProfileArnaud, SZTracer\n", - "import numpy as np\n", - "from scipy.interpolate import interp1d\n", - "from cobaya.likelihood import Likelihood\n", - "\n", - "\n", - "class SZModel:\n", - " pass\n", - "\n", - "\n", - "class SZClLike(Likelihood):\n", - " cl_file: str = \"data/cl_yy.fits\"\n", - " map_name: str = \"SO_y\"\n", - " l_min: int = 100\n", - " l_max: int = 3000\n", - "\n", - " params = {'b_hydro': 0.2}\n", - "\n", - " def initialize(self):\n", - " self.nl_per_decade = 5\n", - " self.mdef = ccl.halos.MassDef(500, 'critical')\n", - " self.prof = HaloProfileArnaud(0.2)\n", - " self._read_data()\n", - " self.ks = np.geomspace(1E-4, 100, 256)\n", - " self.lks = np.log(self.ks)\n", - " self.a_s = np.linspace(0.1, 1, 10)\n", - " self.add_2h = False\n", - "\n", - " def get_requirements(self):\n", - " return {'CCL': {\"methods\": {'sz_model': self._get_sz_model}, \"kmax\": 10}}\n", - "\n", - " def _read_data(self):\n", - " import sacc\n", - " # Read data vector and covariance\n", - " s = sacc.Sacc.load_fits(self.cl_file)\n", - " if self.map_name not in list(s.tracers.keys()):\n", - " raise KeyError(\"Map not found\")\n", - "\n", - " inds = s.indices('cl_00',\n", - " (self.map_name,\n", - " self.map_name),\n", - " ell__gt=self.l_min,\n", - " ell__lt=self.l_max)\n", - " s.keep_indices(inds)\n", - " ls, cl, win = s.get_ell_cl('cl_00',\n", - " self.map_name,\n", - " self.map_name,\n", - " return_windows=True)\n", - " self.leff = ls\n", - " self.data = cl\n", - " self.cov = s.covariance.covmat\n", - " self.invcov = np.linalg.inv(self.cov)\n", - "\n", - " # Read bandpower window functions\n", - " self.ls_all = win.values\n", - " self.l_ls_all = np.log(self.ls_all)\n", - " self.windows = win.weight.T\n", - "\n", - " # Read beam and resample\n", - " t = s.get_tracer(self.map_name)\n", - " beam_f = interp1d(t.ell, t.beam_ell,\n", - " bounds_error=False,\n", - " fill_value=0)\n", - " self.beam2 = beam_f(self.ls_all) ** 2\n", - "\n", - " # Compute ell nodes\n", - " l10_lmax = np.log10(self.ls_all[-1])\n", - " n_sample = int(l10_lmax * self.nl_per_decade) + 1\n", - " self.ls_sample = np.unique(np.logspace(0,\n", - " l10_lmax,\n", - " n_sample).astype(int)).astype(float)\n", - " self.l_ls_sample = np.log(self.ls_sample)\n", - "\n", - " def _get_sz_model(self, cosmo):\n", - " model = SZModel()\n", - " model.hmf = ccl.halos.MassFuncTinker08(cosmo,\n", - " mass_def=self.mdef)\n", - " model.hmb = ccl.halos.HaloBiasTinker10(cosmo,\n", - " mass_def=self.mdef,\n", - " mass_def_strict=False)\n", - " model.hmc = ccl.halos.HMCalculator(cosmo,\n", - " model.hmf,\n", - " model.hmb,\n", - " self.mdef)\n", - " model.szk = SZTracer(cosmo)\n", - " return model\n", - "\n", - " def _get_theory(self, **pars):\n", - " results = self.provider.get_CCL()\n", - " cosmo = results['cosmo']\n", - " sz_model = results['sz_model']\n", - "\n", - " self.prof._update_bhydro(pars['b_hydro'])\n", - " pk2d = ccl.halos.halomod_Pk2D(cosmo,\n", - " sz_model.hmc,\n", - " self.prof,\n", - " lk_arr=self.lks,\n", - " a_arr=self.a_s,\n", - " get_2h=self.add_2h)\n", - " cls = ccl.angular_cl(cosmo, sz_model.szk, sz_model.szk,\n", - " self.ls_sample,\n", - " p_of_k_a=pk2d)\n", - " clf = interp1d(self.l_ls_sample, np.log(cls),\n", - " bounds_error=False, fill_value=-200)\n", - " cls = np.exp(clf(self.l_ls_all)) * self.beam2\n", - " cls = np.dot(self.windows, cls)\n", - " return cls\n", - "\n", - " def logp(self, **pars):\n", - " t = self._get_theory(**pars)\n", - " r = t - self.data\n", - " chi2 = np.dot(r, self.invcov.dot(r))\n", - " return -0.5 * chi2" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "import pyccl as ccl\n", - "\n", - "cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05,\n", - " h=0.7, n_s=0.95, sigma8=0.8,\n", - " transfer_function='bbks')\n", - "mdef = ccl.halos.MassDef(500, 'critical')\n", - "hmf = ccl.halos.MassFuncTinker08(cosmo, mass_def=mdef)\n", - "# hmb = ccl.halos.HaloBiasTinker10(cosmo, mass_def=mdef, mass_def_strict=False)\n", - "# hmc = ccl.halos.HMCalculator(cosmo,hmf,hmb, mdef)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[0;31mSignature:\u001b[0m \u001b[0mhmf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_mass_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcosmo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmdef_other\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mDocstring:\u001b[0m\n", - "Returns the mass function for input parameters.\n", - "\n", - "Args:\n", - " cosmo (:class:`~pyccl.core.Cosmology`): A Cosmology object.\n", - " M (float or array_like): halo mass in units of M_sun.\n", - " a (float): scale factor.\n", - " mdef_other (:class:`~pyccl.halos.massdef.MassDef`):\n", - " the mass definition object that defines M.\n", - "\n", - "Returns:\n", - " float or array_like: mass function :math:`dn/d\\log_{10}M` in units of Mpc^-3.\n", - "\u001b[0;31mFile:\u001b[0m ~/miniconda3/envs/soliket/lib/python3.8/site-packages/pyccl/halos/hmfunc.py\n", - "\u001b[0;31mType:\u001b[0m method\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "hmf.get_mass_function(cosmo, )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from soliket.tests.test_clusters import test_clusters" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[prior] *WARNING* No sampled parameters requested! This will fail for non-mock samplers.\n", - "[camb] Importing *auto-installed* CAMB (but defaulting to *global*).\n", - "[camb] Initialized!\n", - "mock catalog\n", - "Ntot 368.36238138205863\n", - "Ntot 368.36238138205863\n" - ] - } - ], - "source": [ - "like = test_clusters()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "hmf_soliket = like._get_HMF()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "dndm_soliket = hmf_soliket.dn_dM(hmf_soliket.M, 500)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "import pyccl as ccl\n", - "\n", - "pars = {\n", - " \"ombh2\": 0.02225,\n", - " \"omch2\": 0.1198,\n", - " \"H0\": 67.3,\n", - " \"tau\": 0.06,\n", - " \"As\": 2.2e-9,\n", - " \"ns\": 0.96,\n", - " \"mnu\": 0.06,\n", - " \"nnu\": 3.046,\n", - "}\n", - "\n", - "h = pars['H0']/100\n", - "\n", - "cosmo = ccl.Cosmology(Omega_c=pars['omch2']/h**2, \n", - " Omega_b=pars['ombh2']/h**2,\n", - " h=h,\n", - " n_s=pars['ns'], A_s=pars['As'])\n", - "mdef = ccl.halos.MassDef(500, 'critical')\n", - "hmf = ccl.halos.MassFuncTinker08(cosmo, mass_def=mdef)\n", - "# hmb = ccl.halos.HaloBiasTinker10(cosmo, mass_def=mdef, mass_def_strict=False)\n", - "# hmc = ccl.halos.HMCalculator(cosmo,hmf,hmb, mdef)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.598983920243067e-05" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hmf.get_mass_function(cosmo, 1e14, 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "def z_to_a(z):\n", - " return 1 / (1 + z)\n", - "\n", - "dndm_ccl = hmf.get_mass_function(cosmo, hmf_soliket.M, z_to_a(0))" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.loglog(hmf_soliket.M, dndm_soliket[:,0]);\n", - "plt.loglog(hmf_soliket.M, dndm_ccl)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 ,\n", - " 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85, 0.9 , 0.95, 1. , 1.05,\n", - " 1.1 , 1.15, 1.2 , 1.25, 1.3 , 1.35, 1.4 , 1.45, 1.5 , 1.55, 1.6 ,\n", - " 1.65, 1.7 , 1.75, 1.8 , 1.85, 1.9 , 1.95])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hmf_soliket.zarr" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(111, 40)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dndm_soliket.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "hmf" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[model] *WARNING* Ignored blocks/options: ['modules']\n", - "[prior] *WARNING* No sampled parameters requested! This will fail for non-mock samplers.\n", - "[camb] Importing *auto-installed* CAMB (but defaulting to *global*).\n", - "[camb] Initialized!\n", - "mock catalog\n", - "[model] *ERROR* Could not find anything to use input parameter(s) {'num_massive_neutrinos'}.\n" - ] - }, - { - "ename": "LoggedError", - "evalue": "Could not find anything to use input parameter(s) {'num_massive_neutrinos'}.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mLoggedError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mcobaya\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mget_model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mmodel_fiducial\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minfo_fiducial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0mlnl\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel_fiducial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloglikes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/soliket/lib/python3.8/site-packages/cobaya/model.py\u001b[0m in \u001b[0;36mget_model\u001b[0;34m(info)\u001b[0m\n\u001b[1;32m 103\u001b[0m yaml_dump(sort_cosmetic(updated_info)))\n\u001b[1;32m 104\u001b[0m \u001b[0;31m# Initialize the parameters and posterior\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 105\u001b[0;31m return Model(updated_info[_params], updated_info[kinds.likelihood],\n\u001b[0m\u001b[1;32m 106\u001b[0m \u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_prior\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkinds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtheory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[0mpackages_path\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_packages_path\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtiming\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mupdated_info\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_timing\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/miniconda3/envs/soliket/lib/python3.8/site-packages/cobaya/model.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, info_params, info_likelihood, info_prior, info_theory, packages_path, timing, allow_renames, stop_at_error, post, prior_parameterization)\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;31m# Assign input/output parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 150\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_assign_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minfo_likelihood\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minfo_theory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 151\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_dependencies_and_providers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 152\u001b[0m \u001b[0;31m# Add to the updated info some values that are only available after initialisation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 153\u001b[0m self._updated_info = recursive_update(\n", - "\u001b[0;32m~/miniconda3/envs/soliket/lib/python3.8/site-packages/cobaya/model.py\u001b[0m in \u001b[0;36m_set_dependencies_and_providers\u001b[0;34m(self, manual_requirements)\u001b[0m\n\u001b[1;32m 642\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_unassigned_input\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdifference_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mdirect_param_dependence\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 643\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_unassigned_input\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 644\u001b[0;31m raise LoggedError(\n\u001b[0m\u001b[1;32m 645\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Could not find anything to use input parameter(s) %r.\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 646\u001b[0m self._unassigned_input)\n", - "\u001b[0;31mLoggedError\u001b[0m: Could not find anything to use input parameter(s) {'num_massive_neutrinos'}." - ] - } - ], - "source": [ - "import numpy as np\n", - "import cobaya\n", - "\n", - "#fiducial_params = {\n", - "# \"ombh2\": 0.02225,\n", - "# \"omch2\": 0.1198,\n", - "# \"H0\": 67.3,\n", - "# \"tau\": 0.06,\n", - "# \"As\": 2.2e-9,\n", - "# \"ns\": 0.96,\n", - "# \"mnu\": 0.06,\n", - "# \"nnu\": 3.046,\n", - "# \"num_massive_neutrinos\": 3,\n", - "# }\n", - "\n", - "fiducial_params = {'omch2': 0.125, #FOR Testing against NEMO\n", - " 'ombh2': 0.02225,\n", - " 'H0': 70.,\n", - " 'ns': 0.95,\n", - " 'As': 1.88e-9,\n", - " 'mnu': 0.0,\n", - " 'tau': 0.06,\n", - " 'nnu': 3.046,\n", - " 'num_massive_neutrinos':0}\n", - "\n", - "info_fiducial = {\n", - " \"params\": fiducial_params,\n", - " \"likelihood\": {\"soliket.ClusterLikelihood\": {\"stop_at_error\": True,}},\n", - " \"theory\": {\n", - " \"camb\": {\n", - " \"extra_args\": {\n", - " \"accurate_massive_neutrino_transfers\": True,\n", - " \"redshifts\": np.linspace(0, 2, 41),\n", - " \"nonlinear\": False,\n", - " \"kmax\": 10.0,\n", - " \"dark_energy_model\": \"ppf\",\n", - " }\n", - " }\n", - " },\n", - " 'modules': '/Users/nab/Repos/cobaya_modules/'\n", - "}\n", - "\n", - "from cobaya.model import get_model\n", - "\n", - "model_fiducial = get_model(info_fiducial)\n", - "\n", - "lnl = model_fiducial.loglikes({})[0]\n", - "\n", - "#assert np.isfinite(lnl)\n", - "\n", - "print (lnl)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3201.11782" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "3.20111782e+03 " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "def to_array(s):\n", - " return np.array(s[1:-1].split(),dtype=float)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "cob = to_array('''[1.91779243e+03 2.02043522e+03 2.12855762e+03 2.24244963e+03\n", - " 2.36241634e+03 2.48877875e+03 2.62187453e+03 2.76205814e+03\n", - " 2.90970115e+03 3.06519399e+03 3.22894690e+03 3.40139093e+03\n", - " 3.58297892e+03 3.77418527e+03 3.97550527e+03 4.18745804e+03\n", - " 4.41058787e+03 4.64546533e+03 4.89268844e+03 5.15288194e+03\n", - " 5.42669391e+03 5.71480064e+03 6.01790860e+03 6.33675557e+03\n", - " 6.67211169e+03 7.02477837e+03 7.39558064e+03 7.78537346e+03\n", - " 8.19504490e+03 8.62551693e+03 9.07774596e+03 9.55272067e+03\n", - " 1.00514449e+04 1.05749451e+04 1.11242775e+04 1.17005267e+04\n", - " 1.23048059e+04 1.29382521e+04 1.36019888e+04 1.42971316e+04\n", - " 1.50248051e+04 1.57861398e+04 1.65822683e+04 1.74143183e+04\n", - " 1.82833544e+04 1.91903699e+04 2.01363175e+04 2.11221033e+04\n", - " 2.21485784e+04 2.32165276e+04 2.43266008e+04 2.54792770e+04\n", - " 2.66749101e+04 2.79137192e+04 2.91957749e+04 3.05209844e+04\n", - " 3.18890065e+04 3.32991725e+04 3.47505614e+04 3.62419926e+04\n", - " 3.77720101e+04 3.93388662e+04 4.09403760e+04 4.25738469e+04\n", - " 4.42362560e+04 4.59240163e+04 4.76331064e+04 4.93588929e+04\n", - " 5.10982056e+04 5.28417581e+04 5.45838221e+04 5.63176167e+04\n", - " 5.80352782e+04 5.97262636e+04 6.13841174e+04 6.29975068e+04\n", - " 6.45553581e+04 6.60468956e+04 6.74577059e+04 6.87752551e+04\n", - " 6.99847667e+04 7.10720822e+04 7.20214786e+04 7.28172055e+04\n", - " 7.34432459e+04 7.38835866e+04 7.41227154e+04 7.41457834e+04\n", - " 7.39392103e+04 7.34913294e+04 7.27928765e+04 7.18378044e+04\n", - " 7.06240224e+04 6.91542061e+04 6.74366392e+04 6.54858826e+04\n", - " 6.33234412e+04 6.09780869e+04 5.84858334e+04 5.58895332e+04\n", - " 5.32378205e+04 5.05840145e+04 4.79630796e+04 4.54224823e+04\n", - " 4.30385157e+04 4.08557009e+04 3.88968418e+04 3.71592962e+04\n", - " 3.56181247e+04 3.42350631e+04 3.29663004e+04 3.18098809e+04\n", - " 3.05843590e+04 2.92501650e+04 2.77064598e+04 2.59132781e+04\n", - " 2.39074933e+04 2.17954123e+04 1.97133494e+04 1.77946499e+04\n", - " 1.61557214e+04 1.48721871e+04 1.39382623e+04 1.32485331e+04\n", - " 1.26198168e+04 1.18527091e+04 1.08509723e+04 9.69437476e+03\n", - " 8.55992287e+03 7.63650650e+03 7.01472218e+03 6.58542901e+03\n", - " 6.15596301e+03 5.58909113e+03 4.93536714e+03 4.36863082e+03\n", - " 3.98167143e+03 3.68399492e+03 3.34031328e+03 2.95568751e+03\n", - " 2.63780905e+03 2.40219255e+03 2.16883372e+03 1.92501648e+03\n", - " 1.72420458e+03 1.55354656e+03 1.38366898e+03 1.23456422e+03\n", - " 1.10486489e+03 9.82938251e+02 8.76280481e+02 7.79834652e+02\n", - " 6.93233007e+02 6.16067978e+02 5.46779357e+02 4.85137772e+02\n", - " 4.30017945e+02 3.80822296e+02 3.36995234e+02 2.98014280e+02\n", - " 2.63374515e+02 2.32611045e+02 2.05306795e+02 1.81088539e+02\n", - " 1.59624748e+02 1.40617952e+02 1.23800464e+02 1.08931516e+02\n", - " 9.57944513e+01 8.41952818e+01 7.39606670e+01 6.49358828e+01\n", - " 5.69829716e+01 4.99789879e+01 4.38144578e+01 3.83919637e+01\n", - " 3.36248822e+01 2.94363101e+01 2.57580338e+01 2.25295874e+01\n", - " 1.96974140e+01 1.72141215e+01 1.50378042e+01 1.31314262e+01\n", - " 1.14622810e+01 1.00015115e+01 8.72367363e+00 7.60634294e+00\n", - " 6.62977051e+00 5.77657697e+00 5.03147658e+00 4.38103006e+00\n", - " 3.81343009e+00 3.31831045e+00 2.88657462e+00 2.51024377e+00\n", - " 2.18232329e+00 1.89668454e+00 1.64795992e+00 1.43144986e+00]''')\n", - "\n", - "szr = to_array('''[3.99959066e+02 4.21378684e+02 4.43944152e+02 4.67716481e+02\n", - " 4.92759892e+02 5.19142053e+02 5.46934224e+02 5.76211346e+02\n", - " 6.07052230e+02 6.39539788e+02 6.73761212e+02 7.09808222e+02\n", - " 7.47777240e+02 7.87769667e+02 8.29892034e+02 8.74256282e+02\n", - " 9.20979975e+02 9.70186506e+02 1.02200542e+03 1.07657251e+03\n", - " 1.13403026e+03 1.19452802e+03 1.25822238e+03 1.32527715e+03\n", - " 1.39586363e+03 1.47016101e+03 1.54835636e+03 1.63064521e+03\n", - " 1.71723131e+03 1.80832725e+03 1.90415433e+03 2.00494291e+03\n", - " 2.11093202e+03 2.22236882e+03 2.33950982e+03 2.46262043e+03\n", - " 2.59197553e+03 2.72785797e+03 2.87055917e+03 3.02037819e+03\n", - " 3.17762108e+03 3.34260128e+03 3.51563765e+03 3.69705536e+03\n", - " 3.88718255e+03 4.08635126e+03 4.29489467e+03 4.51314609e+03\n", - " 4.74143838e+03 4.98010073e+03 5.22945874e+03 5.48982857e+03\n", - " 5.76151810e+03 6.04482211e+03 6.34002097e+03 6.64737481e+03\n", - " 6.96711777e+03 7.29945766e+03 7.64456484e+03 8.00257470e+03\n", - " 8.37357443e+03 8.75760361e+03 9.15464354e+03 9.56461105e+03\n", - " 9.98735657e+03 1.04226508e+04 1.08701852e+04 1.13295465e+04\n", - " 1.18002235e+04 1.22815761e+04 1.27728351e+04 1.32731059e+04\n", - " 1.37813561e+04 1.42964163e+04 1.48169507e+04 1.53414691e+04\n", - " 1.58682528e+04 1.63953844e+04 1.69207645e+04 1.74421085e+04\n", - " 1.79569088e+04 1.84623275e+04 1.89553252e+04 1.94326115e+04\n", - " 1.98907127e+04 2.03258626e+04 2.07340482e+04 2.11110486e+04\n", - " 2.14523661e+04 2.17534120e+04 2.20093514e+04 2.22153670e+04\n", - " 2.23665450e+04 2.24580787e+04 2.24853736e+04 2.24441070e+04\n", - " 2.23305342e+04 2.21415541e+04 2.18749713e+04 2.15298022e+04\n", - " 2.11063629e+04 2.06067485e+04 2.00348197e+04 1.93965339e+04\n", - " 1.87000904e+04 1.79557425e+04 1.71757830e+04 1.63744588e+04\n", - " 1.55671968e+04 1.47699834e+04 1.39986753e+04 1.32679402e+04\n", - " 1.25901552e+04 1.19742686e+04 1.14246773e+04 1.09401262e+04\n", - " 1.05129124e+04 1.01284973e+04 9.76586715e+03 9.39921540e+03\n", - " 9.00121925e+03 8.54819731e+03 8.02624443e+03 7.43761673e+03\n", - " 6.80300629e+03 6.15983533e+03 5.55452066e+03 5.02967760e+03\n", - " 4.61256052e+03 4.30514229e+03 4.08076831e+03 3.88899397e+03\n", - " 3.67147400e+03 3.38891165e+03 3.04581748e+03 2.69135197e+03\n", - " 2.38890399e+03 2.17480928e+03 2.03390299e+03 1.91027950e+03\n", - " 1.75082800e+03 1.55436243e+03 1.36977916e+03 1.23744874e+03\n", - " 1.14442938e+03 1.04645567e+03 9.29988839e+02 8.25070490e+02\n", - " 7.48608344e+02 6.79602744e+02 6.04786010e+02 5.39255810e+02\n", - " 4.86364586e+02 4.34525924e+02 3.86822224e+02 3.46462947e+02\n", - " 3.08584183e+02 2.74839080e+02 2.44870862e+02 2.17619114e+02\n", - " 1.93491423e+02 1.71746051e+02 1.52405141e+02 1.35114082e+02\n", - " 1.19686669e+02 1.05941447e+02 9.37100091e+01 8.28346085e+01\n", - " 7.31720589e+01 6.45935622e+01 5.69836560e+01 5.02384125e+01\n", - " 4.42642726e+01 3.89770959e+01 3.43013447e+01 3.01692810e+01\n", - " 2.65202037e+01 2.32998216e+01 2.04596366e+01 1.79563649e+01\n", - " 1.57514191e+01 1.38104293e+01 1.21028025e+01 1.06013436e+01\n", - " 9.28190080e+00 8.12303818e+00 7.10575194e+00 6.21320868e+00\n", - " 5.43050691e+00 4.74446732e+00 4.14344229e+00 3.61714382e+00\n", - " 3.15649242e+00 2.75348061e+00 2.40105002e+00 2.09298374e+00\n", - " 1.82380905e+00 1.58870882e+00 1.38344832e+00 1.20430917e+00]''')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD8CAYAAACSCdTiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqoklEQVR4nO3dd3iUVdrH8e+dRiAUAwktARIgJASChF4UkEUFXxAVRRAQEAuLsuoq4tpdd1csFFEsSBNQENRFVOyIiNQQek3ooYYASUgh7bx/wPqyvJSEzMyZmdyf68p1MWeemfmdGbhzOM+Z84gxBqWUUt7Jx3YApZRSzqNFXimlvJgWeaWU8mJa5JVSyotpkVdKKS+mRV4ppbyYn+0AACEhISYiIsJ2DKWU8ihr1649bowJvdwxblHkIyIiSEhIsB1DKaU8iojsu9IxOl2jlFJeTIu8Ukp5MatFXkR6icjk9PR0mzGUUsprWZ2TN8Z8BXzVqlWrB2zmUErZl5+fT0pKCrm5ubajuJ3AwEDCw8Px9/cv8WPd4sSrUkqlpKRQqVIlIiIiEBHbcdyGMYa0tDRSUlKIjIws8eN1Tl4p5RZyc3OpVq2aFvgLiAjVqlW76v/h6EheeR1jDGmnz3DqxDFyMtLIyclGCnLw8fFF/IMoX7EyVUNrUq1KZfx8dZzjTrTAX1xp3hct8spjGWM4eCyNg1uXk7V/PXJ8B9dk7yW04CihnCJE8i/7+CMmmFTfGpyqGMWZmi2pHnsdsU1b4Ofn66IeKE81ZMgQevbsyZ133mk7yhVpkVcewxjD7n37SUn4hqL9K6mRsZFGZh/hUgRAJkGkBtbjZJUWnKxcC5/KNfGtUJWAwAqIXyCFRYVIfg652RkUpB/BN30/5TL3E5/xMxUzvoKdcHBBKNuqdCao+e20vK47Af76T0R5Nv0brNxabl4+G1cv4dSGb6h1fBlNipJpIIZsAjkUFMv2mt2oUL89tWM7UOmamlS6mv/WFhWRmbKFfet+xif5ezqlLyDg18/Y/2tNtte5m9hbRhBeq6bjO6fczsyZM3nzzTcREZo1a8Yrr7zCfffdx/HjxwkNDWX69OnUrVsXgJ9++okxY8aQkZHBuHHj6NmzJ3v37mXQoEFkZWUB8M4779ChQwfuvfde7rjjDm677TYABgwYQN++fbn22msverwjic3L/4lIL6BXw4YNH0hKSrKWQ7mX3LwC1iz/mbwN84k9sZhakkaREfaVj+F03RuoHt+LGtFtwcc50yqFOensWDqPcuum0yB3C1mmHGtCbqf+bc9Rt04dp7ymgm3bttG4cWMAXv5qC1sPZTj0+WNrV+bFXk0uef+WLVu4/fbbWb58OSEhIZw4cYLBgwdz5513MnjwYKZNm8bChQtZsGABQ4YM4ciRIyxatIhdu3Zxww03kJycTFFRET4+PgQGBpKUlET//v1JSEjg119/Zfz48SxYsID09HSaN29OUlISeXl5Fz3+Su/Pf4jIWmNMq8v1W9fJK7dgjGHzpvWkLptG1LHvuZ6j5ONHUuW2nGp6Gw3a305k5cvuw+QwvuWrEHvzA3DzAxzfuZqD371Jp+OfkjXlS36qeQ8t+j1H1eCqLsmiXGfx4sXcddddhISEAFC1alVWrFjBF198AcCgQYN46qmn/ji+b9+++Pj4EBUVRf369dm+fTuRkZE88sgjrF+/Hl9fX3bu3AlA586dGTFiBKmpqXz++ef06dMHPz8/srKyLnq8I+l0jbLqZHoGa7+fSdXtc2lRtIlCIyRXbElSs79S/7q7iQ0KtpovpFEbQhrNI23Peo4ueIFuR6dy+K0FLG72DJ1uHaonaZ3kciNud3HhihcRYfz48dSoUYMNGzZQVFREYGDgH/ffe++9zJ49m7lz5zJ9+nSAyx7vKLp+TFmxbdsmlrz9IDIuhm5bnyVMUtkc/RfOjNxI9Kifibp5OL6WC/z5qkU2J/bxhey/7d/k+Veh68Yn2PDajezaucl2NOUgXbt2Zf78+aSlpQFw4sQJOnTowNy5cwH4+OOPuf766/84fv78+RQVFbFr1y52795NdHQ06enp1KpVCx8fH2bNmkVhYeEfxw8ZMoQJEyYAEBsbC3DZ4x1FR/LKZfLyC1m55Cv813xAmzMriELYFtyFzOsfok78TdTwcf8xR93mXTFxq9ny5ViiN07A9+OuLI0cTrt7nicgIMB2PFUKTZo04dlnn6Vz5874+voSHx/P22+/zdChQ3njjTf+OPH6H3Xr1qVNmzZkZGTw/vvvExgYyIgRI+jTpw8zZ86ke/fuBAUF/XF8jRo1aNy48R8nX4HLHu8oVk+8/kerVq2M7ifvvU5nZ7P268nU3DaDaLOHdCqxL+IuIm95lErVI2zHu2onj+wlZfYI4k7/TpJPfUyviTSKv/7KD1QXdbETi94kOzubuLg4EhMTqVKlSokff7UnXt1/6KQ8VtrJkyz+6O+cfr0pnbe+SAXfQna0/geV/raDZkPGe3SBBwiuGUHcE9+wscPbBBedoMGCXqx4bzjZp3VXVfXffvrpJxo3bszIkSOvqsCXhk7XKIc7fPQomxeMo8WhT+gqGSQFxpHVeRwN2vUGb/vaugjNbrqXjDa3kDjrcdofncOhsT+T3HkMzbr0sZ1OuYlu3bqxb98VL+LkFFrklcOkHjvC1i9eJf7wPG6UbLZXaktOt9FENf+T7WhOV/maEFqPnMW2ld8S9MMTNFtyHwmJn1Cn/wRq1NK19coep0zXiEiQiCSISE9nPL9yL2kn0lgyeRTlJsXT+cgM9ldpzdF+3xHz5A+El4ECf77G7XpQ46k1rAwfRrP0Xwh4vx2Lp79AeoZjv9ijVHEVq8iLyDQROSYimy9o7y4iO0QkWUSePu+u0cA8RwZV7ufkqXQWT3seeetauhyazP7K8Rzu/zNN/7qQGjHtbcezplxgEO3uH0fawJ85VjGarvve4sy4Zvw66x+kZ2bajqfKmOKO5GcA3c9vEBFfYBLQA4gF+otIrIjcCGwFjjkwp3IjWdnZ/Dzzn+SPv5au+ydyLCiag3d+TdMnFlEr+rIn+suUWlHxRI9azJ6e8zhVLpzOu94g782m/Dr9eU6cPGE7niojijUnb4xZKiIRFzS3AZKNMbsBRGQu0BuoCARxtvDniMgiY0zRhc8pIg8CDwJ/bPij3Ft+QQGrF35AxMYJ/IljJJdvSt7Nk4mJv8l2NLcW2epmaHkTe9Z+x5mfX6fzvomkT5jK0vD+NO79JKHVa9mOqLxYaU68hgEHzrudArQ1xjwCICJDgOMXK/AAxpjJwGQ4u06+FDmUkxljSFiygCq/vULHol3s9mtIctfXadj+Nu9bLeMsIkS26gGterB/46+k//AanQ5OIWvSbJbVvJOYvn8npFo12ymVAxUUFODnZ39ti9MSGGNmXOmY83ahdFYMVUpbN6wmZ9GztD6zmqMSyqa2b9L05vsQJ+0AWRbUbdYZmnUmZfsajn/7Kh2OfMzRt79lxXVv0L6bLru0KSsri759+5KSkkJhYSGDBg1izpw5ABQWFrJ582aMMXz44YdMnjyZvLw8GjZsyKxZs6hQoQJDhgwhMDCQdevW0bFjR8aNG2e5R6Ur8geB89eGhZ9rKzbdhdJ9HTywl93zn6VD+jfkSHnWRT9O3B1PUaNcBdvRvEZ4TGvCY74gZcMvmIUjafPbMH7Zu4ZOQ/+Fb1m/LOG3T8MRB+8LVDMOeoy57CHfffcdtWvX5ptvvgHO7i0zevRoAEaNGkX37mdPTd5xxx088MDZsvXcc88xdepURo4cCZy9IPny5cvx9XWPgVBp/iatAaJEJFJEAoB+wMKSPIGI9BKRyenp+g1Bd5F1OpNlU5/imiltaJf+LRtr90UeXU98/5fw0wLvFOHX3kDNJ1ewJfhP3JDyHr+/PZSCggLbscqkuLg4fvzxR0aPHs1vv/32x7dTP/30UxITExkz5uwvic2bN3P99dcTFxfHxx9/zJYtW/54jrvuusttCjxwdr71Sj/AHOAwkM/Zufdh59pvAXYCu4Bni/NcF/tp2bKlUXYVFhSalV9PMQdfbGDMi5XNhjf/xxzbs8V2rLKlqMism/KwMS9WNr+NG2gKCwptJ3KprVu32o5gjDEmLS3NzJo1y3Tq1Mm8/PLLZtOmTSYmJsYcO3bsj2MiIiLM+vXrjTHGTJ8+3QwePNgYY8zgwYPN/PnznZLrYu8PkGCuUF+Lu7qm/yXaFwGLSv2bRlm1fcMK8r9+irb5G9njG8mOGyfSrN0ttmOVPSI0v+9t1k7z4boDH/H79FF0vH+s7VRlyqFDh6hatSoDBw7kmmuuYcqUKcyfP5+ZM2cSGvp/F63JzMykVq1a5Ofn8/HHHxMWFmYx9eVZPfWrJ17tSj16iJ1z/0a7E1+SKUEkxj1P896P4uPnbzta2SVCi6ETSHg7lY4pU0hY2JBWt/7ZdqoyY9OmTYwaNQofHx/8/f3p2bMnixcv/mP+HWD9+vW88sortG3bltDQUNq2bUumG3/JTbcaLoPy8vJYOf9Nrt35DkHksKFmH6L7v0rFa1xzeT11ZXlnzpA0thsNz2xjT8+5xLTuZjuS03n7VsOlpVsNq2LZvOxrUsa0olPSaxwq34hjA36i5Z+naIF3MwHlyhH24HyO+1Qj9Jv7OLJfL3Svro7VIq+ra1wn9dA+1oztQ9OfBlDe5LDpukk0Hv0LtRu1tB1NXcI1ITUp6Pcp/iaf7I/uIkf3qVdXwWqRN8Z8ZYx50NWb6Jcl+fl5rPj4HwR+0JZrM5awss79BI9aR1y3gfptVQ9QL7o5u7u8Q72Cvex8/x5MkeOvAaq8m07XeLGtq35i/6ttaJ/0BnvLNyH13iW0GzaWwAoVbUdTJdD8hj4sj3qSa08vI3H6E7bjOJU7nCN0R6V5X3S6xgsdP3qIlRPuIfbbPlQqymB9+4k0fepHwhrE2Y6mrtJ19zzD79f0ouWB6fz22du24zhFYGAgaWlpWugvYIwhLS2NwMDAq3q8rq7xIoWFhaz+fDyNt44nyOSQWLs/cQP+SYWK19iOphwgP+8MyeNuplHOepbWf4LOg57Dx8d7ptzy8/NJSUkhNzfXdhS3ExgYSHh4OP7+/728uTira7TIe4kd637DfPMEMQU72BYQR9Adb1E3Rk+qepu87Ex2vNePuMxlrKrQifB73iEsvJ7tWMoSXUJZBmSeOs6qd+6j4YJehBYcIbHla8Q8vVQLvJcKqFCJpo8vJDHqL8RnLafChx34ce5E8vL1hKy6OKsj+fO+8fpAUpKuAy4JU1TE+u9nUGfVywSbdBKq9yF2wGtUuibEdjTlIqm7N5AxbzgNcreyyr81tQe8R52IKNuxlAvpdI2XOrJvB8fmPkKznNUk+TagqOdbRMdfbzuWsqGokB0L36Tu+jfJJIgTfT4jJk4vwVhW6HSNlynIz2PV7JeoPO16GmRvYEXUk0Q+vVILfFnm40v0baM5NeAHfDGEfH4He5O32k6l3IgWeQ+RlLiE/WPa0DZ5PDsqtCDjvmW0H/A8fv4BtqMpN1ArKp7ce74kgALOfDKQ7OzTtiMpN6FF3s1lpp9g1aRhNPjyNioWppPYbiLNRy2iVr1GtqMpNxPWqDkHO48lumgX66eOtB1HuQn9MpQbS/x+FjnjW9L62OesDr2DwMcSaNF9MOKjv5vVxTW+oT8JNe+mQ9oXJPzyb9txlBvQE69u6MiBZA7PGUl89nJ2+0SQf8t4olt1tR1LeYi8nNMce6M1UlRA+UdXUTW4qu1Iykn0xKuHKcjPZ+Un/6DSlI7EZCWwssGj1Hl6tRZ4VSIB5StS0OsdaplUNs14zHYcZZkWeTeRtH4Ze8a0o93ON0guH8fJoctoN+jv+AeUsx1NeaCI+D+xMfweOqd/yfKfvrAdR1mkRd6y7NOnWPnecOr/uydVC4+T2GY8zZ76gdoR0bajKQ/XdNDrHPQNI3rZY+zbpcsqyyot8hZtXvIZGWNb0e7oHBJCbsXv0bW0uOU+PbGqHMIvsCLc/Qn+FGBm3cnBfbtsR1IWaDWx4FTqIdaOv5OmS4aRSzm2dJ9H25EzqRKsWxIoxwpr1JyTvaYTShrlpndly4rvbEdSLqZF3oVMURGJX70Pk9oQd2oxy8Pvp+ZTa2jS7mbb0ZQXq9fyZtL6LSJXytPou3tY8enrumd7GaLr5F3kyP6dbH7jJlqsHc0RvzAO9P2eDvePJbB8BdvRVBlQN6YllR9dxrYKLWm/7Z/88tFLtiMpF9F18k5WWFDA2vmv0XT7WxhgY/RjtOn7FL5+frajqTKoqCCfrRP70DTjV1bFv0bb3sNtR1KloOvkLdu7dTW7xrSnzY7XSSrfjPT7ltH+nme0wCtrfPz8iX74U7YHNKVJ4ovsSdpsO5JyMi3yTnAmN4uVUx4n7NPuhBYcZk3L188ui9T9ZpQb8C9XntDBH2FEyJ33AIUFBbYjKSfSIu9g21d/z5HX29AuZRrrqnTDjFhN614P6bJI5VaqhTVkZ8uXaJy/lcQ5L9qOo5xIK4+DZKafYPU7Q4hZ1JeAojNs6DKNNn+dR9XqtW1HU+qiWvzPg6wO6kLz5Pc4uHWF7TjKSbTIO8D6Hz8hZ3xLWqYuYEX1u6n8RALXduljO5ZSlyU+PkQM/oATUgU+v5+8HN2D3htpkS+F40cOsPbN3jT//c+c9qlM8q3/pv2IyQRVusZ2NKWKpXr1miR3fIOwwhTWTH5Y1897IS3yV8EUFbH63xPxf78tcZnLWBHxZ8JHryK65Q22oylVYh1vvJO1YQPoeHIBSyc/gSkqsh1JOZDD1/KJSGPgUSAE+NkY856jX8Omg7u3cPLTEbQ5s56t/k0JunMS7aOb246lVKm0uG8i6949RefDU/llsqHLQ+MQEduxlAMUayQvItNE5JiIbL6gvbuI7BCRZBF5GsAYs80YMxzoC3R0fGQ7CvLzWDHrRap+1IV6uTtY1eR5Yp5eSj0t8MoLiK8fzR+exYaQ/+GGI9P4fe7rtiMpBynudM0MoPv5DSLiC0wCegCxQH8RiT13363AN8AihyW1KHnD7+wd0472uyawPagVOQ+uoO1dT+Lj62s7mlIOIz6+xA3/iE0V2tFu+xg2rFpsO5JygGIVeWPMUuDEBc1tgGRjzG5jTB4wF+h97viFxpgewIBLPaeIPCgiCSKSkJqaenXpnSwn6zQrPniEiC96ElyYxrq2E2j+5DdUD4u0HU0pp/Dx86fBQx9z0ieYyt+OJD0j03YkVUqlOfEaBhw473YKECYiXURkooh8wGVG8saYycaYVsaYVqGhoaWI4Rybl31F2putaH94Fuuq9sDvLwnE9xiqX2pSXq9ClRAybxpPJCmsnfGk7TiqlBx+4tUYswRYUpxjRaQX0Kthw4aOjnHV0k+ksn3WY7Q9+TUHpSabu82i9XW32o6llEvVb9+bDRv60OXwp6z8pSftbuhlO5K6SqUZlh4E6px3O/xcW7EZY74yxjxYpUqVUsRwDGMMa7+dQf7EVrQ8sYiVtQZRbVQCTbXAqzIqdvAEjvrWoM6vj5N6tET/tJUbKU2RXwNEiUikiAQA/YCFJXkCd9lP/ujBPax7oyctVz1Kum819vX5inYPvUNghUpWcyllk3/5yhTcPoVq5hTHptxFbm6O7UjqKhR3CeUcYAUQLSIpIjLMGFMAPAJ8D2wD5hljtpTkxW2P5IsKC1k5fywVJrcnNmsVqxo8Rr2nV9Kg2XVW8ijlburEXc+2tmNokr+FDe8P1S9KeaAye9GQfTvWc/qzh2mSv5kt5ZoT3Pddajdo4tIMSnmKVVOfpO2BD1nR8HHaD3zJdhx1jttfNMTGdE3emTMsn/43an7SjTr5e0i49hViR/+iBV6py2gz9DUSK3amddJbrF/xs+04qgTK1Eh++9ol+H/zKA2K9pJYqQt1B7xNSM26Tn9dpbxBTsYJMse3Jtf4U+nRFQQHB9uOVOa5/UjeVcyZ06x4dzhRC2+jclEGG697lxZPfKkFXqkSKF+5Klm3TCLcHGHT9JG6Y6WH8P7pmuSfkffa0/7YHBJDe1P+8bU063bJL+IqpS4jsnV3NtYdRKeMr1i2aLbtOKoYvHe6JvsEfP8sbPgEqjXE9JqIRHjNfmlKWVOYl8uB19tTOT+VzCG/UC8yynakMqtsTtcYA5s+g3daw6Z50GkUDP9dC7xSDuIbEEiFez4iUPLImD2Y7Nxc25HUZXjXdE16CszpB58Pg+B68NBS6Poc+Ac65vmVUgBUr9+M/e3/SVzhFpZP0f1t3JnVIu+wL0MVFcHqD2FSW9izFG5+FYb9CDV0WaRSzhJz8wNsqtGbbsdnsfrHebbjqEvw/OmaY9th2s2w6Emo0wZGrIT2I8BH93pXytlihr7HXt8IGvz+JMeOpNiOoy7Cs4v8minw/nWQlgS3fwADvzg7TaOUcgn/wCB875pKJZPF/o8e1G0P3JBnz8lXi4LY3vDwGri2H+g1KZVyuToxrdgU/Rda5fzO8i/esR1HXcB7l1AqpVzGFBaw4/UuhOcmk3bvEuo1iLEdqUwom0solVIuJ75+hAycBgLpc+8nv6DAdiR1jhZ5pZRDhNRpxO6Wz9EsfxO/z37Fdhx1jhZ5pZTDNOv5MJsrdqT9nkls3bDKdhyFp594VUq5FxHqDZ1CtpTH/8uHyMrOtp2ozPOOL0MppdxGpWq1OdblDaKK9rB6xlO245R5Ol2jlHK46C792BDSk05HZ5Ow7Fvbcco0LfJKKaeIGfoOqb6h1PjpMdJOpNmOU2ZpkVdKOUW5oGDO9JxEmDnK5ul/0YuMWKJFXinlNPVa3MSmeoPonPk1vy36xHacMkmLvFLKqeIGvs5+vwgar36GgwcP2I5T5miRV0o5lU9Aecr1ncI1ZLJ/5nAKC3UTM1fSdfJKKaer0ag1O2JH0v7MMn6Zr5uYuZKuk1dKuUSTO58nObApbba9yo4d22zHKTN0ukYp5RLi60fowGn4SRHZ8x4kNy/fdqQyQYu8UsplqoRHc6DNc8QXbmTJzH/YjlMmaJFXSrlUdI9H2FG5I10OTCJx7UrbcbyeFnmllGuJUHfIFM5IIBW+HsHp7BzbibyaFnmllMuVr1qb1C6vEWN2seajp23H8Wpa5JVSVjTsMoCN1bpz/ZGZbFz5k+04XkuLvFLKmqjB75PmU5Xg7x8h63SG7TheySlFXkRuE5EPReRTEbnJGa+hlPJ85SsHc/LGCdQxh1k/c7TtOF6p2EVeRKaJyDER2XxBe3cR2SEiySLyNIAxZoEx5gFgOHC3YyMrpbxJTIderK12K+2OzmHT6sW243idkozkZwDdz28QEV9gEtADiAX6i0jseYc8d+5+pZS6pMaD3yLNpypB3z5Kjl4y0KGKXeSNMUuBExc0twGSjTG7jTF5wFygt5z1GvCtMSbxYs8nIg+KSIKIJKSmpl5tfqWUF6hQuSonbniN+mY/a2Y9YzuOVyntnHwYcP7eoSnn2kYC3YA7RWT4xR5ojJlsjGlljGkVGhpayhhKKU8X0+ku1gd3p/2hmWxOXGY7jtdwyolXY8xEY0xLY8xwY8z7lzpOd6FUSp0v6t63yZSKBHw9kpycXNtxvEJpi/xBoM55t8PPtRWL7kKplDpfUHB1jnX6F42KdrNi9ou243iF0hb5NUCUiESKSADQD1hY3AfrSF4pdaGYrgPZVKULHVOmsG3TGttxPF5JllDOAVYA0SKSIiLDjDEFwCPA98A2YJ4xZktxn1NH8kqpi4m8911yJRCz4BHydEviUinJ6pr+xphaxhh/Y0y4MWbqufZFxphGxpgGxph/Oi+qUqqsqFgtjANtXyS2cDsr5/7LdhyPppf/U0q5pabdH2BzUDta73qHvUmbbMfxWHr5P6WUexKh9sD3KRBfMuc9TFFhoe1EHklH8kopt1W1ViQ7m40mLn8Dqz4fZzuOR9KRvFLKrbW47VE2l4snbstYDqfsth3H4+hWw0optyY+PlS9+118KeTQx49gjLEdyaNokVdKub3a9WPZHPVnWub8zppvP7Idx6PonLxSyiO0uPs59vjWJ3L1S5w8cdx2HI+hc/JKKY/g6x+A9H6bquYUW2c+bjuOx9DpGqWUx4hodh3rw/rT8dRCEpctsh3HI2iRV0p5lKYDx3BEqhP88yhOZ2XZjuP2dE5eKeVRylWoQma314g0KayZ/bztOG5P5+SVUh4nquMdbAy+kQ6HPtKdKq9Ap2uUUh6p/sC3yJVAihb8hYKCAttx3JYWeaWUR6pYLYz9rf5Gk8KtrJivWx5cihZ5pZTHanrLCLYFxtN8+zgO7tctDy5GT7wqpTyW+PgQ3O9d/Cng8NyRuuXBReiJV6WUR6sZEcumhg/RKnsZid/Pth3H7eh0jVLK48Xf/QJ7fCMIX/kCGeknbMdxK1rklVIezy+gHEW3jCfUnGTT7Kdtx3ErWuSVUl6hQcuuJIb2pt2xeWxN/M12HLehRV4p5TViBo4lXSrj881fyc/Ptx3HLWiRV0p5jYrXhJDS5jliCneyYv5Y23Hcgi6hVEp5lWY9HmB7+Xia73iLgwf22o5jnS6hVEp5FxGq9n2bQPLYP+exMr92XqdrlFJep3pkHFsaDKN99i+s/Okz23Gs0iKvlPJKzfq9zCGf2oT9/hwZpzNtx7FGi7xSyiv5BpQn9+Y3qMsREme/YDuONVrklVJeq37bnmwIvpH2h2eyc0ui7ThWaJFXSnm1yHsmkCcB5C54jKLCIttxXE6LvFLKq1UODSe52ZM0y9/Aii/fsx3H5bTIK6W8XvPbHiPJP4bGG8eQdvyo7TgupUVeKeX1xMeXcre/RWVzmp2zn7Adx6UcXuRFpL6ITBWRsr04VSnlVurGtmNd7X60P/UVW1b+YDuOyxSryIvINBE5JiKbL2jvLiI7RCRZRJ4GMMbsNsYMc0ZYpZQqjaYDxnCUapT/4Uny887YjuMSxR3JzwC6n98gIr7AJKAHEAv0F5FYh6ZTSikHKl+xCoc7vEz9on2smfea7TguUawib4xZClx4uZU2QPK5kXseMBfoXdwXFpEHRSRBRBJSU1OLHVgppUqj+Y0D2VS+Dc2S3uVwyh7bcZyuNHPyYcCB826nAGEiUk1E3gfiReRvl3qwMWayMaaVMaZVaGhoKWIopVQJiBBy1wT8KeDA3L/aTuN0Dj/xaoxJM8YMN8Y0MMa8erljdathpZQNteo3YWPEENqcXkzir1/ajuNUpSnyB4E6590OP9dWbLrVsFLKlmv7vcxhqUHwkmfIycmxHcdpSlPk1wBRIhIpIgFAP2BhSZ5AR/JKKVsCygdxqss/iDQprJ7zT9txnKa4SyjnACuAaBFJEZFhxpgC4BHge2AbMM8Ys6UkL64jeaWUTY0792VzxQ602jeZvXt22o7jFMVdXdPfGFPLGONvjAk3xkw9177IGNPo3Py79/4qVEp5rVr93sJXijgy769eeRUpvcarUqpMqxbeiG0NH6Bdzm+s8sKrSOk1XpVSZV6zvi9w0KcWtZa/QFZWlu04DqUjeaVUmecbUJ7sP71KPXOIhLmv2I7jUDqSV0opIKrj7Wys1Ik2+6eyb9c223EcRrcaVkqpc8L6TcAgpH7mPSdhtcgrpdQ51cIasDXqIVrlLGftT5/ajuMQOievlFLnad73WQ74hFFr+QvkZHv+SVidk1dKqfP4BQRy+k9jCDNHWTfnRdtxSk2na5RS6gKNO95KYqUbaLl/Bim7SvRFfrejRV4ppS6ibr/xFOJD6mdPePRJWJ2TV0qpiwgJi2Rz1HDic1awfvF823Gums7JK6XUJcT3fYYDPmGELHuB3Jxs23Guik7XKKXUJfgHBJLZ5RXqmMMkfOqZezBqkVdKqcuI7dSHjUEdiN/zIYf277Idp8S0yCul1BXU7DseP4o48OmTtqOUmJ54VUqpK6heL4ZNEUNom7WYxN++th2nRPTEq1JKFUOzfi9xVEKp/MuznMk7YztOsel0jVJKFUNA+YqcuO4FGhbtZeW8N23HKTYt8kopVUyNuw5ie/kWNE+axKGD+23HKRYt8kopVVwiBN85ngrksuvTp22nKRYt8kopVQI1GjRnS/jddExfxIZVi23HuSIt8kopVUIx/f7FSamC/w9PU1BQYDvOZekSSqWUKqHASsEcav00sYU7WPnvSbbjXJYuoVRKqavQtMeDJAU0pvGWsZw8cdx2nEvS6RqllLoK4uNLuVvHEmwy2PLJM7bjXJIWeaWUukp1m3ZkXWgv2qXOJ3nzattxLkqLvFJKlUJU/zfIkgrkLByFKSqyHef/0SKvlFKlULlaTZJi/0Jc3noSvvvIdpz/R4u8UkqVUvwdf2WPbwR1Vv+D7KwM23H+ixZ5pZQqJV8/f87c9Bo1Oc6GOS/bjvNftMgrpZQDxLTtTmKlrsQf+IhDe3fYjvMHLfJKKeUg4Xe/iUE4NH+U7Sh/cHiRF5EgEflIRD4UkQGOfn6llHJX1cMbsDT2ZUaf6MmyJPf4glSxiryITBORYyKy+YL27iKyQ0SSReQ/W7LdAXxmjHkAuNXBeZVSyq11vuMh8oOjePmrLeQX2l9SWdyR/Ayg+/kNIuILTAJ6ALFAfxGJBcKBA+cOK3RMTKWU8gyB/r483zOWpGOnmb1yn+04xSvyxpilwIkLmtsAycaY3caYPGAu0BtI4Wyhv+zzi8iDIpIgIgmpqaklT66UUm6qW+PqXB8Vwrgfd5J22u6lAkszJx/G/43Y4WxxDwO+APqIyHvAV5d6sDFmsjGmlTGmVWhoaCliKKWUexERXuwVS05eIW/+sNNqFoefeDXGZBljhhpj/myM+fhyx+pWw0opb9WweiUGd4hg7pr9bD5or8aVpsgfBOqcdzv8XFux6VbDSilv9mi3KKoFBfDSwi0YY6xkKE2RXwNEiUikiAQA/YCFJXkCHckrpbxZ5UB/Rt0cTcK+kyzccMhKhuIuoZwDrACiRSRFRIYZYwqAR4DvgW3APGPMlpK8uI7klVLe7q6WdWgWXoVXF20n64zrLxVY3NU1/Y0xtYwx/saYcGPM1HPti4wxjYwxDYwx/3RuVKWU8jw+PsKLvZpwJCOXd5cku/71Xf6K59HpGqVUWdCyXjC3x4fx4dI97E/Ldulr6zVelVLKBUZ3j8HPV/jXom0ufV0dySullAvUrBLIiC4N+G7LEZbvct2+NjqSV0opF7n/+vqEB5fn719tpcBF+9roVsNKKeUigf6+PHNLY7YfyWTumgNXfoADaJFXSikX6tG0Jm0jqzL2hx2kZ+c7/fV0Tl4ppVxIRHihVyzpOfm89XOS019P5+SVUsrFmtSuwt2t6zJzxV6Sj2U69bV0ukYppSx48qZGhFQsx/Yjzi3yfk59dqWUUhdVrWI5lj51AwF+zh1r65y8UkpZ4uwCDzonr5RSXk3n5JVSyotpkVdKKS+mRV4ppbyYnnhVSikvpidelVLKi+l0jVJKeTGxdQXx/wohkgqcAi6ct6lyXtul/hwCOGpz5vOft7THXur+i7Vf2Ha52+7e99L0+8I2T+r35e7Xz7z4bZ7U78vd76rPvJ4xJvQy+cAY4xY/wOTLtV3mzwnOzHC1x17q/iv180q33b3vpem3fub6mXtSvz3lM3en6ZqvrtB2qT87O8PVHnup+6/Uzyvddve+l6bfF7Z5Ur8vd79+5sVv86R+X+5+t/nM3WK6pjREJMEY08p2DhvKat/Lar+h7Pa9rPYbSt93dxrJX63JtgNYVFb7Xlb7DWW372W131DKvnv8SF4ppdSlecNIXiml1CVokVdKKS+mRV4ppbyY1xd5EQkSkQQR6Wk7i6uISGMReV9EPhORP9vO40oicpuIfCgin4rITbbzuIqI1BeRqSLyme0srnDu3/VH5z7rAbbzuMrVfM5uW+RFZJqIHBORzRe0dxeRHSKSLCJPF+OpRgPznJPS8RzRb2PMNmPMcKAv0NGZeR3JQX1fYIx5ABgO3O3MvI7ioH7vNsYMc25S5yrh+3AH8Nm5z/pWl4d1oJL0+2o+Z7ct8sAMoPv5DSLiC0wCegCxQH8RiRWROBH5+oKf6iJyI7AVOObq8KUwg1L2+9xjbgW+ARa5Nn6pzMABfT/nuXOP8wQzcFy/PdkMivk+AOHAgXOHFbowozPMoPj9LjG3vZC3MWapiERc0NwGSDbG7AYQkblAb2PMq8D/m44RkS5AEGffpBwRWWSMKXJm7tJyRL/PPc9CYKGIfAN84sTIDuOgz1yAMcC3xphEJ0d2CEd95p6uJO8DkMLZQr8e9x6sXlEJ+721pM/vaW9OGP/32xvOftBhlzrYGPOsMeYxzha5D929wF9GifotIl1EZKKIfIBnjeQvpkR9B0YC3YA7RWS4M4M5WUk/82oi8j4QLyJ/c3Y4F7rU+/AF0EdE3sN52x/YdNF+X83n7LYjeUcyxsywncGVjDFLgCWWY1hhjJkITLSdw9WMMWmcPQ9RJhhjsoChtnO42tV8zp42kj8I1Dnvdvi5Nm9XVvsNZbfvZbXfFyqr74PD+u1pRX4NECUikSISAPQDFlrO5Apltd9QdvteVvt9obL6Pjiu347ao9nRP8Ac4DCQz9n5qGHn2m8BdgK7gGdt59R+a9+13/o+uHO/dYMypZTyYp42XaOUUqoEtMgrpZQX0yKvlFJeTIu8Ukp5MS3ySinlxbTIK6WUF9Mir5RSXkyLvFJKeTEt8kop5cX+F1HUNRWE1HJNAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "k = np.logspace(-4, np.log10(5), 200)\n", - "plt.loglog(k/0.673,cob*0.673**3,label='cobaya')\n", - "plt.plot(k,szr,label='szar')\n", - "plt.legend()\n", - "\n", - "plt.figure()\n", - "plt.semilogx(k,cob*0.673**3/szr)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "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.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/soliket/tests/test_clusters.py b/soliket/tests/test_clusters.py deleted file mode 100644 index bc84735f..00000000 --- a/soliket/tests/test_clusters.py +++ /dev/null @@ -1,49 +0,0 @@ -import numpy as np -import pytest - - -@pytest.mark.skip(reason="Under development") -def test_clusters(): - fiducial_params = { - "ombh2": 0.02225, - "omch2": 0.1198, - "H0": 67.3, - "tau": 0.06, - "As": 2.2e-9, - "ns": 0.96, - "mnu": 0.06, - "nnu": 3.046, - } - - info_fiducial = { - "params": fiducial_params, - "likelihood": {"soliket.ClusterLikelihood": {"stop_at_error": True}}, - "theory": { - "camb": { - "extra_args": { - "accurate_massive_neutrino_transfers": True, - "num_massive_neutrinos": 1, - "redshifts": np.linspace(0, 2, 41), - "nonlinear": False, - "kmax": 10.0, - "dark_energy_model": "ppf", - } - }, - "soliket.CCL": {"stop_at_error": True}, - }, - } - - from cobaya.model import get_model - - model_fiducial = get_model(info_fiducial) - - # import pdb - # pdb.set_trace() - - lnl = model_fiducial.loglikes({})[0] - - assert np.isfinite(lnl) - - like = model_fiducial.likelihood["soliket.ClusterLikelihood"] - - assert like._get_n_expected() > 40 diff --git a/soliket/tests/test_cross_correlation.py b/soliket/tests/test_cross_correlation.py deleted file mode 100644 index 6e4d13db..00000000 --- a/soliket/tests/test_cross_correlation.py +++ /dev/null @@ -1,33 +0,0 @@ -import numpy as np -from soliket.ccl import CCL -from soliket.cross_correlation import CrossCorrelationLikelihood -from cobaya.model import get_model -from cobaya.likelihood import Likelihood - -def test_cross_correlation(): - cosmo_params = { - "Omega_c": 0.25, - "Omega_b": 0.05, - "h": 0.67, - "n_s": 0.96 - } - - info = {"params": {"omch2": cosmo_params['Omega_c'] * cosmo_params['h'] ** 2., - "ombh2": cosmo_params['Omega_b'] * cosmo_params['h'] ** 2., - "H0": cosmo_params['h'] * 100, - "ns": cosmo_params['n_s'], - "As": 2.2e-9, - "tau": 0, - "b1": 1, - "s1": 0.4}, - "likelihood": {"CrossCorrelationLikelihood": CrossCorrelationLikelihood}, - "theory": { - "camb": None, - "ccl": {"external": CCL, "nonlinear": False} - }, - "debug": False, "stop_at_error": True} - - model = get_model(info) - loglikes, derived = model.loglikes() - assert np.isclose(loglikes[0], 88.2, atol = .2, rtol = 0.) - diff --git a/soliket/tests/test_cross_correlation.yaml b/soliket/tests/test_cross_correlation.yaml deleted file mode 100644 index 528fa99b..00000000 --- a/soliket/tests/test_cross_correlation.yaml +++ /dev/null @@ -1,44 +0,0 @@ -params: - ombh2: 0.0245 - H0: 70.0 - ns: 0.965 - logA: - prior: - min: 1.00 - max: 4.00 - latex: \log(10^{10} A_\mathrm{s}) - drop: true - As: - value: 'lambda logA: 1e-10*np.exp(logA)' - latex: A_\mathrm{s} - omegam: - prior: - min: 0.1 - max: 0.9 - latex: \Omega_\mathrm{m} - drop: true - omch2: - value: 'lambda omegam, ombh2, mnu, H0: (omegam*(H0/100)**2-ombh2)-(mnu*(3.046/3)**0.75)/94.0708' - latex: \Omega_\mathrm{c} h^2 - tau: 0.05 - mnu: 0.0 - b1: - prior: - min: 0. - max: 10. - latex: b_1 - s1: 0.4 - sigma8: -likelihood: - soliket.cross_correlation.CrossCorrelationLikelihood: -theory: - camb: - extra_args: - num_massive_neutrinos: 0 - soliket.ccl.CCL: -debug: false -stop_at_error: true -sampler: - evaluate: - -output: chains/test_cross_correlation diff --git a/soliket/tests/test_gaussian.py b/soliket/tests/test_gaussian.py deleted file mode 100644 index 94a74a96..00000000 --- a/soliket/tests/test_gaussian.py +++ /dev/null @@ -1,59 +0,0 @@ -import unittest -import numpy as np -from sklearn.datasets import make_spd_matrix - -from soliket.gaussian import GaussianData, MultiGaussianData, CrossCov - - -def toy_data(): - name1 = "A" - n1 = 10 - x1 = np.arange(n1) - y1 = np.random.random(n1) - - name2 = "B" - n2 = 20 - x2 = np.arange(n2) - y2 = np.random.random(n2) - - name3 = "C" - n3 = 30 - x3 = np.arange(n3) - y3 = np.random.random(n3) - - # Generate arbitrary covariance matrix, partition into parts - full_cov = make_spd_matrix(n1 + n2 + n3, random_state=1234) - cov1 = full_cov[:n1, :n1] - cov2 = full_cov[n1: n1 + n2, n1: n1 + n2] - cov3 = full_cov[n1 + n2:, n1 + n2:] - - data1 = GaussianData(name1, x1, y1, cov1) - data2 = GaussianData(name2, x2, y2, cov2) - data3 = GaussianData(name3, x3, y3, cov3) - - cross_cov = CrossCov( - { - (name1, name2): full_cov[:n1, n1: n1 + n2], - (name1, name3): full_cov[:n1, n1 + n2:], - (name2, name3): full_cov[n1: n1 + n2, n1 + n2:], - } - ) - - return [data1, data2, data3], cross_cov - - -def test_gaussian(): - datalist, cross_cov = toy_data() - - multi = MultiGaussianData(datalist, cross_cov) - - name1, name2, name3 = [d.name for d in datalist] - data1, data2, data3 = datalist - - assert (multi.cross_covs[(name1, name2)] == multi.cross_covs[(name2, name1)].T).all() - assert (multi.cross_covs[(name1, name3)] == multi.cross_covs[(name3, name1)].T).all() - assert (multi.cross_covs[(name2, name3)] == multi.cross_covs[(name3, name2)].T).all() - - assert (multi.cross_covs[(name1, name1)] == data1.cov).all() - assert (multi.cross_covs[(name2, name2)] == data2.cov).all() - assert (multi.cross_covs[(name3, name3)] == data3.cov).all() diff --git a/soliket/tests/test_lensing.py b/soliket/tests/test_lensing.py deleted file mode 100644 index 2c75bebb..00000000 --- a/soliket/tests/test_lensing.py +++ /dev/null @@ -1,89 +0,0 @@ -import os -import tempfile - -import pytest -import numpy as np - -from cobaya.yaml import yaml_load -from cobaya.model import get_model - -packages_path = os.environ.get("COBAYA_PACKAGES_PATH") or os.path.join( - tempfile.gettempdir(), "lensing_packages" -) - -def get_demo_lensing_model(theory): - if theory == "camb": - info_yaml = r""" - likelihood: - soliket.LensingLikelihood: - stop_at_error: True - - theory: - camb: - extra_args: - lens_potential_accuracy: 1 - - params: - ns: - prior: - min: 0.8 - max: 1.2 - H0: - prior: - min: 40 - max: 100 - """ - elif theory == "classy": - info_yaml = r""" - likelihood: - soliket.LensingLikelihood: - stop_at_error: True - - theory: - classy: - extra_args: - output: lCl, tCl - path: global - - params: - n_s: - prior: - min: 0.8 - max: 1.2 - H0: - prior: - min: 40 - max: 100 - - """ - - info = yaml_load(info_yaml) - - from cobaya.install import install - install(info, path=packages_path, skip_global=True) - - test_point = {} - for par, pdict in info["params"].items(): - if not isinstance(pdict, dict): - continue - - if "ref" in pdict: - try: - value = float(pdict["ref"]) - except TypeError: - value = (pdict["ref"]["min"] + pdict["ref"]["max"]) / 2 - test_point[par] = value - elif "prior" in pdict: - value = (pdict["prior"]["min"] + pdict["prior"]["max"]) / 2 - test_point[par] = value - - model = get_model(info) - return model, test_point - - -@pytest.mark.parametrize("theory", ["camb", "classy"]) -def test_lensing(theory): - model, test_point = get_demo_lensing_model(theory) - lnl = model.loglike(test_point)[0] - - assert np.isfinite(lnl) diff --git a/soliket/tests/test_lensing.yaml b/soliket/tests/test_lensing.yaml deleted file mode 100644 index 0ad82d18..00000000 --- a/soliket/tests/test_lensing.yaml +++ /dev/null @@ -1,85 +0,0 @@ -debug: true - -likelihood: - soliket.LensingLikelihood: - theory_lmax: 5000 - -params: - - # fixed - nnu: 3.046 - - # derived - As: - latex: As - value: 'lambda logAs: 10**(-10)*np.exp(logAs)' - - # sampled - H0: - latex: H_0 - prior: - max: 100 - min: 40 - proposal: 0.5 - ref: - max: 80 - min: 64 - logAs: - drop: true - latex: logAs - prior: - max: 4 - min: 2 - proposal: 0.01 - ref: 3.07 - mnu: - latex: mnu - prior: - max: 2 - min: 0 - proposal: 0.001 - ref: 0.06 - ns: - latex: ns - prior: - dist: norm - loc: 0.96 - scale: 0.02 - proposal: 0.01 - ref: 0.96 - ombh2: - latex: ombh2 - prior: - dist: norm - loc: 0.0222 - scale: 0.0009 - proposal: 0.0001 - ref: - max: 0.03 - min: 0.015 - omch2: - latex: omch2 - prior: - max: 0.99 - min: 0.005 - proposal: 0.001 - ref: - max: 0.2 - min: 0.1 - tau: - latex: tau - prior: - dist: norm - loc: 0.066 - scale: 0.012 - proposal: 0.001 - ref: 0.066 - -theory: - camb: - extra_args: - kmax: 0.9 - stop_at_error: true - -sampler: - evaluate: diff --git a/soliket/tests/test_lensing_lite.py b/soliket/tests/test_lensing_lite.py deleted file mode 100644 index dbef13ea..00000000 --- a/soliket/tests/test_lensing_lite.py +++ /dev/null @@ -1,65 +0,0 @@ -import pytest -import numpy as np - -from cobaya.yaml import yaml_load -from cobaya.model import get_model - - -def get_demo_lensing_model(theory): - if theory == "camb": - info_yaml = r""" - likelihood: - soliket.LensingLiteLikelihood: - stop_at_error: True - - theory: - camb: - extra_args: - lens_potential_accuracy: 1 - - params: - ns: - prior: - min: 0.8 - max: 1.2 - H0: - prior: - min: 40 - max: 100 - """ - elif theory == "classy": - info_yaml = r""" - likelihood: - soliket.LensingLiteLikelihood: - stop_at_error: True - - theory: - classy: - extra_args: - output: lCl, tCl - path: global - - params: - n_s: - prior: - min: 0.8 - max: 1.2 - H0: - prior: - min: 40 - max: 100 - - """ - - info = yaml_load(info_yaml) - model = get_model(info) - return model - - -@pytest.mark.parametrize("theory", ["camb", "classy"]) -def test_lensing(theory): - model = get_demo_lensing_model(theory) - ns_param = "ns" if theory == "camb" else "n_s" - lnl = model.loglike({ns_param: 0.965, "H0": 70})[0] - - assert np.isfinite(lnl) diff --git a/soliket/tests/test_lensing_lite.yaml b/soliket/tests/test_lensing_lite.yaml deleted file mode 100644 index 748e2281..00000000 --- a/soliket/tests/test_lensing_lite.yaml +++ /dev/null @@ -1,73 +0,0 @@ -# A simple cobaya likelihood for SO - -debug: True - -likelihood: - soliket.LensingLiteLikelihood: - stop_at_error: True - -params: - # Sampled - cosmomc_theta: - prior: - min: 0.0103 - max: 0.0105 - proposal: 1.5e-6 - latex: \theta_\mathrm{MC} - logA: - prior: - min: 2.6 - max: 3.5 - proposal: 0.0036 - drop: True - latex: \log(10^{10} A_\mathrm{s}) - As: - value: "lambda logA: 1e-10*np.exp(logA)" - latex: A_\mathrm{s} - ns: - prior: - min: 0.9 - max: 1.1 - proposal: 0.0033 - latex: n_\mathrm{s} - ombh2: - prior: - min: 0.017 - max: 0.027 - proposal: 6.5e-5 - latex: \Omega_\mathrm{b}h^2 - omch2: - prior: - min: 0.09 - max: 0.15 - proposal: 0.0011 - latex: \Omega_\mathrm{c}h^2 - Alens: - prior: - min: 0.5 - max: 1.5 - proposal: 0.022 - latex: A_\mathrm{L} - tau: - prior: - dist: norm - loc: 0.0544 - scale: 0.0073 - proposal: 0.0073 - latex: \tau_\mathrm{reio} - H0: - latex: H_0 - sigma8: - latex: \sigma_8 - - -theory: - camb: - stop_at_error: False - extra_args: - lens_potential_accuracy: 1 - -sampler: - evaluate: - -output: chains/test_lensing diff --git a/soliket/tests/test_mflike.py b/soliket/tests/test_mflike.py deleted file mode 100644 index 9beb7eec..00000000 --- a/soliket/tests/test_mflike.py +++ /dev/null @@ -1,132 +0,0 @@ -""" -Make sure that this returns the same result as original mflike.MFLike from LAT_MFlike repo -""" -import os -import tempfile -import unittest -from distutils.version import LooseVersion - -import camb -import mflike -import soliket - - -packages_path = os.environ.get("COBAYA_PACKAGES_PATH") or os.path.join( - tempfile.gettempdir(), "LAT_packages" -) - -cosmo_params = { - "cosmomc_theta": 0.0104085, - "As": 2.0989031673191437e-09, - "ombh2": 0.02237, - "omch2": 0.1200, - "ns": 0.9649, - "Alens": 1.0, - "tau": 0.0544, -} - -nuisance_params = { - "a_tSZ": 3.3044404448917724, - "a_kSZ": 1.6646620740058649, - "a_p": 6.912474322461401, - "beta_p": 2.077474196171309, - "a_c": 4.88617700670901, - "beta_c": 2.2030316332596014, - "n_CIBC": 1.20, - "a_s": 3.099214100532393, - "T_d": 9.60, -} - - -if LooseVersion(camb.__version__) < LooseVersion('1.3'): - chi2s = {"tt": 1384.5669, "te": 1400.2760, "ee": 1428.7597, "tt-te-et-ee": 2412.9275} -else: - chi2s = {"tt": 1384.8184, "te": 1400.4507, "ee": 1428.8454, "tt-te-et-ee": 2413.10375} - -pre = "data_sacc_" - - -class MFLikeTest(unittest.TestCase): - orig = False - - def setUp(self): - from cobaya.install import install - - install({"likelihood": {"mflike.MFLike": None}}, path=packages_path, skip_global=True) - - def get_mflike_type(self, as_string=False): - if self.orig: - t = "mflike.MFLike" - else: - t = "soliket.MFLike" - - if as_string: - return t - else: - return eval(t) - - def test_mflike(self): - # As of now, there is not a mechanism - # in soliket to ensure there is .loglike that can be called like this - # w/out cobaya - - camb_cosmo = cosmo_params.copy() - camb_cosmo.update({"lmax": 9000, "lens_potential_accuracy": 1}) - pars = camb.set_params(**camb_cosmo) - results = camb.get_results(pars) - powers = results.get_cmb_power_spectra(pars, CMB_unit="muK") - cl_dict = {k: powers["total"][:, v] for k, v in {"tt": 0, "ee": 1, "te": 3}.items()} - for select, chi2 in chi2s.items(): - MFLike = self.get_mflike_type() - - my_mflike = MFLike( - { - "packages_path": packages_path, - "input_file": pre + "00000.fits", - "cov_Bbl_file": pre + "w_covar_and_Bbl.fits", - "defaults": { - "polarizations": select.upper().split("-"), - "scales": { - "TT": [2, 5000], - "TE": [2, 5000], - "ET": [2, 5000], - "EE": [2, 5000], - }, - "symmetrize": False, - }, - } - ) - - loglike = my_mflike.loglike(cl_dict, **nuisance_params) - - self.assertAlmostEqual(-2 * (loglike - my_mflike.logp_const), chi2, 2) - - def test_cobaya(self): - mflike_type = self.get_mflike_type(as_string=True) - - params = dict(cosmo_params) - # params['a_tSZ'] = 3.3 - - info = { - "likelihood": { - mflike_type: { - "input_file": pre + "00000.fits", - "cov_Bbl_file": pre + "w_covar_and_Bbl.fits", - } - }, - "theory": {"camb": {"extra_args": {"lens_potential_accuracy": 1}, - "stop_at_error": True}}, - "params": cosmo_params, - "modules": packages_path, - "debug": True, - } - from cobaya.model import get_model - - model = get_model(info) - my_mflike = model.likelihood[mflike_type] - chi2 = -2 * (model.loglikes(nuisance_params)[0] - my_mflike.logp_const) - self.assertAlmostEqual(chi2[0], chi2s["tt-te-et-ee"], 2) - - -class MFLikeTestOrig(MFLikeTest): - orig = True diff --git a/soliket/tests/test_mflike.yaml b/soliket/tests/test_mflike.yaml deleted file mode 100644 index ee446134..00000000 --- a/soliket/tests/test_mflike.yaml +++ /dev/null @@ -1,156 +0,0 @@ -# A simple cobaya likelihood for SO - -debug: True - -likelihood: - soliket.mflike.MFLike: - input_file: data_sacc_00044.fits - cov_Bbl_file: data_sacc_w_covar_and_Bbl.fits - defaults: - # Which spectra? - polarizations: ['TT', 'TE', 'ET', 'EE'] - # Scale cuts (in ell) for each spectrum - scales: - TT: [2, 6002] - TE: [2, 6002] - ET: [2, 6002] - EE: [2, 6002] - symmetrize: False - data: - experiments: - LAT: - frequencies: [93, 145, 225] - - spectra: - - experiments: ['LAT', 'LAT'] - frequencies: [93, 93] - polarizations: ['TT','TE','EE'] - - experiments: ['LAT', 'LAT'] - frequencies: [93, 145] - - experiments: ['LAT', 'LAT'] - frequencies: [93, 225] - - experiments: ['LAT', 'LAT'] - frequencies: [145, 145] - polarizations: ['TT','TE','EE'] - - experiments: ['LAT', 'LAT'] - frequencies: [145, 225] - - experiments: ['LAT', 'LAT'] - frequencies: [225, 225] - polarizations: ['TT','TE','EE'] - -params: - # Sampled - cosmomc_theta: - prior: - min: 0.0103 - max: 0.0105 - proposal: 1.5e-6 - latex: \theta_\mathrm{MC} - logA: - prior: - min: 2.6 - max: 3.5 - proposal: 0.0036 - drop: True - latex: \log(10^{10} A_\mathrm{s}) - As: - value: "lambda logA: 1e-10*np.exp(logA)" - latex: A_\mathrm{s} - ns: - prior: - min: 0.9 - max: 1.1 - proposal: 0.0033 - latex: n_\mathrm{s} - ombh2: - prior: - min: 0.017 - max: 0.027 - proposal: 6.5e-5 - latex: \Omega_\mathrm{b}h^2 - omch2: - prior: - min: 0.09 - max: 0.15 - proposal: 0.0011 - latex: \Omega_\mathrm{c}h^2 - Alens: - prior: - min: 0.5 - max: 1.5 - proposal: 0.022 - latex: A_\mathrm{L} - tau: - prior: - dist: norm - loc: 0.0544 - scale: 0.0073 - proposal: 0.0073 - latex: \tau_\mathrm{reio} - H0: - latex: H_0 - sigma8: - latex: \sigma_8 - - # Sampled nuisance params - a_tSZ: - prior: - min: 3.0 - max: 3.6 - proposal: 0.05 - latex: a_\mathrm{tSZ} - a_kSZ: - prior: - min: 1.4 - max: 1.8 - proposal: 0.1 - latex: a_\mathrm{kSZ} - a_p: - prior: - min: 6.2 - max: 7.6 - proposal: 0.075 - latex: a_p - beta_p: - prior: - min: 1.8 - max: 2.2 - proposal: 0.015 - latex: \beta_p - a_c: - prior: - min: 4.4 - max: 5.4 - proposal: 0.12 - latex: a_c - beta_c: - prior: - min: 2.0 - max: 2.4 - proposal: 0.03 - latex: \beta_c - a_s: - prior: - min: 2.8 - max: 3.4 - proposal: 0.01 - latex: a_s - - # Fixed values of nuisance - n_CIBC: - value: 1.20 - latex: n_\mathrm{CIBC} - T_d: - value: 9.60 - latex: T_d - -theory: - camb: - stop_at_error: False - extra_args: - lens_potential_accuracy: 1 - -sampler: - evaluate: - -output: chains/test_mflike diff --git a/soliket/tests/test_multi.py b/soliket/tests/test_multi.py deleted file mode 100644 index ccf63aaa..00000000 --- a/soliket/tests/test_multi.py +++ /dev/null @@ -1,78 +0,0 @@ -import numpy as np -import pytest -from soliket.tests.test_mflike import cosmo_params, nuisance_params - - -def test_multi(): - - lensing_options = {"theory_lmax": 5000} - - pre = "data_sacc_" - mflike_options = { - "input_file": pre + "00000.fits", - "cov_Bbl_file": pre + "w_covar_and_Bbl.fits", - "stop_at_error": True, - } - - camb_options = {"extra_args": {"lens_potential_accuracy": 1}} - - fg_params = {"a_tSZ": {"prior": {"min": 3.0, "max": 3.6}}, "a_kSZ": {"prior": {"min": 1.4, "max": 1.8}}} - mflike_params = {**cosmo_params, **nuisance_params} - mflike_params.update(fg_params) - - lensing_params = {**cosmo_params} - - info = { - "likelihood": { - "soliket.gaussian.MultiGaussianLikelihood": { - "components": ["soliket.mflike.MFLike", "soliket.LensingLikelihood"], - "options": [mflike_options, lensing_options], - "stop_at_error": True, - } - }, - "theory": {"camb": camb_options}, - "params": {**mflike_params}, - } - - info1 = { - "likelihood": {"soliket.mflike.MFLike": mflike_options}, - "theory": {"camb": camb_options}, - "params": {**mflike_params}, - } - - info2 = { - "likelihood": {"soliket.LensingLikelihood": lensing_options}, - "theory": {"camb": camb_options}, - "params": {**lensing_params}, - } - - from cobaya.model import get_model - - model = get_model(info) - model1 = get_model(info1) - model2 = get_model(info2) - - # To test here, the absolute values of the logps are not identical - # to the sum of components when combined (probably due to numerical issues of - # computing inv_cov); so here we test to make sure - # that the change in logp between two different sets of params is identical - - fg_values_a = {"a_tSZ": nuisance_params["a_tSZ"], "a_kSZ": nuisance_params["a_kSZ"]} - fg_values_b = {k: v * 1.1 for k, v in fg_values_a.items()} - - logp_a = model.loglikes(fg_values_a, cached=False)[0].sum() - logp_b = model.loglikes(fg_values_b, cached=False)[0].sum() - d_logp = logp_b - logp_a - assert np.isfinite(d_logp) - - model1_logp_a = model1.loglikes(fg_values_a, cached=False)[0].sum() - model2_logp_a = model2.loglikes({}, cached=False)[0].sum() - - model1_logp_b = model1.loglikes(fg_values_b, cached=False)[0].sum() - model2_logp_b = model2.loglikes({}, cached=False)[0].sum() - - d_logp1 = model1_logp_b - model1_logp_a - d_logp2 = model2_logp_b - model2_logp_a - d_logp_sum = d_logp1 + d_logp2 - - assert np.isclose(d_logp, d_logp_sum) diff --git a/soliket/tests/test_multi.yaml b/soliket/tests/test_multi.yaml deleted file mode 100644 index 3aea60e2..00000000 --- a/soliket/tests/test_multi.yaml +++ /dev/null @@ -1,163 +0,0 @@ -# A simple cobaya likelihood for SO - -debug: True - -likelihood: - soliket.gaussian.MultiGaussianLikelihood: - components: - - soliket.mflike.MFLike - - soliket.LensingLikelihood - options: - - input_file: data_sacc_00044.fits - cov_Bbl_file: data_sacc_w_covar_and_Bbl.fits - defaults: - # Which spectra? - polarizations: ['TT', 'TE', 'ET', 'EE'] - # Scale cuts (in ell) for each spectrum - scales: - TT: [2, 6002] - TE: [2, 6002] - ET: [2, 6002] - EE: [2, 6002] - symmetrize: False - data: - experiments: - LAT: - frequencies: [93, 145, 225] - - spectra: - - experiments: ['LAT', 'LAT'] - frequencies: [93, 93] - polarizations: ['TT','TE','EE'] - - experiments: ['LAT', 'LAT'] - frequencies: [93, 145] - - experiments: ['LAT', 'LAT'] - frequencies: [93, 225] - - experiments: ['LAT', 'LAT'] - frequencies: [145, 145] - polarizations: ['TT','TE','EE'] - - experiments: ['LAT', 'LAT'] - frequencies: [145, 225] - - experiments: ['LAT', 'LAT'] - frequencies: [225, 225] - polarizations: ['TT','TE','EE'] - - theory_lmax: 5000 - stop_at_error: true - stop_at_error: True - -params: - # Sampled - cosmomc_theta: - prior: - min: 0.0103 - max: 0.0105 - proposal: 1.5e-6 - latex: \theta_\mathrm{MC} - logA: - prior: - min: 2.6 - max: 3.5 - proposal: 0.0036 - drop: True - latex: \log(10^{10} A_\mathrm{s}) - As: - value: "lambda logA: 1e-10*np.exp(logA)" - latex: A_\mathrm{s} - ns: - prior: - min: 0.9 - max: 1.1 - proposal: 0.0033 - latex: n_\mathrm{s} - ombh2: - prior: - min: 0.017 - max: 0.027 - proposal: 6.5e-5 - latex: \Omega_\mathrm{b}h^2 - omch2: - prior: - min: 0.09 - max: 0.15 - proposal: 0.0011 - latex: \Omega_\mathrm{c}h^2 - Alens: - prior: - min: 0.5 - max: 1.5 - proposal: 0.022 - latex: A_\mathrm{L} - tau: - prior: - dist: norm - loc: 0.0544 - scale: 0.0073 - proposal: 0.0073 - latex: \tau_\mathrm{reio} - H0: - latex: H_0 - sigma8: - latex: \sigma_8 - - # Sampled nuisance params - a_tSZ: - prior: - min: 3.0 - max: 3.6 - proposal: 0.05 - latex: a_\mathrm{tSZ} - a_kSZ: - prior: - min: 1.4 - max: 1.8 - proposal: 0.1 - latex: a_\mathrm{kSZ} - a_p: - prior: - min: 6.2 - max: 7.6 - proposal: 0.075 - latex: a_p - beta_p: - prior: - min: 1.8 - max: 2.2 - proposal: 0.015 - latex: \beta_p - a_c: - prior: - min: 4.4 - max: 5.4 - proposal: 0.12 - latex: a_c - beta_c: - prior: - min: 2.0 - max: 2.4 - proposal: 0.03 - latex: \beta_c - a_s: - prior: - min: 2.8 - max: 3.4 - proposal: 0.01 - latex: a_s - - # Fixed values of nuisance - n_CIBC: - value: 1.20 - latex: n_\mathrm{CIBC} - T_d: - value: 9.60 - latex: T_d - -theory: - camb: - stop_at_error: False - extra_args: - lens_potential_accuracy: 1 - -sampler: - evaluate: - -output: chains/test_multi diff --git a/soliket/tests/test_poisson.py b/soliket/tests/test_poisson.py deleted file mode 100644 index 216dfc7f..00000000 --- a/soliket/tests/test_poisson.py +++ /dev/null @@ -1,55 +0,0 @@ -import numpy as np -import pandas as pd -from functools import partial - -from soliket.poisson_data import PoissonData - -x_min = 0 -x_max = 10 - - -def rate_density(x, a): - """simple linear rate density - """ - return a * x - - -def n_expected(a): - return 0.5 * a * (x_max ** 2 - x_min ** 2) # integral(rate_density, x_min, x_max) - - -def generate_data(a, with_samples=False, unc=0.3, Nk=64): - # Generate total number - n = np.random.poisson(n_expected(a)) - - # Generate x values according to rate density (normalized as PDF) - u = np.random.random(n) - - # From inverting CDF of above normalized density - x = np.sqrt(u * (x_max ** 2 - x_min ** 2) + x_min ** 2) - - if not with_samples: - return x - else: - return x[:, None] * (1 + np.random.normal(0, unc, size=(n, Nk))) - - -def test_poisson_experiment(a_true=3, N=100, with_samples=False, Nk=64): - a_maxlikes = [] - for i in range(N): - observations = generate_data(a_true, with_samples=with_samples, Nk=Nk) - if not with_samples: - catalog = pd.DataFrame({"x": observations}) - data = PoissonData("toy", catalog, ["x"]) - else: - catalog = pd.DataFrame({"x": observations.mean(axis=1)}) - samples = {"x": observations, "prior": np.ones(observations.shape)} - data = PoissonData("toy_samples", catalog, ["x"], samples=samples) - - a_grid = np.arange(0.1, 10, 0.1) - lnl = [data.loglike(partial(rate_density, a=a), n_expected(a)) for a in a_grid] - a_maxlike = a_grid[np.argmax(lnl)] - - a_maxlikes.append(a_maxlike) - - assert abs(np.mean(a_maxlikes) - a_true) < 0.1 diff --git a/soliket/tests/test_ps.py b/soliket/tests/test_ps.py deleted file mode 100644 index 68515744..00000000 --- a/soliket/tests/test_ps.py +++ /dev/null @@ -1,79 +0,0 @@ -import os -from tempfile import gettempdir - -import numpy as np -from sklearn.datasets import make_spd_matrix -from scipy.stats import multivariate_normal - -from soliket.gaussian import GaussianData, CrossCov -from soliket import GaussianLikelihood, MultiGaussianLikelihood -from soliket import PSLikelihood - -from soliket.utils import get_likelihood - - -class ToyLikelihood(PSLikelihood): - name = "toy" - n = 10 - sigma = 1 - off_diag_amp = 1e-3 - cov = None - seed = 1234 - - def initialize(self): - np.random.seed(self.seed) - - x = np.arange(self.n) - if self.cov is None: - cov = make_spd_matrix(self.n) * self.off_diag_amp - cov += np.diag(np.ones(self.n) * self.sigma ** 2) - else: - cov = self.cov - - y = np.random.multivariate_normal(np.zeros(self.n), cov) - self.data = GaussianData(self.name, x, y, cov) - - def _get_theory(self): - return np.zeros(self.n) - - -def test_toy(): - n1, n2, n3 = [10, 20, 30] - full_cov = make_spd_matrix(n1 + n2 + n3, random_state=1234) * 1e-1 - full_cov += np.diag(np.ones((n1 + n2 + n3))) - - cov1 = full_cov[:n1, :n1] - cov2 = full_cov[n1: n1 + n2, n1: n1 + n2] - cov3 = full_cov[n1 + n2:, n1 + n2:] - - name1, name2, name3 = ["A", "B", "C"] - - cross_cov = CrossCov( - { - (name1, name2): full_cov[:n1, n1: n1 + n2], - (name1, name3): full_cov[:n1, n1 + n2:], - (name2, name3): full_cov[n1: n1 + n2, n1 + n2:], - } - ) - tempdir = gettempdir() - cross_cov_path = os.path.join(tempdir, "toy_cross_cov.npz") - cross_cov.save(cross_cov_path) - - info1 = {"name": name1, "n": n1, "cov": cov1, "seed": 123} - info2 = {"name": name2, "n": n2, "cov": cov2, "seed": 234} - info3 = {"name": name3, "n": n3, "cov": cov3, "seed": 345} - - lhood = "soliket.tests.test_ps.ToyLikelihood" - components = [lhood] * 3 - options = [info1, info2, info3] - multilike1 = MultiGaussianLikelihood({"components": components, "options": options}) - multilike2 = MultiGaussianLikelihood( - {"components": components, "options": options, "cross_cov_path": cross_cov_path} - ) - - like1 = get_likelihood(lhood, info1) - like2 = get_likelihood(lhood, info2) - like3 = get_likelihood(lhood, info3) - - assert np.isclose(multilike1.logp(), sum([l.logp() for l in [like1, like2, like3]])) - assert not np.isclose(multilike2.logp(), sum([l.logp() for l in [like1, like2, like3]])) diff --git a/soliket/tests/test_runs.py b/soliket/tests/test_runs.py deleted file mode 100644 index e5b23306..00000000 --- a/soliket/tests/test_runs.py +++ /dev/null @@ -1,22 +0,0 @@ -import pkgutil -import pytest - -from cobaya.yaml import yaml_load -from cobaya.run import run - - -@pytest.mark.parametrize("lhood", ["mflike", "lensing", "lensing_lite", "multi", "cross_correlation"]) -def test_evaluate(lhood): - info = yaml_load(pkgutil.get_data("soliket", f"tests/test_{lhood}.yaml")) - info["force"] = True - info['sampler'] = {'evaluate': {}} - - updated_info, sampler = run(info) - -@pytest.mark.parametrize("lhood", ["mflike", "lensing", "lensing_lite", "multi", "cross_correlation"]) -def test_mcmc(lhood): - info = yaml_load(pkgutil.get_data("soliket", f"tests/test_{lhood}.yaml")) - info["force"] = True - info['sampler'] = {'mcmc': {'max_samples': 10, 'max_tries': 1000}} - - updated_info, sampler = run(info) \ No newline at end of file diff --git a/soliket/utils.py b/soliket/utils.py index b0f32ca8..bd01b823 100644 --- a/soliket/utils.py +++ b/soliket/utils.py @@ -2,6 +2,7 @@ from scipy.stats import binned_statistic as binnedstat import numpy as np +# from astLib import WCS from cobaya.likelihood import Likelihood from cobaya.likelihoods.one import one diff --git a/soliket/ymap/classy_sz.py b/soliket/ymap/classy_sz.py new file mode 100644 index 00000000..d059ec3e --- /dev/null +++ b/soliket/ymap/classy_sz.py @@ -0,0 +1,101 @@ +from cobaya.theories.classy import classy +from copy import deepcopy +from typing import NamedTuple, Sequence, Union, Optional +from cobaya.tools import load_module +import logging +import os + +class classy_sz(classy): + def initialize(self): + """Importing CLASS from the correct path, if given, and if not, globally.""" + self.classy_module = self.is_installed() + if not self.classy_module: + raise NotInstalledError( + self.log, "Could not find CLASS_SZ. Check error message above.") + from classy_sz import Class, CosmoSevereError, CosmoComputationError + global CosmoComputationError, CosmoSevereError + self.classy = Class() + super(classy,self).initialize() + # Add general CLASS stuff + self.extra_args["output"] = self.extra_args.get("output", "") + if "sBBN file" in self.extra_args: + self.extra_args["sBBN file"] = ( + self.extra_args["sBBN file"].format(classy=self.path)) + # Derived parameters that may not have been requested, but will be necessary later + self.derived_extra = [] + self.log.info("Initialized!") + + # # class_sz default params for lkl + # self.extra_args["output"] = 'tSZ_1h' + # self.extra_args["multipoles_sz"] = 'P15' + # self.extra_args['nlSZ'] = 18 + + + # # here modify if you want to bypass stuff in the class computation + # def calculate(self, state, want_derived=True, **params_values_dict): + # print("Bypassing class_sz") + + + + + def must_provide(self, **requirements): + if "Cl_sz" in requirements: + # make sure cobaya still runs as it does for standard classy + requirements.pop("Cl_sz") + # specify the method to collect the new observable + self.collectors["Cl_sz"] = Collector( + method="cl_sz", # name of the method in classy.pyx + args_names=[], + args=[]) + + if "sz_binned_cluster_counts" in requirements: + # make sure cobaya still runs as it does for standard classy + requirements.pop("sz_binned_cluster_counts") + # specify the method to collect the new observable + self.collectors["sz_binned_cluster_counts"] = Collector( + method="dndzdy_theoretical", # name of the method in classy.pyx + args_names=[], + args=[]) + + if "sz_unbinned_cluster_counts" in requirements: + # make sure cobaya still runs as it does for standard classy + requirements.pop("sz_unbinned_cluster_counts") + # specify the method to collect the new observable + self.collectors["sz_unbinned_cluster_counts"] = Collector( + method="szunbinned_loglike", # name of the method in classy.pyx + args_names=[], + args=[]) + + super().must_provide(**requirements) + + # get the required new observable + def get_Cl_sz(self): + cls = {} + cls = deepcopy(self._current_state["Cl_sz"]) + return cls + + # get the required new observable + def get_sz_unbinned_cluster_counts(self): + cls = deepcopy(self._current_state["sz_unbinned_cluster_counts"]) + return cls + + # get the required new observable + def get_sz_binned_cluster_counts(self): + cls = {} + cls = deepcopy(self._current_state["sz_binned_cluster_counts"]) + return cls + + + @classmethod + def is_installed(cls, **kwargs): + return load_module('classy_sz') + + +# this just need to be there as it's used to fill-in self.collectors in must_provide: +class Collector(NamedTuple): + method: str + args: Sequence = [] + args_names: Sequence = [] + kwargs: dict = {} + arg_array: Union[int, Sequence] = None + post: Optional[callable] = None diff --git a/soliket/ymap/data/data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt b/soliket/ymap/data/data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt new file mode 100644 index 00000000..dd54c9dc --- /dev/null +++ b/soliket/ymap/data/data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt @@ -0,0 +1,18 @@ +1.000000000000000000e+01 0.000000000000000000e+00 4.300000000000000165e-05 6.999999999999999895e-06 6.401000000000000209e-07 +1.350000000000000000e+01 0.000000000000000000e+00 1.420000000000000092e-04 2.400000000000000061e-05 1.166599999999999977e-06 +1.800000000000000000e+01 0.000000000000000000e+00 2.959999999999999849e-04 4.800000000000000122e-05 2.074300000000000198e-06 +2.350000000000000000e+01 0.000000000000000000e+00 4.000000000000000192e-04 7.299999999999999903e-05 3.536499999999999937e-06 +3.050000000000000000e+01 9.020000000000000240e-04 5.410000000000000312e-04 1.110000000000000011e-04 5.959699999999999877e-06 +4.000000000000000000e+01 2.010000000000000068e-03 1.056000000000000081e-03 2.239999999999999966e-04 1.025800000000000072e-05 +5.250000000000000000e+01 3.118999999999999811e-03 1.647000000000000026e-03 4.490000000000000176e-04 1.769339999999999902e-05 +6.850000000000000000e+01 6.277999999999999726e-03 2.786999999999999981e-03 8.369999999999999619e-04 3.018530000000000049e-05 +8.950000000000000000e+01 1.224199999999999941e-02 4.305999999999999932e-03 1.399999999999999986e-03 5.171790000000000165e-05 +1.170000000000000000e+02 2.158399999999999902e-02 6.841999999999999992e-03 2.700999999999999842e-03 8.893469999999999403e-05 +1.525000000000000000e+02 4.591499999999999748e-02 1.126399999999999971e-02 4.721000000000000370e-03 1.526847000000000122e-04 +1.980000000000000000e+02 7.058200000000000585e-02 1.674399999999999847e-02 8.115000000000000685e-03 2.619278000000000166e-04 +2.575000000000000000e+02 1.197860000000000036e-01 2.734500000000000125e-02 1.461800000000000078e-02 4.563659999999999874e-04 +3.355000000000000000e+02 2.116860000000000130e-01 4.327500000000000097e-02 2.489299999999999846e-02 8.150282000000000446e-04 +4.365000000000000000e+02 3.328630000000000200e-01 7.058699999999999697e-02 5.156999999999999779e-02 1.502764100000000000e-03 +5.675000000000000000e+02 4.349310000000000120e-01 1.153560000000000002e-01 1.072929999999999995e-01 2.934224300000000136e-03 +7.380000000000000000e+02 6.020299999999999541e-01 1.549260000000000081e-01 1.970530000000000059e-01 6.334076600000000321e-03 +9.595000000000000000e+02 7.547329999999999872e-01 2.071999999999999953e-01 3.617130000000000067e-01 1.617079800000000012e-02 diff --git a/soliket/ymap/data/data_ps-ell-y2-erry2_total-planck-collab-15.txt b/soliket/ymap/data/data_ps-ell-y2-erry2_total-planck-collab-15.txt new file mode 100644 index 00000000..623a906b --- /dev/null +++ b/soliket/ymap/data/data_ps-ell-y2-erry2_total-planck-collab-15.txt @@ -0,0 +1,18 @@ +1.000000000000000000e+01 5.079000000000000181e-03 6.289999999999999584e-03 +1.350000000000000000e+01 8.805999999999999592e-03 6.147999999999999819e-03 +1.800000000000000000e+01 1.362999999999999975e-02 5.794999999999999804e-03 +2.350000000000000000e+01 2.961199999999999943e-02 8.049999999999999864e-03 +3.050000000000000000e+01 2.240899999999999836e-02 5.215000000000000017e-03 +4.000000000000000000e+01 2.848600000000000090e-02 4.644999999999999823e-03 +5.250000000000000000e+01 4.275600000000000234e-02 4.682999999999999663e-03 +6.850000000000000000e+01 4.580100000000000143e-02 4.290000000000000410e-03 +8.950000000000000000e+01 7.104299999999999504e-02 4.542000000000000030e-03 +1.170000000000000000e+02 1.191439999999999999e-01 5.618999999999999863e-03 +1.525000000000000000e+02 1.514989999999999948e-01 5.936000000000000304e-03 +1.980000000000000000e+02 1.939029999999999920e-01 6.112000000000000245e-03 +2.575000000000000000e+02 2.817509999999999737e-01 6.871999999999999637e-03 +3.355000000000000000e+02 3.983709999999999751e-01 8.238000000000000531e-03 +4.365000000000000000e+02 5.674280000000000435e-01 9.580999999999999239e-03 +5.675000000000000000e+02 7.686560000000000059e-01 1.242399999999999928e-02 +7.380000000000000000e+02 1.110114000000000045e+00 1.645399999999999988e-02 +9.595000000000000000e+02 1.661413999999999946e+00 2.402299999999999922e-02 diff --git a/soliket/ymap/data/tSZ_c_ell_ref_total-planck-collab-15_step_1.txt b/soliket/ymap/data/tSZ_c_ell_ref_total-planck-collab-15_step_1.txt new file mode 100644 index 00000000..ab24af01 --- /dev/null +++ b/soliket/ymap/data/tSZ_c_ell_ref_total-planck-collab-15_step_1.txt @@ -0,0 +1,18 @@ +1.000000e+01 1.101000e-02 0.000000e+00 3.832516e-06 8.606630e+00 1.161895e+01 +1.350000e+01 1.471027e-02 0.000000e+00 3.893825e-06 1.161895e+01 1.558846e+01 +1.800000e+01 1.947394e-02 0.000000e+00 4.117531e-06 1.558846e+01 2.056696e+01 +2.350000e+01 2.530560e-02 0.000000e+00 4.299960e-06 2.056696e+01 2.677219e+01 +3.050000e+01 3.273882e-02 0.000000e+00 4.239070e-06 2.677219e+01 3.492850e+01 +4.000000e+01 4.283658e-02 0.000000e+00 4.157740e-06 3.492850e+01 4.582576e+01 +5.250000e+01 5.611885e-02 0.000000e+00 4.201464e-06 4.582576e+01 5.996874e+01 +6.850000e+01 7.307477e-02 0.000000e+00 4.221966e-06 5.996874e+01 7.829911e+01 +8.950000e+01 9.518913e-02 0.000000e+00 4.189440e-06 7.829911e+01 1.023303e+02 +1.170000e+02 1.238097e-01 0.000000e+00 4.175270e-06 1.023303e+02 1.335758e+02 +1.525000e+02 1.600527e-01 0.000000e+00 4.165841e-06 1.335758e+02 1.737671e+02 +1.980000e+02 2.051795e-01 0.000000e+00 4.076066e-06 1.737671e+02 2.257986e+02 +2.575000e+02 2.617627e-01 0.000000e+00 3.898407e-06 2.257986e+02 2.939239e+02 +3.355000e+02 3.316388e-01 0.000000e+00 3.687923e-06 2.939239e+02 3.826823e+02 +4.365000e+02 4.149529e-01 0.000000e+00 3.425465e-06 3.826823e+02 4.977085e+02 +5.675000e+02 5.115921e-01 0.000000e+00 3.083198e-06 4.977085e+02 6.471592e+02 +7.380000e+02 6.198693e-01 0.000000e+00 2.677323e-06 6.471592e+02 8.414933e+02 +9.595000e+02 7.350690e-01 0.000000e+00 2.228522e-06 8.414933e+02 1.094055e+03 diff --git a/soliket/ymap/data/tSZ_params_ref_total-planck-collab-15_step_1.txt b/soliket/ymap/data/tSZ_params_ref_total-planck-collab-15_step_1.txt new file mode 100644 index 00000000..79f42bc6 --- /dev/null +++ b/soliket/ymap/data/tSZ_params_ref_total-planck-collab-15_step_1.txt @@ -0,0 +1,44 @@ +# List of input/precision parameters actually read +# (all other parameters set to default values) +# Obtained with CLASS v2.9.4 (for developers: svn version 6142M) +# +# This file can be used as the input file of another run +# +B = 1.41 +omega_b = 0.0224 +omega_cdm = 0.125 +A_s = 1.9e-09 +n_s = 0.96 +H0 = 69.0 +non linear = halofit +output = mPk tSZ_1h +units for tSZ spectrum = dimensionless +component of tSZ power spectrum = total +path_to_class = /Users/boris/Work/CLASS-SZ/SO-SZ/class_sz +write sz results to files = no +mass function = M500 +pressure profile = A10 +multipoles_sz = P15 +M1SZ = 100000000000.0 +M2SZ = 1e+16 +z1SZ = 1e-05 +z2SZ = 4.0 +z_max_pk = 4.0 +N_ur = 0.00641 +N_ncdm = 1 +deg_ncdm = 3 +m_ncdm = 0.02 +T_ncdm = 0.71611 +HMF_prescription_NCDM = CDM +write parameters = yeap +root = /Users/boris/Desktop/test_params +background_verbose = 0 +perturbations_verbose = 0 +sz_verbose = 1 +ndim_redshifts = 50 +ndim_masses = 50 +create reference trispectrum for likelihood code = YES +append_name_trispectrum_ref = total-planck-collab-15_step_1 +path to reference trispectrum for likelihood code = /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/ +P_k_max_1/Mpc = 1 +# diff --git a/soliket/ymap/data/tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt b/soliket/ymap/data/tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt new file mode 100644 index 00000000..6143369d --- /dev/null +++ b/soliket/ymap/data/tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt @@ -0,0 +1,18 @@ +2.985813e-01 2.496598e-01 1.960266e-01 1.473473e-01 1.053946e-01 7.028899e-02 4.431999e-02 2.686686e-02 1.553374e-02 8.619753e-03 4.652101e-03 2.462538e-03 1.267574e-03 6.364955e-04 3.155817e-04 1.547027e-04 7.497380e-05 3.603524e-05 +2.496598e-01 2.243210e-01 1.887662e-01 1.512092e-01 1.149424e-01 8.147952e-02 5.444372e-02 3.479401e-02 2.111681e-02 1.223873e-02 6.859498e-03 3.749645e-03 1.984054e-03 1.019803e-03 5.154987e-04 2.567551e-04 1.260592e-04 6.122762e-05 +1.960266e-01 1.887662e-01 1.699480e-01 1.449536e-01 1.170918e-01 8.829436e-02 6.262714e-02 4.230340e-02 2.704175e-02 1.643525e-02 9.607605e-03 5.447092e-03 2.975273e-03 1.571517e-03 8.126862e-04 4.125061e-04 2.057153e-04 1.011961e-04 +1.473473e-01 1.512092e-01 1.449536e-01 1.311447e-01 1.122312e-01 8.980637e-02 6.751323e-02 4.817163e-02 3.244343e-02 2.070277e-02 1.264705e-02 7.454810e-03 4.214685e-03 2.293912e-03 1.216735e-03 6.308719e-04 3.202372e-04 1.598439e-04 +1.053946e-01 1.149424e-01 1.170918e-01 1.122312e-01 1.016856e-01 8.634101e-02 6.883669e-02 5.194877e-02 3.693727e-02 2.481504e-02 1.589428e-02 9.776924e-03 5.744197e-03 3.234538e-03 1.766472e-03 9.388607e-04 4.865964e-04 2.471101e-04 +7.028899e-02 8.147952e-02 8.829436e-02 8.980637e-02 8.634101e-02 7.802572e-02 6.621260e-02 5.307084e-02 4.002909e-02 2.846482e-02 1.922789e-02 1.241844e-02 7.630525e-03 4.473768e-03 2.530900e-03 1.386554e-03 7.373962e-04 3.826478e-04 +4.431999e-02 5.444372e-02 6.262714e-02 6.751323e-02 6.883669e-02 6.621260e-02 5.985176e-02 5.102316e-02 4.090997e-02 3.087897e-02 2.207461e-02 1.503048e-02 9.703740e-03 5.953825e-03 3.507179e-03 1.990633e-03 1.091486e-03 5.812354e-04 +2.686686e-02 3.479401e-02 4.230340e-02 4.817163e-02 5.194877e-02 5.307084e-02 5.102316e-02 4.622431e-02 3.939123e-02 3.157646e-02 2.391911e-02 1.720389e-02 1.170184e-02 7.539188e-03 4.642264e-03 2.741136e-03 1.556063e-03 8.537144e-04 +1.553374e-02 2.111681e-02 2.704175e-02 3.244343e-02 3.693727e-02 4.002909e-02 4.090997e-02 3.939123e-02 3.570508e-02 3.043970e-02 2.448301e-02 1.865140e-02 1.341102e-02 9.109614e-03 5.890208e-03 3.636082e-03 2.147798e-03 1.220024e-03 +8.619753e-03 1.223873e-02 1.643525e-02 2.070277e-02 2.481504e-02 2.846482e-02 3.087897e-02 3.157646e-02 3.043970e-02 2.761383e-02 2.361045e-02 1.908543e-02 1.454324e-02 1.044877e-02 7.121986e-03 4.616588e-03 2.851147e-03 1.685052e-03 +4.652101e-03 6.859498e-03 9.607605e-03 1.264705e-02 1.589428e-02 1.922789e-02 2.207461e-02 2.391911e-02 2.448301e-02 2.361045e-02 2.145355e-02 1.840757e-02 1.488015e-02 1.132747e-02 8.159007e-03 5.570972e-03 3.610579e-03 2.229308e-03 +2.462538e-03 3.749645e-03 5.447092e-03 7.454810e-03 9.776924e-03 1.241844e-02 1.503048e-02 1.720389e-02 1.865140e-02 1.908543e-02 1.840757e-02 1.675546e-02 1.437006e-02 1.159938e-02 8.841691e-03 6.372594e-03 4.346205e-03 2.812844e-03 +1.267574e-03 1.984054e-03 2.975273e-03 4.214685e-03 5.744197e-03 7.630525e-03 9.703740e-03 1.170184e-02 1.341102e-02 1.454324e-02 1.488015e-02 1.437006e-02 1.308431e-02 1.121357e-02 9.062678e-03 6.912193e-03 4.976169e-03 3.387964e-03 +6.364955e-04 1.019803e-03 1.571517e-03 2.293912e-03 3.234538e-03 4.473768e-03 5.953825e-03 7.539188e-03 9.109614e-03 1.044877e-02 1.132747e-02 1.159938e-02 1.121357e-02 1.021045e-02 8.760226e-03 7.083234e-03 5.395524e-03 3.875965e-03 +3.155817e-04 5.154987e-04 8.126862e-04 1.216735e-03 1.766472e-03 2.530900e-03 3.507179e-03 4.642264e-03 5.890208e-03 7.121986e-03 8.159007e-03 8.841691e-03 9.062678e-03 8.760226e-03 7.977148e-03 6.840147e-03 5.518010e-03 4.188661e-03 +1.547027e-04 2.567551e-04 4.125061e-04 6.308719e-04 9.388607e-04 1.386554e-03 1.990633e-03 2.741136e-03 3.636082e-03 4.616588e-03 5.570972e-03 6.372594e-03 6.912193e-03 7.083234e-03 6.840147e-03 6.218313e-03 5.313977e-03 4.265902e-03 +7.497380e-05 1.260592e-04 2.057153e-04 3.202372e-04 4.865964e-04 7.373962e-04 1.091486e-03 1.556063e-03 2.147798e-03 2.851147e-03 3.610579e-03 4.346205e-03 4.976169e-03 5.395524e-03 5.518010e-03 5.313977e-03 4.809139e-03 4.083690e-03 +3.603524e-05 6.122762e-05 1.011961e-04 1.598439e-04 2.471101e-04 3.826478e-04 5.812354e-04 8.537144e-04 1.220024e-03 1.685052e-03 2.229308e-03 2.812844e-03 3.387964e-03 3.875965e-03 4.188661e-03 4.265902e-03 4.083690e-03 3.665633e-03 diff --git a/soliket/ymap/input_files/sz_input.yaml b/soliket/ymap/input_files/sz_input.yaml new file mode 100644 index 00000000..4a2a7d0d --- /dev/null +++ b/soliket/ymap/input_files/sz_input.yaml @@ -0,0 +1,224 @@ +output: /project/r/rbond/ymehta3/output/param-fitting/mcmcresults/sz_test + +likelihood: + soliket.ymap.ymap_ps.SZLikelihood: + # sz_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/" + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + + + +theory: + soliket.ymap.ymap_ps.SZForegroundTheory: + # speed: 2 + # foreground_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap" + # foreground_data_file: "data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt" + + + + soliket.ymap.classy_sz: + extra_args: + output : 'tSZ_1h, tCl' + units for tSZ spectrum : 'dimensionless' + component of tSZ power spectrum : 'total' + # write sz results to files : 'no' + mass function : 'M500' + # integrate_wrt_m500c : 1 + pressure profile : 'A10' + multipoles_sz : 'P15' + nlSZ : 18 + + z_min : 0.005 + z_max : 3.0 + M_min : 1.0e10 + M_max : 3.5e15 + z_max_pk : 4. + + non_linear: 'halofit' + k_per_decade_class_sz : 20. + k_min_for_pk_class_sz : 1e-3 + k_max_for_pk_class_sz : 1e1 + + perturbations_verbose: 10 + thermodynamics_verbose: 10 + background_verbose: 10 + class_sz_verbose: 10 + spectra_verbose: 10 + + # harmonic_verbose: 0 + # fourier_verbose : 0 + input_verbose : 10 + # lensing_verbose : 0 + # The base model features two massless + # and one massive neutrino with m=0.06eV. + # The settings below ensures that Neff=3.046 + # and m/omega = 93.14 eV + N_ur : 2.0328 + N_ncdm : 1 + m_ncdm : 0.06 + T_ncdm : 0.71611 + YHe: 'BBN' + # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 and n_arraySZ=1000 + # [relevant for tabulation of sigma(R,z)] + # ndimSZ: 50 + # n_arraySZ: 50 + #write parameters : 'yeap' + + + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + + +params: + A_CIB: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 0.66 + scale: 0.16 + proposal: 0.16 + latex: A_\mathrm{CIB} + + A_RS: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 0.004 + scale: 0.34 + proposal: 0.34 + latex: A_\mathrm{RS} + + A_IR: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 2.04 + scale: 0.18 + proposal: 0.18 + latex: A_\mathrm{IR} + + B: + prior: + min: 1.0 + max: 2.0 + ref: + dist: norm + loc: 1.4 + scale: 0.2 + proposal: 0.2 + latex: B + + omega_b: + prior: + min: 0.02 + max: 0.025 + ref: + dist: norm + loc: 0.0224 + scale: 0.00015 + proposal: 0.00015 + latex: \Omega_\mathrm{b} h^2 + + omega_cdm: + prior: + min: 0.11 + max: 0.13 + ref: + dist: norm + loc: 0.1202 + scale: 0.0014 + proposal: 0.0014 + latex: \Omega_\mathrm{c} h^2 + + A_s: + prior: + min: 0.1e-9 + max: 10e-9 + ref: + dist: norm + loc: 2.1e-9 + scale: 0.032e-9 + proposal: 0.032e-9 + latex: A_\mathrm{s} + + n_s: + prior: + min: 0.94 + max: 1. + ref: + dist: norm + loc: 0.965 + scale: 0.0044 + proposal: 0.0044 + latex: n_\mathrm{s} + + # nb: No need to sample tau_reio when doing tsz runs without cmb anisotropy. + # tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.055 + # scale: 0.006 + # proposal: 0.003 + # latex: \tau_\mathrm{reio} + + H0: + prior: + min: 55. + max: 90. + ref: + dist: norm + loc: 67.27 + scale: 0.6 + proposal: 0.6 + latex: H_0 + + # add derived parameter, e.g.: + Omega_m: + latex: \Omega_\mathrm{m} + sigma8: + latex: \sigma_8 + F_sz: + derived: 'lambda sigma8, Omega_m, B, H0: (sigma8/0.8)*(Omega_m/0.3)**0.35*(B/1.25)**-0.35*(H0/70.)**-0.20' + latex: F_\mathrm{sz} + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + # mcmc: + # covmat: #auto + # Rminus1_stop: 0.01 + # drag: true + # proposal_scale: 2.4 + # learn_proposal: True + # learn_proposal_Rminus1_max: 2. + + evaluate: + override: + # #parameter values: + # Bolliet et al 2018 best-fit (see figure 3) + B: 1.41 + omega_cdm: 0.125 + omega_b: 0.0224 + A_s: 1.9e-9 + n_s: 0.96 + H0: 69. + A_CIB: 0.66 + A_IR: 2.04 + A_RS: 0.0004 + + + +debug : True diff --git a/soliket/ymap/input_files/sz_input_fast.yaml b/soliket/ymap/input_files/sz_input_fast.yaml new file mode 100644 index 00000000..3e1c5e69 --- /dev/null +++ b/soliket/ymap/input_files/sz_input_fast.yaml @@ -0,0 +1,263 @@ +output: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/sz_total-planck-collab-15_step_1_test + +likelihood: + soliket.ymap.ymap_ps.SZLikelihood: + # sz_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/" + # ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + # f_sky: 0.47 #sky_fraction of Planck y-map (communicated by Barbara Commis) + # trispectrum_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/" + # trispectrum_ref: "tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt" + + + +theory: + soliket.ymap.ymap_ps.SZForegroundTheory: + # speed: 2 + # foreground_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap" + # foreground_data_file: "data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt" + + + classy_szfast.classy_sz.classy_sz: + use_class_sz_fast_mode: 1 + extra_args: + output : 'tSZ_1h' + units for tSZ spectrum : 'dimensionless' + component of tSZ power spectrum : 'total' + # write sz results to files : 'no' + mass function : 'M500' + # integrate_wrt_m500c : 1 + pressure profile : 'A10' + multipoles_sz : 'P15' + nlSZ : 18 + + z_min : 0.005 + z_max : 3.0 + M_min : 1.0e10 + M_max : 3.5e15 + # z_max_pk : 4. + + # non_linear: 'halofit' + # k_per_decade_class_sz : 20. + # k_min_for_pk_class_sz : 1e-3 + # k_max_for_pk_class_sz : 1e1 + + perturbations_verbose: 0 + thermodynamics_verbose: 0 + background_verbose: 0 + class_sz_verbose: 0 + spectra_verbose: 0 + + # harmonic_verbose: 0 + # fourier_verbose : 0 + input_verbose : 0 + # lensing_verbose : 0 + # The base model features two massless + # and one massive neutrino with m=0.06eV. + # The settings below ensures that Neff=3.046 + # and m/omega = 93.14 eV + N_ur : 2.0328 + N_ncdm : 1 + m_ncdm : 0.06 + T_ncdm : 0.71611 + YHe: 'BBN' + + # + # n_k_pressure_profile : 80 # this is l/ls + # n_m_pressure_profile : 30 # default: 100, decrease for faster + # n_z_pressure_profile : 30 # default: 100, decrease for faster + # + # k_min_gas_pressure_profile : 1e-3 # l/ls hence no need for very extreme values... + # k_max_gas_pressure_profile : 1e2 + # + # + # k_min_samp_fftw : 1e-3 + # k_max_samp_fftw : 1e3 + # N_samp_fftw : 100, + # + # + # hm_consistency : 1 + # + # + # use_fft_for_profiles_transform : 1 + # x_min_gas_pressure_fftw : 1e-5 + # x_max_gas_pressure_fftw : 1e2 + + + # ndim_masses : 500 + ndim_redshifts : 30 + + # following parameters (50,50) give less than 1% difference w.r.t. ndimSZ = 100 and n_arraySZ=1000 + # [relevant for tabulation of sigma(R,z)] + # ndimSZ: 50 + # n_arraySZ: 50 + #write parameters : 'yeap' + + + # create reference trispectrum for likelihood code: 'NO' + # append_name_trispectrum_ref: 'total-planck-collab-15_step_1' + # path to reference trispectrum for likelihood code: '/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_completeness_analysis/' + + + +params: + A_CIB: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 0.66 + scale: 0.16 + proposal: 0.16 + latex: A_\mathrm{CIB} + + A_RS: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 0.004 + scale: 0.34 + proposal: 0.34 + latex: A_\mathrm{RS} + + A_IR: + prior: + min: 0 + max: 5 + ref: + dist: norm + loc: 2.04 + scale: 0.18 + proposal: 0.18 + latex: A_\mathrm{IR} + + B: + prior: + min: 1.0 + max: 2.0 + ref: + dist: norm + loc: 1.4 + scale: 0.2 + proposal: 0.2 + latex: B + + omega_b: + prior: + min: 0.02 + max: 0.025 + ref: + dist: norm + loc: 0.0224 + scale: 0.00015 + proposal: 0.00015 + latex: \Omega_\mathrm{b} h^2 + + omega_cdm: + prior: + min: 0.11 + max: 0.13 + ref: + dist: norm + loc: 0.1202 + scale: 0.0014 + proposal: 0.0014 + latex: \Omega_\mathrm{c} h^2 + + # A_s: + # prior: + # min: 0.1e-9 + # max: 10e-9 + # ref: + # dist: norm + # loc: 2.1e-9 + # scale: 0.032e-9 + # proposal: 0.032e-9 + # latex: A_\mathrm{s} + + logA: + latex: ln10^{10}A_s + prior: + max: 3.5 + min: 2.5 + proposal: 0.12892144 + ref: + dist: norm + loc: 2.9939341 + scale: 0.12892144 + tau_reio: 0.055 + n_s: + prior: + min: 0.94 + max: 1. + ref: + dist: norm + loc: 0.965 + scale: 0.0044 + proposal: 0.0044 + latex: n_\mathrm{s} + + # nb: No need to sample tau_reio when doing tsz runs without cmb anisotropy. + # tau_reio: + # prior: + # min: 0.01 + # max: 0.8 + # ref: + # dist: norm + # loc: 0.055 + # scale: 0.006 + # proposal: 0.003 + # latex: \tau_\mathrm{reio} + + H0: + prior: + min: 55. + max: 90. + ref: + dist: norm + loc: 67.27 + scale: 0.6 + proposal: 0.6 + latex: H_0 + + # add derived parameter, e.g.: + # Omega_m: + # latex: \Omega_\mathrm{m} + # sigma8: + # latex: \sigma_8 + # F_sz: + # derived: 'lambda sigma8, Omega_m, B, H0: (sigma8/0.8)*(Omega_m/0.3)**0.35*(B/1.25)**-0.35*(H0/70.)**-0.20' + # latex: F_\mathrm{sz} + + +sampler: + #settings for covmat see https://cobaya.readthedocs.io/en/latest/sampler_mcmc.html + # mcmc: + # covmat: #auto + # Rminus1_stop: 0.01 + # drag: true + # proposal_scale: 2.4 + # learn_proposal: True + # learn_proposal_Rminus1_max: 2. + + evaluate: + override: + # #parameter values: + # Bolliet et al 2018 best-fit (see figure 3) + B: 1.41 + omega_cdm: 0.125 + omega_b: 0.0224 + # A_s: 1.9e-9 + logA: 3.05321 + n_s: 0.96 + H0: 69. + A_CIB: 0.66 + A_IR: 2.04 + A_RS: 0.0004 + + + +debug : False +timing: True diff --git a/soliket/ymap/input_files/sz_ps_bandpower.yaml b/soliket/ymap/input_files/sz_ps_bandpower.yaml new file mode 100644 index 00000000..4b3185de --- /dev/null +++ b/soliket/ymap/input_files/sz_ps_bandpower.yaml @@ -0,0 +1,258 @@ +output: /Users/boris/Work/CLASS-SZ/ATSZ_ACMB/analysis/chains/ymap_bandpower_fit + +likelihood: + solike.SZ_PS_bandpower_Likelihood: + #use_trispectrum: "no" + sz_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/" + ymap_ps_file: "data_ps-ell-y2-erry2_total-planck-collab-15.txt" + #trispectrum_directory: /Users/boris/Work/CLASS-SZ/ATSZ_ACMB/analysis/ + #trispectrum_ref: tSZ_trispectrum_ref_sz_ps_total_planck18_cosmo_and_bias_B_1d58.txt + #f_sky: 0.47 + +params: + A_cib: + latex: A_\mathrm{CIB} + prior: + max: 5 + min: 0 + proposal: 0.16 + ref: + dist: norm + loc: 0.66 + scale: 0.16 + A_ir: + latex: A_\mathrm{IR} + prior: + max: 5 + min: 0 + proposal: 0.18 + ref: + dist: norm + loc: 2.04 + scale: 0.18 + A_rs: + latex: A_\mathrm{RS} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 0.004 + scale: 0.04 + A_sz_1: + latex: A_\mathrm{sz,1} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 6.462417e-03 + scale: 0.04 + A_sz_2: + latex: A_\mathrm{sz,2} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 8.642066e-03 + scale: 0.04 + A_sz_3: + latex: A_\mathrm{sz,3} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 1.145088e-02 + scale: 0.04 + A_sz_4: + latex: A_\mathrm{sz,4} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 1.489282e-02 + scale: 0.04 + A_sz_5: + latex: A_\mathrm{sz,5} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 1.928490e-02 + scale: 0.04 + A_sz_6: + latex: A_\mathrm{sz,6} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 2.525991e-02 + scale: 0.04 + A_sz_7: + latex: A_\mathrm{sz,7} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 3.313562e-02 + scale: 0.04 + A_sz_8: + latex: A_\mathrm{sz,8} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 4.321872e-02 + scale: 0.04 + A_sz_9: + latex: A_\mathrm{sz,9} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 5.642358e-02 + scale: 0.04 + A_sz_10: + latex: A_\mathrm{sz,10} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 7.361454e-02 + scale: 0.04 + A_sz_11: + latex: A_\mathrm{sz,11} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 9.555227e-02 + scale: 0.04 + A_sz_12: + latex: A_\mathrm{sz,12} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 1.231347e-01 + scale: 0.04 + A_sz_13: + latex: A_\mathrm{sz,13} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 1.581388e-01 + scale: 0.04 + A_sz_14: + latex: A_\mathrm{sz,14} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 2.020091e-01 + scale: 0.04 + A_sz_15: + latex: A_\mathrm{sz,15} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 2.552607e-01 + scale: 0.04 + A_sz_16: + latex: A_\mathrm{sz,16} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 3.183918e-01 + scale: 0.04 + A_sz_17: + latex: A_\mathrm{sz,17} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 3.910665e-01 + scale: 0.04 + A_sz_18: + latex: A_\mathrm{sz,18} + prior: + max: 5 + min: 0 + proposal: 0.04 + ref: + dist: norm + loc: 4.710884e-01 + scale: 0.04 + alpha_cib: 0 + # latex: \alpha_\mathrm{cib} + # prior: + # max: 3. + # min: -1. + # proposal: 0.04 + # ref: + # dist: norm + # loc: 1. + # scale: 0.04 + + # b: + # derived: 'lambda A_sz: 1.-1./(1.48*(A_sz)**(-1./3.2))' + # latex: b + # + # B: + # derived: 'lambda A_sz: 1.48*(A_sz)**(-1./3.2)' + # latex: B + +sampler: + mcmc: + covmat: auto + Rminus1_stop: 0.001 + learn_proposal: True + #drag: true + proposal_scale: 2.4 + max_tries: 5000 + +theory: + solike.SZ_PS_bandpower_Theory: + #tsz_template_file: tSZ_c_ell_ref_sz_ps_total_planck18_cosmo_and_bias_B_1d48.txt + #tsz_template_directory: /Users/boris/Work/CLASS-SZ/ATSZ_ACMB/analysis/ + foreground_template_directory: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/ + foreground_template_file: data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt + #use_2halo: "no" + ell_pivot_cib: 200. diff --git a/soliket/ymap/input_files/sz_ps_template.yaml b/soliket/ymap/input_files/sz_ps_template.yaml new file mode 100644 index 00000000..bcfed7f6 --- /dev/null +++ b/soliket/ymap/input_files/sz_ps_template.yaml @@ -0,0 +1,76 @@ +output: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_template/sz_unresolved_snr6_linear_fit_1h_and_2h_fg_from_total_trispectrum_from_full_mcmc + +likelihood: + solike.SZ_PS_template_Likelihood: + use_trispectrum: "yes" + sz_data_directory: "/Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/" + ymap_ps_file: "data_ps-ell-y2-erry2_diffuse-rotti++20.txt" + trispectrum_directory: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_template/ + trispectrum_ref: tSZ_trispectrum_ref_diffuse-rotti++20-snr6-2h_step_5.txt + f_sky: 0.35443 + +params: + A_cib: + latex: A_\mathrm{CIB} + prior: + max: 5 + min: 0 + proposal: 0.16 + ref: + dist: norm + loc: 0.66 + scale: 0.16 + A_ir: + latex: A_\mathrm{IR} + prior: + max: 5 + min: 0 + proposal: 0.18 + ref: + dist: norm + loc: 2.04 + scale: 0.18 + A_rs: + latex: A_\mathrm{RS} + prior: + max: 5 + min: 0 + proposal: 0.34 + ref: + dist: norm + loc: 0.004 + scale: 0.34 + A_sz: + latex: A_\mathrm{sz} + prior: + max: 5 + min: 0 + proposal: 0.34 + ref: + dist: norm + loc: 1. + scale: 0.34 + b: + derived: 'lambda A_sz: 1.-1./(1.25*(A_sz)**(-1./3.2))' + latex: b + + B: + derived: 'lambda A_sz: 1.25*(A_sz)**(-1./3.2)' + latex: B + +sampler: + mcmc: + covmat: auto + Rminus1_stop: 0.001 + learn_proposal: True + #drag: true + proposal_scale: 2.4 + max_tries: 5000 + +theory: + solike.SZ_PS_template_Theory: + tsz_template_file: tSZ_c_ell_ref_planck18_cosmo_and_bias_0.2.txt + tsz_template_directory: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/chains/sz_ps_template/ + foreground_template_directory: /Users/boris/Work/CLASS-SZ/SO-SZ/Likelihoods_sz/solike/ymap/data/planck_2015_ymap/ + foreground_template_file: data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt + use_2halo: "yes" diff --git a/soliket/ymap/ymap_ps.py b/soliket/ymap/ymap_ps.py new file mode 100644 index 00000000..567393c1 --- /dev/null +++ b/soliket/ymap/ymap_ps.py @@ -0,0 +1,187 @@ +""" +.. module:: sz power spectrum likelihood (in progress) + +""" + +# Acronyms: +# ps: power spectrum +# fg: foregrounds +# cib: cosmic infrared background +# rs: radio sources +# ir: infrared sources +# f_sky: sky fraction + + +from cobaya.theory import Theory +# from cobaya.conventions import _packages_path +_packages_path = 'packages_path' +# from cobaya.likelihoods._base_classes import _InstallableLikelihood +from soliket.gaussian import GaussianLikelihood +import numpy as np +import os +from scipy.ndimage.interpolation import shift +from typing import Optional, Sequence +from pkg_resources import resource_filename + + + +class SZLikelihood(GaussianLikelihood): + sz_data_directory: Optional[str] = resource_filename( + "soliket", "ymap/data/" + ) + ymap_ps_file: Optional[str] = 'data_ps-ell-y2-erry2_total-planck-collab-15.txt' + f_sky: Optional[str] = 0.47 + trispectrum_directory: Optional[str] = resource_filename( + "soliket", "ymap/data/" + ) + trispectrum_ref: Optional[str] = 'tSZ_trispectrum_ref_total-planck-collab-15_step_1.txt' + use_trispectrum: Optional[str] = 'no' + + + def initialize(self): + # print('Initialize') + # exit(0) + self.data_directory = self.sz_data_directory + self.datafile = self.ymap_ps_file + + D = np.loadtxt(os.path.join(self.data_directory, self.datafile)) + + #fill arrays with Planck tSZ and FG data + self.ell_plc = D[:,0] + self.y2AndFg_plc = D[:,1] + self.sigma_tot_plc = D[:,2] + + + #number of data points (multipole bins) + self.num_points = np.shape(self.ell_plc)[0] + + + self.fid_values_exist = False + + fiducial_file_covmat = self.trispectrum_ref + fiducial_file_cell = self.trispectrum_ref.replace("trispectrum","c_ell") + fiducial_file_params = self.trispectrum_ref.replace("trispectrum","params") + + + + self.fiducial_file_params = fiducial_file_params + self.fiducial_file_cell = fiducial_file_cell + self.fiducial_file_covmat = fiducial_file_covmat + #If reference trispectrum is available -> read in the values + if os.path.exists(os.path.join(self.trispectrum_directory, self.fiducial_file_params)): + self.fid_values_exist = True + #read-in the fiducial data + D = np.loadtxt(os.path.join(self.trispectrum_directory, self.fiducial_file_cell)) + self.ell = D[:,0] + self.data = D[:,1] + + #check that the reference tSZ data is computed at same multipoles as planck data + try: + if(np.any(self.ell-self.ell_plc)): + print("[reading ref tSZ files] the reference multipoles do not match the planck data.") + exit(0) + except ValueError: + print("[reading ref tSZ files] the reference multipoles do not match the planck data.") + exit(0) + + #Binning of covmat [not used for planck sz] + #compute number of multipoles in each bin + #[useful when we need to comput ethe gaussian sample variance] + #[not used in the original planck likelihood as sigma_G is tabulated] + #multipoles_bin_center = self.ell + #mp_shift = shift(multipoles_bin_center, -1, cval=np.NaN) + #diff_ell_shift = mp_shift - multipoles_bin_center + #diff_ell_up = diff_ell_shift + #diff_ell_up[len(diff_ell_shift)-1] = diff_ell_shift[len(diff_ell_shift)-2] + #mp_shift = shift(multipoles_bin_center, 1, cval=np.NaN) + #diff_ell_shift = -mp_shift + multipoles_bin_center + #diff_ell_down = diff_ell_shift + #diff_ell_down[0] = diff_ell_shift[1] + #nell = (diff_ell_up + diff_ell_down)/2. + #Compute sigma_G^2 + #self.cvg =1./self.f_sky*(np.asarray(self.data)*np.sqrt(2./(2.*np.asarray(self.ell)+1.)))**2./nell + + #For the planck likelihood we read-in the values of sigma_G: + self.cvg = np.asarray(self.sigma_tot_plc)**2. + self.cvg = np.diag(self.cvg) + self.covmat = np.asarray(np.loadtxt(os.path.join(self.trispectrum_directory, self.fiducial_file_covmat))) + #Add sigm_NG (trispectrum strored in self.covmat) to sigma_G (stored in self.cvg) + if self.use_trispectrum == 'yes': + print('Using both Gaussian and Non-Gaussian sampling variance') + self.covmat = self.covmat/self.f_sky/4./np.pi + self.cvg + else: + print('Using only Gaussian sampling variance') + self.covmat = self.cvg + #print(self.covmat) + self.inv_covmat = np.linalg.inv(self.covmat) + self.det_covmat = np.linalg.det(self.covmat) + #print(np.linalg.eig(self.covmat)) + print('[reading ref tSZ files] read-in completed.') + else: + print('[reading ref tSZ files] reference trispectrum unavailable -> you need to create a cobaya_reference_trispectrum.') + self.covmat = np.identity(self.num_points) + super().initialize() + + + def get_requirements(self): + return {"Cl_sz_foreground": {}, "Cl_sz": {}} + + def _get_data(self): + ell = self.ell_plc + Cl_sz = self.y2AndFg_plc + return ell, Cl_sz + + def _get_cov(self): + cov = self.covmat + return cov + + + def _get_theory(self, **params_values): + theory = self.theory.get_Cl_sz() + cl_1h_theory = theory['1h'] + cl_2h_theory = theory['2h'] + Cl_sz = np.asarray(list(cl_1h_theory)) + np.asarray(list(cl_2h_theory)) + Cl_sz_foreground = self.provider.get_Cl_sz_foreground() + return Cl_sz + Cl_sz_foreground + + + +class SZForegroundTheory(Theory): + + params = {"A_CIB": 0, "A_RS": 0, "A_IR": 0} + + foreground_data_directory: Optional[str] = resource_filename( + "soliket", "ymap/data/" + ) + foreground_data_file: Optional[str] = "data_fg-ell-cib_rs_ir_cn-total-planck-collab-15.txt" + + def initialize(self): + self.datafile = self.foreground_data_file + self.data_directory = self.foreground_data_directory + + D = np.loadtxt(os.path.join(self.data_directory, self.datafile)) + + #fill arrays with Planck FG data + self.A_CIB_MODEL = D[:,1] + self.A_RS_MODEL = D[:,2] + self.A_IR_MODEL = D[:,3] + self.A_CN_MODEL = D[:,4] + + + def calculate(self, state, want_derived=False, **params_values_dict): + #... + #foreground residua amplitudes [TBD] + A_CIB = params_values_dict['A_CIB'] + A_RS = params_values_dict['A_RS'] + A_IR = params_values_dict['A_IR'] + # A_CN amplitude is set by looking at + # SZ_and_fg_models-high_ell.txt at high multipole (ell = 2742), + # where the correlated noise largely dominates over the other + # components (see Bolliet et al. 1712.00788). + A_CN = 0.9033 + #print(state) + + state["Cl_sz_foreground"] = A_CIB*self.A_CIB_MODEL + A_RS*self.A_RS_MODEL + A_IR*self.A_IR_MODEL + A_CN*self.A_CN_MODEL + + def get_Cl_sz_foreground(self): + return self._current_state['Cl_sz_foreground'] diff --git a/soliket/ymap/ymap_ps_bandpower.py b/soliket/ymap/ymap_ps_bandpower.py new file mode 100644 index 00000000..6f46cb3e --- /dev/null +++ b/soliket/ymap/ymap_ps_bandpower.py @@ -0,0 +1,232 @@ +""" +.. module:: sz_template + +:Synopsis: Definition of simplistic y-map power spectrum likelihood using pre-computed frequency dependent templates + for sz powerspectrum (A_sz), and foregrounds, e.g., A_cib, A_ir, A_rs, A_cn. + +:Author: Boris Bolliet 2020 + +:running: $ /Users/boris/opt/anaconda3/bin/mpirun -np 4 /Users/boris/opt/anaconda3/bin/cobaya-run solike/ymap/input_files/sz_template_input.yaml -f +""" + + +from cobaya.theory import Theory +from cobaya.conventions import _packages_path +from solike.gaussian import GaussianLikelihood +import numpy as np +import os +from scipy.ndimage.interpolation import shift +from typing import Optional, Sequence +from scipy.linalg import block_diag + + +# Acronyms: +# ps: power spectrum +# fg: foregrounds +# cib: cosmic infrared background +# rs: radio sources +# ir: infrared sources +# f_sky: sky fraction + +class SZ_PS_bandpower_Likelihood(GaussianLikelihood): + sz_data_directory: Optional[str] = None + ymap_ps_file: Optional[str] = None + #f_sky: Optional[str] = None + #trispectrum_directory: Optional[str] = None + #trispectrum_ref: Optional[str] = None + #use_trispectrum: Optional[str] = None + + # Load the templates + def initialize(self): + self.data_directory = self.sz_data_directory + self.datafile = self.ymap_ps_file + + D = np.loadtxt(os.path.join(self.data_directory, self.datafile)) + + # fill arrays with binned Planck tSZ and FG data + # these is the data points to fit + + # multipoles of bin centre + self.ell = D[:,0] + # tSZ + foregrounds + self.y2AndFg = D[:,1] + # Gaussian error, includes noise from the map + self.sigma_tot = D[:,2] + + + # Now start building the covariance matrix: + # diagonal terms has gaussian contribution: + # this includes the fsky factor. + self.cvg = np.asarray(self.sigma_tot)**2. + self.cvg = np.diag(self.cvg) + # and non-gaussian contribution is the trispectrum + # computed by class_sz in the file + # tSZ_trispectrum_ref_XXX.txt + # self.covmat = np.asarray(np.loadtxt(os.path.join(self.trispectrum_directory, self.trispectrum_ref))) + # # if requested: + # # Add sigm_NG (trispectrum strored in self.covmat) to sigma_G (stored in self.cvg) + # if self.use_trispectrum == 'yes': + # print('Using both Gaussian and Non-Gaussian sampling variance') + # # put the correct Omega_sky,f_sky factor for the non gaussian part + # self.covmat = self.covmat/self.f_sky/4./np.pi + self.cvg + # # if not, just use gaussian terms + # else: + # print('Using only Gaussian sampling variance') + # self.covmat = self.cvg + + # we use the diagonal covariance from Planck paper + self.covmat = self.cvg + + # now compute the iverse and det of covariance matrix + self.inv_covmat = np.linalg.inv(self.covmat) + self.det_covmat = np.linalg.det(self.covmat) + #print(np.linalg.eig(self.covmat)) + print('[reading ref tSZ files] read-in completed.') + + + + super().initialize() + + + def get_requirements(self): + return {"cl_yy_theory": {}} + + # this is the data to fit + def _get_data(self): + x_data = self.ell + y_data = self.y2AndFg + return x_data, y_data + + def _get_cov(self): + cov = self.covmat + return cov + + + def _get_theory(self, **params_values): + cl_yy_theory = self.provider.get_cl_yy_theory() + #difference = self.y2AndFg-cl_yy_theory + # print(difference) + # print(self.sigma) + + #AT = np.dot(difference, np.dot(self.inv_covmat, difference)) + #chi2 = AT + #print(- 0.5*chi2 -0.5*np.log(self.det_covmat)) + #print(chi2) + #print(np.sum(self.I0-DI_theory)) + return cl_yy_theory + + + +class SZ_PS_bandpower_Theory(Theory): + + params = { + "A_sz_1": 0, + "A_sz_2": 0, + "A_sz_3": 0, + "A_sz_4": 0, + "A_sz_5": 0, + "A_sz_6": 0, + "A_sz_7": 0, + "A_sz_8": 0, + "A_sz_9": 0, + "A_sz_10": 0, + "A_sz_11": 0, + "A_sz_12": 0, + "A_sz_13": 0, + "A_sz_14": 0, + "A_sz_15": 0, + "A_sz_16": 0, + "A_sz_17": 0, + "A_sz_18": 0, + "A_cib": 0, + "A_ir": 0, + "A_rs": 0, + "alpha_cib": 0,} + #use_2halo: Optional[str] = None + #tsz_template_file : Optional[str] = None + #tsz_template_directory : Optional[str] = None + foreground_template_directory: Optional[str] = None + foreground_template_file: Optional[str] = None + ell_pivot_cib : Optional[str] = None + + def initialize(self): + + # #read-in the fiducial data for tSZ + # D = np.loadtxt(os.path.join(self.tsz_template_directory, self.tsz_template_file)) + # # tSZ template data points + # # e.g., from the file: tSZ_c_ell_ref_XXX.txt computed by class_sz + # # assuming these are computed at the same bin as the data + # cl_sz_1h = D[:,1] + # cl_sz_2h = D[:,2] + # if self.use_2halo == 'yes': + # print('Using both 1-halo and 2-halo terms') + # self.tSZ_template = cl_sz_1h + cl_sz_2h + # # if not, just use gaussian terms + # else: + # print('Using only 1halo term') + # self.tSZ_template = cl_sz_1h + + + + # similarly read in the foreground templates: + + D = np.loadtxt(os.path.join(self.foreground_template_directory, self.foreground_template_file)) + self.ell = D[:,0] + self.A_CIB_MODEL = D[:,1] + self.A_RS_MODEL = D[:,2] + self.A_IR_MODEL = D[:,3] + self.A_CN_MODEL = D[:,4] + + + + def calculate(self, state, want_derived=False, **params_values_dict): + + + # A_sz_1 = params_values_dict['A_sz_1'] + # A_sz_2 = params_values_dict['A_sz_2'] + # A_sz_3 = params_values_dict['A_sz_3'] + # A_sz_4 = params_values_dict['A_sz_4'] + # A_sz_5 = params_values_dict['A_sz_5'] + # A_sz_6 = params_values_dict['A_sz_6'] + # A_sz_7 = params_values_dict['A_sz_7'] + # A_sz_8 = params_values_dict['A_sz_8'] + # A_sz_9 = params_values_dict['A_sz_9'] + # A_sz_10 = params_values_dict['A_sz_10'] + # A_sz_11 = params_values_dict['A_sz_11'] + # A_sz_12 = params_values_dict['A_sz_12'] + # A_sz_13 = params_values_dict['A_sz_13'] + # A_sz_14 = params_values_dict['A_sz_14'] + # A_sz_15 = params_values_dict['A_sz_15'] + # A_sz_16 = params_values_dict['A_sz_16'] + # A_sz_17 = params_values_dict['A_sz_17'] + # A_sz_18 = params_values_dict['A_sz_18'] + nbins = 18 + tsz = np.zeros(nbins) + + for i in range(1,nbins+1): + p_str = 'A_sz_' + str(i) + tsz[i-1] = params_values_dict[p_str] + + + + A_cib = params_values_dict['A_cib'] + A_ir = params_values_dict['A_ir'] + A_rs = params_values_dict['A_rs'] + A_cn = 0.9033 + + alpha_cib = params_values_dict['alpha_cib'] + + # tsz=A_sz*self.tSZ_template + cib=A_cib*self.A_CIB_MODEL*(self.ell/self.ell_pivot_cib)**alpha_cib + ir=A_ir*self.A_IR_MODEL + rs=A_rs*self.A_RS_MODEL + cn=A_cn*self.A_CN_MODEL + + + + + state["cl_yy_theory"] = tsz + cib + ir + rs + cn + + + def get_cl_yy_theory(self): + return self._current_state['cl_yy_theory'] diff --git a/soliket/ymap/ymap_ps_template.py b/soliket/ymap/ymap_ps_template.py new file mode 100644 index 00000000..1d172815 --- /dev/null +++ b/soliket/ymap/ymap_ps_template.py @@ -0,0 +1,181 @@ +""" +.. module:: sz_template + +:Synopsis: Definition of simplistic y-map power spectrum likelihood using pre-computed frequency dependent templates + for sz powerspectrum (A_sz), and foregrounds, e.g., A_cib, A_ir, A_rs, A_cn. + +:Author: Boris Bolliet 2020 + +:running: $ /Users/boris/opt/anaconda3/bin/mpirun -np 4 /Users/boris/opt/anaconda3/bin/cobaya-run solike/ymap/input_files/sz_template_input.yaml -f +""" + + +from cobaya.theory import Theory +from cobaya.conventions import _packages_path +from solike.gaussian import GaussianLikelihood +import numpy as np +import os +from scipy.ndimage.interpolation import shift +from typing import Optional, Sequence +from scipy.linalg import block_diag + + +# Acronyms: +# ps: power spectrum +# fg: foregrounds +# cib: cosmic infrared background +# rs: radio sources +# ir: infrared sources +# f_sky: sky fraction + +class SZ_PS_template_Likelihood(GaussianLikelihood): + sz_data_directory: Optional[str] = None + ymap_ps_file: Optional[str] = None + f_sky: Optional[str] = None + trispectrum_directory: Optional[str] = None + trispectrum_ref: Optional[str] = None + use_trispectrum: Optional[str] = None + + # Load the templates + def initialize(self): + self.data_directory = self.sz_data_directory + self.datafile = self.ymap_ps_file + + D = np.loadtxt(os.path.join(self.data_directory, self.datafile)) + + # fill arrays with binned Planck tSZ and FG data + # these is the data points to fit + + # multipoles of bin centre + self.ell = D[:,0] + # tSZ + foregrounds + self.y2AndFg = D[:,1] + # Gaussian error, includes noise from the map + self.sigma_tot = D[:,2] + + + # Now start building the covariance matrix: + # diagonal terms has gaussian contribution: + # this includes the fsky factor. + self.cvg = np.asarray(self.sigma_tot)**2. + self.cvg = np.diag(self.cvg) + # and non-gaussian contribution is the trispectrum + # computed by class_sz in the file + # tSZ_trispectrum_ref_XXX.txt + self.covmat = np.asarray(np.loadtxt(os.path.join(self.trispectrum_directory, self.trispectrum_ref))) + # if requested: + # Add sigm_NG (trispectrum strored in self.covmat) to sigma_G (stored in self.cvg) + if self.use_trispectrum == 'yes': + print('Using both Gaussian and Non-Gaussian sampling variance') + # put the correct Omega_sky,f_sky factor for the non gaussian part + self.covmat = self.covmat/self.f_sky/4./np.pi + self.cvg + # if not, just use gaussian terms + else: + print('Using only Gaussian sampling variance') + self.covmat = self.cvg + + # now compute the iverse and det of covariance matrix + self.inv_covmat = np.linalg.inv(self.covmat) + self.det_covmat = np.linalg.det(self.covmat) + #print(np.linalg.eig(self.covmat)) + print('[reading ref tSZ files] read-in completed.') + + + + super().initialize() + + + def get_requirements(self): + return {"cl_yy_theory": {}} + + # this is the data to fit + def _get_data(self): + x_data = self.ell + y_data = self.y2AndFg + return x_data, y_data + + def _get_cov(self): + cov = self.covmat + return cov + + + def _get_theory(self, **params_values): + cl_yy_theory = self.provider.get_cl_yy_theory() + #difference = self.y2AndFg-cl_yy_theory + # print(difference) + # print(self.sigma) + + #AT = np.dot(difference, np.dot(self.inv_covmat, difference)) + #chi2 = AT + #print(- 0.5*chi2 -0.5*np.log(self.det_covmat)) + #print(chi2) + #print(np.sum(self.I0-DI_theory)) + return cl_yy_theory + + + +class SZ_PS_template_Theory(Theory): + + params = {"A_sz": 0, "A_cib": 0, "A_ir": 0, "A_rs": 0, "alpha_cib": 0,} + use_2halo: Optional[str] = None + tsz_template_file : Optional[str] = None + tsz_template_directory : Optional[str] = None + foreground_template_directory: Optional[str] = None + foreground_template_file: Optional[str] = None + ell_pivot_cib : Optional[str] = None + + def initialize(self): + + #read-in the fiducial data for tSZ + D = np.loadtxt(os.path.join(self.tsz_template_directory, self.tsz_template_file)) + # tSZ template data points + # e.g., from the file: tSZ_c_ell_ref_XXX.txt computed by class_sz + # assuming these are computed at the same bin as the data + cl_sz_1h = D[:,1] + cl_sz_2h = D[:,2] + if self.use_2halo == 'yes': + print('Using both 1-halo and 2-halo terms') + self.tSZ_template = cl_sz_1h + cl_sz_2h + # if not, just use gaussian terms + else: + print('Using only 1halo term') + self.tSZ_template = cl_sz_1h + + + + # similarly read in the foreground templates: + + D = np.loadtxt(os.path.join(self.foreground_template_directory, self.foreground_template_file)) + self.ell = D[:,0] + self.A_CIB_MODEL = D[:,1] + self.A_RS_MODEL = D[:,2] + self.A_IR_MODEL = D[:,3] + self.A_CN_MODEL = D[:,4] + + + + def calculate(self, state, want_derived=False, **params_values_dict): + + + A_sz = params_values_dict['A_sz'] + A_cib = params_values_dict['A_cib'] + A_ir = params_values_dict['A_ir'] + A_rs = params_values_dict['A_rs'] + A_cn = 0.9033 + + alpha_cib = params_values_dict['alpha_cib'] + + tsz=A_sz*self.tSZ_template + cib=A_cib*self.A_CIB_MODEL*(self.ell/self.ell_pivot_cib)**alpha_cib + ir=A_ir*self.A_IR_MODEL + rs=A_rs*self.A_RS_MODEL + cn=A_cn*self.A_CN_MODEL + + + + + state["cl_yy_theory"] = tsz + cib + ir + rs + cn + + + def get_cl_yy_theory(self): + return self._current_state['cl_yy_theory']