def BG_sub_sb_func( N_sample, jk_sub_sb, sb_out_put, band_str, BG_file, trunk_R=2e3, ): """ by default, trunk_R = 2Mpc, which meanse the model signal beyond 2Mpc will be treated as background and subtracted from the observation """ tmp_r, tmp_sb = [], [] cat = pds.read_csv(BG_file) (e_a, e_b, e_x0, e_A, e_alpha, e_B, offD) = (np.array(cat['e_a'])[0], np.array(cat['e_b'])[0], np.array(cat['e_x0'])[0], np.array(cat['e_A'])[0], np.array(cat['e_alpha'])[0], np.array(cat['e_B'])[0], np.array(cat['offD'])[0]) I_e, R_e = np.array(cat['I_e'])[0], np.array(cat['R_e'])[0] sb_2Mpc = sersic_func(trunk_R, I_e, R_e) for kk in range(N_sample): with h5py.File(jk_sub_sb % kk, 'r') as f: c_r_arr = np.array(f['r']) c_sb_arr = np.array(f['sb']) c_sb_err = np.array(f['sb_err']) npix = np.array(f['npix']) id_Nul = npix < 1 c_r_arr[id_Nul] = np.nan c_sb_arr[id_Nul] = np.nan c_sb_err[id_Nul] = np.nan full_r_fit = cc_rand_sb_func(c_r_arr, e_a, e_b, e_x0, e_A, e_alpha, e_B) full_BG = full_r_fit - offD + sb_2Mpc devi_sb = c_sb_arr - full_BG tmp_r.append(c_r_arr) tmp_sb.append(devi_sb) tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func( tmp_sb, tmp_r, band_str, N_sample, )[4:] ## save BG-subtracted pros with h5py.File(sb_out_put, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) return
def aveg_jack_PA_SB_func(J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, N_bin, n_rbins, pix_size, zx, band_str): """ measure the average SB profile of jackknife subsample ----------------------------------- J_sub_img, J_sub_pix_cont : the stacked image and corresponding pixel counts of subsamples J_sub_sb : .csv file, the output file of surface brightness profile of subsamples jack_SB_file : .csv file, the output of average jackknife subsample surface brightness N_bin, n_rbins : the number of subsample (N_bin), and number of radii bins (n_rbins) pix_size, zx : pixel scale (in units of arcsec) and redshift of measurement band_str : filter information (i.e., 'g', 'r', 'i') """ #. radius bin lim_r = 0 for nn in range(N_bin): with h5py.File(J_sub_img % nn, 'r') as f: tmp_img = np.array(f['a']) xn, yn = np.int(tmp_img.shape[1] / 2), np.int(tmp_img.shape[0] / 2) id_nn = np.isnan(tmp_img) eff_y, eff_x = np.where(id_nn == False) dR = np.sqrt((eff_y - yn)**2 + (eff_x - xn)**2) dR_max = np.int(dR.max()) + 1 lim_r = np.max([lim_r, dR_max]) r_bins = np.logspace(0, np.log10(lim_r), n_rbins) #. SB measure for nn in range(N_bin): with h5py.File(J_sub_img % nn, 'r') as f: tmp_img = np.array(f['a']) with h5py.File(J_sub_pix_cont % nn, 'r') as f: tmp_cont = np.array(f['a']) xn, yn = np.int(tmp_img.shape[1] / 2), np.int(tmp_img.shape[0] / 2) h_array, v_array, d_array = PA_SB_Zx_func(tmp_img, tmp_cont, pix_size, xn, yn, zx, r_bins) SB_h_R, SB_h, SB_h_err, N_pix_h, nsum_ratio_h = h_array[:] SB_v_R, SB_v, SB_v_err, N_pix_v, nsum_ratio_v = v_array[:] SB_d_R, SB_d, SB_d_err, N_pix_d, nsum_ratio_d = d_array[:] id_hx = N_pix_h < 1. SB_h_R[id_hx] = np.nan SB_h[id_hx] = np.nan SB_h_err[id_hx] = np.nan id_vx = N_pix_v < 1. SB_v_R[id_vx] = np.nan SB_v[id_vx] = np.nan SB_v_err[id_vx] = np.nan id_dx = N_pix_d < 1. SB_d_R[id_dx] = np.nan SB_d[id_dx] = np.nan SB_d_err[id_dx] = np.nan #. save keys = [ 'r_h', 'sb_h', 'sb_err_h', 'r_v', 'sb_v', 'sb_err_v', 'r_d', 'sb_d', 'sb_err_d' ] values = [ SB_h_R, SB_h, SB_h_err, SB_v_R, SB_v, SB_v_err, SB_d_R, SB_d, SB_d_err ] fill = dict(zip(keys, values)) data = pds.DataFrame(fill) data.to_csv(J_sub_sb % nn) #. average of jackknife tmp_h_sb = [] tmp_h_r = [] tmp_v_sb = [] tmp_v_r = [] tmp_d_sb = [] tmp_d_r = [] for nn in range(N_bin): n_dat = pds.read_csv(J_sub_sb % nn) r_arr = np.array(n_dat['r_h']) sb_arr = np.array(n_dat['sb_h']) sb_err = np.array(n_dat['sb_err_h']) tmp_h_sb.append(sb_arr) tmp_h_r.append(r_arr) r_arr = np.array(n_dat['r_v']) sb_arr = np.array(n_dat['sb_v']) sb_err = np.array(n_dat['sb_err_v']) tmp_v_sb.append(sb_arr) tmp_v_r.append(r_arr) r_arr = np.array(n_dat['r_d']) sb_arr = np.array(n_dat['sb_d']) sb_err = np.array(n_dat['sb_err_d']) tmp_d_sb.append(sb_arr) tmp_d_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R_h, tt_jk_SB_h, tt_jk_err_h, lim_R_h = jack_SB_func( tmp_h_sb, tmp_h_r, band_str, N_bin)[4:] tt_jk_R_v, tt_jk_SB_v, tt_jk_err_v, lim_R_v = jack_SB_func( tmp_v_sb, tmp_v_r, band_str, N_bin)[4:] tt_jk_R_d, tt_jk_SB_d, tt_jk_err_d, lim_R_d = jack_SB_func( tmp_d_sb, tmp_d_r, band_str, N_bin)[4:] #. adjust the array length Len = [len(tt_jk_R_h), len(tt_jk_R_v), len(tt_jk_R_d)] L_max = np.max(Len) out_R_v = np.ones(L_max, ) * np.nan out_SB_v = np.ones(L_max, ) * np.nan out_err_v = np.ones(L_max, ) * np.nan out_R_v[:Len[0]] = tt_jk_R_v[:Len[0]] out_SB_v[:Len[0]] = tt_jk_SB_v[:Len[0]] out_err_v[:Len[0]] = tt_jk_err_v[:Len[0]] out_R_h = np.ones(L_max, ) * np.nan out_SB_h = np.ones(L_max, ) * np.nan out_err_h = np.ones(L_max, ) * np.nan out_R_h[:Len[1]] = tt_jk_R_h[:Len[1]] out_SB_h[:Len[1]] = tt_jk_SB_h[:Len[1]] out_err_h[:Len[1]] = tt_jk_err_h[:Len[1]] out_R_d = np.ones(L_max, ) * np.nan out_SB_d = np.ones(L_max, ) * np.nan out_err_d = np.ones(L_max, ) * np.nan out_R_d[:Len[2]] = tt_jk_R_d[:Len[2]] out_SB_d[:Len[2]] = tt_jk_SB_d[:Len[2]] out_err_d[:Len[2]] = tt_jk_err_d[:Len[2]] sb_lim_r_h = np.ones(len(out_R_h)) * lim_R_h sb_lim_r_v = np.ones(len(out_R_v)) * lim_R_v sb_lim_r_d = np.ones(len(out_R_d)) * lim_R_d #. keys = [ 'r_h', 'sb_h', 'sb_err_h', 'lim_R_h', 'r_v', 'sb_v', 'sb_err_v', 'lim_R_v', 'r_d', 'sb_d', 'sb_err_d', 'lim_R_d' ] values = [ out_R_h, out_SB_h, out_err_h, sb_lim_r_h, out_R_v, out_SB_v, out_err_v, sb_lim_r_v, out_R_d, out_SB_d, out_err_d, sb_lim_r_d ] fill = dict(zip(keys, values)) data = pds.DataFrame(fill) data.to_csv(jack_SB_file) return
def stack_BG_sub_func(sat_sb_file, bg_sb_file, band_str, N_sample, out_file, sub_out_file=None): """ sat_sb_file : SB(r) of satellites, .h5 files band_str : filter information bg_sb_file : background SB(r), .h5 file out_file : .csv file N_sample : number of subsample sub_out_file : output the BG-sub profile of subsamples or not """ tmp_SB, tmp_R = [], [] with h5py.File(bg_sb_file, 'r') as f: t_bg_r = np.array(f['r']) t_bg_sb = np.array(f['sb']) t_bg_err = np.array(f['sb_err']) interp_mu_F = interp.interp1d(t_bg_r, t_bg_sb, kind='linear', fill_value='extrapolate') interp_mu_err = interp.interp1d(t_bg_r, t_bg_err, kind='linear', fill_value='extrapolate') for kk in range(N_sample): with h5py.File(sat_sb_file % kk, 'r') as f: tt_r = np.array(f['r']) tt_sb = np.array(f['sb']) tt_err = np.array(f['sb_err']) tt_npix = np.array(f['npix']) id_Nul = tt_npix < 1 tt_r[id_Nul] = np.nan tt_sb[id_Nul] = np.nan tt_err[id_Nul] = np.nan _kk_sb = tt_sb - interp_mu_F(tt_r) if sub_out_file is not None: _kk_err = np.sqrt(tt_err**2 + interp_mu_err(tt_r)**2) keys = ['r', 'sb', 'sb_err'] values = [tt_r, _kk_sb, _kk_err] fill = dict(zip(keys, values)) out_data = pds.DataFrame(fill) out_data.to_csv(sub_out_file % kk) tmp_R.append(tt_r) tmp_SB.append(_kk_sb) tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func(tmp_SB, tmp_R, band_str, N_sample)[4:] keys = ['r', 'sb', 'sb_err'] values = [tt_jk_R, tt_jk_SB, tt_jk_err] fill = dict(zip(keys, values)) out_data = pds.DataFrame(fill) out_data.to_csv(out_file) return
with h5py.File(J_sub_sb % nn, 'r') as f: r_arr = np.array(f['r'])[:-1] sb_arr = np.array(f['sb'])[:-1] sb_err = np.array(f['sb_err'])[:-1] npix = np.array(f['npix'])[:-1] nratio = np.array(f['nratio'])[:-1] idvx = npix < 1. sb_arr[idvx] = np.nan r_arr[idvx] = np.nan tmp_sb.append(sb_arr) tmp_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func( tmp_sb, tmp_r, band_str, N_bin)[4:] sb_lim_r = np.ones(len(tt_jk_R)) * lim_R with h5py.File(jack_SB_file, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) f['lim_r'] = np.array(sb_lim_r) order_id = np.arange(0, N_bin, 1) order_id = order_id.astype(np.int32) weit_aveg_img( order_id, sub_img, sub_pix_cont, jack_img,
def jack_main_func(id_cen, N_bin, n_rbins, cat_ra, cat_dec, cat_z, img_x, img_y, img_file, band_str, sub_img, sub_pix_cont, sub_sb, J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, jack_img, jack_cont_arr, id_cut = False, N_edg = None, id_Z0 = True, z_ref = None, id_S2N = False, S2N = None, id_sub = True, edg_bins = None, sub_rms = None, J_sub_rms = None, jack_rms_arr = None, N_weit = None): """ combining jackknife stacking process, and save : sub-sample (sub-jack-sample) stacking image, pixel conunt array, surface brightness profiles id_cen : 0 - stacking by centering on BCGs, 1 - stacking by centering on img center N_bin : number of jackknife sample n_rbins : the number of radius bins (int type) cat_ra, cat_dec, cat_z : catalog information about the stacking sample, ra, dec, z img_x, img_y : BCG position (in image coordinate) img_file : img-data name (include file-name structure:'/xxx/xxx/xxx.xxx') band_str : the band of imgs, 'str' type sub_img, sub_pix_cont, sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of individual sub-sample img stacking result J_sub_img, J_sub_pix_cont, J_sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of jackknife sub-sample img stacking result jack_SB_file : file name of the final jackknife stacking SB profile ('/xxx/xxx/xxx.xxx') jack_img : mean of the jackknife stacking img ('/xxx/xxx/xxx.xxx') jack_cont_arr : mean of the pixel count array ('/xxx/xxx/xxx.xxx') id_cut : id_cut == True, cut img edge pixels before stacking, id_cut == False, just stacking original size imgs N_edg : the cut region width, in unit of pixel, only applied when id_cut == True, pixels in this region will be set as 'no flux' contribution pixels (ie. set as np.nan) id_Z0 : stacking imgs on observation coordinate (id_Z0 = True, and reference redshift is z_ref) or not (id_Z0 = False, give radius in physical unit, kpc), default is True id_S2N, S2N : if set S/N limitation for SB profile measure or not, Default is False (no limitation applied). if id_S2N = True, then measure the SB profile, and in region where S/N is lower than S2N with be treated as only one radius bins (edg_bins = None), (or measured according edg_bins.) id_sub : measure and save the SB profiles for sub-samples of not, default is True sub_rms, J_sub_rms : pixel standard deviation of stacking images (for sub-sample and jackknife sub-sample) jack_rms_file : the final rms_file (total sample imgs stacking result) N_weit : if weight the cluster image with satellite number or not ('None') if N_weit != None, is has the same length as the cat_ra array """ print( 'id_Z0', id_Z0 ) print( 'id_cut', id_cut ) print( 'N_edg', N_edg ) print( 'z_ref', z_ref ) zN = len( cat_z ) if N_weit is None: wit_n_arr = np.ones( zN,) else: wit_n_arr = N_weit + 0. id_arr = np.arange(0, zN, 1) id_group = id_arr % N_bin lis_ra, lis_dec, lis_z = [], [], [] lis_x, lis_y = [], [] lis_wn = [] for nn in range( N_bin ): id_xbin = np.where( id_group == nn )[0] lis_ra.append( cat_ra[ id_xbin ] ) lis_dec.append( cat_dec[ id_xbin ] ) lis_z.append( cat_z[ id_xbin ] ) lis_x.append( img_x[ id_xbin ] ) lis_y.append( img_y[ id_xbin ] ) lis_wn.append( wit_n_arr[ id_xbin ] ) band_id = band.index( band_str ) ## img stacking for nn in range(N_bin): set_z = lis_z[ nn ] set_ra = lis_ra[ nn ] set_dec = lis_dec[ nn ] set_x = lis_x[ nn ] set_y = lis_y[ nn ] set_wn = lis_wn[ nn ] sub_img_file = sub_img % nn sub_cont_file = sub_pix_cont % nn if sub_rms is not None: sub_rms_file = sub_rms % nn else: sub_rms_file = None if id_cut == False: stack_func(img_file, sub_img_file, set_z, set_ra, set_dec, band[ band_id ], set_x, set_y, id_cen, rms_file = sub_rms_file, pix_con_file = sub_cont_file, N_weit = set_wn ) if id_cut == True: cut_stack_func(img_file, sub_img_file, set_z, set_ra, set_dec, band[ band_id ], set_x, set_y, id_cen, N_edg, rms_file = sub_rms_file, pix_con_file = sub_cont_file, N_weit = set_wn ) for nn in range( N_bin ): id_arry = np.linspace(0, N_bin -1, N_bin) id_arry = id_arry.astype(int) jack_id = list(id_arry) jack_id.remove(jack_id[nn]) jack_id = np.array(jack_id) jack_img_file = J_sub_img % nn jack_cont_file = J_sub_pix_cont % nn weit_aveg_img(jack_id, sub_img, sub_pix_cont, jack_img_file, sum_weit_file = jack_cont_file,) if sub_rms is not None: jack_rms_file = J_sub_rms % nn weit_aveg_img(jack_id, sub_rms, sub_pix_cont, jack_rms_file,) ## SB measurement if id_sub == True: ## sub-samples SB_pros_func(sub_img, sub_pix_cont, sub_sb, N_bin, n_rbins, id_Z0, z_ref) if id_S2N == False: ## jackknife sub-samples SB_pros_func(J_sub_img, J_sub_pix_cont, J_sub_sb, N_bin, n_rbins, id_Z0, z_ref) ## final jackknife SB profile tmp_sb = [] tmp_r = [] for nn in range( N_bin ): with h5py.File(J_sub_sb % nn, 'r') as f: r_arr = np.array(f['r'])[:-1] sb_arr = np.array(f['sb'])[:-1] sb_err = np.array(f['sb_err'])[:-1] npix = np.array(f['npix'])[:-1] nratio = np.array(f['nratio'])[:-1] idvx = npix < 1. sb_arr[idvx] = np.nan r_arr[idvx] = np.nan tmp_sb.append(sb_arr) tmp_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func(tmp_sb, tmp_r, band[ band_id ], N_bin)[4:] sb_lim_r = np.ones( len(tt_jk_R) ) * lim_R with h5py.File(jack_SB_file, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) f['lim_r'] = np.array(sb_lim_r) else: if id_Z0 == True: lim_SB_pros_func(J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, n_rbins, N_bin, S2N, band_id, edg_bins,) else: zref_lim_SB_adjust_func(J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, n_rbins, N_bin, S2N, z_ref, band_id, edg_bins,) # calculate the directly stacking result( 2D_img, pixel_count array, and rms file [if sub_rms is not None] ) order_id = np.arange(0, N_bin, 1) order_id = order_id.astype( np.int32 ) weit_aveg_img(order_id, sub_img, sub_pix_cont, jack_img, sum_weit_file = jack_cont_arr,) if sub_rms is not None: weit_aveg_img(order_id, sub_rms, sub_pix_cont, jack_rms_arr,) return
def tmp_SB_func( R_bins, N_bin, J_sub_img, J_sub_pix_cont, J_sub_sb, band_id, jack_sb, pixel, ): r_bins = R_bins for nn in range(N_bin): with h5py.File(J_sub_img % nn, 'r') as f: tmp_img = np.array(f['a']) with h5py.File(J_sub_pix_cont % nn, 'r') as f: tmp_cont = np.array(f['a']) xn, yn = np.int(tmp_img.shape[1] / 2), np.int(tmp_img.shape[0] / 2) Intns, Angl_r, Intns_err, npix, nratio = light_measure_Z0_weit( tmp_img, tmp_cont, pixel, xn, yn, r_bins) sb_arr, sb_err_arr = Intns, Intns_err r_arr = Angl_r with h5py.File(J_sub_sb % nn, 'w') as f: f['r'] = np.array(r_arr) f['sb'] = np.array(sb_arr) f['sb_err'] = np.array(sb_err_arr) f['nratio'] = np.array(nratio) f['npix'] = np.array(npix) ## final jackknife SB profile tmp_sb = [] tmp_r = [] for nn in range(N_bin): with h5py.File(J_sub_sb % nn, 'r') as f: r_arr = np.array(f['r'])[:-1] sb_arr = np.array(f['sb'])[:-1] sb_err = np.array(f['sb_err'])[:-1] npix = np.array(f['npix'])[:-1] nratio = np.array(f['nratio'])[:-1] idvx = npix < 1. sb_arr[idvx] = np.nan r_arr[idvx] = np.nan tmp_sb.append(sb_arr) tmp_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func(tmp_sb, tmp_r, band[band_id], N_bin)[4:] sb_lim_r = np.ones(len(tt_jk_R)) * lim_R with h5py.File(jack_sb, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) f['lim_r'] = np.array(sb_lim_r) return
def sat_BG_fast_stack_func(bcg_ra, bcg_dec, bcg_z, sat_ra, sat_dec, img_x, img_y, img_file, band_str, id_cen, N_bin, n_rbins, sub_img, sub_pix_cont, sub_sb, J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, jack_img, jack_cont_arr, rank, id_cut=False, N_edg=None, id_Z0=True, z_ref=None, id_S2N=False, S2N=None, edg_bins=None, id_sub=True, sub_rms=None, J_sub_rms=None, jack_rms_arr=None, weit_img=None): """ combining jackknife stacking process, and save : sub-sample (sub-jack-sample) stacking image, pixel conunt array, surface brightness profiles id_cen : 0 - stacking by centering on BCGs, 1 - stacking by centering on img center N_bin : number of jackknife sample n_rbins : the number of radius bins (int type) cat_ra, cat_dec, cat_z : catalog information about the stacking sample, ra, dec, z sat_ra, sat_dec : satellites' location img_x, img_y : satellites position (in image coordinate) img_file : img-data name (include file-name structure:'/xxx/xxx/xxx.xxx') band_str : the band of imgs, 'str' type sub_img, sub_pix_cont, sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of individual sub-sample img stacking result J_sub_img, J_sub_pix_cont, J_sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of jackknife sub-sample img stacking result jack_SB_file : file name of the final jackknife stacking SB profile ('/xxx/xxx/xxx.xxx') jack_img : mean of the jackknife stacking img ('/xxx/xxx/xxx.xxx') jack_cont_arr : mean of the pixel count array ('/xxx/xxx/xxx.xxx') id_cut : id_cut == True, cut img edge pixels before stacking, id_cut == False, just stacking original size imgs N_edg : the cut region width, in unit of pixel, only applied when id_cut == True, pixels in this region will be set as 'no flux' contribution pixels (ie. set as np.nan) id_Z0 : stacking imgs on observation coordinate (id_Z0 = True, and reference redshift is z_ref) or not (id_Z0 = False, give radius in physical unit, kpc), default is True id_S2N, S2N : if set S/N limitation for SB profile measure or not, Default is False (no limitation applied). if id_S2N = True, then measure the SB profile, and in region where S/N is lower than S2N with be treated as only one radius bins (edg_bins = None), (or measured according edg_bins.) id_sub : measure and save the SB profiles for sub-samples of not, default is True sub_rms, J_sub_rms : pixel standard deviation of stacking images (for sub-sample and jackknife sub-sample) jack_rms_file : the final rms_file (total sample imgs stacking result) --------------------------- weit_img : array use to apply weight to each stacked image (can be the masekd image after resampling), default is array has value of 1 only. """ from img_sat_BG_jack_stack import weit_aveg_img from img_sat_BG_jack_stack import SB_pros_func from img_sat_BG_jack_stack import aveg_stack_img from img_sat_BG_stack import cut_stack_func, stack_func zN = len(bcg_z) id_arr = np.arange(0, zN, 1) id_group = id_arr % N_bin for nn in range(rank, rank + 1): id_xbin = np.where(id_group == nn)[0] set_z = bcg_z[id_xbin] set_ra = bcg_ra[id_xbin] set_dec = bcg_dec[id_xbin] set_s_ra = sat_ra[id_xbin] set_s_dec = sat_dec[id_xbin] set_x = img_x[id_xbin] set_y = img_y[id_xbin] sub_img_file = sub_img % nn sub_cont_file = sub_pix_cont % nn if sub_rms is not None: sub_rms_file = sub_rms % nn else: sub_rms_file = None if id_cut == False: stack_func(img_file, sub_img_file, set_z, set_ra, set_dec, band_str, set_s_ra, set_s_dec, set_x, set_y, id_cen, rms_file=sub_rms_file, pix_con_file=sub_cont_file, weit_img=weit_img) if id_cut == True: cut_stack_func(img_file, sub_img_file, set_z, set_ra, set_dec, band_str, set_s_ra, set_s_dec, set_x, set_y, id_cen, N_edg, rms_file=sub_rms_file, pix_con_file=sub_cont_file, weit_img=weit_img) commd.Barrier() for nn in range(rank, rank + 1): id_arry = np.linspace(0, N_bin - 1, N_bin) id_arry = id_arry.astype(int) jack_id = list(id_arry) jack_id.remove(jack_id[nn]) jack_id = np.array(jack_id) jack_img_file = J_sub_img % nn jack_cont_file = J_sub_pix_cont % nn weit_aveg_img( jack_id, sub_img, sub_pix_cont, jack_img_file, sum_weit_file=jack_cont_file, ) if sub_rms is not None: jack_rms_file = J_sub_rms % nn weit_aveg_img( jack_id, sub_rms, sub_pix_cont, jack_rms_file, ) commd.Barrier() if rank == 0: ## SB measurement if id_sub == True: ## sub-samples SB_pros_func(sub_img, sub_pix_cont, sub_sb, N_bin, n_rbins, id_Z0, z_ref) if id_S2N == False: ## jackknife sub-samples SB_pros_func(J_sub_img, J_sub_pix_cont, J_sub_sb, N_bin, n_rbins, id_Z0, z_ref) ## final jackknife SB profile tmp_sb = [] tmp_r = [] for nn in range(N_bin): with h5py.File(J_sub_sb % nn, 'r') as f: r_arr = np.array(f['r'])[:-1] sb_arr = np.array(f['sb'])[:-1] sb_err = np.array(f['sb_err'])[:-1] npix = np.array(f['npix'])[:-1] nratio = np.array(f['nratio'])[:-1] idvx = npix < 1. sb_arr[idvx] = np.nan r_arr[idvx] = np.nan tmp_sb.append(sb_arr) tmp_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func( tmp_sb, tmp_r, band_str, N_bin)[4:] sb_lim_r = np.ones(len(tt_jk_R)) * lim_R with h5py.File(jack_SB_file, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) f['lim_r'] = np.array(sb_lim_r) else: if id_Z0 == True: lim_SB_pros_func( J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, n_rbins, N_bin, S2N, band_str, edg_bins, ) else: zref_lim_SB_adjust_func( J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, n_rbins, N_bin, S2N, z_ref, band_str, edg_bins, ) # calculate the directly stacking result( 2D_img, pixel_count array, and rms file [if sub_rms is not None] ) order_id = np.arange(0, N_bin, 1) order_id = order_id.astype(np.int32) weit_aveg_img( order_id, sub_img, sub_pix_cont, jack_img, sum_weit_file=jack_cont_arr, ) if sub_rms is not None: weit_aveg_img(order_id, sub_rms, sub_pix_cont, jack_rms_arr) print('%d-rank, Done!' % rank) return
def sky_jack_main_func( id_cen, N_bin, n_rbins, cat_ra, cat_dec, cat_z, img_x, img_y, img_file, band_str, sub_img, sub_pix_cont, sub_sb, J_sub_img, J_sub_pix_cont, J_sub_sb, jack_SB_file, jack_img, jack_cont_arr, id_mean=0, id_cut=False, N_edg=None, id_Z0=True, z_ref=None, id_sub=True, sub_rms=None, J_sub_rms=None, jack_rms_arr=None, ): """ combining jackknife stacking process, and save : sub-sample (sub-jack-sample) stacking image, pixel conunt array, surface brightness profiles id_cen : 0 - stacking by centering on BCGs, 1 - stacking by centering on img center, 2 - stacking by random center N_bin : number of jackknife sample n_rbins : the number of radius bins (int type) cat_ra, cat_dec, cat_z : catalog information about the stacking sample, ra, dec, z img_x, img_y : BCG position (in image coordinate) img_file : img-data name (include file-name structure:'/xxx/xxx/xxx.xxx') band_str : the band of imgs, 'str' type sub_img, sub_pix_cont, sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of individual sub-sample img stacking result J_sub_img, J_sub_pix_cont, J_sub_sb (stacking img, pixel counts array, SB profile): file name (including patch and file name: '/xxx/xxx/xxx.xxx') of jackknife sub-sample img stacking result jack_SB_file : file name of the final jackknife stacking SB profile ('/xxx/xxx/xxx.xxx') jack_img : mean of the jackknife stacking img ('/xxx/xxx/xxx.xxx') jack_cont_arr : mean of the pixel count array ('/xxx/xxx/xxx.xxx') id_cut : id_cut == True, cut img edge pixels before stacking, id_cut == False, just stacking original size imgs N_edg : the cut region width, in unit of pixel, only applied when id_cut == True, pixels in this region will be set as 'no flux' contribution pixels (ie. set as np.nan) id_Z0 : stacking imgs on observation coordinate (id_Z0 = True) or not (id_Z0 = False, give radius in physical unit, kpc), default is True z_ref : reference redshift, (used when id_Z0 = False,) stacking imgs at z_ref. id_sub : if measure the individual sub-samples profile( id_sub = True), or not (id_sub = False) id_mean : 0, 1, 2. 0 - img_add = img; 1 - img_add = img - np.mean(img); 2 - img_add = img - np.median(img); Default is id_mean = 0 sub_rms, J_sub_rms : pixel standard deviation of stacking images (for sub-sample and jackknife sub-sample) jack_rms_file : the final rms_file (total sample imgs stacking result) """ zN = len(cat_z) id_arr = np.arange(0, zN, 1) id_group = id_arr % N_bin lis_ra, lis_dec, lis_z = [], [], [] lis_x, lis_y = [], [] for nn in range(N_bin): id_xbin = np.where(id_group == nn)[0] lis_ra.append(cat_ra[id_xbin]) lis_dec.append(cat_dec[id_xbin]) lis_z.append(cat_z[id_xbin]) lis_x.append(img_x[id_xbin]) lis_y.append(img_y[id_xbin]) ## img stacking for nn in range(N_bin): set_z = lis_z[nn] set_ra = lis_ra[nn] set_dec = lis_dec[nn] set_x = lis_x[nn] set_y = lis_y[nn] sub_img_file = sub_img % nn sub_cont_file = sub_pix_cont % nn if sub_rms is not None: sub_rms_file = sub_rms % nn else: sub_rms_file = None if id_cut == False: stack_func( img_file, sub_img_file, set_z, set_ra, set_dec, band_str, set_x, set_y, id_cen, rms_file=sub_rms_file, pix_con_file=sub_cont_file, id_mean=id_mean, ) if id_cut == True: cut_stack_func( img_file, sub_img_file, set_z, set_ra, set_dec, band_str, set_x, set_y, id_cen, N_edg, rms_file=sub_rms_file, pix_con_file=sub_cont_file, id_mean=id_mean, ) for nn in range(N_bin): id_arry = np.linspace(0, N_bin - 1, N_bin) id_arry = id_arry.astype(int) jack_id = list(id_arry) jack_id.remove(jack_id[nn]) jack_id = np.array(jack_id) jack_img_file = J_sub_img % nn jack_cont_file = J_sub_pix_cont % nn weit_aveg_img( jack_id, sub_img, sub_pix_cont, jack_img_file, sum_weit_file=jack_cont_file, ) if sub_rms is not None: jack_rms_file = J_sub_rms % nn weit_aveg_img( jack_id, sub_rms, sub_pix_cont, jack_rms_file, ) ## SB measurement if id_sub == True: ## sub-samples SB_pros_func(sub_img, sub_pix_cont, sub_sb, N_bin, n_rbins, id_Z0, z_ref) ## jackknife sub-samples SB_pros_func(J_sub_img, J_sub_pix_cont, J_sub_sb, N_bin, n_rbins, id_Z0, z_ref) ## final jackknife SB profile tmp_sb = [] tmp_r = [] for nn in range(N_bin): with h5py.File(J_sub_sb % nn, 'r') as f: r_arr = np.array(f['r'])[:-1] sb_arr = np.array(f['sb'])[:-1] sb_err = np.array(f['sb_err'])[:-1] npix = np.array(f['npix'])[:-1] nratio = np.array(f['nratio'])[:-1] idvx = npix < 1. sb_arr[idvx] = np.nan r_arr[idvx] = np.nan tmp_sb.append(sb_arr) tmp_r.append(r_arr) ## only save the sb result in unit " nanomaggies / arcsec^2 " tt_jk_R, tt_jk_SB, tt_jk_err, lim_R = jack_SB_func(tmp_sb, tmp_r, band_str, N_bin)[4:] sb_lim_r = np.ones(len(tt_jk_R)) * lim_R with h5py.File(jack_SB_file, 'w') as f: f['r'] = np.array(tt_jk_R) f['sb'] = np.array(tt_jk_SB) f['sb_err'] = np.array(tt_jk_err) f['lim_r'] = np.array(sb_lim_r) # calculate the directly stacking result( 2D_img, pixel_count array, and rms file [if sub_rms is not None] ) order_id = np.arange(0, N_bin, 1) order_id = order_id.astype(np.int32) weit_aveg_img( order_id, sub_img, sub_pix_cont, jack_img, sum_weit_file=jack_cont_arr, ) if sub_rms is not None: weit_aveg_img( order_id, sub_rms, sub_pix_cont, jack_rms_arr, ) return