From 0f316eac6e1bb45651674316e8ea37dfb8062880 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Fri, 28 Jul 2023 16:51:39 +0200 Subject: [PATCH 1/8] starting n(z) resampling --- example/test_slics.py | 58 +++++++++++++++- requirements.txt | 1 + sp_peaks/slics.py | 149 ++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 201 insertions(+), 7 deletions(-) diff --git a/example/test_slics.py b/example/test_slics.py index 6b91c02..2bf238b 100644 --- a/example/test_slics.py +++ b/example/test_slics.py @@ -20,6 +20,10 @@ # %load_ext autoreload # %autoreload 2 +import matplotlib.pylab as plt +import os +from cs_util import cat as cs_cat + # + import sp_peaks print(f"sp_peaks version = {sp_peaks.__version__}") @@ -27,11 +31,16 @@ from sp_peaks import slics # - -cat_path = "/n17data/tersenov/SLICS/Cosmo_DES/06_f/LOS3/DES_MocksCat_06_f_4_Bin3_LOS3_R19.dat" +root_directory = "/n17data/tersenov/SLICS/Cosmo_DES" + +cat_path = f"{root_directory}/06_f/LOS3/DES_MocksCat_06_f_4_Bin3_LOS3_R19.dat" # Load catalogue, all columns dat = slics.read_catalogue(cat_path) +# DEBUG +dat_comb = dat + # Print column names print(dat.dtype.names) @@ -41,6 +50,53 @@ # Load only essential columns dat_ess = slics.read_catalogue(cat_path, all_col=False) +from astropy.table import vstack +x = vstack([dat, dat]) + +len(dat) + print(dat_ess[0]) +# Combine all four redshift bins for given cosmo ID, line of sight, and tile number +dat_comb = slics.read_multiple_catalogues( + root_directory, + cosmo_id="fid_f", + zbins=None, + lsos=[2], + tiles=[5], + combine="add", + verbose=True, +) + +len(dat_comb) + +# + +# Read CFIS redshift distribution (blind version "A", ShapePipe) +dndz_CFIS_path = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt" +z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path) + +nz = len(z_edges_ext) +print(len(z_centers_ext), len(dndz_ext), len(z_edges_ext)) +# - + +dndz_slics, z_edges_slics = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_CFIS) + +# CHeck that z +max(z_edges_slics - z_edges_ext) + +plt.plot(res[1][:-1], res[0] / sum(res[0]), '-') +plt.plot(z_centers_ext, dndz_ext / sum(dndz_ext), '-') + +res[1][np.where(res[0] == 0)] + +z_max = 1.8 + +idx_z_max = np.where(z_edges_ext < z_max) +dndz_ext = dndz_ext[idx_z_max] +dndz_slics = dndz_slics[idx_z_max] + +probability = dndz_ext / dndz_slics + +probability + diff --git a/requirements.txt b/requirements.txt index d75f7ef..f8c8c69 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ +cs_util emcee==3.1.1 zenodo_get chainconsumer diff --git a/sp_peaks/slics.py b/sp_peaks/slics.py index 5ed43c1..541ef56 100644 --- a/sp_peaks/slics.py +++ b/sp_peaks/slics.py @@ -8,6 +8,15 @@ :Authors: Martin Kilbinger """ +import os +import numpy as np + +from astropy.io import ascii +from astropy.table import vstack + +from cs_util import cat as cs_cat + + col_names = [ "RA", "Dec", @@ -24,14 +33,14 @@ col_names_essential = [ "RA", "Dec", - "e1_data", - "e2_data", + "gamma1_sim", + "gamma2_sim", "redshift_true_sim", ] - -import os -from astropy.io import ascii +max_los = 4 +max_zbin = 4 +max_tile = 19 def read_catalogue(file_path, all_col=True): @@ -59,7 +68,7 @@ def read_catalogue(file_path, all_col=True): """ if not os.path.exists(file_path): - raise IOError(f"SLICS catlogue file {file_path} does not exist") + raise IOError(f"SLICS catalogue file {file_path} does not exist") if all_col: include_names = None @@ -69,3 +78,131 @@ def read_catalogue(file_path, all_col=True): dat = ascii.read(file_path, names=col_names, include_names=include_names) return dat + + +def get_cat_name(cosmo_id, zbin, los, tile): + """Get Cat Name. + + Return catalogue file name. + + Parameters + ---------- + cosmo_id : str + cosmology model ID + zbin : int + redshift bin number + los : int + line-of-sight number + tile : int + tile number (realisation) + + Returns + ------- + str + catalogue name + + """ + cat_name = ( + f"{cosmo_id}/LOS{los}/DES_MocksCat_{cosmo_id}_4_Bin{zbin}_LOS{los}_" + + f"R{tile}.dat" + ) + + return cat_name + + +def read_multiple_catalogues( + root_directory, + cosmo_id="fid_f", + zbins=None, + lsos=None, + tiles=None, + combine="add", + verbose=False, +): + """Read Multiple Catalogues. + + Read and combine a number of SLICS catalogues. + + Parameters + ---------- + root_directory : str + root directory of input catalogues + cosmo_id : str + cosmology model ID + zbins : list + list of redshift bins to combine, default is None (combine all) + lsos : list + list of lines of sight numbers to combine, default is None + (combine all) + tiles : list + list of tile numbers to combine, default is None (combine all) + + Returns + ------- + dict + catalogue content + + """ + if not os.path.exists(root_directory): + raise IOError(f"Root directory {root_directory} does not exist") + + if not zbins: + zbins = np.arange(max_zbin) + 1 + if not lsos: + lsos = np.arange(max_los) + 1 + if not tiles: + tiles = np.arrange(max_tile) + 1 + + dat_comb = None + + # Loop over input catalogue identifiers + for zbin in zbins: + for los in lsos: + for tile in tiles: + + # Get single catalogue + cat_name = get_cat_name(cosmo_id, zbin, los, tile) + cat_path = f"{root_directory}/{cat_name}" + + if verbose: + print(f"Reading catalogue {cat_name}...") + dat = read_catalogue(cat_path, all_col=False) + + if dat_comb is None: + # First time: Copy catalogue + dat_comb = dat.copy() + else: + # Other times: Combine with previous + if combine == "add": + dat_comb = vstack([dat_comb, dat]) + else: + pass + + return dat_comb + + +def resample_z(dat, dndz_path, z_max=None): + + # Read external dndz file + z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_path) + + # Create redshift histogram of SLICS catalogue, using external zbins + dndz_slics, z_edges_slics = np.histogram( + dat["redshift_true_sim"], + bins=z_edges_ext + ) + + # Cut redshifts if desired + if z_max is not None: + idx_z_max = np.where(z_edges_ext < z_max) + dndz_ext = dndz_ext[idx_z_max] + dndz_slics = dndz_slics[idx_z_max] + + # Normalise redshift distributions + dndz_ext = dndz_ext / sum(dndz_ext) + dndz_slics = dndz_slics / sum(dndz_slics) + + probability = dndz_ext / dndz_slics + + + From d4d037b9991cf441e7428f590cea79d3d3ac7e22 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Sun, 30 Jul 2023 21:32:04 +0200 Subject: [PATCH 2/8] poetry installation works --- .gitignore | 1 + notebooks/test.py | 32 ++ notebooks/test_slics.ipynb | 560 +++++++++++++++++++++++++++ {example => notebooks}/test_slics.py | 25 +- pyproject.toml | 95 ++--- sp_peaks/slics.py | 38 +- sp_peaks/transform_to_notebooks.py | 24 ++ 7 files changed, 692 insertions(+), 83 deletions(-) create mode 100644 notebooks/test.py create mode 100644 notebooks/test_slics.ipynb rename {example => notebooks}/test_slics.py (72%) create mode 100755 sp_peaks/transform_to_notebooks.py diff --git a/.gitignore b/.gitignore index 1859f04..8e9310d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ build +dist sp_peaks.egg-info/ .ipynb_checkpoints example/test_slics.ipynb diff --git a/notebooks/test.py b/notebooks/test.py new file mode 100644 index 0000000..7677f92 --- /dev/null +++ b/notebooks/test.py @@ -0,0 +1,32 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.14.7 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# # CosmoSLICS simulation testing +# 07/2023 + +# %matplotlib inline +# %load_ext autoreload +# %autoreload 2 + +import matplotlib.pylab as plt +import os +from cs_util import cat as cs_cat + +# + +import sp_peaks +print(f"sp_peaks version = {sp_peaks.__version__}") + +from sp_peaks import slics +# - diff --git a/notebooks/test_slics.ipynb b/notebooks/test_slics.ipynb new file mode 100644 index 0000000..384a2ab --- /dev/null +++ b/notebooks/test_slics.ipynb @@ -0,0 +1,560 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CosmoSLICS simulation testing\n", + "07/2023 " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline \n", + "%load_ext autoreload \n", + "%autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pylab as plt\n", + "import os\n", + "from cs_util import cat as cs_cat" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sp_peaks version = 0.0.1\n" + ] + } + ], + "source": [ + "import sp_peaks \n", + "print(f\"sp_peaks version = {sp_peaks.__version__}\")\n", + "\n", + "from sp_peaks import slics" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "root_directory = \"/n17data/tersenov/SLICS/Cosmo_DES\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "cat_path = f\"{root_directory}/06_f/LOS3/DES_MocksCat_06_f_4_Bin3_LOS3_R19.dat\"" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Load catalogue, all columns\n", + "dat = slics.read_catalogue(cat_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# DEBUG\n", + "dat_comb = dat" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('RA',\n", + " 'Dec',\n", + " 'e1_data',\n", + " 'e2_data',\n", + " 'w',\n", + " 'redshift_true_sim',\n", + " 'gamma1_sim',\n", + " 'gamma2_sim',\n", + " 'kappa_sim',\n", + " 'S_metacal_data')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Print column names\n", + "print(dat.dtype.names)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Row index=0\n", + "\n", + "\n", + "\n", + "\n", + "
RADece1_datae2_datawredshift_true_simgamma1_simgamma2_simkappa_simS_metacal_data
float64float64float64float64float64float64float64float64float64float64
9.98507210.83404565-0.3871837-0.0931029391.00.819839720.0119375370.00051228399-0.010907983-0.17440903
" + ], + "text/plain": [ + "\n", + " RA Dec e1_data e2_data w redshift_true_sim gamma1_sim gamma2_sim kappa_sim S_metacal_data\n", + " float64 float64 float64 float64 float64 float64 float64 float64 float64 float64 \n", + "--------- ---------- ---------- ------------ ------- ----------------- ----------- ------------- ------------ --------------\n", + "9.9850721 0.83404565 -0.3871837 -0.093102939 1.0 0.81983972 0.011937537 0.00051228399 -0.010907983 -0.17440903" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Print first line\n", + "print(dat[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Load only essential columns\n", + "dat_ess = slics.read_catalogue(cat_path, all_col=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.table import vstack\n", + "x = vstack([dat, dat])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "412196" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(dat)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "Row index=0\n", + "\n", + "\n", + "\n", + "\n", + "
RADece1_datae2_dataredshift_true_sim
float64float64float64float64float64
9.98507210.83404565-0.3871837-0.0931029390.81983972
" + ], + "text/plain": [ + "\n", + " RA Dec e1_data e2_data redshift_true_sim\n", + " float64 float64 float64 float64 float64 \n", + "--------- ---------- ---------- ------------ -----------------\n", + "9.9850721 0.83404565 -0.3871837 -0.093102939 0.81983972" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(dat_ess[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin1_LOS2_R5.dat...\n", + "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin2_LOS2_R5.dat...\n", + "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin3_LOS2_R5.dat...\n", + "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin4_LOS2_R5.dat...\n" + ] + } + ], + "source": [ + "# Combine all four redshift bins for given cosmo ID, line of sight, and tile number\n", + "dat_comb = slics.read_multiple_catalogues(\n", + " root_directory,\n", + " cosmo_id=\"fid_f\",\n", + " zbins=None,\n", + " lsos=[2],\n", + " tiles=[5],\n", + " combine=\"add\",\n", + " verbose=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1236929" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(dat_comb)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200 200 201\n" + ] + } + ], + "source": [ + "# Read CFIS redshift distribution (blind version \"A\", ShapePipe)\n", + "dndz_CFIS_path = \"/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt\"\n", + "z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path)\n", + "\n", + "nz = len(z_edges_ext)\n", + "print(len(z_centers_ext), len(dndz_ext), len(z_edges_ext))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "dndz_slics, z_edges_slics = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_CFIS)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# CHeck that z\n", + "max(z_edges_slics - z_edges_ext)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(res[1][:-1], res[0] / sum(res[0]), '-')\n", + "plt.plot(z_centers_ext, dndz_ext / sum(dndz_ext), '-')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3.1 , 3.125, 3.15 , 3.175, 3.2 , 3.225, 3.25 , 3.275, 3.3 ,\n", + " 3.325, 3.35 , 3.375, 3.4 , 3.425, 3.45 , 3.475, 3.5 , 3.525,\n", + " 3.55 , 3.575, 3.6 , 3.625, 3.65 , 3.675, 3.7 , 3.725, 3.75 ,\n", + " 3.775, 3.8 , 3.825, 3.85 , 3.875, 3.9 , 3.925, 3.95 , 3.975,\n", + " 4. , 4.025, 4.05 , 4.075, 4.1 , 4.125, 4.15 , 4.175, 4.2 ,\n", + " 4.225, 4.25 , 4.275, 4.3 , 4.325, 4.35 , 4.375, 4.4 , 4.425,\n", + " 4.45 , 4.475, 4.5 , 4.525, 4.55 , 4.575, 4.6 , 4.625, 4.65 ,\n", + " 4.675, 4.7 , 4.725, 4.75 , 4.775, 4.8 , 4.825, 4.85 , 4.875,\n", + " 4.9 , 4.925, 4.95 , 4.975])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res[1][np.where(res[0] == 0)]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "z_max = 1.8" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "idx_z_max = np.where(z_edges_ext < z_max) \n", + "dndz_ext = dndz_ext[idx_z_max] \n", + "dndz_slics = dndz_slics[idx_z_max] " + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "probability = dndz_ext / dndz_slics " + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<Column name='dn_dz' dtype='float64' length=72>\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
2.8594946127434253e-07
1.574042958404797e-06
3.4526586550599785e-05
3.6643725378022684e-05
5.022913194677407e-06
1.1714737205167959e-05
8.970696531364506e-06
1.3304558529801936e-05
9.060341138639804e-06
9.521187042241408e-06
9.429373093166353e-06
1.4343356129976788e-05
5.95389015170617e-06
7.148540213151322e-06
1.0605122695037108e-05
7.191759690474512e-06
1.6749245245411434e-05
2.8701152664041492e-05
3.880998267525931e-05
4.5776419574454834e-05
3.935527228675306e-05
...
2.8076328050197772e-05
3.020942349646766e-05
1.8046714427860424e-05
1.880129882157627e-05
2.2470929566663213e-05
1.2017156234951234e-05
2.4378470209440235e-05
1.4958056487754153e-05
1.5363682367389733e-05
1.247317735341576e-05
2.2038203225290923e-05
0.0
1.3428355735607473e-05
1.8418623069785764e-05
2.3499622537313078e-05
2.1033612764878806e-05
2.1430473383084254e-05
4.0807727759405945e-06
1.6966532454325473e-05
5.408643282397454e-06
" + ], + "text/plain": [ + "\n", + "2.8594946127434253e-07\n", + " 1.574042958404797e-06\n", + "3.4526586550599785e-05\n", + "3.6643725378022684e-05\n", + " 5.022913194677407e-06\n", + "1.1714737205167959e-05\n", + " 8.970696531364506e-06\n", + "1.3304558529801936e-05\n", + " 9.060341138639804e-06\n", + " 9.521187042241408e-06\n", + " 9.429373093166353e-06\n", + "1.4343356129976788e-05\n", + " 5.95389015170617e-06\n", + " 7.148540213151322e-06\n", + "1.0605122695037108e-05\n", + " 7.191759690474512e-06\n", + "1.6749245245411434e-05\n", + "2.8701152664041492e-05\n", + " 3.880998267525931e-05\n", + "4.5776419574454834e-05\n", + " 3.935527228675306e-05\n", + " ...\n", + "2.8076328050197772e-05\n", + " 3.020942349646766e-05\n", + "1.8046714427860424e-05\n", + " 1.880129882157627e-05\n", + "2.2470929566663213e-05\n", + "1.2017156234951234e-05\n", + "2.4378470209440235e-05\n", + "1.4958056487754153e-05\n", + "1.5363682367389733e-05\n", + " 1.247317735341576e-05\n", + "2.2038203225290923e-05\n", + " 0.0\n", + "1.3428355735607473e-05\n", + "1.8418623069785764e-05\n", + "2.3499622537313078e-05\n", + "2.1033612764878806e-05\n", + "2.1430473383084254e-05\n", + "4.0807727759405945e-06\n", + "1.6966532454325473e-05\n", + " 5.408643282397454e-06" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "probability" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py" + }, + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/example/test_slics.py b/notebooks/test_slics.py similarity index 72% rename from example/test_slics.py rename to notebooks/test_slics.py index 2bf238b..bab4d71 100644 --- a/example/test_slics.py +++ b/notebooks/test_slics.py @@ -73,30 +73,7 @@ # + # Read CFIS redshift distribution (blind version "A", ShapePipe) dndz_CFIS_path = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt" -z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path) - -nz = len(z_edges_ext) -print(len(z_centers_ext), len(dndz_ext), len(z_edges_ext)) +res = slics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8) # - -dndz_slics, z_edges_slics = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_CFIS) - -# CHeck that z -max(z_edges_slics - z_edges_ext) - -plt.plot(res[1][:-1], res[0] / sum(res[0]), '-') -plt.plot(z_centers_ext, dndz_ext / sum(dndz_ext), '-') - -res[1][np.where(res[0] == 0)] - -z_max = 1.8 - -idx_z_max = np.where(z_edges_ext < z_max) -dndz_ext = dndz_ext[idx_z_max] -dndz_slics = dndz_slics[idx_z_max] - -probability = dndz_ext / dndz_slics - -probability - diff --git a/pyproject.toml b/pyproject.toml index 69085e6..d49a423 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,66 +1,29 @@ -[project] +[tool.poetry] name = "sp_peaks" +version = "0.0.1" +description = "ShapePipe peak counts" readme = "README.md" -#requires-python = "==3.6.13" -requires-python = ">=3.10" authors = [ - { "name" = "The CosmoStat Lab" }, -] -maintainers = [ - { "name" = "Andreas Tersenov", "email" = "andreas.tersenov@cea.fr" }, - { "name" = "Lucie Baumont", "email" = "lucie.baumont@cea.fr" }, - { "name" = "Martin Kilbinger", "email" = "martin.kilbinger@cea.fr" }, -] -dynamic = ["version"] -license = { "file" = "LICENSE" } -keywords = [ - "CosmoStat", - "cosmology", - "weak gravitational lensing", - "peak counts", -] -classifiers = [ - "Development Status :: 1 - Planning", - "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.6", - "Operating System :: POSIX :: Linux", - "Operating System :: MacOS", - "Topic :: Scientific/Engineering", -] -dependencies = [ - "astropy>=4.0", - "numpy>=1.19", - "scipy>=1.5", - "scikit-learn>=1.3", + "Andreas Tersenov ", + "Lucie Baumont ", + "Martin Kilbinger ", ] -[project.optional-dependencies] -lint = [ - "black", -] -release = [ - "build", - "twine", -] -test = [ - "pytest", - "pytest-black", - "pytest-cov", - "pytest-pydocstyle", -] +[tool.poetry.dev-dependencies] +pytest = "^7.0" +pytest-black = "^0.3" +pytest-cov = "^2.0" +pytest-pydocstyle = "*" -# Install for development -dev = ["sp_peaks[lint,release,test]"] +[tool.black] +line-length = 80 +target-version = ["py309", "py310", "py311"] -[project.urls] +[tool.poetry.urls] Source = "https://github.com/CosmoStat/shear-pipe-peaks" Documentation = "https://github.com/CosmoStat/shear-pipe-peaks" Tracker = "https://github.com/CosmoStat/shear-pipe-peaks/issues" -[tool.black] -line-length = 80 - [tool.pydocstyle] convention = "numpy" @@ -68,9 +31,35 @@ convention = "numpy" addopts = "--verbose --black --pydocstyle --cov=sp_peaks" testpaths = ["sp_peaks"] -# Select library directory(ies) [tool.setuptools] packages = ["sp_peaks"] [tool.setuptools.dynamic] version = {attr = "sp_peaks.__version__"} + +[tool.poetry.dependencies] +python = "^3.9" + +astropy = "*" +joblib = "*" +matplotlib = "*" +numpy = "*" +scipy = "*" +scikit-learn = "*" +tqdm = "*" + +chainconsumer = "*" +cs_util = "*" +emcee = "^3.1.1" +getdist = "*" +jupyter = "*" +jupytext = "*" +lenspack = "*" +zenodo_get = "*" + +[tool.poetry.scripts] +run = "sp_peaks.transform_to_notebooks:main" + +[build-system] +requires = ["flit_core>=3.0.0"] +build-backend = "flit_core.buildapi" diff --git a/sp_peaks/slics.py b/sp_peaks/slics.py index 541ef56..4039598 100644 --- a/sp_peaks/slics.py +++ b/sp_peaks/slics.py @@ -9,6 +9,7 @@ """ import os +import random import numpy as np from astropy.io import ascii @@ -181,7 +182,7 @@ def read_multiple_catalogues( return dat_comb -def resample_z(dat, dndz_path, z_max=None): +def resample_z(dat, dndz_path, n_goal, z_max=None): # Read external dndz file z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_path) @@ -198,11 +199,36 @@ def resample_z(dat, dndz_path, z_max=None): dndz_ext = dndz_ext[idx_z_max] dndz_slics = dndz_slics[idx_z_max] - # Normalise redshift distributions - dndz_ext = dndz_ext / sum(dndz_ext) - dndz_slics = dndz_slics / sum(dndz_slics) + # Normalise external redshift distributions to desired number of resampled + # objects + dndz_ext = dndz_ext / sum(dndz_ext) * n_goal - probability = dndz_ext / dndz_slics + import pdb + pdb.set_trace() - + # Ratio of external to SLICS histogram = fraction of galaxies in each + # bin to resample + ratio = dndz_ext / dndz_slics + if (ratio == 0).any(): + print( + "Warning: in at least one z-bin the number of resampled galaxies" + + " will be zero" + ) + + # TODO: user-input of total resampled number (or number density) + + # Get indices in external redshift histogram of SLICS input catalogue + idx_z = np.digitize(dat["redshift_true_sim"], z_edges_ext) + + for idx in range(len(dndz_slics)): + n_drop = int(ratio[idx] * dndz_slics[idx]) + + # Get index list for this z-bin + w = (np.where(idx_z == idx + 1))[0] + + # Create sample of Indices of objects to be dropped for this bin + i_drop = random.sample(list(w), n_drop) + + # Mark objects to be dropped with invalid redshift + dat["redshift_true_sim"][i_drop] = -99 diff --git a/sp_peaks/transform_to_notebooks.py b/sp_peaks/transform_to_notebooks.py new file mode 100755 index 0000000..8d50e49 --- /dev/null +++ b/sp_peaks/transform_to_notebooks.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python + +import os +import jupytext + +def transform_to_notebooks(): + notebook_dir = "./notebooks" + + for filename in os.listdir(notebook_dir): + if filename.endswith(".py"): + nb_file = os.path.join(notebook_dir, f"{os.path.splitext(filename)[0]}.ipynb") + if not os.path.exists(nb_file): + py_file = os.path.join(notebook_dir, filename) + jupytext.write(jupytext.read(py_file), nb_file) + print(f"{py_file} -> {nb_file}") + else: + print(f"{nb_file} exists") + +def main(): + print("MKDEBUG") + transform_to_notebooks() + +if __name__ == "__main__": + main() From 9b294f3f6cd3ecd047a34354b088104ca8ca8dd3 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Tue, 1 Aug 2023 13:41:54 +0200 Subject: [PATCH 3/8] redshift resampling is working --- .gitignore | 1 + notebooks/test_slics.ipynb | 445 ++++++++++++------------------------- notebooks/test_slics.py | 86 +++++-- sp_peaks/slics.py | 119 +++++++++- 4 files changed, 323 insertions(+), 328 deletions(-) diff --git a/.gitignore b/.gitignore index 8e9310d..01c2fc2 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ sp_peaks.egg-info/ .ipynb_checkpoints example/test_slics.ipynb __pycache__ +poetry.lock diff --git a/notebooks/test_slics.ipynb b/notebooks/test_slics.ipynb index 384a2ab..cef3b0c 100644 --- a/notebooks/test_slics.ipynb +++ b/notebooks/test_slics.ipynb @@ -27,6 +27,8 @@ "source": [ "import matplotlib.pylab as plt\n", "import os\n", + "import copy\n", + "import numpy as np\n", "from cs_util import cat as cs_cat" ] }, @@ -56,7 +58,8 @@ "metadata": {}, "outputs": [], "source": [ - "root_directory = \"/n17data/tersenov/SLICS/Cosmo_DES\"" + "#root_directory = \"/n17data/tersenov/SLICS/Cosmo_DES\"\n", + "root_directory = \".\"" ] }, { @@ -82,35 +85,13 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [ - "# DEBUG\n", - "dat_comb = dat" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "('RA',\n", - " 'Dec',\n", - " 'e1_data',\n", - " 'e2_data',\n", - " 'w',\n", - " 'redshift_true_sim',\n", - " 'gamma1_sim',\n", - " 'gamma2_sim',\n", - " 'kappa_sim',\n", - " 'S_metacal_data')" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "('RA', 'Dec', 'e1_data', 'e2_data', 'w', 'redshift_true_sim', 'gamma1_sim', 'gamma2_sim', 'kappa_sim', 'S_metacal_data')\n" + ] } ], "source": [ @@ -120,30 +101,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "Row index=0\n", - "\n", - "\n", - "\n", - "\n", - "
RADece1_datae2_datawredshift_true_simgamma1_simgamma2_simkappa_simS_metacal_data
float64float64float64float64float64float64float64float64float64float64
9.98507210.83404565-0.3871837-0.0931029391.00.819839720.0119375370.00051228399-0.010907983-0.17440903
" - ], - "text/plain": [ - "\n", - " RA Dec e1_data e2_data w redshift_true_sim gamma1_sim gamma2_sim kappa_sim S_metacal_data\n", - " float64 float64 float64 float64 float64 float64 float64 float64 float64 float64 \n", - "--------- ---------- ---------- ------------ ------- ----------------- ----------- ------------- ------------ --------------\n", - "9.9850721 0.83404565 -0.3871837 -0.093102939 1.0 0.81983972 0.011937537 0.00051228399 -0.010907983 -0.17440903" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " RA Dec e1_data e2_data w redshift_true_sim gamma1_sim gamma2_sim kappa_sim S_metacal_data\n", + "--------- ---------- ---------- ------------ --- ----------------- ----------- ------------- ------------ --------------\n", + "9.9850721 0.83404565 -0.3871837 -0.093102939 1.0 0.81983972 0.011937537 0.00051228399 -0.010907983 -0.17440903\n" + ] } ], "source": [ @@ -153,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -161,36 +129,6 @@ "dat_ess = slics.read_catalogue(cat_path, all_col=False)" ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "from astropy.table import vstack\n", - "x = vstack([dat, dat])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "412196" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(dat)" - ] - }, { "cell_type": "code", "execution_count": 13, @@ -199,26 +137,13 @@ }, "outputs": [ { - "data": { - "text/html": [ - "Row index=0\n", - "\n", - "\n", - "\n", - "\n", - "
RADece1_datae2_dataredshift_true_sim
float64float64float64float64float64
9.98507210.83404565-0.3871837-0.0931029390.81983972
" - ], - "text/plain": [ - "\n", - " RA Dec e1_data e2_data redshift_true_sim\n", - " float64 float64 float64 float64 float64 \n", - "--------- ---------- ---------- ------------ -----------------\n", - "9.9850721 0.83404565 -0.3871837 -0.093102939 0.81983972" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " RA Dec redshift_true_sim gamma1_sim gamma2_sim \n", + "--------- ---------- ----------------- ----------- -------------\n", + "9.9850721 0.83404565 0.81983972 0.011937537 0.00051228399\n" + ] } ], "source": [ @@ -227,17 +152,16 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin1_LOS2_R5.dat...\n", - "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin2_LOS2_R5.dat...\n", - "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin3_LOS2_R5.dat...\n", - "Reading catalogue fid_f/LOS2/DES_MocksCat_fid_f_4_Bin4_LOS2_R5.dat...\n" + "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin1_LOS2_R5.dat...\n", + "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin2_LOS2_R5.dat...\n", + "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin3_LOS2_R5.dat...\n" ] } ], @@ -245,7 +169,7 @@ "# Combine all four redshift bins for given cosmo ID, line of sight, and tile number\n", "dat_comb = slics.read_multiple_catalogues(\n", " root_directory,\n", - " cosmo_id=\"fid_f\",\n", + " cosmo_id=\"06_f\",\n", " zbins=None,\n", " lsos=[2],\n", " tiles=[5],\n", @@ -256,96 +180,140 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "1236929" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of galaxies = 1236929\n", + "Number density = 3.56 arcmin^{-2}\n" + ] } ], "source": [ - "len(dat_comb)" + "print(f\"Number of galaxies = {len(dat_comb)}\")\n", + "n_gal = slics.get_number_density(dat_comb)\n", + "print(f\"Number density = {n_gal:.2f} arcmin^{{-2}}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Read CFIS redshift distribution (blind version \"A\", ShapePipe)\n", + "dndz_CFIS_path = \"dndz_SP_A.txt\"\n", + "#dndz_CFIS_path = \"/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt\"dslics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8)" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Testing\n", + "\n", + "# External (CFIS) redshift histogram\n", + "z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path)\n", + "\n", + "# Original SLICS redshift histogram\n", + "dndz_slics, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "200 200 201\n" + "Warning: in at least one z-bin the number of resampled galaxies will be zero.\n", + "Warning: in 61 z-bins the number of resampled galaxies is larger than the input number.\n", + "dropping 26947 to match nofz\n" ] } ], "source": [ - "# Read CFIS redshift distribution (blind version \"A\", ShapePipe)\n", - "dndz_CFIS_path = \"/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt\"\n", - "z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path)\n", - "\n", - "nz = len(z_edges_ext)\n", - "print(len(z_centers_ext), len(dndz_ext), len(z_edges_ext))" + "# Resample\n", + "n_goal = len(dat_comb) / 10\n", + "slics.resample_z(dat_comb, dndz_CFIS_path, n_goal, z_max=1.8, verbose=True)" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "dndz_slics, z_edges_slics = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_CFIS)" + "# Testing\n", + "\n", + "# Resampled SLICS redshift histogram\n", + "dndz_resampled, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext)" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 1, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "0.0" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" + "ename": "NameError", + "evalue": "name 'plt' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Testing: resampled numbers are never higher than original ones\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39msubplots(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n\u001b[1;32m 4\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 5\u001b[0m z_centers_ext, dndz_slics, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 6\u001b[0m z_centers_ext, dndz_resampled, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_xlim([\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m2\u001b[39m])\n", + "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined" + ] } ], "source": [ - "# CHeck that z\n", - "max(z_edges_slics - z_edges_ext)" + "# Testing: resampled numbers are never higher than original ones\n", + "fig, ax = plt.subplots(figsize=(8, 8))\n", + "\n", + "ax.plot(\n", + " z_centers_ext, dndz_slics, '-',\n", + " z_centers_ext, dndz_resampled, '-',\n", + ")\n", + "ax.set_xlim([0, 2])\n", + "plt.savefig(\"dndz_slics_res.pdf\")" ] }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 14, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_47592/2664705319.py:6: RuntimeWarning: invalid value encountered in divide\n", + " z_centers_ext, dndz_resampled / dndz_slics, '-',\n" + ] + }, { "data": { "text/plain": [ - "[]" + "(0.0, 2.0)" ] }, - "execution_count": 54, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -353,176 +321,47 @@ } ], "source": [ - "plt.plot(res[1][:-1], res[0] / sum(res[0]), '-')\n", - "plt.plot(z_centers_ext, dndz_ext / sum(dndz_ext), '-')" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3.1 , 3.125, 3.15 , 3.175, 3.2 , 3.225, 3.25 , 3.275, 3.3 ,\n", - " 3.325, 3.35 , 3.375, 3.4 , 3.425, 3.45 , 3.475, 3.5 , 3.525,\n", - " 3.55 , 3.575, 3.6 , 3.625, 3.65 , 3.675, 3.7 , 3.725, 3.75 ,\n", - " 3.775, 3.8 , 3.825, 3.85 , 3.875, 3.9 , 3.925, 3.95 , 3.975,\n", - " 4. , 4.025, 4.05 , 4.075, 4.1 , 4.125, 4.15 , 4.175, 4.2 ,\n", - " 4.225, 4.25 , 4.275, 4.3 , 4.325, 4.35 , 4.375, 4.4 , 4.425,\n", - " 4.45 , 4.475, 4.5 , 4.525, 4.55 , 4.575, 4.6 , 4.625, 4.65 ,\n", - " 4.675, 4.7 , 4.725, 4.75 , 4.775, 4.8 , 4.825, 4.85 , 4.875,\n", - " 4.9 , 4.925, 4.95 , 4.975])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res[1][np.where(res[0] == 0)]" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "z_max = 1.8" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "idx_z_max = np.where(z_edges_ext < z_max) \n", - "dndz_ext = dndz_ext[idx_z_max] \n", - "dndz_slics = dndz_slics[idx_z_max] " - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "probability = dndz_ext / dndz_slics " + "# Testing: ratio of resampled to original numbers are never larger than unity\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 8))\n", + "\n", + "ax.plot(\n", + " z_centers_ext, dndz_resampled / dndz_slics, '-',\n", + ")\n", + "ax.set_xlim([0, 2])\n", + "plt.savefig(\"dndz_slics_res_ratio.pdf\")" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 2, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "<Column name='dn_dz' dtype='float64' length=72>\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
2.8594946127434253e-07
1.574042958404797e-06
3.4526586550599785e-05
3.6643725378022684e-05
5.022913194677407e-06
1.1714737205167959e-05
8.970696531364506e-06
1.3304558529801936e-05
9.060341138639804e-06
9.521187042241408e-06
9.429373093166353e-06
1.4343356129976788e-05
5.95389015170617e-06
7.148540213151322e-06
1.0605122695037108e-05
7.191759690474512e-06
1.6749245245411434e-05
2.8701152664041492e-05
3.880998267525931e-05
4.5776419574454834e-05
3.935527228675306e-05
...
2.8076328050197772e-05
3.020942349646766e-05
1.8046714427860424e-05
1.880129882157627e-05
2.2470929566663213e-05
1.2017156234951234e-05
2.4378470209440235e-05
1.4958056487754153e-05
1.5363682367389733e-05
1.247317735341576e-05
2.2038203225290923e-05
0.0
1.3428355735607473e-05
1.8418623069785764e-05
2.3499622537313078e-05
2.1033612764878806e-05
2.1430473383084254e-05
4.0807727759405945e-06
1.6966532454325473e-05
5.408643282397454e-06
" - ], - "text/plain": [ - "\n", - "2.8594946127434253e-07\n", - " 1.574042958404797e-06\n", - "3.4526586550599785e-05\n", - "3.6643725378022684e-05\n", - " 5.022913194677407e-06\n", - "1.1714737205167959e-05\n", - " 8.970696531364506e-06\n", - "1.3304558529801936e-05\n", - " 9.060341138639804e-06\n", - " 9.521187042241408e-06\n", - " 9.429373093166353e-06\n", - "1.4343356129976788e-05\n", - " 5.95389015170617e-06\n", - " 7.148540213151322e-06\n", - "1.0605122695037108e-05\n", - " 7.191759690474512e-06\n", - "1.6749245245411434e-05\n", - "2.8701152664041492e-05\n", - " 3.880998267525931e-05\n", - "4.5776419574454834e-05\n", - " 3.935527228675306e-05\n", - " ...\n", - "2.8076328050197772e-05\n", - " 3.020942349646766e-05\n", - "1.8046714427860424e-05\n", - " 1.880129882157627e-05\n", - "2.2470929566663213e-05\n", - "1.2017156234951234e-05\n", - "2.4378470209440235e-05\n", - "1.4958056487754153e-05\n", - "1.5363682367389733e-05\n", - " 1.247317735341576e-05\n", - "2.2038203225290923e-05\n", - " 0.0\n", - "1.3428355735607473e-05\n", - "1.8418623069785764e-05\n", - "2.3499622537313078e-05\n", - "2.1033612764878806e-05\n", - "2.1430473383084254e-05\n", - "4.0807727759405945e-06\n", - "1.6966532454325473e-05\n", - " 5.408643282397454e-06" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" + "ename": "NameError", + "evalue": "name 'np' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Resampled SLICS redshift histogram\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m dndz_resampled_norm, _ \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241m.\u001b[39mhistogram(dat_comb[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mredshift_true_sim\u001b[39m\u001b[38;5;124m\"\u001b[39m], bins\u001b[38;5;241m=\u001b[39mz_edges_ext, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Testing: resampled dndz follows external dndz\u001b[39;00m\n\u001b[1;32m 6\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n", + "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" + ] } ], "source": [ - "probability" + "# Resampled SLICS redshift histogram\n", + "dndz_resampled_norm, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext, density=True)\n", + "\n", + "# Testing: resampled dndz follows external dndz\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 8))\n", + "\n", + "ax.plot(z_centers_ext, dndz_ext, '-', label='CFIS')\n", + "ax.plot(z_centers_ext, dndz_resampled_norm, '-', label='resampled')\n", + "ax.set_xlim([0, 2])\n", + "_ = ax.legend()\n", + "plt.savefig(\"dndz_CFIS_res.pdf\")" ] }, { @@ -552,7 +391,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.6" } }, "nbformat": 4, diff --git a/notebooks/test_slics.py b/notebooks/test_slics.py index bab4d71..a38c71b 100644 --- a/notebooks/test_slics.py +++ b/notebooks/test_slics.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.14.7 +# jupytext_version: 1.15.0 # kernelspec: # display_name: Python 3 (ipykernel) # language: python @@ -22,6 +22,8 @@ import matplotlib.pylab as plt import os +import copy +import numpy as np from cs_util import cat as cs_cat # + @@ -31,16 +33,14 @@ from sp_peaks import slics # - -root_directory = "/n17data/tersenov/SLICS/Cosmo_DES" +#root_directory = "/n17data/tersenov/SLICS/Cosmo_DES" +root_directory = "." cat_path = f"{root_directory}/06_f/LOS3/DES_MocksCat_06_f_4_Bin3_LOS3_R19.dat" # Load catalogue, all columns dat = slics.read_catalogue(cat_path) -# DEBUG -dat_comb = dat - # Print column names print(dat.dtype.names) @@ -50,17 +50,12 @@ # Load only essential columns dat_ess = slics.read_catalogue(cat_path, all_col=False) -from astropy.table import vstack -x = vstack([dat, dat]) - -len(dat) - print(dat_ess[0]) # Combine all four redshift bins for given cosmo ID, line of sight, and tile number dat_comb = slics.read_multiple_catalogues( root_directory, - cosmo_id="fid_f", + cosmo_id="06_f", zbins=None, lsos=[2], tiles=[5], @@ -68,12 +63,73 @@ verbose=True, ) -len(dat_comb) +print(f"Number of galaxies = {len(dat_comb)}") +n_gal = slics.get_number_density(dat_comb) +print(f"Number density = {n_gal:.2f} arcmin^{{-2}}") -# + # Read CFIS redshift distribution (blind version "A", ShapePipe) -dndz_CFIS_path = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt" -res = slics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8) +dndz_CFIS_path = "dndz_SP_A.txt" +#dndz_CFIS_path = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt"dslics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8) + +# + +# Testing + +# External (CFIS) redshift histogram +z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path) + +# Original SLICS redshift histogram +dndz_slics, _ = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_ext) + +# Original SLICS normalised redshift histogram +dndz_slics_norm, _ = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_ext, density=True) +# - + +# Resample +n_goal = len(dat_comb) / 10 +slics.resample_z(dat_comb, dndz_CFIS_path, n_goal, z_max=1.8, verbose=True) + +# + +# Testing + +# Resampled SLICS redshift histogram +dndz_resampled, _ = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_ext) + +# + +# Testing: resampled numbers are never higher than original ones +fig, ax = plt.subplots(figsize=(8, 8)) + +ax.plot( + z_centers_ext, dndz_slics, '-', + z_centers_ext, dndz_resampled, '-', +) +ax.set_xlim([0, 2]) +plt.savefig("dndz_slics_res.pdf") + +# + +# Testing: ratio of resampled to original numbers are never larger than unity + +fig, ax = plt.subplots(figsize=(8, 8)) + +ax.plot( + z_centers_ext, dndz_resampled / dndz_slics, '-', +) +ax.set_xlim([0, 2]) +plt.savefig("dndz_slics_res_ratio.pdf") + +# + +# Resampled SLICS redshift histogram +dndz_resampled_norm, _ = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_ext, density=True) + +# Testing: resampled dndz follows external dndz + +fig, ax = plt.subplots(figsize=(8, 8)) + +ax.plot(z_centers_ext, dndz_ext, '-', label='CFIS') +ax.plot(z_centers_ext, dndz_slics_norm, '-', label='SLICS') +ax.plot(z_centers_ext, dndz_resampled_norm, '-', label='resampled') +ax.set_xlim([0, 2]) +_ = ax.legend() +plt.savefig("dndz_CFIS_slics_res.pdf") # - diff --git a/sp_peaks/slics.py b/sp_peaks/slics.py index 4039598..38f6383 100644 --- a/sp_peaks/slics.py +++ b/sp_peaks/slics.py @@ -15,6 +15,8 @@ from astropy.io import ascii from astropy.table import vstack +from lenspack.geometry import measures + from cs_util import cat as cs_cat @@ -182,13 +184,44 @@ def read_multiple_catalogues( return dat_comb -def resample_z(dat, dndz_path, n_goal, z_max=None): +def drop_marked(dat): + """Drop Marked. + + Remove rows with marked (np.inf) redshifts. + + Parameters + ---------- + dat : dict + input SLICS catalogue + + """ + idx_drop = np.isnan(dat["redshift_true_sim"]) + dat_out = dat[~idx_drop] + + +def resample_z(dat, dndz_path, n_goal, z_max=None, verbose=False): + """Resample Z. + Resample catalogue according to external redshift distribution from file. + + Parameters + ---------- + dat : dict + input SLICS catalogue + dndz_path : str + path to external redshift distribution file + n_goal : int + number of galaxies to be reached after resampling + z_max : float, optional + maximum redshift, default is ``None`` (use all redshifts) + verbose : bool, optional + verbose output if ``True``, default is ``False`` + """ # Read external dndz file z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_path) # Create redshift histogram of SLICS catalogue, using external zbins - dndz_slics, z_edges_slics = np.histogram( + dndz_slics, _ = np.histogram( dat["redshift_true_sim"], bins=z_edges_ext ) @@ -196,6 +229,7 @@ def resample_z(dat, dndz_path, n_goal, z_max=None): # Cut redshifts if desired if z_max is not None: idx_z_max = np.where(z_edges_ext < z_max) + z_centers_ext = z_centers_ext[idx_z_max] dndz_ext = dndz_ext[idx_z_max] dndz_slics = dndz_slics[idx_z_max] @@ -203,9 +237,6 @@ def resample_z(dat, dndz_path, n_goal, z_max=None): # objects dndz_ext = dndz_ext / sum(dndz_ext) * n_goal - import pdb - pdb.set_trace() - # Ratio of external to SLICS histogram = fraction of galaxies in each # bin to resample ratio = dndz_ext / dndz_slics @@ -213,22 +244,90 @@ def resample_z(dat, dndz_path, n_goal, z_max=None): if (ratio == 0).any(): print( "Warning: in at least one z-bin the number of resampled galaxies" - + " will be zero" + + " will be zero." + ) + + idx_over = np.where(ratio > 1)[0] + if len(idx_over) > 0: + print( + f"Warning: in {len(idx_over)} z-bins the number of resampled" + + " galaxies is larger than the input number." ) - # TODO: user-input of total resampled number (or number density) + # Truncate ratio to one + ratio[idx_over] = 1 # Get indices in external redshift histogram of SLICS input catalogue idx_z = np.digitize(dat["redshift_true_sim"], z_edges_ext) + n_tot = 0 + #import pdb + #pdb.set_trace() for idx in range(len(dndz_slics)): - n_drop = int(ratio[idx] * dndz_slics[idx]) + n_drop = dndz_slics[idx] - int(ratio[idx] * dndz_slics[idx]) # Get index list for this z-bin w = (np.where(idx_z == idx + 1))[0] # Create sample of Indices of objects to be dropped for this bin - i_drop = random.sample(list(w), n_drop) + i_drop = np.array(random.sample(list(w), n_drop)) # Mark objects to be dropped with invalid redshift - dat["redshift_true_sim"][i_drop] = -99 + dat["redshift_true_sim"][i_drop] = np.inf + + n_tot = n_tot + len(i_drop) + + if verbose: + print(f'dropping {n_tot} to match nofz'.format(n_tot)) + + drop_marked(dat) + + +def get_extend(dat): + """Get extend. + + Return extend of catalogue. + + Parameters + ---------- + dat : dict + input SLICS catalogue + + Returns + ------- + list + extend ([ra_min, ra_max, dec_min, dec_max]) + + """ + ra_min = np.amin(dat["RA"]) + ra_max = np.amax(dat["RA"]) + dec_min = np.amin(dat["Dec"]) + dec_max = np.amax(dat["Dec"]) + + return [ra_min, ra_max, dec_min, dec_max] + + +def get_number_density(dat): + """Get Number Density + + Return galaxy number density, not accounting for masking + + Parameters + ---------- + dat : dict + input SLICS catalogue + + Returns + ------- + float + number of galaxies [arcmin^{-2}] + + """ + extend = get_extend(dat) + + solid_angle_deg = measures.solid_angle(extend) + solid_angle_amin = solid_angle_deg * 60 ** 2 + + ngal = len(dat) / solid_angle_amin + + return ngal From 0e8026005747d6ae446c5bef2bddcf11e1313085 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Tue, 1 Aug 2023 13:43:39 +0200 Subject: [PATCH 4/8] removed test py script --- notebooks/test.py | 32 -------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 notebooks/test.py diff --git a/notebooks/test.py b/notebooks/test.py deleted file mode 100644 index 7677f92..0000000 --- a/notebooks/test.py +++ /dev/null @@ -1,32 +0,0 @@ -# --- -# jupyter: -# jupytext: -# formats: ipynb,py -# text_representation: -# extension: .py -# format_name: light -# format_version: '1.5' -# jupytext_version: 1.14.7 -# kernelspec: -# display_name: Python 3 (ipykernel) -# language: python -# name: python3 -# --- - -# # CosmoSLICS simulation testing -# 07/2023 - -# %matplotlib inline -# %load_ext autoreload -# %autoreload 2 - -import matplotlib.pylab as plt -import os -from cs_util import cat as cs_cat - -# + -import sp_peaks -print(f"sp_peaks version = {sp_peaks.__version__}") - -from sp_peaks import slics -# - From b743dab58a64474755d1a4f294d3e7b1b0926202 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Tue, 1 Aug 2023 13:44:17 +0200 Subject: [PATCH 5/8] ignore ipynb notebooks in notebook folder --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 01c2fc2..b4c9666 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,6 @@ build dist sp_peaks.egg-info/ .ipynb_checkpoints -example/test_slics.ipynb +notebook/test_slics.ipynb __pycache__ poetry.lock From 8551f703273cdb67a8457da1670608df067ac8c7 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Tue, 1 Aug 2023 13:44:31 +0200 Subject: [PATCH 6/8] ignore ipynb notebooks in notebook folder --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index b4c9666..8065813 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,6 @@ build dist sp_peaks.egg-info/ .ipynb_checkpoints -notebook/test_slics.ipynb +notebooks/test_slics.ipynb __pycache__ poetry.lock From 7888e4044fb8c2e892991613c0aa23d1e1e5c534 Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Tue, 1 Aug 2023 16:21:51 +0200 Subject: [PATCH 7/8] resmpling: case if original dndz=0 --- notebooks/test_slics.ipynb | 146 ++++++++++++++++++++++--------------- notebooks/test_slics.py | 33 ++++++--- sp_peaks/slics.py | 45 ++++++++---- 3 files changed, 145 insertions(+), 79 deletions(-) diff --git a/notebooks/test_slics.ipynb b/notebooks/test_slics.ipynb index cef3b0c..995fb4b 100644 --- a/notebooks/test_slics.ipynb +++ b/notebooks/test_slics.ipynb @@ -54,12 +54,25 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "#root_directory = \"/n17data/tersenov/SLICS/Cosmo_DES\"\n", - "root_directory = \".\"" + "# Set input directories\n", + "\n", + "# SLICS simulations\n", + "root_directory = \"/n17data/tersenov/SLICS/Cosmo_DES\"\n", + "#root_directory = \".\"\n", + "\n", + "# CFIS redshift distribution\n", + "dndz_CFIS_directory = \"/n17data/mkilbing/astro/data/CFIS/v1.0/nz\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read SLICS catalogue" ] }, { @@ -150,9 +163,16 @@ "print(dat_ess[0])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read and combine multiple SLICS catalogues" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -161,7 +181,8 @@ "text": [ "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin1_LOS2_R5.dat...\n", "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin2_LOS2_R5.dat...\n", - "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin3_LOS2_R5.dat...\n" + "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin3_LOS2_R5.dat...\n", + "Reading catalogue 06_f/LOS2/DES_MocksCat_06_f_4_Bin4_LOS2_R5.dat...\n" ] } ], @@ -180,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -198,56 +219,74 @@ "print(f\"Number density = {n_gal:.2f} arcmin^{{-2}}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Resample SLICS to match exteral dn/dz" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ - "# Read CFIS redshift distribution (blind version \"A\", ShapePipe)\n", - "dndz_CFIS_path = \"dndz_SP_A.txt\"\n", - "#dndz_CFIS_path = \"/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt\"dslics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8)" + "# Set CFIS redshift distribution (blind version \"A\", ShapePipe)\n", + "dndz_CFIS_path = f\"{dndz_CFIS_directory}/dndz_SP_A.txt\"" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ - "# Testing\n", + "# Test resampling. Compare redshift distributions\n", "\n", "# External (CFIS) redshift histogram\n", "z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path)\n", "\n", "# Original SLICS redshift histogram\n", - "dndz_slics, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext)" + "dndz_slics, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext)\n", + "\n", + "# Original SLICS normalised redshift histogram\n", + "dndz_slics_norm, _ = np.histogram(dat_comb[\"redshift_true_sim\"], bins=z_edges_ext, density=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the number of objects to resample.\n", + "# Has to be smaller than number of input objects.\n", + "n_goal = len(dat_comb) / 2" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Warning: in at least one z-bin the number of resampled galaxies will be zero.\n", - "Warning: in 61 z-bins the number of resampled galaxies is larger than the input number.\n", - "dropping 26947 to match nofz\n" + "Warning: in 4 z-bins the number of resampled galaxies will be set to the original number.\n", + "dropping 622883 to match nofz\n" ] } ], "source": [ "# Resample\n", - "n_goal = len(dat_comb) / 10\n", "slics.resample_z(dat_comb, dndz_CFIS_path, n_goal, z_max=1.8, verbose=True)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -259,19 +298,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 48, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'plt' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Testing: resampled numbers are never higher than original ones\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m \u001b[43mplt\u001b[49m\u001b[38;5;241m.\u001b[39msubplots(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n\u001b[1;32m 4\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 5\u001b[0m z_centers_ext, dndz_slics, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 6\u001b[0m z_centers_ext, dndz_resampled, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m-\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_xlim([\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m2\u001b[39m])\n", - "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -280,7 +318,7 @@ "\n", "ax.plot(\n", " z_centers_ext, dndz_slics, '-',\n", - " z_centers_ext, dndz_resampled, '-',\n", + " z_centers_ext, dndz_resampled, '-.',\n", ")\n", "ax.set_xlim([0, 2])\n", "plt.savefig(\"dndz_slics_res.pdf\")" @@ -288,30 +326,20 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_47592/2664705319.py:6: RuntimeWarning: invalid value encountered in divide\n", + "/tmp/ipykernel_31672/1314214541.py:6: RuntimeWarning: invalid value encountered in divide\n", " z_centers_ext, dndz_resampled / dndz_slics, '-',\n" ] }, { "data": { - "text/plain": [ - "(0.0, 2.0)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -334,19 +362,20 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": 50, + "metadata": { + "lines_to_next_cell": 0 + }, "outputs": [ { - "ename": "NameError", - "evalue": "name 'np' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# Resampled SLICS redshift histogram\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m dndz_resampled_norm, _ \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241m.\u001b[39mhistogram(dat_comb[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mredshift_true_sim\u001b[39m\u001b[38;5;124m\"\u001b[39m], bins\u001b[38;5;241m=\u001b[39mz_edges_ext, density\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Testing: resampled dndz follows external dndz\u001b[39;00m\n\u001b[1;32m 6\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m8\u001b[39m, \u001b[38;5;241m8\u001b[39m))\n", - "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -358,16 +387,19 @@ "fig, ax = plt.subplots(figsize=(8, 8))\n", "\n", "ax.plot(z_centers_ext, dndz_ext, '-', label='CFIS')\n", + "ax.plot(z_centers_ext, dndz_slics_norm, '-', label='SLICS')\n", "ax.plot(z_centers_ext, dndz_resampled_norm, '-', label='resampled')\n", "ax.set_xlim([0, 2])\n", "_ = ax.legend()\n", - "plt.savefig(\"dndz_CFIS_res.pdf\")" + "plt.savefig(\"dndz_CFIS_slics_res.pdf\")" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "lines_to_next_cell": 2 + }, "outputs": [], "source": [] } @@ -391,7 +423,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/notebooks/test_slics.py b/notebooks/test_slics.py index a38c71b..b82af3e 100644 --- a/notebooks/test_slics.py +++ b/notebooks/test_slics.py @@ -6,7 +6,7 @@ # extension: .py # format_name: light # format_version: '1.5' -# jupytext_version: 1.15.0 +# jupytext_version: 1.14.7 # kernelspec: # display_name: Python 3 (ipykernel) # language: python @@ -31,10 +31,19 @@ print(f"sp_peaks version = {sp_peaks.__version__}") from sp_peaks import slics + +# + +# Set input directories + +# SLICS simulations +root_directory = "/n17data/tersenov/SLICS/Cosmo_DES" +#root_directory = "." + +# CFIS redshift distribution +dndz_CFIS_directory = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz" # - -#root_directory = "/n17data/tersenov/SLICS/Cosmo_DES" -root_directory = "." +# ## Read SLICS catalogue cat_path = f"{root_directory}/06_f/LOS3/DES_MocksCat_06_f_4_Bin3_LOS3_R19.dat" @@ -52,6 +61,8 @@ print(dat_ess[0]) +# ## Read and combine multiple SLICS catalogues + # Combine all four redshift bins for given cosmo ID, line of sight, and tile number dat_comb = slics.read_multiple_catalogues( root_directory, @@ -67,12 +78,13 @@ n_gal = slics.get_number_density(dat_comb) print(f"Number density = {n_gal:.2f} arcmin^{{-2}}") -# Read CFIS redshift distribution (blind version "A", ShapePipe) -dndz_CFIS_path = "dndz_SP_A.txt" -#dndz_CFIS_path = "/n17data/mkilbing/astro/data/CFIS/v1.0/nz/dndz_SP_A.txt"dslics.resample_z(dat_comb, dndz_CFIS_path, len(dat_comb) / 4, z_max=1.8) +# ### Resample SLICS to match exteral dn/dz + +# Set CFIS redshift distribution (blind version "A", ShapePipe) +dndz_CFIS_path = f"{dndz_CFIS_directory}/dndz_SP_A.txt" # + -# Testing +# Test resampling. Compare redshift distributions # External (CFIS) redshift histogram z_centers_ext, dndz_ext, z_edges_ext = cs_cat.read_dndz(dndz_CFIS_path) @@ -84,8 +96,11 @@ dndz_slics_norm, _ = np.histogram(dat_comb["redshift_true_sim"], bins=z_edges_ext, density=True) # - +# Set the number of objects to resample. +# Has to be smaller than number of input objects. +n_goal = len(dat_comb) / 2 + # Resample -n_goal = len(dat_comb) / 10 slics.resample_z(dat_comb, dndz_CFIS_path, n_goal, z_max=1.8, verbose=True) # + @@ -100,7 +115,7 @@ ax.plot( z_centers_ext, dndz_slics, '-', - z_centers_ext, dndz_resampled, '-', + z_centers_ext, dndz_resampled, '-.', ) ax.set_xlim([0, 2]) plt.savefig("dndz_slics_res.pdf") diff --git a/sp_peaks/slics.py b/sp_peaks/slics.py index 38f6383..e3c37e5 100644 --- a/sp_peaks/slics.py +++ b/sp_peaks/slics.py @@ -239,19 +239,28 @@ def resample_z(dat, dndz_path, n_goal, z_max=None, verbose=False): # Ratio of external to SLICS histogram = fraction of galaxies in each # bin to resample - ratio = dndz_ext / dndz_slics + ratio = dndz_ext + w_nonz = dndz_slics > 0 - if (ratio == 0).any(): + # Set ratio where SLICS histogram is non-zero + ratio[w_nonz] = ratio[w_nonz] / dndz_slics[w_nonz] + + # Set to 0 where SLICS histogram is zero -> resample zero galaxies + # in this bin + ratio[~w_nonz] = 0 + + idx_zero = np.where(~w_nonz)[0] + if len(idx_zero) > 0: print( - "Warning: in at least one z-bin the number of resampled galaxies" - + " will be zero." + f"Warning: in {len(idx_zero)} z-bins the number of resampled galaxies" + + " will be set to zero." ) idx_over = np.where(ratio > 1)[0] if len(idx_over) > 0: print( f"Warning: in {len(idx_over)} z-bins the number of resampled" - + " galaxies is larger than the input number." + + " galaxies will be set to the original number." ) # Truncate ratio to one @@ -261,21 +270,31 @@ def resample_z(dat, dndz_path, n_goal, z_max=None, verbose=False): idx_z = np.digitize(dat["redshift_true_sim"], z_edges_ext) n_tot = 0 - #import pdb - #pdb.set_trace() for idx in range(len(dndz_slics)): - n_drop = dndz_slics[idx] - int(ratio[idx] * dndz_slics[idx]) + + if ratio[idx] == 1: + # No galaxy is removed in this z-bin + continue # Get index list for this z-bin w = (np.where(idx_z == idx + 1))[0] - # Create sample of Indices of objects to be dropped for this bin - i_drop = np.array(random.sample(list(w), n_drop)) + if ratio[idx] > 0: + # Number of objects to remove + n_drop = dndz_slics[idx] - int(ratio[idx] * dndz_slics[idx]) + + # Create sample of Indices of objects to be dropped for this bin + i_drop = np.array(random.sample(list(w), n_drop)) + + # Mark objects to be dropped with invalid redshift + dat["redshift_true_sim"][i_drop] = np.inf - # Mark objects to be dropped with invalid redshift - dat["redshift_true_sim"][i_drop] = np.inf + else: + # Remove all objects in this z-bin + n_drop = len(w) + dat["redshift_true_sim"][w] = np.inf - n_tot = n_tot + len(i_drop) + n_tot = n_tot + n_drop if verbose: print(f'dropping {n_tot} to match nofz'.format(n_tot)) From 57579161071570da3adb88fa37c4ec44712f575d Mon Sep 17 00:00:00 2001 From: Martin Kilbinger Date: Wed, 30 Aug 2023 16:18:53 +0200 Subject: [PATCH 8/8] transformer script style --- sp_peaks/transform_to_notebooks.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/sp_peaks/transform_to_notebooks.py b/sp_peaks/transform_to_notebooks.py index 8d50e49..e3918ad 100755 --- a/sp_peaks/transform_to_notebooks.py +++ b/sp_peaks/transform_to_notebooks.py @@ -4,11 +4,19 @@ import jupytext def transform_to_notebooks(): + """Transform to Notebooks. + + Transform python scripts to jupyter notbooks. + + """ notebook_dir = "./notebooks" for filename in os.listdir(notebook_dir): if filename.endswith(".py"): - nb_file = os.path.join(notebook_dir, f"{os.path.splitext(filename)[0]}.ipynb") + nb_file = os.path.join( + notebook_dir, + f"{os.path.splitext(filename)[0]}.ipynb", + ) if not os.path.exists(nb_file): py_file = os.path.join(notebook_dir, filename) jupytext.write(jupytext.read(py_file), nb_file) @@ -16,9 +24,12 @@ def transform_to_notebooks(): else: print(f"{nb_file} exists") + def main(): - print("MKDEBUG") transform_to_notebooks() + return 0 + + if __name__ == "__main__": main()