def set_bin_(data, bin_num, bound_scale, method="mean"):
if method == "mean":
temp_data = numpy.sort(data)
bin_size = len(temp_data) / bin_num
bins = [temp_data[int(i * bin_size)] for i in range(bin_num)]
bins.append(temp_data[-1] * bound_scale)
bins = numpy.array(bins)
elif method == "linear":
m1, m2 = data.min(), data.max()
bins = numpy.linspace(m1, m2, bin_num + 1)
bins[-1] = bins[-1] * bound_scale
elif method == "log":
data_min = data.min()
bin_num2 = int(bin_num / 2)
bins = numpy.zeros((bin_num + 1, ))
if data_min < 0:
temp_data = numpy.sort(numpy.abs(data))
data_min, data_max = temp_data[0] * 0.98, temp_data[-1]
bin_num_ = bin_num2 - 1
invers = range(bin_num_, -1, -1)
hbins = tool_box.set_bin_log(data_min, data_max, bin_num_)
bins[bin_num2 + 1:] = hbins
bins[:bin_num2] = -hbins[invers]
bins[0] = bins[0] * bound_scale
bins[-1] = bins[-1] * bound_scale
else:
data_max = data.max()
bins = tool_box.set_bin_log(data_min, data_max, bin_num)
bins[0] = bins[0] * 0.95
bins[-1] = bins[-1] * bound_scale
else:
m = max(numpy.abs(data.min()), numpy.abs(data.max()))
bins = numpy.linspace(-m, m, bin_num + 1)
bins[-1] = bins[-1] * bound_scale
bins[0] = bins[0] * bound_scale
return bins
from plot_tool import Image_Plot
import tool_box
import numpy
import corner
import pyccl as ccl
import correlation_function_tool as cf_tool
import h5py
import camb
import time
cmd = argv[1]
dx = float(argv[2])
num = int(argv[3])
Lpts_min, Lpts_max, Lpts_num = 10, 20000, 10000
ell = tool_box.set_bin_log(Lpts_min, Lpts_max, Lpts_num)
redshift_bin = numpy.array([0.2, 0.39, 0.58, 0.72, 0.86, 1.02, 1.3],
dtype=numpy.float32)
redshift_bin_num = len(redshift_bin) - 1
tomo_panel_num = int(
(redshift_bin_num * redshift_bin_num + redshift_bin_num) / 2)
theta_num = 30
theta = numpy.zeros((tomo_panel_num, theta_num))
theta_radian = numpy.zeros((tomo_panel_num, theta_num))
for i in range(tomo_panel_num):
theta[i] = tool_box.set_bin_log(1, 60, theta_num)
theta_radian[i] = theta[i] / 60 / 180 * numpy.pi
theta_deg = theta / 60
# import os
# my_home = os.popen("echo $HOME").readlines()[0][:-1]
# path.append('%s/work/mylib/'%my_home)
path.append("D:/Github/astrophy-research/mylib/")
from plot_tool import Image_Plot
import tool_box
parent_path = "F:/works/GGL/1/w1/"
img = Image_Plot()
img.subplots(1, 1)
file_num = 6
bin_num = 13
x = tool_box.set_bin_log(0.04, 15, bin_num + 1)
print(x)
signal = numpy.zeros((file_num, bin_num))
sigma = numpy.zeros((file_num, bin_num))
los_dist = numpy.zeros((file_num, bin_num))
for i in range(file_num):
data_path = parent_path + "cmass_result_w_1_%s.npz" % i
data = numpy.load(data_path)["arr_0"]
signal[i] = data[0]
sigma[i] = data[1]
los_dist[i] = data[-1]
for i in range(6):
print(x.shape, signal[:, i].shape)
img.axs[0][0].errorbar(los_dist[:, i],
st = time.time()
redshift_bin = numpy.array([0.2, 0.39, 0.58, 0.72, 0.86, 1.02, 1.3],dtype=numpy.float32)
h5f = h5py.File("./data/zhist.hdf5","r")
zehist = h5f["/zhist"][()]
zebin = h5f["/zbin"][()]
zebin_cent = h5f["/zbin_cent"][()]
h5f.close()
redshift_bin_num = 6
tomo_panel_num = int((redshift_bin_num * redshift_bin_num + redshift_bin_num) / 2)
h = 0.674
ell = tool_box.set_bin_log(10, 20000, 10000)
used_zbins = numpy.array([0,1,1,1,1,1])
sigma8_num = 250
omega_c_num = 100
omega_b_num = 50
theta_num = 15
sigma8_list = numpy.linspace(0.3, 2.5, sigma8_num)
omega_c_list = numpy.linspace(0.01, 0.8,omega_c_num)
omega_b_list = numpy.linspace(0.01,0.2,omega_b_num)
theta_deg = numpy.zeros((15, theta_num))
for i in range(15):
theta_deg[i] = tool_box.set_bin_log(0.8, 60, theta_num)/60
cos_2theta = numpy.cos(2 * pos_ang)
sin_2theta = numpy.sin(2 * pos_ang)
et = e1 * cos_2theta - e2 * sin_2theta
ex = e1 * sin_2theta + e2 * cos_2theta
# crit = co_dist_s/co_dist_f/(co_dist_s-co_dist_f)/(1+z_f)
# crit_integ = co_dist_integ_s/co_dist_integ_f/(co_dist_integ_s-co_dist_integ_f)/(1+z_f)
crit = phy_dist_s / phy_dist_f / (phy_dist_s - phy_dist_f) * (1 + z_f)
crit_integ = phy_dist_integ_s / phy_dist_integ_f / (
phy_dist_integ_s - phy_dist_integ_f) * (1 + z_f)
# radius bin
radius_num = 24
radius_bin = tool_box.set_bin_log(0.1, 25.12, radius_num + 1)
print("Radius bin:", radius_bin)
theta = numpy.linspace(0, 2 * numpy.pi, 1000)
# mask
mask_py = numpy.zeros((source_num, radius_num), dtype=numpy.intc) - 1
img = Image_Plot()
img.subplots(1, 1)
result = numpy.zeros((3, radius_num))
for i in range(radius_num):
idx1 = sep_dist >= radius_bin[i]
idx2 = sep_dist < radius_bin[i + 1]
theta = h5f["/theta"][()]
# only \xi_+
xi = h5f["/xi_p"][()]
cov_inv = h5f["/inv_cov_xi_p"][()]
used_zbin = h5f["/used_zbin"][()]
h5f.close()
# arcmin to radian & degree
theta_radian = theta / 60 / 180 * numpy.pi
theta_degree = theta / 60
data_num = theta_radian.shape[0]
theta_num_per_bin = 5
ell = tool_box.set_bin_log(10, 20000, 10000)
print("Data vector len: ", xi.shape)
################### initialize emcee #############################
numpy.random.seed(seed_ini) #+ rank*10)
para_lim = [[0.1, 3], [0.01, 0.8], [0.01, 0.2]]
nwalkers, ndim = thread, len(para_lim)
initial = numpy.zeros((nwalkers, ndim))
for i in range(ndim):
a, b = para_lim[i]
initial[:, i] = numpy.random.uniform(a, b, nwalkers)
print(nsteps, " steps")
from sys import path, argv
path.append('%s/work/mylib/' % my_home)
import h5py
import numpy
import tool_box
import time
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
cpus = comm.Get_size()
cor_gg_len = int(argv[1])
cmd = argv[2]
chi_guess_num = cpus
chi_guess_bin = tool_box.set_bin_log(1. / 10**9, 1. / 10**4, chi_guess_num)
print(chi_guess_bin)
shear_test = numpy.linspace(-0.04, 0.04, chi_guess_num)
mean = [0, 0]
i = rank
if cmd == "corr":
cov = [[numpy.abs(chi_guess_bin[i] * 2), chi_guess_bin[i]],
[chi_guess_bin[i],
numpy.abs(chi_guess_bin[i] * 2)]]
gg1 = tool_box.rand_gauss2n(cor_gg_len, mean,
cov).astype(dtype=numpy.float32)
gg2 = tool_box.rand_gauss2n(cor_gg_len, mean,
def set_bin(data, bin_num, bound_scale, method="mean", log_end=5):
if method == "mean":
temp_data = numpy.sort(data)
bin_size = len(temp_data) / bin_num
bins = [temp_data[int(i * bin_size)] for i in range(bin_num)]
bins.append(temp_data[-1] * bound_scale)
bins = numpy.array(bins)
elif method == "sym-mean":
temp_data = numpy.sort(
numpy.abs(data)) # [:int(len(data[data>0])*0.99)]
bin_size = len(temp_data) / bin_num * 2
bins = numpy.array(
[temp_data[int(i * bin_size)] for i in range(1, int(bin_num / 2))])
bins = numpy.sort(numpy.append(numpy.append(-bins, [0.]), bins))
bound = numpy.max(numpy.abs(data)) * bound_scale
bins = numpy.append(-bound, numpy.append(bins, bound))
elif method == "linear":
m1, m2 = data.min(), data.max()
bins = numpy.linspace(m1, m2, bin_num + 1)
bins[-1] = bins[-1] * bound_scale
elif method == "mix_bin":
mean_num, log_num = bin_num
mean_num2, log_num2 = int(mean_num / 2), int(log_num / 2)
hbins = numpy.zeros((mean_num2 + log_num2, ))
temp_data = numpy.sort(
numpy.abs(data)) # [:int(len(data[data>0])*0.99)]
bin_size = len(temp_data) / mean_num * 2
mean_bins = numpy.array(
[temp_data[int(i * bin_size)] for i in range(1, mean_num2)])
hbins[:mean_num2 - 1] = mean_bins
hbins[mean_num2 - 1] = temp_data[-1]
ed = numpy.log10(temp_data[-1])
log_bin = 10**numpy.linspace(ed, ed + log_end, log_num2 + 1)
hbins[mean_num2:] = log_bin[1:]
inv = range(mean_num2 + log_num2 - 1, -1, -1)
bins = numpy.zeros((mean_num + log_num + 1))
bins[mean_num2 + log_num2 + 1:] = hbins
bins[:mean_num2 + log_num2] = -hbins[inv]
elif method == "log":
data_min = data.min()
bin_num2 = int(bin_num / 2)
bins = numpy.zeros((bin_num + 1, ))
if data_min < 0:
temp_data = numpy.sort(numpy.abs(data))
data_min, data_max = temp_data[0], temp_data[-1]
if data_min < 10:
data_min = 10
else:
data_min = data_min * 0.95
bin_num_ = bin_num2 - 1
inverse = range(bin_num_, -1, -1)
hbins = tool_box.set_bin_log(data_min, data_max, bin_num2)
# hbins = numpy.exp(numpy.linspace(numpy.log(data_min), numpy.log(data_max), bin_num2))
# hbins = 10**numpy.linspace(numpy.log10(data_min), numpy.log10(data_max), bin_num2)
bins[bin_num2 + 1:] = hbins
bins[:bin_num2] = -hbins[inverse]
bins[0] = bins[0] * bound_scale
bins[-1] = bins[-1] * bound_scale
else:
data_max = data.max()
bins = tool_box.set_bin_log(data_min, data_max, bin_num)
bins[0] = bins[0] * 0.95
bins[-1] = bins[-1] * bound_scale
else:
m = max(numpy.abs(data.min()), numpy.abs(data.max()))
bins = numpy.linspace(-m, m, bin_num + 1)
bins[-1] = bins[-1] * bound_scale
bins[0] = bins[0] * bound_scale
return bins
# arcmin to radian & degree
theta_radian = theta/60/180*numpy.pi
theta_degree = theta/60
theta_num_per_bin = 5
data_num = theta_radian.shape[0]
print("Data vec: ", theta_radian.shape)
# print(theta)
# print(theta_radian)
# print(theta_degree)
logger = tool_box.get_logger("./logs/log_%d.dat"%rank)
ell = tool_box.set_bin_log(5, 15000, 200)
# xi_cache = numpy.zeros((len(ijk_sub), data_num)) - 1
count = 0
total_step = len(ijk_sub)
for tag in ijk_sub:
i, j, k = tag
omega_bm0, omega_cm0, sigma8 = omega_bm_bin[i], omega_cm_bin[j], sigma8_bin[k]
try:
xi_predict = cf_tool.get_tomo_xi_ccl_2(sigma8, omega_cm0, omega_bm0, h, zebin_cent, zehist,
theta_degree, theta_num_per_bin, ell, used_zbins)
diff = xi - xi_predict.flatten()
chi_sq = - 0.5 * numpy.dot(diff, numpy.dot(cov_inv, diff))
# xi_cache[count] = xi_predict
import numpy
import matplotlib.pyplot as plt
from sys import path
path.append("E:/Github/astrophy-research/mylib")
from plot_tool import Image_Plot
from Fourier_Quad import Fourier_Quad
import h5py
from astropy.cosmology import FlatLambdaCDM
import tool_box
radius_bin = tool_box.set_bin_log(0.04,15, 13)
h = 0.7
C_0_hat = 2.99792458
H_0 = 100*h
coeff = 1000*C_0_hat/h
cosmos = FlatLambdaCDM(H_0, Om0=0.31)
fq = Fourier_Quad(12, 124)
filen = 8
result = numpy.zeros((5, filen))
rad_id = 6
area = 1
fore_zbin = 1
print(radius_bin[rad_id], radius_bin[rad_id+1])
data_path = "F:/works/GGL/%d/"%fore_zbin
cfht_data = numpy.loadtxt("E:/Github/astrophy-research/galaxy-galaxy lensing/GGL_calculation/lensing_low/data.dat")
# numprocs = comm.Get_size()
numprocs = 1# comm.Get_size()
rank = 0
h0 = 0.71
H0 = 100*h0
omg_cm0 = 0.2648
omg_bm0 = 0.0448
# omg_m0 = omg_cm0 + omg_bm0
omg_m0 = 0.2648
cosmos = FlatLambdaCDM(H0,omg_m0)
radius_bin_num = 13
radius_bin = tool_box.set_bin_log(0.1, 30, radius_bin_num+1)
if rank == 0:
print("Radius bin: ", radius_bin)
h5f = h5py.File("/home/hklee/work/cosmoDC2/c_data.h5","r")
halo_dec = h5f["/dec"][()]
halo_ra = h5f["/ra"][()]
halo_mass = h5f["/halo_mass"][()]
halo_z = h5f["/redshift"][()]
# halo_id = h5f["/halo_id"][()].astype(dtype=numpy.intc)
h5f.close()
h5f = h5py.File("/home/hklee/work/cosmoDC2/g_data.h5","r")
ori_src_dec = h5f["/dec"][()]
ori_src_ra = h5f["/ra"][()]
ori_src_z = h5f["/redshift"][()]
import tool_box
import warnings
from sklearn.cluster import KMeans
import time
import prepare_tools
warnings.filterwarnings('error')
# parameters
area_num = 4
# theta bin
theta_bin_num = 5
# theta_bin = tool_box.set_bin_log(1, 128, theta_bin_num+1).astype(numpy.float32)
theta_bin = tool_box.set_bin_log(0.8, 60, theta_bin_num+1).astype(numpy.float32)
# bin number for ra & dec of each exposure
deg2arcmin = 60
deg2rad = numpy.pi/180
grid_size = 15 #arcmin
# position in CFHTLens catalog
ra_idx = 0
dec_idx = 1
redshift_idx = 10
redshift_sep_thresh = 0.01
rank = comm.Get_rank()
cpus = comm.Get_size()
time.sleep(rank * 0.5)
t1 = time.time()
data_path = argv[1]
tag_1 = int(argv[2])
tag_2 = tag_1 + 1
data_type = argv[3]
# chi guess bin for PDF_SYM
chi_guess_num = 400
inv = [chi_guess_num - 1 - i for i in range(chi_guess_num)]
chi_guess_bin_p = tool_box.set_bin_log(3. * 10**(-10), 6. * 10**(-4),
chi_guess_num).astype(numpy.float32)
chi_guess_bin = numpy.zeros((2 * chi_guess_num, ), dtype=numpy.float32)
chi_guess_bin[:chi_guess_num] = -chi_guess_bin_p[inv]
chi_guess_bin[chi_guess_num:] = chi_guess_bin_p
chi_guess_bin = numpy.sort(chi_guess_bin)
chi_guess_num = int(chi_guess_num * 2)
# chi_guess_num = 100
# inv = [chi_guess_num-1-i for i in range(chi_guess_num)]
# xi_cache = numpy.load(data_path+"/xi_cache_%s.npz"%data_type)["arr_0"]
# signal_p = xi_cache[0,int(tag_1/2)]
# signal_p_err = xi_cache[1,int(tag_1/2)]*10
# chi_guess_bin = numpy.linspace(signal_p-signal_p_err, signal_p + signal_p_err, chi_guess_num).astype(numpy.float32)
mg_bin_num = 10
omg_cm0h2 = 0.26 * h**2
omg_bm0 = 0.05
omg_bm0h2 = 0.05 * h**2
omg_m0 = omg_cm0 + omg_bm0
kmin, cal_kmax, interp_kmax, kpts_num = 1e-4, 3, 5, 300
zmin, interp_zmax, zbin_num, interp_znum = 0, 4, 150, int(argv[1])
zpts_test_1 = numpy.linspace(zmin, interp_zmax, zbin_num)
zpts_test_2 = numpy.linspace(zmin, interp_zmax, interp_znum)
kh_test = tool_box.set_bin_log(kmin, cal_kmax, kpts_num)
t1 = time.time()
camb_result = cf_tool.get_CambResult(H0,
omg_cm0h2,
omg_bm0h2,
As,
ns,
zpts_test_1,
kmax=interp_kmax)[0]
pk_interp = camb_result.get_matter_power_interpolator()
sigma8_1 = camb_result.get_sigma8()[-1]
pk_nonlin_interp_1 = cf_tool.get_interpPk(pk_interp, zpts_test_1, kh_test)
import gauss_fit_fun
import scipy
import tool_box
coeff = 554.682135528
fq = Fourier_Quad(12,123)
total_path = "E:/GGL_FQ/"
# signal = numpy.zeros((2,10))
npz_cache = numpy.load("%scache.npz"%total_path)
signal = npz_cache["arr_0"]
print(signal.shape)
r = tool_box.set_bin_log(0.04,15,13)[:10]
# img = Image_Plot(plt_line_width=2)
# img.subplots(1, 1)
# img.set_style()
# img.axs[0][0].errorbar(r,signal[0],signal[1],capsize=3)
# img.axs[0][0].set_xscale("log")
# img.axs[0][0].set_yscale("log")
# img.set_label(0,0,0,"$\Delta\Sigma \; [\\rm{h \cdot M_{\odot}} \cdot \\rm{pc^{-2}}]$")
# img.set_label(0,0,1,"$\\rm{R} \; [\\rm{Mpc} \cdot \\rm{h^{-1}}]$")
# img.save_img(total_path + "signal.png")
# img.show_img()
# exit()
nums = []
for ig in range(10):
h5f = h5py.File("%sradius_%d.hdf5"%(total_path,ig),"r")
data_col = h5f["/data_col"].value
