def compute_xi2(x,
y,
z,
L,
s_min,
s_max,
n_sbins,
fn_save,
nmubins=15,
nthreads=1):
print("Computing xi_2")
# Set up bins (log)
sbins = np.logspace(np.log10(smin), np.log10(smax),
nsbins + 1) # note the + 1 to nbins
s_avg = 10**(0.5 * (np.log10(sbins)[1:] + np.log10(sbins)[:-1]))
# Use halotools to compute the quadrupole, as in this example:
# https://halotools.readthedocs.io/en/latest/api/halotools.mock_observables.tpcf_multipole.html
sample = np.vstack((x, y, z)).T
mu_bins = np.linspace(0, 1, nmubins)
xi_s_mu = s_mu_tpcf(sample, sbins, mu_bins, period=L)
xi_2 = tpcf_multipole(xi_s_mu, mu_bins, order=1) # Order 1 is quadrupole
print("Saving")
os.makedirs(os.path.dirname(savename), exist_ok=True)
results = np.array([s_avg, xi_2])
np.savetxt(savename, results.T, delimiter=',', fmt=['%f', '%e'])
def reference_sim_tpcf(pos1, redges, Nmu, BoxSize, randoms=None, pos2=None):
"""Refernce 2D 2PCF using halotools"""
from halotools.mock_observables import s_mu_tpcf
mu_bins = numpy.linspace(0, 1, Nmu+1)
estimator = 'Natural' if randoms is None else 'Landy-Szalay'
do_auto = True if pos2 is None else False
return s_mu_tpcf(pos1, redges, mu_bins, period=BoxSize, sample2=pos2,
randoms=randoms, estimator=estimator, do_auto=do_auto)
def reference_sim_tpcf(pos1, redges, Nmu, BoxSize, randoms=None, pos2=None):
"""Refernce 2D 2PCF using halotools"""
from halotools.mock_observables import s_mu_tpcf
mu_bins = numpy.linspace(0, 1, Nmu+1)
estimator = 'Natural' if randoms is None else 'Landy-Szalay'
do_auto = True if pos2 is None else False
return s_mu_tpcf(pos1, redges, mu_bins, period=BoxSize, sample2=pos2,
randoms=randoms, estimator=estimator, do_auto=do_auto)
def tpcf_s(
pos: np.ndarray,
vel: np.ndarray,
chi_range: np.array,
mu_range: np.array,
los: int = 2,
boxsize: float = 500.,
nthreads: int = 1,
) -> np.ndarray:
"""
TPCF in redshift space
Args:
Note: halotools tpcf_s_mu assumes the line of sight is always the z direction
"""
# convert real- into redshift-space coord.
pos_s = pos.copy()
pos_s[:, los] += vel[:, los] / 100. #[Mpc/h]
# enforce periodic boundary condition
pos_s[:, los] = np.where(
pos_s[:, los] > boxsize,
pos_s[:, los] - boxsize,
pos_s[:, los],
)
pos_s[:, los] = np.where(
pos_s[:, los] < 0.,
pos_s[:, los] + boxsize,
pos_s[:, los],
)
if (los != 2):
# rotate coords. to ensure los=2 as it is required by halotools
pos_s_old = pos_s.copy()
pos_s[:, 2] = pos_s_old[:, los]
pos_s[:, los] = pos_s_old[:, 2]
# compute TPCF in redshift space
tpcf = s_mu_tpcf(
sample1=pos_s,
s_bins=chi_range,
mu_bins=mu_range,
period=boxsize,
estimator="Landy-Szalay",
num_threads=nthreads,
)
return tpcf
def xi_rsd(x, y, z, L, smin, smax, nsbins, savename, nthreads=1, order=1):
print("Computing xi_2")
#LOG
sbins = np.logspace(np.log10(smin), np.log10(smax),
nsbins + 1) # note the + 1 to nbins
s_avg = 10**(0.5 * (np.log10(sbins)[1:] + np.log10(sbins)[:-1]))
#LINEAR
#sbins = np.linspace(smin, smax, sbins + 1) # note the + 1 to nbins
#s_avg = 0.5*(sbins[1:] + sbins[:-1])
sample = np.vstack((x, y, z)).T
nmubins = 15
mu_bins = np.linspace(0, 1, nmubins)
xi_s_mu = s_mu_tpcf(sample, sbins, mu_bins, period=L)
xi_2 = tpcf_multipole(xi_s_mu, mu_bins, order=order)
print("Saving")
os.makedirs(os.path.dirname(savename), exist_ok=True)
print(xi_2)
results = np.array([s_avg, xi_2])
np.savetxt(savename, results.T, delimiter=',', fmt=['%f', '%e'])
def compute_tpcf_s_mu(s,
mu,
pos,
vel,
los_direction,
cosmology,
boxsize,
num_threads=1):
'''
Computes the redshift space two point correlation function
Args:
s: np.array
binning in redshift space pair distances.
mu: np.array
binning in the cosine of the angle respect to the line of sight.
pos: np.ndarray
3-D array with the position of the tracers, in Mpc/h.
vel: np.ndarray
3-D array with the velocities of the tracers, in km/s.
los_direction: int
line of sight direction either 0(=x), 1(=y), 2(=z)
cosmology: dict
dictionary containing the simulatoin's cosmological parameters.
boxsize: float
size of the simulation's box.
num_threads: int
number of threads to use.
Returns:
tpcf_s_mu: np.ndarray
2-D array with the redshift space tpcf.
'''
s_pos = pos.copy()
# Move tracers to redshift space
s_pos[:, los_direction] += vel[:, los_direction] / 100. # to Mpc/h
# Apply periodic boundary conditions
s_pos[:, los_direction] = np.where(s_pos[:, los_direction] > boxsize,
s_pos[:, los_direction] - boxsize,
s_pos[:, los_direction])
s_pos[:, los_direction] = np.where(s_pos[:, los_direction] < 0.,
s_pos[:, los_direction] + boxsize,
s_pos[:, los_direction])
assert np.prod((s_pos > 0) & (s_pos < boxsize))
# Halotools tpcf_s_mu assumes the line of sight is always the z direction
if (los_direction != 2):
s_pos_old = s_pos.copy()
s_pos[:, 2] = s_pos_old[:, los_direction]
s_pos[:, los_direction] = s_pos_old[:, 2]
tpcf_s_mu = s_mu_tpcf(s_pos,
s,
mu,
period=boxsize,
estimator=u'Landy-Szalay',
num_threads=num_threads)
return tpcf_s_mu
import numpy as np
from halotools.mock_observables import tpcf, s_mu_tpcf, tpcf_multipole
import matplotlib.pyplot as plt
h = 0.6726
b = 2.23
pos = np.fromfile('sample_input_gal_mx3_float32_0-1100_mpc.dat',
dtype=np.float32).reshape(-1, 4)[:, 1:4]*h
s_bins, mu_bins = np.arange(5, 155, 5), np.arange(0, 1.05, 0.05)
r = (s_bins[:-1] + s_bins[1:])/2
xi = tpcf(pos, s_bins, period=1100)
xi_s_mu = s_mu_tpcf(pos, s_bins, mu_bins, period=1100)
xi_0 = tpcf_multipole(xi_s_mu, mu_bins, order=0)
xi_2 = tpcf_multipole(xi_s_mu, mu_bins, order=2)
fig, ax = plt.subplots()
ax.plot(r, xi*np.square(r), 'o:', label='xi')
ax.plot(r, xi_0*np.square(r), '+:', label='xi_0')
ax.plot(r, xi_2*np.square(r), 'x-.', label='xi_2')
fig.legend()
fig.savefig('correlation.pdf')