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 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 stack_test():
x0 = 2427
y0 = 1765
Nx = np.linspace(0, 4854, 4855)
Ny = np.linspace(0, 3530, 3531)
sum_grid = np.array(np.meshgrid(Nx, Ny))
sum_array_0 = np.zeros((len(Ny), len(Nx)), dtype=np.float)
count_array_0 = np.ones((len(Ny), len(Nx)), dtype=np.float) * np.nan
p_count_0 = np.zeros((len(Ny), len(Nx)), dtype=np.float)
SB_ref = []
Ar_ref = []
bins = 60
for kd in range(stack_N):
zg = z[kd]
rag = ra[kd]
decg = dec[kd]
param_A = '/home/xkchen/mywork/ICL/data/SEX/default_mask_A.sex'
out_cat = '/home/xkchen/mywork/ICL/data/SEX/default_mask_A.param'
out_load_A = '/home/xkchen/mywork/ICL/data/SEX/result/mask_A_test.cat'
tmp_load = '/home/xkchen/mywork/ICL/data/test_data/'
load = '/home/xkchen/mywork/ICL/data/total_data/sample_02_03/'
file = 'frame-r-ra%.3f-dec%.3f-redshift%.3f.fits.bz2' % (rag, decg, zg)
data = fits.getdata(load + file, header=True)
img = data[0]
Head = data[1]
wcs = awc.WCS(Head)
Da = Test_model.angular_diameter_distance(zg).value
Ar = rad2asec / Da
Rp = Ar / pixel
xt = np.linspace(0, img.shape[1] - 1, img.shape[1])
yt = np.linspace(0, img.shape[0] - 1, img.shape[0])
grd = np.array(np.meshgrid(xt, yt))
cx_BCG, cy_BCG = wcs.all_world2pix(rag * U.deg, decg * U.deg, 1)
ra_img, dec_img = wcs.all_pix2world(grd[0, :], grd[1, :], 1)
pos = SkyCoord(ra_img, dec_img, frame='fk5', unit='deg')
EBV = sfd(pos)
Av = Rv * EBV * 0.86
Al = A_wave(l_wave[2], Rv) * Av
img1 = img * 10**(Al / 2.5)
imgt = flux_recal(img1, zg, z_ref)
eta = Da_ref / Da
mu = 1 / eta
xn, yn, resam = gen(imgt, 1, eta, cx_BCG, cy_BCG)
xn = np.int(xn)
yn = np.int(yn)
if eta > 1:
resam = resam[1:, 1:]
elif eta == 1:
resam = resam[1:-1, 1:-1]
else:
resam = resam
ix0 = np.int(Head['CRPIX1'] * mu)
iy0 = np.int(Head['CRPIX2'] * mu)
RA0 = Head['CRVAL1']
DEC0 = Head['CRVAL2']
keys = [
'SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', 'CRPIX1',
'CRPIX2', 'CENTER_X', 'CENTER_Y', 'CRVAL1', 'CRVAL2', 'CENTER_RA',
'CENTER_DEC', 'ORIGN_Z'
]
value = [
'T', 32, 2, resam.shape[1], resam.shape[0], ix0, iy0, xn, yn, RA0,
DEC0, rag, decg, zg
]
ff = dict(zip(keys, value))
fil = fits.Header(ff)
fits.writeto(tmp_load + 'frame-%s-ra%.3f-dec%.3f-redshift%.3f.fits' %
('r', rag, decg, zg),
resam,
header=fil,
overwrite=True)
file_source = tmp_load + 'frame-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (
'r', rag, decg, zg)
cmd = 'sex ' + file_source + ' -c %s -CATALOG_NAME %s -PARAMETERS_NAME %s' % (
param_A, out_load_A, out_cat)
print(cmd)
A = subpro.Popen(cmd, shell=True)
A.wait()
source = asc.read(out_load_A)
Numb = np.array(source['NUMBER'][-1])
A = np.array(source['A_IMAGE'])
B = np.array(source['B_IMAGE'])
chi = np.array(source['THETA_IMAGE'])
cx = np.array(source['X_IMAGE']) - 1
cy = np.array(source['Y_IMAGE']) - 1
Kron = 6
Lr = Kron * A
Sr = Kron * B
CX = cx * 1
CY = cy * 1
a = Lr * 1
b = Sr * 1
theta = chi * 1
mask_A = np.ones((resam.shape[0], resam.shape[1]), dtype=np.float)
ox = np.linspace(0, resam.shape[1] - 1, resam.shape[1])
oy = np.linspace(0, resam.shape[0] - 1, resam.shape[0])
basic_coord = np.array(np.meshgrid(ox, oy))
major = a / 2
minor = b / 2
senior = np.sqrt(major**2 - minor**2)
tdr = np.sqrt((CX - xn)**2 + (CY - yn)**2)
dr00 = np.where(tdr == np.min(tdr))[0]
for k in range(Numb):
xc = CX[k]
yc = CY[k]
lr = major[k]
sr = minor[k]
cr = senior[k]
set_r = np.int(np.ceil(1.2 * lr))
la0 = np.int(xc - set_r)
la1 = np.int(xc + set_r + 1)
lb0 = np.int(yc - set_r)
lb1 = np.int(yc + set_r + 1)
if k == dr00[0]:
continue
else:
phi = theta[k] * np.pi / 180
df1 = lr**2 - cr**2 * np.cos(phi)**2
df2 = lr**2 - cr**2 * np.sin(phi)**2
fr = ((basic_coord[0, :][lb0:lb1, la0:la1] - xc)**2 * df1 +
(basic_coord[1, :][lb0:lb1, la0:la1] - yc)**2 * df2 -
cr**2 * np.sin(2 * phi) *
(basic_coord[0, :][lb0:lb1, la0:la1] - xc) *
(basic_coord[1, :][lb0:lb1, la0:la1] - yc))
idr = fr / (lr**2 * sr**2)
jx = idr < 1
iu = np.where(jx == True)
iv = np.ones((jx.shape[0], jx.shape[1]), dtype=np.float)
iv[iu] = np.nan
mask_A[lb0:lb1, la0:la1] = mask_A[lb0:lb1, la0:la1] * iv
mirro_A = mask_A * resam
plt.figure()
ax = plt.subplot(111)
ax.set_title('source mask after resample %d' % kd)
ax.imshow(resam,
cmap='Greys',
vmin=1e-3,
origin='lower',
norm=mpl.colors.LogNorm())
hsc.ellipses(CX, CY, w=a, h=b, rot=theta, fc='', ec='r', alpha=0.5)
plt.xlim(0, resam.shape[1])
plt.ylim(0, resam.shape[0])
plt.savefig('/home/xkchen/mywork/ICL/code/source_%d.png' % kd, dpi=300)
plt.close()
ox = np.linspace(0, resam.shape[1] - 1, resam.shape[1])
oy = np.linspace(0, resam.shape[0] - 1, resam.shape[0])
oo_grd = np.array(np.meshgrid(ox, oy))
cdr = np.sqrt((oo_grd[0, :] - xn)**2 + (oo_grd[1, :] - yn)**2)
idd = (cdr > Rpp) & (cdr < 1.1 * Rpp)
cut_res = mirro_A[idd]
id_nan = np.isnan(cut_res)
idx = np.where(id_nan == False)
bl_array = cut_res[idx]
back_cc = np.mean(bl_array)
mirroA = mirro_A - back_cc
SB2, R2, Anr2, err2 = light_measure(mirroA, bins, 1, Rpp, xn, yn,
pixel, z_ref)
SB_ = SB2[1:]
Ar_ = Anr2[1:]
R_ = R2[1:]
err_ = err2[1:]
SB_ref.append(SB_)
Ar_ref.append(Ar_)
la0 = np.int(y0 - yn)
la1 = np.int(y0 - yn + resam.shape[0])
lb0 = np.int(x0 - xn)
lb1 = np.int(x0 - xn + resam.shape[1])
idx = np.isnan(resam)
idv = np.where(idx == False)
sum_array_0[la0:la1,
lb0:lb1][idv] = sum_array_0[la0:la1,
lb0:lb1][idv] + mirroA[idv]
count_array_0[la0:la1, lb0:lb1][idv] = resam[idv]
id_nan = np.isnan(count_array_0)
id_fals = np.where(id_nan == False)
p_count_0[id_fals] = p_count_0[id_fals] + 1
count_array_0[la0:la1, lb0:lb1][idv] = np.nan
ll0 = [np.min(kk / Angu_ref) for kk in Ar_ref]
tar0 = np.min(ll0)
ll1 = [np.max(kk / Angu_ref) for kk in Ar_ref]
tar1 = np.max(ll1)
tar_down = tar0 * Angu_ref
tar_up = tar1 * Angu_ref
inter_frac = np.logspace(np.log10(tar0), np.log10(tar1), bins)
inter_ar = inter_frac * Angu_ref
m_flux = np.ones((stack_N, bins), dtype=np.float) * np.nan
for pp in range(len(SB_ref)):
id_count = np.zeros(bins, dtype=np.float)
tsb = SB_ref[pp]
tar = Ar_ref[pp] / Angu_ref
t_flux = 10**((22.5 + 2.5 * np.log10(pixel**2) - tsb) / 2.5)
for kk in range(len(tar)):
sub_ar = np.abs(inter_frac - tar[kk])
id_min = np.where(sub_ar == np.min(sub_ar))[0]
id_count[id_min[0]] = id_count[id_min[0]] + 1
id_nuzero = id_count != 0
id_g = np.where(id_nuzero == True)[0]
m_flux[pp, id_g] = t_flux
m_count = np.zeros(bins, dtype=np.float)
inter_flux = np.zeros(bins, dtype=np.float)
for pp in range(bins):
sub_flux = m_flux[:, pp]
iy = np.isnan(sub_flux)
iv = np.where(iy == False)[0]
m_count[pp] = len(iv)
inter_flux[pp] = inter_flux[pp] + np.sum(sub_flux[iv])
inter_flux = inter_flux / m_count
id_nan = np.isnan(inter_flux)
id_x = id_nan == False
id_inf = np.isinf(inter_flux)
id_y = id_inf == False
id_zero = inter_flux == 0
id_z = id_zero == False
id_set = id_x & id_y & id_z
ref_ar = inter_ar[id_set]
ref_flux = inter_flux[id_set]
ref_SB = 22.5 - 2.5 * np.log10(ref_flux) + 2.5 * np.log10(pixel**2)
f_SB = interp(ref_ar, ref_SB, kind='cubic')
mean_array_0 = sum_array_0 / p_count_0
where_are_inf = np.isinf(mean_array_0)
mean_array_0[where_are_inf] = np.nan
id_zeros = np.where(p_count_0 == 0)
mean_array_0[id_zeros] = np.nan
SB, R, Ar, error = light_measure(mean_array_0, bins, 1, Rpp, x0, y0, pixel,
z_ref)
SB_0 = SB[1:] + 0
R_0 = R[1:]
Ar_0 = Ar[1:]
err_0 = error[1:]
Ar0 = (Ar_0 / Angu_ref) * Angu_ref
plt.figure(figsize=(16, 8))
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
ax = plt.subplot(gs[0])
bx = plt.subplot(gs[1])
ax.plot(ref_ar, ref_SB, 'r-', label='$stacking \, profile$', alpha=0.5)
ax.plot(Ar0, SB_0, 'g--', label='$stacking \, img$', alpha=0.5)
bx.plot(Ar0[(Ar0 > tar_down * 1.01) & (Ar0 < tar_up / 1.01)],
SB_0[(Ar0 > tar_down * 1.01) & (Ar0 < tar_up / 1.01)] -
f_SB(Ar0[(Ar0 > tar_down * 1.01) & (Ar0 < tar_up / 1.01)]),
'b*',
alpha=0.5)
ax.set_xscale('log')
ax.set_xlabel('$R[arcsec]$')
ax.set_ylabel('$SB[mag/arcsec^2]$')
ax.tick_params(axis='both', which='both', direction='in')
ax.legend(loc=1, fontsize=12)
ax.invert_yaxis()
bx.set_xlabel('$R[arcsec]$')
bx.set_xscale('log')
bx.set_ylabel('$ \Delta{SB}[mag/arcsec^2] $')
bx.tick_params(axis='both', which='both', direction='in')
plt.subplots_adjust(hspace=0)
plt.tight_layout()
plt.savefig('/home/xkchen/mywork/ICL/code/stack_test.png', dpi=300)
plt.close()
raise
return
def resamp_test():
for kd in range(10):
z_ref = 0.25
Da_ref = Test_model.angular_diameter_distance(z_ref).value
Angu_ref = (R0 / Da_ref) * rad2asec
Rpp = Angu_ref / pixel
bins = 50
x0 = np.linspace(0, 2047, 2048)
y0 = np.linspace(0, 1488, 1489)
grd = np.array(np.meshgrid(x0, y0))
r_star = 2 * 1.5 / pixel
zg = z[kd]
rag = ra[kd]
decg = dec[kd]
param_A = '/home/xkchen/mywork/ICL/data/SEX/default_mask_A.sex'
out_cat = '/home/xkchen/mywork/ICL/data/SEX/default_mask_A.param'
out_load_A = '/home/xkchen/mywork/ICL/data/SEX/result/mask_A_test.cat'
tmp_load = '/home/xkchen/mywork/ICL/data/test_data/'
load = '/home/xkchen/mywork/ICL/data/total_data/sample_02_03/'
file = 'frame-r-ra%.3f-dec%.3f-redshift%.3f.fits.bz2' % (rag, decg, zg)
data = fits.open(load + file)
img = data[0].data
Head = data[0].header
wcs = awc.WCS(Head)
Da = Test_model.angular_diameter_distance(zg).value
Ar = rad2asec / Da
Rp = Ar / pixel
cx_BCG, cy_BCG = wcs.all_world2pix(rag * U.deg, decg * U.deg, 1)
ra_img, dec_img = wcs.all_pix2world(grd[0, :], grd[1, :], 1)
pos = SkyCoord(ra_img, dec_img, frame='fk5', unit='deg')
EBV = sfd(pos)
Av = Rv * EBV * 0.86
Al = A_wave(l_wave[2], Rv) * Av
img1 = img * 10**(Al / 2.5)
## part1: find the source and mask in original image
hdu = fits.PrimaryHDU()
hdu.data = img1
hdu.header = Head
hdu.writeto(tmp_load + 'frame-%s-ra%.3f-dec%.3f-redshift%.3f.fits' %
('r', rag, decg, zg),
overwrite=True)
file_source = tmp_load + 'frame-%s-ra%.3f-dec%.3f-redshift%.3f.fits' % (
'r', rag, decg, zg)
cmd = 'sex ' + file_source + ' -c %s -CATALOG_NAME %s -PARAMETERS_NAME %s' % (
param_A, out_load_A, out_cat)
print(cmd)
A = subpro.Popen(cmd, shell=True)
A.wait()
source = asc.read(out_load_A)
Numb = np.array(source['NUMBER'][-1])
A = np.array(source['A_IMAGE'])
B = np.array(source['B_IMAGE'])
chi = np.array(source['THETA_IMAGE'])
cx = np.array(source['X_IMAGE']) - 1
cy = np.array(source['Y_IMAGE']) - 1
Kron = 6
Lr = Kron * A
Sr = Kron * B
cat = pd.read_csv(
'/home/xkchen/mywork/ICL/data/star_catalog/source_SQL_Z%.3f_ra%.3f_dec%.3f.txt'
% (zg, rag, decg),
skiprows=1)
ra_s = np.array(cat['ra'])
dec_s = np.array(cat['dec'])
mag = np.array(cat['r'])
x_side = img.shape[1]
y_side = img.shape[0]
x, y = wcs.all_world2pix(ra_s * U.deg, dec_s * U.deg, 1)
ia = (x >= 0) & (x <= x_side)
ib = (y >= 0) & (y <= y_side)
ie = (mag <= 20)
ic = ia & ib & ie
comx = x[ic]
comy = y[ic]
comr = np.ones(len(comx), dtype=np.float) * r_star
com_chi = np.zeros(len(comx), dtype=np.float)
CX = np.r_[cx, comx]
CY = np.r_[cy, comy]
a = np.r_[Lr, 2 * comr]
b = np.r_[Sr, 2 * comr]
theta = np.r_[chi, com_chi]
Numb = Numb + len(comx)
mask_A = np.ones((img.shape[0], img.shape[1]), dtype=np.float)
ox = np.linspace(0, img.shape[1] - 1, img.shape[1])
oy = np.linspace(0, img.shape[0] - 1, img.shape[0])
basic_coord = np.array(np.meshgrid(ox, oy))
major = a / 2
minor = b / 2
senior = np.sqrt(major**2 - minor**2)
tdr = np.sqrt((CX - cx_BCG)**2 + (CY - cy_BCG)**2)
dr00 = np.where(tdr == np.min(tdr))[0]
for k in range(Numb):
xc = CX[k]
yc = CY[k]
lr = major[k]
sr = minor[k]
cr = senior[k]
set_r = np.int(np.ceil(1.2 * lr))
la0 = np.int(xc - set_r)
la1 = np.int(xc + set_r + 1)
lb0 = np.int(yc - set_r)
lb1 = np.int(yc + set_r + 1)
if k == dr00[0]:
continue
else:
phi = theta[k] * np.pi / 180
df1 = lr**2 - cr**2 * np.cos(phi)**2
df2 = lr**2 - cr**2 * np.sin(phi)**2
fr = ((basic_coord[0, :][lb0:lb1, la0:la1] - xc)**2 * df1 +
(basic_coord[1, :][lb0:lb1, la0:la1] - yc)**2 * df2 -
cr**2 * np.sin(2 * phi) *
(basic_coord[0, :][lb0:lb1, la0:la1] - xc) *
(basic_coord[1, :][lb0:lb1, la0:la1] - yc))
idr = fr / (lr**2 * sr**2)
jx = idr < 1
#jx = (-1)*jx+1
#mask_A[lb0: lb1, la0: la1] = mask_A[lb0: lb1, la0: la1] * jx
iu = np.where(jx == True)
iv = np.ones((jx.shape[0], jx.shape[1]), dtype=np.float)
iv[iu] = np.nan
mask_A[lb0:lb1, la0:la1] = mask_A[lb0:lb1, la0:la1] * iv
mirro_A = mask_A * img1
SB2, R2, Anr2, err2 = light_measure(mirro_A, bins, 1, Rp, cx_BCG,
cy_BCG, pixel, zg)
'''
## test the flux distribution in each bins
sub_R = np.logspace(0, np.log10(Rp), bins)
cdr = np.sqrt((grd[0,:] - cx_BCG)**2 + (grd[1,:] - cy_BCG)**2)
Nr = len(sub_R)
for xx in range(Nr - 1):
idr = (cdr >= sub_R[xx]) & (cdr < sub_R[xx + 1])
sub_f = mirro_A[idr]
id_nan = np.isnan(sub_f)
iv = np.where(id_nan == False)[0]
bl_array = sub_f[iv]
plt.figure()
plt.title('$flux \; distribution \; in \; %d \; bins$' % (xx))
plt.hist(bl_array, histtype = 'step', color = 'b', normed = True)
plt.xlabel('$flux[nmagy]$')
plt.savefig('/home/xkchen/mywork/ICL/code/flux_%dbins_DF_%.3fra_%.3fdec_%.3fz.png' % (xx, rag, decg, zg), dpi = 300)
plt.close()
'''
# flux scale and pixel resample
eta = Da_ref / Da
mu = 1 / eta
SB_ref = SB2 - 10 * np.log10((1 + zg) / (1 + z_ref))
Ar_ref = Anr2 * mu
f_SB = interp(Ar_ref, SB_ref, kind='cubic')
imgt = flux_recal(img1, zg, z_ref)
mirroA = flux_recal(mirro_A, zg, z_ref)
xn, yn, resam = gen(mirroA, 1, eta, cx_BCG,
cy_BCG) #############???????
xn = np.int(xn)
yn = np.int(yn)
if eta > 1:
resam = resam[1:, 1:]
elif eta == 1:
resam = resam[1:-1, 1:-1]
else:
resam = resam
SBn, Rn, Anrn, errn = light_measure(resam, bins, 1, Rpp, xn, yn, pixel,
z_ref)
arn = Anrn[(Anrn >= np.min(Ar_ref)) & (Anrn <= np.max(Ar_ref))]
plt.figure(figsize=(16, 8))
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
ax = plt.subplot(gs[0])
bx = plt.subplot(gs[1])
ax.plot(Anrn, SBn, 'b-', label='$SB_{resample}$', alpha=0.5)
ax.plot(Ar_ref, SB_ref, 'g--', label='$SB_{ref}$', alpha=0.5)
bx.plot(
arn, SBn[(Anrn >= np.min(Ar_ref)) & (Anrn <= np.max(Ar_ref))] -
f_SB(arn), 'g*')
bx.axhline(y=np.mean(SBn[(Anrn >= np.min(Ar_ref))
& (Anrn <= np.max(Ar_ref))] - f_SB(arn)),
ls='--',
color='b')
ax.set_ylabel('$SB[mag/arcsec^2]$')
ax.set_xlabel('$R[arcsec]$')
ax.set_xscale('log')
ax.tick_params(axis='both', which='both', direction='in')
ax.invert_yaxis()
ax.legend(loc=1, fontsize=15)
bx.set_xlabel('$R[arcsec]$')
bx.set_xscale('log')
bx.set_ylabel('$ \Delta{SB}[mag/arcsec^2] $')
bx.tick_params(axis='both', which='both', direction='in')
bx.legend(loc=3, fontsize=12)
plt.subplots_adjust(hspace=0)
plt.tight_layout()
plt.savefig(
'/home/xkchen/mywork/ICL/code/resamp_err_SB_%d_ra%.3f_dec%.3f_z%.3f.png'
% (bins, rag, decg, zg),
dpi=300)
plt.close() #############???????????????
'''
xn, yn, resam = gen(imgt, 1, eta, cx_BCG, cy_BCG)
xn = np.int(xn)
yn = np.int(yn)
if eta > 1:
resam = resam[1:, 1:]
elif eta == 1:
resam = resam[1:-1, 1:-1]
else:
resam = resam
## handle with these pixels around 0
# from mask
id_zero = np.where(mask_A == 0)
tt_mask = mask_A * 1
tt_mask[id_zero] = np.nan
ttx, tty, ttmask = gen(tt_mask, 1, eta, cx_BCG, cy_BCG)
if eta > 1:
ttmask = ttmask[1:, 1:]
elif eta == 1:
ttmask = ttmask[1:-1, 1:-1]
else:
ttmask = ttmask
id_nan = np.isnan(ttmask)
ttmask[id_nan] = 0
idnzeo = np.where(ttmask != 0)
ttmask[idnzeo] = 1
tt_img = ttmask * resam
SB3, R3, Anr3, err3 = light_measure(tt_img, bins, 1, Rpp, xn, yn, pixel, z_ref)
# from masked img
id_zero = np.where(mirroA == 0)
tt_mirro = mirroA * 1
tt_mirro[id_zero] = np.nan
x2, y2, resam2 = gen(tt_mirro, 1, eta, cx_BCG, cy_BCG)
x2 = np.int(x2)
y2 = np.int(y2)
if eta > 1:
resam2 = resam2[1:, 1:]
elif eta == 1:
resam2 = resam2[1:-1, 1:-1]
else:
resam2 = resam2
id_nan = np.isnan(resam2)
resam2[id_nan] = 0
SB5, R5, Anr5, err5 = light_measure(resam2, bins, 1, Rpp, x2, y2, pixel, z_ref)
### part2: mask after resample (mask with the same source)
CX_ = CX * mu
CY_ = CY * mu
a_ = a * mu
b_ = b * mu
res_mask_1 = np.ones((resam.shape[0], resam.shape[1]), dtype = np.float)
ox_ = np.linspace(0, resam.shape[1] - 1, resam.shape[1])
oy_ = np.linspace(0, resam.shape[0] - 1, resam.shape[0])
basic_coord = np.array(np.meshgrid(ox_, oy_))
major = a_ / 2
minor = b_ / 2
senior = np.sqrt(major**2 - minor**2)
tdr = np.sqrt((CX_ - xn)**2 + (CY_ - yn)**2)
dr00 = np.where(tdr == np.min(tdr))[0]
for k in range(Numb):
xc = CX_[k]
yc = CY_[k]
lr = major[k]
sr = minor[k]
cr = senior[k]
set_r = np.int(np.ceil(1.2 * lr))
la0 = np.int(xc - set_r)
la1 = np.int(xc + set_r +1)
lb0 = np.int(yc - set_r)
lb1 = np.int(yc + set_r +1)
if k == dr00[0] :
continue
else:
phi = theta[k]*np.pi/180
df1 = lr**2 - cr**2*np.cos(phi)**2
df2 = lr**2 - cr**2*np.sin(phi)**2
fr = ((basic_coord[0,:][lb0: lb1, la0: la1] - xc)**2*df1 + (basic_coord[1,:][lb0: lb1, la0: la1] - yc)**2*df2
- cr**2*np.sin(2*phi)*(basic_coord[0,:][lb0: lb1, la0: la1] - xc)*(basic_coord[1,:][lb0: lb1, la0: la1] - yc))
idr = fr/(lr**2*sr**2)
jx = idr<=1
jx = (-1)*jx+1
res_mask_1[lb0: lb1, la0: la1] = res_mask_1[lb0: lb1, la0: la1]*jx
resam1 = res_mask_1 * resam
SBt, Rt, Anrt, errt = light_measure(resam1, bins, 1, Rpp, xn, yn, pixel, z_ref)
# cut these pixel which is 0 before resamp
xm, ym, res_mask_2 = gen(mask_A, 1, eta, cx_BCG, cy_BCG)
if eta > 1:
res_mask_2 = res_mask_2[1:, 1:]
elif eta == 1:
res_mask_2 = res_mask_2[1:-1, 1:-1]
else:
res_mask_2 = res_mask_2
mix, miy, mirro_img = gen(mirroA, 1, eta, cx_BCG, cy_BCG)
mix = np.int(mix)
miy = np.int(miy)
if eta > 1:
mirro_img = mirro_img[1:, 1:]
elif eta == 1:
mirro_img = mirro_img[1:-1, 1:-1]
else:
mirro_img = mirro_img
val, cont = sts.find_repeats(res_mask_2)
ids = np.where(cont == np.max(cont))[0]
res_mask2 = res_mask_2 / val[ids[0]]
print('scale factor = ', val[ids[0]])
SB4, R4, Anr4, err4 = weit_l_measure(mirro_img, res_mask2, bins, 1, Rpp, mix, miy, pixel, z_ref)
ar4 = Anr4[(Anr4 >= np.min(Ar_ref)) & (Anr4 <= np.max(Ar_ref))]
ar3 = Anr3[(Anr3 >= np.min(Ar_ref)) & (Anr3 <= np.max(Ar_ref))]
art = Anrt[(Anrt >= np.min(Ar_ref)) & (Anrt <= np.max(Ar_ref))]
plt.figure(figsize = (16, 8))
gs = gridspec.GridSpec(1, 2, width_ratios = [1,1])
ax = plt.subplot(gs[0])
bx = plt.subplot(gs[1])
ax.plot(Anrt, SBt, 'g-.', label = '$SB_{re-load \, source \, at \, z_{0}}$', alpha = 0.5)
ax.plot(Anr4, SB4, 'b-', label = '$SB_{resample \, mask \, Metrix}$', alpha = 0.5)
ax.plot(Anr3, SB3, 'r:', label = '$SB_{correct \, resample}$', alpha = 0.5)
ax.plot(Ar_ref, SB_ref, 'k--', label = '$SB_{ref}$', alpha = 0.5)
bx.plot(ar4, SB4[(Anr4 >= np.min(Ar_ref)) & (Anr4 <= np.max(Ar_ref))] - f_SB(ar4),
'b*', label = '$ [SB_{resample \, mask} - SB_{ref}] $', alpha = 0.5)
bx.plot(ar3, SB3[(Anr3 >= np.min(Ar_ref)) & (Anr3 <= np.max(Ar_ref))] - f_SB(ar3),
'r*', label = '$ [SB_{correct \, resample} - SB_{ref}] $', alpha = 0.5)
bx.plot(art, SBt[(Anrt >= np.min(Ar_ref)) & (Anrt <= np.max(Ar_ref))] - f_SB(art),
'g*', label = '$ [SB_{re-load \, source} - SB_{ref}] $', alpha = 0.5)
bx.axhline(y = np.mean(SB4[(Anr4 >= np.min(Ar_ref)) & (Anr4 <= np.max(Ar_ref))] - f_SB(ar4)), color = 'b', ls = '--', alpha = 0.5)
bx.axhline(y = np.mean(SB3[(Anr3 >= np.min(Ar_ref)) & (Anr3 <= np.max(Ar_ref))] - f_SB(ar3)), color = 'r', ls = '--', alpha = 0.5)
bx.axhline(y = np.mean(SBt[(Anrt >= np.min(Ar_ref)) & (Anrt <= np.max(Ar_ref))] - f_SB(art)), color = 'g', ls = '--', alpha = 0.5)
ax.set_title('resample SB profile comparation')
ax.set_ylabel('$SB[mag/arcsec^2]$')
ax.set_xlabel('$R[arcsec]$')
ax.set_xscale('log')
ax.tick_params(axis = 'both', which = 'both', direction = 'in')
ax.invert_yaxis()
ax.legend(loc = 1, fontsize = 15)
bx.set_xlabel('$R[arcsec]$')
bx.set_xscale('log')
bx.set_ylabel('$ \Delta{SB}[mag/arcsec^2] $')
bx.tick_params(axis = 'both', which = 'both', direction = 'in')
bx.legend(loc = 3, fontsize = 12)
plt.subplots_adjust(hspace = 0)
plt.tight_layout()
plt.savefig('/home/xkchen/mywork/ICL/code/resample_test_SB_%d_ra%.3f_dec%.3f_z%.3f.png' % (bins, rag, decg, zg), dpi = 300)
plt.close()
'''
raise
return
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 pix_resample(band_id, sub_z, sub_ra, sub_dec):
tot_N = len(sub_z)
ii = np.int(band_id)
for k in range(tot_N):
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
## read image (applied mask, extinction correction)
data = fits.getdata(tmp + 'test/A_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)
Angu_z = R0 * rad2asec / Da_g
Rp_z = Angu_z / 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(tmp + 'test/resam-%s-ra%.3f-dec%.3f-redshift%.3f.fits' %
(band[ii], ra_g, dec_g, z_g),
resam,
header=fil,
overwrite=True)
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
