def compare_abundance_line(param_fname1, param_fname2):
param1 = dtk.Param(param_fname1)
param2 = dtk.Param(param_fname2)
m_infall1, radius1 = load_abundance_line(get_fname(param1))
m_infall2, radius2 = load_abundance_line(get_fname(param2))
f, ax = plt.subplots(1)
ax.loglog(m_infall1, radius1, label='arg1')
ax.loglog(m_infall2, radius2, label='arg2')
plt.show()
def make_zoom_param(input_param_fname):
base_param = dtk.Param(input_param_fname)
mi_bins_info = base_param.get_float_list("mi_bins_info")
rd_bins_info = base_param.get_float_list("rd_bins_info")
rm_bins_info = base_param.get_float_list("rm_bins_info")
spacing = {}
spacing["mi"] = get_spacing(mi_bins_info)
spacing["rd"] = get_spacing(rd_bins_info)
spacing["rm"] = get_spacing(rm_bins_info)
model_fit_param = dtk.Param("figs/"+input_param_fname+"/calc_likelihood_bounds.py/grid_fit_param.txt")
model_params = ['mi', 'rd', 'rm']
for mp in model_params:
if mp in model_fit_param:
rd_factor = 1.0
if mp == "rd":
rd_factor = 1000.0
old_values = base_param.get_float_list(mp+"_bins_info")
center = model_fit_param.get_float(mp)
lower, upper = model_fit_param.get_float_list(mp+"_limits")
print("\n\nparam:", mp)
old_range = (old_values[1]-old_values[0])*rd_factor
print(" old range: {:.3f}->{:.3f}".format(old_values[0]*rd_factor, old_values[1]*rd_factor))
print("\trange: {:.3f}".format((old_values[1]-old_values[0])*rd_factor))
print(" fit: {:.3f} +{:.3f} -{:.3f}".format(center, upper-center, center-lower))
print("\trange: {:3f}".format(upper-lower))
err = np.max([center-lower, upper-center, spacing[mp]])
# print(center-lower, upper-center)
print(" target err: {:.3f}".format(err))
# if err< 0.002:
# err = 0.002
new_lower_limit = lower - err*3
new_upper_limit = upper + err*3
if new_lower_limit < 0:
new_lower_limit = 0
print(" New limits: {:.3f} -> {:.3f}".format(new_lower_limit, new_upper_limit))
new_range = new_upper_limit - new_lower_limit
print("\trange: {:.3f}".format(new_range))
print("\tchange: {:.3f}".format(new_range/old_range))
if mp != 'rd':
base_param.set_var(mp+"_bins_info", "{} {} {}".format(new_lower_limit, new_upper_limit, old_values[2]))
else:
base_param.set_var(mp+"_bins_info", "{} {} {}".format(new_lower_limit/1000, new_upper_limit/1000, old_values[2]))
with open(input_param_fname.replace(".param", "_zoom.param"), 'w') as f:
f.write(str(base_param))
def plot_abundance_line(ax, param_fname):
param = dtk.Param(param_fname)
core_loc = param.get_string('core_loc')
expected_abundance = param.get_string('expected_abundance')
fname = "tmp_hdf5/{}/abundance={}.hdf5".format(core_loc,
expected_abundance)
print(fname)
def plot_1pt_distributions(param_file):
param = dtk.Param(param_file)
cluster_hfname = param.get_string("cluster_loc")
zmr_hfname = param.get_string("zmrh5_loc")
core_hfile = h5py.File(cluster_hfname, 'r')
zmr_hfile = h5py.File(zmr_hfname, 'r')
plot_cluster_mass(
core_hfile,
'/data/a/cpac/dkorytov/data/Ngal_sdss/data/normal_wmap7/query_results/query_results.hdf5'
)
plot_cluster_redshift(
0.24,
'/data/a/cpac/dkorytov/data/Ngal_sdss/data/normal_wmap7/query_results/query_results.hdf5'
)
plot_cluster_cores2(core_hfile, [
10,
10.5,
11,
11.5,
12,
12.5,
13.0,
13.5,
])
dtk.save_figs("figs/" + param_file + "/" + __file__ + "/")
plt.show()
def load_from_param(self,file_loc):
param = dtk.Param(file_loc)
self.z_bins = np.array(param.get_float_list("z_bins"))
self.m_bins = np.array(param.get_float_list("m_bins"))
self.r_bins = np.array(param.get_float_list("r_bins"))
self.zmr_gal_density = np.array(param.get_float_list("zmr_gal_density"))
self.zmr_gal_density_err = np.array(param.get_float_list("zmr_gal_density_err"))
def plot_mstar_background(param_fname):
param = dtk.Param(param_fname)
background_folder = param.get_string('background_folder')
galaxy_type = param.get_int('galaxy_type')
galaxy_weight = param.get_int('galaxy_weight')
background.set_gal_type_weight(galaxy_type, galaxy_weight)
background.set_gal_clr_type(param.get_int('galaxy_color_type'),
param.get_int_list('galaxy_mag_lim1'))
background.set_gal_mag_type(param.get_int('galaxy_mag_type'),
param.get_int_list('galaxy_mag_lim1'))
plt.figure()
labels = {
-1: '$>2.50 $L$_\star$',
-0.5: '$>1.58 $L$_\star$',
0: '$> 1.00 $L$_\star$',
0.5: '$> 0.63 $L$_\star$',
1: '$> 0.40 $L$_\star$',
}
for mstar_cut in [-1, -0.5, 0, 0.5, 1.0][::-1]:
background.set_mstar_cut(mstar_cut)
a, b = background.get_background_estimate_sqdeg(
background_folder, galaxy_type, galaxy_weight)
z_range = np.linspace(0.1, 0.35, 100)
plt.plot(z_range, a(z_range), label=labels[mstar_cut])
plt.yscale('log')
plt.xlabel('redshift')
plt.ylabel('background galaxy density [deg$^{-2}$]')
plt.legend(framealpha=0.0, labelspacing=0.0)
plt.tight_layout()
def calc_abundance_line(param_fname, plot=False):
param = dtk.Param(param_fname)
core_loc = param.get_string('core_loc')
rL = param.get_float('rL')
expected_comov_abundance = param.get_float('expected_comov_abundance')
step = param.get_int('step')
core_loc = core_loc.replace("${step}", str(step))
if "qcontinuum" in param:
qcontinuum = param.get_bool("qcontinuum")
else:
qcontinuum = False
cat = load_core_cat(core_loc.replace('${step}', str(step)))
expected_num = int(rL * rL * rL * expected_comov_abundance)
x = np.logspace(11, 12.6, 50)
y = np.zeros_like(x)
print("calculating radius")
cat = sort_cat(cat, 'radius')
for i in range(0, len(x)):
print("\t", i)
y[i] = calc_abundance_radius(cat, x[i], expected_num, presort=True)
if plot:
print('num/vol: ', expected_comov_abundance)
print('vol: ', rL * rL * rL)
print('expected_num:', expected_num)
print(x)
print(y)
plt.figure()
plt.plot(x, y, '-x')
plt.yscale('log')
plt.xscale('log')
y1 = np.logspace(-3, -.2, 25)
x1 = np.zeros_like(y1)
print("calculating infall")
cat = sort_cat(cat, 'infall_mass')
for i in range(0, len(x1)):
print("\t", i)
x1[i] = calc_abundance_infall_mass(cat,
y1[i],
expected_num,
presort=True)
if plot:
plt.plot(x1, y1, '-x')
print(x1)
print(y1)
abund_infall_mass = np.concatenate((x, x1))
abund_radius = np.concatenate((y, y1))
srt = np.argsort(abund_infall_mass)
slct = np.isfinite(abund_infall_mass[srt]) & np.isfinite(abund_radius[srt])
out_fname = 'tmp_hdf5/{}/abundance={}.hdf5'.format(
core_loc, expected_comov_abundance)
dtk.ensure_dir(out_fname)
print(out_fname)
hfile = h5py.File(out_fname, 'w')
hfile['abund_infall_mass'] = abund_infall_mass[srt][slct]
hfile['abund_radius'] = abund_radius[srt][slct]
hfile.close()
plt.show()
def get_cores(param_filename):
cat = {}
param = dtk.Param(param_filename)
cluster_loc = param.get_string("cluster_loc")
hfile = h5py.File(cluster_loc, 'r')
cat['radius'] = hfile['cores/core_r'].value
cat['mass'] = hfile['cores/core_m'].value
return cat
def load_zmr(param_fname):
param = dtk.Param(param_fname)
result_folder = param.get_string("result_folder")
fname = result_folder + "type1_weight1_mag1_clr1_result.hdf5"
print(fname)
zmr = h5py.File(fname, 'r')
return zmr
def get_survival_rate(param_fname, fit, mass_bins):
param = dtk.Param(param_fname)
cluster_loc = param.get_string('cluster_loc')
cluster_load_num = param.get_int('cluster_load_num')
cluster_data = load_clusters(cluster_loc)
# getting the Ngal with and without disruption
model_fit_fname = "figs/"+param_fname+"/calc_likelihood_bounds.py/grid_fit_param.txt"
model_fit = load_fit_limits(model_fit_fname)
return get_survival_rate_cluster(cluster_data, cluster_load_num, mass_bins, model_fit, )
def plot_core_abundance(param_fname):
param = dtk.Param(param_fname)
cores = load_cores(param.get_string("core_loc"), param.get_int("step"))
core_num = len(cores['infall_mass'])
h, xbins, ybins = np.histogram2d(np.log10(cores['infall_mass']),
np.log10(cores['radius']),
bins=128)
plt.figure()
plt.pcolor(xbins, ybins, h.T, cmap="Blues", norm=clr.LogNorm())
plt.ylabel("Log10 Core Radius")
plt.xlabel("Log10 Infall Mass")
h_sum = np.cumsum(h, axis=1)
# h_sum = h_sum[-1,:] - h_sum
# h_sum = h_sum.T
plt.figure()
plt.pcolor(xbins, ybins, h_sum.T, cmap="Blues", norm=clr.LogNorm())
plt.ylabel("Log10 Core Radius")
plt.xlabel("Log10 Infall Mass")
h_sum2 = np.cumsum(h_sum, axis=0)
h_sum2 = h_sum2[-1, :] - h_sum2
plt.figure()
plt.pcolor(xbins, ybins, h_sum2.T, cmap="Blues", norm=clr.LogNorm())
plt.contour(dtk.bins_avg(xbins), dtk.bins_avg(ybins), h_sum2.T)
plt.ylabel("Log10 Core Radius")
plt.xlabel("Log10 Infall Mass")
plt.figure()
plt.pcolor(xbins, ybins, h_sum2.T, cmap="Blues", norm=clr.LogNorm())
plt.contour(dtk.bins_avg(xbins),
dtk.bins_avg(ybins),
h_sum2.T / (500 * 500 * 500),
levels=[0.0010, 0.0015, 0.002])
plt.ylabel("Log10 Core Radius")
plt.xlabel("Log10 Infall Mass")
plt.figure()
percentiles = [10, 20, 30, 40, 50, 60, 70, 80, 90]
result1 = dtk.binned_percentile(np.log10(cores['infall_mass']),
np.log10(cores['radius']),
xbins,
percentiles,
minimum_number=100)
print(result1.shape)
plt.pcolor(xbins, ybins, h.T, cmap="Blues", norm=clr.LogNorm())
plt.colorbar(label='Population Density')
plt.plot(12.25, np.log10(0.05), "*", label='model fit')
for i, percentile in enumerate(percentiles):
plt.plot(dtk.bins_avg(xbins),
result1[:, i],
'-',
label="{}%".format(percentile))
plt.legend(loc='best', framealpha=0)
plt.show()
def get_clusters(param_fname, core_host_mass=False):
param = dtk.Param(param_fname)
cluster_loc = param.get_string('cluster_loc')
central = param.get_bool('force_central_as_galaxy')
if central:
print("It's compact central")
clusters = ClusterData()
clusters.load_file(cluster_loc,
treat_centrals=central,
step=401,
core_host_mass=core_host_mass)
return clusters, central
def miscenter_clusters(param_fname):
param = dtk.Param(param_fname)
sod_input = param.get_string('sod_input')
sod_output = param.get_string('sod_output')
step = param.get_int('step')
# re-scale from kpc to mpc
miscenter_mean = param.get_float('miscenter_mean')/1000
miscenter_width = param.get_float('miscenter_width')/1000
sod_input = sod_input.replace('${step}', str(step))
sod_output = sod_output.replace('${step}', str(step))
assert sod_input != sod_output, 'Output file cannot be the same as the input file'
cat = load_clusters(sod_input)
apply_miscentering_to_cluster(cat, miscenter_mean, miscenter_width)
save_clusters(sod_output, cat)
def load_param(self, file_loc):
print(file_loc)
if ".param" in file_loc:
param = dtk.Param(file_loc)
self.z_bins = np.array(param.get_float_list("z_bins"))
self.m_bins = np.array(param.get_float_list("m_bins"))
self.r_bins = np.array(param.get_float_list("r_bins"))
self.z_size = self.z_bins.size -1
self.m_size = self.m_bins.size -1
self.r_size = self.r_bins.size -1
zm_shape = (self.z_size,self.m_size)
zmr_shape = (self.z_size,self.m_size,self.r_size)
self.zm_Ngal = np.array(param.get_float_list("zm_Ngal")).reshape(zm_shape)
self.zm_Ngal_err = np.array(param.get_float_list("zm_Ngal_err")).reshape(zm_shape)
self.zm_Ngal_var = np.array(param.get_float_list("zm_Ngal_var")).reshape(zm_shape)
self.zmr_gal_counts = np.array(param.get_float_list("zmr_gal_counts")).reshape(zmr_shape)
self.zmr_gal_density = np.array(param.get_float_list("zmr_gal_density")).reshape(zmr_shape)
self.zmr_gal_density_err = np.array(param.get_float_list("zmr_gal_density_err")).reshape(zmr_shape)
self.zmr_gal_density_var = np.array(param.get_float_list("zmr_gal_density_var")).reshape(zmr_shape)
self.zmr_dgal_dr = np.array(param.get_float_list("zmr_dgal_dr")).reshape(zmr_shape)
self.zmr_dgal_dr_err = np.array(param.get_float_list("zmr_dgal_dr_err")).reshape(zmr_shape)
self.zmr_dgal_dr_var = np.array(param.get_float_list("zmr_dgal_dr_var")).reshape(zmr_shape)
self.zmr_gal_accum = np.array(param.get_float_list("zmr_gal_accum")).reshape(zmr_shape)
self.zmr_gal_accum_err = np.array(param.get_float_list("zmr_gal_accum_err")).reshape(zmr_shape)
self.zmr_gal_accum_var = np.array(param.get_float_list("zmr_gal_accum_var")).reshape(zmr_shape)
self.zm_counts = np.array(param.get_float_list("zm_counts")).reshape(zm_shape)
self.zmr_counts = np.array(param.get_float_list("zmr_counts")).reshape(zmr_shape)
elif ".hdf5" in file_loc:
hfile = h5py.File(file_loc, 'r')
print(hfile.keys())
self.z_bins = hfile['z_bins'].value
self.m_bins = hfile['m_bins'].value
self.r_bins = hfile['r_bins'].value
self.z_size = self.z_bins.size -1
self.m_size = self.m_bins.size -1
self.r_size = self.r_bins.size -1
self.zm_Ngal = hfile['zm_Ngal']
self.zm_Ngal_err = hfile['zm_Ngal_err']
self.zm_Ngal_var = hfile['zm_Ngal_var']
self.zmr_gal_density = hfile['zmr_gal_density']
self.zmr_gal_density_var = hfile['zmr_gal_density_var']
self.zmr_gal_density_err = hfile['zmr_gal_density_err']
self.zm_counts = hfile['zm_counts']
self.zmr_counts = hfile['zmr_counts']
else:
raise ValueError("{} doesn't have .param or .hdf5".format(file_loc))
def load_fit_limits(fname):
if fname in load_fit_limits.cache:
return load_fit_limits.cache[fname]
pfile = dtk.Param(fname)
result = {}
for p in ['mi', 'rd', 'rm']:
if p in pfile:
result[p] = pfile.get_float(p)
result[p + '_limits'] = np.array(
pfile.get_float_list(p + '_limits'))
result[p + '_lower_err'] = result[p] - result[p + '_limits'][0]
result[p + '_upper_err'] = result[p + '_limits'][1] - result[p]
if 'X_red' in pfile:
result['x2'] = pfile.get_float('X_red')
print(result['x2'])
else:
result['x2'] = np.nan
return result
def plot_luminosity_dependent_ngal_all(param_file, title=None):
param = dtk.Param(param_file)
sdss_zmr_loc = param.get_string('zmrh5_loc')
print(sdss_zmr_loc)
hfile = h5py.File(sdss_zmr_loc, 'r')
zmr_sdss = ZMR(file_loc="output/"+param_file+"/zmr_sdss.param")
if dtk.file_exists("output/"+param_file+"/zmr_lkhd_cores.param"):
fname = "output/"+param_file+"/zmr_lkhd_cores.param"
zmr_cores = ZMR(file_loc=fname)
print("likelihood zmrs")
else:
fname = "output/"+param_file+"/zmr_cores.param"
zmr_cores = ZMR(file_loc=fname)
print("fit zmrs")
mass_bins = zmr_cores.m_bins
mass_bins_centers = dtk.bins_avg(mass_bins)
zmr_Ngal = zmr_cores.zmr_gal_counts[0].sum(axis=1)/zmr_cores.zm_counts[0]
def compare_z_dep(param_fname):
param = dtk.Param(param_fname)
result_folder = param.get_string('result_folder')
hfile = h5py.File(result_folder + 'type1_weight1_mag1_clr1_result.hdf5',
'r')
zmr = hfile['zmr_gal_density'][()]
zmr_err = hfile['zmr_gal_density_err'][()]
zmr_cnt = hfile['zmr_counts'][()]
r_bins = hfile['r_bins'][()]
r_bins_cen = dtk.bins_avg(r_bins)
z_bins = hfile['z_bins'][()]
print(r_bins_cen)
shape = zmr.shape
for i in range(shape[1]):
if not np.isfinite(np.sum(zmr[0, i, :])):
continue
plt.figure()
for j in range(shape[0]):
plt.plot(r_bins_cen,
zmr[j, i, :],
label='{:.2f}<z<{:.2f}'.format(z_bins[j], z_bins[j + 1]))
plt.fill_between(r_bins_cen,
zmr[j, i, :] + zmr_err[j, i, :],
zmr[j, i, :] - zmr_err[j, i, :],
alpha=0.3)
print(np.sum(zmr_cnt[0, i, :]), np.sum(zmr_cnt[1, i, :]),
np.nanmean(np.sum(zmr_cnt[0, i, :]) / np.sum(zmr_cnt[1, i, :])))
print(zmr[0, i, :])
print(zmr[1, i, :])
print(np.nanmean(zmr[0, i, :] / zmr[1, i, :]))
print('\n')
plt.yscale('log')
plt.legend()
np.log10(np.nanmean(zmr[0, i, :] / zmr[1, i, :]))
plt.show()
def plot_saved_clusters(param_filename):
global n2merger
param = dtk.Param(param_filename)
cluster_loc = param.get_string("cluster_loc")
cluster_data = ClusterData()
# n2lib_loc = "lib/libn2merg.so"
# n2merger = N2Merger(n2lib_loc)
# core_loc = param.get_string('core_loc').replace("${step}", str(401)).replace("_500L", "")
fit_mi, fit_rd = get_fit_param(param_filename)
# fit_mi, fit_rd = 1e12, 1e3
print("Infall mass: {:.2e}\nR disrupt: {:.4f}".format(fit_mi, fit_rd))
# test_core_catalog(core_loc, 1)
cluster_data.load_file(cluster_loc)
for i in range(int(cluster_data.num)):
if cluster_data.mass[i] > 1e14:
# cluster_data.plot_fit_cluster(i, 12.2, 0.02)
# cluster_data.plot_cluster(i)
cluster_data.plot_fit_cluster(i, fit_mi, fit_rd)
dtk.save_figs("figs/" + __file__ + "/" + param_filename + "/",
extension=".png")
plt.show()
plt.close('all')
def test_saved_clusters(param_filename):
param = dtk.Param(param_filename)
cluster_loc = param.get_string('cluster_loc')
sod_loc = param.get_string("sod_loc")
sod_hdf5 = param.get_string("sod_hdf5")
sod_data_raw = SODData()
sod_data_saved = SODData()
sod_data_saved.load_sod(
'/media/luna1/dkorytov/data/OuterRim/sod_200m/sod_m200m.401.test1.hdf5',
True)
saved_cluster = ClusterData()
saved_cluster.load_file('tmp_hdf5/clusters_OR_M200m.test1.hdf5')
# sod_data_raw.load_sod('/media/luna1/dkorytov/data/OuterRim/sod/m000.401.sodproperties', False)
plt.figure()
bins = np.logspace(12, 16, 32)
plt.title("Mass")
# plot_hist(sod_data_raw.mass, bins, label='sod_raw')
plot_hist(sod_data_saved.mass, bins, label='sod saved')
plot_hist(saved_cluster.mass, bins, label='saved cluster')
plt.yscale('log')
plt.xscale('log')
plt.xlabel('m200')
plt.legend(loc='best')
plt.figure()
bins = np.linspace(0, 5, 64)
plt.title("radius")
# plot_hist(sod_data_raw.rad, bins, label='sod_raw')
plot_hist(sod_data_saved.rad, bins, label='sod saved')
plot_hist(saved_cluster.rad, bins, label='saved cluster')
plt.yscale('log')
plt.xlabel('r200')
plt.legend(loc='best')
plt.show()
#!/usr/bin/env python2.7
import matplotlib
#matplotlib.use('Agg')
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as clrs
import sys
import dtk
param = dtk.Param(sys.argv[1])
fof_loc = param.get_string("fof_loc")
sod_loc = param.get_string("sod_loc")
core_loc = param.get_string("core_loc")
gal_loc = param.get_string("gal_loc")
hp_loc = param.get_string("hp_loc")
mt_loc = param.get_string("mt_loc")
steps = param.get_int_list("steps")
core_intacted_radius = param.get_float("core_intact_radius")
fof_cat = dtk.Catalog(fof_loc)
sod_cat = dtk.Catalog(sod_loc)
core_cat = dtk.Catalog(core_loc)
hp_cat = dtk.Catalog(hp_loc)
gal_cat = dtk.Catalog(gal_loc)
mt_cat = dtk.Catalog(mt_loc)
gal_mt_cat = dtk.Catalog()
step = steps[0]
fof_cat.add_steps(steps)
sod_cat.add_steps(steps)
def calc_likelihood_bounds(param_file_name):
param = dtk.Param(param_file_name)
expected_comov_abundance = param.get_float('expected_comov_abundance')
core_loc = param.get_string('core_loc')
step = param.get_int('step')
core_loc = core_loc.replace("${step}", str(step))
lgrid_param = dtk.Param("output/" + param_file_name + "/lgrid.param")
has_rm = param.get_bool("fit_r_merger")
has_rd = param.get_float_list("rd_bins_info")[2] > 2
result = np.array(lgrid_param.get_double_list("result"))
hfile_fit = h5py.File("output/" + param_file_name +
"/fit_core_params.hdf5")
nan_slct = np.isnan(result)
result[nan_slct] = np.ones(np.sum(nan_slct)) * 1000000
mi_bins = np.array(lgrid_param.get_float_list("mi_bins"))
rd_bins = np.array(lgrid_param.get_float_list("rd_bins")) * 1000
rm_bins = np.array(lgrid_param.get_float_list("rm_bins"))
result2 = result.reshape((mi_bins.size, rd_bins.size, rm_bins.size))
#print(np.min(result2), np.max(result2))
lkhd = np.exp(-(result2 - np.min(result2)))
lkhd_mi = np.sum(lkhd, axis=(1, 2))
lkhd_rd = np.sum(lkhd, axis=(0, 2))
lkhd_rm = np.sum(lkhd, axis=(0, 1))
# print(np.shape(lkhd_mi))
# lkhd_mi = renormalize(lkhd_mi, np.log10(mi_bins))
# lkhd_mi = renormalize(lkhd_rd, rd_bins)
# lkhd_mi = renormalize(lkhd_rm, rm_bins)
lkhd_mi_rd = np.sum(lkhd, axis=2)
lkhd_mi_rm = np.sum(lkhd, axis=1)
#print(np.shape(lkhd_mi))
max_lkhd = np.unravel_index(np.argmax(lkhd, axis=None), lkhd.shape)
fit_mi = hfile_fit['m_infall'][()][0]
fit_mi_bds_lwr, fit_mi_bds_upr, fit_lkhd_mi, fit_mi_bins = get_bounds_limits(
lkhd_mi,
np.log10(mi_bins),
np.log10(fit_mi),
fine_grain=5000,
fit_index=max_lkhd[0])
if has_rd:
fit_rd = hfile_fit['r_disrupt'][()][0]
fit_rd_bds_lwr, fit_rd_bds_upr, _, fit_rd_bins = get_bounds_limits(
lkhd_rd, rd_bins, fit_rd, fine_grain=5000, fit_index=max_lkhd[1])
if has_rm:
fit_rm = hfile_fit['r_merger'][()][0]
fit_rm_bds_lwr, fit_rm_bds_upr, _, fit_rm_bins = get_bounds_limits(
lkhd_rm, rm_bins, fit_rm, fine_grain=5000, fit_index=max_lkhd[2])
if has_rd and not has_rm:
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{disrupt}}$ [h$^{-1}$kpc]'
],
grid_dic={
'bins': [np.log10(mi_bins), rd_bins],
'lkhd': np.sum(lkhd, axis=2),
'cost': None
},
expected_comov_abundance=expected_comov_abundance,
core_loc=core_loc)
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{disrupt}}$ [h$^{-1}$kpc]'
],
grid_dic={
'bins': [np.log10(mi_bins), rd_bins],
'lkhd': np.sum(lkhd, axis=2),
'cost': np.sum(result2, axis=2)
},
expected_comov_abundance=expected_comov_abundance,
core_loc=core_loc)
# corner_plot([r'M$_{\mathrm{infall}}$', 'R$_{\mathrm{disrupt}}$'], mcmc_dic = {'mcmc_loc': "output/{}/mcmc.gio".format(param_file_name)})
# corner_plot([r'M$_{\mathrm{infall}}$', 'R$_{\mathrm{disrupt}}$'], grid_dic = {'bins': [np.log10(mi_bins), rd_bins], 'lkhd': np.sum(lkhd, axis=2), 'cost': None}, mcmc_dic = {'mcmc_loc': "output/{}/mcmc.gio".format(param_file_name)})
if has_rm and not has_rd:
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{merger}}$ [h$^{-1}$Mpc]'
],
grid_dic={
'bins': [np.log10(mi_bins), rm_bins],
'lkhd': np.sum(lkhd, axis=1),
'cost': None
},
expected_comov_abundance=expected_comov_abundance,
core_loc=core_loc)
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{merger}}$ [h$^{-1}$Mpc]'
],
grid_dic={
'bins': [np.log10(mi_bins), rm_bins],
'lkhd': np.sum(lkhd, axis=1),
'cost': np.sum(result2, axis=1)
},
expected_comov_abundance=expected_comov_abundance,
core_loc=core_loc)
if has_rm and has_rd:
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{disrupt}}$ [h$^{-1}$kpc]',
'R$_{\mathrm{merge}}$ [h$^{-1}$Mpc]',
],
grid_dic={
'bins': [np.log10(mi_bins), rd_bins, rm_bins],
'lkhd': lkhd,
'cost': None
},
expected_comov_abundance=expected_comov_abundance)
corner_plot(
[
r'log$_{10}$M$_{\mathrm{infall}}$/h$^{-1}$M$_\odot$',
'R$_{\mathrm{disrupt}}$ [h$^{-1}$kpc]',
'R$_{\mathrm{merge}}$ [h$^{-1}$Mpc]',
],
grid_dic={
'bins': [np.log10(mi_bins), rd_bins, rm_bins],
'lkhd': lkhd,
'cost': result2
},
expected_comov_abundance=expected_comov_abundance)
#corner_plot([r'M$_{\mathrm{infall}}$', 'R$_{\mathrm{disrupt}}$', 'R$_{\mathrm{merge}}$', ], [np.log10(mi_bins), rd_bins, rm_bins], lkhd, cost = result2)
if not has_rm and not has_rd:
# plot_1d_likelihood("M$_{infall}$", mi_bins, lkhd_mi, fit_mi, mi_bds, log=True);
plot_1d_likelihood("M$_{infall}$ [h$^{-1}$M$_\odot$]",
fit_mi_bins,
fit_lkhd_mi,
fit_mi, [fit_mi_bds_lwr, fit_mi_bds_upr],
log=False)
# corner_plot([r'M$_{\mathrm{infall}}$'], grid_dic = {'bins':[np.log10(mi_bins)]]
grid_fit_fname = "figs/" + param_file_name + "/" + __file__ + "/grid_fit_param.txt"
dtk.ensure_dir(grid_fit_fname)
txt_file = open(grid_fit_fname, 'w')
txt_file.write("mi\t{}\n".format(np.log10(mi_bins[np.argmax(lkhd_mi)])))
txt_file.write("mi_limits\t{}\t{}\n".format(fit_mi_bins[fit_mi_bds_lwr],
fit_mi_bins[fit_mi_bds_upr]))
param_num = 1
if has_rd:
txt_file.write("rd\t{}\n".format(rd_bins[np.argmax(lkhd_rd)]))
txt_file.write("rd_limits\t{}\t{}\n".format(
fit_rd_bins[fit_rd_bds_lwr], fit_rd_bins[fit_rd_bds_upr]))
param_num += 1
if has_rm:
txt_file.write("rm\t{}\n".format(rm_bins[np.argmax(lkhd_rm)]))
# txt_file.write("rm\t{}\n".format(fit_rm))#rm_bins[np.argmax(lkhd_rm)]))
txt_file.write("rm_limits\t{}\t{}\n".format(
fit_rm_bins[fit_rm_bds_lwr], fit_rm_bins[fit_rm_bds_upr]))
param_num += 1
txt_file.write("cost\t{}\n".format(np.min(result2)))
dof = (
5 *
15) - param_num #Five mass bins w/ halos. Each halo has 15 radial bins
txt_file.write("X_red\t{}\n".format(np.min(result2) / dof))
def query(param_fname):
param = dtk.Param(param_fname)
query_data_folder = param.get_string("query_data_folder")
cluster_size_max = param.get_bool("cluster_size_max")
cluster_size = param.get_int("cluster_size")
cluster_start = param.get_int("cluster_start")
random_size_max = param.get_bool("random_size_max")
random_size = param.get_int("random_size")
random_start = param.get_int("random_start")
query_galaxy_only = param.get_bool("query_galaxy_only")
r200_factor = param.get_float("r200_factor")
cosmology_name = param.get_string("cosmology_name")
if "richness_mass_author" in param:
richness_mass_author = param.get_string("richness_mass_author")
else:
richness_mass_author = "Rykoff_crit"
if "mass_type" in param:
mass_type = param.get_string("mass_type")
assert (mass_type in ['critical', 'crit', 'mean']), "Mass type ("+mass_type+") not understood"
else:
mass_type = "critical"
if "cluster_use_random_positions" in param:
cluster_use_random_positions = param.get_bool("cluster_use_random_positions")
else:
cluster_use_random_positions = False
if "query_random" in param:
query_random = param.get_bool("query_random")
else:
query_random = True
if "query_cluster" in param:
query_cluster = param.get_bool("query_cluster")
else:
query_cluster = True
if "spider_clusters" in param:
spider_clusters = param.get_bool("spider_clusters")
else:
spider_clusters = False
if "spider_mean" in param:
spider_mean = param.get_bool("spider_mean")
else:
spider_mean = False
if "spider_bcg_center" in param:
spider_bcg_center = param.get_bool("spider_bcg_center")
else:
spider_bcg_center = False
if "spider_mass_from_richness" in param:
spider_mass_from_richness = param.get_bool("spider_mass_from_richness")
else:
spider_mass_from_richness = False
cosmo = background.set_cosmology(cosmology_name)
dtk.ensure_dir(query_data_folder)
if query_random:
print("Querying random fields...")
rand_cat = load_redmapper_randoms_fits("redmapper_dr8_public_v6.3_randoms.fits")
if(random_size_max):
random_size = cat['ra'].size
query_sdss_culster(query_data_folder, rand_cat['ra'],
rand_cat['dec'], rand_cat['z'],
rand_cat['lambda'], "rnd", random_size,
start=random_start, plot=False,
query_galaxy_only=query_galaxy_only,
r200_factor=r200_factor,
richness_mass_author=richness_mass_author)
else:
print ("Not quering random fields...")
if query_cluster:
print( "Querying redmapper clusters...")
print(spider_clusters)
if not spider_clusters:
cluster_cat = load_redmapper_cluster_fits("redmapper_dr8_public_v6.3_catalog.fits")
spider_rad = None
else:
cluster_cat = load_spider_fits("/media/luna1/dkorytov/data/spider_xray/catCluster-SPIDERS_RASS_CLUS-v2.0.fits")
if spider_bcg_center:
spider_bcg_center = load_spiders_bcg_fits("./SpidersXclusterBCGs-v2.0.fits")
cluster_cat = combine_spiders_bcg(cluster_cat, spider_bcg_center)
cluster_cat['ra'] = cluster_cat['ra_bcg']
cluster_cat['dec'] = cluster_cat['dec_bcg']
if spider_mass_from_richness:
spider_rad = None # use the default richness -> mass conversion.
print("spider mass from richness")
else:
spider_rad = cluster_cat['r200c_deg']
if(cluster_size_max):
cluster_size = cluster_cat['ra'].size
if(cluster_use_random_positions ):
raise
cluster_cat['ra'][:cluster_size] = rand_cat['ra'][:cluster_size]
cluster_cat['dec'][:cluster_size] = rand_cat['dec'][:cluster_size]
# query_cat(cat,
query_sdss_culster(query_data_folder, cluster_cat['ra'],
cluster_cat['dec'], cluster_cat['z'],
cluster_cat['lambda'], "gal", cluster_size,
start=cluster_start, plot=False,
spider_rad=spider_rad,
spider_mean=spider_mean,
r200_factor=r200_factor,
richness_mass_author=richness_mass_author,
)
else:
print("Not querying redmapper clusters...")
def get_ngal_fit(param_fname,
cluster_num,
color,
plot_fit=True,
spider=False,
manual_calc=False):
param = dtk.Param(param_fname)
cluster_loc = param.get_string('cluster_loc')
if cluster_num is None:
cluster_num = param.get_int('cluster_load_num')
zmrh5_loc = param.get_string('zmrh5_loc')
zmr_sdss = ZMR(zmrh5_loc)
zmr_fit = ZMR("output/" + param_fname + "/zmr_lkhd_cores.param")
m_bins = zmr_fit.m_bins
r_bins = zmr_fit.r_bins
zmr_core_ngal, zmr_core_ngal_err = zmr_fit.get_ngal(
) # only one z-bin, so we don't select it out
zmr_core_ngal = zmr_core_ngal[0]
zmr_core_ngal_err = zmr_core_ngal_err[0]
zmr_sdss_ngal, zmr_sdss_ngal_err = zmr_sdss.get_ngal()
zmr_sdss_ngal = zmr_sdss_ngal[0]
zmr_sdss_ngal_err = zmr_sdss_ngal_err[0]
if manual_calc:
model_fit_fname = "figs/" + param_fname + "/calc_likelihood_bounds.py/grid_fit_param.txt"
model_fit = load_fit_limits(model_fit_fname)
m_infall = 10**model_fit['mi']
if 'rd' in model_fit:
# print(model_fit['rd'])
r_disrupt = model_fit['rd'] / 1000.0 #convert to mpc/h from kpc/h
else:
r_disrupt = np.inf
# print("\ncalculating ngal for ", param_fname)
# print("\tmodel_fit_fname:", model_fit_fname)
# print("\tmodel params: {:.2e} {:.3f}".format(m_infall, r_disrupt))
print(cluster_loc)
cluster_data = load_clusters(cluster_loc)
if cluster_num == -1:
cluster_num = cluster_data.num
cluster_ngal = np.zeros(cluster_num)
cluster_m_i = np.zeros(cluster_num)
for i in range(0, cluster_num):
mass_index = cluster_data.get_cluster_mass_bin(i, m_bins)
cluster_m_i[i] = mass_index
cluster_ngal[i] = cluster_data.get_ngal(i, m_infall, r_disrupt)[1]
ngal_mean = np.zeros(len(m_bins) - 1)
ngal_err = np.zeros(len(m_bins) - 1)
ngal_std = np.zeros(len(m_bins) - 1)
for i in range(0, len(m_bins) - 1):
slct = cluster_m_i == i
ngal_mean[i] = np.mean(cluster_ngal[slct])
ngal_std[i] = np.std(cluster_ngal[slct])
ngal_err[i] = ngal_std[i] / np.sqrt(np.sum(slct))
# print("{:.2e}->{:.2e}: {}".format(m_bins[i], m_bins[i+1], np.sum(slct)))
plt.plot(dtk.bins_avg(m_bins),
ngal_mean,
'-x',
color=color,
label='Ngal recalc')
if plot_fit:
plt.plot(dtk.bins_avg(m_bins), zmr_core_ngal, '-', color=color)
plt.fill_between(dtk.bins_avg(m_bins),
zmr_core_ngal - zmr_core_ngal_err,
zmr_core_ngal + zmr_core_ngal_err,
color=color,
alpha=0.3)
offset_amount = 1.025
if spider:
markerfacecolor = 'None'
markeredgecolor = color
xaxis_offset = offset_amount
lw = 1
else:
markerfacecolor = color
markeredgecolor = 'None'
xaxis_offset = 1. / offset_amount
lw = 2
# remove problematic 2.5 L* low mass cluster in the spider sample
if "mstar-1" in param_fname and "spider" in param_fname:
print("SPIDERSS!: ", zmr_sdss_ngal)
zmr_sdss_ngal[zmr_sdss_ngal < 0.1] = np.nan
plt.errorbar(dtk.bins_avg(m_bins) * xaxis_offset,
zmr_sdss_ngal,
yerr=zmr_sdss_ngal_err,
fmt='o',
capsize=0,
lw=lw,
color=color,
markeredgecolor=markeredgecolor,
markerfacecolor=markerfacecolor)
# plt.fill_between(dtk.bins_avg(m_bins), ngal_mean-ngal_err, ngal_mean+ngal_err, color=color, alpha=0.3)
plt.yscale('log')
plt.xscale('log')
#!/usr/bin/env python2.7
import numpy as np
import matplotlib.pyplot as plt
import dtk
import sys
import myutil
import h5py
param1 = dtk.Param(sys.argv[1])
param2 = dtk.Param(sys.argv[2])
output1 = param1.get_string('output')
output_mod1 = output1.replace(".hdf5", "_mod.hdf5")
hfile1 = h5py.File(output_mod1, 'r')
output2 = myutil.get_output_loc(param2)
output_mod2 = output2.replace(".hdf5", "_mod.hdf5")
hfile2 = h5py.File(output_mod2, 'r')
match_list = []
mismatch_list = []
mismatch_val = []
only_1_list = []
only_2_list = []
def check_group(hgroup1, hgroup2):
hobjects1 = []
hobjects2 = []
hgroup1.visit(hobjects1.append)
for ch_id in ids:
slct = chain_id == ch_id
ssq.append(np.var(data[slct]))
chain_avg = np.mean(data[slct])
B += (chain_avg - global_avg)**2
W = np.mean(ssq)
B = n / (m - 1.0) * B
var = (n - 1.0) / n * W + 1.0 / n * B
R = np.sqrt(var / W)
return R
if (__name__ == '__main__'):
print "Gelman Ruben Test"
param_file_name = sys.argv[1]
param = dtk.Param(param_file_name)
file_loc = "output/" + param_file_name + "/mcmc.gio"
print "loading data"
mcmc_id = dtk.gio_read(file_loc, "mcmc_walker_id")
mcmc_step = dtk.gio_read(file_loc, "mcmc_walker_step")
mcmc_mi = dtk.gio_read(file_loc, "mcmc_mass_infall")
mcmc_rd = dtk.gio_read(file_loc, "mcmc_r_disrupt")
print "data loaded"
slct_half = mcmc_step > np.max(mcmc_step) / 2.0
print "M_infall: ", gelman_ruben_test(mcmc_mi[slct_half],
mcmc_id[slct_half])
print "R_dispupt: ", gelman_ruben_test(mcmc_rd[slct_half],
mcmc_id[slct_half])
if (param.get_bool("fit_r_merger")):
mcmc_rm = dtk.gio_read(file_loc, "mcmc_r_merger")
#!/usr/bin/env python2.7
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as clrs
import dtk
params = dtk.Param("mcmc/test.param")
m_i = np.array(params.get_float_list("m_i"))
r_d = np.array(params.get_float_list("r_d"))
r_f = np.array(params.get_float_list("r_f"))
r_m = np.array(params.get_float_list("r_m"))
print min(m_i), max(m_i)
print min(r_d), max(r_d)
plt.figure()
plt.plot(m_i, r_d, '.', alpha=.3)
plt.yscale('log')
plt.xscale('log')
plt.xlabel('m_infall')
plt.ylabel('r_disrupt')
plt.grid()
plt.figure()
H, x_bins, y_bins = np.histogram2d(m_i,
r_d,
bins=(np.logspace(10, 12, 100),
np.logspace(-2, -1, 100)))
print H
plt.pcolor(x_bins, y_bins, H.T, cmap='PuBu', norm=clrs.LogNorm())
def query_mask(param_fname):
global num_pass
global num_fail
param = dtk.Param(param_fname)
query_data_folder = param.get_string("query_data_folder")
cosmology_name = param.get_string("cosmology_name")
cluster_size_max = param.get_bool("cluster_size_max")
cluster_size = param.get_int("cluster_size")
cluster_start = param.get_int("cluster_start")
random_size_max = param.get_bool("random_size_max")
random_size = param.get_int("random_size")
random_start = param.get_int("random_start")
query_galaxy_only = param.get_bool("query_galaxy_only")
r200_factor = param.get_float("r200_factor")
if "richness_mass_author" in param:
richness_mass_author = param.get_string("richness_mass_author")
else:
richness_mass_author = "Rykoff"
print "Richness mass author: ", richness_mass_author
if "clusters_query" in param:
clusters_query = param.get_bool("clusters_query")
else:
clusters_query = True
if "randoms_query" in param:
randoms_query = param.get_bool("randoms_query")
else:
randoms_query = True
if "spider_clusters" in param:
spider_clusters = param.get_bool("spider_clusters")
else:
spider_clusters = False
if "spider_mean" in param:
spider_mean = param.get_bool("spider_mean")
else:
spider_mean = False
if "spider_bcg_center" in param:
spider_bcg_center = param.get_bool("spider_bcg_center")
else:
spider_bcg_center = False
if "spider_mass_from_richness" in param:
spider_mass_from_richness = param.get_bool("spider_mass_from_richness")
else:
spider_mass_from_richness = False
dtk.ensure_dir(query_data_folder)
background.set_cosmology(cosmology_name)
num_pass = 0
num_fail = 0
if clusters_query:
print "Querying redmapper clusters..."
if not spider_clusters:
cluster_cat = load_redmapper_cluster_fits(
"redmapper_dr8_public_v6.3_catalog.fits")
spider_rad = None
else:
cluster_cat = load_spider_fits(
"/media/luna1/dkorytov/data/spider_xray/catCluster-SPIDERS_RASS_CLUS-v2.0.fits"
)
if spider_bcg_center:
print "spider bcg center"
spider_bcg_center = load_spiders_bcg_fits(
"./SpidersXclusterBCGs-v2.0.fits")
cluster_cat = combine_spiders_bcg(cluster_cat,
spider_bcg_center)
cluster_cat['ra'] = cluster_cat['ra_bcg']
cluster_cat['dec'] = cluster_cat['dec_bcg']
if spider_mass_from_richness:
spider_rad = None # use the default richness -> mass conversion.
print "spider mass from richness"
else:
spider_rad = cluster_cat['r200c_deg']
if (cluster_size_max):
cluster_size = cluster_cat['ra'].size
query_sdss_mask(query_data_folder,
cluster_cat['ra'],
cluster_cat['dec'],
cluster_cat['z'],
cluster_cat['lambda'],
"gal",
cluster_size,
r200_factor=r200_factor,
start=cluster_start,
plot=False,
save_data=True,
spider_rad=spider_rad,
richness_mass_author=richness_mass_author)
if randoms_query:
print "Querying random fields..."
rand_cat = load_redmapper_randoms_fits(
"redmapper_dr8_public_v6.3_randoms.fits")
if (random_size_max):
random_size = rand_cat['ra'].size
query_sdss_mask(query_data_folder,
rand_cat['ra'],
rand_cat['dec'],
rand_cat['z'],
rand_cat['lambda'],
"rnd",
random_size,
r200_factor=r200_factor,
start=random_start,
plot=False,
save_data=True,
richness_mass_author=richness_mass_author)
#!/usr/bin/env python2.7
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as clr
import sys
import dtk
param_file_name = sys.argv[1]
i = 0
dtk.set_fig_path("figs/" + param_file_name + "/" + __file__ + "/")
while (True):
param = dtk.Param("output/" + param_file_name + "/" + __file__ +
"/lgrid.param")
# if(sys.argv[1] == 'cpp'):
# param = dtk.Param("tmp/clstr%d.param"%i)
# elif(sys.argv[1] == 'py'):
# param = dtk.Param("tmp/clstr%d_py.param"%i)
# else:
# print "no \"cpp\"/\"py\" argument afterwards. Quitting"
halo_x = param.get_float("halo_x")
halo_y = param.get_float("halo_y")
halo_m = param.get_float("halo_mass")
halo_r = param.get_float("halo_radius")
core_x = np.array(param.get_float_list("core_x"))
core_y = np.array(param.get_float_list("core_y"))
core_r = np.array(param.get_float_list("core_r"))
core_m = np.array(param.get_float_list("core_m"))
print np.min(core_r), "->", np.max(core_r)
#!/usr/bin/env python2.7
import numpy as np
import matplotlib.pyplot as plt
import dtk
param = dtk.Param("tmp/fof_test.param")
x = np.array(param.get_float_list("x"))
y = np.array(param.get_float_list("y"))
z = np.array(param.get_float_list("z"))
c = np.array(param.get_int_list("c"))
clrs = np.unique(c)
print clrs.size, '/', c.size
plt.figure()
plt.scatter(x, y, c=c, edgecolor='none')
plt.xlim((0, 5))
plt.ylim((0, 5))
plt.grid()
plt.show()
def plot_saved_clusters(param_fname):
param = dtk.Param(param_fname)
query_data_file = param.get_string(
'query_data_folder') + 'query_results.hdf5'
mstar_offset = param.get_int('mstar_cut_offset')
query_results = param.get_string("query_data_folder")
query_cluster_all = param.get_bool('query_cluster_all')
query_cluster_num = param.get_int('query_cluster_num')
query_type = param.get_string('query_type')
cosmology_name = param.get_string("cosmology_name")
galaxy_type = param.get_int("galaxy_type")
galaxy_weight = param.get_int("galaxy_weight")
galaxy_color_type = param.get_int("galaxy_color_type")
galaxy_mag_type = param.get_int("galaxy_mag_type")
galaxy_color_lim = param.get_float_list("galaxy_color_lim%d" %
galaxy_color_type)
galaxy_mag_lim = param.get_float_list("galaxy_mag_lim%d" % galaxy_mag_type)
background_folder = param.get_string("background_folder")
background_force = param.get_bool("background_force")
background_all = param.get_bool("background_all")
background_num = param.get_int("background_num")
# z bins for background estimate
background_z_start = param.get_float('background_z_start')
background_z_end = param.get_float('background_z_end')
background_z_num = param.get_float('background_z_num')
# external data such as spt
spt_plot = param.get_bool("spt_plot")
spt_file = param.get_string("spt_file")
#params for the final cluster bining
z_bins_num = param.get_int("z_bins")
z_bins_start = param.get_float("z_bins_start")
z_bins_end = param.get_float("z_bins_end")
mass_bins_num = param.get_int("mass_bins")
mass_bins_start = param.get_float("mass_bins_start")
mass_bins_end = param.get_float("mass_bins_end")
radial_r200_rescale = param.get_bool('radial_r200_rescale')
radial_bin_num = param.get_int('radial_bin_num')
radial_bin_kpc_min = param.get_float('radial_bin_kpc_min')
radial_bin_kpc_max = param.get_float('radial_bin_kpc_max')
radial_bin_r200_min = param.get_float('radial_bin_r200_min')
radial_bin_r200_max = param.get_float('radial_bin_r200_max')
RS_line_plot = param.get_bool('RS_line_plot')
#params for saving the resulting profiles
result_folder = param.get_string("result_folder")
if ('mstar_cut_offset' in param.data.keys()):
mstar_cut_offset = param.get_float('mstar_cut_offset')
else:
mstar_cut_offset = 1.0
if 'background_r200_factor' in param:
background_r200_factor = param.get_float('background_r200_factor')
else:
background_r200_factor = 1.0
if 'richness_mass_author' in param:
richness_mass_author = param.get_string("richness_mass_author")
else:
richness_mass_author = None
if 'convert_m200m_to_m200c' in param:
convert_m200m_to_m200c = param.get_bool('convert_m200m_to_m200c')
else:
convert_m200m_to_m200c = False
if 'convert_m200c_to_m200m' in param:
convert_m200c_to_m200m = param.get_bool('convert_m200c_to_m200m')
else:
convert_m200c_to_m200m = False
#######################
## Processing Params ##
#######################
background_z_bins = np.linspace(background_z_start, background_z_end,
int(background_z_num))
if (galaxy_type == 1):
galaxy_type_name = "all"
elif (galaxy_type == 2):
galaxy_type_name = "red"
elif (galaxy_type == 3):
galaxy_type_name = "non-red"
else:
print("unknwon galaxy type")
raise
if (galaxy_weight == 1):
galaxy_weight_name = "normal"
elif (galaxy_weight == 2):
galaxy_weight_name = "red squence"
elif (galaxy_weight == 3):
galaxy_weight_name = 'red squence rykoff'
else:
print("unknown galaxy weight")
raise
if (galaxy_color_type == 1):
galaxy_color_name = 'g-r'
elif (galaxy_color_type == 2):
galaxy_color_name = 'g-r - RS(z)'
if (galaxy_mag_type == 1):
galaxy_mag_name = 'i'
elif (galaxy_mag_type == 2):
galaxy_mag_name = 'i-m*(z)'
background.set_gal_clr_type(galaxy_color_type, galaxy_color_lim)
background.set_gal_mag_type(galaxy_mag_type, galaxy_mag_lim)
background.set_gal_type_weight(galaxy_type, galaxy_weight)
background.set_cosmology(cosmology_name)
background.set_mstar_cut(mstar_cut_offset)
background.set_mstar_cut(param.get_float('mstar_cut_offset'))
[dataclstr, datagal, data_pass_mask, clstr_num] = background.get_clstr(
query_type,
query_results,
100,
till_end=False,
# query_cluster_num,
# till_end=query_cluster_all,
richness_mass_author=richness_mass_author,
convert_m200c_to_m200m=convert_m200c_to_m200m,
convert_m200m_to_m200c=convert_m200m_to_m200c)
for i in range(0, 400):
print(list(dataclstr[i].keys()))
print(list(datagal[i].keys()))
gal_prop = dataclstr[i]
gal = datagal[i]
rad = float(gal_prop['r200_arcmin']) / 60
dec = float(gal_prop['dec'])
ra = float(gal_prop['ra'])
mass = float(gal_prop['m200'])
z = float(gal_prop['z'])
if dec > 10 or mass < 2e14 or z > 0.35:
continue
plt.figure()
print(ra, dec, rad)
# c1 = plt.Circle((ra, dec), rad, fill=True, color='r', lw=2)
e_r200 = matplotlib.patches.Ellipse((ra, dec),
rad / np.cos(dec / 360) * 2.0,
rad * 2.0,
fill=False,
color='k',
lw=2)
plt.gca().add_artist(e_r200)
# plotting radial bins
for j in range(0, 16):
rad_bin = float(j) / 16 * rad
e_bin = matplotlib.patches.Ellipse(
(ra, dec),
rad_bin / np.cos(dec / 360) * 2.0,
rad_bin * 2.0,
fill=False,
color='k',
lw=1,
ls='--')
plt.gca().add_artist(e_bin)
plt.ylabel('Dec [deg]')
plt.xlabel('Ra [deg]')
plt.plot([], [], 'k', lw=2, label='$R_{200c}$')
plt.plot([], [], 'k', ls='--', label='radial bins')
## Galaxies
# bright saturated satur_center nopetro deblended_as_moving
cut_flgs = 0x0000000000000002 | 0x0000000000040000 | 0x0000080000000000 | 0x0000000000000100 | 0x0000000100000000
flgs = gal['flags_i'] | gal['flags_r'] | gal['flags_g']
slct1 = gal['type'] != 31
slct2 = np.logical_not(flgs & cut_flgs)
slct3 = gal['m_i'] < background.m_cut(z)
slct = slct1 & slct2 & slct3
plt.plot(gal['ra'][slct],
gal['dec'][slct],
'.',
alpha=0.6,
label='galaxies')
plt.text(
0.05,
0.05,
'M$_{{200c}}$=\n{:2.2e}[$h^{{-1}}$M$_{{\odot}}$]'.format(mass),
transform=plt.gca().transAxes,
verticalalignment='bottom',
horizontalalignment='left')
plt.text(0.95,
0.05,
'z={:.2f}'.format(z),
transform=plt.gca().transAxes,
verticalalignment='bottom',
horizontalalignment='right')
plt.legend(framealpha=0.0, labelspacing=0)
plt.axis('equal')
pyplot_zoom_out(top=0.2, right=-0.5, left=0.3)
plt.tight_layout()
dtk.save_figs('figs/' + __file__ + '/', '.pdf')
plt.close('all')
