def gammat(self, lens, sources, lens_bin_idx):
'''calculate tangential shear correlation'''
lens_corr = self.io.df_to_corr(lens, shears=False)
source_corr = self.io.df_to_corr(sources, shears=True)
rand = self.io.read_randoms(self.io.path_dict['random_prefix'] +
'_{}.hdf'.format(lens_bin_idx))
corr_kwargs = {
'min_sep': 3,
'max_sep': 90,
'nbins': 12,
'sep_units': 'arcmin'
}
#now make correlation functions
GGL = treecorr.NGCorrelation(**corr_kwargs)
GGL.process(lens_corr, source_corr)
# calculate random signal
GGL_rand = treecorr.NGCorrelation(**corr_kwargs)
GGL_rand.process(rand, source_corr)
return {
'xi+': GGL.xi - GGL_rand.xi,
'xi-': GGL.xi_im,
'r': np.exp(GGL.meanlogr),
'sig': np.sqrt(GGL.varxi)
}
def xshear_lens_jk(jk_label):
source_jk_mask = labels_source_jk == jk_label
source_mask = (source_z>0.1)&(source_z<0.3)
source_mask = (~source_jk_mask)&(source_mask)
source_cat=treecorr.Catalog(x=source_ra[source_mask],y=source_dec[source_mask],g1=source_e1[source_mask],g2=-1.*source_e2[source_mask],w=source_w[source_mask],x_units='degree',y_units='degree')
mask_z_lens = (lens_z_jk>0.5)&(lens_z_jk<0.7)
lens_mask = labels_lens_jk == jk_label
lens_mask = (~lens_mask)&(mask_z_lens)
lens_cat = treecorr.Catalog(x=lens_ra_jk[lens_mask], y=lens_dec_jk[lens_mask], x_units='degree', y_units='degree')
ng = treecorr.NGCorrelation(nbins = 20, min_sep=0.5, max_sep=250, sep_units='arcmin', verbose=1)
ng.process(lens_cat, source_cat)
r_lens_h, xt_lens_h, xx_lens_h , w_lens_h = ng.meanr , ng.xi , ng.xi_im, ng.npairs
w_lens_h = w_lens_h / np.sum(w_lens_h)
#print "lens", xt_lens_h
random_mask = labels_random_jk == jk_label
random_cat = treecorr.Catalog(x=random_ra_jk[~random_mask], y=random_dec_jk[~random_mask], x_units='degree', y_units='degree')
ng = treecorr.NGCorrelation(nbins = 20, min_sep=0.5, max_sep=250, sep_units='arcmin', verbose=1)
ng.process(random_cat, source_cat)
r_rand_h, xt_rand_h, xx_rand_h , w_rand_h = ng.meanr , ng.xi, ng.xi_im, ng.npairs
w_rand_h = w_rand_h / np.sum(w_rand_h)
#print "random", xt_rand_h
return r_lens_h, xt_lens_h, xx_lens_h , w_lens_h, r_rand_h, xt_rand_h, xx_rand_h , w_rand_h
def calculate_shear_pos(self, data, i, j):
import treecorr
cat_i = self.get_shear_catalog(data, i)
n_i = cat_i.nobj
cat_j, rancat_j = self.get_lens_catalog(data, j)
n_j = cat_j.nobj
n_rand_j = rancat_j.nobj if rancat_j is not None else 0
print(
f"Rank {self.rank} calculating shear-position bin pair ({i},{j}): {n_i} x {n_j} objects, {n_rand_j} randoms"
)
ng = treecorr.NGCorrelation(self.config)
ng.process(cat_j, cat_i)
if rancat_j:
rg = treecorr.NGCorrelation(self.config)
rg.process(rancat_j, cat_i)
else:
rg = None
gammat, gammat_im, gammaterr = ng.calculateXi(rg=rg)
theta = np.exp(ng.meanlogr)
gammaterr = np.sqrt(gammaterr)
return theta, gammat, gammaterr, ng.npairs, ng.weight
def calc_pos_shear(self,i,j,verbose,num_threads):
mask = self.lens_binning==i
lenscat_i = treecorr.Catalog(w=self.lensweight[mask], ra=self.lens['ra'][mask], dec=self.lens['dec'][mask], ra_units='deg', dec_units='deg')
mask = self.ran_binning==i
rancat_i = treecorr.Catalog(w=np.ones(np.sum(mask)), ra=self.randoms['ra'][mask], dec=self.randoms['dec'][mask], ra_units='deg', dec_units='deg')
m1,m2,mask = self.get_m(j)
if self.params['has_sheared']:
cat_j = treecorr.Catalog(g1=self.shape['e1'][mask]/m1[mask], g2=self.shape['e2'][mask]/m2[mask], w=self.weight[mask], ra=self.shape['ra'][mask], dec=self.shape['dec'][mask], ra_units='deg', dec_units='deg')
else:
cat_j = treecorr.Catalog(g1=self.shape['e1'][mask], g2=self.shape['e2'][mask], w=self.weight[mask], ra=self.shape['ra'][mask], dec=self.shape['dec'][mask], ra_units='deg', dec_units='deg')
biascat_j = treecorr.Catalog(k=np.sqrt(self.shape['m1'][mask]*self.shape['m2'][mask]), w=self.weight[mask], ra=self.shape['ra'][mask], dec=self.shape['dec'][mask], ra_units='deg', dec_units='deg')
ng = treecorr.NGCorrelation(nbins=self.params['tbins'], min_sep=self.params['tbounds'][0], max_sep=self.params['tbounds'][1], sep_units='arcmin', bin_slop=self.params['slop'], verbose=verbose,num_threads=num_threads)
rg = treecorr.NGCorrelation(nbins=self.params['tbins'], min_sep=self.params['tbounds'][0], max_sep=self.params['tbounds'][1], sep_units='arcmin', bin_slop=self.params['slop'], verbose=verbose,num_threads=num_threads)
if self.params['has_sheared']:
norm = 1.
else:
nk = treecorr.NKCorrelation(nbins=self.params['tbins'], min_sep=self.params['tbounds'][0], max_sep=self.params['tbounds'][1], sep_units='arcmin', bin_slop=self.params['slop'], verbose=verbose,num_threads=num_threads)
nk.process(lenscat_i,biascat_j)
norm,tmp=nk.calculateXi()
ng.process(lenscat_i,cat_j)
rg.process(rancat_i,cat_j)
gammat,gammat_im,gammaterr=ng.calculateXi(rg)
theta=np.exp(ng.meanlogr)
if np.sum(norm)==0:
norm=1.
gammat/=norm
gammat_im/=norm
gammaterr=np.sqrt(gammaterr/norm)
return theta, gammat, gammaterr
def test_contiguous():
# This unit test comes from Melanie Simet who discovered a bug in earlier
# versions of the code that the Catalog didn't correctly handle input arrays
# that were not contiguous in memory. We want to make sure this kind of
# input works correctly. It also checks that the input dtype doesn't have
# to be float
source_data = numpy.array([
(0.0380569697547, 0.0142782758818, 0.330845443464, -0.111049332655),
(-0.0261291090735, 0.0863787933931, 0.122954685209, 0.40260430406),
(-0.0261291090735, 0.0863787933931, 0.122954685209, 0.40260430406),
(0.125086697534, 0.0283621046495, -0.208159531309, 0.142491564101),
(0.0457709426026, -0.0299249486373, -0.0406555089425, 0.24515956887),
(-0.00338578248926, 0.0460291122935, 0.363057738173, -0.524536297555)],
dtype=[('ra', None), ('dec', numpy.float64), ('g1', numpy.float32),
('g2', numpy.float128)])
config = {'min_sep': 0.05, 'max_sep': 0.2, 'sep_units': 'degrees', 'nbins': 5 }
cat1 = treecorr.Catalog(ra=[0], dec=[0], ra_units='deg', dec_units='deg') # dumb lens
cat2 = treecorr.Catalog(ra=source_data['ra'], ra_units='deg',
dec=source_data['dec'], dec_units='deg',
g1=source_data['g1'],
g2=source_data['g2'])
cat2_float = treecorr.Catalog(ra=source_data['ra'].astype(float), ra_units='deg',
dec=source_data['dec'].astype(float), dec_units='deg',
g1=source_data['g1'].astype(float),
g2=source_data['g2'].astype(float))
print("dtypes of original arrays: ", [source_data[key].dtype for key in ['ra','dec','g1','g2']])
print("dtypes of cat2 arrays: ", [getattr(cat2,key).dtype for key in ['ra','dec','g1','g2']])
print("is original g2 array contiguous?", source_data['g2'].flags['C_CONTIGUOUS'])
print("is cat2.g2 array contiguous?", cat2.g2.flags['C_CONTIGUOUS'])
assert not source_data['g2'].flags['C_CONTIGUOUS']
assert cat2.g2.flags['C_CONTIGUOUS']
ng = treecorr.NGCorrelation(config)
ng.process(cat1,cat2)
ng_float = treecorr.NGCorrelation(config)
ng_float.process(cat1,cat2_float)
numpy.testing.assert_equal(ng.xi, ng_float.xi)
# While we're at it, check that non-1d inputs work, but emit a warning.
if __name__ == '__main__':
v = 1
else:
v = 0
cat2_non1d = treecorr.Catalog(ra=source_data['ra'].reshape(3,2), ra_units='deg',
dec=source_data['dec'].reshape(1,1,1,6), dec_units='deg',
g1=source_data['g1'].reshape(6,1),
g2=source_data['g2'].reshape(1,6), verbose=v)
ng.process(cat1,cat2_non1d)
numpy.testing.assert_equal(ng.xi, ng_float.xi)
def xshear_lens_jk(zl1, zl2, jk_label):
source_file = h5py.File("source_zb_" + str(zl2 + 0.1) + "_0.9.h5")
source_ra = source_file["ra"][:]
source_dec = source_file["dec"][:]
source_z = source_file["zb"][:]
source_e1 = source_file["psf1"][:]
source_e2 = source_file["psf2"][:]
source_w = source_file["w"][:]
source_size = source_file["snr"][:]
source_file.close()
source_cat = treecorr.Catalog(x=source_ra,
y=source_dec,
g1=source_e1,
g2=-1. * source_e2,
w=source_w,
x_units='degree',
y_units='degree')
mask_z_lens = (lens_z_jk > zl1) & (lens_z_jk < zl2)
lens_mask = labels_lens_jk == jk_label
lens_mask = (~lens_mask) & (mask_z_lens)
lens_cat = treecorr.Catalog(x=lens_ra_jk[lens_mask],
y=lens_dec_jk[lens_mask],
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(source_cat, lens_cat)
r_lens_h, xt_lens_h = ng.meanr, ng.xi
random_mask = labels_random_jk == jk_label
random_cat = treecorr.Catalog(x=random_ra_jk[~random_mask],
y=random_dec_jk[~random_mask],
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(source_cat, random_cat)
r_rand_h, xt_rand_h = ng.meanr, ng.xi
return r_lens_h, xt_lens_h, r_rand_h, xt_rand_h
def compute_position_shear(self, i, j, cat1, cat2):
maski = (cat1.mask) & (self.p1 == i)
maskj = (cat2.mask) & (self.p2 == j)
# Initialised the catlogues
cat_i = treecorr.Catalog(ra=cat1.cols['ra'][maski],
dec=cat1.cols['dec'][maski],
ra_units='deg',
dec_units='deg')
rcat_i = treecorr.Catalog(ra=self.rcat1['ra'][maski],
dec=self.rcat1['dec'][maski],
ra_units='deg',
dec_units='deg')
namej_1, namej_2 = colnames[self.corrtype[1]]
cat_j = treecorr.Catalog(g1=cat2.cols[namej_1][maskj],
g2=cat2.cols[namej_2][maskj],
ra=cat2.cols['ra'][maskj],
dec=cat2.cols['dec'][maskj],
ra_units='deg',
dec_units='deg')
# Set up the correlation
ng = treecorr.NGCorrelation(nbins=cat1.info['tbins'],
min_sep=cat1.info['tmin'],
max_sep=cat1.info['tmax'],
sep_units='arcmin',
bin_slop=0.1,
verbose=True,
num_threads=1)
rg = treecorr.NGCorrelation(nbins=cat1.info['tbins'],
min_sep=cat1.info['tmin'],
max_sep=cat1.info['tmax'],
sep_units='arcmin',
bin_slop=0.1,
verbose=True,
num_threads=1)
# And process it
ng.process(cat_i, cat_j)
rg.process(rcat_i, cat_j)
gammat, gammat_im, gammaterr = ng.calculateXi(rg)
theta = np.exp(ng.meanlogr)
gammaterr = np.sqrt(gammaterr)
return theta, gammat, gammat_im, gammaterr, gammaterr
def pos_shear_corr(pos_lens,pos_source,shear_source,k_source=None,w_lense=None,w_source=None,same_cell=False,num_threads=0): nbins = 6 min_sep = 0.05 # 3 arcmin max_sep = 3.0 # 180 arcmin bin_size = (max_sep-min_sep)/nbins # roughly bin_slop = 0.05/bin_size # 0.1 -> 0.05 # 2pt_pipeline for des used bin_slop: 0.01 here: https://github.com/des-science/2pt_pipeline/blob/master/pipeline/twopt_pipeline.yaml logger = None ra_lens, dec_lens = pos_lens ra_source, dec_source = pos_source g1_source, g2_source = shear_source # foreground (lens) cat_lens = treecorr.Catalog(ra=ra_lens, dec=dec_lens, w=w_lense, ra_units='degrees', dec_units='degrees') # background (source) cat_source = treecorr.Catalog(ra=ra_source, dec=dec_source, w=w_source, g1=g1_source, g2=g2_source, k=k_source, ra_units='degrees', dec_units='degrees') ng = treecorr.NGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=bin_slop, sep_units='degrees', logger=logger) ng.process_cross(cat_lens,cat_source,num_threads=num_threads) # there's no process_auto for this object # one shear variance per pixel per source zbin varg = treecorr.calculateVarG(cat_source) if same_cell else np.nan return ng, varg
def test_pairwise():
# Test the same profile, but with the pairwise calcualtion:
nsource = 1000000
gamma0 = 0.05
r0 = 10.
L = 5. * r0
numpy.random.seed(8675309)
x = (numpy.random.random_sample(nsource)-0.5) * L
y = (numpy.random.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
gammat = gamma0 * numpy.exp(-0.5*r2/r0**2)
g1 = -gammat * (x**2-y**2)/r2
g2 = -gammat * (2.*x*y)/r2
dx = (numpy.random.random_sample(nsource)-0.5) * L
dx = (numpy.random.random_sample(nsource)-0.5) * L
lens_cat = treecorr.Catalog(x=dx, y=dx, x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=x+dx, y=y+dx, g1=g1, g2=g2, x_units='arcmin', y_units='arcmin')
ng = treecorr.NGCorrelation(bin_size=0.1, min_sep=1., max_sep=25., sep_units='arcmin',
verbose=1, pairwise=True)
ng.process(lens_cat, source_cat)
r = ng.meanr
true_gt = gamma0 * numpy.exp(-0.5*r**2/r0**2)
print('ng.xi = ',ng.xi)
print('ng.xi_im = ',ng.xi_im)
print('true_gammat = ',true_gt)
print('ratio = ',ng.xi / true_gt)
print('diff = ',ng.xi - true_gt)
print('max diff = ',max(abs(ng.xi - true_gt)))
# I don't really understand why this comes out slightly less accurate.
# I would have thought it would be slightly more accurate because it doesn't use the
# approximations intrinsic to the tree calculation.
assert max(abs(ng.xi - true_gt)) < 4.e-4
assert max(abs(ng.xi_im)) < 3.e-5
# Check that we get the same result using the corr2 executable:
if __name__ == '__main__':
lens_cat.write(os.path.join('data','ng_pairwise_lens.dat'))
source_cat.write(os.path.join('data','ng_pairwise_source.dat'))
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"ng_pairwise.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','ng_pairwise.out'),names=True)
print('ng.xi = ',ng.xi)
print('from corr2 output = ',corr2_output['gamT'])
print('ratio = ',corr2_output['gamT']/ng.xi)
print('diff = ',corr2_output['gamT']-ng.xi)
numpy.testing.assert_almost_equal(corr2_output['gamT']/ng.xi, 1., decimal=3)
print('xi_im from corr2 output = ',corr2_output['gamX'])
assert max(abs(corr2_output['gamX'])) < 3.e-5
def test_single():
# Use gamma_t(r) = gamma0 exp(-r^2/2r0^2) around a single lens
# i.e. gamma(r) = -gamma0 exp(-r^2/2r0^2) (x+iy)^2/r^2
nsource = 1000000
gamma0 = 0.05
r0 = 10.
L = 5. * r0
numpy.random.seed(8675309)
x = (numpy.random.random_sample(nsource)-0.5) * L
y = (numpy.random.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
gammat = gamma0 * numpy.exp(-0.5*r2/r0**2)
g1 = -gammat * (x**2-y**2)/r2
g2 = -gammat * (2.*x*y)/r2
lens_cat = treecorr.Catalog(x=[0], y=[0], x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=x, y=y, g1=g1, g2=g2, x_units='arcmin', y_units='arcmin')
ng = treecorr.NGCorrelation(bin_size=0.1, min_sep=1., max_sep=25., sep_units='arcmin',
verbose=1)
ng.process(lens_cat, source_cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ',ng.meanlogr - numpy.log(ng.meanr))
numpy.testing.assert_almost_equal(ng.meanlogr, numpy.log(ng.meanr), decimal=3)
r = ng.meanr
true_gt = gamma0 * numpy.exp(-0.5*r**2/r0**2)
print('ng.xi = ',ng.xi)
print('ng.xi_im = ',ng.xi_im)
print('true_gammat = ',true_gt)
print('ratio = ',ng.xi / true_gt)
print('diff = ',ng.xi - true_gt)
print('max diff = ',max(abs(ng.xi - true_gt)))
assert max(abs(ng.xi - true_gt)) < 4.e-4
assert max(abs(ng.xi_im)) < 3.e-5
# Check that we get the same result using the corr2 executable:
if __name__ == '__main__':
lens_cat.write(os.path.join('data','ng_single_lens.dat'))
source_cat.write(os.path.join('data','ng_single_source.dat'))
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"ng_single.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','ng_single.out'),names=True)
print('ng.xi = ',ng.xi)
print('from corr2 output = ',corr2_output['gamT'])
print('ratio = ',corr2_output['gamT']/ng.xi)
print('diff = ',corr2_output['gamT']-ng.xi)
numpy.testing.assert_almost_equal(corr2_output['gamT']/ng.xi, 1., decimal=3)
print('xi_im from corr2 output = ',corr2_output['gamX'])
assert max(abs(corr2_output['gamX'])) < 3.e-5
def cross_corr(gal, shear, random, config):
'''
measure the cross-correlation between a gal catalog and a shear catalog
'''
min_sep = config['min_sep']
max_sep = config['max_sep']
units = config['units']
nbins = config['nbins']
bin_slop = config['bin_slop']
gal_cat = treecorr.Catalog(ra = gal["RA"] , dec = gal["DEC"], ra_units='deg', dec_units='deg')
shear_cat = treecorr.Catalog(ra = shear["RA"] , dec = shear["DEC"], g1 = shear["gamma1"], g2 = -1.*shear["gamma2"], ra_units='deg', dec_units='deg')
ran_cat = treecorr.Catalog(ra = random["RA"] , dec = random["DEC"], ra_units='deg', dec_units='deg')
ng = treecorr.NGCorrelation(min_sep = min_sep, max_sep = max_sep, nbins = nbins, sep_units = units, bin_slop = bin_slop)
rg = treecorr.NGCorrelation(min_sep = min_sep, max_sep = max_sep, nbins = nbins, sep_units = units, bin_slop = bin_slop)
ng.process(gal_cat, shear_cat, num_threads = 60)
rg.process(ran_cat, shear_cat, num_threads = 60)
theta, xi_t , xi_x , w , npairs = ng.meanr, ng.xi, ng.xi_im, ng.weight, ng.npairs
theta_r, xi_tr , xi_xr , wr , npairs_r = rg.meanr, rg.xi, rg.xi_im, rg.weight, rg.npairs
return theta, xi_t, xi_x, npairs, xi_tr, xi_xr, npairs_r
def get_xi(map, window_norm, mask=None, Sim_jk=None):
self = Sim_jk
maps = {'galaxy': map[0]}
maps['shear'] = {0: map[1], 1: map[2]}
if mask is None:
mask = {}
mask['galaxy'] = maps['galaxy'] == hp.UNSEEN
mask['shear'] = maps['shear'][0] == hp.UNSEEN
tree_cat_args = get_treecorr_cat_args(maps, masks=mask, nside=Sim_jk.nside)
tree_cat = {}
tree_cat['galaxy'] = treecorr.Catalog(w=maps['galaxy'][~mask['galaxy']],
**tree_cat_args['galaxy'])
tree_cat['shear'] = treecorr.Catalog(g1=maps['shear'][0][~mask['shear']],
g2=maps['shear'][1][~mask['shear']],
**tree_cat_args['shear'])
del mask
ndim = 3 #FIXME
xi = np.zeros(self.n_th_bins * (self.ndim + 1))
th_i = 0
tree_corrs = {}
n_th_bins = self.n_th_bins
for corr in self.kappa_class.corrs: #note that in treecorr npairs includes pairs with 0 weights. That affects this calc
if corr == corr_ggl:
tree_corrs[corr] = treecorr.NGCorrelation(**corr_config)
tree_corrs[corr].process(tree_cat['galaxy'], tree_cat['shear'])
xi[th_i:th_i + n_th_bins] = tree_corrs[corr].xi * tree_corrs[
corr].weight / window_norm[corr][
'weight'] * -1 #sign convention
#
th_i += self.n_th_bins
if corr == corr_ll:
tree_corrs[corr] = treecorr.GGCorrelation(**corr_config)
tree_corrs[corr].process(tree_cat['shear'])
xi[th_i:th_i + n_th_bins] = tree_corrs[
corr].xip #*tree_corrs[corr].npairs/window_norm[corr]['weight']
th_i += n_th_bins
xi[th_i:th_i + n_th_bins] = tree_corrs[
corr].xim #*tree_corrs[corr].npairs/window_norm[corr]['weight']
th_i += n_th_bins
if corr == corr_gg:
tree_corrs[corr] = treecorr.NNCorrelation(**corr_config)
tree_corrs[corr].process(tree_cat['galaxy'])
xi[th_i:th_i + n_th_bins] = tree_corrs[corr].weight / tree_corrs[
corr].npairs #window_norm[corr]['weight'] #
# xi[th_i:th_i+n_th_bins]=tree_corrs[corr].weight/window_norm[corr]
th_i += n_th_bins
# del tree_cat,tree_corrs
# gc.collect()
return xi
def compute_SingleMock_SinglePair_NGCorrelation(cat_j, bin_i, bin_j, config):
cat_i_name = '/home/hcamacho/lens_s1_z' + str(bin_i + 1) + '_c1.fits'
cat_i = treecorr.Catalog(cat_i_name, config)
ng = treecorr.NGCorrelation(config)
ng.process(cat_i, cat_j, num_threads=ncpus)
data_name = '/home/anderson/3x2pt/ng_data/ng_s1_z' + str(bin_i + 1) + str(
bin_j + 1) + '_c1.dat'
ng.write(data_name)
ng.clear()
return
def compute_SinglePair_NGCorrelation(cat_j, bin_i, bin_j, config):
cat_i_name = input_dir + 'lens-cat_z'+str(bin_i+1)+'.fits'
cat_i = treecorr.Catalog(cat_i_name, config)
ng = treecorr.NGCorrelation(config)
ng.process(cat_i, cat_j, num_threads=ncpus)
data_name = output_dir + 'ng_data/ng_z'+str(bin_i+1)+str(bin_j+1)+'.dat'
ng.write(data_name)
ng.clear()
return
def xshear_lens_jk(zl1, zl2, jk_label):
mask_z_source = source_z>zl2+0.1
source_cat=treecorr.Catalog(x=source_ra[mask_z_source],y=source_dec[mask_z_source],g1=source_e1[mask_z_source],g2=-1.*source_e2[mask_z_source],w=source_w[mask_z_source],x_units='degree',y_units='degree')
mask_z_lens = (lens_z_jk>zl1)&(lens_z_jk<zl2)
lens_mask = labels_lens_jk == jk_label
lens_mask = (~lens_mask)&(mask_z_lens)
lens_cat = treecorr.Catalog(x=lens_ra_jk[lens_mask], y=lens_dec_jk[lens_mask], x_units='degree', y_units='degree')
ng = treecorr.NGCorrelation(nbins = 25, min_sep=0.3, max_sep=300, sep_units='arcmin', verbose=1)
ng.process(lens_cat, source_cat)
r_lens_h, xt_lens_h = ng.meanr , ng.xi
random_mask = labels_random_jk == jk_label
random_cat = treecorr.Catalog(x=random_ra_jk[~random_mask], y=random_dec_jk[~random_mask], x_units='degree', y_units='degree')
ng = treecorr.NGCorrelation(nbins = 25, min_sep=0.3, max_sep=300, sep_units='arcmin', verbose=1)
ng.process(random_cat, source_cat)
r_rand_h, xt_rand_h = ng.meanr , ng.xi
return r_lens_h, xt_lens_h, r_rand_h, xt_rand_h
def getRandomGGL(source_table, n_resample=100):
'''use a catalog of randoms as lens objects
'''
#read in the randoms and make a master table
fields = ('F1', 'F2', 'F3', 'F4', 'F5')
random_tables = [ascii.read(f + 'randoms.csv') for f in fields]
master_randoms = vstack(random_tables)
#the randoms are ~6 times bigger than the lens catalogs
master_randoms = master_randoms[::6]
gammat_list = []
gammax_list = []
r_list = []
lens_tab_size = len(master_randoms)
src_tab_size = len(source_table)
#calibrate the shear bias
source_table = shearBias(source_table)
for i in range(0, n_resample):
#make new catalogs by resampling input lens and src
lens_resamp_idx = np.random.randint(0, lens_tab_size, lens_tab_size)
src_resamp_idx = np.random.randint(0, src_tab_size, src_tab_size)
random_cat = treecorr.Catalog(
ra=master_randoms[lens_resamp_idx]['ra'].data,
dec=master_randoms[lens_resamp_idx]['dec'].data,
ra_units='radians',
dec_units='radians')
source_corr = astpyToCorr(source_table[src_resamp_idx])
#now make correlation functions
GGL = treecorr.NGCorrelation(min_sep=0.1,
max_sep=90,
nbins=10,
sep_units='arcmin')
GGL.process(random_cat, source_corr)
gammat_list.append(GGL.xi)
gammax_list.append(GGL.xi_im)
r_list.append(np.exp(GGL.meanlogr))
return {'gammat': gammat_list, "gammax": gammax_list, "r": r_list}
def test_add_precompute_results_treecorr():
try:
import treecorr
except ImportError:
warnings.warn('TreeCorr is not installed. Skipping test.',
RuntimeWarning)
return 0
table_l, table_s = get_test_catalogs(1000, 10000)
theta_bins = np.logspace(0, 1, 11)
cat_l = treecorr.Catalog(ra=table_l['ra'],
dec=table_l['dec'],
ra_units='deg',
dec_units='deg')
cat_s = treecorr.Catalog(ra=table_s['ra'],
dec=table_s['dec'],
g1=table_s['e_1'],
g2=table_s['e_2'],
ra_units='deg',
dec_units='deg')
ng = treecorr.NGCorrelation(max_sep=np.amax(theta_bins),
min_sep=np.amin(theta_bins),
nbins=len(theta_bins) - 1,
sep_units='deg',
metric='Arc',
brute=True)
ng.process(cat_l, cat_s)
table_l = precompute.add_precompute_results(table_l,
table_s,
theta_bins,
shear_mode=True,
nside=32)
assert np.all(np.array(ng.npairs, dtype=int) == number_of_pairs(table_l))
assert np.all(
np.isclose(ng.xi, raw_tangential_shear(table_l), atol=1e-9, rtol=0))
def NGCorrelation(self):
"""
Caclulates 2D correlation function using Catalog's ra, dec.
Requires randcatalog to exist.
Returns tuple (logr, meanlogr, xi, xi_im, xivar)
"""
catN = treecorr.Catalog(ra=self.catalog["ra"], dec=self.catalog["dec"],
ra_units="radians", dec_units="radians", g1=self.catalog["g1"],
g2=self.catalog["g2"] )
dd=treecorr.NGCorrelation(min_sep=self.min_sep, bin_size=self.bin_size,
max_sep=self.max_sep, sep_units='arcmin')
dd.process(catN,catN)
logr = dd.logr
meanlogr = dd.logr
xi=dd.xi
xi_im=dd.xi_im
xivar=dd.varxi
return (logr, meanlogr, xi, xi_im, xivar)
def CorProcess(catN,
catG,
sightBins,
nbins,
min_sep,
max_sep,
rpar_step,
rpar_min,
logfile,
which_corr='NG',
RR=False):
#print('test corProcess',file=logfile)
corList = list()
pairCounts = np.zeros((sightBins, nbins))
wpairCounts = np.zeros((sightBins, nbins))
for i in np.arange(sightBins):
if which_corr == 'NG' and not RR:
corList.append(
treecorr.NGCorrelation(nbins=nbins,
min_sep=min_sep,
max_sep=max_sep,
min_rpar=i * rpar_step + rpar_min,
max_rpar=(i + 1) * rpar_step +
rpar_min)) #metric='Rperp'
if which_corr == 'NN' or RR:
#print('RR test', file=logfile)
corList.append(
treecorr.NNCorrelation(nbins=nbins,
min_sep=min_sep,
max_sep=max_sep,
min_rpar=i * rpar_step + rpar_min,
max_rpar=(i + 1) * rpar_step +
rpar_min)) #metric='Rperp'
corList[i].process(catN, catG, metric='Rperp')
pairCounts[i] = corList[i].npairs
wpairCounts[i] = corList[i].weight
return corList, pairCounts, wpairCounts
def getGGL(lens_table,
source_table,
n_resample=100,
swap_test=True,
cal_lens=True,
cal_source=True,
shape_cut=True):
"""
calculate galaxy galaxy lensing
parameters
lens_table: astropy table of lens galaxies. must have positions and shear specified
source_table: astropy table of source galaxies. must have positions and shear specified
n_resample: number of bootstrap resamplings to do. default is 100
swap_test: calculate the tangential shear swapping lens and souces
returns a dictionary containing the following:
gammat: tangential shear for each boostrap iterations. a list of n_resample
python arrays
gammax: tangential shear calculated after rotating sources 45 degrees
r: mean center of radial bins
gammat_flip: tangential shear calculated for swap test
gammax_flip: tangential shear calculated after rotating sources 45 degrees
calculated for the swap
r_flip: mean center of radial bins
nullGGL : galaxy galaxy lens treecorr object.
swap shear and lens planes and calculate tangential shear
nice null test for photo-zs
"""
lens_tab_size = len(lens_table)
gammat_list = []
gammax_list = []
r_list = []
#calibrate the shear bias for both tables
if cal_lens:
lens_table = shearBias(lens_table)
if shape_cut:
source_table = shapeCut(source_table)
if cal_source:
source_table = shearBias(source_table)
src_tab_size = len(source_table)
#each iteration in the loop is a bootstrap resample
for i in range(0, n_resample):
#make new catalogs by resampling input lens and src
lens_resamp_idx = np.random.randint(0, lens_tab_size, lens_tab_size)
lens_corr = astpyToCorr(lens_table[lens_resamp_idx])
src_resamp_idx = np.random.randint(0, src_tab_size, src_tab_size)
source_corr = astpyToCorr(source_table[src_resamp_idx])
#now make correlation functions
GGL = treecorr.NGCorrelation(min_sep=0.1,
max_sep=90,
nbins=10,
sep_units='arcmin')
GGL.process(lens_corr, source_corr)
gammat_list.append(GGL.xi)
gammax_list.append(GGL.xi_im)
r_list.append(np.exp(GGL.meanlogr))
#option to do a one off lens source swap
if swap_test == False:
return {"gammat": gammat_list, "gammax": gammax_list, "r": r_list}
else:
nullGGL = treecorr.NGCorrelation(min_sep=0.1,
max_sep=90,
nbins=10,
sep_units='arcmin')
nullGGL.process(source_corr, lens_corr)
return {
"gammat": gammat_list,
"gammax": gammax_list,
"r": r_list,
"gammat_flip": nullGGL.xi,
"r_flip": np.exp(nullGGL.meanlogr)
}
def corr2(config, logger=None):
"""Run the full two-point correlation function code based on the parameters in the
given config dict.
The function print_corr2_params() will output information about the valid parameters
that are expected to be in the config dict.
Optionally a logger parameter maybe given, in which case it is used for logging.
If not given, the logging will be based on the verbose and log_file parameters.
:param config: The configuration dict which defines what to do.
:param logger: If desired, a logger object for logging. (default: None, in which case
one will be built according to the config dict's verbose level.)
"""
# Setup logger based on config verbose value
if logger is None:
logger = treecorr.config.setup_logger(
treecorr.config.get(config,'verbose',int,1),
config.get('log_file',None))
# Check that config doesn't have any extra parameters.
# (Such values are probably typos.)
# Also convert the given parameters to the correct type, etc.
config = treecorr.config.check_config(config, corr2_valid_params, corr2_aliases, logger)
import pprint
logger.debug('Using configuration dict:\n%s',pprint.pformat(config))
if ( 'output_dots' not in config
and config.get('log_file',None) is None
and config['verbose'] >= 2 ):
config['output_dots'] = True
# Set the number of threads
num_threads = config.get('num_threads',None)
logger.debug('From config dict, num_threads = %s',num_threads)
treecorr.set_omp_threads(num_threads, logger)
# Read in the input files. Each of these is a list.
cat1 = treecorr.read_catalogs(config, 'file_name', 'file_list', 0, logger)
if len(cat1) == 0:
raise AttributeError("Either file_name or file_list is required")
cat2 = treecorr.read_catalogs(config, 'file_name2', 'file_list2', 1, logger)
rand1 = treecorr.read_catalogs(config, 'rand_file_name', 'rand_file_list', 0, logger)
rand2 = treecorr.read_catalogs(config, 'rand_file_name2', 'rand_file_list2', 1, logger)
if len(cat2) == 0 and len(rand2) > 0:
raise AttributeError("rand_file_name2 is invalid without file_name2")
logger.info("Done reading input catalogs")
# Do GG correlation function if necessary
if 'gg_file_name' in config or 'm2_file_name' in config:
logger.warning("Performing GG calculations...")
gg = treecorr.GGCorrelation(config,logger)
gg.process(cat1,cat2)
logger.info("Done GG calculations.")
if 'gg_file_name' in config:
gg.write(config['gg_file_name'])
logger.warning("Wrote GG correlation to %s",config['gg_file_name'])
if 'm2_file_name' in config:
gg.writeMapSq(config['m2_file_name'], m2_uform=config['m2_uform'])
logger.warning("Wrote Mapsq values to %s",config['m2_file_name'])
# Do NG correlation function if necessary
if 'ng_file_name' in config or 'nm_file_name' in config or 'norm_file_name' in config:
if len(cat2) == 0:
raise AttributeError("file_name2 is required for ng correlation")
logger.warning("Performing NG calculations...")
ng = treecorr.NGCorrelation(config,logger)
ng.process(cat1,cat2)
logger.info("Done NG calculation.")
# The default ng_statistic is compensated _iff_ rand files are given.
rg = None
if len(rand1) == 0:
if config.get('ng_statistic',None) == 'compensated':
raise AttributeError("rand_files is required for ng_statistic = compensated")
elif config.get('ng_statistic','compensated') == 'compensated':
rg = treecorr.NGCorrelation(config,logger)
rg.process(rand1,cat2)
logger.info("Done RG calculation.")
if 'ng_file_name' in config:
ng.write(config['ng_file_name'], rg)
logger.warning("Wrote NG correlation to %s",config['ng_file_name'])
if 'nm_file_name' in config:
ng.writeNMap(config['nm_file_name'], rg, m2_uform=config['m2_uform'])
logger.warning("Wrote NMap values to %s",config['nm_file_name'])
if 'norm_file_name' in config:
gg = treecorr.GGCorrelation(config,logger)
gg.process(cat2)
logger.info("Done GG calculation for norm")
dd = treecorr.NNCorrelation(config,logger)
dd.process(cat1)
logger.info("Done DD calculation for norm")
rr = treecorr.NNCorrelation(config,logger)
rr.process(rand1)
logger.info("Done RR calculation for norm")
dr = None
if config['nn_statistic'] == 'compensated':
dr = treecorr.NNCorrelation(config,logger)
dr.process(cat1,rand1)
logger.info("Done DR calculation for norm")
ng.writeNorm(config['norm_file_name'],gg,dd,rr,dr,rg,m2_uform=config['m2_uform'])
logger.warning("Wrote Norm values to %s",config['norm_file_name'])
# Do NN correlation function if necessary
if 'nn_file_name' in config:
if len(rand1) == 0:
raise AttributeError("rand_file_name is required for NN correlation")
if len(cat2) > 0 and len(rand2) == 0:
raise AttributeError("rand_file_name2 is required for NN cross-correlation")
logger.warning("Performing DD calculations...")
dd = treecorr.NNCorrelation(config,logger)
dd.process(cat1,cat2)
logger.info("Done DD calculations.")
dr = None
rd = None
if len(cat2) == 0:
logger.warning("Performing RR calculations...")
rr = treecorr.NNCorrelation(config,logger)
rr.process(rand1)
logger.info("Done RR calculations.")
if config['nn_statistic'] == 'compensated':
logger.warning("Performing DR calculations...")
dr = treecorr.NNCorrelation(config,logger)
dr.process(cat1,rand1)
logger.info("Done DR calculations.")
else:
logger.warning("Performing RR calculations...")
rr = treecorr.NNCorrelation(config,logger)
rr.process(rand1,rand2)
logger.info("Done RR calculations.")
if config['nn_statistic'] == 'compensated':
logger.warning("Performing DR calculations...")
dr = treecorr.NNCorrelation(config,logger)
dr.process(cat1,rand2)
logger.info("Done DR calculations.")
rd = treecorr.NNCorrelation(config,logger)
rd.process(rand1,cat2)
logger.info("Done RD calculations.")
dd.write(config['nn_file_name'],rr,dr,rd)
logger.warning("Wrote NN correlation to %s",config['nn_file_name'])
# Do KK correlation function if necessary
if 'kk_file_name' in config:
logger.warning("Performing KK calculations...")
kk = treecorr.KKCorrelation(config,logger)
kk.process(cat1,cat2)
logger.info("Done KK calculations.")
kk.write(config['kk_file_name'])
logger.warning("Wrote KK correlation to %s",config['kk_file_name'])
# Do NG correlation function if necessary
if 'nk_file_name' in config:
if len(cat2) == 0:
raise AttributeError("file_name2 is required for nk correlation")
logger.warning("Performing NK calculations...")
nk = treecorr.NKCorrelation(config,logger)
nk.process(cat1,cat2)
logger.info("Done NK calculation.")
rk = None
if len(rand1) == 0:
if config.get('nk_statistic',None) == 'compensated':
raise AttributeError("rand_files is required for nk_statistic = compensated")
elif config.get('nk_statistic','compensated') == 'compensated':
rk = treecorr.NKCorrelation(config,logger)
rk.process(rand1,cat2)
logger.info("Done RK calculation.")
nk.write(config['nk_file_name'], rk)
logger.warning("Wrote NK correlation to %s",config['nk_file_name'])
# Do KG correlation function if necessary
if 'kg_file_name' in config:
if len(cat2) == 0:
raise AttributeError("file_name2 is required for kg correlation")
logger.warning("Performing KG calculations...")
kg = treecorr.KGCorrelation(config,logger)
kg.process(cat1,cat2)
logger.info("Done KG calculation.")
kg.write(config['kg_file_name'])
logger.warning("Wrote KG correlation to %s",config['kg_file_name'])
logging.info(f"Calculating for NSIDE = {nside}")
rcscat = treecorr.Catalog("rcslens.fits", rcsconfig)
szcat = treecorr.Catalog(f"szmaps_masked{maskno}_{nside}.fits", szconfig)
m1cat = treecorr.Catalog("rcslens.fits", m1config)
kg = treecorr.KGCorrelation(corrconfig,logger=logging.getLogger())
kg.process(szcat, rcscat) # Calculate the cross-correlation
kg.write(f"crosscorr{maskno}_{nside}.result")
nk = treecorr.NKCorrelation(corrconfig,logger=logging.getLogger())
nk.process(szcat, m1cat)
nk.write(f"calib{maskno}_{nside}.result")
ny = treecorr.NKCorrelation(corrconfig,logger=logging.getLogger())
ny.process(rcscat, szcat)
ny.write(f"ycorr{maskno}_{nside}.result")
ng = treecorr.NGCorrelation(corrconfig,logger=logging.getLogger())
ng.process(rcscat, rcscat)
ng.write(f"shearcorr{maskno}_{nside}.result")
gg = treecorr.GGCorrelation(corrconfig,logger=logging.getLogger())
gg.process(rcscat, rcscat)
gg.write(f"shear_auto_corr{maskno}_{nside}.result")
kk = treecorr.KKCorrelation(corrconfig,logger=logging.getLogger())
kk.process(szcat, szcat)
kk.write(f"sz_auto_corr{maskno}_{nside}.result")
logging.info("DONE")
def test_rlens():
# Same as above, except use R_lens for separation.
# Use gamma_t(r) = gamma0 exp(-R^2/2R0^2) around a bunch of foreground lenses.
nlens = 100
nsource = 200000
gamma0 = 0.05
R0 = 10.
L = 50. * R0
numpy.random.seed(8675309)
xl = (numpy.random.random_sample(nlens)-0.5) * L # -250 < x < 250
zl = (numpy.random.random_sample(nlens)-0.5) * L # -250 < y < 250
yl = numpy.random.random_sample(nlens) * 4*L + 10*L # 5000 < z < 7000
rl = numpy.sqrt(xl**2 + yl**2 + zl**2)
xs = (numpy.random.random_sample(nsource)-0.5) * L
zs = (numpy.random.random_sample(nsource)-0.5) * L
ys = numpy.random.random_sample(nsource) * 8*L + 160*L # 80000 < z < 84000
rs = numpy.sqrt(xs**2 + ys**2 + zs**2)
g1 = numpy.zeros( (nsource,) )
g2 = numpy.zeros( (nsource,) )
bin_size = 0.1
# min_sep is set so the first bin doesn't have 0 pairs.
min_sep = 1.3*R0
# max_sep can't be too large, since the measured value starts to have shape noise for larger
# values of separation. We're not adding any shape noise directly, but the shear from other
# lenses is effectively a shape noise, and that comes to dominate the measurement above ~4R0.
max_sep = 4.*R0
nbins = int(numpy.ceil(numpy.log(max_sep/min_sep)/bin_size))
true_gt = numpy.zeros( (nbins,) )
true_npairs = numpy.zeros((nbins,), dtype=int)
print('Making shear vectors')
for x,y,z,r in zip(xl,yl,zl,rl):
# Use |r1 x r2| = |r1| |r2| sin(theta)
xcross = ys * z - zs * y
ycross = zs * x - xs * z
zcross = xs * y - ys * x
sintheta = numpy.sqrt(xcross**2 + ycross**2 + zcross**2) / (rs * r)
Rlens = 2. * r * numpy.sin(numpy.arcsin(sintheta)/2)
gammat = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
# For the rotation, approximate that the x,z coords are approx the perpendicular plane.
# So just normalize back to the unit sphere and do the 2d projection calculation.
# It's not exactly right, but it should be good enough for this unit test.
dx = xs/rs-x/r
dz = zs/rs-z/r
drsq = dx**2 + dz**2
g1 += -gammat * (dx**2-dz**2)/drsq
g2 += -gammat * (2.*dx*dz)/drsq
index = numpy.floor( numpy.log(Rlens/min_sep) / bin_size).astype(int)
mask = (index >= 0) & (index < nbins)
numpy.add.at(true_gt, index[mask], gammat[mask])
numpy.add.at(true_npairs, index[mask], 1)
true_gt /= true_npairs
# Start with bin_slop == 0. With only 100 lenses, this still runs very fast.
lens_cat = treecorr.Catalog(x=xl, y=yl, z=zl)
source_cat = treecorr.Catalog(x=xs, y=ys, z=zs, g1=g1, g2=g2)
ng0 = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0)
ng0.process(lens_cat, source_cat)
Rlens = ng0.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results with bin_slop = 0:')
print('ng.npairs = ',ng0.npairs)
print('true_npairs = ',true_npairs)
print('ng.xi = ',ng0.xi)
print('true_gammat = ',true_gt)
print('ratio = ',ng0.xi / true_gt)
print('diff = ',ng0.xi - true_gt)
print('max diff = ',max(abs(ng0.xi - true_gt)))
assert max(abs(ng0.xi - true_gt)) < 2.e-6
print('ng.xi_im = ',ng0.xi_im)
assert max(abs(ng0.xi_im)) < 1.e-6
print('ng.xi = ',ng0.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng0.xi / theory_gt)
print('diff = ',ng0.xi - theory_gt)
print('max diff = ',max(abs(ng0.xi - theory_gt)))
assert max(abs(ng0.xi - theory_gt)) < 4.e-5
# Now use a more normal value for bin_slop.
ng1 = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0.5)
ng1.process(lens_cat, source_cat)
Rlens = ng1.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results with bin_slop = 0.5')
print('ng.npairs = ',ng1.npairs)
print('ng.xi = ',ng1.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng1.xi / theory_gt)
print('diff = ',ng1.xi - theory_gt)
print('max diff = ',max(abs(ng1.xi - theory_gt)))
assert max(abs(ng1.xi - theory_gt)) < 5.e-5
print('ng.xi_im = ',ng1.xi_im)
assert max(abs(ng1.xi_im)) < 3.e-6
# Check that we get the same result using the corr2 executable:
if __name__ == '__main__':
lens_cat.write(os.path.join('data','ng_rlens_lens.dat'))
source_cat.write(os.path.join('data','ng_rlens_source.dat'))
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"ng_rlens.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','ng_rlens.out'),names=True)
print('ng.xi = ',ng1.xi)
print('from corr2 output = ',corr2_output['gamT'])
print('ratio = ',corr2_output['gamT']/ng1.xi)
print('diff = ',corr2_output['gamT']-ng1.xi)
numpy.testing.assert_almost_equal(corr2_output['gamT'], ng1.xi, decimal=6)
numpy.testing.assert_almost_equal(corr2_output['gamX'], ng1.xi_im, decimal=6)
# Repeat with the sources being given as RA/Dec only.
ral, decl = treecorr.CelestialCoord.xyz_to_radec(xl,yl,zl)
ras, decs = treecorr.CelestialCoord.xyz_to_radec(xs,ys,zs)
lens_cat = treecorr.Catalog(ra=ral, dec=decl, ra_units='radians', dec_units='radians', r=rl)
source_cat = treecorr.Catalog(ra=ras, dec=decs, ra_units='radians', dec_units='radians',
g1=g1, g2=g2)
# Again, start with bin_slop == 0.
# This version should be identical to the 3D version. When bin_slop != 0, it won't be
# exactly identical, since the tree construction will have different decisions along the
# way (since everything is at the same radius here), but the results are consistent.
ng0s = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0)
ng0s.process(lens_cat, source_cat)
Rlens = ng0s.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results when sources have no radius information, first bin_slop=0')
print('ng.npairs = ',ng0s.npairs)
print('true_npairs = ',true_npairs)
print('ng.xi = ',ng0s.xi)
print('true_gammat = ',true_gt)
print('ratio = ',ng0s.xi / true_gt)
print('diff = ',ng0s.xi - true_gt)
print('max diff = ',max(abs(ng0s.xi - true_gt)))
assert max(abs(ng0s.xi - true_gt)) < 2.e-6
print('ng.xi_im = ',ng0s.xi_im)
assert max(abs(ng0s.xi_im)) < 1.e-6
print('ng.xi = ',ng0s.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng0s.xi / theory_gt)
print('diff = ',ng0s.xi - theory_gt)
print('max diff = ',max(abs(ng0s.xi - theory_gt)))
assert max(abs(ng0s.xi - theory_gt)) < 4.e-5
assert max(abs(ng0s.xi - ng0.xi)) < 1.e-7
assert max(abs(ng0s.xi_im - ng0.xi_im)) < 1.e-7
assert max(abs(ng0s.npairs - ng0.npairs)) < 1.e-7
# Now use a more normal value for bin_slop.
ng1s = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0.5)
ng1s.process(lens_cat, source_cat)
Rlens = ng1s.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results with bin_slop = 0.5')
print('ng.npairs = ',ng1s.npairs)
print('ng.xi = ',ng1s.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng1s.xi / theory_gt)
print('diff = ',ng1s.xi - theory_gt)
print('max diff = ',max(abs(ng1s.xi - theory_gt)))
assert max(abs(ng1s.xi - theory_gt)) < 5.e-5
print('ng.xi_im = ',ng1s.xi_im)
assert max(abs(ng1s.xi_im)) < 3.e-6
def xi_2pt(cata,
catb=None,
k=None,
ga=None,
gb=None,
corr='GG',
maska=None,
maskb=None,
wa=None,
wb=None,
ran=True,
mock=False,
erron=True,
jkmask=None,
label0='',
plot=False):
"""
This is a flexible convenience wrapper for interaction with treecorr to work on CatalogStore objects. Some basic examples are given in corr_tests() of the main testsuite.py. g1, g2 correctly by c1, c2 if ellipticities and cat.bs is true. Correction by sensitivity, 1+m applied if cat.bs=True. Weighting applied if cat.wt is true. Other config properties for treecorr stored in CatalogStore object. See catalog.py or config.py. Not all correlation types fully integrated or tested. For example, only one kappa value is currently possible. Will be updated in future as useful.
Use:
:cata, catb: CatalogStore - Must supply both cata, catb (can be same reference) if NG or NK correlation. Otherwise catb is optional.
:k: str - Array name in cata, catb to use for kappa correlation.
:ga, gb: str - Array names for g1, g2 treecorr inputs. If None assume e1, e2.
:corr: str - Type of correlation for treecorr.
:maska, maskb: [bool] - Masking array to apply to input catalogs.
:wa, wb: [float] - Additional weights to apply after cat.w is used. Combined as e.g., w=sqrt(cat.w*wa).
:ran: bool - Use randoms in correlation calculation. If True, assumes cat.ran_ra, cat.ran_dec exist.
:mock: bool - If mock catalog from sims. Used when calculating covariances from sims, not currently migrated from SV code.
:erron: bool - Calculate jackknife or sim cov errors. If False, uses treecorr error outputs. Not currently migrated from SV code. When implemented requires cat.calc_err in ('jk', 'mock').
:jkmask: [bool] - For jk, mock cov calculation loop over regions/sims.
:label0: str - Additional (optional) label string used in some outputs.
:plot: bool - Plot output?
Output (len cat.tbins):
:theta: [float] - Treecorr np.exp(meanlogr)
:out: ([float]x4) - Output of signal e.g., (xi+,xi-,xi+im,x-im). For correlations with only one xi output, (xi,0.,xi_im,0.).
:err: ([float]x4) - Same but for sqrt(var).
:chi2: ([float]x4) - Same but for chi^2 if using jk or sim covariance.
"""
maska = catalog.CatalogMethods.check_mask(cata.coadd, maska)
jkmask = catalog.CatalogMethods.check_mask(cata.coadd, jkmask)
maska0 = maska & jkmask
if wa is None:
wa = np.ones(len(cata.coadd))
e1, e2, w, ms = lin.linear_methods.get_lin_e_w_ms(cata,
xi=True,
mock=mock,
mask=maska0,
w1=wa)
if catb is None:
if corr not in ['GG', 'NN', 'KK']:
raise UseError(
'Must supply both cata,catb for NG,NK correlations.')
if ga is not None:
e1 = getattr(cata, ga + '1')[maska]
e2 = getattr(cata, ga + '2')[maska]
else:
ga = 'e'
if catb is None:
gb = ga
if (corr == 'GG') | ((catb != None) & (corr == 'KG')):
catxa = treecorr.Catalog(g1=e1,
g2=e2,
w=w,
ra=cata.ra[maska0],
dec=cata.dec[maska0],
ra_units='deg',
dec_units='deg')
catma = treecorr.Catalog(k=ms,
w=w,
ra=cata.ra[maska0],
dec=cata.dec[maska0],
ra_units='deg',
dec_units='deg')
elif (corr == 'NN') | ((catb != None) & (corr in ['NG', 'NK'])):
catxa = treecorr.Catalog(w=w,
ra=cata.ra[maska0],
dec=cata.dec[maska0],
ra_units='deg',
dec_units='deg')
if ran:
catra = treecorr.Catalog(w=w,
ra=cata.ran_ra[maska0],
dec=cata.ran_dec[maska0],
ra_units='deg',
dec_units='deg')
elif corr == 'KK':
if k is None:
raise UseError('Must specify k for KK correlation.')
if k not in dir(cata):
raise UseError('Unknown k field specified.')
catxa = treecorr.Catalog(k=getattr(cata, k)[maska0],
w=w,
ra=cata.ra[maska0],
dec=cata.dec[maska0],
ra_units='deg',
dec_units='deg')
if catb is not None:
maskb = catalog.CatalogMethods.check_mask(catb.coadd, maskb)
if wb is None:
wb = np.ones(len(catb.coadd))
e1, e2, w, ms = lin.linear_methods.get_lin_e_w_ms(catb,
xi=True,
mock=mock,
mask=maskb,
w1=wb)
if gb is not None:
e1 = getattr(cata, gb + '1')[maskb]
e2 = getattr(cata, gb + '2')[maskb]
else:
gb = 'e'
if corr in ['GG', 'NG', 'KG']:
catxb = treecorr.Catalog(g1=e1,
g2=e2,
w=w,
ra=catb.ra[maskb],
dec=catb.dec[maskb],
ra_units='deg',
dec_units='deg')
catmb = treecorr.Catalog(k=ms,
w=w,
ra=catb.ra[maskb],
dec=catb.dec[maskb],
ra_units='deg',
dec_units='deg')
elif corr == 'NN':
catxb = treecorr.Catalog(w=w,
ra=catb.ra[maskb],
dec=catb.dec[maskb],
ra_units='deg',
dec_units='deg')
if ran:
catrb = treecorr.Catalog(w=w,
ra=catb.ran_ra[maskb],
dec=catb.ran_dec[maskb],
ra_units='deg',
dec_units='deg')
elif corr in ['KK', 'NK']:
if k is None:
raise UseError('Must specify k for KK correlation.')
if k not in dir(catb):
raise UseError('Unknown k field specified.')
catxb = treecorr.Catalog(k=getattr(catb, k)[maskb],
w=w,
ra=catb.ra[maskb],
dec=catb.dec[maskb],
ra_units='deg',
dec_units='deg')
xim = None
xip_im = None
xim_im = None
ximerr = None
xiperr_im = None
ximerr_im = None
if corr == 'GG':
gg = treecorr.GGCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
kk = treecorr.KKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
if catb is None:
gg.process(catxa)
kk.process(catma)
else:
gg.process(catxa, catxb)
kk.process(catma, catmb)
xip = gg.xip / kk.xi
xim = gg.xim / kk.xi
xiperr = ximerr = np.sqrt(gg.varxi)
xip_im = gg.xip_im / kk.xi
xim_im = gg.xim_im / kk.xi
theta = np.exp(gg.meanlogr)
elif corr == 'NN':
nn = treecorr.NNCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
if ran:
nr = treecorr.NNCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
rr = treecorr.NNCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
if catb is None:
nn.process(catxa)
xip = nn.npairs
xiperr = np.sqrt(nn.npairs)
if ran:
nr.process(catxa, catra)
rr.process(catra)
xip, xiperr = nn.calculateXi(rr, nr)
xiperr = np.sqrt(xiperr)
else:
rn = treecorr.NNCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
nn.process(catxa, catxb)
xip = nn.npairs
xiperr = np.sqrt(nn.npairs)
if ran:
nr.process(catxa, catrb)
nr.process(catra, catxb)
rr.process(catra, catrb)
xip, xiperr = nn.calculateXi(rr, nr, rn)
xiperr = np.sqrt(xiperr)
theta = np.exp(nn.meanlogr)
elif corr == 'KK':
kk = treecorr.KKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
if catb is None:
kk.process(catxa)
else:
kk.process(catxa, catxb)
xip = kk.xi
xiperr = np.sqrt(kk.varxi)
theta = np.exp(kk.meanlogr)
elif corr == 'KG':
kg = treecorr.KGCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
kk = treecorr.KKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
kg.process(catxa, catxb)
kk.process(catxa, catmb)
xip = kg.xi / kk.xi
xiperr = np.sqrt(kg.varxi)
xip_im = kg.xi_im / kk.xi
theta = np.exp(kg.meanlogr)
elif corr == 'NG':
ng = treecorr.NGCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
nk = treecorr.NKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
ng.process(catxa, catxb)
nk.process(catxa, catmb)
xip = ng.xi / nk.xi
xiperr = np.sqrt(ng.varxi)
xip_im = ng.xi_im / nk.xi
if ran:
rg = treecorr.NGCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
rk = treecorr.NKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
rg.process(catra, catxb)
rk.process(catra, catmb)
xip, xip_im, xiperr = ng.calculateXi(rg)
tmpa, tmp = nk.calculateXi(rk)
if np.sum(tmpa) == 0:
tmpa = np.ones(len(xip))
xip /= tmpa
xiperr = np.sqrt(xiperr)
xip_im /= tmpa
theta = np.exp(ng.meanlogr)
elif corr == 'NK':
nk = treecorr.NKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
nk.process(catxa, catxb)
xip = nk.xi
xiperr = np.sqrt(nk.varxi)
if ran:
rk = treecorr.NKCorrelation(nbins=cata.tbins,
min_sep=cata.sep[0],
max_sep=cata.sep[1],
sep_units='arcmin',
bin_slop=cata.slop,
verbose=0)
rk.process(catra, catxb)
xip, xiperr = nk.calculateXi(rk)
xiperr = np.sqrt(xiperr)
theta = np.exp(nk.meanlogr)
out = [xip, xim, xip_im, xim_im]
err = [xiperr, ximerr, xiperr, ximerr]
chi2 = [0., 0., 0., 0.]
if erron:
kwargs = {
'catb': catb,
'k': k,
'corr': corr,
'maska': maska,
'maskb': maskb,
'wa': wa,
'wb': wb,
'ran': ran
}
if catb is None:
if corr in ['KK', 'NK', 'KG']:
label = 'xi_2pt_' + cata.name + '_' + k + '_' + corr + '_' + label0
else:
label = 'xi_2pt_' + cata.name + '_' + corr + '_' + label0
else:
if corr in ['KK', 'NK', 'KG']:
label = 'xi_2pt_' + cata.name + '-' + catb.name + '_' + k + '_' + corr + '_' + label0
else:
label = 'xi_2pt_' + cata.name + '-' + catb.name + '_' + corr + '_' + label0
if cata.calc_err == 'jk':
err, chi2 = jackknife_methods.jk(cata, xi_2pt.xi_2pt,
[xip, xim, xip_im, xim_im],
label, **kwargs)
elif cata.calc_err == 'mock':
ggperr, ggmerr, chi2p, chi2m, ceerr, cberr, cechi2, cbchi2 = BCC_Methods.jk_iter_xi(
cat,
ggp,
ggm,
ce,
cb,
mask,
w,
cosebi=cosebi,
parallel=parallel)
if plot:
fig.plot_methods.fig_create_xi(cata, corr, theta, out, err, k, ga,
gb)
return theta, out, err, chi2
def test_rlens_bkg():
# Same as above, except limit the sources to be in the background of the lens.
nlens = 100
nsource = 200000
gamma0 = 0.05
R0 = 10.
L = 50. * R0
numpy.random.seed(8675309)
xl = (numpy.random.random_sample(nlens)-0.5) * L # -250 < x < 250
zl = (numpy.random.random_sample(nlens)-0.5) * L # -250 < y < 250
yl = numpy.random.random_sample(nlens) * 4*L + 10*L # 5000 < z < 7000
rl = numpy.sqrt(xl**2 + yl**2 + zl**2)
xs = (numpy.random.random_sample(nsource)-0.5) * L
zs = (numpy.random.random_sample(nsource)-0.5) * L
ys = numpy.random.random_sample(nsource) * 12*L + 8*L # 4000 < z < 10000
rs = numpy.sqrt(xs**2 + ys**2 + zs**2)
print('xl = ',numpy.min(xl),numpy.max(xl))
print('yl = ',numpy.min(yl),numpy.max(yl))
print('zl = ',numpy.min(zl),numpy.max(zl))
print('xs = ',numpy.min(xs),numpy.max(xs))
print('ys = ',numpy.min(ys),numpy.max(ys))
print('zs = ',numpy.min(zs),numpy.max(zs))
g1 = numpy.zeros( (nsource,) )
g2 = numpy.zeros( (nsource,) )
bin_size = 0.1
# min_sep is set so the first bin doesn't have 0 pairs.
min_sep = 1.3*R0
# max_sep can't be too large, since the measured value starts to have shape noise for larger
# values of separation. We're not adding any shape noise directly, but the shear from other
# lenses is effectively a shape noise, and that comes to dominate the measurement above ~4R0.
max_sep = 4.*R0
nbins = int(numpy.ceil(numpy.log(max_sep/min_sep)/bin_size))
print('Making shear vectors')
for x,y,z,r in zip(xl,yl,zl,rl):
# This time, only give the true shear to the background galaxies.
bkg = (rs > r)
# Use |r1 x r2| = |r1| |r2| sin(theta)
xcross = ys[bkg] * z - zs[bkg] * y
ycross = zs[bkg] * x - xs[bkg] * z
zcross = xs[bkg] * y - ys[bkg] * x
sintheta = numpy.sqrt(xcross**2 + ycross**2 + zcross**2) / (rs[bkg] * r)
Rlens = 2. * r * numpy.sin(numpy.arcsin(sintheta)/2)
gammat = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
# For the rotation, approximate that the x,z coords are approx the perpendicular plane.
# So just normalize back to the unit sphere and do the 2d projection calculation.
# It's not exactly right, but it should be good enough for this unit test.
dx = (xs/rs)[bkg]-x/r
dz = (zs/rs)[bkg]-z/r
drsq = dx**2 + dz**2
g1[bkg] += -gammat * (dx**2-dz**2)/drsq
g2[bkg] += -gammat * (2.*dx*dz)/drsq
# Slight subtlety in this test vs the previous one. We need to build up the full g1,g2
# arrays first before calculating the true_gt value, since we need to include the background
# galaxies for each lens regardless of whether they had signal or not.
true_gt = numpy.zeros( (nbins,) )
true_npairs = numpy.zeros((nbins,), dtype=int)
for x,y,z,r in zip(xl,yl,zl,rl):
# Use |r1 x r2| = |r1| |r2| sin(theta)
xcross = ys * z - zs * y
ycross = zs * x - xs * z
zcross = xs * y - ys * x
sintheta = numpy.sqrt(xcross**2 + ycross**2 + zcross**2) / (rs * r)
Rlens = 2. * r * numpy.sin(numpy.arcsin(sintheta)/2)
dx = xs/rs-x/r
dz = zs/rs-z/r
drsq = dx**2 + dz**2
gt = -g1 * (dx**2-dz**2)/drsq - g2 * (2.*dx*dz)/drsq
bkg = (rs > r)
index = numpy.floor( numpy.log(Rlens/min_sep) / bin_size).astype(int)
mask = (index >= 0) & (index < nbins) & bkg
numpy.add.at(true_gt, index[mask], gt[mask])
numpy.add.at(true_npairs, index[mask], 1)
true_gt /= true_npairs
# Start with bin_slop == 0. With only 100 lenses, this still runs very fast.
lens_cat = treecorr.Catalog(x=xl, y=yl, z=zl)
source_cat = treecorr.Catalog(x=xs, y=ys, z=zs, g1=g1, g2=g2)
ng0 = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0, min_rpar=0)
ng0.process(lens_cat, source_cat)
Rlens = ng0.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results with bin_slop = 0:')
print('ng.npairs = ',ng0.npairs)
print('true_npairs = ',true_npairs)
print('ng.xi = ',ng0.xi)
print('true_gammat = ',true_gt)
print('ratio = ',ng0.xi / true_gt)
print('diff = ',ng0.xi - true_gt)
print('max diff = ',max(abs(ng0.xi - true_gt)))
assert max(abs(ng0.xi - true_gt)) < 2.e-6
print('ng.xi = ',ng0.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng0.xi / theory_gt)
print('diff = ',ng0.xi - theory_gt)
print('max diff = ',max(abs(ng0.xi - theory_gt)))
assert max(abs(ng0.xi - theory_gt)) < 1.e-3
print('ng.xi_im = ',ng0.xi_im)
assert max(abs(ng0.xi_im)) < 1.e-3
# Without min_rpar, this should fail.
lens_cat = treecorr.Catalog(x=xl, y=yl, z=zl)
source_cat = treecorr.Catalog(x=xs, y=ys, z=zs, g1=g1, g2=g2)
ng0 = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0)
ng0.process(lens_cat, source_cat)
Rlens = ng0.meanr
print('Results without min_rpar')
print('ng.xi = ',ng0.xi)
print('true_gammat = ',true_gt)
print('max diff = ',max(abs(ng0.xi - true_gt)))
assert max(abs(ng0.xi - true_gt)) > 5.e-3
# Now use a more normal value for bin_slop.
ng1 = treecorr.NGCorrelation(bin_size=bin_size, min_sep=min_sep, max_sep=max_sep, verbose=1,
metric='Rlens', bin_slop=0.5, min_rpar=0)
ng1.process(lens_cat, source_cat)
Rlens = ng1.meanr
theory_gt = gamma0 * numpy.exp(-0.5*Rlens**2/R0**2)
print('Results with bin_slop = 0.5')
print('ng.npairs = ',ng1.npairs)
print('ng.xi = ',ng1.xi)
print('theory_gammat = ',theory_gt)
print('ratio = ',ng1.xi / theory_gt)
print('diff = ',ng1.xi - theory_gt)
print('max diff = ',max(abs(ng1.xi - theory_gt)))
assert max(abs(ng1.xi - theory_gt)) < 1.e-3
print('ng.xi_im = ',ng1.xi_im)
assert max(abs(ng1.xi_im)) < 1.e-3
# Check that we get the same result using the corr2 executable:
if __name__ == '__main__':
lens_cat.write(os.path.join('data','ng_rlens_bkg_lens.dat'))
source_cat.write(os.path.join('data','ng_rlens_bkg_source.dat'))
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"ng_rlens_bkg.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','ng_rlens_bkg.out'),names=True)
print('ng.xi = ',ng1.xi)
print('from corr2 output = ',corr2_output['gamT'])
print('ratio = ',corr2_output['gamT']/ng1.xi)
print('diff = ',corr2_output['gamT']-ng1.xi)
numpy.testing.assert_almost_equal(corr2_output['gamT'], ng1.xi, decimal=6)
numpy.testing.assert_almost_equal(corr2_output['gamX'], ng1.xi_im, decimal=6)
def xshear_lens_jk(zl1, zl2, jk_label):
source_file = h5py.File("source_zb_" + str(zl2 + 0.1) + "_0.9.h5")
source_ra = source_file["ra"][:]
source_dec = source_file["dec"][:]
source_z = source_file["zb"][:]
source_e1 = source_file["e1"][:]
source_e2 = source_file["e2"][:]
source_w = source_file["w"][:]
source_size = source_file["snr"][:]
size_mask = source_size > np.median(source_size)
source_file.close()
#### LARGE GALAXIES ####
source_cat = treecorr.Catalog(x=source_ra[size_mask],
y=source_dec[size_mask],
g1=source_e1[size_mask],
g2=-1. * source_e2[size_mask],
w=source_w[size_mask],
x_units='degree',
y_units='degree')
mask_z_lens = (lens_z_jk > zl1) & (lens_z_jk < zl2)
lens_mask = labels_lens_jk == jk_label
lens_mask = (~lens_mask) & (mask_z_lens)
lens_cat = treecorr.Catalog(x=lens_ra_jk[lens_mask],
y=lens_dec_jk[lens_mask],
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(lens_cat, source_cat)
r_lens_h, xt_lens_h = ng.meanr, ng.xi
random_mask = labels_random_jk == jk_label
random_cat = treecorr.Catalog(x=random_ra_jk[~random_mask],
y=random_dec_jk[~random_mask],
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(random_cat, source_cat)
r_rand_h, xt_rand_h = ng.meanr, ng.xi
#### SMALL GALAXIES ####
source_cat = treecorr.Catalog(x=source_ra[~size_mask],
y=source_dec[~size_mask],
g1=source_e1[~size_mask],
g2=-1. * source_e2[~size_mask],
w=source_w[~size_mask],
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(lens_cat, source_cat)
r_lens_l, xt_lens_l = ng.meanr, ng.xi
ng = treecorr.NGCorrelation(nbins=25,
min_sep=0.3,
max_sep=300,
sep_units='arcmin',
verbose=1)
ng.process(random_cat, source_cat)
r_rand_l, xt_rand_l = ng.meanr, ng.xi
return r_lens_h, xt_lens_h, r_rand_h, xt_rand_h, r_lens_l, xt_lens_l, r_rand_l, xt_rand_l
def test_haloellip():
"""This is similar to the Clampitt halo ellipticity measurement, but using counts for the
background galaxies rather than shears.
w_aligned = Sum_i (w_i * cos(2theta)) / Sum_i (w_i)
w_cross = Sum_i (w_i * sin(2theta)) / Sum_i (w_i)
where theta is measured w.r.t. the coordinate system where the halo ellitpicity
is along the x-axis. Converting this to complex notation, we obtain:
w_a - i w_c = < exp(-2itheta) >
= < exp(2iphi) exp(-2i(theta+phi)) >
= < ehalo exp(-2i(theta+phi)) >
where ehalo = exp(2iphi) is the unit-normalized shape of the halo in the normal world
coordinate system. Note that the combination theta+phi is the angle between the line joining
the two points and the E-W coordinate, which means that
w_a - i w_c = -gamma_t(n_bg, ehalo)
so the reverse of the usual galaxy-galaxy lensing order. The N is the background galaxies
and G is the halo shapes (normalized to have |ehalo| = 1).
"""
nhalo = 10
nsource = 1000000 # sources per halo
ntot = nsource * nhalo
L = 100000. # The side length in which the halos are placed
R = 10. # The (rms) radius of the associated sources from the halos
# In this case, we want L >> R so that most sources are only associated
# with the one halo we used for assigning its shear value.
# Lenses are randomly located with random shapes.
numpy.random.seed(86753099)
halo_g1 = numpy.random.normal(0., 0.3, (nhalo,))
halo_g2 = numpy.random.normal(0., 0.3, (nhalo,))
halo_g = halo_g1 + 1j * halo_g2
# The interpretation is simpler if they all have the same |g|, so just make them all 0.3.
halo_g *= 0.3 / numpy.abs(halo_g)
halo_absg = numpy.abs(halo_g)
halo_x = (numpy.random.random_sample(nhalo)-0.5) * L
halo_y = (numpy.random.random_sample(nhalo)-0.5) * L
print('Made halos',len(halo_x))
# For the sources, place nsource galaxies around each halo with the expected azimuthal pattern
source_x = numpy.empty(ntot)
source_y = numpy.empty(ntot)
for i in range(nhalo):
absg = halo_absg[i]
# First position the sources in a Gaussian cloud around the halo center.
dx = numpy.random.normal(0., 10., (nsource,))
dy = numpy.random.normal(0., 10., (nsource,))
r = numpy.sqrt(dx*dx + dy*dy)
t = numpy.arctan2(dy,dx)
# z = dx + idy = r exp(it)
# Reposition the sources azimuthally so p(theta) ~ 1 + |g_halo| * cos(2 theta)
# Currently t has p(t) = 1/2pi.
# Let u be the new azimuthal angle with p(u) = (1/2pi) (1 + |g| cos(2u))
# p(u) = |dt/du| p(t)
# 1 + |g| cos(2u) = dt/du
# t = int( (1 + |g| cos(2u)) du = u + 1/2 |g| sin(2u)
# This doesn't have an analytic solution, but a few iterations of Newton-Raphson
# should work well enough.
u = t.copy()
for i in range(4):
u -= (u - t + 0.5 * absg * numpy.sin(2.*u)) / (1. + absg * numpy.cos(2.*u))
z = r * numpy.exp(1j * u)
exp2iphi = z**2 / numpy.abs(z)**2
# Now rotate the whole system by the phase of the halo ellipticity.
exp2ialpha = halo_g[i] / absg
expialpha = numpy.sqrt(exp2ialpha)
z *= expialpha
# Place the source galaxies at this dx,dy with this shape
source_x[i*nsource: (i+1)*nsource] = halo_x[i] + z.real
source_y[i*nsource: (i+1)*nsource] = halo_y[i] + z.imag
print('Made sources',len(source_x))
source_cat = treecorr.Catalog(x=source_x, y=source_y)
# Big fat bin to increase S/N. The way I set it up, the signal is the same in all
# radial bins, so just combine them together for higher S/N.
ng = treecorr.NGCorrelation(min_sep=5, max_sep=10, nbins=1)
halo_mean_absg = numpy.mean(halo_absg)
print('mean_absg = ',halo_mean_absg)
# First the original version where we only use the phase of the halo ellipticities:
halo_cat1 = treecorr.Catalog(x=halo_x, y=halo_y,
g1=halo_g.real/halo_absg, g2=halo_g.imag/halo_absg)
ng.process(source_cat, halo_cat1)
print('ng.npairs = ',ng.npairs)
print('ng.xi = ',ng.xi)
# The expected signal is
# E(ng) = - < int( p(t) cos(2t) ) >
# = - < int( (1 + e_halo cos(2t)) cos(2t) ) >
# = -0.5 <e_halo>
print('expected signal = ',-0.5 * halo_mean_absg)
# These tests don't quite work at the 1% level of accuracy, but 2% seems to work for most.
# This is effected by checking that 1/2 the value matches 0.5 to 2 decimal places.
numpy.testing.assert_almost_equal(ng.xi, -0.5 * halo_mean_absg, decimal=2)
# Next weight the halos by their absg.
halo_cat2 = treecorr.Catalog(x=halo_x, y=halo_y, w=halo_absg,
g1=halo_g.real/halo_absg, g2=halo_g.imag/halo_absg)
ng.process(source_cat, halo_cat2)
print('ng.xi = ',ng.xi)
# Now the net signal is
# sum(w * p*cos(2t)) / sum(w)
# = 0.5 * <absg^2> / <absg>
halo_mean_gsq = numpy.mean(halo_absg**2)
print('expected signal = ',0.5 * halo_mean_gsq / halo_mean_absg)
numpy.testing.assert_almost_equal(ng.xi, -0.5 * halo_mean_gsq / halo_mean_absg, decimal=2)
# Finally, use the unnormalized halo_g for the halo ellipticities
halo_cat3 = treecorr.Catalog(x=halo_x, y=halo_y, g1=halo_g.real, g2=halo_g.imag)
ng.process(source_cat, halo_cat3)
print('ng.xi = ',ng.xi)
# Now the net signal is
# sum(absg * p*cos(2t)) / N
# = 0.5 * <absg^2>
print('expected signal = ',0.5 * halo_mean_gsq)
numpy.testing.assert_almost_equal(ng.xi, -0.5 * halo_mean_gsq, decimal=2)
def dsigma(lens, source):
source_ra = source[:, 0]
source_dec = source[:, 1]
source_z = source[:, -1]
source_e1 = -1. * source[:, 2]
source_e2 = source[:, 3]
source_w = source[:, 4]
lens_z = lens[:, 4]
lens_ra = lens[:, 3]
lens_dec = lens[:, 2]
lens_Dc = cosmo.comoving_distance(np.median(lens_z))
source_Dc = cosmo.comoving_distance(source_z)
lens_Da = cosmo.angular_diameter_distance(np.median(lens_z))
source_Dc = source_Dc * 1e6
lens_Dc = lens_Dc * 1e6
lens_Da = lens_Da * 1e6
DlsoDs = (source_Dc - lens_Dc) / source_Dc
Sigma_crit = (c.value**2) / (4 * np.pi * G.value) * 1 / (lens_Da * DlsoDs)
lens_cat = treecorr.Catalog(x=lens_ra,
y=lens_dec,
x_units='degree',
y_units='degree')
source_cat = treecorr.Catalog(x=source_ra,
y=source_dec,
g1=source_e1 * Sigma_crit,
g2=source_e2 * Sigma_crit,
w=source_w * Sigma_crit**-2.,
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=5,
min_sep=0.2,
max_sep=6,
sep_units='arcmin',
verbose=1)
ng.process(lens_cat, source_cat)
r, xi_t, xi_x, w, npairs = ng.meanr, ng.xi, ng.xi_im, ng.weight, ng.npairs
print "done with lens source cross-correlation"
lens_Dc = cosmo.comoving_distance(np.median(rand_z))
lens_Da = cosmo.angular_diameter_distance(np.median(rand_z))
source_Dc = source_Dc * 1e6
lens_Dc = lens_Dc * 1e6
lens_Da = lens_Da * 1e6
DlsoDs = (source_Dc - lens_Dc) / source_Dc
Sigma_crit = (c.value**2) / (4 * np.pi * G.value) * 1 / (lens_Da * DlsoDs)
random_cat = treecorr.Catalog(x=rname[:, 2],
y=rname[:, 1],
x_units='degree',
y_units='degree')
source_cat = treecorr.Catalog(x=source_ra,
y=source_dec,
g1=source_e1 * Sigma_crit,
g2=source_e2 * Sigma_crit,
w=source_w * Sigma_crit**-2.,
x_units='degree',
y_units='degree')
ng = treecorr.NGCorrelation(nbins=5,
min_sep=0.2,
max_sep=6,
sep_units='arcmin',
verbose=1)
ng.process(random_cat, source_cat)
rr, xi_tr, xi_xr, wr = ng.meanr, ng.xi, ng.xi_im, ng.weight
return r, xi_t, xi_x, w, xi_tr, xi_xr, wr, npairs, np.mean(Sigma_crit)
g2=e2)
troughcat = treecorr.Catalog(ra=RA,
dec=DEC,
ra_units='deg',
dec_units='deg',
w=weights)
config = {
'min_sep': Rarcmin,
'max_sep': Rarcmax,
'nbins': Nbins,
'sep_units': 'arcmin',
'verbose': 2
}
ng = treecorr.NGCorrelation(config)
ng.process(troughcat, galcat) # Compute the cross-correlation.
output_temp = 'temp_treecor.txt'
ng.write(output_temp) # Write out to a file.
shearfile = np.loadtxt(output_temp).T
Rbins, gamma_t, gamma_x, gamma_error, Nsrc = \
[shearfile[0], shearfile[3], shearfile[4], np.sqrt(shearfile[5]), shearfile[7]]
"""
if 'pc' in Runit:
# Translate to comoving ESD
Rbins = Rbins*(1+troughZ)
gamma_t, gamma_x, gamma_error = np.array([gamma_t, gamma_x, gamma_error])/(1+troughZ)**2
"""
def map(self, mapunit):
if self.gt is None:
self.gt = np.zeros((self.njack, self.nabins, self.nmbins,
self.nmbins1, self.nzbins * self.nzbins1))
self.gt_rand = np.zeros((self.njack, self.nabins, self.nmbins,
self.nmbins1, self.nzbins * self.nzbins1))
self.weights = np.zeros((self.njack, self.nabins, self.nmbins,
self.nmbins1, self.nzbins * self.nzbins1))
self.weights_rand = np.zeros(
(self.njack, self.nabins, self.nmbins, self.nmbins1,
self.nzbins * self.nzbins1))
self.varg = np.zeros((self.njack, self.nmbins, self.nmbins1,
self.nzbins * self.nzbins1))
self.nzd1 = np.zeros(
(self.njack, 200, self.nmbins, 1, self.nzbins))
self.nzd2 = np.zeros(
(self.njack, 200, 1, self.nmbins1, self.nzbins1))
self.nd1 = np.zeros((self.njack, self.nmbins, self.nmbins1,
self.nzbins * self.nzbins1))
self.nd2 = np.zeros((self.njack, self.nmbins, self.nmbins1,
self.nzbins * self.nzbins1))
for i in range(self.nzbins):
print('Finding redshift indices')
zlidx = mapunit['redshift'].searchsorted(self.zbins[i])
zhidx = mapunit['redshift'].searchsorted(self.zbins[i + 1])
for i1 in range(self.nzbins1):
if self.same_zbins:
zlidx1 = mapunit['redshift1'].searchsorted(self.zbins[i])
zhidx1 = mapunit['redshift1'].searchsorted(self.zbins[i +
1])
else:
zlidx1 = mapunit['redshift1'].searchsorted(self.zbins1[i1])
zhidx1 = mapunit['redshift1'].searchsorted(self.zbins1[i1 +
1])
if self.rbins is not None:
if self.same_zbins:
zm = (self.zbins[i] + self.zbins[i + 1]) / 2
else:
zm = (self.zbins1[i] + self.zbins1[i + 1]) / 2
self.abins[:, i] = self.computeAngularBinsFromRadii(
self.rbins, zm)
if self.sep_units == 'arcmin':
self.abins[:, i] *= 60
if (zlidx == zhidx):
print("No galaxies in redshift bin {0} to {1}".format(
self.zbins[i], self.zbins[i + 1]))
print('z: {}'.format(z))
print("Min and max z: {0}, {1}".format(
np.min(mapunit['redshift']),
np.max(mapunit['redshift'])))
continue
elif (zlidx1 == zhidx1):
print("No galaxies in redshift bin {0} to {1}".format(
self.zbins1[i], self.zbins1[i + 1]))
print('z1: {}'.format(mapunit['redshift1']))
print("Min and max z1: {0}, {1}".format(
np.min(mapunit['redshift1']),
np.max(mapunit['redshift1'])))
continue
for li, j in enumerate(self.minds):
if self.mkey is not None:
if self.mcutind is not None:
if self.upper_limit:
lidx = mapunit[self.mkey][
zlidx:zhidx, self.mcutind] < self.mbins[j]
else:
lidx = ((self.mbins[j] <= mapunit[self.mkey][
zlidx:zhidx, self.mcutind])
& (mapunit[self.mkey][zlidx:zhidx,
self.mcutind] <
self.mbins[j + 1]))
else:
if self.upper_limit:
lidx = mapunit[
self.mkey][zlidx:zhidx] < self.mbins[j]
else:
lidx = ((self.mbins[j] <=
mapunit[self.mkey][zlidx:zhidx])
& (mapunit[self.mkey][zlidx:zhidx] <
self.mbins[j + 1]))
else:
lidx = np.ones(zhidx - zlidx, dtype=np.bool)
for li1, j1 in enumerate(self.minds1):
if self.mkey1 is not None:
if self.mcutind1 is not None:
if self.upper_limit1:
lidx1 = mapunit[self.mkey1][
zlidx1:zhidx1,
self.mcutind1] < self.mbins1[j1]
else:
lidx1 = (
(self.mbins1[j1] <= mapunit[self.mkey1]
[zlidx1:zhidx1, self.mcutind1])
& (mapunit[self.mkey1][zlidx1:zhidx1,
self.mcutind1] <
self.mbins1[j1 + 1]))
else:
if self.upper_limit1:
lidx1 = mapunit[self.mkey1][
zlidx1:zhidx1] < self.mbins1[j1]
else:
lidx1 = (
(self.mbins1[j1] <=
mapunit[self.mkey1][zlidx1:zhidx1])
& (mapunit[self.mkey1][zlidx1:zhidx1] <
self.mbins1[j1 + 1]))
else:
lidx1 = np.ones(zhidx1 - zlidx1, dtype=np.bool)
rands = self.getRandoms(
mapunit['azim_ang1'][zlidx1:zhidx1][lidx1],
mapunit['polar_ang1'][zlidx1:zhidx1][lidx1],
mapunit['redshift1'][zlidx1:zhidx1][lidx1],
zmin=self.zbins1[i1],
zmax=self.zbins1[i1 + 1])
self.nd1[self.jcount, j, j1,
i * self.nzbins1 + i1] = len(
mapunit['azim_ang'][zlidx:zhidx][lidx])
self.nd2[self.jcount, j, j1,
i * self.nzbins1 + i1] = len(
mapunit['azim_ang'][zlidx1:zhidx1][lidx1])
self.nzd1[self.jcount, :, j, 0, i], _ = np.histogram(
mapunit['redshift'][zlidx:zhidx][lidx],
self.nofzbins)
self.nzd2[self.jcount, :, 0, j1, i1], _ = np.histogram(
mapunit['redshift'][zlidx1:zhidx1][lidx1],
self.nofzbins)
print("Number of cat1 in this z/lum bin: {0}".format(
np.sum(lidx)))
print("Number of cat2 in this z/lum bin: {0}".format(
np.sum(lidx1)))
cat1 = treecorr.Catalog(
g1=mapunit['gamma1'][zlidx:zhidx][lidx],
g2=-mapunit['gamma2'][zlidx:zhidx][lidx],
ra=mapunit['azim_ang'][zlidx:zhidx][lidx],
dec=mapunit['polar_ang'][zlidx:zhidx][lidx],
ra_units='deg',
dec_units='deg')
cat2 = treecorr.Catalog(
ra=mapunit['azim_ang1'][zlidx1:zhidx1][lidx1],
dec=mapunit['polar_ang1'][zlidx1:zhidx1][lidx1],
ra_units='deg',
dec_units='deg')
rand_cat = treecorr.Catalog(ra=rands['azim_ang'],
dec=rands['polar_ang'],
ra_units='deg',
dec_units='deg')
sys.stdout.flush()
if (self.nd1[self.jcount, j, j1, i * self.nzbins1 + i1]
< 1) | (self.nd2[self.jcount, j, j1,
i * self.nzbins1 + i1] < 1):
continue
print('processing position-shear correlation')
ng = treecorr.NGCorrelation(min_sep=self.abins[0, i],
max_sep=self.abins[-1, i],
nbins=self.nabins,
sep_units=self.sep_units,
bin_slop=self.bin_slop)
print(
'min(ra), max(ra), min(dec), max(dec): {}, {}, {}, {}'
.format(np.min(mapunit['azim_ang']),
np.max(mapunit['azim_ang']),
np.min(mapunit['polar_ang']),
np.max(mapunit['polar_ang'])))
ng.process_cross(cat2, cat1, num_threads=self.nthreads)
self.gt[self.jcount, :, j, j1,
i * self.nzbins1 + i1] = ng.xi
self.weights[self.jcount, :, j, j1,
i * self.nzbins1 + i1] = ng.weight
self.varg[self.jcount, j, j1,
i * self.nzbins1 + i1] = cat1.varg
rg = treecorr.NGCorrelation(min_sep=self.abins[0, i],
max_sep=self.abins[-1, i],
nbins=self.nabins,
sep_units=self.sep_units,
bin_slop=self.bin_slop)
print(
'min(rand_ra), max(rand_ra), min(rand_dec), max(rand_dec): {}, {}, {}, {}'
.format(np.min(rands['azim_ang']),
np.max(rands['azim_ang']),
np.min(rands['polar_ang']),
np.max(rands['polar_ang'])))
rg.process_cross(rand_cat,
cat1,
num_threads=self.nthreads)
self.gt_rand[self.jcount, :, j, j1,
i * self.nzbins + i1] = rg.xi
self.weights_rand[self.jcount, :, j, j1,
i * self.nzbins + i1] = rg.weight
if self.amean is None:
if (ng.meanlogr != 0.0).any():
self.amean = np.exp(ng.meanlogr)
else:
self.amean = np.exp(ng.logr)
