def resamp_img(band_id, sub_z, sub_ra, sub_dec): ii = np.int(band_id) zn = len(sub_z) for k in range(zn): ra_g = sub_ra[k] dec_g = sub_dec[k] z_g = sub_z[k] Da_g = Test_model.angular_diameter_distance(z_g).value try: #data = fits.getdata(load + 'random_cat/mask_img/random_mask_%s_ra%.3f_dec%.3f_z%.3f.fits' % (band[ii], ra_g, dec_g, z_g), header = True) data = fits.getdata(load + 'random_cat/mask_no_dust/random_mask_%s_ra%.3f_dec%.3f_z%.3f.fits' % (band[ii], ra_g, dec_g, z_g), header = True) img = data[0] cx0 = data[1]['CRPIX1'] cy0 = data[1]['CRPIX2'] RA0 = data[1]['CRVAL1'] DEC0 = data[1]['CRVAL2'] wcs = awc.WCS(data[1]) cx, cy = wcs.all_world2pix(ra_g*U.deg, dec_g*U.deg, 1) Angur = (R0 * rad2asec / Da_g) Rp = Angur / pixel L_ref = Da_ref * pixel / rad2asec L_z0 = Da_g * pixel / rad2asec b = L_ref / L_z0 f_goal = flux_recal(img, z_g, z_ref) ix0 = np.int(cx0 / b) iy0 = np.int(cy0 / b) if b > 1: resam, xn, yn = sum_samp(b, b, f_goal, cx, cy) else: resam, xn, yn = down_samp(b, b, f_goal, cx, cy) xn = np.int(xn) yn = np.int(yn) x0 = resam.shape[1] y0 = resam.shape[0] keys = ['SIMPLE','BITPIX','NAXIS','NAXIS1','NAXIS2','CRPIX1','CRPIX2','CENTER_X','CENTER_Y', 'CRVAL1','CRVAL2','CENTER_RA','CENTER_DEC','ORIGN_Z', 'P_SCALE'] value = ['T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g, pixel] ff = dict(zip(keys,value)) fil = fits.Header(ff) #fits.writeto(load + 'random_cat/resample_img/rand-resamp-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % # (band[ii], ra_g, dec_g, z_g), resam, header = fil, overwrite = True) fits.writeto(load + 'random_cat/resamp_no_dust/rand-resamp-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[ii], ra_g, dec_g, z_g), resam, header = fil, overwrite = True) except FileNotFoundError: continue return
def spec_resamp_B(band_id, z_set, ra_set, dec_set):
ii = np.int(band_id)
zn = len(z_set)
print('Now band is %s' % band[ii])
for k in range(zn):
ra_g, dec_g, z_g = ra_set[k], dec_set[k], z_set[k]
Da_g = Test_model.angular_diameter_distance(z_g).value
# use star catalog dr12
data_B = fits.getdata(load +
'mask_data/B_plane/1.5sigma/B_mask_data_%s_ra%.3f_dec%.3f_z%.3f.fits'%(band[ii], ra_g, dec_g, z_g), header = True)
img_B = data_B[0]
head_mean = data_B[1]
cx0 = data_B[1]['CRPIX1']
cy0 = data_B[1]['CRPIX2']
RA0 = data_B[1]['CRVAL1']
DEC0 = data_B[1]['CRVAL2']
wcs = awc.WCS(data_B[1])
cx, cy = wcs.all_world2pix(ra_g*U.deg, dec_g*U.deg, 1)
Angur = (R0 * rad2asec/Da_g)
Rp = Angur/pixel
L_ref = Da_ref * pixel / rad2asec
L_z0 = Da_g*pixel/rad2asec
b = L_ref/L_z0
Rref = (R0*rad2asec/Da_ref)/pixel
f_goal = flux_recal(img_B, z_g, z_ref)
ix0 = np.int(cx0/b)
iy0 = np.int(cy0/b)
if b > 1:
resam, xn, yn = sum_samp(b, b, f_goal, cx, cy)
else:
resam, xn, yn = down_samp(b, b, f_goal, cx, cy)
xn = np.int(xn)
yn = np.int(yn)
x0 = resam.shape[1]
y0 = resam.shape[0]
keys = ['SIMPLE','BITPIX','NAXIS','NAXIS1','NAXIS2','CRPIX1','CRPIX2','CENTER_X','CENTER_Y',
'CRVAL1','CRVAL2','CENTER_RA','CENTER_DEC','ORIGN_Z', 'P_SCALE']
value = ['T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g, pixel]
ff = dict(zip(keys,value))
fil = fits.Header(ff)
fits.writeto(load +
'resample/resam_B/frameB-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[ii], ra_g, dec_g, z_g), resam, header = fil, overwrite=True)
return
def photo_sky_resamp(band_id, sub_z, sub_ra, sub_dec): ii = np.int(band_id) zn = len(sub_z) for k in range(zn): ra_g = sub_ra[k] dec_g = sub_dec[k] z_g = sub_z[k] Da_g = Test_model.angular_diameter_distance(z_g).value try: data = fits.open(load + 'photo_z/sky/sky_img/sky-ra%.3f-dec%.3f-z%.3f-%s-band.fits' % (ra_g, dec_g, z_g, band[ii]) ) img = data[0].data head = data[0].header cx0 = data[0].header['CRPIX1'] cy0 = data[0].header['CRPIX2'] RA0 = data[0].header['CRVAL1'] DEC0 = data[0].header['CRVAL2'] wcs = awc.WCS(head) cx, cy = wcs.all_world2pix(ra_g*U.deg, dec_g*U.deg, 1) Angur = rad2asec / Da_g Rp = Angur / pixel L_ref = Da_ref * pixel / rad2asec L_z0 = Da_g * pixel / rad2asec b = L_ref / L_z0 ix0 = np.int(cx0 / b) iy0 = np.int(cy0 / b) if b > 1: resam, xn, yn = sum_samp(b, b, img, cx, cy) else: resam, xn, yn = down_samp(b, b, img, cx, cy) xn = np.int(xn) yn = np.int(yn) x0 = resam.shape[1] y0 = resam.shape[0] keys = ['SIMPLE','BITPIX','NAXIS','NAXIS1','NAXIS2','CRPIX1','CRPIX2','CENTER_X','CENTER_Y', 'CRVAL1','CRVAL2','CENTER_RA','CENTER_DEC','ORIGN_Z', 'P_SCALE'] value = ['T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g, pixel] ff = dict(zip(keys,value)) fil = fits.Header(ff) fits.writeto(load + 'photo_z/sky/sky_resam_img/resampl_sky-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[ii], ra_g, dec_g, z_g), resam, header = fil, overwrite = True) except FileNotFoundError: continue
def mock_resamp(band_id, sub_z, sub_ra, sub_dec): kk = np.int(band_id) zn = len(sub_z) for k in range(zn): ra_g = sub_ra[k] dec_g = sub_dec[k] z_g = sub_z[k] Da_g = Test_model.angular_diameter_distance(z_g).value data = fits.open( load + 'mock_ccd/mock_frame/mock-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[kk], ra_g, dec_g, z_g) ) img = data[0].data cx0, cy0 = data[0].header['CRPIX1'], data[0].header['CRPIX2'] RA0, DEC0 = data[0].header['CRVAL1'], data[0].header['CRVAL2'] cx, cy = data[0].header['CENTER_X'], data[0].header['CENTER_Y'] ref_d = fits.open( d_file + 'frame-%s-ra%.3f-dec%.3f-redshift%.3f.fits.bz2' % (band[kk], ra_g, dec_g, z_g) ) NMGY = ref_d[0].header['NMGY'] img = img * NMGY # so the resample image have change DN to nmaggy L_ref = Da_ref * pixel / rad2asec L_z0 = Da_g * pixel / rad2asec b = L_ref / L_z0 f_goal = flux_recal(img, z_g, z_ref) # scale all mock to z_ref ix0 = np.int(cx0 / b) iy0 = np.int(cy0 / b) if b > 1: resam, xn, yn = sum_samp(b, b, f_goal, cx, cy) else: resam, xn, yn = down_samp(b, b, f_goal, cx, cy) xn = np.int(xn) yn = np.int(yn) x0 = resam.shape[1] y0 = resam.shape[0] keys = ['SIMPLE','BITPIX','NAXIS','NAXIS1','NAXIS2','CRPIX1','CRPIX2','CENTER_X','CENTER_Y', 'CRVAL1','CRVAL2','CENTER_RA','CENTER_DEC','ORIGN_Z', 'P_SCALE'] value = ['T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g, pixel] ff = dict(zip(keys,value)) fil = fits.Header(ff) fits.writeto(load + 'mock_ccd/mock_resamp/mock_resam-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[kk], ra_g, dec_g, z_g), resam, header = fil, overwrite=True)
def resamp_test():
# SB profile measurement
NMGY = 5e-3 # mean value of the data sample
gain = 4.735 # for r band (mean value)
V_dark = 1.2 # for r band (mean value)
exp_time = 54 # exposure time, in unit second
bins, Nz = 65, len(set_z)
mock_flux = pds.read_csv(load + 'mock_flux_data_r_band.csv')
mock_SB = pds.read_csv(load + 'mock_SB_data_r_band.csv')
ins_SB = pds.read_csv(load + 'mock_intrinsic_SB_r_band.csv')
r = ins_SB['r']
INS_SB = ins_SB['0.250']
f_SB = interp.interp1d(r, INS_SB, kind = 'cubic')
R_t = np.zeros((Nz, bins), dtype = np.float)
SB_t = np.zeros((Nz, bins), dtype = np.float)
err_up = np.zeros((Nz, bins), dtype = np.float)
err_botm = np.zeros((Nz, bins), dtype = np.float)
R_s = np.zeros((Nz, bins), dtype = np.float)
SB_s = np.zeros((Nz, bins), dtype = np.float)
err_s_up = np.zeros((Nz, bins), dtype = np.float)
err_s_botm = np.zeros((Nz, bins), dtype = np.float)
R_smal, R_max = 10, 10**3.02
for k in range(Nz):
#data = fits.getdata(load + 'noise/noise_frame_z%.3f_ra%.3f_dec%.3f.fits' % (set_z[k], set_ra[k], set_dec[k]), header = True)
data = fits.getdata(load + 'noise_mask/add_mask_frame_z%.3f_ra%.3f_dec%.3f.fits' % (set_z[k], set_ra[k], set_dec[k]), header = True)
img = data[0]
Dag = Test_model.angular_diameter_distance(set_z[k]).value
Rp = (rad2asec / Dag) / pixel
cenx = data[1]['CENTER_X']
ceny = data[1]['CENTER_Y']
Len_ref = Da_ref * pixel / rad2asec
Len_z0 = Dag * pixel / rad2asec
eta = Len_ref/Len_z0
mu = 1 / eta
N_flux = img * NMGY
scale_img = flux_recal(N_flux, set_z[k], z_ref)
if eta > 1:
resamt, xn, yn = sum_samp(eta, eta, scale_img, cenx, ceny)
else:
resamt, xn, yn = down_samp(eta, eta, scale_img, cenx, ceny)
xn = np.int(xn)
yn = np.int(yn)
Nx = resamt.shape[1]
Ny = resamt.shape[0]
## PS : the flux saved in resample file is in unit "nmaggy", not DN (DN is for previous files)
keys = ['SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', 'CENTER_X', 'CENTER_Y', 'ORIGN_Z', 'P_SCALE']
value = ['T', 32, 2, Nx, Ny, xn, yn, set_z[k], pixel]
ff = dict(zip(keys,value))
fil = fits.Header(ff)
#fits.writeto(load + 'resamp/resamp-noise-ra%.3f-dec%.3f-redshift%.3f.fits' % (set_ra[k], set_dec[k], set_z[k]), resamt, header = fil, overwrite=True)
fits.writeto(load + 'resamp/resamp-mask-ra%.3f-dec%.3f-redshift%.3f.fits' % (set_ra[k], set_dec[k], set_z[k]), resamt, header = fil, overwrite=True)
Intns, Intns_r, Intns_err, Npix = light_measure(N_flux, bins, R_smal, R_max, cenx, ceny, pixel, set_z[k])
flux0 = Intns + Intns_err
flux1 = Intns - Intns_err
SB = 22.5 - 2.5 * np.log10(Intns) + 2.5 * np.log10(pixel**2)
SB = SB - 10 * np.log10( (1 + set_z[k]) / (1 + z_ref) )
SB0 = 22.5 - 2.5 * np.log10(flux0) + 2.5 * np.log10(pixel**2)
SB1 = 22.5 - 2.5 * np.log10(flux1) + 2.5 * np.log10(pixel**2)
err0 = SB - SB0
err1 = SB1 - SB
R_t[k, :], SB_t[k, :], err_up[k, :], err_botm[k, :] = Intns_r, SB, err0, err1
Intns, Intns_r, Intns_err, Npix = light_measure(resamt, bins, R_smal, R_max, xn, yn, pixel, z_ref)
flux0 = Intns + Intns_err
flux1 = Intns - Intns_err
SB = 22.5 - 2.5 * np.log10(Intns) + 2.5 * np.log10(pixel**2)
SB0 = 22.5 - 2.5 * np.log10(flux0) + 2.5 * np.log10(pixel**2)
SB1 = 22.5 - 2.5 * np.log10(flux1) + 2.5 * np.log10(pixel**2)
err0 = SB - SB0
err1 = SB1 - SB
R_s[k, :], SB_s[k, :], err_s_up[k, :], err_s_botm[k, :] = Intns_r, SB, err0, err1
plt.figure(figsize = (20, 24))
gs = gridspec.GridSpec(5, 4)
for k in range(Nz):
Dag = Test_model.angular_diameter_distance(set_z[k]).value
id_nan = np.isnan(SB_t[k,:])
ivx = id_nan == False
ss_R = R_t[k, ivx]
ss_SB = SB_t[k, ivx]
iux = ( ss_R > np.min(r) ) & ( ss_R < np.max(r) )
ddsb = ss_SB[iux] - f_SB( ss_R[iux] )
ddsr = ss_R[iux]
std = np.nanstd(ddsb)
aver = np.nanmean(ddsb)
err0 = err_up[k, ivx]
err1 = err_botm[k, ivx]
id_nan = np.isnan(err1)
err1[id_nan] = 100. # set a large value for show the break out errorbar
id_nan = np.isnan(SB_s[k,:])
ipx = id_nan == False
tt_R = R_s[k, ipx]
tt_SB = SB_s[k, ipx]
iqx = ( tt_R > np.min(r) ) & ( tt_R < np.max(r) )
ddtb = tt_SB[iqx] - f_SB( tt_R[iqx] )
ddtr = tt_R[iqx]
t_std = np.nanstd(ddtb)
t_aver = np.nanmean(ddtb)
t_err0 = err_s_up[k, ipx]
t_err1 = err_s_botm[k, ipx]
id_nan = np.isnan(t_err1)
t_err1[id_nan] = 100. # set a large value for show the break out errorbar
gs0 = gridspec.GridSpecFromSubplotSpec(5, 1, subplot_spec = gs[ k // 4, k % 4])
ax0 = plt.subplot(gs0[:4])
ax1 = plt.subplot(gs0[-1])
ax0.plot(r, INS_SB, 'r-', label = '$ Intrinsic $', alpha = 0.5)
ax0.errorbar(ss_R, ss_SB, yerr = [err0, err1], xerr = None, ls = '', fmt = 'b^', label = ' sky subtracted ', alpha = 0.5)
ax0.errorbar(tt_R, tt_SB, yerr = [t_err0, t_err1], xerr = None, ls = '', fmt = 'gs', label = ' sky subtracted + resampled ', alpha = 0.5)
ax0.set_xscale('log')
ax0.set_ylabel('$SB[mag/arcsec^2]$')
ax0.legend(loc = 1)
ax0.set_xlim(9, 1010)
ax0.set_ylim(19, 34)
ax0.invert_yaxis()
ax0.tick_params(axis = 'both', which = 'both', direction = 'in')
bx1 = ax0.twiny()
xtik = ax0.get_xticks()
xtik = np.array(xtik)
xR = xtik * 10**(-3) * rad2asec / Dag
bx1.set_xscale('log')
bx1.set_xticks(xtik)
bx1.set_xticklabels(['$%.2f^{ \prime \prime }$' % uu for uu in xR])
bx1.tick_params(axis = 'both', which = 'both', direction = 'in')
bx1.set_xlim(ax0.get_xlim())
ax0.set_xticks([])
ax1.plot(ddsr, ddsb, 'b-', alpha = 0.5)
ax1.axhline(y = 0, linestyle = '--', color = 'r', alpha = 0.5, label = '$ \Delta{SB} = 0 $')
#ax1.errorbar(ddsr, ddsb, yerr = [err0[iux], err1[iux]], xerr = None, ls = '', fmt = 'b^', alpha = 0.5)
ax1.plot(ddsr, ddsb, 'b-', alpha = 0.5)
ax1.axhline(y = aver, linestyle = '--', color = 'b', alpha = 0.5)
ax1.axhline(y = aver + std, linestyle = '--', color = 'b', alpha = 0.5)
ax1.axhline(y = aver - std, linestyle = '--', color = 'b', alpha = 0.5)
#ax1.errorbar(ddtr, ddtb, yerr = [t_err0[iqx], t_err1[iqx]], xerr = None, ls = '', fmt = 'gs', alpha = 0.5)
ax1.plot(ddtr, ddtb, 'g-', alpha = 0.5)
ax1.axhline(y = t_aver, linestyle = '--', color = 'g', alpha = 0.5)
ax1.axhline(y = t_aver + t_std, linestyle = '-.', color = 'g', alpha = 0.5)
ax1.axhline(y = t_aver - t_std, linestyle = '-.', color = 'g', alpha = 0.5)
ax1.set_xlim(9, 1010)
ax1.set_ylim(-1, 1)
ax1.set_xscale('log')
ax1.set_xlabel('$R[kpc]$')
ax1.set_ylabel('$ SB_{M} - SB_{I} $')
ax1.tick_params(axis = 'both', which = 'both', direction = 'in')
plt.tight_layout()
#plt.savefig('noise_resample_SB.pdf', dpi = 300)
plt.savefig('mask_resample_SB.pdf', dpi = 300)
plt.close()
raise
def resamp_func(d_file,
sub_z,
sub_ra,
sub_dec,
ra_set,
dec_set,
img_x,
img_y,
band,
out_file,
z_ref,
stack_info=None,
pixel=0.396,
id_dimm=False):
"""
d_file : path where save the masked data (include file-name structure:'/xxx/xxx/xxx.xxx')
ra_set, dec_set : ra, dec, z of will be resampled imgs
sub_z, sub_ra, sub_dec : BCG information
band : the band of imgs, 'str' type
out_file : path where to save the resampling img
pixel : pixel scale, in unit 'arcsec' (default is 0.396)
z_ref : reference redshift, the redshift to which all clusters will be scaled
id_dimm : if do cosmic dimming correction or not
img_x, img_y : satellite location on image frame before pixel resampling
"""
zn = len(ra_set)
sat_x, sat_y = [], []
for k in range(zn):
ra_g = ra_set[k]
dec_g = dec_set[k]
bcg_z, bcg_ra, bcg_dec = sub_z[k], sub_ra[k], sub_dec[k]
z_g = bcg_z + 0.
file = d_file % (band, bcg_ra, bcg_dec, bcg_z, ra_g, dec_g)
data = fits.open(file)
img = data[0].data
#. satellite (ra, dec)
RA0 = data[0].header['CRVAL1']
DEC0 = data[0].header['CRVAL2']
#. BCG (ra, dec)
BCG_RA = data[0].header['BCG_RA']
BCG_DEC = data[0].header['BCG_DEC']
#. read satellite position from catalog
# cx, cy = data[0].header['CENTER_X'], data[0].header['CENTER_Y']
cx, cy = img_x[k], img_y[k]
Da_g = Test_model.angular_diameter_distance(z_g).value
Dl_g = Test_model.luminosity_distance(z_g).value
Da_ref = Test_model.angular_diameter_distance(z_ref).value
Dl_ref = Test_model.luminosity_distance(z_ref).value
#. observation angle and flux factor at z_ref
pixel_ref = pixel * (Da_g / Da_ref)
eta_flux = Dl_g**2 / Dl_ref**2 #... flux change due to distance
eta_pix = pixel / pixel_ref
if id_dimm == True:
dimm_flux = flux_recal(img, z_g, z_ref)
pre_img = dimm_flux * eta_flux
else:
pre_img = img * 1.
if eta_pix > 1:
resam, xn, yn = sum_samp(eta_pix, eta_pix, pre_img, cx, cy)
else:
resam, xn, yn = down_samp(eta_pix, eta_pix, pre_img, cx, cy)
# cheng the data type
out_data = resam.astype('float32')
sat_x.append(xn)
sat_y.append(yn)
x0 = resam.shape[1]
y0 = resam.shape[0]
keys = [
'SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', 'CENTER_X',
'CENTER_Y', 'CRVAL1', 'CRVAL2', 'BCG_RA', 'BCG_DEC', 'ORIGN_Z',
'P_SCALE'
]
value = [
'T', 32, 2, x0, y0, xn, yn, RA0, DEC0, BCG_RA, BCG_DEC, z_g, pixel
]
ff = dict(zip(keys, value))
fill = fits.Header(ff)
fits.writeto(out_file % (band, bcg_ra, bcg_dec, bcg_z, ra_g, dec_g),
out_data,
header=fill,
overwrite=True)
sat_x = np.array(sat_x)
sat_y = np.array(sat_y)
if stack_info != None:
keys = [
'bcg_ra', 'bcg_dec', 'bcg_z', 'sat_ra', 'sat_dec', 'sat_x', 'sat_y'
]
values = [sub_ra, sub_dec, sub_z, ra_set, dec_set, sat_x, sat_y]
fill = dict(zip(keys, values))
data = pds.DataFrame(fill)
data.to_csv(stack_info)
return
def resample_test():
bins = 65
with h5py.File(load + 'mock_flux_data.h5') as f:
Lob = np.array(f['a'])
with h5py.File(load + 'mock_mag_data.h5') as f:
Iner_SB = np.array(f['a'])
with h5py.File(load + 'mock_intric_SB.h5') as f:
Lc = np.array(f['a'][0])
rbin = np.array(f['a'][1])
R0 = np.max(rbin)
Rpp = (rad2asec * 10**(-3) * R0 / Da_ref) / pixel
r_sc = rbin / np.max(rbin)
set_z = np.r_[set_z0[:10], set_z1[:10]]
set_ra = np.r_[ra_z0[:10], ra_z1[:10]]
set_dec = np.r_[dec_z0[:10], dec_z1[:10]]
a_ref = 1 / (1 + z_ref)
Lref = Lc * a_ref**4 / (4 * np.pi * rad2asec**2
) # L at z in unit: (Lsun/kpc^2)/arcsec^2
Lob_ref = Lref * Lsun / kpc2cm**2
SB_ref = 22.5 - 2.5 * np.log10(Lob_ref / (10**(-9) * f0))
f_SB = interp.interp1d(rbin, SB_ref)
Nz = len(set_z)
R_t = np.zeros((Nz, bins), dtype=np.float)
SB_t = np.zeros((Nz, bins), dtype=np.float)
err_t = np.zeros((Nz, bins), dtype=np.float)
R_01 = np.zeros((Nz, bins), dtype=np.float)
SB_01 = np.zeros((Nz, bins), dtype=np.float)
err_01 = np.zeros((Nz, bins), dtype=np.float)
for k in range(Nz):
data = fits.getdata(load + 'mock/mock_z%.3f_ra%.3f_dec%.3f.fits' %
(set_z[k], set_ra[k], set_dec[k]),
header=True)
#data = fits.getdata(load + 'noise/noise_frame_z%.3f_ra%.3f_dec%.3f.fits' % (set_z[k], set_ra[k], set_dec[k]), header = True)
#data = fits.getdata(load + 'noise_mask/add_mask_frame_z%.3f_ra%.3f_dec%.3f.fits' % (set_z[k], set_ra[k], set_dec[k]), header = True)
img = data[0]
Dag = Test_model.angular_diameter_distance(set_z[k]).value
Rp = (rad2asec * 10**(-3) * R0 / Dag) / pixel
cenx = data[1]['CENTER_X']
ceny = data[1]['CENTER_Y']
Len_ref = Da_ref * pixel / rad2asec
Len_z0 = Dag * pixel / rad2asec
eta = Len_ref / Len_z0
mu = 1 / eta
scale_img = flux_recal(
img, set_z[k], z_ref) # scale the flux to the reference redshift
if eta > 1:
resamt, xn, yn = sum_samp(eta, eta, scale_img, cenx, ceny)
else:
resamt, xn, yn = down_samp(eta, eta, scale_img, cenx, ceny)
xn = np.int(xn)
yn = np.int(yn)
Nx = resamt.shape[1]
Ny = resamt.shape[0]
keys = [
'SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', 'CENTER_X',
'CENTER_Y', 'ORIGN_Z', 'P_SCALE'
]
value = ['T', 32, 2, Nx, Ny, xn, yn, set_z[k], pixel]
ff = dict(zip(keys, value))
fil = fits.Header(ff)
fits.writeto(load + 'resamp-mock-ra%.3f-dec%.3f-redshift%.3f.fits' %
(set_ra[k], set_dec[k], set_z[k]),
resamt,
header=fil,
overwrite=True)
#fits.writeto(load + 'resamp-noise-ra%.3f-dec%.3f-redshift%.3f.fits' % (set_ra[k], set_dec[k], set_z[k]), resamt, header = fil, overwrite=True)
#fits.writeto(load + 'resamp-mask-ra%.3f-dec%.3f-redshift%.3f.fits' % (set_ra[k], set_dec[k], set_z[k]), resamt, header = fil, overwrite=True)
SBt, Rt, Art, errt = light_measure(resamt, bins, 1, Rpp, xn, yn, pixel,
z_ref)[:4]
SB_t[k, :] = SBt
R_t[k, :] = Rt
err_t[k, :] = errt
SB, R, Anr, err = light_measure(scale_img, bins, 1, Rp, cenx, ceny,
pixel * mu, z_ref)[:4]
SB_01[k, :] = SB
R_01[k, :] = R
err_01[k, :] = err
plt.figure(figsize=(20, 24))
gs = gridspec.GridSpec(5, 4)
for k in range(Nz):
Dag = Test_model.angular_diameter_distance(set_z[k]).value
id_nan = np.isnan(SB_t[k, :])
ivx = id_nan == False
ss_R = R_t[k, ivx]
ss_SB = SB_t[k, ivx]
ddsb = ss_SB[(ss_R > np.min(rbin)) & (ss_R < np.max(rbin))] - f_SB(
ss_R[(ss_R > np.min(rbin)) & (ss_R < np.max(rbin))])
ddsr = ss_R[(ss_R > np.min(rbin)) & (ss_R < np.max(rbin))]
id_nan = np.isnan(SB_01[k, :])
ivx = id_nan == False
st_R = R_01[k, ivx]
st_SB = SB_01[k, ivx]
ddtb = st_SB[(st_R > np.min(rbin)) & (st_R < np.max(rbin))] - f_SB(
st_R[(st_R > np.min(rbin)) & (st_R < np.max(rbin))])
ddtr = st_R[(st_R > np.min(rbin)) & (st_R < np.max(rbin))]
gs0 = gridspec.GridSpecFromSubplotSpec(5,
1,
subplot_spec=gs[k // 4, k % 4])
ax0 = plt.subplot(gs0[:4])
ax1 = plt.subplot(gs0[-1])
ax0.plot(rbin, SB_ref, 'r-', label='$ Intrinsic $', alpha=0.5)
ax0.plot(ss_R, ss_SB, 'g--', label='$ Smooth $', alpha=0.5)
ax0.plot(st_R,
st_SB,
'b-.',
label='$ Smooth + resampling $',
alpha=0.5)
#ax0.plot(ss_R, ss_SB, 'g--', label = '$ Noise $', alpha = 0.5)
#ax0.plot(st_R, st_SB, 'b-.', label = '$ Noise + resampling $', alpha = 0.5)
#ax0.plot(ss_R, ss_SB, 'g--', label = '$ Add \; mask $', alpha = 0.5)
#ax0.plot(st_R, st_SB, 'b-.', label = '$ Mask + resampling $', alpha = 0.5)
ax0.set_xscale('log')
ax0.set_xlim(1e1, 1e3)
ax0.set_ylabel('$SB[mag/arcsec^2]$')
ax0.invert_yaxis()
ax0.legend(loc=1)
ax0.tick_params(axis='both', which='both', direction='in')
bx1 = ax0.twiny()
xtik = ax0.get_xticks()
xtik = np.array(xtik)
xR = xtik * 10**(-3) * rad2asec / Dag
bx1.set_xscale('log')
bx1.set_xticks(xtik)
bx1.set_xticklabels(['$%.2f^{ \prime \prime }$' % uu for uu in xR])
bx1.set_xlim(ax0.get_xlim())
bx1.tick_params(axis='both', which='both', direction='in')
ax0.set_xticks([])
ax1.plot(ddsr, ddsb, 'g-', alpha=0.5)
ax1.plot(ddtr, ddtb, 'b-.', alpha=0.5)
ax1.axhline(y=0,
linestyle='--',
color='k',
alpha=0.5,
label='$ \Delta{SB} = 0 $')
ax1.set_xscale('log')
ax1.set_xlim(1e1, 1e3)
ax1.set_xlabel('$R[kpc]$')
ax1.set_ylabel('$ SB_{M} - SB_{I} $')
ax1.set_ylim(-1e-2, 1e-2)
ax1.tick_params(axis='both', which='both', direction='in')
plt.tight_layout()
plt.savefig('mock_resample_SB.pdf', dpi=300)
#plt.savefig('noise_resample_SB.pdf', dpi = 300)
#plt.savefig('mask_resample_SB.pdf', dpi = 300)
plt.close()
raise
return
def resamp_Bpl(band_id, sub_z, sub_ra, sub_dec):
ii = np.int(band_id)
zn = len(sub_z)
print('Now band is %s' % band[ii])
for k in range(zn):
ra_g = sub_ra[k]
dec_g = sub_dec[k]
z_g = sub_z[k]
Da_g = Test_model.angular_diameter_distance(z_g).value
# use star catalog dr12
data_B = fits.getdata(load +
'mask_data/B_plane/1.5sigma/B_mask_data_%s_ra%.3f_dec%.3f_z%.3f.fits'%(band[ii], ra_g, dec_g, z_g), header = True)
img_B = data_B[0]
head_mean = data_B[1]
cx0 = data_B[1]['CRPIX1']
cy0 = data_B[1]['CRPIX2']
RA0 = data_B[1]['CRVAL1']
DEC0 = data_B[1]['CRVAL2']
wcs = awc.WCS(data_B[1])
cx, cy = wcs.all_world2pix(ra_g*U.deg, dec_g*U.deg, 1)
Angur = (R0 * rad2asec/Da_g)
Rp = Angur/pixel
L_ref = Da_ref * pixel / rad2asec
L_z0 = Da_g*pixel/rad2asec
b = L_ref/L_z0
Rref = (R0*rad2asec/Da_ref)/pixel
f_goal = flux_recal(img_B, z_g, z_ref)
ix0 = np.int(cx0/b)
iy0 = np.int(cy0/b)
'''
xn, yn, resam = gen(f_goal, 1, b, cx, cy)
if b > 1:
resam = resam[1:, 1:]
elif b == 1:
resam = resam[1:-1, 1:-1]
else:
resam = resam
'''
if b > 1:
resam, xn, yn = sum_samp(b, b, f_goal, cx, cy)
else:
resam, xn, yn = down_samp(b, b, f_goal, cx, cy)
xn = np.int(xn)
yn = np.int(yn)
x0 = resam.shape[1]
y0 = resam.shape[0]
keys = ['SIMPLE','BITPIX','NAXIS','NAXIS1','NAXIS2','CRPIX1','CRPIX2','CENTER_X','CENTER_Y',
'CRVAL1','CRVAL2','CENTER_RA','CENTER_DEC','ORIGN_Z', 'P_SCALE']
value = ['T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g, pixel]
ff = dict(zip(keys,value))
fil = fits.Header(ff)
fits.writeto(load +
'resample/resam_B/frameB-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (band[ii], ra_g, dec_g, z_g), resam, header = fil, overwrite=True)
plt.figure()
ax = plt.imshow(resam, cmap = 'Greys', origin = 'lower', vmin = 1e-3, vmax = 1e2, norm = mpl.colors.LogNorm())
plt.colorbar(ax, fraction = 0.035, pad = 0.01, label = '$flux[nmaggy]$')
hsc.circles(xn, yn, s = Rpp, fc = '', ec = 'b', )
hsc.circles(xn, yn, s = 1.1 * Rpp, fc = '', ec = 'b', ls = '--')
plt.scatter(xn, yn, s = 10, marker = 'X', facecolors = '', edgecolors = 'r', linewidth = 0.5, alpha = 0.5)
plt.title('resample B mask ra%.3f dec%.3f z%.3f in %s band' % (ra_g, dec_g, z_g, band[ii]))
plt.xlim(0, resam.shape[1])
plt.ylim(0, resam.shape[0])
plt.savefig(
'/mnt/ddnfs/data_users/cxkttwl/ICL/fig_class/resamp_B/resampB_%s_ra%.3f_dec%.3f_z%.3f.png'%(band[ii], ra_g, dec_g, z_g), dpi = 300)
plt.close()
print('Now band %s have finished!!' % band[ii])
return
def resamp_func(
d_file,
z_set,
ra_set,
dec_set,
img_x,
img_y,
band,
out_file,
z_ref,
stack_info=None,
pixel=0.396,
id_dimm=False,
):
"""
d_file : path where save the masked data (include file-name structure:'/xxx/xxx/xxx.xxx')
z_set, ra_set, dec_set : ra, dec, z of will be resampled imgs
band : the band of imgs, 'str' type
out_file : path where to save the resampling img
pixel : pixel scale, in unit 'arcsec' (default is 0.396)
z_ref : reference redshift, the redshift to which all clusters will be scaled
id_dimm : if do cosmic dimming correction or not
img_x, img_y : BCG location on image frame before pixel resampling
"""
zn = len(z_set)
bcg_x, bcg_y = [], []
for k in range(zn):
ra_g = ra_set[k]
dec_g = dec_set[k]
z_g = z_set[k]
file = d_file % (band, ra_g, dec_g, z_g)
data = fits.getdata(file, header=True)
img = data[0]
cx0 = data[1]['CRPIX1']
cy0 = data[1]['CRPIX2']
RA0 = data[1]['CRVAL1']
DEC0 = data[1]['CRVAL2']
#. convert (ra, dec) to location in image frame
#wcs = awc.WCS(data[1])
#cx, cy = wcs.all_world2pix(ra_g * U.deg, dec_g * U.deg, 1)
#. read BCG position from catalog
cx, cy = img_x[k], img_y[k]
Da_g = Test_model.angular_diameter_distance(z_g).value
Da_ref = Test_model.angular_diameter_distance(z_ref).value
Dl_g = Test_model.luminosity_distance(z_g).value
Dl_ref = Test_model.luminosity_distance(z_ref).value
#. observation angle and flux factor at z_ref
pixel_ref = pixel * (Da_g / Da_ref)
eta_flux = Dl_g**2 / Dl_ref**2 #... flux change due to distance
eta_pix = pixel / pixel_ref
if id_dimm == True:
dimm_flux = flux_recal(img, z_g, z_ref)
pre_img = dimm_flux * eta_flux
else:
pre_img = img * 1.
ix0 = np.int(cx0 / eta_pix)
iy0 = np.int(cy0 / eta_pix)
if eta_pix > 1:
resam, xn, yn = sum_samp(eta_pix, eta_pix, pre_img, cx, cy)
else:
resam, xn, yn = down_samp(eta_pix, eta_pix, pre_img, cx, cy)
# cheng the data type
out_data = resam.astype('float32')
bcg_x.append(xn)
bcg_y.append(yn)
x0 = resam.shape[1]
y0 = resam.shape[0]
keys = [
'SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', 'CRPIX1',
'CRPIX2', 'CENTER_X', 'CENTER_Y', 'CRVAL1', 'CRVAL2', 'BCG_RA',
'BCG_DEC', 'ORIGN_Z', 'P_SCALE'
]
value = [
'T', 32, 2, x0, y0, ix0, iy0, xn, yn, RA0, DEC0, ra_g, dec_g, z_g,
pixel
]
ff = dict(zip(keys, value))
fil = fits.Header(ff)
fits.writeto(out_file % (band, ra_g, dec_g, z_g),
out_data,
header=fil,
overwrite=True)
bcg_x = np.array(bcg_x)
bcg_y = np.array(bcg_y)
if stack_info != None:
keys = ['ra', 'dec', 'z', 'bcg_x', 'bcg_y']
values = [ra_set, dec_set, z_set, bcg_x, bcg_y]
fill = dict(zip(keys, values))
data = pds.DataFrame(fill)
data.to_csv(stack_info)
return
