def map_data(self, data, mask_pattern):
n = self.modules_count
mask_func = util.mask_func(mask_pattern)
data_len = len(data)
x = y = 0
t = (data_len - 1) // 13 + 1
for i in xrange(13):
for j in xrange(t):
if j * 13 + i < data_len:
c = data[j * 13 + i]
else:
continue
for k in xrange(8):
while x < n and y < n and self.modules[y][x] != None:
x += 1
if x >= n:
x = 0
y += 1
if x >= n or y >= n:
break
self.modules[y][x] = ((c & 0x80) != 0)
if (mask_func(y + 1, x + 1)):
self.modules[y][x] = not self.modules[y][x]
c <<= 1
while y < n:
while x < n:
if self.modules[y][x] == None:
self.modules[y][x] = (mask_func(y + 1, x + 1))
x += 1
x = 0
y += 1
def test_subvol_gmf(Mr):
"""
"""
thr = -1.0 * np.float(Mr)
model = PrebuiltHodModelFactory("zheng07", threshold=thr, halocat="multidark", redshift=0.0)
model.new_haloprop_func_dict = {"sim_subvol": util.mk_id_column}
datsubvol = lambda x: util.mask_func(x, 0)
model.populate_mock(simname="multidark", masking_function=datsubvol, enforce_PBC=False)
# compute group richness
# These are wrong because they assume periodicity
# rich = richness(model.mock.compute_fof_group_ids())
# gmf = GMF(rich) #GMF
# print gmf
# print GMF(rich , counts = True)
galaxy_sample = model.mock.galaxy_table
x = galaxy_sample["x"]
y = galaxy_sample["y"]
z = galaxy_sample["z"]
vz = galaxy_sample["vz"]
pos = three_dim_pos_bundle(model.mock.galaxy_table, "x", "y", "z", velocity=vz, velocity_distortion_dimension="z")
b_para, b_perp = 0.2, 0.2
groups = FoFGroups(pos, b_perp, b_para, period=None, Lbox=200, num_threads="max")
gids = groups.group_ids
rich = richness(gids)
gmf = GMF(rich)
print gmf
print GMF(rich, counts=True)
return None
def test_GMFbinning(Mr):
""" Tests for the GMF binning scheme in order to make it sensible.
"""
gids_saved = "gids_saved.p"
if not os.path.isfile(gids_saved):
thr = -1.0 * np.float(Mr)
model = PrebuiltHodModelFactory("zheng07", threshold=thr, halocat="multidark", redshift=0.0)
model.new_haloprop_func_dict = {"sim_subvol": util.mk_id_column}
datsubvol = lambda x: util.mask_func(x, 0)
model.populate_mock(simname="multidark", masking_function=datsubvol, enforce_PBC=False)
galaxy_sample = model.mock.galaxy_table
x = galaxy_sample["x"]
y = galaxy_sample["y"]
z = galaxy_sample["z"]
vz = galaxy_sample["vz"]
pos = three_dim_pos_bundle(
model.mock.galaxy_table, "x", "y", "z", velocity=vz, velocity_distortion_dimension="z"
)
b_para, b_perp = 0.2, 0.2
groups = FoFGroups(pos, b_perp, b_para, period=None, Lbox=200, num_threads="max")
pickle.dump(groups, open(gids_saved, "wb"))
else:
groups = pickle.load(open(gids_saved, "rb"))
gids = groups.group_ids
rich = richness(gids)
# print "rich=" , rich
rbins = np.logspace(np.log10(3.0), np.log10(20), 10)
rbins = np.array([1, 2.0, 3.0, 4.0, 5.0, 6.0, 7, 9, 11, 14, 17, 20])
gmf = GMF(rich, counts=False, bins=rbins)
gmf_counts = GMF(rich, counts=True, bins=rbins)
print rbins
print gmf
print gmf_counts
fig = plt.figure(1)
sub = fig.add_subplot(111)
sub.plot(0.5 * (rbins[:-1] + rbins[1:]), gmf)
sub.set_xscale("log")
sub.set_yscale("log")
plt.show()
# print gmf
# print GMF(rich , counts = True)
return None
def test_subvol_gmf(Mr):
'''
'''
thr = -1. * np.float(Mr)
model = PrebuiltHodModelFactory('zheng07',
threshold=thr,
halocat='multidark',
redshift=0.)
model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
datsubvol = lambda x: util.mask_func(x, 0)
model.populate_mock(simname='multidark',
masking_function=datsubvol,
enforce_PBC=False)
#compute group richness
# These are wrong because they assume periodicity
#rich = richness(model.mock.compute_fof_group_ids())
#gmf = GMF(rich) #GMF
#print gmf
#print GMF(rich , counts = True)
galaxy_sample = model.mock.galaxy_table
x = galaxy_sample['x']
y = galaxy_sample['y']
z = galaxy_sample['z']
vz = galaxy_sample['vz']
pos = three_dim_pos_bundle(model.mock.galaxy_table,
'x',
'y',
'z',
velocity=vz,
velocity_distortion_dimension="z")
b_para, b_perp = 0.2, 0.2
groups = FoFGroups(pos,
b_perp,
b_para,
period=None,
Lbox=200,
num_threads='max')
gids = groups.group_ids
rich = richness(gids)
gmf = GMF(rich)
print gmf
print GMF(rich, counts=True)
return None
def map_data(self, data, mask_pattern):
p = 0
for i in range(self.segments):
for j in range(7, (self.version * 5 - 1) * 11):
x = START_WIDTH + 1 + i * 34 + (j //
(5 * self.version - 1)) * 3
xx = j // (5 * self.version - 1)
y = 15 * (self.version) - 1 - (j % (5 * self.version - 1)) * 3
if p < len(self.data_cache):
d = data[p] ^ util.mask_func(
mask_pattern, xx, (5 * self.version - 1 - y // 3))
for k in range(9):
self.modules[y - k % 3][x +
(k // 3)] = (d &
(1 <<
(8 - k))) != 0
p += 1
def map_data(self, data, mask_pattern):
inc = -1
row = self.modules_count - 1
bitIndex = 7
byteIndex = 0
mask_func = util.mask_func(mask_pattern)
data_len = len(data)
#print(self.modules)
for col in range(self.modules_count - 1, 0, -2):
if col <= 6:
col -= 1
col_range = (col, col - 1)
while True:
for c in col_range:
if self.modules[row][c] is None:
dark = False
if byteIndex < data_len:
dark = (((data[byteIndex] >> bitIndex) & 1) == 1)
if mask_func(row, c):
dark = not dark
self.modules[row][c] = dark
bitIndex -= 1
if bitIndex == -1:
byteIndex += 1
bitIndex = 7
row += inc
if row < 0 or self.modules_count <= row:
row -= inc
inc = -inc
break
def main():
###############################Multi-Dark###########################
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
t0 = time.time()
model.populate_mock(halocat, enforce_PBC = False)
print(time.time() - t0)
t0 = time.time()
model.populate_mock(halocat, enforce_PBC = False)
print(time.time() - t0)
pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
nthreads = 1
binfile = path.join(path.dirname(path.abspath(__file__)),
"/home/mj/Corrfunc/xi_theory/tests/", "bins")
autocorr = 1
pos = pos.astype(np.float32)
x , y , z = pos[:,0] , pos[:,1] , pos[:,2]
DD = _countpairs.countpairs(autocorr, nthreads, binfile, x, y, z,
x , y , z)
ND = len(pos)
NR = 50*800000
DD = np.array(DD)[:,3]
num_randoms = 50 * 800000
xran = np.random.uniform(0, 1000, num_randoms)
yran = np.random.uniform(0, 1000, num_randoms)
zran = np.random.uniform(0, 1000, num_randoms)
randoms = np.vstack((xran, yran, zran)).T
randoms = randoms.astype(np.float32)
xran = randoms[:,0]
yran = randoms[:,1]
zran = randoms[:,2]
results_RR = _countpairs.countpairs(autocorr, nthreads, binfile, xran, yran, zran,
xran, yran, zran)
RR = np.array(results_RR)[:,3]
factor1 = 1.*ND*ND/(NR*NR)
mult = lambda x,y: x*y
xi_MD = mult(1.0/factor1 , DD/RR) - 1.
print(xi_MD)
###############################Subvolume of Multi-Dark###########################
num_srandoms = 50 * 8000
xran = np.random.uniform(0, 200, num_srandoms)
yran = np.random.uniform(0, 200, num_srandoms)
zran = np.random.uniform(0, 200, num_srandoms)
randoms = np.vstack((xran, yran, zran)).T
randoms = randoms.astype(np.float32)
xran = randoms[:,0]
yran = randoms[:,1]
zran = randoms[:,2]
results_RR = _countpairs.countpairs(autocorr, nthreads, binfile, xran, yran, zran,
xran, yran, zran)
RR_sub = np.array(results_RR)[:,3]
import util
sub_model = PrebuiltHodModelFactory('zheng07' , threshold = -21)
sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
sub_halocat = CachedHaloCatalog(simname='multidark', redshift=0, halo_finder='rockstar')
xi_subs = []
for i in range(10):
simsubvol = lambda x: util.mask_func(x, i)
sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
sub_pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')
nthreads = 1
binfile = path.join(path.dirname(path.abspath(__file__)),
"/home/mj/Corrfunc/xi_theory/tests/", "bins")
autocorr = 1
sub_pos = sub_pos.astype(np.float32)
x , y , z = sub_pos[:,0] , sub_pos[:,1] , sub_pos[:,2]
DD_sub = _countpairs.countpairs(autocorr, nthreads, binfile, x, y, z,
x, y, z)
ND_sub = len(sub_pos)
NR_sub = 50 * 8000
DD_sub = np.array(DD_sub)[:,3]
factor1 = 1.*ND_sub*ND_sub/(NR_sub*NR_sub)
mult = lambda x,y: x*y
xi_n = mult(1.0/factor1 , DD_sub/RR_sub) - 1.
xi_subs.append(xi_n)
xi_subs = np.array(xi_subs)
np.savetxt("xi_subs.dat" , xi_subs)
import matplotlib.pyplot as plt
from ChangTools.plotting import prettyplot
from ChangTools.plotting import prettycolors
binfile = path.join(path.dirname(path.abspath(__file__)),
"/home/mj/Corrfunc/xi_theory/tests/", "bins")
rbins = np.loadtxt(binfile)
rbins_centers = np.mean(rbins , axis = 1)
xi_subs = np.loadtxt("xi_subs.dat")
fig = plt.figure(figsize=(10,10))
ax = fig.add_subplot(111)
for i in range(10):
ax.semilogx(rbins_centers , xi_subs[i,:] / xi_MD , alpha = 0.2)
plt.xlabel(r"$r$" , fontsize = 20)
plt.ylabel(r"$\xi_{\rm subvolume}(r) / \xi_{\rm MD}(r)$" , fontsize = 20)
plt.savefig("xi_ratios.pdf")
def Subvolume_FullvolumeCut(N_sub, ratio=False):
''' Test the 2PCF estimates from MultiDark subvolume versus the
2PCF for the entire MultiDark volume WITHOUT periodic boundary conditions
and actual pair counts, CUT into subvolumes of the same size *AFTER*
populate mock
Parameters
----------
N_sub : (int)
Number of subvolumes to sample
'''
prettyplot()
pretty_colors = prettycolors()
pickle_file = ''.join([
'/export/bbq2/hahn/ccppabc/dump/',
'xi_subvolume_fullvolume_cut_test',
'.Nsub', str(N_sub),
'.p'])
fig = plt.figure(1)
sub = fig.add_subplot(111)
xi_bin = xi_binedges()
# Entire MultiDark Volume (No Periodic Boundary Conditions)
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
sub_RR = data_RR(box='md_sub')
sub_randoms = data_random(box='md_sub')
sub_NR = len(sub_randoms)
rmax = xi_bin.max()
full_approx_cell1_size = [rmax , rmax , rmax]
full_approx_cellran_size = [rmax , rmax , rmax]
model.populate_mock(halocat, enforce_PBC=False)
subvol_id = util.mk_id_column(table=model.mock.galaxy_table)
full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
# Full Volume
if os.path.isfile(pickle_file):
data_dump = pickle.load(open(pickle_file, 'rb'))
full_xi = data_dump['full_xi']
else:
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
full_randoms = data_random(box='md_all')
full_RR = data_RR(box='md_all')
full_NR = len(full_randoms)
rmax = xi_bin.max()
full_approx_cell1_size = [rmax , rmax , rmax]
full_approx_cellran_size = [rmax , rmax , rmax]
model.populate_mock(halocat, enforce_PBC=False)
full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
full_xi = tpcf(
full_pos, xi_bin,
randoms=full_randoms, period=None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(full_pos.shape[0]), estimator='Natural',
approx_cell1_size=full_approx_cell1_size,
approx_cellran_size=full_approx_cellran_size,
RR_precomputed = full_RR,
NR_precomputed = full_NR)
data_dump = {}
data_dump['full_xi'] = full_xi
if not ratio:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), full_xi,
lw=2, ls='-', c='k', label=r'Full Volume')
if os.path.isfile(pickle_file):
fullcut_xi_list = data_dump['fullcut_xi']['fullcut_xi_list']
fullcut_xi_avg = data_dump['fullcut_xi']['fullcut_xi_avg']
else:
data_dump['fullcut_xi'] = {}
fullcut_xi_list = []
fullcut_xi_tot = np.zeros(len(xi_bin)-1)
for id in np.unique(subvol_id)[:N_sub]:
print 'Subvolume ', id
in_cut = np.where(subvol_id == id)
fullcut_pos = full_pos[in_cut]
fullcut_xi = tpcf(
fullcut_pos, xi_bin,
randoms=sub_randoms, period=None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(fullcut_pos.shape[0]), estimator='Natural',
approx_cell1_size=full_approx_cell1_size,
approx_cellran_size=full_approx_cellran_size,
RR_precomputed=sub_RR,
NR_precomputed=sub_NR)
fullcut_xi_list.append(fullcut_xi)
fullcut_xi_tot += fullcut_xi
fullcut_xi_avg = fullcut_xi_tot / np.float(N_sub)
data_dump['fullcut_xi']['fullcut_xi_list']= fullcut_xi_list
data_dump['fullcut_xi']['fullcut_xi_avg']= fullcut_xi_avg
if not ratio:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), fullcut_xi_avg,
lw=2, ls='-', c='k', label=r'Full Volume Cut Average')
else:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), fullcut_xi_avg/full_xi,
lw=2, ls='-', c='k', label=r'Full Volume Cut Average')
if not os.path.isfile(pickle_file):
# MultiDark SubVolume (precomputed RR pairs)
sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
sub_halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
sub_RR = data_RR(box='md_sub')
sub_randoms = data_random(box='md_sub')
sub_NR = len(sub_randoms)
sub_xis_list = []
sub_xis = np.zeros(len(full_xi))
for ii in range(1,N_sub):
print 'Subvolume ', ii
# randomly sample one of the subvolumes
rint = ii #np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')
xi, yi , zi = util.random_shifter(rint)
temp_randoms = sub_randoms.copy()
temp_randoms[:,0] += xi
temp_randoms[:,1] += yi
temp_randoms[:,2] += zi
rmax = xi_bin.max()
sub_approx_cell1_size = [rmax , rmax , rmax]
sub_approx_cellran_size = [rmax , rmax , rmax]
sub_xi = tpcf(
pos, xi_bin,
randoms=temp_randoms,
period = None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(pos.shape[0]),
estimator='Natural',
approx_cell1_size = sub_approx_cell1_size,
approx_cellran_size = sub_approx_cellran_size,
RR_precomputed=sub_RR,
NR_precomputed=sub_NR)
label = None
if ii == N_sub - 1:
label = 'Subvolumes'
sub_xis += sub_xi
sub_xis_list.append(sub_xi)
sub_xi_avg = sub_xis/np.float(N_sub)
data_dump['Natural'] = {}
data_dump['Natural']['sub_xi_avg'] = sub_xi_avg
data_dump['Natural']['sub_xis_list'] = sub_xis_list
else:
sub_xis_list = data_dump['Natural']['sub_xis_list']
sub_xi_avg = data_dump['Natural']['sub_xi_avg']
if not os.path.isfile(pickle_file):
pickle.dump(data_dump, open(pickle_file, 'wb'))
if not ratio:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg,
lw=2, ls='--', c=pretty_colors[3], label='Subvolume')
else:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg/full_xi,
lw=2, ls='--', c=pretty_colors[3], label='Subvolume')
sub.set_xlim([0.1, 50.])
sub.set_xlabel('r', fontsize=30)
sub.set_xscale('log')
if not ratio:
sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
sub.set_yscale('log')
else:
sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$", fontsize=25)
sub.legend(loc='lower left')
if ratio:
fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub', str(N_sub), '.ratio.png'])
else:
fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub', str(N_sub), '.png'])
fig.savefig(fig_file, bbox_inches='tight', dpi=100)
plt.close()
return None
def Subvolume_Analytic(N_sub, ratio=False):
''' Test the 2PCF estimates from MultiDark subvolume versus the
analytic 2PCF for the entire MultiDark volume
Parameters
----------
N_sub : (int)
Number of subvolumes to sample
'''
prettyplot()
pretty_colors = prettycolors()
pickle_file = ''.join([
'/export/bbq2/hahn/ccppabc/dump/',
'xi_subvolume_test',
'.Nsub', str(N_sub),
'.p'])
fig = plt.figure(1)
sub = fig.add_subplot(111)
xi_bin = xi_binedges()
if os.path.isfile(pickle_file):
data_dump = pickle.load(open(pickle_file, 'rb'))
full_xi = data_dump['full_xi']
else:
# Entire MultiDark Volume (Analytic xi)
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
model.populate_mock(halocat)
pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
# while the estimator claims to be Landy-Szalay, I highly suspect it
# actually uses Landy-Szalay since DR pairs cannot be calculated from
# analytic randoms
full_xi = tpcf(pos, xi_bin, period=model.mock.Lbox, max_sample_size=int(2e5), estimator='Landy-Szalay', num_threads=1)
data_dump = {}
data_dump['full_xi'] = full_xi
if not ratio:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), full_xi, lw=2, ls='-', c='k', label=r'Analytic $\xi$ Entire Volume')
if not os.path.isfile(pickle_file):
# MultiDark SubVolume (precomputed RR pairs)
sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
sub_halocat = CachedHaloCatalog(simname = 'multidark', redshift = 0, halo_finder = 'rockstar')
RR = data_RR()
randoms = data_random()
NR = len(randoms)
for method in ['Landy-Szalay', 'Natural']:
if method == 'Landy-Szalay':
iii = 3
elif method == 'Natural':
iii = 5
if not os.path.isfile(pickle_file):
sub_xis_list = []
sub_xis = np.zeros(len(full_xi))
for ii in range(1,N_sub+1):
# randomly sample one of the subvolumes
rint = ii #np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
sub_model.populate_mock(sub_halocat, masking_function=simsubvol, enforce_PBC=False)
pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y', 'z')
xi, yi , zi = util.random_shifter(rint)
temp_randoms = randoms.copy()
temp_randoms[:,0] += xi
temp_randoms[:,1] += yi
temp_randoms[:,2] += zi
rmax = xi_bin.max()
approx_cell1_size = [rmax , rmax , rmax]
approx_cellran_size = [rmax , rmax , rmax]
sub_xi = tpcf(
pos, xi_bin, pos,
randoms=temp_randoms,
period = None,
max_sample_size=int(1e5),
estimator=method,
approx_cell1_size = approx_cell1_size,
approx_cellran_size = approx_cellran_size,
RR_precomputed=RR,
NR_precomputed=NR)
label = None
if ii == N_sub - 1:
label = 'Subvolumes'
#if not ratio:
# sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi, lw=0.5, ls='--', c=pretty_colors[iii])
sub_xis += sub_xi
sub_xis_list.append(sub_xi)
sub_xi_avg = sub_xis/np.float(N_sub)
data_dump[method] = {}
data_dump[method]['sub_xi_avg'] = sub_xi_avg
data_dump[method]['sub_xis_list'] = sub_xis_list
else:
sub_xis_list = data_dump[method]['sub_xis_list']
sub_xi_avg = data_dump[method]['sub_xi_avg']
if not ratio:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg,
lw=2, ls='--', c=pretty_colors[iii], label='Subvolume '+method)
else:
sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi_avg/full_xi,
lw=2, ls='--', c=pretty_colors[iii], label='Subvolume '+method)
if not os.path.isfile(pickle_file):
pickle.dump(data_dump, open(pickle_file, 'wb'))
sub.set_xlim([0.1, 50.])
sub.set_xlabel('r', fontsize=30)
sub.set_xscale('log')
if not ratio:
sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
sub.set_yscale('log')
else:
sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$", fontsize=25)
sub.legend(loc='lower left')
if ratio:
fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_analytic.Nsub', str(N_sub), '.ratio.png'])
else:
fig_file = ''.join([util.fig_dir(), 'test_xi_subvolume_analytic.Nsub', str(N_sub), '.png'])
fig.savefig(fig_file, bbox_inches='tight', dpi=100)
plt.close()
return None
def _sum_stat(self, theta, prior_range=None, observables=['nbar', 'gmf']):
'''
Given theta, sum_stat calculates the observables from our forward model
Parameters
----------
theta : (self explanatory)
prior_range : If specified, checks to make sure that theta is within the prior range.
'''
self.model.param_dict['logM0'] = theta[0]
self.model.param_dict['sigma_logM'] = np.exp(theta[1])
self.model.param_dict['logMmin'] = theta[2]
self.model.param_dict['alpha'] = theta[3]
self.model.param_dict['logM1'] = theta[4]
rbins = xi_binedges()
rmax = rbins.max()
period = None
approx_cell1_size = [rmax, rmax, rmax]
approx_cellran_size = [rmax, rmax, rmax]
if prior_range is None:
rint = np.random.randint(1, 125)
####simsubvol = lambda x: util.mask_func(x, rint)
####self.model.populate_mock(self.halocat,
#### masking_function=simsubvol,
#### enforce_PBC=False)
self.model.populate_mock(self.halocat)
pos = three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y',
'z')
pos = util.mask_galaxy_table(pos, rint)
xi, yi, zi = util.random_shifter(rint)
temp_randoms = self.randoms.copy()
temp_randoms[:, 0] += xi
temp_randoms[:, 1] += yi
temp_randoms[:, 2] += zi
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(len(pos) /
200**3.) # nbar of the galaxy catalog
elif obv == 'gmf':
#compute group richness
nbar = len(pos) / 200**3.
b = self.b_normal * (nbar)**(-1. / 3)
groups = pyfof.friends_of_friends(pos, b)
w = np.array([len(x) for x in groups])
gbins = data_gmf_bins()
gmf = np.histogram(w, gbins)[0] / (200.**3.)
obvs.append(gmf)
elif obv == 'xi':
greek_xi = tpcf(pos,
rbins,
pos,
randoms=temp_randoms,
period=period,
max_sample_size=int(1e5),
estimator='Natural',
approx_cell1_size=approx_cell1_size,
approx_cellran_size=approx_cellran_size,
RR_precomputed=self.RR,
NR_precomputed=self.NR)
obvs.append(greek_xi)
else:
raise NotImplementedError(
'Only nbar 2pcf, gmf implemented so far')
return obvs
else:
if np.all((prior_range[:, 0] < theta)
& (theta < prior_range[:, 1])):
# if all theta_i is within prior range ...
try:
rint = np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
self.model.populate_mock(self.halocat,
masking_function=simsubvol,
enforce_PBC=False)
pos = three_dim_pos_bundle(self.model.mock.galaxy_table,
'x', 'y', 'z')
xi, yi, zi = util.random_shifter(rint)
temp_randoms = self.randoms.copy()
temp_randoms[:, 0] += xi
temp_randoms[:, 1] += yi
temp_randoms[:, 2] += zi
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(len(pos) /
200**3.) # nbar of the galaxy catalog
elif obv == 'gmf':
nbar = len(pos) / 200**3.
b = self.b_normal * (nbar)**(-1. / 3)
groups = pyfof.friends_of_friends(pos, b)
w = np.array([len(x) for x in groups])
gbins = data_gmf_bins()
gmf = np.histogram(w, gbins)[0] / (200.**3.)
obvs.append(gmf)
elif obv == 'xi':
greek_xi = tpcf(
pos,
rbins,
pos,
randoms=temp_randoms,
period=period,
max_sample_size=int(2e5),
estimator='Natural',
approx_cell1_size=approx_cell1_size,
approx_cellran_size=approx_cellran_size,
RR_precomputed=self.RR,
NR_precomputed=self.NR)
obvs.append(greek_xi)
else:
raise NotImplementedError(
'Only nbar, tpcf, and gmf are implemented so far'
)
return obvs
except ValueError:
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(10.)
elif obv == 'gmf':
bins = data_gmf_bins()
obvs.append(np.ones_like(bins)[:-1] * 1000.)
elif obv == 'xi':
obvs.append(np.zeros(len(xi_binedges()[:-1])))
return obvs
else:
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(10.)
elif obv == 'gmf':
bins = data_gmf_bins()
obvs.append(np.ones_like(bins)[:-1] * 1000.)
elif obv == 'xi':
obvs.append(np.zeros(len(xi_binedges()[:-1])))
return obvs
num_randoms = 50 * 8000
xran = np.random.uniform(0, 250, num_randoms)
yran = np.random.uniform(0, 250, num_randoms)
zran = np.random.uniform(0, 250, num_randoms)
sub_randoms = np.vstack((xran, yran, zran)).T
sub_model = PrebuiltHodModelFactory('zheng07')
sub_model.new_haloprop_func_dict = {'sim_subvol': mk_id_column}
sub_halocat = CachedHaloCatalog(simname='multidark', redshift=0,
halo_finder='rockstar')
print "starting with 250 mpc subvols:"
sub_xi_list = []
for ii in range(1,Nsub+1):
print ii
simsubvol = lambda x: mask_func(x, ii)
sub_model.populate_mock(sub_halocat,
masking_function=simsubvol, enforce_PBC=False)
sub_pos = three_dim_pos_bundle(sub_model.mock.galaxy_table,
'x', 'y', 'z')
xi, yi, zi = random_shifter(ii)
temp_randoms = sub_randoms.copy()
temp_randoms[:,0] += xi
temp_randoms[:,1] += yi
temp_randoms[:,2] += zi
sub_xi = tpcf(sub_pos, xi_bin,
randoms=temp_randoms,
do_auto=True,
def _sum_stat(self, theta, prior_range=None, observables=['nbar', 'gmf']):
'''
Given theta, sum_stat calculates the observables from our forward model
Parameters
----------
theta : (self explanatory)
prior_range : If specified, checks to make sure that theta is within the prior range.
'''
self.model.param_dict['logM0'] = theta[0]
self.model.param_dict['sigma_logM'] = np.exp(theta[1])
self.model.param_dict['logMmin'] = theta[2]
self.model.param_dict['alpha'] = theta[3]
self.model.param_dict['logM1'] = theta[4]
rbins = xi_binedges()
rmax = rbins.max()
period = None
approx_cell1_size = [rmax , rmax , rmax]
approx_cellran_size = [rmax , rmax , rmax]
if prior_range is None:
rint = np.random.randint(1, 125)
####simsubvol = lambda x: util.mask_func(x, rint)
####self.model.populate_mock(self.halocat,
#### masking_function=simsubvol,
#### enforce_PBC=False)
self.model.populate_mock(self.halocat)
pos =three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
pos = util.mask_galaxy_table(pos , rint)
xi , yi , zi = util.random_shifter(rint)
temp_randoms = self.randoms.copy()
temp_randoms[:,0] += xi
temp_randoms[:,1] += yi
temp_randoms[:,2] += zi
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(len(pos) / 200**3.) # nbar of the galaxy catalog
elif obv == 'gmf':
#compute group richness
nbar = len(pos) / 200**3.
b = self.b_normal * (nbar)**(-1./3)
groups = pyfof.friends_of_friends(pos , b)
w = np.array([len(x) for x in groups])
gbins = data_gmf_bins()
gmf = np.histogram(w , gbins)[0] / (200.**3.)
obvs.append(gmf)
elif obv == 'xi':
greek_xi = tpcf(
pos, rbins, pos,
randoms=temp_randoms, period = period,
max_sample_size=int(1e5), estimator='Natural',
approx_cell1_size=approx_cell1_size,
approx_cellran_size=approx_cellran_size,
RR_precomputed = self.RR,
NR_precomputed = self.NR)
obvs.append(greek_xi)
else:
raise NotImplementedError('Only nbar 2pcf, gmf implemented so far')
return obvs
else:
if np.all((prior_range[:,0] < theta) & (theta < prior_range[:,1])):
# if all theta_i is within prior range ...
try:
rint = np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
self.model.populate_mock(self.halocat,
masking_function=simsubvol,
enforce_PBC=False)
pos =three_dim_pos_bundle(self.model.mock.galaxy_table, 'x', 'y', 'z')
#imposing mask on the galaxy table
pos = util.mask_galaxy_table(pos , rint)
xi , yi , zi = util.random_shifter(rint)
temp_randoms = self.randoms.copy()
temp_randoms[:,0] += xi
temp_randoms[:,1] += yi
temp_randoms[:,2] += zi
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(len(pos) / 200**3.) # nbar of the galaxy catalog
elif obv == 'gmf':
nbar = len(pos) / 200**3.
b = self.b_normal * (nbar)**(-1./3)
groups = pyfof.friends_of_friends(pos , b)
w = np.array([len(x) for x in groups])
gbins =data_gmf_bins()
gmf = np.histogram(w , gbins)[0] / (200.**3.)
obvs.append(gmf)
elif obv == 'xi':
greek_xi = tpcf(
pos, rbins, pos,
randoms=temp_randoms, period = period,
max_sample_size=int(1e5), estimator='Natural',
approx_cell1_size=approx_cell1_size,
approx_cellran_size=approx_cellran_size,
RR_precomputed = self.RR,
NR_precomputed = self.NR)
obvs.append(greek_xi)
else:
raise NotImplementedError('Only nbar, tpcf, and gmf are implemented so far')
return obvs
except ValueError:
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(10.)
elif obv == 'gmf':
bins = data_gmf_bins()
obvs.append(np.ones_like(bins)[:-1]*1000.)
elif obv == 'xi':
obvs.append(np.zeros(len(xi_binedges()[:-1])))
return obvs
else:
obvs = []
for obv in observables:
if obv == 'nbar':
obvs.append(10.)
elif obv == 'gmf':
bins = data_gmf_bins()
obvs.append(np.ones_like(bins)[:-1]*1000.)
elif obv == 'xi':
obvs.append(np.zeros(len(xi_binedges()[:-1])))
return obvs
def test_GMFbinning(Mr):
''' Tests for the GMF binning scheme in order to make it sensible.
'''
gids_saved = 'gids_saved.p'
if not os.path.isfile(gids_saved):
thr = -1. * np.float(Mr)
model = PrebuiltHodModelFactory('zheng07',
threshold=thr,
halocat='multidark',
redshift=0.)
model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
datsubvol = lambda x: util.mask_func(x, 0)
model.populate_mock(simname='multidark',
masking_function=datsubvol,
enforce_PBC=False)
galaxy_sample = model.mock.galaxy_table
x = galaxy_sample['x']
y = galaxy_sample['y']
z = galaxy_sample['z']
vz = galaxy_sample['vz']
pos = three_dim_pos_bundle(model.mock.galaxy_table,
'x',
'y',
'z',
velocity=vz,
velocity_distortion_dimension="z")
b_para, b_perp = 0.2, 0.2
groups = FoFGroups(pos,
b_perp,
b_para,
period=None,
Lbox=200,
num_threads='max')
pickle.dump(groups, open(gids_saved, 'wb'))
else:
groups = pickle.load(open(gids_saved, 'rb'))
gids = groups.group_ids
rich = richness(gids)
#print "rich=" , rich
rbins = np.logspace(np.log10(3.), np.log10(20), 10)
rbins = np.array([1, 2., 3., 4., 5., 6., 7, 9, 11, 14, 17, 20])
gmf = GMF(rich, counts=False, bins=rbins)
gmf_counts = GMF(rich, counts=True, bins=rbins)
print rbins
print gmf
print gmf_counts
fig = plt.figure(1)
sub = fig.add_subplot(111)
sub.plot(0.5 * (rbins[:-1] + rbins[1:]), gmf)
sub.set_xscale('log')
sub.set_yscale('log')
plt.show()
#print gmf
#print GMF(rich , counts = True)
return None
def Subvolume_FullvolumeCut(N_sub, ratio=False):
''' Test the 2PCF estimates from MultiDark subvolume versus the
2PCF for the entire MultiDark volume WITHOUT periodic boundary conditions
and actual pair counts, CUT into subvolumes of the same size *AFTER*
populate mock
Parameters
----------
N_sub : (int)
Number of subvolumes to sample
'''
prettyplot()
pretty_colors = prettycolors()
pickle_file = ''.join([
'/export/bbq2/hahn/ccppabc/dump/', 'xi_subvolume_fullvolume_cut_test',
'.Nsub',
str(N_sub), '.p'
])
fig = plt.figure(1)
sub = fig.add_subplot(111)
xi_bin = xi_binedges()
# Entire MultiDark Volume (No Periodic Boundary Conditions)
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname='multidark',
redshift=0,
halo_finder='rockstar')
sub_RR = data_RR(box='md_sub')
sub_randoms = data_random(box='md_sub')
sub_NR = len(sub_randoms)
rmax = xi_bin.max()
full_approx_cell1_size = [rmax, rmax, rmax]
full_approx_cellran_size = [rmax, rmax, rmax]
model.populate_mock(halocat, enforce_PBC=False)
subvol_id = util.mk_id_column(table=model.mock.galaxy_table)
full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
# Full Volume
if os.path.isfile(pickle_file):
data_dump = pickle.load(open(pickle_file, 'rb'))
full_xi = data_dump['full_xi']
else:
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname='multidark',
redshift=0,
halo_finder='rockstar')
full_randoms = data_random(box='md_all')
full_RR = data_RR(box='md_all')
full_NR = len(full_randoms)
rmax = xi_bin.max()
full_approx_cell1_size = [rmax, rmax, rmax]
full_approx_cellran_size = [rmax, rmax, rmax]
model.populate_mock(halocat, enforce_PBC=False)
full_pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
full_xi = tpcf(full_pos,
xi_bin,
randoms=full_randoms,
period=None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(full_pos.shape[0]),
estimator='Natural',
approx_cell1_size=full_approx_cell1_size,
approx_cellran_size=full_approx_cellran_size,
RR_precomputed=full_RR,
NR_precomputed=full_NR)
data_dump = {}
data_dump['full_xi'] = full_xi
if not ratio:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
full_xi,
lw=2,
ls='-',
c='k',
label=r'Full Volume')
if os.path.isfile(pickle_file):
fullcut_xi_list = data_dump['fullcut_xi']['fullcut_xi_list']
fullcut_xi_avg = data_dump['fullcut_xi']['fullcut_xi_avg']
else:
data_dump['fullcut_xi'] = {}
fullcut_xi_list = []
fullcut_xi_tot = np.zeros(len(xi_bin) - 1)
for id in np.unique(subvol_id)[:N_sub]:
print 'Subvolume ', id
in_cut = np.where(subvol_id == id)
fullcut_pos = full_pos[in_cut]
fullcut_xi = tpcf(fullcut_pos,
xi_bin,
randoms=sub_randoms,
period=None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(fullcut_pos.shape[0]),
estimator='Natural',
approx_cell1_size=full_approx_cell1_size,
approx_cellran_size=full_approx_cellran_size,
RR_precomputed=sub_RR,
NR_precomputed=sub_NR)
fullcut_xi_list.append(fullcut_xi)
fullcut_xi_tot += fullcut_xi
fullcut_xi_avg = fullcut_xi_tot / np.float(N_sub)
data_dump['fullcut_xi']['fullcut_xi_list'] = fullcut_xi_list
data_dump['fullcut_xi']['fullcut_xi_avg'] = fullcut_xi_avg
if not ratio:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
fullcut_xi_avg,
lw=2,
ls='-',
c='k',
label=r'Full Volume Cut Average')
else:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
fullcut_xi_avg / full_xi,
lw=2,
ls='-',
c='k',
label=r'Full Volume Cut Average')
if not os.path.isfile(pickle_file):
# MultiDark SubVolume (precomputed RR pairs)
sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
sub_halocat = CachedHaloCatalog(simname='multidark',
redshift=0,
halo_finder='rockstar')
sub_RR = data_RR(box='md_sub')
sub_randoms = data_random(box='md_sub')
sub_NR = len(sub_randoms)
sub_xis_list = []
sub_xis = np.zeros(len(full_xi))
for ii in range(1, N_sub):
print 'Subvolume ', ii
# randomly sample one of the subvolumes
rint = ii #np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
sub_model.populate_mock(sub_halocat,
masking_function=simsubvol,
enforce_PBC=False)
pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x', 'y',
'z')
xi, yi, zi = util.random_shifter(rint)
temp_randoms = sub_randoms.copy()
temp_randoms[:, 0] += xi
temp_randoms[:, 1] += yi
temp_randoms[:, 2] += zi
rmax = xi_bin.max()
sub_approx_cell1_size = [rmax, rmax, rmax]
sub_approx_cellran_size = [rmax, rmax, rmax]
sub_xi = tpcf(pos,
xi_bin,
randoms=temp_randoms,
period=None,
do_auto=True,
do_cross=False,
num_threads=5,
max_sample_size=int(pos.shape[0]),
estimator='Natural',
approx_cell1_size=sub_approx_cell1_size,
approx_cellran_size=sub_approx_cellran_size,
RR_precomputed=sub_RR,
NR_precomputed=sub_NR)
label = None
if ii == N_sub - 1:
label = 'Subvolumes'
sub_xis += sub_xi
sub_xis_list.append(sub_xi)
sub_xi_avg = sub_xis / np.float(N_sub)
data_dump['Natural'] = {}
data_dump['Natural']['sub_xi_avg'] = sub_xi_avg
data_dump['Natural']['sub_xis_list'] = sub_xis_list
else:
sub_xis_list = data_dump['Natural']['sub_xis_list']
sub_xi_avg = data_dump['Natural']['sub_xi_avg']
if not os.path.isfile(pickle_file):
pickle.dump(data_dump, open(pickle_file, 'wb'))
if not ratio:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
sub_xi_avg,
lw=2,
ls='--',
c=pretty_colors[3],
label='Subvolume')
else:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
sub_xi_avg / full_xi,
lw=2,
ls='--',
c=pretty_colors[3],
label='Subvolume')
sub.set_xlim([0.1, 50.])
sub.set_xlabel('r', fontsize=30)
sub.set_xscale('log')
if not ratio:
sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
sub.set_yscale('log')
else:
sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$",
fontsize=25)
sub.legend(loc='lower left')
if ratio:
fig_file = ''.join([
util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub',
str(N_sub), '.ratio.png'
])
else:
fig_file = ''.join([
util.fig_dir(), 'test_xi_subvolume_fullvolume_cut.Nsub',
str(N_sub), '.png'
])
fig.savefig(fig_file, bbox_inches='tight', dpi=100)
plt.close()
return None
def Subvolume_Analytic(N_sub, ratio=False):
''' Test the 2PCF estimates from MultiDark subvolume versus the
analytic 2PCF for the entire MultiDark volume
Parameters
----------
N_sub : (int)
Number of subvolumes to sample
'''
prettyplot()
pretty_colors = prettycolors()
pickle_file = ''.join([
'/export/bbq2/hahn/ccppabc/dump/', 'xi_subvolume_test', '.Nsub',
str(N_sub), '.p'
])
fig = plt.figure(1)
sub = fig.add_subplot(111)
xi_bin = xi_binedges()
if os.path.isfile(pickle_file):
data_dump = pickle.load(open(pickle_file, 'rb'))
full_xi = data_dump['full_xi']
else:
# Entire MultiDark Volume (Analytic xi)
model = PrebuiltHodModelFactory('zheng07', threshold=-21)
halocat = CachedHaloCatalog(simname='multidark',
redshift=0,
halo_finder='rockstar')
model.populate_mock(halocat)
pos = three_dim_pos_bundle(model.mock.galaxy_table, 'x', 'y', 'z')
# while the estimator claims to be Landy-Szalay, I highly suspect it
# actually uses Landy-Szalay since DR pairs cannot be calculated from
# analytic randoms
full_xi = tpcf(pos,
xi_bin,
period=model.mock.Lbox,
max_sample_size=int(2e5),
estimator='Landy-Szalay',
num_threads=1)
data_dump = {}
data_dump['full_xi'] = full_xi
if not ratio:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
full_xi,
lw=2,
ls='-',
c='k',
label=r'Analytic $\xi$ Entire Volume')
if not os.path.isfile(pickle_file):
# MultiDark SubVolume (precomputed RR pairs)
sub_model = PrebuiltHodModelFactory('zheng07', threshold=-21)
sub_model.new_haloprop_func_dict = {'sim_subvol': util.mk_id_column}
sub_halocat = CachedHaloCatalog(simname='multidark',
redshift=0,
halo_finder='rockstar')
RR = data_RR()
randoms = data_random()
NR = len(randoms)
for method in ['Landy-Szalay', 'Natural']:
if method == 'Landy-Szalay':
iii = 3
elif method == 'Natural':
iii = 5
if not os.path.isfile(pickle_file):
sub_xis_list = []
sub_xis = np.zeros(len(full_xi))
for ii in range(1, N_sub + 1):
# randomly sample one of the subvolumes
rint = ii #np.random.randint(1, 125)
simsubvol = lambda x: util.mask_func(x, rint)
sub_model.populate_mock(sub_halocat,
masking_function=simsubvol,
enforce_PBC=False)
pos = three_dim_pos_bundle(sub_model.mock.galaxy_table, 'x',
'y', 'z')
xi, yi, zi = util.random_shifter(rint)
temp_randoms = randoms.copy()
temp_randoms[:, 0] += xi
temp_randoms[:, 1] += yi
temp_randoms[:, 2] += zi
rmax = xi_bin.max()
approx_cell1_size = [rmax, rmax, rmax]
approx_cellran_size = [rmax, rmax, rmax]
sub_xi = tpcf(pos,
xi_bin,
pos,
randoms=temp_randoms,
period=None,
max_sample_size=int(1e5),
estimator=method,
approx_cell1_size=approx_cell1_size,
approx_cellran_size=approx_cellran_size,
RR_precomputed=RR,
NR_precomputed=NR)
label = None
if ii == N_sub - 1:
label = 'Subvolumes'
#if not ratio:
# sub.plot(0.5*(xi_bin[:-1]+xi_bin[1:]), sub_xi, lw=0.5, ls='--', c=pretty_colors[iii])
sub_xis += sub_xi
sub_xis_list.append(sub_xi)
sub_xi_avg = sub_xis / np.float(N_sub)
data_dump[method] = {}
data_dump[method]['sub_xi_avg'] = sub_xi_avg
data_dump[method]['sub_xis_list'] = sub_xis_list
else:
sub_xis_list = data_dump[method]['sub_xis_list']
sub_xi_avg = data_dump[method]['sub_xi_avg']
if not ratio:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
sub_xi_avg,
lw=2,
ls='--',
c=pretty_colors[iii],
label='Subvolume ' + method)
else:
sub.plot(0.5 * (xi_bin[:-1] + xi_bin[1:]),
sub_xi_avg / full_xi,
lw=2,
ls='--',
c=pretty_colors[iii],
label='Subvolume ' + method)
if not os.path.isfile(pickle_file):
pickle.dump(data_dump, open(pickle_file, 'wb'))
sub.set_xlim([0.1, 50.])
sub.set_xlabel('r', fontsize=30)
sub.set_xscale('log')
if not ratio:
sub.set_ylabel(r"$\xi \mathtt{(r)}$", fontsize=25)
sub.set_yscale('log')
else:
sub.set_ylabel(r"$\overline{\xi^\mathtt{sub}}/\xi^\mathtt{all}$",
fontsize=25)
sub.legend(loc='lower left')
if ratio:
fig_file = ''.join([
util.fig_dir(), 'test_xi_subvolume_analytic.Nsub',
str(N_sub), '.ratio.png'
])
else:
fig_file = ''.join([
util.fig_dir(), 'test_xi_subvolume_analytic.Nsub',
str(N_sub), '.png'
])
fig.savefig(fig_file, bbox_inches='tight', dpi=100)
plt.close()
return None
