def NN3DCorrelation(self, min_sep=1, max_sep=200, bin_size=0.5):
"""
Caclulates 3D correlation function of objects using Catalog's ra, dec, r
Requires randcatalog to exist. Distance units are Mpc/h.
Returns tuple (logr, meanlogr, xi, xivar)
"""
catS = treecorr.Catalog(ra=self.catalog["ra"], dec=self.catalog["dec"],
r=self.catalog["r"],
ra_units="radians", dec_units="radians")
if (self.randcatalog):
catR = treecorr.Catalog(ra=self.randcatalog["ra"],
dec=self.randcatalog["dec"],
r=self.randcatalog["r"], ra_units="radians",
dec_units="radians")
else:
print ("Need random catalog for NN")
stop()
dd=treecorr.NNCorrelation(min_sep=min_sep, bin_size=bin_size,
max_sep=max_sep)
dr=treecorr.NNCorrelation(min_sep=min_sep, bin_size=bin_size,
max_sep=max_sep)
rr=treecorr.NNCorrelation(min_sep=min_sep, bin_size=bin_size,
max_sep=max_sep)
dd.process(catS)
dr.process(catS, catR)
rr.process(catR)
xi, xivar=dd.calculateXi(rr,dr)
logr = dd.logr
meanlogr= dd.meanlogr
return (logr, meanlogr, xi, xivar)
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 shear_shear_corr(pos1,pos2,shear1,shear2,k1=None,k2=None,w1=None,w2=None,same_zshell=False,same_cell=False,unique_encounter=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 # num_threads = 5 #None #0 logger = None if same_zshell and same_cell: # auto ra, dec = pos1 # either 1 or 2 works g1, g2 = shear1 k = k1 w = w1 cat = treecorr.Catalog(g1=g1, g2=g2, k=k, ra=ra, dec=dec, w=w, ra_units='degrees', dec_units='degrees') elif same_zshell: # just wanted to distrubute the workload fairly for two encounters (didn't want to make one of the cores idle) ra1, dec1 = np.array_split(pos1[0], 2), np.array_split(pos1[1], 2) # split in half ra2, dec2 = np.array_split(pos2[0], 2), np.array_split(pos2[1], 2) g1_1st, g2_1st = np.array_split(shear1[0], 2), np.array_split(shear1[1], 2) g1_2nd, g2_2nd = np.array_split(shear2[0], 2), np.array_split(shear2[1], 2) k1 = np.array_split(k1, 2) if (k1 is not None) else [None,None] k2 = np.array_split(k2, 2) if (k2 is not None) else [None,None] w1 = np.array_split(w1, 2) if (w1 is not None) else [None,None] w2 = np.array_split(w2, 2) if (w2 is not None) else [None,None] cat1 = [treecorr.Catalog(g1=g1_1st[h], g2=g2_1st[h], k=k1[h], ra=ra1[h], dec=dec1[h], w=w1[h], ra_units='degrees', dec_units='degrees') for h in [0,1]] cat2 = [treecorr.Catalog(g1=g1_2nd[h], g2=g2_2nd[h], k=k2[h], ra=ra2[h], dec=dec2[h], w=w2[h], ra_units='degrees', dec_units='degrees') for h in [0,1]] else: ra1, dec1 = pos1 ra2, dec2 = pos2 g1_1st, g2_1st = shear1 g1_2nd, g2_2nd = shear2 cat1 = treecorr.Catalog(g1=g1_1st, g2=g2_1st, k=k1, ra=ra1, dec=dec1, w=w1, ra_units='degrees', dec_units='degrees') cat2 = treecorr.Catalog(g1=g1_2nd, g2=g2_2nd, k=k2, ra=ra2, dec=dec2, w=w2, ra_units='degrees', dec_units='degrees') gg = treecorr.GGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=bin_slop, sep_units='degrees', logger=logger) if same_zshell and same_cell: gg.process_auto(cat,num_threads=num_threads) elif same_zshell: # just wanted to distrubute the workload fairly for two encounters (didn't want to make one of the cores idle) if unique_encounter: # the following two counts shouldn't be doubled up cuz they're the same in both directions gg.process_cross(cat1[0],cat2[0],num_threads=num_threads) gg.process_cross(cat1[1],cat2[1],num_threads=num_threads) else: # in the other encounter cat1 and cat2 are switched but does not matter anyway gg.process_cross(cat2[0],cat1[1],num_threads=num_threads) gg.process_cross(cat2[1],cat1[0],num_threads=num_threads) else: gg.process_cross(cat1,cat2,num_threads=num_threads) if same_zshell and same_cell: varg1 = treecorr.calculateVarG(cat) varg2 = varg1 elif same_cell: varg1 = treecorr.calculateVarG(cat1) varg2 = treecorr.calculateVarG(cat2) else: varg1 = np.nan varg2 = np.nan return gg, varg1, varg2
def calc_3pt(data, randoms, config_fname, zvar, random_zvar, ra_var='RA', dec_var='DEC', random_ra_var='RA', random_dec_var='DEC'):
config_3pt = load_config(config_fname)['3PCF']
cat = treecorr.Catalog(ra=data[ra_var], dec=data[dec_var],
dec_units='degrees', ra_units='degrees',
r=datasets.buzzard_cosmo.comoving_distance(data[zvar]).value*datasets.buzzard_cosmo.h)
random_cat = treecorr.Catalog(ra=randoms[random_ra_var], dec=randoms[random_dec_var],
dec_units='degrees', ra_units='degrees',
r=datasets.buzzard_cosmo.comoving_distance(randoms[random_zvar]).value*datasets.buzzard_cosmo.h)
print config_3pt
ddd = treecorr.NNNCorrelation(config=config_3pt)
ddr = treecorr.NNNCorrelation(config=config_3pt)
drd = treecorr.NNNCorrelation(config=config_3pt)
rdd = treecorr.NNNCorrelation(config=config_3pt)
rdr = treecorr.NNNCorrelation(config=config_3pt)
rrd = treecorr.NNNCorrelation(config=config_3pt)
drr = treecorr.NNNCorrelation(config=config_3pt)
rrr = treecorr.NNNCorrelation(config=config_3pt)
ddd.process(cat, metric=config_3pt['metric'])
ddr.process(cat, cat, random_cat, metric=config_3pt['metric'])
drd.process(cat, random_cat, cat, metric=config_3pt['metric'])
rdd.process(random_cat, cat, cat, metric=config_3pt['metric'])
rdr.process(random_cat, cat, random_cat, metric=config_3pt['metric'])
rrd.process(random_cat, random_cat, cat, metric=config_3pt['metric'])
drr.process(cat, random_cat, random_cat, metric=config_3pt['metric'])
rrr.process(random_cat, random_cat, random_cat,
metric=config_3pt['metric'])
zeta, varzeta = ddd.calculateZeta(
ddr=ddr, drd=drd, rdd=rdd, rrd=rrd, rdr=rdr, drr=drr, rrr=rrr)
return zeta
def NNCorrelation(self):
"""
Caclulates 2D correlation function using Catalog's ra, dec.
Requires randcatalog to exist.
Returns tuple (logr, meanlogr, xi, xivar)
"""
catS = treecorr.Catalog(ra=self.catalog["ra"], dec=self.catalog["dec"],
ra_units="radians", dec_units="radians")
if (self.randcatalog):
catR = treecorr.Catalog(ra=self.randcatalog["ra"],
dec=self.randcatalog["dec"], ra_units="radians",
dec_units="radians")
else:
print ("Need random catalog for NN")
stop()
dd=treecorr.NNCorrelation(min_sep=self.min_sep, bin_size=self.bin_size,
max_sep=self.max_sep, sep_units='arcmin')
dr=treecorr.NNCorrelation(min_sep=self.min_sep, bin_size=self.bin_size,
max_sep=self.max_sep, sep_units='arcmin' )
rr=treecorr.NNCorrelation(min_sep=self.min_sep, bin_size=self.bin_size,
max_sep=self.max_sep, sep_units='arcmin')
dd.process(catS)
dr.process(catS, catR)
rr.process(catR)
xi, xivar=dd.calculateXi(rr,dr)
logr = dd.logr
meanlogr= dd.meanlogr
return (logr, meanlogr, xi, xivar)
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 test_direct():
nobj = 5000
numpy.random.seed(8675309)
x = numpy.random.random_sample(nobj)
y = numpy.random.random_sample(nobj)
ra = numpy.random.random_sample(nobj)
dec = numpy.random.random_sample(nobj)
w = numpy.random.random_sample(nobj)
g1 = numpy.random.random_sample(nobj)
g2 = numpy.random.random_sample(nobj)
k = numpy.random.random_sample(nobj)
cat1 = treecorr.Catalog(x=x, y=y, w=w, g1=g1, g2=g2, k=k)
numpy.testing.assert_almost_equal(cat1.x, x)
numpy.testing.assert_almost_equal(cat1.y, y)
numpy.testing.assert_almost_equal(cat1.w, w)
numpy.testing.assert_almost_equal(cat1.g1, g1)
numpy.testing.assert_almost_equal(cat1.g2, g2)
numpy.testing.assert_almost_equal(cat1.k, k)
cat2 = treecorr.Catalog(ra=ra, dec=dec, w=w, g1=g1, g2=g2, k=k,
ra_units='hours', dec_units='degrees')
numpy.testing.assert_almost_equal(cat2.ra, ra * treecorr.hours)
numpy.testing.assert_almost_equal(cat2.dec, dec * treecorr.degrees)
numpy.testing.assert_almost_equal(cat2.w, w)
numpy.testing.assert_almost_equal(cat2.g1, g1)
numpy.testing.assert_almost_equal(cat2.g2, g2)
numpy.testing.assert_almost_equal(cat2.k, k)
def calc_pos_pos(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')
mask = self.lens_binning==j
lenscat_j = 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==j
rancat_j = treecorr.Catalog(w=np.ones(np.sum(mask)), ra=self.randoms['ra'][mask], dec=self.randoms['dec'][mask], ra_units='deg', dec_units='deg')
nn = treecorr.NNCorrelation(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)
rn = treecorr.NNCorrelation(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)
nr = treecorr.NNCorrelation(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)
rr = treecorr.NNCorrelation(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)
nn.process(lenscat_i,lenscat_j)
rn.process(rancat_i,lenscat_j)
nr.process(lenscat_i,rancat_j)
rr.process(rancat_i,rancat_j)
theta=np.exp(nn.meanlogr)
wtheta,wthetaerr=nn.calculateXi(rr,dr=nr,rd=rn)
wthetaerr=np.sqrt(wthetaerr)
return theta, wtheta, wthetaerr
def calcalate_hhcf_full(outpath,halopath,nbins,limits,Nh,randoms):
"""
Calculate the halo-halo correlation function
for the full volume.
"""
redpath = halopath+"/reduced_halo_cats/reduced_halo_cat.txt"
infile = open(redpath,"r")
halos = np.zeros((int(Nh),3))
i = 0
for line in infile:
if line[0] is "#": continue
parts = line.split()
halos[i,:] = float(parts[x_index]),float(parts[y_index]),float(parts[z_index])
i+=1
infile.close()
#Interface with treecorr
config = {'nbins':nbins,'min_sep':limits[0],'max_sep':limits[1]}
halo_cat = treecorr.Catalog(x=halos[:,0],y=halos[:,1],z=halos[:,2],config=config)
random_cat = treecorr.Catalog(x=randoms[:,0],y=randoms[:,1],z=randoms[:,2],config=config)
DD = treecorr.NNCorrelation(config)
DR = treecorr.NNCorrelation(config)
RR = treecorr.NNCorrelation(config)
DD.process(halo_cat)
DR.process(halo_cat,random_cat)
RR.process(random_cat)
DD.write(outpath+"/halohalo_correlation_function/full_hhcf/full_hhcf.txt",RR,DR)
print "\tFull halo-halo correlation function complete."
return
def calc_xi_perp(self, data1, data2, min_rpar, max_rpar, nbins=20, slop=0.1, randoms=True):
# Build a catalogue of random points drawn from the same volume
rx = np.random.random(size=data1['x'].size) * (data1['x'].max()-data1['x'].min()) + data1['x'].mean()
ry = np.random.random(size=data1['x'].size) * (data1['y'].max()-data1['y'].min()) + data1['y'].mean()
rz = np.random.random(size=data1['x'].size) * (data1['z'].max()-data1['z'].min()) + data1['z'].mean()
# Create the catalogues
cat_i = treecorr.Catalog(x=data1['x'], y=data1['y'], z=data1['z'])
cat_j = treecorr.Catalog(x=data2['x'], y=data2['y'], z=data2['z'])
rancat_i = treecorr.Catalog(x=rx, y=ry, z=rz)
rancat_j = treecorr.Catalog(x=rx, y=ry, z=rz)
nn = treecorr.NNCorrelation(nbins=nbins, min_rpar=min_rpar, max_rpar=max_rpar, min_sep=15, max_sep=10e3, bin_slop=slop)
rn = treecorr.NNCorrelation(nbins=nbins, min_rpar=min_rpar, max_rpar=max_rpar, min_sep=15, max_sep=10e3, bin_slop=slop)
nr = treecorr.NNCorrelation(nbins=nbins, min_rpar=min_rpar, max_rpar=max_rpar, min_sep=15, max_sep=10e3, bin_slop=slop)
rr = treecorr.NNCorrelation(nbins=nbins, min_rpar=min_rpar, max_rpar=max_rpar, min_sep=15, max_sep=10e3, bin_slop=slop)
nn.process(cat_i,cat_j, metric='Rperp') #, metric='Periodic')
rn.process(rancat_i,cat_j, metric='Rperp') #, metric='Periodic')
nr.process(cat_i,rancat_j, metric='Rperp') #, metric='Periodic')
rr.process(rancat_i,rancat_j, metric='Rperp') #, metric='Periodic')
R = np.exp(nn.meanlogr)
if randoms:
w, werr = nn.calculateXi(rr,dr=nr,rd=rn)
else:
w, werr = nn.calculateXi(rr,dr=None,rd=None)
werr = np.sqrt(werr)
return R, w, werr
def CorrelationFunction(source, source_random, corrconfig=None, source_ra='ra', source_dec='dec', source_random_ra=None, source_random_dec=None):
if corrconfig is None:
corrconfig = {'sep_units': 'degrees',
'min_sep': 0.1,
'max_sep': 6,
'nbins': 25,
'bin_slop': 0.25,
'num_threads': 1}
if source_random_ra is None:
source_random_ra = source_ra
if source_random_dec is None:
source_random_dec = source_dec
SourceCat = treecorr.Catalog(ra=source[source_ra], dec=source[source_dec], ra_units='degrees', dec_units='degrees')
SourceRand = treecorr.Catalog(ra=source_random[source_random_ra], dec=source_random[source_random_dec], ra_units='degrees', dec_units='degrees')
dd = treecorr.NNCorrelation(**corrconfig)
dr = treecorr.NNCorrelation(**corrconfig)
rr = treecorr.NNCorrelation(**corrconfig)
dd.process(SourceCat)
dr.process(SourceCat, SourceRand)
rr.process(SourceRand)
xi, varxi = dd.calculateXi(rr, dr=dr)
r = np.exp(dd.logr)
return [xi, r]
def get_lens_catalog(self, data, i):
import treecorr
mask = data['lens_bin'] == i
if 'lens_ra' in data:
ra = data['lens_ra'][mask]
dec = data['lens_dec'][mask]
else:
ra = data['ra'][mask]
dec = data['dec'][mask]
cat = treecorr.Catalog(ra=ra,
dec=dec,
ra_units='degree',
dec_units='degree')
if 'random_bin' in data:
random_mask = data['random_bin'] == i
rancat = treecorr.Catalog(ra=data['random_ra'][random_mask],
dec=data['random_dec'][random_mask],
ra_units='degree',
dec_units='degree')
else:
rancat = None
return cat, rancat
def test_pairwise():
# Test the pairwise option.
ngal = 1000
s = 10.
np.random.seed(8675309)
x1 = np.random.normal(0,s, (ngal,) )
y1 = np.random.normal(0,s, (ngal,) )
w1 = np.random.random(ngal)
x2 = np.random.normal(0,s, (ngal,) )
y2 = np.random.normal(0,s, (ngal,) )
w2 = np.random.random(ngal)
k2 = np.random.normal(0,3, (ngal,) )
w1 = np.ones_like(w1)
w2 = np.ones_like(w2)
cat1 = treecorr.Catalog(x=x1, y=y1, w=w1)
cat2 = treecorr.Catalog(x=x2, y=y2, w=w2, k=k2)
min_sep = 5.
max_sep = 50.
nbins = 10
bin_size = np.log(max_sep/min_sep) / nbins
nk = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
nk.process_pairwise(cat1, cat2)
nk.finalize(cat2.vark)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=float)
rsq = (x1-x2)**2 + (y1-y2)**2
r = np.sqrt(rsq)
logr = np.log(r)
ww = w1 * w2
xi = ww * k2
index = np.floor(np.log(r/min_sep) / bin_size).astype(int)
mask = (index >= 0) & (index < nbins)
np.add.at(true_npairs, index[mask], 1)
np.add.at(true_weight, index[mask], ww[mask])
np.add.at(true_xi, index[mask], xi[mask])
true_xi /= true_weight
np.testing.assert_array_equal(nk.npairs, true_npairs)
np.testing.assert_allclose(nk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
np.testing.assert_allclose(nk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
# If cats have names, then the logger will mention them.
# Also, test running with optional args.
cat1.name = "first"
cat2.name = "second"
with CaptureLog() as cl:
nk.logger = cl.logger
nk.process_pairwise(cat1, cat2, metric='Euclidean', num_threads=2)
assert "for cats first, second" in cl.output
def test_getCF(self):
"""Test getCF() directly, without first processing by child classes."""
stile_args = {'ra_units': 'degrees', 'dec_units': 'degrees', 'min_sep': 0.05, 'max_sep': 1,
'sep_units': 'degrees', 'nbins': 20}
cf = stile.sys_tests.CorrelationFunctionSysTest()
dh = temp_data_handler()
lens_data = stile.ReadASCIITable('../examples/example_lens_catalog.dat',
fields={'id': 0, 'ra': 1, 'dec': 2, 'z': 3, 'g1': 4, 'g2': 5})
source_data = stile.ReadASCIITable('../examples/example_source_catalog.dat',
fields={'id': 0, 'ra': 1, 'dec': 2, 'z': 3, 'g1': 4, 'g2': 5})
lens_catalog = treecorr.Catalog(ra=numpy.array([lens_data['ra']]),
dec=numpy.array([lens_data['dec']]),
ra_units='degrees', dec_units='degrees')
source_catalog = treecorr.Catalog(ra=source_data['ra'], dec=source_data['dec'],
g1=source_data['g1'], g2=source_data['g2'],
ra_units='degrees', dec_units='degrees')
results = cf.getCF('ng', lens_catalog, source_catalog, **stile_args)
numpy.testing.assert_array_equal(*helper.FormatSame(results, self.expected_result))
results2 = cf.getCF('ng', lens_data, source_data, config=stile_args)
self.assertEqual(self.expected_result.dtype.names, results.dtype.names)
# Missing necessary data file
numpy.testing.assert_equal(results, results2)
self.assertRaises(TypeError,
cf.getCF, {}, 'ng',
file_name='../examples/example_lens_catalog.dat')
# Nonsensical correlation type
self.assertRaises(ValueError, cf.getCF, 'hello', lens_data, source_data, config=stile_args)
# Then, test a test that uses .getCF().
realshear = stile.sys_tests.GalaxyShearSysTest()
results3 = realshear(lens_data, source_data, config=stile_args)
numpy.testing.assert_equal(results, results3)
def get_xi_window_norm(window=None, nside=None):
window_norm = {corr: {} for corr in corrs}
mask = {}
for tracer in window.keys():
# window[tracer]=kappa_class.z_bins[tracer][0]['window']
mask[tracer] = window[tracer] == hp.UNSEEN
# window[tracer]=window[tracer][~mask[tracer]]
fsky = mask[tracer].mean()
cat0 = {'fullsky': np.ones_like(mask)}
tree_cat_args0 = get_treecorr_cat_args(cat0, masks=None, nside=nside)
tree_cat0 = treecorr.Catalog(**tree_cat_args0['fullsky'])
tree_corrs0 = treecorr.NNCorrelation(**corr_config)
_ = tree_corrs0.process(tree_cat0, tree_cat0)
npairs0 = tree_corrs0.npairs * fsky
del cat0, tree_cat0, tree_corrs0
tree_cat_args = get_treecorr_cat_args(window, masks=mask, nside=nside)
tree_cat = {
tracer: treecorr.Catalog(w=window[tracer][~mask[tracer]],
**tree_cat_args[tracer])
for tracer in window.keys()
}
del mask
for corr in corrs:
tree_corrs = treecorr.NNCorrelation(**corr_config)
_ = tree_corrs.process(tree_cat[corr[0]], tree_cat[corr[1]])
window_norm[corr]['weight'] = tree_corrs.weight
window_norm[corr]['npairs'] = tree_corrs.npairs
window_norm[corr]['npairs0'] = npairs0
del tree_cat, tree_corrs
return window_norm
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 calc_2pt(data,
randoms,
config_fname,
zvar,
random_zvar,
ra_var='RA',
dec_var='DEC',
random_ra_var='RA',
random_dec_var='DEC'):
config_2pt = load_config(config_fname)['2PCF']
cat = treecorr.Catalog(
ra=data[ra_var],
dec=data[dec_var],
dec_units='degrees',
ra_units='degrees',
)
random_cat = treecorr.Catalog(
ra=randoms[random_ra_var],
dec=randoms[random_dec_var],
dec_units='degrees',
ra_units='degrees',
)
print config_2pt
dd = treecorr.NNCorrelation(config=config_2pt)
dr = treecorr.NNCorrelation(config=config_2pt)
rr = treecorr.NNCorrelation(config=config_2pt)
dd.process(cat, metric=config_2pt['metric'])
dr.process(cat, random_cat, metric=config_2pt['metric'])
rr.process(random_cat, metric=config_2pt['metric'])
xi, varxi = dd.calculateXi(dr=dr, rr=rr)
return xi
def correlate(self,group1=0,group2=0):
print 'Will correlate galaxies in groups %d and %d'%(group1,group2)
data1 = self.get(table='subfind_halos' , fields='groupId, x, y, z', cond='subfind_halos.snapnum = %d AND subfind_halos.groupId = %d'%(self.snapshot, group1))
data2 = self.get(table='subfind_halos' , fields='groupId, x, y, z', cond='subfind_halos.snapnum = %d AND subfind_halos.groupId = %d'%(self.snapshot, group2))
#Setup the correlation
print 'Setting up correlation'
corr = treecorr.NNCorrelation(nbins=15, min_sep=30, max_sep=4e3)
cat1 = treecorr.Catalog(x=data1['x'],y=data1['y'],z=data1['z'])
cat2 = treecorr.Catalog(x=data2['x'],y=data2['y'],z=data2['z'])
print 'Calculating...'
corr.process(cat1,cat2)
print 'Random-Random'
rr = treecorr.NNCorrelation(nbins=15, min_sep=30, max_sep=4e3)
rx,ry,rz = np.random.choice(data1['x'], size=5000),np.random.choice(data1['y'], size=5000),np.random.choice(data1['z'], size=5000)
rcat = treecorr.Catalog(x=rx, y=ry, z=rz)
rr.process(rcat)
print 'Data-Random'
dr = treecorr.NNCorrelation(nbins=15, min_sep=30, max_sep=4e3)
dr.process(rcat, cat2)
print 'Random-Data'
rd = treecorr.NNCorrelation(nbins=15, min_sep=30, max_sep=4e3)
rd.process(cat1, rcat)
xi,varxi = corr.calculateXi(rr,dr,rd)
return np.exp(corr.logr), xi, varxi
def test_constant():
# A fairly trivial test is to use a constant value of kappa everywhere.
ngal = 100000
A = 0.05
L = 100.
numpy.random.seed(8675309)
x = (numpy.random.random_sample(ngal) - 0.5) * L
y = (numpy.random.random_sample(ngal) - 0.5) * L
kappa = A * numpy.ones(ngal)
cat = treecorr.Catalog(x=x,
y=y,
k=kappa,
x_units='arcmin',
y_units='arcmin')
kk = treecorr.KKCorrelation(bin_size=0.1,
min_sep=0.1,
max_sep=10.,
sep_units='arcmin')
kk.process(cat)
print('kk.xi = ', kk.xi)
numpy.testing.assert_almost_equal(kk.xi, A**2, decimal=10)
# Now add some noise to the values. It should still work, but at slightly lower accuracy.
kappa += 0.001 * (numpy.random.random_sample(ngal) - 0.5)
cat = treecorr.Catalog(x=x,
y=y,
k=kappa,
x_units='arcmin',
y_units='arcmin')
kk.process(cat)
print('kk.xi = ', kk.xi)
numpy.testing.assert_almost_equal(kk.xi, A**2, decimal=6)
def compute_gg_treecorr(cat1, cat2, options, nbins, ijk):
print('Using treecorr', treecorr.version)
slop = 0.1
# arrays to store the output
r = np.zeros(nbins)
DD = np.zeros_like(r)
DR = np.zeros_like(r)
RR = np.zeros_like(r)
RD = np.zeros_like(r)
# Set up the catalogues
rcat1, rcat2, _, _ = randoms(cat1, cat2, ijk, period=options['box_size'])
#import pdb ; pdb.set_trace()
cat1 = treecorr.Catalog(g1=None, g2=None, x=cat1['x'], y=cat1['y'], z=cat1['z'])
cat2 = treecorr.Catalog(g1=None, g2=None, x=cat2['x'], y=cat2['y'], z=cat2['z'])
NR1 = rcat1.x.size * 1.0
NR2 = rcat2.x.size * 1.0
ND1 = cat1.x.size * 1.0
ND2 = cat2.x.size * 1.0
f0 = (NR1*NR2)/(ND1*ND2)
f1 = (NR1*NR2)/(ND1*NR2)
f2 = (NR1*NR2)/(ND2*NR1)
print('Processing DD')
nn = treecorr.NNCorrelation(nbins=nbins, min_sep=options['rlim'][0], max_sep=options['rlim'][1], bin_slop=slop, verbose=0, period=options['box_size'])
#nn.process(rcat1, rcat2, period=options['box_size'], metric='Periodic')
nn.process(cat1, cat2, metric='Periodic')
nn.finalize()
DD = np.copy(nn.weight)
rp_bins = np.copy(nn.rnom)
nn.clear()
print('Processing RD')
nn = treecorr.NNCorrelation(nbins=nbins, min_sep=options['rlim'][0], max_sep=options['rlim'][1], bin_slop=slop, verbose=0, period=options['box_size'])
nn.process(rcat1, cat2, metric='Periodic')
RD = np.copy(nn.weight)
nn.clear()
print('Processing DR')
nn = treecorr.NNCorrelation(nbins=nbins, min_sep=options['rlim'][0], max_sep=options['rlim'][1], bin_slop=slop, verbose=0, period=options['box_size'])
nn.process(cat1, rcat2, metric='Periodic')
DR = np.copy(nn.weight)
nn.clear()
print('Processing RR')
nn = treecorr.NNCorrelation(nbins=nbins, min_sep=options['rlim'][0], max_sep=options['rlim'][1], bin_slop=slop, verbose=0, period=options['box_size'])
nn.process(rcat1, rcat2, metric='Periodic')
RR = np.copy(nn.weight)
nn.clear()
gg = (f0 * DD/RR) - (f1 * DR/RR) - (f2 * RD/RR) + 1.0
return gg
def correlate_data(self):
cat_c = treecorr.Catalog(ra=self.c_rel[0].copy(),
dec=self.c_rel[1].copy(),
r=self.c_rel[3].copy(),
ra_units='deg',
dec_units='deg')
self.nn = treecorr.NNCorrelation(min_sep=self.min_sep,
max_sep=self.max_sep,
nbins=self.nbins,
metric='Rlens')
self.cat_g = treecorr.Catalog(ra=self.b_g_rel[0].copy(),
dec=self.b_g_rel[1].copy(),
w=np.power(self.b_g_rel[2].copy(),
self.n),
ra_units='deg',
dec_units='deg')
self.nn.process(cat_c, self.cat_g)
z_bar = self.nn.weight.copy() / self.nn.npairs.copy()
self.mean_z = np.average(np.power(self.b_g_rel[2], self.n))
self.del_z_bar = z_bar - self.mean_z
self.N = self.nn.npairs.copy()
self.sep = self.nn.meanr.copy()
return None
def correlate_data(self):
self.del_z_bars = np.zeros((self.n, self.nbins))
self.N = np.zeros(self.nbins)
self.seps = np.zeros((self.n, self.nbins))
cat_c = treecorr.Catalog(ra=self.c_rel[0].copy(),
dec=self.c_rel[1].copy(),
r=self.c_rel[3].copy(),
ra_units='deg',
dec_units='deg')
nn = treecorr.NNCorrelation(min_sep=self.min_sep,
max_sep=self.max_sep,
nbins=self.nbins,
metric='Rlens')
for i in range(self.n):
cat_g = treecorr.Catalog(ra=self.b_g_rel[0].copy(),
dec=self.b_g_rel[1].copy(),
w=np.power(self.b_g_rel[2].copy(), i + 1),
ra_units='deg',
dec_units='deg')
nn.process(cat_c, cat_g)
z_bar = nn.weight.copy() / nn.npairs.copy()
mean_z = np.average(np.power(self.b_g_rel[2], i + 1))
self.del_z_bars[i, :] = z_bar - mean_z
self.N = nn.npairs.copy()
self.seps[i] = nn.meanr.copy()
return None
def _get_corrs_nosep(self, data, min_sep=44, max_sep=1e6, binning='log', nbins=20, ctype=('s','s'), estimator='Landy-Szalay', verbosity=1, randoms=None, method='halotools'):
if verbosity>0:
print 'Will construct %s - %s correlation functions'%ctype
print 'Using %s estimator'%estimator
# Decide on an appropriate binning scheme
if (binning.lower()=='log'):
rbins = np.logspace(np.log10(min_sep), np.log10(max_sep), nbins )
elif (binning.lower()=='linear'):
rbins = np.linspace(min_sep, max_sep, nbins )
if verbosity>1:
print 'Will use %s binning:'%binning, rbins
# Parse the mask
mask1 = util.choose_cs_mask(data,ctype[0])
mask2 = util.choose_cs_mask(data,ctype[1])
pos1 = pretending.return_xyz_formatted_array(data['x'], data['y'], data['z'], mask = mask1)
pos2 = pretending.return_xyz_formatted_array(data['x'], data['y'], data['z'], mask = mask2)
# And do the randoms
if randoms is None:
r1 = util.construct_random_cat(data, mask=mask1)
r2 = util.construct_random_cat(data, mask=mask2)
else:
if verbosity>0:
print 'Using random points provided for normalisation.'
r1 = randoms
R = np.sqrt(np.array(rbins)[1:]*np.array(rbins)[:-1])
print 'Using %s to calculate two-point correlations'%method
if method=='halotools':
return R, pretending.tpcf(pos1, rbins, sample2=pos2, randoms=r1, period=info.Lbox, estimator=estimator )
elif method=='treecorr':
print 'Constructing catalogues...'
cat_i = treecorr.Catalog(x=data['x'][mask1], y=data['y'][mask1], z=data['z'][mask1])
cat_j = treecorr.Catalog(x=data['x'][mask2], y=data['y'][mask2], z=data['z'][mask2])
rx_1 = (np.random.random(size=data['x'][mask1].size) - 0.5) * (data['x'][mask1].max()-data['x'][mask1].min()) + data['x'][mask1].mean()
ry_1 = (np.random.random(size=data['x'][mask1].size) - 0.5) * (data['y'][mask1].max()-data['y'][mask1].min()) + data['y'][mask1].mean()
rz_1 = (np.random.random(size=data['x'][mask1].size) - 0.5) * (data['z'][mask1].max()-data['z'][mask1].min()) + data['z'][mask1].mean()
rancat_1 = treecorr.Catalog(x=rx_1, y=ry_1, z=rz_1)
print 'Correlating...'
nn = treecorr.NNCorrelation(nbins=nbins, min_sep=min_sep, max_sep=max_sep, bin_slop=0.1)
nr = treecorr.NNCorrelation(nbins=nbins, min_sep=min_sep, max_sep=max_sep, bin_slop=0.1)
rn = treecorr.NNCorrelation(nbins=nbins, min_sep=min_sep, max_sep=max_sep, bin_slop=0.1)
rr = treecorr.NNCorrelation(nbins=nbins, min_sep=min_sep, max_sep=max_sep, bin_slop=0.1)
nn.process(cat_i,cat_j)
nr.process(rancat_1,cat_i)
rn.process(cat_j,rancat_1)
rr.process(rancat_1,rancat_1)
R = np.exp(nn.meanlogr)
w = (nn.weight - nr.weight - rn.weight + rr.weight) / rr.weight
return R, w
def test_fits():
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
get_from_wiki('Aardvark.fit')
file_name = os.path.join('data','Aardvark.fit')
config = treecorr.read_config('Aardvark.yaml')
config['verbose'] = 1
# Just test a few random particular values
cat1 = treecorr.Catalog(file_name, config)
np.testing.assert_equal(len(cat1.ra), 390935)
np.testing.assert_equal(cat1.nobj, 390935)
np.testing.assert_almost_equal(cat1.ra[0], 56.4195 * (pi/180.))
np.testing.assert_almost_equal(cat1.ra[390934], 78.4782 * (pi/180.))
np.testing.assert_almost_equal(cat1.dec[290333], 83.1579 * (pi/180.))
np.testing.assert_almost_equal(cat1.g1[46392], 0.0005066675)
np.testing.assert_almost_equal(cat1.g2[46392], -0.0001006742)
np.testing.assert_almost_equal(cat1.k[46392], -0.0008628797)
# The catalog doesn't have x, y, or w, but test that functionality as well.
del config['ra_col']
del config['dec_col']
config['x_col'] = 'RA'
config['y_col'] = 'DEC'
config['w_col'] = 'MU'
config['flag_col'] = 'INDEX'
config['ignore_flag'] = 64
cat2 = treecorr.Catalog(file_name, config)
np.testing.assert_almost_equal(cat2.x[390934], 78.4782, decimal=4)
np.testing.assert_almost_equal(cat2.y[290333], 83.1579, decimal=4)
np.testing.assert_almost_equal(cat2.w[46392], 0.) # index = 1200379
np.testing.assert_almost_equal(cat2.w[46393], 0.9995946) # index = 1200386
# Test using a limited set of rows
config['first_row'] = 101
config['last_row'] = 50000
cat3 = treecorr.Catalog(file_name, config)
np.testing.assert_equal(len(cat3.x), 49900)
np.testing.assert_equal(cat3.ntot, 49900)
np.testing.assert_equal(cat3.nobj, sum(cat3.w != 0))
np.testing.assert_equal(cat3.sumw, sum(cat3.w))
np.testing.assert_equal(cat3.sumw, sum(cat2.w[100:50000]))
np.testing.assert_almost_equal(cat3.g1[46292], 0.0005066675)
np.testing.assert_almost_equal(cat3.g2[46292], -0.0001006742)
np.testing.assert_almost_equal(cat3.k[46292], -0.0008628797)
cat4 = treecorr.read_catalogs(config, key='file_name', is_rand=True)[0]
np.testing.assert_equal(len(cat4.x), 49900)
np.testing.assert_equal(cat4.ntot, 49900)
np.testing.assert_equal(cat4.nobj, sum(cat4.w != 0))
np.testing.assert_equal(cat4.sumw, sum(cat4.w))
np.testing.assert_equal(cat4.sumw, sum(cat2.w[100:50000]))
assert cat4.g1 is None
assert cat4.g2 is None
assert cat4.k is None
def correlation_TreeCorr(data_ra, data_dec, data_r, rand_ra, rand_dec, rand_r, config) :
import time
import numpy as np
import treecorr
import sys
# Begin timing
start = time.time()
# Make sure arrays match
assert data_ra.size == data_dec.size, "Data must have both RA and DEC"
assert rand_ra.size == rand_dec.size, "Randoms must have both RA and DEC"
# Create TreeCorr catalog objects
dcat = treecorr.Catalog(ra=data_ra, dec=data_dec, r=data_r, ra_units='deg', dec_units='deg')
rcat = treecorr.Catalog(ra=rand_ra, dec=rand_dec, r=rand_r, ra_units='deg', dec_units='deg')
print ('TreeCorr catalogs created')
sys.stdout.flush()
# Run TreeCorr processes for DD, DR, RD, and RR
dd = treecorr.NNCorrelation(config)
dr = treecorr.NNCorrelation(config)
# rd = treecorr.NNCorrelation(config)
rr = treecorr.NNCorrelation(config)
dd.process(dcat)
print ('DD done')
sys.stdout.flush()
# I also need to get the bin locations for plotting
logr = dd.logr
dr.process(dcat, rcat)
print ('DR done')
sys.stdout.flush()
# rd.process(rcat, dcat)
# print ('RD done')
# sys.stdout.flush()
rr.process(rcat)
print ('RR done')
sys.stdout.flush()
# Find the correlation function and errors
# xi, varxi = dd.calculateXi(rr, dr, rd)
xi, varxi = dd.calculateXi(rr, dr)
print ('Correlation function and errors calculated')
sys.stdout.flush()
# Find elapsed time
runtime = time.time() - start
del start
## Print the time it took
h = int(np.floor(runtime/(60.0*60.0)))
m = int(np.floor((runtime - (60.0*60.0*h))/60.0))
s = runtime - 60.0*60.0*h - 60.0*m
print ('Elapsed time: {:>02d}:{:>02d}:{:>05.2f}'.format(h, m, s))
sys.stdout.flush()
del runtime, h, m, s
# Return xi, varxi, and bin locations
return (xi, varxi, logr)
def measure_rho(ra, dec, e1, e2, s, m_e1, m_e2, m_s, max_sep, tag=None):
"""Compute the rho statistics
"""
import treecorr
de1 = e1 - m_e1
de2 = e2 - m_e2
dt = (s**2 - m_s**2) / s**2
ecat = treecorr.Catalog(ra=ra,
dec=dec,
ra_units='deg',
dec_units='deg',
g1=e1,
g2=e2)
decat = treecorr.Catalog(ra=ra,
dec=dec,
ra_units='deg',
dec_units='deg',
g1=de1,
g2=de2)
dtcat = treecorr.Catalog(ra=ra,
dec=dec,
ra_units='deg',
dec_units='deg',
k=dt,
g1=dt * e1,
g2=dt * e2)
ecat.name = 'ecat'
decat.name = 'decat'
dtcat.name = 'dtcat'
if tag is not None:
for cat in [ecat, decat, dtcat]:
cat.name = tag + ":" + cat.name
min_sep = 0.5
bin_size = 0.5
bin_slop = 0.1
results = []
for (cat1, cat2) in [(decat, decat), (ecat, decat), (dtcat, dtcat),
(decat, dtcat), (ecat, dtcat)]:
print 'Doing correlation of %s vs %s' % (cat1.name, cat2.name)
rho = treecorr.GGCorrelation(min_sep=min_sep,
max_sep=max_sep,
sep_units='arcmin',
bin_size=bin_size,
bin_slop=bin_slop,
verbose=2)
if cat1 is cat2:
rho.process(cat1)
else:
rho.process(cat1, cat2)
results.append(rho)
return results
def test_single():
# Use kappa(r) = kappa0 exp(-r^2/2r0^2) (1-r^2/2r0^2) around a single lens
nsource = 1000000
kappa0 = 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)
k = kappa0 * numpy.exp(-0.5 * r2 / r0**2) * (1. - 0.5 * r2 / r0**2)
lens_cat = treecorr.Catalog(x=[0],
y=[0],
x_units='arcmin',
y_units='arcmin')
source_cat = treecorr.Catalog(x=x,
y=y,
k=k,
x_units='arcmin',
y_units='arcmin')
nk = treecorr.NKCorrelation(bin_size=0.1,
min_sep=1.,
max_sep=25.,
sep_units='arcmin',
verbose=1)
nk.process(lens_cat, source_cat)
r = nk.meanr
true_k = kappa0 * numpy.exp(
-0.5 * r**2 / r0**2) * (1. - 0.5 * r**2 / r0**2)
print('nk.xi = ', nk.xi)
print('true_kappa = ', true_k)
print('ratio = ', nk.xi / true_k)
print('diff = ', nk.xi - true_k)
print('max diff = ', max(abs(nk.xi - true_k)))
assert max(abs(nk.xi - true_k)) < 4.e-4
# Check that we get the same result using the corr2 executable:
if __name__ == '__main__':
lens_cat.write(os.path.join('data', 'nk_single_lens.dat'))
source_cat.write(os.path.join('data', 'nk_single_source.dat'))
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen([corr2_exe, "nk_single.yaml"])
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output',
'nk_single.out'),
names=True)
print('nk.xi = ', nk.xi)
print('from corr2 output = ', corr2_output['kappa'])
print('ratio = ', corr2_output['kappa'] / nk.xi)
print('diff = ', corr2_output['kappa'] - nk.xi)
numpy.testing.assert_almost_equal(corr2_output['kappa'] / nk.xi,
1.,
decimal=3)
def loadGalaxy():
print 'loading SuperCosmos catalog and mask...'
catalog = np.load('datalog/wisecatalog.npy')
scosmask = healpy.read_map('WISExSCOSmask.fits', verbose=False)
num = 30000000
coord = SkyCoord(catalog[0], catalog[1], frame='icrs', unit='deg').galactic
l, b = coord.l.deg, coord.b.deg
catalog = catalog[:, scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
cat_galaxy = treecorr.Catalog(ra=catalog[0],
dec=catalog[1],
ra_units='deg',
dec_units='deg')
print('Done!\n')
print 'generating random galaxy catalog'
#plt.scatter(catalog[0],catalog[1],s=0.01)
#plt.xlabel('RA(deg)')
#plt.ylabel('DEC(deg)')
#plt.show()
ra_min = np.min(cat_galaxy.ra)
ra_max = np.max(cat_galaxy.ra)
dec_min = np.min(cat_galaxy.dec)
dec_max = np.max(cat_galaxy.dec)
#print('ra range = %f .. %f' % (ra_min, ra_max))
#print('dec range = %f .. %f' % (dec_min, dec_max))
rand_ra = np.random.uniform(ra_min, ra_max, num)
rand_sindec = np.random.uniform(np.sin(dec_min), np.sin(dec_max), num)
rand_dec = np.arcsin(rand_sindec)
coord = SkyCoord(rand_ra, rand_dec, frame='icrs', unit='rad').galactic
l, b = coord.l.deg, coord.b.deg
rand_ra = rand_ra[scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
rand_dec = rand_dec[scosmask[healpy.ang2pix(
256, l, b, nest=False, lonlat=True)] == 1]
cat_rand = treecorr.Catalog(ra=rand_ra,
dec=rand_dec,
ra_units='radians',
dec_units='radians')
#plt.scatter(np.rad2deg(rand_ra),np.rad2deg(rand_dec),s=0.01)
#plt.xlabel('RA(deg)')
#plt.ylabel('DEC(deg)')
#plt.show()
print('Done!\n')
return cat_galaxy, cat_rand
def compute_statistic(self, i, ra, dec, q1, q2):
n = len(ra)
print(f"Computing Rowe statistic rho_{i} from {n} objects")
import treecorr
corr = treecorr.GGCorrelation(self.config)
cat1 = treecorr.Catalog(ra=ra, dec=dec, g1=q1[0], g2=q1[1], ra_units='deg', dec_units='deg')
cat2 = treecorr.Catalog(ra=ra, dec=dec, g1=q2[0], g2=q2[1], ra_units='deg', dec_units='deg')
corr.process(cat1, cat2)
return corr.meanr, corr.xip, corr.varxip**0.5
def calculate_cross(config, all_halos, all_dms, halorandoms, dmrandoms, step,
ndivs, Njk):
"""
Calcualte the DD, DR, RD and RR cross correlations
"""
#Inititalize these objects
DDc_all = []
DRc_all = []
RDc_all = []
RRc_all = []
for i in xrange(0, Njk):
DDc_all.append(treecorr.NNCorrelation(config))
DRc_all.append(treecorr.NNCorrelation(config))
RDc_all.append(treecorr.NNCorrelation(config))
RRc_all.append(treecorr.NNCorrelation(config))
for index1 in xrange(0, Njk):
halos = all_halos[index1]
halo_cat = treecorr.Catalog(x=halos[:, 0],
y=halos[:, 1],
z=halos[:, 2],
config=config)
i1 = index1 % ndivs
j1 = (index1 / ndivs) % ndivs
k1 = index1 / ndivs**2
dmrandom_cat = treecorr.Catalog(x=dmrandoms[:, 0] + i1 * step,
y=dmrandoms[:, 1] + j1 * step,
z=dmrandoms[:, 2] + k1 * step,
config=config)
for index2 in xrange(index1 + 1, Njk):
dm = all_dms[index2]
dm_cat = treecorr.Catalog(x=dm[:, 0],
y=dm[:, 1],
z=dm[:, 2],
config=config)
i2 = index2 % ndivs
j2 = (index2 / ndivs) % ndivs
k2 = index2 / ndivs**2
halorandom_cat = treecorr.Catalog(x=halorandoms[:, 0] + i2 * step,
y=halorandoms[:, 1] + j2 * step,
z=halorandoms[:, 2] + k2 * step,
config=config)
DD = treecorr.NNCorrelation(config)
DR = treecorr.NNCorrelation(config)
RD = treecorr.NNCorrelation(config)
RR = treecorr.NNCorrelation(config)
DD.process(halo_cat, dm_cat)
DR.process(halo_cat, halorandom_cat)
RD.process(dm_cat, dmrandom_cat)
RR.process(dmrandom_cat, halorandom_cat)
DDc_all[index1] += DD
DDc_all[index2] += DD
DRc_all[index1] += DR
RDc_all[index2] += RD
RRc_all[index1] += RR
RRc_all[index2] += RR
return DDc_all, DRc_all, RDc_all, RRc_all
