notebooks/synth_cluster_tutorial-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b7289d5c",
   "metadata": {},
   "source": [
    "# Synthetic Cluster Generation Tutorial Part 2: cluster  member emulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229d95b5",
   "metadata": {},
   "source": [
    "Owner: **Tamas Norbert Varga** @vargatn\n",
    "\n",
    "This notebook relies on one external package in addition to the default desc kernels on NERSC\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0074d7c0",
   "metadata": {},
   "source": [
    "This notebook will describe how to set up, run and postprocess the cluster line-of-sight emulation with the skysampler package. The settings are adapted to DC2 and DESC data products, see Part 1 of the tutorial.\n",
    "\n",
    "\n",
    "**Objectives:**\n",
    "\n",
    "    * Load and collate galaxy catalogs \n",
    "    * Set up cluster line-of-sight emulation script\n",
    "    * INTENSIVE Draw samples from the proposal galaxy catalog and calculate survival scores for rejection sampling.\n",
    "    * Define KDE model for cluster member galaxy features\n",
    "    * Visualize model against simulations\n",
    "\n",
    "Logistics: This notebook is intended to be be run with a python 3 installation of the skysampler package https://github.com/vargatn/skysampler/tree/lsst-dev  \n",
    "\n",
    "Other notes:\n",
    "\n",
    "    Some calculations in this notebook are time consuming, and are optimized for a HPC environment other than NERSC. These cells are currently commented out.\n",
    "    \n",
    "Output:\n",
    "\n",
    "    The results of this notebook are made available on NERSC at /global/cscratch1/sd/tvarga/DC_DATA/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1ecf05eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import fitsio as fio\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import copy\n",
    "import sys\n",
    "import glob\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import healpy as hp\n",
    "import matplotlib as mpl\n",
    "import subprocess as sp\n",
    "\n",
    "import scipy.interpolate as interpolate\n",
    "import pickle as pickle\n",
    "\n",
    "import multiprocessing as mp\n",
    "import skysampler_lsst # this package is installed from https://github.com/LSSTDESC/synth_cluster/tree/main/skysampler_lsst\n",
    "import skysampler_lsst.emulator as emulator\n",
    "import skysampler_lsst.utils as utils\n",
    "from skysampler_lsst.reader import result_reader"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "650fc56f",
   "metadata": {},
   "source": [
    "## Data paths\n",
    " These will vary upon your server data locations, change them accordingly"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f7b35c3",
   "metadata": {},
   "source": [
    " Paths for data preparations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b593942",
   "metadata": {},
   "outputs": [],
   "source": [
    "# redmapper catalog paths\n",
    "redmapper_path = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/dc2_cluster_sim_cutouts/cosmoDC2_v1.1.4_redmapper_v0.7.5_clust.h5\"\n",
    "\n",
    "# cutout paths string\n",
    "cutout_fname_base = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/dc2_cluster_sim_cutouts/clust-{}_dc2-sim-cutout.h5\"\n",
    "# cutout output name\n",
    "cutout_oname = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/dc2_cluster_sim_cutouts/clust_dc2-sim-LOS_v1.h5\"\n",
    "\n",
    "# reference pixel filename input\n",
    "fname_refpixel = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/dc2_cluster_sim_cutouts/cosmoDC2_v1.1.4_refpixel-{}.h5\"\n",
    "# reference pixel filename output\n",
    "oname_refpixel = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/dc2_cluster_sim_cutouts/cosmoDC2_v1.1.4_refpixels.h5\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "369aa64e",
   "metadata": {},
   "source": [
    "Path for resampling calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d6567fa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# paths for calculations\n",
    "root_path = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/resamples/\"\n",
    "deep_data_path = oname_refpixel\n",
    "wide_data_path = cutout_oname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f5c42c55",
   "metadata": {},
   "outputs": [],
   "source": [
    "tag_root = \"dc2-alpha_concentric_sample-v01_test-03\" # this is what the current output files will be saved as"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baba02bc",
   "metadata": {},
   "source": [
    " # Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04263fec",
   "metadata": {},
   "source": [
    "## Concatenate cluster catalog cutouts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2a9b6e6",
   "metadata": {},
   "source": [
    "We are concatenating the galaxy catalog cutouts around clusters. These are initially saved in a separate file for each cluster. For further processing these are saved again in a single file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "93c97daa",
   "metadata": {},
   "outputs": [],
   "source": [
    "clusters = pd.read_hdf(redmapper_path, key=\"data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0d401e88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ii = (clusters[\"richness\"] > 30) & (clusters[\"richness\"] < 60) & (clusters[\"redshift\"] > 0.3) & (clusters[\"redshift\"] < 0.35)\n",
    "ii.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e3a6d37",
   "metadata": {},
   "source": [
    "Note that above we restricts the redshift range to 0.3 - 0.35. This is done as the emulated clusters will be representative of the ensemble properties of the selection. A narrow redshift range minimizes the intrinsic spread in apparent photometry properties.\n",
    "\n",
    "There are 41 clusters in this selection\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "46988736",
   "metadata": {},
   "outputs": [],
   "source": [
    "# table = []\n",
    "# for cid in clusters[ii][\"cluster_id\"]:\n",
    "#     print(cid)\n",
    "#     fname = cutout_fname_base.format(cid)\n",
    "#     tab = pd.read_hdf(fname, key=\"data\")\n",
    "#     tab[\"cluster_id\"] = cid\n",
    "#     tab = tab[tab[\"R\"] < 16 ]\n",
    "#     table.append(tab)\n",
    "# table = pd.concat(table)\n",
    "# table.to_hdf(cutout_oname, key=\"data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68d4cef",
   "metadata": {},
   "source": [
    "## reference field data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d1fab2",
   "metadata": {},
   "source": [
    "Since we saved all galaxies from three randomly selected healpix pixels, we are now concatenating them for further processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "35bd5b5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pixels = [8786, 8791, 9937]\n",
    "# refpixel = []\n",
    "# for pix in pixels:\n",
    "#     print(pix)\n",
    "#     tmp = pd.read_hdf(fname_refpixel.format(pix), key=\"data\")\n",
    "#     refpixel.append(tmp)\n",
    "# refpixel = pd.concat(refpixel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d37edd81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# refpixel[\"R\"] = np.sqrt(np.random.uniform(0, 16**2., size=len(refpixel)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6503d3b",
   "metadata": {},
   "source": [
    "We assign a mock uniform radial profile to reference field galaxies. In case of availability, this can be replaced by the radial profile around random points (such as redmapper randoms). That approach is bit more advanced, and captures the un-evennes and edges in the survey footprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ba0e6093",
   "metadata": {},
   "outputs": [],
   "source": [
    "# refpixel.to_hdf(oname_refpixel, key=\"data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4312a2dc",
   "metadata": {},
   "source": [
    "# Train KDE model and calculate survival scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "16708b5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "NREPEATS = 4 # number of times the full run is repeated\n",
    "NSAMPLES = 1600000 # number of propsal samples to draw\n",
    "NCHUNKS = 160 # number of CPU cores to use\n",
    "bandwidth=0.1 # Gaussian KDE bandwidth in the eigen-feature space after applying PCA\n",
    "\n",
    "# data paths, the code will create a subfolder within root_path based on tag_root\n",
    "\n",
    "# The number of galaxies goes with surface area element, to avoid modeling very un-balanced PDFs \n",
    "# a series of nested concentric segments are modeled consecutively and later stiched together\n",
    "LOGR_DRAW_RMINS = np.array([-3, -0.5, 0., 0.5])\n",
    "LOGR_DRAW_RMAXS = np.array([-0.5, 0., 0.5, 1.2])\n",
    "LOGR_CAT_RMAXS = [0., 0.5, 1.1, 1.2]\n",
    "\n",
    "# feature aliases and definitions from the deep / reference dataset for comparison with the wide dataset\n",
    "deep_c_settings = {\n",
    "    \"columns\": [\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"COLOR_G_R\", (\"mag_g\", \"mag_r\", \"-\")),\n",
    "        (\"COLOR_R_I\", (\"mag_r\", \"mag_i\", \"-\")),\n",
    "    ],\n",
    "    \"logs\": [False, False, False, False],\n",
    "    \"limits\": [(17, 22.5), (-1, 3), (-1, 3), (-1, 3)],\n",
    "}\n",
    "\n",
    "# feature aliases and definitions for all features we want to model and inherit from the deep / reference fields\n",
    "deep_smc_settings = {\n",
    "    \"columns\": [\n",
    "        (\"GABS\", (\"ellipticity_1_true\", \"ellipticity_2_true\", \"SQSUM\")),\n",
    "        (\"SIZE\", \"size_true\"),\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"COLOR_G_R\", (\"mag_g\", \"mag_r\", \"-\")),\n",
    "        (\"COLOR_R_I\", (\"mag_r\", \"mag_i\", \"-\")),\n",
    "        (\"COLOR_I_Z\", (\"mag_i\", \"mag_z\", \"-\")),\n",
    "        (\"STELLAR_MASS\", \"stellar_mass\"),\n",
    "        (\"HALO_MASS\", \"halo_mass\")\n",
    "    ],\n",
    "    \"logs\": [False, True, False, False, False, False, True, True],\n",
    "    \"limits\": [(0., 1.), (-1, 5), (17, 25), (-1, 3), (-1, 3), (-1, 3), (10**3, 10**13), (10**9, 10**16)],\n",
    "}\n",
    "\n",
    "# feature aliases and definitions from wide dataset\n",
    "wide_cr_settings = {\n",
    "    \"columns\": [\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"COLOR_G_R\", (\"mag_g\", \"mag_r\", \"-\")),\n",
    "        (\"COLOR_R_I\", (\"mag_r\", \"mag_i\", \"-\")),\n",
    "        (\"LOGR\", \"R\"),\n",
    "    ],\n",
    "    \"logs\": [False, False, False, True],\n",
    "    \"limits\": [(17, 22.5), (-1, 3), (-1, 3), (1e-3, 16.), ],\n",
    "}\n",
    "\n",
    "# the radial profile around clusters from the wide dataset\n",
    "wide_r_settings = {\n",
    "    \"columns\": [\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"LOGR\", \"R\"),\n",
    "    ],\n",
    "    \"logs\": [False, True,],\n",
    "    \"limits\": [(17, 22.5), (1e-3, 16.),],\n",
    "}\n",
    "# features to use for rejection sampling\n",
    "columns = {\n",
    "    \"cols_dc\": [\"COLOR_G_R\", \"COLOR_R_I\",],\n",
    "    \"cols_wr\": [\"LOGR\",],\n",
    "    \"cols_wcr\": [\"COLOR_G_R\", \"COLOR_R_I\", \"LOGR\",],\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f65c1eb",
   "metadata": {},
   "source": [
    "The below script carries out most heavy lifting calculation\n",
    "\n",
    "1) loading the data\n",
    "\n",
    "2) constructs the features from the above dictionaries\n",
    "\n",
    "3) transforms features into their eigien-space and builds a KDE\n",
    "\n",
    "4) draws NSAMPLES proposal points from the features in  deep_smc_settings \n",
    "\n",
    "5) scores each proposal point based on the KDE models of the other features. (scores are transformed according to PCA jacobian for each feature space)\n",
    "\n",
    "6) saves samples, scores, and jacobian for each draw\n",
    "\n",
    "This section is commented out as it takes a ~few hunderd CPU hours to run and it's not optimized for NERSC job managers. Currently it was ran in a local computing resource at LMU Munich.\n",
    "\n",
    "The results of the calculation are made available on NERSC, so feel free to skip to the next sections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0a38d1d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"started reading\")\n",
    "# refpixel = pd.read_hdf(deep_data_path, key=\"data\")\n",
    "# table = pd.read_hdf(wide_data_path, key=\"data\")\n",
    "\n",
    "# print(\"creating output folder\")\n",
    "# root_path = root_path + tag_root + \"/\"\n",
    "# print(root_path)\n",
    "# if not os.path.isdir(root_path):\n",
    "#     os.mkdir(root_path)\n",
    "\n",
    "# nrbins = len(LOGR_DRAW_RMINS)\n",
    "# print(\"NRBINS:\", nrbins)\n",
    "\n",
    "# for nrep in np.arange(NREPEATS):\n",
    "#     tag = tag_root + \"_run\" + str(nrep)\n",
    "#     print(\"running repeat\", nrep, \"out of\", NREPEATS)\n",
    "#     print(tag)\n",
    "\n",
    "#     master_seed = np.random.randint(0, np.iinfo(np.int32).max, 1)[0]\n",
    "#     rng = np.random.RandomState(seed=master_seed)\n",
    "#     seeds = rng.randint(0, np.iinfo(np.int32).max, nrbins * 5)\n",
    "\n",
    "#     i = 0\n",
    "#     print(\"starting concentric shell resampling\")\n",
    "#     for i in np.arange(nrbins):\n",
    "#         print(\"rbin\", i)\n",
    "#         outname = root_path + \"/\" + tag + \"_{:1d}\".format(master_seed) + \"_rbin{:d}\".format(i)\n",
    "#         print(outname)\n",
    "\n",
    "#         # loading random data\n",
    "#         tmp_wide_r_settings = wide_r_settings.copy()\n",
    "#         tmp_wide_r_settings[\"limits\"][-1] = (10**-3, 10**LOGR_CAT_RMAXS[i])\n",
    "#         _wide_r_settings_rands = emulator.construct_deep_container(refpixel, tmp_wide_r_settings, seed=seeds[nrbins * i + 0], drop=\"MAG_I\")\n",
    "\n",
    "#         tmp_wide_cr_settings = wide_cr_settings.copy()\n",
    "#         tmp_wide_cr_settings[\"limits\"][-1] = (10**-3, 10**LOGR_CAT_RMAXS[i])\n",
    "#         _wide_cr_settings_rands = emulator.construct_deep_container(refpixel, tmp_wide_cr_settings, seed=seeds[nrbins * i + 1], drop=\"MAG_I\")\n",
    "\n",
    "#         # loading deep catalogs\n",
    "#         _deep_c_settings = emulator.construct_deep_container(refpixel, deep_c_settings, seed=seeds[nrbins * i + 2], drop=\"MAG_I\")\n",
    "#         _deep_smc_settings = emulator.construct_deep_container(refpixel, deep_smc_settings, seed=seeds[nrbins * i + 3])\n",
    "\n",
    "#         # loading cluster data\n",
    "#         tmp_wide_cr_settings = wide_cr_settings.copy()\n",
    "#         tmp_wide_cr_settings[\"limits\"][-1] = (10**-3, 10**LOGR_CAT_RMAXS[i])\n",
    "#         _wide_cr_settings_clust = emulator.construct_deep_container(table, tmp_wide_cr_settings, seed=seeds[nrbins * i + 4], drop=\"MAG_I\")\n",
    "\n",
    "#         infodicts, samples = emulator.make_classifier_infodicts(_wide_cr_settings_clust, _wide_r_settings_rands,\n",
    "#                                                                 _wide_cr_settings_rands,\n",
    "#                                                                 _deep_c_settings, _deep_smc_settings,\n",
    "#                                                                 columns, nsamples=NSAMPLES, nchunks=NCHUNKS,\n",
    "#                                                                 bandwidth=bandwidth,\n",
    "#                                                                 rmin=LOGR_DRAW_RMINS[i],\n",
    "#                                                                 rmax=LOGR_DRAW_RMAXS[i])\n",
    "\n",
    "#         fname = outname + \"_samples.fits\"\n",
    "#         print(fname)\n",
    "#         fio.write(fname, samples.to_records(), clobber=True)\n",
    "#         master_dict = {\n",
    "#             \"columns\": infodicts[0][\"columns\"],\n",
    "#             \"bandwidth\": infodicts[0][\"bandwidth\"],\n",
    "#             \"deep_c_settings\": deep_c_settings,\n",
    "#             \"deep_smc_settings\": deep_smc_settings,\n",
    "#             \"wide_r_settings\": tmp_wide_r_settings,\n",
    "#             \"wide_cr_settings\": tmp_wide_cr_settings,\n",
    "#             \"rmin\": infodicts[0][\"rmin\"],\n",
    "#             \"rmax\": infodicts[0][\"rmin\"],\n",
    "#         }\n",
    "#         pickle.dump(master_dict, open(outname + \".p\", \"wb\"))\n",
    "#         print(\"calculating scores\")\n",
    "#         result = emulator.run_scores2(infodicts)\n",
    "#         print(\"finished calculating scores\")\n",
    "#         fname = outname + \"_scores.fits\"\n",
    "#         print(fname)\n",
    "#         fio.write(fname, result.to_records(), clobber=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "193a2706",
   "metadata": {},
   "source": [
    "# Posprocess  rejection sampling results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a67164",
   "metadata": {},
   "source": [
    "The below settings are mostly identical to the previous section.\n",
    "\n",
    "Since we are working in DC2, we have access to all features in the deep / reference data also around clusters, so we modify that feature list to include everything\n",
    "\n",
    "*The below settings define the **reference dataset** for convinience, and are slightly different from the ones in the previous sections*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5572471e",
   "metadata": {},
   "outputs": [],
   "source": [
    "NREPEATS = 4\n",
    "NSAMPLES = 1600000\n",
    "NCHUNKS = 160\n",
    "bandwidth=0.1\n",
    "\n",
    "LOGR_DRAW_RMINS = np.array([-3, -0.5, 0., 0.5])\n",
    "LOGR_DRAW_RMAXS = np.array([-0.5, 0., 0.5, 1.2])\n",
    "LOGR_CAT_RMAXS = [0., 0.5, 1.1, 1.2]\n",
    "\n",
    "deep_smc_settings = {\n",
    "    \"columns\": [\n",
    "        (\"GABS\", (\"ellipticity_1_true\", \"ellipticity_2_true\", \"SQSUM\")),\n",
    "        (\"SIZE\", \"size_true\"),\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"COLOR_G_R\", (\"mag_g\", \"mag_r\", \"-\")),\n",
    "        (\"COLOR_R_I\", (\"mag_r\", \"mag_i\", \"-\")),\n",
    "        (\"COLOR_I_Z\", (\"mag_i\", \"mag_z\", \"-\")),\n",
    "        (\"STELLAR_MASS\", \"stellar_mass\"),\n",
    "        (\"HALO_MASS\", \"halo_mass\")        \n",
    "    ],\n",
    "    \"logs\": [False, True, False, False, False, False, True, True],\n",
    "    \"limits\": [(0., 1.), (-1, 5), (17, 25), (-1, 3), (-1, 3), (-1, 3), (10**3, 10**13), (10**9, 10**16)],\n",
    "}\n",
    "\n",
    "# this is just a copy of the deep_smc_settings, in DC2 we have access to this information\n",
    "wide_cr_settings = {\n",
    "    \"columns\": [\n",
    "        (\"GABS\", (\"ellipticity_1_true\", \"ellipticity_2_true\", \"SQSUM\")),\n",
    "        (\"SIZE\", \"size_true\"),\n",
    "        (\"MAG_I\", \"mag_i\"),\n",
    "        (\"COLOR_G_R\", (\"mag_g\", \"mag_r\", \"-\")),\n",
    "        (\"COLOR_R_I\", (\"mag_r\", \"mag_i\", \"-\")),\n",
    "        (\"COLOR_I_Z\", (\"mag_i\", \"mag_z\", \"-\")),\n",
    "        (\"STELLAR_MASS\", \"stellar_mass\"),\n",
    "        (\"HALO_MASS\", \"halo_mass\"),\n",
    "        (\"LOGR\", \"R\"),        \n",
    "    ],\n",
    "    \"logs\": [False, True, False, False, False, False, True, True, True],\n",
    "    \"limits\": [(0., 1.), (-1, 5), (17, 25), (-1, 3), (-1, 3), (-1, 3), (10**3, 10**13), (10**9, 10**16), (1e-3, 16)],\n",
    "}\n",
    "\n",
    "columns = {\n",
    "    \"cols_dc\": [\"COLOR_G_R\", \"COLOR_R_I\",],\n",
    "    \"cols_wr\": [\"LOGR\",],\n",
    "    \"cols_wcr\": [\"COLOR_G_R\", \"COLOR_R_I\", \"LOGR\",],\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf831c3",
   "metadata": {},
   "source": [
    " loading a bunch of data files, this part is a bit redundant, but if you did not execute the previous section then you have to load them here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b9bfb2c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "refpixel = pd.read_hdf(deep_data_path, key=\"data\")\n",
    "table = pd.read_hdf(wide_data_path, key=\"data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a6e9396d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1513572, 9)\n",
      "(1513572,)\n",
      "(1513572, 8)\n",
      "(1513572,)\n",
      "(1009658, 9)\n",
      "(1009658,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "tmp_wide_cr_settings = wide_cr_settings.copy()\n",
    "_wide_cr_settings_rands = emulator.construct_deep_container(refpixel, tmp_wide_cr_settings)\n",
    "\n",
    "# loading deep catalogs\n",
    "_deep_smc_settings = emulator.construct_deep_container(refpixel, deep_smc_settings)\n",
    "\n",
    "# loading cluster data\n",
    "tmp_wide_cr_settings = wide_cr_settings.copy()\n",
    "_wide_cr_settings_clust = emulator.construct_deep_container(table, tmp_wide_cr_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfe0bf6e",
   "metadata": {},
   "source": [
    "Loop over the files which contain the proposed galaxy draws, and the corresponding acceptance scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a9d5ff2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "samples = []\n",
    "scores = []\n",
    "for rbin in np.arange(4):\n",
    "    print(rbin)\n",
    "#     expr = \"/e/ocean1/users/vargatn/EMULATOR/EPSILON/resamples/epsilon_concentric_sample_v06_run*_rbin\" + str(rbin) + \"*samples.fits\" \n",
    "    expr = \"/e/ocean1/users/vargatn/LSST/DC2_1.1.4/clusters_v01/resamples/dc2-alpha_concentric_sample-v01_test-03/dc2-alpha_concentric_sample-v01_test-03_run0*_rbin\" + str(rbin) + \"*samples.fits\" \n",
    "\n",
    "    fnames_samples = np.sort(glob.glob(expr))\n",
    "    fnames_scores = []\n",
    "    for fname in fnames_samples:\n",
    "        fnames_scores.append(fname.replace(\"samples.fits\", \"scores.fits\"))\n",
    "\n",
    "    samples_sep = []\n",
    "    scores_sep = []\n",
    "    for i, fname in enumerate(fnames_samples):\n",
    "#         print(fname)\n",
    "        samples_sep.append(fio.read(fname))\n",
    "        scores_sep.append(fio.read(fnames_scores[i]))\n",
    "        \n",
    "    samples.append(np.hstack(samples_sep))\n",
    "    scores.append(np.hstack(scores_sep))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "13a6d244",
   "metadata": {},
   "outputs": [],
   "source": [
    "mag_lims = (17, 22.5)\n",
    "r_lims_all = [(-1.5, -0.5), (-0.5, 0.), (0, 0.5), (0.5, 1.0)]\n",
    "redges = [-1.5, -0.5, 0., 0.5, 1.0]\n",
    "rareas = np.array([np.pi*((10**redges[i+1])**2. - (10**redges[i])**2.) for i in np.arange(len(redges)-1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ffb9f8ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/moon/vargatn/anaconda3/envs/main3/lib/python3.8/site-packages/pandas/core/arraylike.py:274: RuntimeWarning: divide by zero encountered in log10\n",
      "  result = getattr(ufunc, method)(*inputs, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "# Calculate the observed surface density of **bright** fields galaxies, \n",
    "# this will anchor our expectation about the full galaxy distribution\n",
    "\n",
    "magcol = \"mag_i\"\n",
    "ii = ((table[magcol] > mag_lims[0]) & (table[magcol] < mag_lims[1]))\n",
    "\n",
    "clust_los_nums = np.histogram(np.log10(table[ii][\"R\"]), bins=redges)[0] / 41 # / nc\n",
    "\n",
    "ii = ((refpixel[magcol] > mag_lims[0]) & (refpixel[magcol] < mag_lims[1]))\n",
    "surfdens = len(refpixel[ii]) / hp.nside2pixarea(32, degrees=True) / 3600 / 3\n",
    "rands_los_nums = surfdens * rareas\n",
    "# rands_los_nums = np.histogram(np.log10(refpixel[ii][\"R\"]), bins=redges)[0] / rareas#* ratio# / nr\n",
    "nratios = clust_los_nums / rands_los_nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "afc03270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2.741989144315195\n",
      "1\n",
      "1.7913041757345514\n",
      "2\n",
      "1.1243442810539395\n",
      "3\n",
      "0.793271619957704\n"
     ]
    }
   ],
   "source": [
    "ifields2 = []\n",
    "iclusts2 = []\n",
    "i2ds2 = []\n",
    "for rbin in np.arange(4):\n",
    "    print(rbin)\n",
    "    _ifield, _iclust, _i2d = result_reader(samples[rbin], scores[rbin], nratio=nratios[rbin], m_factor=100, seed=rbin)\n",
    "    ifields2.append(_ifield)\n",
    "    iclusts2.append(_iclust)\n",
    "    i2ds2.append(_i2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0ea60a49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# draw a mock galaxy sample representative of cluster member galaxies\n",
    "csamples = []\n",
    "for rbin in np.arange(4):\n",
    "    print(rbin)\n",
    "    tab = pd.DataFrame.from_records(samples[rbin][iclusts2[rbin]].byteswap().newbyteorder())\n",
    "    tab.drop('index', axis=1, inplace=True)\n",
    "    kde = emulator.KDEContainer(tab)\n",
    "    kde.standardize_data()\n",
    "    kde.construct_kde(0.1)\n",
    "    _csample = kde.random_draw(4e6)\n",
    "    csamples.append(_csample)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4ca84d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# draw a mock galaxy sample representative of field galaxies, this is a good sanity check to compare with the reference fields\n",
    "rsamples = []\n",
    "for rbin in np.arange(4):\n",
    "    print(rbin)\n",
    "    tab = pd.DataFrame.from_records(samples[rbin][ifields2[rbin]].byteswap().newbyteorder())\n",
    "    tab.drop('index', axis=1, inplace=True)\n",
    "    kde = emulator.KDEContainer(tab)\n",
    "    kde.standardize_data()\n",
    "    kde.construct_kde(0.1)\n",
    "    _rsample = kde.random_draw(4e6)\n",
    "    rsamples.append(_rsample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c3e66456",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# draw a mock galaxy sample representative of all galaxies in the cluster line of sight. This is a mixture of cluster member and non-cluster member galaxies\n",
    "allsamples = []\n",
    "for rbin in np.arange(4):\n",
    "    print(rbin)\n",
    "    tab = pd.DataFrame.from_records(samples[rbin][i2ds2[rbin]].byteswap().newbyteorder())\n",
    "    tab.drop('index', axis=1, inplace=True)\n",
    "    kde = emulator.KDEContainer(tab)\n",
    "    kde.standardize_data()\n",
    "    kde.construct_kde(0.1)\n",
    "    _sample = kde.random_draw(4e6)\n",
    "    allsamples.append(_sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c4e539",
   "metadata": {},
   "source": [
    "## Visualize model and data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3905f8ee",
   "metadata": {},
   "source": [
    "Let's visualize what the above cluster line of sight models predict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d0db490e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tohist(edges, vals):\n",
    "    arr = []\n",
    "    res = []\n",
    "    for i in np.arange(len(vals)):\n",
    "        arr.append(edges[i])\n",
    "        arr.append(edges[i + 1])\n",
    "        res.append(vals[i])\n",
    "        res.append(vals[i])\n",
    "    return arr, res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "65852afe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.13, 0.9, 'DC2 redmapper clusters Emulator model')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 828x504 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axarr = plt.subplots(nrows=3, ncols=4, figsize=(11.5, 7.), sharex=False, sharey=False)\n",
    "fig.subplots_adjust(hspace=0.075, wspace=0.05)\n",
    "\n",
    "bins_hist = np.linspace(-0.5, 2.5, 20)\n",
    "cens_hist = bins_hist[:-1] + np.diff(bins_hist) / 2\n",
    "bins_kde = np.linspace(-0.5, 2.5, 40)\n",
    "cens = bins_kde[:-1] + np.diff(bins_kde) / 2\n",
    "\n",
    "for ax in axarr[0]:\n",
    "    ax.set_xticklabels([])\n",
    "for ax in axarr[1]:\n",
    "    ax.set_xticklabels([])    \n",
    "\n",
    "for ax in axarr[:, 0]:\n",
    "    ax.set_yticklabels([])\n",
    "    \n",
    "for ax in axarr[0, 1:]:\n",
    "    ax.set_yticklabels([])\n",
    "for ax in axarr[1, 1:]:\n",
    "    ax.set_yticklabels([])\n",
    "for ax in axarr[2, 1:]:\n",
    "    ax.set_yticklabels([])    \n",
    "        \n",
    "for ax in axarr[2]:\n",
    "    ax.set_xlabel(\"g - r\", fontsize=12)\n",
    "for ax in axarr[:, 0]:\n",
    "    ax.set_ylabel(\"p.d.f.\", fontsize=12)\n",
    "    \n",
    "col = \"COLOR_G_R\" \n",
    "magcol = \"MAG_I\"\n",
    "rcol = \"LOGR\"\n",
    "\n",
    "r_lims_all = [(-1.5, -0.5), (-0.5, 0.), (0, 0.5), (0.5, 1.0)]\n",
    "\n",
    "# ####################################################################################################\n",
    "mag_lims = (19., 21.)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[0, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "\n",
    "\n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "\n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\")     \n",
    "    \n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")    \n",
    "    \n",
    "# ####################################################################################################\n",
    "mag_lims = (21., 22.5)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[1, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "\n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "    \n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\") \n",
    "    \n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")        \n",
    "\n",
    "    \n",
    "# ####################################################################################################\n",
    "mag_lims = (23., 24)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[2, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "   \n",
    "    \n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "    \n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\")    \n",
    "\n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")     \n",
    "    handles, labels = ax.get_legend_handles_labels()    \n",
    "\n",
    "    \n",
    "fs = 10\n",
    "\n",
    "axarr[2, 3].legend(loc=1, fontsize=fs, handles=handles, labels=labels)    \n",
    "# axarr[2, 2].legend(loc=1, fontsize=fs, handles=handles[3:], labels=labels[3:])  \n",
    "    \n",
    "\n",
    "# axarr[2, 0].text(0.05, 0.72, \"Depth Extrapolation\", transform=axarr[2, 0].transAxes, fontsize=fs)\n",
    "axarr[0, 0].text(0.05, 0.63, \"$\\lambda\\in[30;\\,60)$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "axarr[0, 0].text(0.05, 0.51, \"$z\\in[0.3;\\,0.35)$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "\n",
    "axarr[0, 0].text(0.05, 0.85, \"$i-mag\\in[19;\\, 21]$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "axarr[1, 0].text(0.05, 0.85, \"$i-mag\\in[21;\\, 22.5]$\", transform=axarr[1, 0].transAxes, fontsize=fs)\n",
    "axarr[2, 0].text(0.05, 0.85, \"$i-mag\\in[23;\\, 24]$ \", transform=axarr[2, 0].transAxes, fontsize=fs)\n",
    "axarr[2, 0].text(0.05, 0.73, \"Depth Extrapolation\".upper(), transform=axarr[2, 0].transAxes, fontsize=fs, color=\"red\")\n",
    "fig.text(0.13, 0.9, \"DC2 redmapper clusters Emulator model\", fontsize=14)\n",
    "# fig.savefig(\"DC2-ALPHA_LOWZ_decoupled_g-r-color_magnitude_slices_radial_v01.png\", dpi=300, bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "67cbae35",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-30-c682a167d2b7>:15: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels([\"0\", \"1\", \"2\", \"3\", \"\"])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.13, 0.9, 'DC2 redmapper clusters Emulator model')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 828x504 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axarr = plt.subplots(nrows=3, ncols=4, figsize=(11.5, 7.), sharex=False, sharey=False)\n",
    "fig.subplots_adjust(hspace=0.075, wspace=0.05)\n",
    "\n",
    "bins_hist = np.linspace(4, 12, 20)\n",
    "cens_hist = bins_hist[:-1] + np.diff(bins_hist) / 2\n",
    "bins_kde = np.linspace(4, 12, 40)\n",
    "cens = bins_kde[:-1] + np.diff(bins_kde) / 2\n",
    "\n",
    "for ax in axarr[0]:\n",
    "    ax.set_xticklabels([])\n",
    "for ax in axarr[1]:\n",
    "    ax.set_xticklabels([])    \n",
    "\n",
    "for ax in axarr[:, 0]:\n",
    "    ax.set_yticklabels([\"0\", \"1\", \"2\", \"3\", \"\"])\n",
    "    \n",
    "for ax in axarr[0, 1:]:\n",
    "    ax.set_yticklabels([])\n",
    "for ax in axarr[1, 1:]:\n",
    "    ax.set_yticklabels([])\n",
    "for ax in axarr[2, 1:]:\n",
    "    ax.set_yticklabels([])    \n",
    "        \n",
    "for ax in axarr[2]:\n",
    "    ax.set_xlabel(\"stellar mass [Msun]\", fontsize=12)\n",
    "for ax in axarr[:, 0]:\n",
    "    ax.set_ylabel(\"p.d.f.\", fontsize=12)\n",
    "    \n",
    "col = \"STELLAR_MASS\" \n",
    "magcol = \"MAG_I\"\n",
    "rcol = \"LOGR\"\n",
    "\n",
    "r_lims_all = [(-1.5, -0.5), (-0.5, 0.), (0, 0.5), (0.5, 1.0)]\n",
    "\n",
    "# ####################################################################################################\n",
    "mag_lims = (19., 21.)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[0, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "    \n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "\n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\")         \n",
    "    \n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")    \n",
    "    \n",
    "# ####################################################################################################\n",
    "mag_lims = (21., 22.5)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[1, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "\n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "    \n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\")     \n",
    "    \n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")        \n",
    "\n",
    "    \n",
    "# ####################################################################################################\n",
    "mag_lims = (23., 24)\n",
    "for rbin in np.arange(4):\n",
    "    ax = axarr[2, rbin]\n",
    "\n",
    "    r_lims = r_lims_all[rbin]\n",
    "    sample = samples[rbin]\n",
    "    csample = csamples[rbin]\n",
    "    rsample = rsamples[rbin]\n",
    "    \n",
    "    \n",
    "    ctab = _wide_cr_settings_clust[\"container\"].data.copy()\n",
    "    ii = ((ctab[magcol] > mag_lims[0]) & (ctab[magcol] < mag_lims[1]) &\n",
    "          (ctab[rcol] > r_lims[0]) & (ctab[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(ctab[ii][col], bins=bins_hist)[0]    \n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"orange\", label=\"Cluster LOS\", lw=2)    \n",
    "    \n",
    "    ii = (sample[magcol] > mag_lims[0]) & (sample[magcol] < mag_lims[1])\n",
    "    counts = np.histogram(sample[ii][col], bins=bins_hist)[0]\n",
    "    c16 = (counts - np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    c84 = (counts + np.sqrt(counts)) / (counts * np.diff(bins_hist)).sum()\n",
    "    counts = counts / (counts * np.diff(bins_hist)).sum()\n",
    "    edges, v16 = tohist(bins_hist, c16)\n",
    "    edges, v84 = tohist(bins_hist, c84)\n",
    "    ax.fill_between(edges, v16, v84, color=\"cornflowerblue\", lw=2, label=\"field\")     \n",
    "    \n",
    "    allsample = allsamples[rbin]\n",
    "    ii = ((allsample[magcol] > mag_lims[0]) & (allsample[magcol] < mag_lims[1]) &\n",
    "          (allsample[rcol] > r_lims[0]) & (allsample[rcol] < r_lims[1]))\n",
    "    counts = np.histogram(allsample[ii][col], bins=bins_kde, density=True)[0]    \n",
    "    ax.plot(cens, counts, ls=\"--\", color=\"black\", lw=2.5, label=\"LOS model\")     \n",
    "    handles, labels = ax.get_legend_handles_labels()    \n",
    "\n",
    "    \n",
    "fs = 10\n",
    "\n",
    "axarr[2, 3].legend(loc=3, fontsize=fs, handles=handles, labels=labels)    \n",
    "# axarr[2, 2].legend(loc=1, fontsize=fs, handles=handles[3:], labels=labels[3:])  \n",
    "    \n",
    "\n",
    "# axarr[2, 0].text(0.05, 0.72, \"Depth Extrapolation\", transform=axarr[2, 0].transAxes, fontsize=fs)\n",
    "axarr[0, 0].text(0.05, 0.63, \"$\\lambda\\in[30;\\,60)$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "axarr[0, 0].text(0.05, 0.51, \"$z\\in[0.3;\\,0.35)$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "\n",
    "axarr[0, 0].text(0.05, 0.85, \"$i-mag\\in[19;\\, 21]$\", transform=axarr[0, 0].transAxes, fontsize=fs)\n",
    "axarr[1, 0].text(0.05, 0.85, \"$i-mag\\in[21;\\, 22.5]$\", transform=axarr[1, 0].transAxes, fontsize=fs)\n",
    "axarr[2, 0].text(0.05, 0.85, \"$i-mag\\in[23;\\, 24]$ \", transform=axarr[2, 0].transAxes, fontsize=fs)\n",
    "axarr[0, 3].text(0.45, 0.73, \"Extrapolation\".upper(), transform=axarr[0, 3].transAxes, fontsize=fs, color=\"red\")\n",
    "axarr[1, 3].text(0.45, 0.73, \"Extrapolation\".upper(), transform=axarr[1, 3].transAxes, fontsize=fs, color=\"red\")\n",
    "axarr[2, 3].text(0.45, 0.73, \"Extrapolation\".upper(), transform=axarr[2, 3].transAxes, fontsize=fs, color=\"red\")\n",
    "fig.text(0.13, 0.9, \"DC2 redmapper clusters Emulator model\", fontsize=14)\n",
    "# fig.savefig(\"DC2-ALPHA_LOWZ_decoupled_size_magnitude_slices_radial_v01.png\", dpi=300, bbox_inches=\"tight\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fc5a3a4",
   "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.10.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "widgets": {
   "state": {},
   "version": "1.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}