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 = 100000
gamma0 = 0.05
kappa = 0.23
r0 = 10.
L = 5. * r0
rng = np.random.RandomState(8675309)
x = (rng.random_sample(nsource)-0.5) * L
y = (rng.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
gammat = gamma0 * np.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], k=[kappa], x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=x, y=y, g1=g1, g2=g2, x_units='arcmin', y_units='arcmin')
kg = treecorr.KGCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
kg.process(lens_cat, source_cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ',kg.meanlogr - np.log(kg.meanr))
np.testing.assert_allclose(kg.meanlogr, np.log(kg.meanr), atol=1.e-3)
r = kg.meanr
true_kgt = kappa * gamma0 * np.exp(-0.5*r**2/r0**2)
print('kg.xi = ',kg.xi)
print('kg.xi_im = ',kg.xi_im)
print('true_gammat = ',true_kgt)
print('ratio = ',kg.xi / true_kgt)
print('diff = ',kg.xi - true_kgt)
print('max diff = ',max(abs(kg.xi - true_kgt)))
np.testing.assert_allclose(kg.xi, true_kgt, rtol=1.e-2)
np.testing.assert_allclose(kg.xi_im, 0, atol=1.e-4)
# Check that we get the same result using the corr2 function:
lens_cat.write(os.path.join('data','kg_single_lens.dat'))
source_cat.write(os.path.join('data','kg_single_source.dat'))
config = treecorr.read_config('configs/kg_single.yaml')
config['verbose'] = 0
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','kg_single.out'), names=True,
skip_header=1)
print('kg.xi = ',kg.xi)
print('from corr2 output = ',corr2_output['kgamT'])
print('ratio = ',corr2_output['kgamT']/kg.xi)
print('diff = ',corr2_output['kgamT']-kg.xi)
np.testing.assert_allclose(corr2_output['kgamT'], kg.xi, rtol=1.e-3)
print('xi_im from corr2 output = ',corr2_output['kgamX'])
np.testing.assert_allclose(corr2_output['kgamX'], 0., atol=1.e-4)
def test_single():
# Use kappa(r) = kappa0 exp(-r^2/2r0^2) (1-r^2/2r0^2) around a single lens
nsource = 100000
kappa0 = 0.05
r0 = 10.
L = 5. * r0
np.random.seed(8675309)
x = (np.random.random_sample(nsource)-0.5) * L
y = (np.random.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
k = kappa0 * np.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 * np.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)))
# Note: there is a zero crossing, so need to include atol as well as rtol
np.testing.assert_allclose(nk.xi, true_k, rtol=1.e-2, atol=1.e-4)
# Check that we get the same result using the corr2 function
lens_cat.write(os.path.join('data','nk_single_lens.dat'))
source_cat.write(os.path.join('data','nk_single_source.dat'))
config = treecorr.read_config('configs/nk_single.yaml')
config['verbose'] = 0
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','nk_single.out'), names=True,
skip_header=1)
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)
np.testing.assert_allclose(corr2_output['kappa'], nk.xi, rtol=1.e-3)
# There is special handling for single-row catalogs when using np.genfromtxt rather
# than pandas. So mock it up to make sure we test it.
if sys.version_info < (3,): return # mock only available on python 3
from unittest import mock
with mock.patch.dict(sys.modules, {'pandas':None}):
with CaptureLog() as cl:
treecorr.corr2(config, logger=cl.logger)
assert "Unable to import pandas" in cl.output
corr2_output = np.genfromtxt(os.path.join('output','nk_single.out'), names=True,
skip_header=1)
np.testing.assert_allclose(corr2_output['kappa'], nk.xi, rtol=1.e-3)
def test_single():
# Use kappa(r) = kappa0 exp(-r^2/2r0^2) (1-r^2/2r0^2) around a single lens
nsource = 100000
kappa0 = 0.05
r0 = 10.
L = 5. * r0
rng = np.random.RandomState(8675309)
x = (rng.random_sample(nsource)-0.5) * L
y = (rng.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
k = kappa0 * np.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 * np.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)))
# Note: there is a zero crossing, so need to include atol as well as rtol
np.testing.assert_allclose(nk.xi, true_k, rtol=1.e-2, atol=1.e-4)
# Check that we get the same result using the corr2 function
lens_cat.write(os.path.join('data','nk_single_lens.dat'))
source_cat.write(os.path.join('data','nk_single_source.dat'))
config = treecorr.read_config('configs/nk_single.yaml')
config['verbose'] = 0
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','nk_single.out'), names=True,
skip_header=1)
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)
np.testing.assert_allclose(corr2_output['kappa'], nk.xi, rtol=1.e-3)
# There is special handling for single-row catalogs when using np.genfromtxt rather
# than pandas. So mock it up to make sure we test it.
if sys.version_info < (3,): return # mock only available on python 3
from unittest import mock
with mock.patch.dict(sys.modules, {'pandas':None}):
with CaptureLog() as cl:
treecorr.corr2(config, logger=cl.logger)
assert "Unable to import pandas" in cl.output
corr2_output = np.genfromtxt(os.path.join('output','nk_single.out'), names=True,
skip_header=1)
np.testing.assert_allclose(corr2_output['kappa'], nk.xi, rtol=1.e-3)
def test_pairwise2():
# Test the same profile, but with the pairwise calcualtion:
nsource = 100000
gamma0 = 0.05
kappa = 0.23
r0 = 10.
L = 5. * r0
rng = np.random.RandomState(8675309)
x = (rng.random_sample(nsource)-0.5) * L
y = (rng.random_sample(nsource)-0.5) * L
r2 = (x**2 + y**2)
gammat = gamma0 * np.exp(-0.5*r2/r0**2)
g1 = -gammat * (x**2-y**2)/r2
g2 = -gammat * (2.*x*y)/r2
dx = (rng.random_sample(nsource)-0.5) * L
dx = (rng.random_sample(nsource)-0.5) * L
k = kappa * np.ones(nsource)
lens_cat = treecorr.Catalog(x=dx, y=dx, k=k, 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')
kg = treecorr.KGCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1, pairwise=True)
kg.process(lens_cat, source_cat)
r = kg.meanr
true_kgt = kappa * gamma0 * np.exp(-0.5*r**2/r0**2)
print('kg.xi = ',kg.xi)
print('kg.xi_im = ',kg.xi_im)
print('true_gammat = ',true_kgt)
print('ratio = ',kg.xi / true_kgt)
print('diff = ',kg.xi - true_kgt)
print('max diff = ',max(abs(kg.xi - true_kgt)))
np.testing.assert_allclose(kg.xi, true_kgt, rtol=1.e-2)
np.testing.assert_allclose(kg.xi_im, 0, atol=1.e-4)
# Check that we get the same result using the corr2 function
lens_cat.write(os.path.join('data','kg_pairwise_lens.dat'))
source_cat.write(os.path.join('data','kg_pairwise_source.dat'))
config = treecorr.read_config('configs/kg_pairwise.yaml')
config['verbose'] = 0
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','kg_pairwise.out'), names=True,
skip_header=1)
print('kg.xi = ',kg.xi)
print('from corr2 output = ',corr2_output['kgamT'])
print('ratio = ',corr2_output['kgamT']/kg.xi)
print('diff = ',corr2_output['kgamT']-kg.xi)
np.testing.assert_allclose(corr2_output['kgamT'], kg.xi, rtol=1.e-3)
print('xi_im from corr2 output = ',corr2_output['kgamX'])
np.testing.assert_allclose(corr2_output['kgamX'], 0., atol=1.e-4)
def test_direct_spherical():
# Repeat in spherical coords
ngal = 100
s = 10.
rng = np.random.RandomState(8675309)
x1 = rng.normal(0,s, (ngal,) )
y1 = rng.normal(0,s, (ngal,) ) + 200 # Put everything at large y, so small angle on sky
z1 = rng.normal(0,s, (ngal,) )
w1 = rng.random_sample(ngal)
k1 = rng.normal(5,1, (ngal,) )
x2 = rng.normal(0,s, (ngal,) )
y2 = rng.normal(0,s, (ngal,) ) + 200
z2 = rng.normal(0,s, (ngal,) )
w2 = rng.random_sample(ngal)
g12 = rng.normal(0,0.2, (ngal,) )
g22 = rng.normal(0,0.2, (ngal,) )
ra1, dec1 = coord.CelestialCoord.xyz_to_radec(x1,y1,z1)
ra2, dec2 = coord.CelestialCoord.xyz_to_radec(x2,y2,z2)
cat1 = treecorr.Catalog(ra=ra1, dec=dec1, ra_units='rad', dec_units='rad', w=w1, k=k1)
cat2 = treecorr.Catalog(ra=ra2, dec=dec2, ra_units='rad', dec_units='rad', w=w2, g1=g12, g2=g22)
min_sep = 1.
max_sep = 10.
nbins = 50
bin_size = np.log(max_sep/min_sep) / nbins
kg = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins,
sep_units='deg', brute=True)
kg.process(cat1, cat2)
r1 = np.sqrt(x1**2 + y1**2 + z1**2)
r2 = np.sqrt(x2**2 + y2**2 + z2**2)
x1 /= r1; y1 /= r1; z1 /= r1
x2 /= r2; y2 /= r2; z2 /= r2
north_pole = coord.CelestialCoord(0*coord.radians, 90*coord.degrees)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=complex)
c1 = [coord.CelestialCoord(r*coord.radians, d*coord.radians) for (r,d) in zip(ra1, dec1)]
c2 = [coord.CelestialCoord(r*coord.radians, d*coord.radians) for (r,d) in zip(ra2, dec2)]
for i in range(ngal):
for j in range(ngal):
rsq = (x1[i]-x2[j])**2 + (y1[i]-y2[j])**2 + (z1[i]-z2[j])**2
r = np.sqrt(rsq)
r *= coord.radians / coord.degrees
logr = np.log(r)
index = np.floor(np.log(r/min_sep) / bin_size).astype(int)
if index < 0 or index >= nbins:
continue
# Rotate shears to coordinates where line connecting is horizontal.
# Original orientation is where north is up.
theta2 = 90*coord.degrees - c2[j].angleBetween(c1[i], north_pole)
expm2theta2 = np.cos(2*theta2) - 1j * np.sin(2*theta2)
g2 = g12[j] + 1j * g22[j]
g2 *= expm2theta2
ww = w1[i] * w2[j]
xi = -ww * k1[i] * g2
true_npairs[index] += 1
true_weight[index] += ww
true_xi[index] += xi
true_xi /= true_weight
print('true_npairs = ',true_npairs)
print('diff = ',kg.npairs - true_npairs)
np.testing.assert_array_equal(kg.npairs, true_npairs)
print('true_weight = ',true_weight)
print('diff = ',kg.weight - true_weight)
np.testing.assert_allclose(kg.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ',true_xi)
print('kg.xi = ',kg.xi)
np.testing.assert_allclose(kg.xi, true_xi.real, rtol=1.e-4, atol=1.e-8)
np.testing.assert_allclose(kg.xi_im, true_xi.imag, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/kg_direct_spherical.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['kg_file_name'])
np.testing.assert_allclose(data['r_nom'], kg.rnom)
np.testing.assert_allclose(data['npairs'], kg.npairs)
np.testing.assert_allclose(data['weight'], kg.weight)
np.testing.assert_allclose(data['kgamT'], kg.xi, rtol=1.e-3)
np.testing.assert_allclose(data['kgamX'], kg.xi_im, rtol=1.e-3)
# Repeat with binslop = 0
# And don't do any top-level recursion so we actually test not going to the leaves.
kg = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins,
sep_units='deg', bin_slop=0, max_top=0)
kg.process(cat1, cat2)
np.testing.assert_array_equal(kg.npairs, true_npairs)
np.testing.assert_allclose(kg.weight, true_weight, rtol=1.e-5, atol=1.e-8)
np.testing.assert_allclose(kg.xi, true_xi.real, rtol=1.e-3, atol=1.e-3)
np.testing.assert_allclose(kg.xi_im, true_xi.imag, rtol=1.e-3, atol=1.e-3)
def test_list():
# Test that we can use a list of files for either data or rand or both.
nobj = 5000
numpy.random.seed(8675309)
ncats = 3
data_cats = []
rand_cats = []
s = 10.
L = 50. * s
numpy.random.seed(8675309)
x = numpy.random.normal(0,s, (nobj,ncats) )
y = numpy.random.normal(0,s, (nobj,ncats) )
data_cats = [ treecorr.Catalog(x=x[:,k],y=y[:,k]) for k in range(ncats) ]
rx = (numpy.random.random_sample((nobj,ncats))-0.5) * L
ry = (numpy.random.random_sample((nobj,ncats))-0.5) * L
rand_cats = [ treecorr.Catalog(x=rx[:,k],y=ry[:,k]) for k in range(ncats) ]
dd = treecorr.NNCorrelation(bin_size=0.1, min_sep=1., max_sep=25., verbose=1)
dd.process(data_cats)
print('dd.npairs = ',dd.npairs)
rr = treecorr.NNCorrelation(bin_size=0.1, min_sep=1., max_sep=25., verbose=1)
rr.process(rand_cats)
print('rr.npairs = ',rr.npairs)
xi, varxi = dd.calculateXi(rr)
print('xi = ',xi)
# Now do the same thing with one big catalog for each.
ddx = treecorr.NNCorrelation(bin_size=0.1, min_sep=1., max_sep=25., verbose=1)
rrx = treecorr.NNCorrelation(bin_size=0.1, min_sep=1., max_sep=25., verbose=1)
data_catx = treecorr.Catalog(x=x.reshape( (nobj*ncats,) ), y=y.reshape( (nobj*ncats,) ))
rand_catx = treecorr.Catalog(x=rx.reshape( (nobj*ncats,) ), y=ry.reshape( (nobj*ncats,) ))
ddx.process(data_catx)
rrx.process(rand_catx)
xix, varxix = ddx.calculateXi(rrx)
print('ddx.npairs = ',ddx.npairs)
print('rrx.npairs = ',rrx.npairs)
print('xix = ',xix)
print('ratio = ',xi/xix)
print('diff = ',xi-xix)
numpy.testing.assert_almost_equal(xix/xi, 1., decimal=2)
# Check that we get the same result using the corr2 executable:
file_list = []
rand_file_list = []
for k in range(ncats):
file_name = os.path.join('data','nn_list_data%d.dat'%k)
with open(file_name, 'w') as fid:
for i in range(nobj):
fid.write(('%.8f %.8f\n')%(x[i,k],y[i,k]))
file_list.append(file_name)
rand_file_name = os.path.join('data','nn_list_rand%d.dat'%k)
with open(rand_file_name, 'w') as fid:
for i in range(nobj):
fid.write(('%.8f %.8f\n')%(rx[i,k],ry[i,k]))
rand_file_list.append(rand_file_name)
list_name = os.path.join('data','nn_list_data_files.txt')
with open(list_name, 'w') as fid:
for file_name in file_list:
fid.write('%s\n'%file_name)
rand_list_name = os.path.join('data','nn_list_rand_files.txt')
with open(rand_list_name, 'w') as fid:
for file_name in rand_file_list:
fid.write('%s\n'%file_name)
file_namex = os.path.join('data','nn_list_datax.dat')
with open(file_namex, 'w') as fid:
for k in range(ncats):
for i in range(nobj):
fid.write(('%.8f %.8f\n')%(x[i,k],y[i,k]))
rand_file_namex = os.path.join('data','nn_list_randx.dat')
with open(rand_file_namex, 'w') as fid:
for k in range(ncats):
for i in range(nobj):
fid.write(('%.8f %.8f\n')%(rx[i,k],ry[i,k]))
# First do this via the corr2 function.
config = treecorr.config.read_config('nn_list1.yaml')
logger = treecorr.config.setup_logger(0)
treecorr.corr2(config, logger)
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list1.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=3)
# Now calling out to the external corr2 executable.
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"nn_list1.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list1.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=3)
import subprocess
p = subprocess.Popen( [corr2_exe,"nn_list2.json"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list2.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=2)
import subprocess
p = subprocess.Popen( [corr2_exe,"nn_list3.params"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list3.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=2)
import subprocess
p = subprocess.Popen( [corr2_exe, "nn_list4.config", "-f", "yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list4.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=2)
import subprocess
p = subprocess.Popen( [corr2_exe, "nn_list5.config", "-f", "json"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_list5.out'),names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=2)
# For this one, the output file is in the current directory, which used to give an error.
import subprocess
p = subprocess.Popen( [corr2_exe, "nn_list6.config", "-f", "params"] )
p.communicate()
output_file = 'nn_list6.out'
corr2_output = numpy.genfromtxt(output_file,names=True,skip_header=1)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/xi)
print('diff = ',corr2_output['xi']-xi)
numpy.testing.assert_almost_equal(corr2_output['xi']/xi, 1., decimal=2)
# Move it to the output directory now to keep the current directory clean.
mv_output_file = os.path.join('output',output_file)
if os.path.exists(mv_output_file):
os.remove(mv_output_file)
os.rename(output_file, mv_output_file)
def test_direct_count():
# If the catalogs are small enough, we can do a direct count of the number of pairs
# to see if comes out right. This should exactly match the treecorr code if bin_slop=0.
ngal = 100
s = 10.
numpy.random.seed(8675309)
x1 = numpy.random.normal(0,s, (ngal,) )
y1 = numpy.random.normal(0,s, (ngal,) )
cat1 = treecorr.Catalog(x=x1, y=y1)
x2 = numpy.random.normal(0,s, (ngal,) )
y2 = numpy.random.normal(0,s, (ngal,) )
cat2 = treecorr.Catalog(x=x2, y=y2)
min_sep = 1.
max_sep = 50.
nbins = 50
dd = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0.)
dd.process(cat1, cat2)
print('dd.npairs = ',dd.npairs)
log_min_sep = numpy.log(min_sep)
log_max_sep = numpy.log(max_sep)
true_npairs = numpy.zeros(nbins)
bin_size = (log_max_sep - log_min_sep) / nbins
for i in range(ngal):
for j in range(ngal):
rsq = (x1[i]-x2[j])**2 + (y1[i]-y2[j])**2
logr = 0.5 * numpy.log(rsq)
k = int(numpy.floor( (logr-log_min_sep) / bin_size ))
if k < 0: continue
if k >= nbins: continue
true_npairs[k] += 1
print('true_npairs = ',true_npairs)
print('diff = ',dd.npairs - true_npairs)
numpy.testing.assert_array_equal(dd.npairs, true_npairs)
# Check that running via the corr2 script works correctly.
file_name1 = os.path.join('data','nn_direct_data1.dat')
with open(file_name1, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x1[i],y1[i]))
file_name2 = os.path.join('data','nn_direct_data2.dat')
with open(file_name2, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x2[i],y2[i]))
L = 10*s
nrand = ngal
rx1 = (numpy.random.random_sample(nrand)-0.5) * L
ry1 = (numpy.random.random_sample(nrand)-0.5) * L
rx2 = (numpy.random.random_sample(nrand)-0.5) * L
ry2 = (numpy.random.random_sample(nrand)-0.5) * L
rcat1 = treecorr.Catalog(x=rx1, y=ry1)
rcat2 = treecorr.Catalog(x=rx2, y=ry2)
rand_file_name1 = os.path.join('data','nn_direct_rand1.dat')
with open(rand_file_name1, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx1[i],ry1[i]))
rand_file_name2 = os.path.join('data','nn_direct_rand2.dat')
with open(rand_file_name2, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx2[i],ry2[i]))
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0.,
verbose=0)
rr.process(rcat1,rcat2)
xi, varxi = dd.calculateXi(rr)
# First do this via the corr2 function.
config = treecorr.config.read_config('nn_direct.yaml')
logger = treecorr.config.setup_logger(0)
treecorr.corr2(config, logger)
corr2_output = numpy.genfromtxt(os.path.join('output','nn_direct.out'), names=True,
skip_header=1)
print('corr2_output = ',corr2_output)
print('corr2_output.dtype = ',corr2_output.dtype)
print('rnom = ',dd.rnom)
print(' ',corr2_output['R_nom'])
numpy.testing.assert_almost_equal(corr2_output['R_nom'], dd.rnom, decimal=3)
print('DD = ',dd.npairs)
print(' ',corr2_output['DD'])
numpy.testing.assert_almost_equal(corr2_output['DD'], dd.npairs, decimal=3)
numpy.testing.assert_almost_equal(corr2_output['npairs'], dd.npairs, decimal=3)
print('RR = ',rr.npairs)
print(' ',corr2_output['RR'])
numpy.testing.assert_almost_equal(corr2_output['RR'], rr.npairs, decimal=3)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['xi'])
print('diff = ',corr2_output['xi']-xi)
diff_index = numpy.where(numpy.abs(corr2_output['xi']-xi) > 1.e-5)[0]
print('different at ',diff_index)
print('xi[diffs] = ',xi[diff_index])
print('corr2.xi[diffs] = ',corr2_output['xi'][diff_index])
print('diff[diffs] = ',xi[diff_index] - corr2_output['xi'][diff_index])
numpy.testing.assert_almost_equal(corr2_output['xi'], xi, decimal=3)
# Now calling out to the external corr2 executable.
import subprocess
corr2_exe = get_script_name('corr2')
p = subprocess.Popen( [corr2_exe,"nn_direct.yaml"] )
p.communicate()
corr2_output = numpy.genfromtxt(os.path.join('output','nn_direct.out'), names=True,
skip_header=1)
numpy.testing.assert_almost_equal(corr2_output['xi'], xi, decimal=3)
# Repeat with binslop not precisely 0, since the code flow is different for bin_slop == 0.
dd = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=1.e-16)
dd.process(cat1, cat2)
numpy.testing.assert_array_equal(dd.npairs, true_npairs)
# And again with no top-level recursion
dd = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=1.e-16,
max_top=0)
dd.process(cat1, cat2)
numpy.testing.assert_array_equal(dd.npairs, true_npairs)
def test_nk():
# Use kappa(r) = kappa0 exp(-r^2/2r0^2) (1-r^2/2r0^2) around many lenses.
nlens = 1000
nsource = 100000
kappa0 = 0.05
r0 = 10.
L = 100. * r0
rng = np.random.RandomState(8675309)
xl = (rng.random_sample(nlens) - 0.5) * L
yl = (rng.random_sample(nlens) - 0.5) * L
xs = (rng.random_sample(nsource) - 0.5) * L
ys = (rng.random_sample(nsource) - 0.5) * L
k = np.zeros((nsource, ))
for x, y in zip(xl, yl):
dx = xs - x
dy = ys - y
r2 = dx**2 + dy**2
k += kappa0 * np.exp(-0.5 * r2 / r0**2) * (1. - 0.5 * r2 / r0**2)
lens_cat = treecorr.Catalog(x=xl, y=yl, x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=xs,
y=ys,
k=k,
x_units='arcmin',
y_units='arcmin')
nk = treecorr.NKCorrelation(bin_size=0.1,
min_sep=1.,
max_sep=20.,
sep_units='arcmin',
verbose=1)
nk.process(lens_cat, source_cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ', nk.meanlogr - np.log(nk.meanr))
np.testing.assert_allclose(nk.meanlogr, np.log(nk.meanr), atol=1.e-3)
r = nk.meanr
true_k = kappa0 * np.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)))
np.testing.assert_allclose(nk.xi, true_k, rtol=0.1, atol=2.e-3)
nrand = nlens * 13
xr = (rng.random_sample(nrand) - 0.5) * L
yr = (rng.random_sample(nrand) - 0.5) * L
rand_cat = treecorr.Catalog(x=xr, y=yr, x_units='arcmin', y_units='arcmin')
rk = treecorr.NKCorrelation(bin_size=0.1,
min_sep=1.,
max_sep=20.,
sep_units='arcmin',
verbose=1)
rk.process(rand_cat, source_cat)
print('rk.xi = ', rk.xi)
xi, varxi = nk.calculateXi(rk)
print('compensated xi = ', xi)
print('true_kappa = ', true_k)
print('ratio = ', xi / true_k)
print('diff = ', xi - true_k)
print('max diff = ', max(abs(xi - true_k)))
# It turns out this doesn't come out much better. I think the imprecision is mostly just due
# to the smallish number of lenses, not to edge effects
np.testing.assert_allclose(nk.xi, true_k, rtol=0.05, atol=1.e-3)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that we get the same result using the corr2 function
lens_cat.write(os.path.join('data', 'nk_lens.fits'))
source_cat.write(os.path.join('data', 'nk_source.fits'))
rand_cat.write(os.path.join('data', 'nk_rand.fits'))
config = treecorr.read_config('configs/nk.yaml')
config['verbose'] = 0
config['precision'] = 8
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output', 'nk.out'),
names=True,
skip_header=1)
print('nk.xi = ', nk.xi)
print('xi = ', xi)
print('from corr2 output = ', corr2_output['kappa'])
print('ratio = ', corr2_output['kappa'] / xi)
print('diff = ', corr2_output['kappa'] - xi)
np.testing.assert_allclose(corr2_output['kappa'], xi, rtol=1.e-3)
# In the corr2 context, you can turn off the compensated bit, even if there are randoms
# (e.g. maybe you only want randoms for some nn calculation, but not nk.)
config['nk_statistic'] = 'simple'
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output', 'nk.out'),
names=True,
skip_header=1)
xi_simple, _ = nk.calculateXi()
np.testing.assert_equal(xi_simple, nk.xi)
np.testing.assert_allclose(corr2_output['kappa'], xi_simple, rtol=1.e-3)
# Check the fits write option
out_file_name1 = os.path.join('output', 'nk_out1.fits')
nk.write(out_file_name1)
data = fitsio.read(out_file_name1)
np.testing.assert_almost_equal(data['r_nom'], np.exp(nk.logr))
np.testing.assert_almost_equal(data['meanr'], nk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], nk.meanlogr)
np.testing.assert_almost_equal(data['kappa'], nk.xi)
np.testing.assert_almost_equal(data['sigma'], np.sqrt(nk.varxi))
np.testing.assert_almost_equal(data['weight'], nk.weight)
np.testing.assert_almost_equal(data['npairs'], nk.npairs)
out_file_name2 = os.path.join('output', 'nk_out2.fits')
nk.write(out_file_name2, rk)
data = fitsio.read(out_file_name2)
np.testing.assert_almost_equal(data['r_nom'], np.exp(nk.logr))
np.testing.assert_almost_equal(data['meanr'], nk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], nk.meanlogr)
np.testing.assert_almost_equal(data['kappa'], xi)
np.testing.assert_almost_equal(data['sigma'], np.sqrt(varxi))
np.testing.assert_almost_equal(data['weight'], nk.weight)
np.testing.assert_almost_equal(data['npairs'], nk.npairs)
# Check the read function
nk2 = treecorr.NKCorrelation(bin_size=0.1,
min_sep=1.,
max_sep=20.,
sep_units='arcmin')
nk2.read(out_file_name2)
np.testing.assert_almost_equal(nk2.logr, nk.logr)
np.testing.assert_almost_equal(nk2.meanr, nk.meanr)
np.testing.assert_almost_equal(nk2.meanlogr, nk.meanlogr)
np.testing.assert_almost_equal(nk2.xi, nk.xi)
np.testing.assert_almost_equal(nk2.varxi, nk.varxi)
np.testing.assert_almost_equal(nk2.weight, nk.weight)
np.testing.assert_almost_equal(nk2.npairs, nk.npairs)
assert nk2.coords == nk.coords
assert nk2.metric == nk.metric
assert nk2.sep_units == nk.sep_units
assert nk2.bin_type == nk.bin_type
def test_direct():
# If the catalogs are small enough, we can do a direct calculation to see if comes out right.
# This should exactly match the treecorr result if brute force.
ngal = 200
s = 10.
rng = np.random.RandomState(8675309)
x1 = rng.normal(0, s, (ngal, ))
y1 = rng.normal(0, s, (ngal, ))
w1 = rng.random_sample(ngal)
x2 = rng.normal(0, s, (ngal, ))
y2 = rng.normal(0, s, (ngal, ))
w2 = rng.random_sample(ngal)
k2 = rng.normal(0, 3, (ngal, ))
cat1 = treecorr.Catalog(x=x1, y=y1, w=w1)
cat2 = treecorr.Catalog(x=x2, y=y2, w=w2, k=k2)
min_sep = 1.
max_sep = 50.
nbins = 50
bin_size = np.log(max_sep / min_sep) / nbins
nk = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
brute=True)
nk.process(cat1, cat2)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=float)
for i in range(ngal):
# It's hard to do all the pairs at once with numpy operations (although maybe possible).
# But we can at least do all the pairs for each entry in cat1 at once with arrays.
rsq = (x1[i] - x2)**2 + (y1[i] - y2)**2
r = np.sqrt(rsq)
ww = w1[i] * 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
print('true_npairs = ', true_npairs)
print('diff = ', nk.npairs - true_npairs)
np.testing.assert_array_equal(nk.npairs, true_npairs)
print('true_weight = ', true_weight)
print('diff = ', nk.weight - true_weight)
np.testing.assert_allclose(nk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ', true_xi)
print('nk.xi = ', nk.xi)
np.testing.assert_allclose(nk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/nk_direct.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['nk_file_name'])
np.testing.assert_allclose(data['r_nom'], nk.rnom)
np.testing.assert_allclose(data['npairs'], nk.npairs)
np.testing.assert_allclose(data['weight'], nk.weight)
np.testing.assert_allclose(data['kappa'], nk.xi, rtol=1.e-3)
# Invalid with only one file_name
del config['file_name2']
with assert_raises(TypeError):
treecorr.corr2(config)
config['file_name2'] = 'data/nk_direct_cat2.fits'
# Invalid to request compoensated if no rand_file
config['nk_statistic'] = 'compensated'
with assert_raises(TypeError):
treecorr.corr2(config)
# Repeat with binslop = 0, since the code flow is different from brute=True
# And don't do any top-level recursion so we actually test not going to the leaves.
nk = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
bin_slop=0,
max_top=0)
nk.process(cat1, cat2)
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)
# Check a few basic operations with a NKCorrelation object.
do_pickle(nk)
nk2 = nk.copy()
nk2 += nk
np.testing.assert_allclose(nk2.npairs, 2 * nk.npairs)
np.testing.assert_allclose(nk2.weight, 2 * nk.weight)
np.testing.assert_allclose(nk2.meanr, 2 * nk.meanr)
np.testing.assert_allclose(nk2.meanlogr, 2 * nk.meanlogr)
np.testing.assert_allclose(nk2.xi, 2 * nk.xi)
nk2.clear()
nk2 += nk
np.testing.assert_allclose(nk2.npairs, nk.npairs)
np.testing.assert_allclose(nk2.weight, nk.weight)
np.testing.assert_allclose(nk2.meanr, nk.meanr)
np.testing.assert_allclose(nk2.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk2.xi, nk.xi)
ascii_name = 'output/nk_ascii.txt'
nk.write(ascii_name, precision=16)
nk3 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
nk3.read(ascii_name)
np.testing.assert_allclose(nk3.npairs, nk.npairs)
np.testing.assert_allclose(nk3.weight, nk.weight)
np.testing.assert_allclose(nk3.meanr, nk.meanr)
np.testing.assert_allclose(nk3.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk3.xi, nk.xi)
with assert_raises(TypeError):
nk2 += config
nk4 = treecorr.NKCorrelation(min_sep=min_sep / 2,
max_sep=max_sep,
nbins=nbins)
with assert_raises(ValueError):
nk2 += nk4
nk5 = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep * 2,
nbins=nbins)
with assert_raises(ValueError):
nk2 += nk5
nk6 = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins * 2)
with assert_raises(ValueError):
nk2 += nk6
fits_name = 'output/nk_fits.fits'
nk.write(fits_name)
nk4 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
nk4.read(fits_name)
np.testing.assert_allclose(nk4.npairs, nk.npairs)
np.testing.assert_allclose(nk4.weight, nk.weight)
np.testing.assert_allclose(nk4.meanr, nk.meanr)
np.testing.assert_allclose(nk4.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk4.xi, nk.xi)
def test_direct_spherical():
# Repeat in spherical coords
ngal = 100
s = 10.
rng = np.random.RandomState(8675309)
x1 = rng.normal(0, s, (ngal, ))
y1 = rng.normal(
0, s,
(ngal, )) + 200 # Put everything at large y, so small angle on sky
z1 = rng.normal(0, s, (ngal, ))
w1 = rng.random_sample(ngal)
x2 = rng.normal(0, s, (ngal, ))
y2 = rng.normal(0, s, (ngal, )) + 200
z2 = rng.normal(0, s, (ngal, ))
w2 = rng.random_sample(ngal)
k2 = rng.normal(0, 3, (ngal, ))
ra1, dec1 = coord.CelestialCoord.xyz_to_radec(x1, y1, z1)
ra2, dec2 = coord.CelestialCoord.xyz_to_radec(x2, y2, z2)
cat1 = treecorr.Catalog(ra=ra1,
dec=dec1,
ra_units='rad',
dec_units='rad',
w=w1)
cat2 = treecorr.Catalog(ra=ra2,
dec=dec2,
ra_units='rad',
dec_units='rad',
w=w2,
k=k2)
min_sep = 1.
max_sep = 10.
nbins = 50
bin_size = np.log(max_sep / min_sep) / nbins
nk = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
sep_units='deg',
brute=True)
nk.process(cat1, cat2)
r1 = np.sqrt(x1**2 + y1**2 + z1**2)
r2 = np.sqrt(x2**2 + y2**2 + z2**2)
x1 /= r1
y1 /= r1
z1 /= r1
x2 /= r2
y2 /= r2
z2 /= r2
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=float)
for i in range(ngal):
for j in range(ngal):
rsq = (x1[i] - x2[j])**2 + (y1[i] - y2[j])**2 + (z1[i] - z2[j])**2
r = np.sqrt(rsq)
r *= coord.radians / coord.degrees
index = np.floor(np.log(r / min_sep) / bin_size).astype(int)
if index < 0 or index >= nbins:
continue
ww = w1[i] * w2[j]
xi = ww * k2[j]
true_npairs[index] += 1
true_weight[index] += ww
true_xi[index] += xi
true_xi /= true_weight
print('true_npairs = ', true_npairs)
print('diff = ', nk.npairs - true_npairs)
np.testing.assert_array_equal(nk.npairs, true_npairs)
print('true_weight = ', true_weight)
print('diff = ', nk.weight - true_weight)
np.testing.assert_allclose(nk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ', true_xi)
print('nk.xi = ', nk.xi)
np.testing.assert_allclose(nk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/nk_direct_spherical.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['nk_file_name'])
np.testing.assert_allclose(data['r_nom'], nk.rnom)
np.testing.assert_allclose(data['npairs'], nk.npairs)
np.testing.assert_allclose(data['weight'], nk.weight)
np.testing.assert_allclose(data['kappa'], nk.xi, rtol=1.e-3)
# Repeat with binslop = 0, since the code flow is different from brute=True.
# And don't do any top-level recursion so we actually test not going to the leaves.
nk = treecorr.NKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
sep_units='deg',
bin_slop=0,
max_top=0)
nk.process(cat1, cat2)
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-3, atol=1.e-6)
def test_direct():
# If the catalogs are small enough, we can do a direct calculation to see if comes out right.
# This should exactly match the treecorr result if brute force.
ngal = 200
s = 10.
rng = np.random.RandomState(8675309)
x1 = rng.normal(0,s, (ngal,) )
y1 = rng.normal(0,s, (ngal,) )
w1 = rng.random_sample(ngal)
x2 = rng.normal(0,s, (ngal,) )
y2 = rng.normal(0,s, (ngal,) )
w2 = rng.random_sample(ngal)
k2 = rng.normal(0,3, (ngal,) )
cat1 = treecorr.Catalog(x=x1, y=y1, w=w1)
cat2 = treecorr.Catalog(x=x2, y=y2, w=w2, k=k2)
min_sep = 1.
max_sep = 50.
nbins = 50
bin_size = np.log(max_sep/min_sep) / nbins
nk = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, brute=True)
nk.process(cat1, cat2)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=float)
for i in range(ngal):
# It's hard to do all the pairs at once with numpy operations (although maybe possible).
# But we can at least do all the pairs for each entry in cat1 at once with arrays.
rsq = (x1[i]-x2)**2 + (y1[i]-y2)**2
r = np.sqrt(rsq)
logr = np.log(r)
ww = w1[i] * 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
print('true_npairs = ',true_npairs)
print('diff = ',nk.npairs - true_npairs)
np.testing.assert_array_equal(nk.npairs, true_npairs)
print('true_weight = ',true_weight)
print('diff = ',nk.weight - true_weight)
np.testing.assert_allclose(nk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ',true_xi)
print('nk.xi = ',nk.xi)
np.testing.assert_allclose(nk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/nk_direct.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['nk_file_name'])
np.testing.assert_allclose(data['r_nom'], nk.rnom)
np.testing.assert_allclose(data['npairs'], nk.npairs)
np.testing.assert_allclose(data['weight'], nk.weight)
np.testing.assert_allclose(data['kappa'], nk.xi, rtol=1.e-3)
# Invalid with only one file_name
del config['file_name2']
with assert_raises(TypeError):
treecorr.corr2(config)
config['file_name2'] = 'data/nk_direct_cat2.fits'
# Invalid to request compoensated if no rand_file
config['nk_statistic'] = 'compensated'
with assert_raises(TypeError):
treecorr.corr2(config)
# Repeat with binslop = 0, since the code flow is different from brute=True
# And don't do any top-level recursion so we actually test not going to the leaves.
nk = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
max_top=0)
nk.process(cat1, cat2)
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)
# Check a few basic operations with a NKCorrelation object.
do_pickle(nk)
nk2 = nk.copy()
nk2 += nk
np.testing.assert_allclose(nk2.npairs, 2*nk.npairs)
np.testing.assert_allclose(nk2.weight, 2*nk.weight)
np.testing.assert_allclose(nk2.meanr, 2*nk.meanr)
np.testing.assert_allclose(nk2.meanlogr, 2*nk.meanlogr)
np.testing.assert_allclose(nk2.xi, 2*nk.xi)
nk2.clear()
nk2 += nk
np.testing.assert_allclose(nk2.npairs, nk.npairs)
np.testing.assert_allclose(nk2.weight, nk.weight)
np.testing.assert_allclose(nk2.meanr, nk.meanr)
np.testing.assert_allclose(nk2.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk2.xi, nk.xi)
ascii_name = 'output/nk_ascii.txt'
nk.write(ascii_name, precision=16)
nk3 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
nk3.read(ascii_name)
np.testing.assert_allclose(nk3.npairs, nk.npairs)
np.testing.assert_allclose(nk3.weight, nk.weight)
np.testing.assert_allclose(nk3.meanr, nk.meanr)
np.testing.assert_allclose(nk3.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk3.xi, nk.xi)
with assert_raises(TypeError):
nk2 += config
nk4 = treecorr.NKCorrelation(min_sep=min_sep/2, max_sep=max_sep, nbins=nbins)
with assert_raises(ValueError):
nk2 += nk4
nk5 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep*2, nbins=nbins)
with assert_raises(ValueError):
nk2 += nk5
nk6 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins*2)
with assert_raises(ValueError):
nk2 += nk6
fits_name = 'output/nk_fits.fits'
nk.write(fits_name)
nk4 = treecorr.NKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
nk4.read(fits_name)
np.testing.assert_allclose(nk4.npairs, nk.npairs)
np.testing.assert_allclose(nk4.weight, nk.weight)
np.testing.assert_allclose(nk4.meanr, nk.meanr)
np.testing.assert_allclose(nk4.meanlogr, nk.meanlogr)
np.testing.assert_allclose(nk4.xi, nk.xi)
out_keyword = keyword1
elif cycle == 1:
# Do clipped X clipped
keyword1 = 'SS%s.rCLIP_%ssigma'%(SS,sigma)
keyword2 = keyword1
out_keyword = keyword1
elif cycle == 2:
# Do unclipped X clipped
keyword1 = 'ORIG'
keyword2 = 'SS%s.rCLIP_%ssigma'%(SS,sigma)
out_keyword = keyword1 + '_X_' + keyword2
input_file1 = '%s/Correlation_Function/%s/%s.%s.ThetaX_ThetaY_e1_e2_w.Std.asc' %(overall_DIR, DIRname1, combined_name1, keyword1)
input_file2 = '%s/Correlation_Function/%s/%s.%s.ThetaX_ThetaY_e1_e2_w.Std.asc' %(overall_DIR, DIRname2, combined_name2, keyword2)
output_file = '%s/Tree_Correlation_Function/%s/ThBins%s/%s.%s.CorrFun.asc' %(overall_DIR, DIRname, ThBins, combined_name1, out_keyword)
Assemble_TreeCorr_ConfigFile(input_file1, input_file2, output_file, metric, flip_g2, bin_slop, min_sep, max_sep, ThBins, cn)
config_file='%s/Tree_Correlation_Function/config_files/config_treecorr%s.yaml' %(overall_DIR,cn)
config = treecorr.read_config(config_file)
t1 = time.time()
treecorr.corr2(config)
t2=time.time()
print( "TreeCorr time for %s is %.1f s" %(output_file, (t2-t1)) )
import numpy as np
import healpy as hp
import matplotlib.pyplot as plt
import pylab
import os
import sys
import pyfits
import glob
import treecorr
## Full im3shape_v7_r
config = treecorr.read_config('/Users/drgk/DES/SV_tests/split_xi/sample.params_shearhsear_im3shape')
config['file_name'] = '/Users/drgk/DES/SV_tests/athena_cats/im3shape_v7_r_shears_03_z_13.dat'
config['gg_file_name'] = '/Users/drgk/DES/SV_tests/split_xi/gg_galshear_im3shape_v7_r.out'
treecorr.corr2(config)
config = treecorr.read_config('/Users/drgk/DES/SV_tests/split_xi/sample.params_kappakappa_im3shape')
config['file_name'] = '/Users/drgk/DES/SV_tests/athena_cats/im3shape_v7_r_m_03_z_13.dat'
config['kk_file_name'] = '/Users/drgk/DES/SV_tests/split_xi/kk_galshear_im3shape_v7_r.out'
treecorr.corr2(config)
####### AIRMASS ##############
## im3shape_v7_r Airmass Upper
config = treecorr.read_config('/Users/drgk/DES/SV_tests/split_xi/sample.params_shearhsear_im3shape')
config['file_name'] = '/Users/drgk/DES/SV_tests/athena_cats/im3shape_v7_r_shears_airmass_r_upper_nzweighted.dat'
config['gg_file_name'] = '/Users/drgk/DES/SV_tests/split_xi/gg_galshear_im3shape_v7_r_airmass_r_upper_nzweighted.out'
treecorr.corr2(config)
config = treecorr.read_config('/Users/drgk/DES/SV_tests/split_xi/sample.params_kappakappa_im3shape')
config['file_name'] = '/Users/drgk/DES/SV_tests/athena_cats/im3shape_v7_r_m_airmass_r_upper_nzweighted.dat'
def test_kk():
# cf. http://adsabs.harvard.edu/abs/2002A%26A...389..729S for the basic formulae I use here.
#
# Use kappa(r) = A exp(-r^2/2s^2)
#
# The Fourier transform is: kappa~(k) = 2 pi A s^2 exp(-s^2 k^2/2) / L^2
# P(k) = (1/2pi) <|kappa~(k)|^2> = 2 pi A^2 (s/L)^4 exp(-s^2 k^2)
# xi(r) = (1/2pi) int( dk k P(k) J0(kr) )
# = pi A^2 (s/L)^2 exp(-r^2/2s^2/4)
# Note: I'm not sure I handled the L factors correctly, but the units at the end need
# to be kappa^2, so it needs to be (s/L)^2.
s = 10.
if __name__ == '__main__':
ngal = 1000000
L = 30. * s # Not infinity, so this introduces some error. Our integrals were to infinity.
tol_factor = 1
else:
ngal = 100000
L = 30. * s
tol_factor = 2
A = 0.05
rng = np.random.RandomState(8675309)
x = (rng.random_sample(ngal)-0.5) * L
y = (rng.random_sample(ngal)-0.5) * L
r2 = (x**2 + y**2)/s**2
kappa = A * np.exp(-r2/2.)
cat = treecorr.Catalog(x=x, y=y, k=kappa, x_units='arcmin', y_units='arcmin')
kk = treecorr.KKCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
kk.process(cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ',kk.meanlogr - np.log(kk.meanr))
np.testing.assert_allclose(kk.meanlogr, np.log(kk.meanr), atol=1.e-3)
r = kk.meanr
true_xi = np.pi * A**2 * (s/L)**2 * np.exp(-0.25*r**2/s**2)
print('kk.xi = ',kk.xi)
print('true_xi = ',true_xi)
print('ratio = ',kk.xi / true_xi)
print('diff = ',kk.xi - true_xi)
print('max diff = ',max(abs(kk.xi - true_xi)))
print('max rel diff = ',max(abs((kk.xi - true_xi)/true_xi)))
np.testing.assert_allclose(kk.xi, true_xi, rtol=0.1*tol_factor)
# It should also work as a cross-correlation of this cat with itself
kk.process(cat,cat)
np.testing.assert_allclose(kk.meanlogr, np.log(kk.meanr), atol=1.e-3)
np.testing.assert_allclose(kk.xi, true_xi, rtol=0.1*tol_factor)
# Check that we get the same result using the corr2 function
cat.write(os.path.join('data','kk.dat'))
config = treecorr.read_config('configs/kk.yaml')
config['verbose'] = 0
config['precision'] = 8
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','kk.out'), names=True, skip_header=1)
print('kk.xi = ',kk.xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/kk.xi)
print('diff = ',corr2_output['xi']-kk.xi)
np.testing.assert_allclose(corr2_output['xi'], kk.xi, rtol=1.e-3)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check the fits write option
out_file_name = os.path.join('output','kk_out.fits')
kk.write(out_file_name)
data = fitsio.read(out_file_name)
np.testing.assert_almost_equal(data['r_nom'], np.exp(kk.logr))
np.testing.assert_almost_equal(data['meanr'], kk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], kk.meanlogr)
np.testing.assert_almost_equal(data['xi'], kk.xi)
np.testing.assert_almost_equal(data['sigma_xi'], np.sqrt(kk.varxi))
np.testing.assert_almost_equal(data['weight'], kk.weight)
np.testing.assert_almost_equal(data['npairs'], kk.npairs)
# Check the read function
kk2 = treecorr.KKCorrelation(bin_size=0.1, min_sep=1., max_sep=100., sep_units='arcmin')
kk2.read(out_file_name)
np.testing.assert_almost_equal(kk2.logr, kk.logr)
np.testing.assert_almost_equal(kk2.meanr, kk.meanr)
np.testing.assert_almost_equal(kk2.meanlogr, kk.meanlogr)
np.testing.assert_almost_equal(kk2.xi, kk.xi)
np.testing.assert_almost_equal(kk2.varxi, kk.varxi)
np.testing.assert_almost_equal(kk2.weight, kk.weight)
np.testing.assert_almost_equal(kk2.npairs, kk.npairs)
assert kk2.coords == kk.coords
assert kk2.metric == kk.metric
assert kk2.sep_units == kk.sep_units
assert kk2.bin_type == kk.bin_type
def test_nk():
# Use kappa(r) = kappa0 exp(-r^2/2r0^2) (1-r^2/2r0^2) around many lenses.
nlens = 1000
nsource = 100000
kappa0 = 0.05
r0 = 10.
L = 100. * r0
rng = np.random.RandomState(8675309)
xl = (rng.random_sample(nlens)-0.5) * L
yl = (rng.random_sample(nlens)-0.5) * L
xs = (rng.random_sample(nsource)-0.5) * L
ys = (rng.random_sample(nsource)-0.5) * L
k = np.zeros( (nsource,) )
for x,y in zip(xl,yl):
dx = xs-x
dy = ys-y
r2 = dx**2 + dy**2
k += kappa0 * np.exp(-0.5*r2/r0**2) * (1.-0.5*r2/r0**2)
lens_cat = treecorr.Catalog(x=xl, y=yl, x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=xs, y=ys, k=k, x_units='arcmin', y_units='arcmin')
nk = treecorr.NKCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
nk.process(lens_cat, source_cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ',nk.meanlogr - np.log(nk.meanr))
np.testing.assert_allclose(nk.meanlogr, np.log(nk.meanr), atol=1.e-3)
r = nk.meanr
true_k = kappa0 * np.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)))
np.testing.assert_allclose(nk.xi, true_k, rtol=0.1, atol=2.e-3)
nrand = nlens * 13
xr = (rng.random_sample(nrand)-0.5) * L
yr = (rng.random_sample(nrand)-0.5) * L
rand_cat = treecorr.Catalog(x=xr, y=yr, x_units='arcmin', y_units='arcmin')
rk = treecorr.NKCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
rk.process(rand_cat, source_cat)
print('rk.xi = ',rk.xi)
xi, varxi = nk.calculateXi(rk)
print('compensated xi = ',xi)
print('true_kappa = ',true_k)
print('ratio = ',xi / true_k)
print('diff = ',xi - true_k)
print('max diff = ',max(abs(xi - true_k)))
# It turns out this doesn't come out much better. I think the imprecision is mostly just due
# to the smallish number of lenses, not to edge effects
np.testing.assert_allclose(nk.xi, true_k, rtol=0.05, atol=1.e-3)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that we get the same result using the corr2 function
lens_cat.write(os.path.join('data','nk_lens.fits'))
source_cat.write(os.path.join('data','nk_source.fits'))
rand_cat.write(os.path.join('data','nk_rand.fits'))
config = treecorr.read_config('configs/nk.yaml')
config['verbose'] = 0
config['precision'] = 8
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','nk.out'), names=True, skip_header=1)
print('nk.xi = ',nk.xi)
print('xi = ',xi)
print('from corr2 output = ',corr2_output['kappa'])
print('ratio = ',corr2_output['kappa']/xi)
print('diff = ',corr2_output['kappa']-xi)
np.testing.assert_allclose(corr2_output['kappa'], xi, rtol=1.e-3)
# In the corr2 context, you can turn off the compensated bit, even if there are randoms
# (e.g. maybe you only want randoms for some nn calculation, but not nk.)
config['nk_statistic'] = 'simple'
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','nk.out'), names=True, skip_header=1)
xi_simple, _ = nk.calculateXi()
np.testing.assert_allclose(corr2_output['kappa'], xi_simple, rtol=1.e-3)
# Check the fits write option
out_file_name1 = os.path.join('output','nk_out1.fits')
nk.write(out_file_name1)
data = fitsio.read(out_file_name1)
np.testing.assert_almost_equal(data['r_nom'], np.exp(nk.logr))
np.testing.assert_almost_equal(data['meanr'], nk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], nk.meanlogr)
np.testing.assert_almost_equal(data['kappa'], nk.xi)
np.testing.assert_almost_equal(data['sigma'], np.sqrt(nk.varxi))
np.testing.assert_almost_equal(data['weight'], nk.weight)
np.testing.assert_almost_equal(data['npairs'], nk.npairs)
out_file_name2 = os.path.join('output','nk_out2.fits')
nk.write(out_file_name2, rk)
data = fitsio.read(out_file_name2)
np.testing.assert_almost_equal(data['r_nom'], np.exp(nk.logr))
np.testing.assert_almost_equal(data['meanr'], nk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], nk.meanlogr)
np.testing.assert_almost_equal(data['kappa'], xi)
np.testing.assert_almost_equal(data['sigma'], np.sqrt(varxi))
np.testing.assert_almost_equal(data['weight'], nk.weight)
np.testing.assert_almost_equal(data['npairs'], nk.npairs)
# Check the read function
nk2 = treecorr.NKCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin')
nk2.read(out_file_name1)
np.testing.assert_almost_equal(nk2.logr, nk.logr)
np.testing.assert_almost_equal(nk2.meanr, nk.meanr)
np.testing.assert_almost_equal(nk2.meanlogr, nk.meanlogr)
np.testing.assert_almost_equal(nk2.xi, nk.xi)
np.testing.assert_almost_equal(nk2.varxi, nk.varxi)
np.testing.assert_almost_equal(nk2.weight, nk.weight)
np.testing.assert_almost_equal(nk2.npairs, nk.npairs)
assert nk2.coords == nk.coords
assert nk2.metric == nk.metric
assert nk2.sep_units == nk.sep_units
assert nk2.bin_type == nk.bin_type
def test_direct():
# If the catalogs are small enough, we can do a direct calculation to see if comes out right.
# This should exactly match the treecorr result if brute=True.
ngal = 200
s = 10.
rng = np.random.RandomState(8675309)
x1 = rng.normal(0,s, (ngal,) )
y1 = rng.normal(0,s, (ngal,) )
w1 = rng.random_sample(ngal)
k1 = rng.normal(5,1, (ngal,) )
x2 = rng.normal(0,s, (ngal,) )
y2 = rng.normal(0,s, (ngal,) )
w2 = rng.random_sample(ngal)
g12 = rng.normal(0,0.2, (ngal,) )
g22 = rng.normal(0,0.2, (ngal,) )
cat1 = treecorr.Catalog(x=x1, y=y1, w=w1, k=k1)
cat2 = treecorr.Catalog(x=x2, y=y2, w=w2, g1=g12, g2=g22)
min_sep = 1.
max_sep = 50.
nbins = 50
bin_size = np.log(max_sep/min_sep) / nbins
kg = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, brute=True)
kg.process(cat1, cat2)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=complex)
for i in range(ngal):
# It's hard to do all the pairs at once with numpy operations (although maybe possible).
# But we can at least do all the pairs for each entry in cat1 at once with arrays.
rsq = (x1[i]-x2)**2 + (y1[i]-y2)**2
r = np.sqrt(rsq)
logr = np.log(r)
expmialpha = ((x1[i]-x2) - 1j*(y1[i]-y2)) / r
ww = w1[i] * w2
xi = -ww * k1[i] * (g12 + 1j*g22) * expmialpha**2
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
print('true_npairs = ',true_npairs)
print('diff = ',kg.npairs - true_npairs)
np.testing.assert_array_equal(kg.npairs, true_npairs)
print('true_weight = ',true_weight)
print('diff = ',kg.weight - true_weight)
np.testing.assert_allclose(kg.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ',true_xi)
print('kg.xi = ',kg.xi)
print('kg.xi_im = ',kg.xi_im)
np.testing.assert_allclose(kg.xi, true_xi.real, rtol=1.e-4, atol=1.e-8)
np.testing.assert_allclose(kg.xi_im, true_xi.imag, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/kg_direct.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['kg_file_name'])
np.testing.assert_allclose(data['r_nom'], kg.rnom)
np.testing.assert_allclose(data['npairs'], kg.npairs)
np.testing.assert_allclose(data['weight'], kg.weight)
np.testing.assert_allclose(data['kgamT'], kg.xi, rtol=1.e-3)
np.testing.assert_allclose(data['kgamX'], kg.xi_im, rtol=1.e-3)
# Invalid with only one file_name
del config['file_name2']
with assert_raises(TypeError):
treecorr.corr2(config)
# Repeat with binslop = 0, since code is different for bin_slop=0 and brute=True.
# And don't do any top-level recursion so we actually test not going to the leaves.
kg = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
max_top=0)
kg.process(cat1, cat2)
np.testing.assert_array_equal(kg.npairs, true_npairs)
np.testing.assert_allclose(kg.weight, true_weight, rtol=1.e-5, atol=1.e-8)
np.testing.assert_allclose(kg.xi, true_xi.real, rtol=1.e-3, atol=1.e-3)
np.testing.assert_allclose(kg.xi_im, true_xi.imag, rtol=1.e-3, atol=1.e-3)
# Check a few basic operations with a KGCorrelation object.
do_pickle(kg)
kg2 = kg.copy()
kg2 += kg
np.testing.assert_allclose(kg2.npairs, 2*kg.npairs)
np.testing.assert_allclose(kg2.weight, 2*kg.weight)
np.testing.assert_allclose(kg2.meanr, 2*kg.meanr)
np.testing.assert_allclose(kg2.meanlogr, 2*kg.meanlogr)
np.testing.assert_allclose(kg2.xi, 2*kg.xi)
np.testing.assert_allclose(kg2.xi_im, 2*kg.xi_im)
kg2.clear()
kg2 += kg
np.testing.assert_allclose(kg2.npairs, kg.npairs)
np.testing.assert_allclose(kg2.weight, kg.weight)
np.testing.assert_allclose(kg2.meanr, kg.meanr)
np.testing.assert_allclose(kg2.meanlogr, kg.meanlogr)
np.testing.assert_allclose(kg2.xi, kg.xi)
np.testing.assert_allclose(kg2.xi_im, kg.xi_im)
ascii_name = 'output/kg_ascii.txt'
kg.write(ascii_name, precision=16)
kg3 = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
kg3.read(ascii_name)
np.testing.assert_allclose(kg3.npairs, kg.npairs)
np.testing.assert_allclose(kg3.weight, kg.weight)
np.testing.assert_allclose(kg3.meanr, kg.meanr)
np.testing.assert_allclose(kg3.meanlogr, kg.meanlogr)
np.testing.assert_allclose(kg3.xi, kg.xi)
np.testing.assert_allclose(kg3.xi_im, kg.xi_im)
fits_name = 'output/kg_fits.fits'
kg.write(fits_name)
kg4 = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
kg4.read(fits_name)
np.testing.assert_allclose(kg4.npairs, kg.npairs)
np.testing.assert_allclose(kg4.weight, kg.weight)
np.testing.assert_allclose(kg4.meanr, kg.meanr)
np.testing.assert_allclose(kg4.meanlogr, kg.meanlogr)
np.testing.assert_allclose(kg4.xi, kg.xi)
np.testing.assert_allclose(kg4.xi_im, kg.xi_im)
with assert_raises(TypeError):
kg2 += config
kg4 = treecorr.KGCorrelation(min_sep=min_sep/2, max_sep=max_sep, nbins=nbins)
with assert_raises(ValueError):
kg2 += kg4
kg5 = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep*2, nbins=nbins)
with assert_raises(ValueError):
kg2 += kg5
kg6 = treecorr.KGCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins*2)
with assert_raises(ValueError):
kg2 += kg6
def test_direct_count():
# This is essentially the same as test_nn.py:test_direct_count, but using periodic distances.
# And the points are uniform in the box, so plenty of pairs crossing the edges.
ngal = 100
Lx = 50.
Ly = 80.
rng = np.random.RandomState(8675309)
x1 = (rng.random_sample(ngal)-0.5) * Lx
y1 = (rng.random_sample(ngal)-0.5) * Ly
cat1 = treecorr.Catalog(x=x1, y=y1)
x2 = (rng.random_sample(ngal)-0.5) * Lx
y2 = (rng.random_sample(ngal)-0.5) * Ly
cat2 = treecorr.Catalog(x=x2, y=y2)
min_sep = 1.
max_sep = 50.
nbins = 50
dd = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
xperiod=Lx, yperiod=Ly)
dd.process(cat1, cat2, metric='Periodic')
print('dd.npairs = ',dd.npairs)
log_min_sep = np.log(min_sep)
log_max_sep = np.log(max_sep)
true_npairs = np.zeros(nbins)
bin_size = (log_max_sep - log_min_sep) / nbins
for i in range(ngal):
for j in range(ngal):
dx = min(abs(x1[i]-x2[j]), Lx - abs(x1[i]-x2[j]))
dy = min(abs(y1[i]-y2[j]), Ly - abs(y1[i]-y2[j]))
rsq = dx**2 + dy**2
logr = 0.5 * np.log(rsq)
k = int(np.floor( (logr-log_min_sep) / bin_size ))
if k < 0: continue
if k >= nbins: continue
true_npairs[k] += 1
print('true_npairs = ',true_npairs)
print('diff = ',dd.npairs - true_npairs)
np.testing.assert_array_equal(dd.npairs, true_npairs)
# Check that running via the corr2 script works correctly.
file_name1 = os.path.join('data','nn_periodic_data1.dat')
with open(file_name1, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x1[i],y1[i]))
file_name2 = os.path.join('data','nn_periodic_data2.dat')
with open(file_name2, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x2[i],y2[i]))
nrand = ngal
rx1 = (rng.random_sample(nrand)-0.5) * Lx
ry1 = (rng.random_sample(nrand)-0.5) * Ly
rx2 = (rng.random_sample(nrand)-0.5) * Lx
ry2 = (rng.random_sample(nrand)-0.5) * Ly
rcat1 = treecorr.Catalog(x=rx1, y=ry1)
rcat2 = treecorr.Catalog(x=rx2, y=ry2)
rand_file_name1 = os.path.join('data','nn_periodic_rand1.dat')
with open(rand_file_name1, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx1[i],ry1[i]))
rand_file_name2 = os.path.join('data','nn_periodic_rand2.dat')
with open(rand_file_name2, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx2[i],ry2[i]))
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
verbose=0, xperiod=Lx, yperiod=Ly)
rr.process(rcat1,rcat2, metric='Periodic')
xi, varxi = dd.calculateXi(rr)
print('xi = ',xi)
# Do this via the corr2 function.
config = treecorr.config.read_config('configs/nn_periodic.yaml')
logger = treecorr.config.setup_logger(2)
treecorr.corr2(config, logger)
corr2_output = np.genfromtxt(os.path.join('output','nn_periodic.out'), names=True,
skip_header=1)
np.testing.assert_allclose(corr2_output['r_nom'], dd.rnom, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['DD'], dd.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['npairs'], dd.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['RR'], rr.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['xi'], xi, rtol=1.e-3)
# If don't give a period, then an error.
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
# Or if only give one kind of period
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, xperiod=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, yperiod=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
# If give period, but then don't use Periodic metric, that's also an error.
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, period=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2)
def test_direct_count():
# This is essentially the same as test_nn.py:test_direct_count, but using periodic distances.
# And the points are uniform in the box, so plenty of pairs crossing the edges.
ngal = 100
Lx = 50.
Ly = 80.
rng = np.random.RandomState(8675309)
x1 = (rng.random_sample(ngal)-0.5) * Lx
y1 = (rng.random_sample(ngal)-0.5) * Ly
cat1 = treecorr.Catalog(x=x1, y=y1)
x2 = (rng.random_sample(ngal)-0.5) * Lx
y2 = (rng.random_sample(ngal)-0.5) * Ly
cat2 = treecorr.Catalog(x=x2, y=y2)
min_sep = 1.
max_sep = 50.
nbins = 50
dd = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
xperiod=Lx, yperiod=Ly)
dd.process(cat1, cat2, metric='Periodic')
print('dd.npairs = ',dd.npairs)
log_min_sep = np.log(min_sep)
log_max_sep = np.log(max_sep)
true_npairs = np.zeros(nbins)
bin_size = (log_max_sep - log_min_sep) / nbins
for i in range(ngal):
for j in range(ngal):
dx = min(abs(x1[i]-x2[j]), Lx - abs(x1[i]-x2[j]))
dy = min(abs(y1[i]-y2[j]), Ly - abs(y1[i]-y2[j]))
rsq = dx**2 + dy**2
logr = 0.5 * np.log(rsq)
k = int(np.floor( (logr-log_min_sep) / bin_size ))
if k < 0: continue
if k >= nbins: continue
true_npairs[k] += 1
print('true_npairs = ',true_npairs)
print('diff = ',dd.npairs - true_npairs)
np.testing.assert_array_equal(dd.npairs, true_npairs)
# Check that running via the corr2 script works correctly.
file_name1 = os.path.join('data','nn_periodic_data1.dat')
with open(file_name1, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x1[i],y1[i]))
file_name2 = os.path.join('data','nn_periodic_data2.dat')
with open(file_name2, 'w') as fid:
for i in range(ngal):
fid.write(('%.20f %.20f\n')%(x2[i],y2[i]))
nrand = ngal
rx1 = (rng.random_sample(nrand)-0.5) * Lx
ry1 = (rng.random_sample(nrand)-0.5) * Ly
rx2 = (rng.random_sample(nrand)-0.5) * Lx
ry2 = (rng.random_sample(nrand)-0.5) * Ly
rcat1 = treecorr.Catalog(x=rx1, y=ry1)
rcat2 = treecorr.Catalog(x=rx2, y=ry2)
rand_file_name1 = os.path.join('data','nn_periodic_rand1.dat')
with open(rand_file_name1, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx1[i],ry1[i]))
rand_file_name2 = os.path.join('data','nn_periodic_rand2.dat')
with open(rand_file_name2, 'w') as fid:
for i in range(nrand):
fid.write(('%.20f %.20f\n')%(rx2[i],ry2[i]))
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, bin_slop=0,
verbose=0, xperiod=Lx, yperiod=Ly)
rr.process(rcat1,rcat2, metric='Periodic')
xi, varxi = dd.calculateXi(rr)
print('xi = ',xi)
# Do this via the corr2 function.
config = treecorr.config.read_config('configs/nn_periodic.yaml')
logger = treecorr.config.setup_logger(2)
treecorr.corr2(config, logger)
corr2_output = np.genfromtxt(os.path.join('output','nn_periodic.out'), names=True,
skip_header=1)
np.testing.assert_allclose(corr2_output['r_nom'], dd.rnom, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['DD'], dd.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['npairs'], dd.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['RR'], rr.npairs, rtol=1.e-3)
np.testing.assert_allclose(corr2_output['xi'], xi, rtol=1.e-3)
# If don't give a period, then an error.
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
# Or if only give one kind of period
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, xperiod=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, yperiod=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2, metric='Periodic')
# If give period, but then don't use Periodic metric, that's also an error.
rr = treecorr.NNCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins, period=3)
with assert_raises(ValueError):
rr.process(rcat1,rcat2)
def test_kk():
# cf. http://adsabs.harvard.edu/abs/2002A%26A...389..729S for the basic formulae I use here.
#
# Use kappa(r) = A exp(-r^2/2s^2)
#
# The Fourier transform is: kappa~(k) = 2 pi A s^2 exp(-s^2 k^2/2) / L^2
# P(k) = (1/2pi) <|kappa~(k)|^2> = 2 pi A^2 (s/L)^4 exp(-s^2 k^2)
# xi(r) = (1/2pi) int( dk k P(k) J0(kr) )
# = pi A^2 (s/L)^2 exp(-r^2/2s^2/4)
# Note: I'm not sure I handled the L factors correctly, but the units at the end need
# to be kappa^2, so it needs to be (s/L)^2.
s = 10.
if __name__ == '__main__':
ngal = 1000000
L = 30. * s # Not infinity, so this introduces some error. Our integrals were to infinity.
tol_factor = 1
else:
ngal = 100000
L = 30. * s
tol_factor = 2
A = 0.05
rng = np.random.RandomState(8675309)
x = (rng.random_sample(ngal)-0.5) * L
y = (rng.random_sample(ngal)-0.5) * L
r2 = (x**2 + y**2)/s**2
kappa = A * np.exp(-r2/2.)
cat = treecorr.Catalog(x=x, y=y, k=kappa, x_units='arcmin', y_units='arcmin')
kk = treecorr.KKCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
kk.process(cat)
# log(<R>) != <logR>, but it should be close:
print('meanlogr - log(meanr) = ',kk.meanlogr - np.log(kk.meanr))
np.testing.assert_allclose(kk.meanlogr, np.log(kk.meanr), atol=1.e-3)
r = kk.meanr
true_xi = np.pi * A**2 * (s/L)**2 * np.exp(-0.25*r**2/s**2)
print('kk.xi = ',kk.xi)
print('true_xi = ',true_xi)
print('ratio = ',kk.xi / true_xi)
print('diff = ',kk.xi - true_xi)
print('max diff = ',max(abs(kk.xi - true_xi)))
print('max rel diff = ',max(abs((kk.xi - true_xi)/true_xi)))
np.testing.assert_allclose(kk.xi, true_xi, rtol=0.1*tol_factor)
# It should also work as a cross-correlation of this cat with itself
kk.process(cat,cat)
np.testing.assert_allclose(kk.meanlogr, np.log(kk.meanr), atol=1.e-3)
np.testing.assert_allclose(kk.xi, true_xi, rtol=0.1*tol_factor)
# Check that we get the same result using the corr2 function
cat.write(os.path.join('data','kk.dat'))
config = treecorr.read_config('configs/kk.yaml')
config['verbose'] = 0
config['precision'] = 8
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','kk.out'), names=True, skip_header=1)
print('kk.xi = ',kk.xi)
print('from corr2 output = ',corr2_output['xi'])
print('ratio = ',corr2_output['xi']/kk.xi)
print('diff = ',corr2_output['xi']-kk.xi)
np.testing.assert_allclose(corr2_output['xi'], kk.xi, rtol=1.e-3)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check the fits write option
out_file_name = os.path.join('output','kk_out.fits')
kk.write(out_file_name)
data = fitsio.read(out_file_name)
np.testing.assert_almost_equal(data['r_nom'], np.exp(kk.logr))
np.testing.assert_almost_equal(data['meanr'], kk.meanr)
np.testing.assert_almost_equal(data['meanlogr'], kk.meanlogr)
np.testing.assert_almost_equal(data['xi'], kk.xi)
np.testing.assert_almost_equal(data['sigma_xi'], np.sqrt(kk.varxi))
np.testing.assert_almost_equal(data['weight'], kk.weight)
np.testing.assert_almost_equal(data['npairs'], kk.npairs)
# Check the read function
kk2 = treecorr.KKCorrelation(bin_size=0.1, min_sep=1., max_sep=100., sep_units='arcmin')
kk2.read(out_file_name)
np.testing.assert_almost_equal(kk2.logr, kk.logr)
np.testing.assert_almost_equal(kk2.meanr, kk.meanr)
np.testing.assert_almost_equal(kk2.meanlogr, kk.meanlogr)
np.testing.assert_almost_equal(kk2.xi, kk.xi)
np.testing.assert_almost_equal(kk2.varxi, kk.varxi)
np.testing.assert_almost_equal(kk2.weight, kk.weight)
np.testing.assert_almost_equal(kk2.npairs, kk.npairs)
assert kk2.coords == kk.coords
assert kk2.metric == kk.metric
assert kk2.sep_units == kk.sep_units
assert kk2.bin_type == kk.bin_type
def test_kg():
# Use gamma_t(r) = gamma0 exp(-r^2/2r0^2) around a bunch of foreground lenses.
# i.e. gamma(r) = -gamma0 exp(-r^2/2r0^2) (x+iy)^2/r^2
# For each lens, we divide this by a random kappa value assigned to that lens, so
# the final kg output shoudl be just gamma_t.
nlens = 1000
nsource = 30000
r0 = 10.
L = 50. * r0
gamma0 = 0.05
rng = np.random.RandomState(8675309)
xl = (rng.random_sample(nlens)-0.5) * L
yl = (rng.random_sample(nlens)-0.5) * L
kl = rng.normal(0.23, 0.05, (nlens,) )
xs = (rng.random_sample(nsource)-0.5) * L
ys = (rng.random_sample(nsource)-0.5) * L
g1 = np.zeros( (nsource,) )
g2 = np.zeros( (nsource,) )
for x,y,k in zip(xl,yl,kl):
dx = xs-x
dy = ys-y
r2 = dx**2 + dy**2
gammat = gamma0 * np.exp(-0.5*r2/r0**2) / k
g1 += -gammat * (dx**2-dy**2)/r2
g2 += -gammat * (2.*dx*dy)/r2
lens_cat = treecorr.Catalog(x=xl, y=yl, k=kl, x_units='arcmin', y_units='arcmin')
source_cat = treecorr.Catalog(x=xs, y=ys, g1=g1, g2=g2, x_units='arcmin', y_units='arcmin')
kg = treecorr.KGCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin',
verbose=1)
kg.process(lens_cat, source_cat)
r = kg.meanr
true_gt = gamma0 * np.exp(-0.5*r**2/r0**2)
print('kg.xi = ',kg.xi)
print('kg.xi_im = ',kg.xi_im)
print('true_gammat = ',true_gt)
print('ratio = ',kg.xi / true_gt)
print('diff = ',kg.xi - true_gt)
print('max diff = ',max(abs(kg.xi - true_gt)))
np.testing.assert_allclose(kg.xi, true_gt, rtol=0.1)
np.testing.assert_allclose(kg.xi_im, 0., atol=1.e-2)
# Check that we get the same result using the corr2 function:
lens_cat.write(os.path.join('data','kg_lens.dat'))
source_cat.write(os.path.join('data','kg_source.dat'))
config = treecorr.read_config('configs/kg.yaml')
config['verbose'] = 0
config['precision'] = 8
treecorr.corr2(config)
corr2_output = np.genfromtxt(os.path.join('output','kg.out'), names=True, skip_header=1)
print('kg.xi = ',kg.xi)
print('from corr2 output = ',corr2_output['kgamT'])
print('ratio = ',corr2_output['kgamT']/kg.xi)
print('diff = ',corr2_output['kgamT']-kg.xi)
np.testing.assert_allclose(corr2_output['kgamT'], kg.xi, rtol=1.e-3)
print('xi_im from corr2 output = ',corr2_output['kgamX'])
np.testing.assert_allclose(corr2_output['kgamX'], 0., atol=1.e-2)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check the fits write option
out_file_name1 = os.path.join('output','kg_out1.fits')
kg.write(out_file_name1)
data = fitsio.read(out_file_name1)
np.testing.assert_almost_equal(data['r_nom'], np.exp(kg.logr))
np.testing.assert_almost_equal(data['meanr'], kg.meanr)
np.testing.assert_almost_equal(data['meanlogr'], kg.meanlogr)
np.testing.assert_almost_equal(data['kgamT'], kg.xi)
np.testing.assert_almost_equal(data['kgamX'], kg.xi_im)
np.testing.assert_almost_equal(data['sigma'], np.sqrt(kg.varxi))
np.testing.assert_almost_equal(data['weight'], kg.weight)
np.testing.assert_almost_equal(data['npairs'], kg.npairs)
# Check the read function
kg2 = treecorr.KGCorrelation(bin_size=0.1, min_sep=1., max_sep=20., sep_units='arcmin')
kg2.read(out_file_name1)
np.testing.assert_almost_equal(kg2.logr, kg.logr)
np.testing.assert_almost_equal(kg2.meanr, kg.meanr)
np.testing.assert_almost_equal(kg2.meanlogr, kg.meanlogr)
np.testing.assert_almost_equal(kg2.xi, kg.xi)
np.testing.assert_almost_equal(kg2.xi_im, kg.xi_im)
np.testing.assert_almost_equal(kg2.varxi, kg.varxi)
np.testing.assert_almost_equal(kg2.weight, kg.weight)
np.testing.assert_almost_equal(kg2.npairs, kg.npairs)
assert kg2.coords == kg.coords
assert kg2.metric == kg.metric
assert kg2.sep_units == kg.sep_units
assert kg2.bin_type == kg.bin_type
def test_direct():
# If the catalogs are small enough, we can do a direct calculation to see if comes out right.
# This should exactly match the treecorr result if bin_slop=0.
ngal = 200
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)
k1 = np.random.normal(10, 1, (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, ))
cat1 = treecorr.Catalog(x=x1, y=y1, w=w1, k=k1)
cat2 = treecorr.Catalog(x=x2, y=y2, w=w2, k=k2)
min_sep = 1.
max_sep = 50.
nbins = 50
bin_size = np.log(max_sep / min_sep) / nbins
kk = treecorr.KKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
bin_slop=0.)
kk.process(cat1, cat2)
true_npairs = np.zeros(nbins, dtype=int)
true_weight = np.zeros(nbins, dtype=float)
true_xi = np.zeros(nbins, dtype=float)
for i in range(ngal):
# It's hard to do all the pairs at once with numpy operations (although maybe possible).
# But we can at least do all the pairs for each entry in cat1 at once with arrays.
rsq = (x1[i] - x2)**2 + (y1[i] - y2)**2
r = np.sqrt(rsq)
logr = np.log(r)
expmialpha = ((x1[i] - x2) - 1j * (y1[i] - y2)) / r
ww = w1[i] * w2
xi = ww * k1[i] * 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
print('true_npairs = ', true_npairs)
print('diff = ', kk.npairs - true_npairs)
np.testing.assert_array_equal(kk.npairs, true_npairs)
print('true_weight = ', true_weight)
print('diff = ', kk.weight - true_weight)
np.testing.assert_allclose(kk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
print('true_xi = ', true_xi)
print('kk.xi = ', kk.xi)
np.testing.assert_allclose(kk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
try:
import fitsio
except ImportError:
print('Skipping FITS tests, since fitsio is not installed')
return
# Check that running via the corr2 script works correctly.
config = treecorr.config.read_config('configs/kk_direct.yaml')
cat1.write(config['file_name'])
cat2.write(config['file_name2'])
treecorr.corr2(config)
data = fitsio.read(config['kk_file_name'])
np.testing.assert_allclose(data['R_nom'], kk.rnom)
np.testing.assert_allclose(data['npairs'], kk.npairs)
np.testing.assert_allclose(data['weight'], kk.weight)
np.testing.assert_allclose(data['xi'], kk.xi, rtol=1.e-3)
# Repeat with binslop not precisely 0, since the code flow is different for bin_slop == 0.
# And don't do any top-level recursion so we actually test not going to the leaves.
kk = treecorr.KKCorrelation(min_sep=min_sep,
max_sep=max_sep,
nbins=nbins,
bin_slop=1.e-16,
max_top=0)
kk.process(cat1, cat2)
np.testing.assert_array_equal(kk.npairs, true_npairs)
np.testing.assert_allclose(kk.weight, true_weight, rtol=1.e-5, atol=1.e-8)
np.testing.assert_allclose(kk.xi, true_xi, rtol=1.e-4, atol=1.e-8)
# Check a few basic operations with a KKCorrelation object.
do_pickle(kk)
kk2 = kk.copy()
kk2 += kk
np.testing.assert_allclose(kk2.npairs, 2 * kk.npairs)
np.testing.assert_allclose(kk2.weight, 2 * kk.weight)
np.testing.assert_allclose(kk2.meanr, 2 * kk.meanr)
np.testing.assert_allclose(kk2.meanlogr, 2 * kk.meanlogr)
np.testing.assert_allclose(kk2.xi, 2 * kk.xi)
kk2.clear()
kk2 += kk
np.testing.assert_allclose(kk2.npairs, kk.npairs)
np.testing.assert_allclose(kk2.weight, kk.weight)
np.testing.assert_allclose(kk2.meanr, kk.meanr)
np.testing.assert_allclose(kk2.meanlogr, kk.meanlogr)
np.testing.assert_allclose(kk2.xi, kk.xi)
ascii_name = 'output/kk_ascii.txt'
kk.write(ascii_name, precision=16)
kk3 = treecorr.KKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
kk3.read(ascii_name)
np.testing.assert_allclose(kk3.npairs, kk.npairs)
np.testing.assert_allclose(kk3.weight, kk.weight)
np.testing.assert_allclose(kk3.meanr, kk.meanr)
np.testing.assert_allclose(kk3.meanlogr, kk.meanlogr)
np.testing.assert_allclose(kk3.xi, kk.xi)
fits_name = 'output/kk_fits.fits'
kk.write(fits_name)
kk4 = treecorr.KKCorrelation(min_sep=min_sep, max_sep=max_sep, nbins=nbins)
kk4.read(fits_name)
np.testing.assert_allclose(kk4.npairs, kk.npairs)
np.testing.assert_allclose(kk4.weight, kk.weight)
np.testing.assert_allclose(kk4.meanr, kk.meanr)
np.testing.assert_allclose(kk4.meanlogr, kk.meanlogr)
np.testing.assert_allclose(kk4.xi, kk.xi)