xcf.nside = args.nside
xcf.rej = args.rej
xcf.zref = args.z_ref
xcf.z_evol_del = args.z_evol_del
xcf.z_evol_obj = args.z_evol_obj
xcf.lambda_abs = constants.absorber_IGM[args.lambda_abs]
xcf.max_diagram = args.max_diagram
### Cosmo
if (args.fid_Or != 0.) or (args.fid_Ok != 0.) or (args.fid_wl != -1.):
print(
"ERROR: Cosmology with other than Omega_m set are not yet implemented"
)
sys.exit()
cosmo = constants.cosmo(Om=args.fid_Om,
Or=args.fid_Or,
Ok=args.fid_Ok,
wl=args.fid_wl)
### Read deltas
dels, ndels, zmin_pix, zmax_pix = io.read_deltas(args.in_dir,
args.nside,
xcf.lambda_abs,
args.z_evol_del,
args.z_ref,
cosmo=cosmo,
nspec=args.nspec)
for p, delsp in dels.items():
for d in delsp:
d.fname = 'D1'
for k in [
'co', 'de', 'order', 'iv', 'diff', 'm_SNR', 'm_reso',
class kappa:
nside = 256
nside_data = 32
rot = healpy.Rotator(coord=['C', 'G'])
lambda_abs = 1215.67
fid_Om = 0.31
cosmo = constants.cosmo(fid_Om)
rt_min = 0.
rt_max = 40.
rp_min = 0.
rp_max = 10.
nt = 1
np = 1
xi2d = None
angmax = None
z_min_pix = None
true_corr = False
counter = Value('i', 0)
lock = Lock()
data = {}
ndata = 0
@staticmethod
def load_model(modelfile, nbins=50):
data_rp, data_rt, xi_dist = np.loadtxt(modelfile, unpack=1)
#-- get the larger value of the first separation bin to make a grid
rp_min = data_rp.reshape(50, 50)[0].max()
rp_max = data_rp.reshape(50, 50)[-1].min()
rt_min = data_rt.reshape(50, 50)[:, 0].max()
rt_max = data_rt.reshape(50, 50)[:, -1].min()
#-- create the regular grid for griddata
rp = np.linspace(rp_min, rp_max, nbins)
rt = np.linspace(rt_min, rt_max, nbins)
xim = sp.interpolate.griddata((data_rt, data_rp), xi_dist, \
(rt[:, None], rp[None, :]), method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, xim)
return xi2d
@staticmethod
def read_deltas(in_dir, nspec=None):
data = {}
ndata = 0
dels = []
fi = glob.glob(in_dir + "/*.fits.gz")
for i, f in enumerate(fi):
sys.stderr.write("\rread {} of {} {}".format(i, len(fi), ndata))
hdus = fitsio.FITS(f)
dels += [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(hdus[1:])
hdus.close()
if nspec and ndata > nspec:
break
phi = [d.ra for d in dels]
th = [sp.pi / 2. - d.dec for d in dels]
pix = healpy.ang2pix(kappa.nside_data, th, phi)
z_min_pix = 10**dels[0].ll[0] / kappa.lambda_abs - 1
for d, p in zip(dels, pix):
if p not in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / kappa.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.z = z
d.r_comov = kappa.cosmo.r_comoving(z)
d.we *= ((1. + z) / (1. + 2.25))**(2.9 - 1.)
d.project()
kappa.z_min_pix = z_min_pix
kappa.angmax = 2.*\
sp.arcsin(kappa.rt_max/(2.*kappa.cosmo.r_comoving(z_min_pix)))
kappa.ndata = ndata
kappa.data = data
return data
@staticmethod
def fill_neighs():
data = kappa.data
print('\n Filling neighbors')
for ipix in data.keys():
for d1 in data[ipix]:
npix = healpy.query_disc(kappa.nside_data, \
[d1.xcart, d1.ycart, d1.zcart], \
kappa.angmax, inclusive = True)
npix = [p for p in npix if p in data]
neighs = [d for p in npix for d in data[p]]
ang = d1 ^ neighs
w = ang < kappa.angmax
neighs = sp.array(neighs)[w]
d1.neighs = [d for d in neighs if d1.ra > d.ra]
@staticmethod
def get_kappa(pixels):
ikappa = []
skappa = {}
wkappa = {}
gamma1 = {}
gamma2 = {}
nkappa = {}
for ipix in pixels:
for i, d1 in enumerate(kappa.data[ipix]):
sys.stderr.write("\rcomputing kappa: {}%".format(\
round(kappa.counter.value*100./kappa.ndata,2)))
with kappa.lock:
kappa.counter.value += 1
for d2 in d1.neighs:
#-- compute the cartesian mid points and convert back
#-- to ra, dec
mid_xcart = 0.5 * (d1.xcart + d2.xcart)
mid_ycart = 0.5 * (d1.ycart + d2.ycart)
mid_zcart = 0.5 * (d1.zcart + d2.zcart)
mid_ra, mid_dec = get_radec(\
np.array([mid_xcart, mid_ycart, mid_zcart]))
#-- apply rotation into Galactic coordinates
#th, phi = kappa.rot(sp.pi/2-mid_dec, mid_ra)
#-- keeping without rotation and adding pi to RA for visual
th, phi = sp.pi / 2 - mid_dec, mid_ra
th1, phi1 = sp.pi / 2 - d1.dec, d1.ra
th2, phi2 = sp.pi / 2 - d2.dec, d2.ra
#-- check if pair of skewers belong to same spectro
same_half_plate = (d1.plate == d2.plate) and\
( (d1.fid<=500 and d2.fid<=500) or \
(d1.fid>500 and d2.fid>500) )
#-- angle between skewers
ang = d1 ^ d2
if kappa.true_corr:
ang_delensed = d1.delensed_angle(d2)
#-- getting pixel in between
mid_pix = healpy.ang2pix(kappa.nside, \
th, phi)
if kappa.true_corr:
sk, wk, g1, g2, nk = kappa.fast_kappa_true(\
d1.z, d1.r_comov, \
d2.z, d2.r_comov, \
ang_delensed, ang, \
th1, phi1, th2, phi2)
else:
sk, wk, g1, g2, nk = kappa.fast_kappa(\
d1.z, d1.r_comov, d1.we, d1.de, \
d2.z, d2.r_comov, d2.we, d2.de, \
ang, same_half_plate, \
th1, phi1, th2, phi2)
if mid_pix in ikappa:
skappa[mid_pix] += sk
wkappa[mid_pix] += wk
gamma1[mid_pix] += g1
gamma2[mid_pix] += g2
nkappa[mid_pix] += nk
else:
ikappa.append(mid_pix)
skappa[mid_pix] = sk
wkappa[mid_pix] = wk
gamma1[mid_pix] = g1
gamma2[mid_pix] = g2
nkappa[mid_pix] = nk
setattr(d1, "neighs", None)
return ikappa, skappa, wkappa, gamma1, gamma2, nkappa
@staticmethod
def fast_kappa(z1, r1, w1, d1, z2, r2, w2, d2, ang, same_half_plate, th1,
phi1, th2, phi2):
rp = abs(r1 - r2[:, None]) * sp.cos(ang / 2)
rt = (r1 + r2[:, None]) * sp.sin(ang / 2)
d12 = d1 * d2[:, None]
w12 = w1 * w2[:, None]
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
w12 = w12[w]
d12 = d12[w]
x = (phi2 - phi1) * sp.sin(th1)
y = th2 - th1
gamma_ang = sp.arctan2(y, x)
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
#-- this is the weight of the estimator
R = 1 / (xip_model * rt)
ska = sp.sum((d12 - xi_model) / R * w12)
gam1 = 4 * sp.cos(2 * gamma_ang) * sp.sum(
(d12 - xi_model) / R * w12) # SY
gam2 = 4 * sp.sin(2 * gamma_ang) * sp.sum(
(d12 - xi_model) / R * w12) # SY
wka = sp.sum(w12 / R**2)
nka = 1. * d12.size
return ska, wka, gam1, gam2, nka
@staticmethod
def fast_kappa_true(z1, r1, z2, r2, ang, ang_lens, th1, phi1, th2, phi2):
rp = abs(r1 - r2[:, None]) * sp.cos(ang / 2)
rt = (r1 + r2[:, None]) * sp.sin(ang / 2)
rp_lens = abs(r1 - r2[:, None]) * sp.cos(ang_lens / 2)
rt_lens = (r1 + r2[:, None]) * sp.sin(ang_lens / 2)
#z = (z1+z2[:,None])/2
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
rp_lens = rp_lens[w]
rt_lens = rt_lens[w]
#z = z[w]
x = (phi2 - phi1) * sp.sin(th1) # SY
y = th2 - th1 # SY
gamma_ang = sp.arctan2(y, x) # SY
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xi_lens = kappa.xi2d(rt_lens, rp_lens, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
R = 1 / (xip_model * rt)
#ska = sp.sum( (xi_lens - xi_model)*R )
#wka = xi_lens.size
ska = sp.sum((xi_lens - xi_model) / R)
wka = sp.sum(1 / R**2)
gam1 = 4 * sp.cos(2 * gamma_ang) * sp.sum(
(xi_lens - xi_model) / R) # SY
gam2 = 4 * sp.sin(2 * gamma_ang) * sp.sum(
(xi_lens - xi_model) / R) # SY
nka = 1. * xi_lens.size
return ska, wka, gam1, gam2, nka
print("nproc",args.nproc)
xcf.rp_max = args.rp_max
xcf.rp_min = args.rp_min
xcf.rt_max = args.rt_max
xcf.z_cut_max = args.z_cut_max
xcf.z_cut_min = args.z_cut_min
xcf.np = args.np
xcf.nt = args.nt
xcf.nside = args.nside
xcf.zref = args.z_ref
xcf.alpha = args.z_evol_del
xcf.lambda_abs = constants.absorber_IGM[args.lambda_abs]
xcf.rej = args.rej
cosmo = constants.cosmo(args.fid_Om)
### Read deltas
dels, ndels, zmin_pix, zmax_pix = io_lens.read_deltas(args.in_dir, args.nside, xcf.lambda_abs,
args.z_evol_del, args.z_ref, cosmo=cosmo,nspec=args.nspec)
xcf.npix = len(dels)
xcf.dels = dels
xcf.ndels = ndels
sys.stderr.write("\n")
print("done, npix = {}\n".format(xcf.npix))
### Find the redshift range
if (args.z_min_obj is None):
dmin_pix = cosmo.r_comoving(zmin_pix)
dmin_obj = max(0.,dmin_pix+xcf.rp_min)
args.z_min_obj = cosmo.r_2_z(dmin_obj)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description=
'Computes the convolution term Fvoigt(k) and saves it in an ASCII file. The inputs are a DLA and a QSO catalog (both as fits binary tables). The DLA table must contain the columns "MOCKID" matching qso "THING_ID", and "Z_DLA_RSD". The QSO table must contain the columns "THING_ID", and "Z"'
)
parser.add_argument(
'--dla-catalog',
type=str,
default=None,
required=True,
help=
'DLA catalog fits file , like /project/projectdirs/desi/mocks/lya_forest/develop/saclay/v4.4/v4.4.3/master_DLA.fits'
)
parser.add_argument(
'--drq-catalog',
type=str,
default=None,
required=True,
help=
'DRQ catalog fits file, like /project/projectdirs/desi/mocks/lya_forest/develop/saclay/v4.4/v4.4.3/eboss-0.2/zcat_desi_drq.fits'
)
parser.add_argument(
'--weight-vs-wavelength',
type=str,
default=None,
required=False,
help=
'sum of delta weight as a function of wavelength (two columns ASCII file)'
)
parser.add_argument(
'-o',
'--output',
type=str,
default=None,
required=True,
help='FVoigt as a function of k in h/Mpc (two columns ASCII file)')
parser.add_argument('-d', '--debug', action='store_true', default=True)
parser.add_argument('-p',
'--plot',
action='store_true',
help="show some plots")
args = parser.parse_args()
if args.debug: print("read DLA catalog")
dla = fits.open(args.dla_catalog)[1].data
if args.debug: print("read DRQ catalog")
qso = fits.open(args.drq_catalog)[1].data
if args.debug: print("only keep DLAs in DRQ quasars LOS")
dla = dla[:][np.in1d(dla['MOCKID'], qso['THING_ID'])]
#nb_dla = dla['Z_DLA_RSD'].size
#nb_qso = qso['Z'].size #nombre de ligne de visée
coarse_wavelength = np.arange(3000, 8000, 100)
if args.weight_vs_wavelength is None:
filename = "/global/common/software/desi/users/jguy/igmhub/code_stage_lbl/build_Fvoigt/data/weight_lambda.txt"
print(
"WARNING: Hardcoded weight vs wavelength file {}".format(filename))
args.weight_vs_wavelength = filename
if args.weight_vs_wavelength is not None:
if args.debug: print("read weights vs wave")
tmp = np.loadtxt(args.weight_vs_wavelength)
weight = np.interp(coarse_wavelength, tmp[:, 0], tmp[:, 1])
else:
weight = np.ones(coarse_wavelength.shape)
zdla = np.mean(dla['Z_DLA_RSD'])
NHI = np.linspace(17, 22, (22 - 17) / 0.1 + 1)
# probability of finding a DLA at NHI in a QSO LOS (per A and per unit NHI)
# averaged over wavelength, using the provided wavelength weight
prob = compute_dla_prob(coarse_wavelength,
NHI,
dla=dla,
qso=qso,
weight=weight)
ii = (prob > 0)
prob = prob[ii]
NHI = NHI[ii]
if args.plot:
plt.figure("prob")
plt.plot(NHI, prob, "o-")
plt.xlabel("NHI (log10(cm-2))")
plt.ylabel("prob(DLA) per unit NHI per A")
# now use a finer wavelength grid
wavelength = np.arange(3000, 8000, 1.)
# conversion A -> Mpc/h
fidcosmo = constants.cosmo(Om=0.3)
r_wave = fidcosmo.r_comoving(wavelength / constants.absorber_IGM["LYA"] -
1)
# linear grid of Mpc/h (need to convert to linear grid for the FFT)
r_lin = np.linspace(r_wave[0], r_wave[-1], r_wave.size)
for i in range(NHI.size):
if args.debug:
print("compute dF/dNHI for NHI={} ({}/{})".format(
NHI[i], (i + 1), NHI.size))
profile = profile_voigt_lambda(wavelength, zdla, NHI[i])
profile_r = np.interp(r_lin, r_wave,
profile) # interpolation to linear r grid
# r is in Mpc h^-1 --> k in h*Mpc^-1
ft_profile, k = fft_profile(profile_r, np.abs(r_lin[1] - r_lin[0]))
ft_profile = np.abs(ft_profile)
if i == 0:
df = np.array([ft_profile * prob[i]])
else:
df = np.concatenate((df, np.array([ft_profile * prob[i]])))
if args.debug: print("compute F(k)=int dF/dNHI * dNHI")
Fvoigt = np.zeros(k.size)
for i in range(k.size):
Fvoigt[i] = integrate.trapz(df[:, i], NHI)
Fvoigt = Fvoigt / Fvoigt[k.size // 2]
ii = (k >= 0)
k = k[ii]
Fvoigt = Fvoigt[ii]
if args.debug: print("save in {}".format(args.output))
np.savetxt(args.output, np.array([k, Fvoigt]).T)
if args.plot:
plt.figure("fk")
plt.plot(k, Fvoigt, label="this model")
plt.plot(k, np.exp(-k * 10), "--", label="exp(-k*(10 Mpc/h))")
plt.plot(k, np.exp(-k * 6), ":", label="exp(-k*(6 Mpc/h))")
plt.xscale("log")
plt.xlabel("k (h/Mpc)")
plt.ylabel("F(k)")
plt.legend(loc="upper right")
plt.grid()
plt.show()
class kappa:
nside = 256
nside_data = 32
rot = healpy.Rotator(coord=['C', 'G'])
lambda_abs = 1215.67
fid_Om = 0.31
cosmo = constants.cosmo(fid_Om)
rt_min = 0.
rt_max = 40.
rp_min = 0.
rp_max = 10.
nt = 1
np = 1
xi2d = None
angmax = None
z_min_pix = None
true_corr = False
counter = Value('i', 0)
lock = Lock()
data = {}
ndata = 0
## - SY 4/6/19 Changed to use new picca model and fit files
@staticmethod
def load_model(file_xi, file_fit, nbins=50):
h = fitsio.FITS(file_xi)
ff = h5py.File(file_fit, 'r')
base = file_xi
fit = ff[base + '/fit'][...]
data_rp = h[1]['RP'][:]
data_rt = h[1]['RT'][:]
hh = h[1].read_header()
rpmin = hh['RPMIN']
rpmax = hh['RPMAX']
rtmin = 0
rtmax = hh['RTMAX']
h.close()
ff.close()
rpmin = data_rp.reshape(50, 50)[0].max()
rpmax = data_rp.reshape(50, 50)[-1].min()
rtmin = data_rt.reshape(50, 50)[:, 0].max()
rtmax = data_rt.reshape(50, 50)[:, -1].min()
#-- create the regular grid for griddata
rp = np.linspace(rpmin, rpmax, nbins)
rt = np.linspace(rtmin, rtmax, nbins)
xim = sp.interpolate.griddata((data_rt, data_rp), fit, \
(rt[:, None], rp[None, :]), method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, xim)
kappa.xi2d = xi2d
return xi2d
@staticmethod
def read_deltas(in_dir, nspec=None):
data = {}
ndata = 0
dels = []
fi = glob.glob(in_dir + "/*.fits.gz")
for i, f in enumerate(fi):
sys.stderr.write("\rread {} of {} {}".format(i, len(fi), ndata))
hdus = fitsio.FITS(f)
dels += [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(hdus[1:])
hdus.close()
if nspec and ndata > nspec:
break
phi = [d.ra for d in dels]
th = [sp.pi / 2. - d.dec for d in dels]
pix = healpy.ang2pix(kappa.nside_data, th, phi)
z_min_pix = 10**dels[0].ll[0] / kappa.lambda_abs - 1
for d, p in zip(dels, pix):
if p not in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / kappa.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.z = z
d.r_comov = kappa.cosmo.r_comoving(z)
d.we *= ((1. + z) / (1. + 2.25))**(2.9 - 1.)
d.project()
kappa.z_min_pix = z_min_pix
kappa.angmax = 2.*\
sp.arcsin(kappa.rt_max/(2.*kappa.cosmo.r_comoving(z_min_pix)))
kappa.ndata = ndata
kappa.data = data
return data
@staticmethod
def fill_neighs():
data = kappa.data
print('\n Filling neighbors')
for ipix in data.keys():
for d1 in data[ipix]:
npix = healpy.query_disc(kappa.nside_data, \
[d1.xcart, d1.ycart, d1.zcart], \
kappa.angmax, inclusive = True)
npix = [p for p in npix if p in data]
neighs = [d for p in npix for d in data[p]]
ang = d1 ^ neighs
w = ang < kappa.angmax
neighs = sp.array(neighs)[w]
d1.neighs = [d for d in neighs if d1.ra > d.ra]
@staticmethod
def get_kappa(pixels):
id1 = []
id2 = []
skappa = []
wkappa = []
for ipix in pixels:
j = 0
for i, d1 in enumerate(kappa.data[ipix]):
j += 1
kcounter = round(kappa.counter.value * 100. / kappa.ndata, 2)
if (j % 5 == 0):
sys.stderr.write("\rcomputing kappa: {}%".format(kcounter))
with kappa.lock:
kappa.counter.value += 1
for d2 in d1.neighs:
#-- compute the cartesian mid points and convert back
#-- to ra, dec
#mid_xcart = 0.5*(d1.xcart+d2.xcart)
#mid_ycart = 0.5*(d1.ycart+d2.ycart)
#mid_zcart = 0.5*(d1.zcart+d2.zcart)
#mid_ra, mid_dec = get_radec(\
# np.array([mid_xcart, mid_ycart, mid_zcart]))
#-- apply rotation into Galactic coordinates
#th, phi = kappa.rot(sp.pi/2-mid_dec, mid_ra)
#-- keeping without rotation
#th, phi = sp.pi/2-mid_dec, mid_ra
#-- check if pair of skewers belong to same spectro
#same_half_plate = (d1.plate == d2.plate) and\
# ( (d1.fid<=500 and d2.fid<=500) or \
# (d1.fid>500 and d2.fid>500) )
#-- angle between skewers
ang = d1 ^ d2
if kappa.true_corr:
ang_delensed = d1.delensed_angle(d2)
#-- getting pixel in between
#mid_pix = healpy.ang2pix(kappa.nside, \
# th, phi)
if kappa.true_corr:
sk, wk = kappa.fast_kappa_true(\
d1.z, d1.r_comov, \
d2.z, d2.r_comov, \
ang_delensed, ang)
else:
sk, wk = kappa.fast_kappa(\
d1.z, d1.r_comov, d1.we, d1.de, \
d2.z, d2.r_comov, d2.we, d2.de, \
ang)
if wk != 0:
id1.append(d1.thid)
id2.append(d2.thid)
skappa.append(sk)
wkappa.append(wk)
setattr(d1, "neighs", None)
return id1, id2, skappa, wkappa
@staticmethod
def fast_kappa(z1, r1, w1, d1, z2, r2, w2, d2, ang):
rp = abs(r1 - r2[:, None]) * sp.cos(ang / 2)
rt = (r1 + r2[:, None]) * sp.sin(ang / 2)
d12 = d1 * d2[:, None]
w12 = w1 * w2[:, None]
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
w12 = w12[w]
d12 = d12[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
#-- weight of estimator
R = -1 / (xip_model * rt)
ska = sp.sum((d12 - xi_model) / R * w12)
wka = sp.sum(w12 / R**2)
return ska, wka
@staticmethod
def fast_kappa_true(z1, r1, z2, r2, ang, ang_lens):
rp = (r1 - r2[:, None]) * sp.cos(ang / 2)
rt = (r1 + r2[:, None]) * sp.sin(ang / 2)
rp_lens = (r1 - r2[:, None]) * sp.cos(ang_lens / 2)
rt_lens = (r1 + r2[:, None]) * sp.sin(ang_lens / 2)
#z = (z1+z2[:,None])/2
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min) ## SY 18/2/19
rp = rp[w]
rt = rt[w]
rp_lens = rp_lens[w]
rt_lens = rt_lens[w]
#z = z[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xi_lens = kappa.xi2d(rt_lens, rp_lens, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
R = -1 / (xip_model * rt)
ska = sp.sum((xi_lens - xi_model) / R)
wka = sp.sum(1 / R**2)
return ska, wka
class kappa:
nside = 256
nside_data = 32
rot = healpy.Rotator(coord=['C', 'G'])
lambda_abs = 1215.67
fid_Om = 0.31
cosmo = constants.cosmo(fid_Om)
rt_min = 0.
rt_max = 40.
rp_min = 0.
rp_max = 10.
nt = 1
np = 1
xi2d = None
angmax = None
z_min_pix = None
counter = Value('i', 0)
lock = Lock()
data = {}
ndata = 0
@staticmethod
def load_model(modelfile, nbins=50):
data_rp, data_rt, xi_dist = N.loadtxt(modelfile, unpack=1)
#-- get the larger value of the first separation bin to make a grid
rp_min = data_rp.reshape(100, 50)[0].max()
rp_max = data_rp.reshape(100, 50)[-1].min()
rt_min = data_rt.reshape(100, 50)[:, 0].max()
rt_max = data_rt.reshape(100, 50)[:, -1].min()
#-- create the regular grid for griddata
rp = N.linspace(rp_min, rp_max, nbins * 2)
rt = N.linspace(rt_min, rt_max, nbins)
xim = sp.interpolate.griddata((data_rt, data_rp), xi_dist, \
(rt[:, None], rp[None, :]), method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, xim)
kappa.xi2d = xi2d
return xi2d
@staticmethod
def read_deltas(in_dir, nspec=None):
data = {}
ndata = 0
dels = []
fi = glob.glob(in_dir + "/*.fits.gz")
for i, f in enumerate(fi):
sys.stderr.write("\rread {} of {} {}".format(i, len(fi), ndata))
hdus = fitsio.FITS(f)
dels += [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(hdus[1:])
hdus.close()
if nspec and ndata > nspec:
break
phi = [d.ra for d in dels]
th = [sp.pi / 2. - d.dec for d in dels]
pix = healpy.ang2pix(kappa.nside_data, th, phi)
z_min_pix = 10**dels[0].ll[0] / kappa.lambda_abs - 1
for d, p in zip(dels, pix):
if p not in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / kappa.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.z = z
d.r_comov = kappa.cosmo.r_comoving(z)
d.we *= ((1. + z) / (1. + 2.25))**(2.9 - 1.)
d.project()
kappa.z_min_pix = z_min_pix
kappa.angmax = 2.*\
sp.arcsin(kappa.rt_max/(2.*kappa.cosmo.r_comoving(z_min_pix)))
kappa.ndata = ndata
kappa.data = data
return data
@staticmethod
def fill_neighs():
data = kappa.data
objs = kappa.objs
print('\n Filling neighbors')
for ipix in data.keys():
for d in data[ipix]:
npix = healpy.query_disc(kappa.nside_data, \
[d.xcart, d.ycart, d.zcart], \
kappa.angmax, inclusive = True)
npix = [p for p in npix if p in objs]
neighs = [q for p in npix for q in objs[p] if q.thid != d.thid]
ang = d ^ neighs
w = ang < kappa.angmax
neighs = sp.array(neighs)[w]
d.neighs = [q for q in neighs if d.ra > q.ra]
#d.neighs = sp.array([q for q in neighs if (10**(d.ll[-1]- \
# sp.log10(lambda_abs))-1 + q.zqso)/2. >= z_cut_min \
# and (10**(d.ll[-1]- sp.log10(lambda_abs))-1 + \
# q.zqso)/2. < z_cut_max])
@staticmethod
def get_kappa(pixels):
ikappa = []
skappa = {}
wkappa = {}
gamma1 = {}
gamma2 = {}
for ipix in pixels:
for i, d in enumerate(kappa.data[ipix]):
sys.stderr.write("\rcomputing kappa: {}%".format(\
round(kappa.counter.value*100./kappa.ndata,2)))
with kappa.lock:
kappa.counter.value += 1
for q in d.neighs:
#-- compute the cartesian mid points and convert back
#-- to ra, dec
mid_xcart = 0.5 * (d.xcart + q.xcart)
mid_ycart = 0.5 * (d.ycart + q.ycart)
mid_zcart = 0.5 * (d.zcart + q.zcart)
mid_ra, mid_dec = get_radec(\
N.array([mid_xcart, mid_ycart, mid_zcart]))
#-- apply rotation into Galactic coordinates
#th, phi = kappa.rot(sp.pi/2-mid_dec, mid_ra)
#-- keeping without rotation
th, phi = sp.pi / 2 - mid_dec, mid_ra
th1, phi1 = sp.pi / 2 - d.dec, d.ra
thq, phiq = sp.pi / 2 - q.dec, q.ra
#-- check if pair of skewers belong to same spectro
same_half_plate = (d.plate == q.plate) and\
( (d.fid<=500 and q.fid<=500) or \
(d.fid>500 and q.fid>500) )
#-- angle between skewers
ang = d ^ q
if kappa.true_corr:
ang_delensed = d.delensed_angle(q)
#-- getting pixel in between
mid_pix = healpy.ang2pix(kappa.nside, \
th, phi)
if kappa.true_corr:
sk, wk, g1, g2 = kappa.fast_kappa_true(\
d.z, d.r_comov, \
q.zqso, q.r_comov, \
ang_delensed, ang, \
th1, phi1, thq, phiq)
else:
sk, wk, g1, g2 = kappa.fast_kappa(\
d.z, d.r_comov, d.we, d.de, \
q.zqso, q.r_comov, q.we, ang, \
th1, phi1, thq, phiq)
if mid_pix in ikappa:
skappa[mid_pix] += sk
wkappa[mid_pix] += wk
gamma1[mid_pix] += g1
gamma2[mid_pix] += g2
else:
ikappa.append(mid_pix)
skappa[mid_pix] = sk
wkappa[mid_pix] = wk
gamma1[mid_pix] = g1
gamma2[mid_pix] = g2
setattr(d, "neighs", None)
return ikappa, skappa, wkappa, gamma1, gamma2
@staticmethod
def fast_kappa(z1,r1,w1,d1,zq,rq,wq,ang, \
th1, phi1, thq, phiq):
rp = (r1[:, None] - rq) * sp.cos(ang / 2)
rt = (r1[:, None] + rq) * sp.sin(ang / 2)
we = w1[:, None] * wq
de = d1[:, None]
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
we = we[w]
de = de[w]
x = (phiq - phi1) * sp.sin(th1)
y = thq - th1
gamma_ang = sp.arctan2(y, x)
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
#-- weight of estimator
R = 1 / (xip_model * rt)
ska = sp.sum((de - xi_model) / R * we)
wka = sp.sum(we / R**2)
gam1 = 4 * sp.cos(2 * gamma_ang) * sp.sum((de - xi_model) / R * we)
gam2 = 4 * sp.sin(2 * gamma_ang) * sp.sum((de - xi_model) / R * we)
return ska, wka, gam1, gam2
@staticmethod
def fast_kappa_true(z1, r1, zq, rq, ang, ang_lens, \
th1, phi1, thq, phiq):
rp = abs(r1[:, None] - rq) * sp.cos(ang / 2)
rt = (r1[:, None] + rq) * sp.sin(ang / 2)
rp_lens = abs(r1[:, None] - rq) * sp.cos(ang_lens / 2)
rt_lens = (r1[:, None] + rq) * sp.sin(ang_lens / 2)
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
rp_lens = rp_lens[w]
rt_lens = rt_lens[w]
x = (phiq - phi1) * sp.sin(th1)
y = thq - th1
gamma_ang = sp.arctan2(y, x)
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xi_lens = kappa.xi2d(rt_lens, rp_lens, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
R = 1 / (xip_model * rt)
ska = sp.sum((xi_lens - xi_model) / R)
wka = sp.sum(1 / R**2)
gam1 = 4 * sp.cos(2 * gamma_ang) * sp.sum((xi_lens - xi_model) / R)
gam2 = 4 * sp.sin(2 * gamma_ang) * sp.sum((xi_lens - xi_model) / R)
return ska, wka, gam1, gam2
class kappa:
nside_data = 16
rot = healpy.Rotator(coord=['C', 'G'])
lambda_abs = 1215.67
fid_Om = 0.31
cosmo = constants.cosmo(fid_Om)
xi2d = None
angmax = None
z_min_pix = None
data = {}
ndata = 0
@staticmethod
def load_model(modelfile, nbins=50):
data_rp, data_rt, xi_dist = np.loadtxt(modelfile, unpack=1)
#-- get the larger value of the first separation bin to make a grid
rp_min = data_rp.reshape(100, 50)[0].max()
rp_max = data_rp.reshape(100, 50)[-1].min()
rt_min = data_rt.reshape(100, 50)[:, 0].max()
rt_max = data_rt.reshape(100, 50)[:, -1].min()
print('rt_min rt_max', rt_min, rt_max)
print('rp_min rp_max', rp_min, rp_max)
#-- create the regular grid for griddata
rp = np.linspace(rp_min, rp_max, nbins * 2)
rt = np.linspace(rt_min, rt_max, nbins)
xim = sp.interpolate.griddata((data_rt, data_rp), xi_dist, \
(rt[:, None], rp[None, :]), method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, xim)
kappa.xi2d = xi2d
return xi2d
@staticmethod
def load_model_h5(modelfile, xifile):
#- Read correlation function file to get rp and rt values
h = fitsio.FITS(xifile)
data_rp = h[1]['RP'][:]
data_rt = h[1]['RT'][:]
hh = h[1].read_header()
nrp = hh['NP']
nrt = hh['NT']
h.close()
#-- get the larger value of the first separation bin to make a grid
rp_min = data_rp.reshape(nrp, nrt)[0].max()
rp_max = data_rp.reshape(nrp, nrt)[-1].min()
rt_min = data_rt.reshape(nrp, nrt)[:, 0].max()
rt_max = data_rt.reshape(nrp, nrt)[:, -1].min()
print(
f'rtmin = {rt_min:.1f} rtmax = {rt_max:.1f} rpmin = {rp_min:.1f} rpmax = {rp_max:.1f}'
)
ff = h5py.File(modelfile, 'r')
keys = list(ff.keys())
for k in keys:
if k != 'best fit':
base = k
break
fit = ff[base + '/fit'][...]
ff.close()
#-- create the regular grid for griddata
rp = np.linspace(rp_min, rp_max, nrp)
rt = np.linspace(rt_min, rt_max, nrt)
xim = sp.interpolate.griddata((data_rt, data_rp), fit, \
(rt[:, None], rp[None, :]), method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, xim)
kappa.xi2d = xi2d
return xi2d
@staticmethod
def read_deltas(in_dir, nspec=None):
data = {}
ndata = 0
dels = []
fi = glob.glob(in_dir + "/*.fits.gz")
for i, f in enumerate(fi):
sys.stderr.write("\rread {} of {} {}".format(i, len(fi), ndata))
sys.stderr.flush()
hdus = fitsio.FITS(f)
dels += [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(hdus[1:])
hdus.close()
if nspec and ndata > nspec:
break
phi = [d.ra for d in dels]
th = [sp.pi / 2. - d.dec for d in dels]
pix = healpy.ang2pix(kappa.nside_data, th, phi)
z_min_pix = 10**dels[0].ll[0] / kappa.lambda_abs - 1
for d, p in zip(dels, pix):
if p not in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / kappa.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.z = z
d.r_comov = kappa.cosmo.r_comoving(z)
d.we *= ((1. + z) / (1. + 2.25))**(2.9 - 1.)
d.project()
kappa.z_min_pix = z_min_pix
kappa.angmax = 2.*\
sp.arcsin(kappa.rt_max/(2.*kappa.cosmo.r_comoving(z_min_pix)))
kappa.ndata = ndata
kappa.data = data
return data
@staticmethod
def fill_neighs(pix):
data = kappa.data
objs = kappa.objs
ndata = len(data)
i = 0
for ipix in pix:
for d in data[ipix]:
npix = healpy.query_disc(kappa.nside_data,
[d.xcart, d.ycart, d.zcart],
kappa.angmax,
inclusive=True)
npix = [p for p in npix if p in objs]
neighs = [q for p in npix for q in objs[p] if q.thid != d.thid]
ang = d ^ neighs
w = ang < kappa.angmax
neighs = sp.array(neighs)[w]
d.neighs = sp.array([q for q in neighs])
i += 1
@staticmethod
def get_kappa(pixels):
id1 = []
id2 = []
skappa = []
wkappa = []
for ipix in pixels:
for i, d in enumerate(kappa.data[ipix]):
sys.stderr.write("\rcomputing kappa: {}%".format(\
round(kappa.counter.value*100./kappa.ndata,2)))
with kappa.lock:
kappa.counter.value += 1
for q in d.neighs:
#-- angle between skewers
ang = d ^ q
if kappa.true_corr:
ang_delensed = d.delensed_angle(q)
if kappa.true_corr:
sk, wk = kappa.fast_kappa_true(\
d.z, d.r_comov, \
q.zqso, q.r_comov, \
ang_delensed, ang)
else:
sk, wk = kappa.fast_kappa(\
d.z, d.r_comov, d.we, d.de, \
q.zqso, q.r_comov, q.we, ang)
if wk != 0:
id1.append(q.thid)
id2.append(d.thid)
skappa.append(sk)
wkappa.append(wk)
setattr(d, "neighs", None)
return id1, id2, skappa, wkappa
@staticmethod
def fast_kappa(z1, r1, w1, d1, zq, rq, wq, ang):
rp = (r1 - rq) * sp.cos(ang / 2)
rt = (r1 + rq) * sp.sin(ang / 2)
we = w1 * wq
de = d1
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
we = we[w]
de = de[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
#-- weight of estimator
R = -1 / (xip_model * rt)
ska = sp.sum((de - xi_model) / R * we)
wka = sp.sum(we / R**2)
return ska, wka
@staticmethod
def fast_kappa_true(z1, r1, zq, rq, ang, ang_lens):
rp = (r1 - rq) * sp.cos(ang / 2)
rt = (r1 + rq) * sp.sin(ang / 2)
rp_lens = (r1 - rq) * sp.cos(ang_lens / 2)
rt_lens = (r1 + rq) * sp.sin(ang_lens / 2)
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
rp_lens = rp_lens[w]
rt_lens = rt_lens[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xi_lens = kappa.xi2d(rt_lens, rp_lens, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
R = -1 / (xip_model * rt)
ska = sp.sum((xi_lens - xi_model) / R)
wka = sp.sum(1 / R**2)
return ska, wka
class kappa:
#nside = 256
nside_data = 32
rot = healpy.Rotator(coord=['C', 'G'])
lambda_abs = 1215.67
fid_Om = 0.31
cosmo = constants.cosmo(fid_Om)
rt_min = 0.
rt_max = 40.
rp_min = 0.
rp_max = 10.
nt = 1
np = 1
xi2d = None
angmax = None
z_min_pix = None
counter = Value('i', 0)
lock = Lock()
data = {}
ndata = 0
## - SY 4/6/19 Changed to use new picca model and fit files
@staticmethod
def load_model(file_xi, file_fit, nbins=50):
h = fitsio.FITS(file_xi)
ff = h5py.File(file_fit, 'r')
base = file_xi
fit = ff[base + '/fit'][...]
data_rp = h[1]['RP'][:]
data_rt = h[1]['RT'][:]
hh = h[1].read_header()
rpmin = hh['RPMIN']
rpmax = hh['RPMAX']
rtmin = 0
rtmax = hh['RTMAX']
h.close()
ff.close()
rpmin = data_rp.reshape(100, 50)[0].max()
rpmax = data_rp.reshape(100, 50)[-1].min()
rtmin = data_rt.reshape(100, 50)[:, 0].max()
rtmax = data_rt.reshape(100, 50)[:, -1].min()
#-- create the regular grid for griddata
rp = np.linspace(rpmin, rpmax, nbins * 2)
rt = np.linspace(rtmin, rtmax, nbins)
#xim = sp.interpolate.griddata((data_rt, data_rp), fit, \
# (rt[:, None], rp[None, :]), method='cubic')
xim = sp.interpolate.griddata(
(data_rt, data_rp),
fit, (np.outer(np.ones(
rp.size), rt).ravel(), np.outer(rp, np.ones(rt.size)).ravel()),
method='cubic')
#-- create interpolator object
xi2d = sp.interpolate.RectBivariateSpline(rt, rp, \
xim.reshape((100, 50)).T )
kappa.xi2d = xi2d
return xi2d
@staticmethod
def read_deltas(in_dir, nspec=None):
data = {}
ndata = 0
dels = []
fi = glob.glob(in_dir + "/*.fits.gz")
for i, f in enumerate(fi):
sys.stderr.write("\rread {} of {} {}".format(i, len(fi), ndata))
hdus = fitsio.FITS(f)
dels += [delta.from_fitsio(h) for h in hdus[1:]]
ndata += len(hdus[1:])
hdus.close()
if nspec and ndata > nspec:
break
phi = [d.ra for d in dels]
th = [sp.pi / 2. - d.dec for d in dels]
pix = healpy.ang2pix(kappa.nside_data, th, phi)
z_min_pix = 10**dels[0].ll[0] / kappa.lambda_abs - 1
for d, p in zip(dels, pix):
if p not in data:
data[p] = []
data[p].append(d)
z = 10**d.ll / kappa.lambda_abs - 1.
z_min_pix = sp.amin(sp.append([z_min_pix], z))
d.z = z
d.r_comov = kappa.cosmo.r_comoving(z)
d.we *= ((1. + z) / (1. + 2.25))**(2.9 - 1.)
d.project()
kappa.z_min_pix = z_min_pix
kappa.angmax = 2.*\
sp.arcsin(kappa.rt_max/(2.*kappa.cosmo.r_comoving(z_min_pix)))
kappa.ndata = ndata
kappa.data = data
return data
@staticmethod
def fill_neighs():
data = kappa.data
objs = kappa.objs
print('\n Filling neighbors')
for ipix in data.keys():
for d in data[ipix]:
npix = healpy.query_disc(kappa.nside_data, \
[d.xcart, d.ycart, d.zcart], \
kappa.angmax, inclusive = True)
npix = [p for p in npix if p in objs]
neighs = [q for p in npix for q in objs[p] if q.thid != d.thid]
ang = d ^ neighs
w = ang < kappa.angmax
neighs = sp.array(neighs)[w]
d.qneighs = [q for q in neighs]
@staticmethod
def get_kappa(pixels):
id1 = []
id2 = []
skappa = []
wkappa = []
for ipix in pixels:
for i, d in enumerate(kappa.data[ipix]):
sys.stderr.write("\rcomputing kappa: {}%".format(\
round(kappa.counter.value*100./kappa.ndata,2)))
with kappa.lock:
kappa.counter.value += 1
for q in d.qneighs:
#-- angle between skewers
ang = d ^ q
if kappa.true_corr:
ang_delensed = d.delensed_angle(q)
if kappa.true_corr:
sk, wk = kappa.fast_kappa_true(\
d.z, d.r_comov, \
q.zqso, q.r_comov, \
ang_delensed, ang)
else:
sk, wk = kappa.fast_kappa(\
d.z, d.r_comov, d.we, d.de, \
q.zqso, q.r_comov, q.we, ang)
if wk != 0:
id1.append(q.thid)
id2.append(d.thid)
skappa.append(sk)
wkappa.append(wk)
setattr(d, "neighs", None)
return id1, id2, skappa, wkappa
@staticmethod
def fast_kappa(z1, r1, w1, d1, zq, rq, wq, ang):
rp = (r1[:, None] - rq) * sp.cos(ang / 2)
rt = (r1[:, None] + rq) * sp.sin(ang / 2)
we = w1[:, None] * wq
de = d1[:, None]
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
we = we[w]
de = de[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
#-- weight of estimator
R = -1 / (xip_model * rt)
ska = sp.sum((de - xi_model) / R * we)
wka = sp.sum(we / R**2)
return ska, wka
@staticmethod
def fast_kappa_true(z1, r1, zq, rq, ang, ang_lens):
rp = (r1[:, None] - rq) * sp.cos(ang / 2)
rt = (r1[:, None] + rq) * sp.sin(ang / 2)
rp_lens = (r1[:, None] - rq) * sp.cos(ang_lens / 2)
rt_lens = (r1[:, None] + rq) * sp.sin(ang_lens / 2)
w = (rp>=kappa.rp_min) & (rp<=kappa.rp_max) & \
(rt<=kappa.rt_max) & (rt>=kappa.rt_min)
rp = rp[w]
rt = rt[w]
rp_lens = rp_lens[w]
rt_lens = rt_lens[w]
#-- getting model and first derivative
xi_model = kappa.xi2d(rt, rp, grid=False)
xi_lens = kappa.xi2d(rt_lens, rp_lens, grid=False)
xip_model = kappa.xi2d(rt, rp, dx=1, grid=False)
R = -1 / (xip_model * rt)
ska = sp.sum((xi_lens - xi_model) / R)
wka = sp.sum(1 / R**2)
return ska, wka
