def test_agreement_with_sigma8():
"""test sigma8 works basic to jdem"""
cosmo_base = defaults.cosmology_wmap.copy()
cosmo_base = cp.add_derived_pars(cosmo_base, 'jdem')
cosmo_base['de_model'] = 'constant_w'
cosmo_base['w'] = -1.
cosmo_base['sigma8'] = 0.7925070693605805
power_params = defaults.power_params.copy()
power_params.camb['maxkh'] = 3.
power_params.camb['kmax'] = 10.
power_params.camb['npoints'] = 1000
power_params.camb['accuracy'] = 2
power_params.camb['leave_h'] = False
power_params_jdem = deepcopy(power_params)
power_params_jdem.camb['force_sigma8'] = False
power_params_basi = deepcopy(power_params)
power_params_basi.camb['force_sigma8'] = True
cosmo_jdem = cosmo_base.copy()
cosmo_jdem['p_space'] = 'jdem'
C_fid_jdem = cp.CosmoPie(cosmo_jdem, 'jdem')
P_jdem = mps.MatterPower(C_fid_jdem, power_params_jdem)
C_fid_jdem.set_power(P_jdem)
cosmo_basi = cosmo_base.copy()
cosmo_basi['p_space'] = 'basic'
C_fid_basi = cp.CosmoPie(cosmo_basi, 'basic')
P_basi = mps.MatterPower(C_fid_basi, power_params_basi)
C_fid_basi.set_power(P_basi)
zs = np.arange(0.2, 1.41, 0.40)
z_fine = np.linspace(0.001, 1.4, 1000)
geo_jdem = FullSkyGeo(zs, C_fid_jdem, z_fine)
geo_basi = FullSkyGeo(zs, C_fid_basi, z_fine)
jdem_pars = np.array(
['ns', 'Omegamh2', 'Omegabh2', 'OmegaLh2', 'LogAs', 'w'])
jdem_eps = np.array([0.002, 0.00025, 0.0001, 0.00025, 0.01, 0.01])
basi_pars = np.array(['ns', 'Omegamh2', 'Omegabh2', 'h', 'sigma8', 'w'])
basi_eps = np.array([0.002, 0.00025, 0.0001, 0.00025, 0.001, 0.01])
sw_params = defaults.sw_survey_params.copy()
len_params = defaults.lensing_params.copy()
sw_observable_list = defaults.sw_observable_list.copy()
nz_wfirst_lens = NZWFirstEff(defaults.nz_params_wfirst_lens.copy())
prior_params = defaults.prior_fisher_params.copy()
basis_params = defaults.basis_params.copy()
sw_survey_jdem = sws.SWSurvey(geo_jdem, 'wfirst', C_fid_jdem, sw_params,
jdem_pars, jdem_eps, sw_observable_list,
len_params, nz_wfirst_lens)
sw_survey_basi = sws.SWSurvey(geo_basi, 'wfirst', C_fid_basi, sw_params,
basi_pars, basi_eps, sw_observable_list,
len_params, nz_wfirst_lens)
#need to fix As because the code cannot presently do this
for itr in range(0, basi_pars.size):
for i in range(0, 2):
cosmo_alt_basi = sw_survey_basi.len_pow.Cs_pert[
itr, i].cosmology.copy()
n_As = 10
logAs = np.linspace(cosmo_alt_basi['LogAs'] * 0.9,
cosmo_alt_basi['LogAs'] * 1.1, n_As)
As = np.exp(logAs)
sigma8s = np.zeros(n_As)
for itr2 in xrange(0, n_As):
cosmo_alt_basi['As'] = As[itr2]
cosmo_alt_basi['LogAs'] = logAs[itr2]
sigma8s[itr2] = camb_sigma8(cosmo_alt_basi,
power_params_basi.camb)
logAs_interp = InterpolatedUnivariateSpline(sigma8s[::-1],
logAs[::-1],
ext=2,
k=3)
sw_survey_basi.len_pow.Cs_pert[
itr, i].cosmology['LogAs'] = logAs_interp(
sw_survey_basi.len_pow.Cs_pert[itr, i].cosmology['sigma8'])
sw_survey_basi.len_pow.Cs_pert[itr, i].cosmology['As'] = np.exp(
sw_survey_basi.len_pow.Cs_pert[itr, i].cosmology['LogAs'])
dO_dpar_jdem = sw_survey_jdem.get_dO_I_dpar_array()
dO_dpar_basi = sw_survey_basi.get_dO_I_dpar_array()
response_pars = np.array([
'ns', 'Omegach2', 'Omegabh2', 'Omegamh2', 'OmegaLh2', 'h', 'LogAs',
'w', 'sigma8'
])
l_max = 24
r_max_jdem = geo_jdem.r_fine[-1]
k_cut_jdem = 30. / r_max_jdem
basis_jdem = SphBasisK(r_max_jdem,
C_fid_jdem,
k_cut_jdem,
basis_params,
l_ceil=l_max,
needs_m=True)
SS_jdem = SuperSurvey(np.array([sw_survey_jdem]),
np.array([]),
basis_jdem,
C_fid_jdem,
prior_params,
get_a=False,
do_unmitigated=True,
do_mitigated=False)
r_max_basi = geo_basi.r_fine[-1]
k_cut_basi = 30. / r_max_basi
basis_basi = SphBasisK(r_max_basi,
C_fid_basi,
k_cut_basi,
basis_params,
l_ceil=l_max,
needs_m=True)
SS_basi = SuperSurvey(np.array([sw_survey_basi]),
np.array([]),
basis_basi,
C_fid_basi,
prior_params,
get_a=False,
do_unmitigated=True,
do_mitigated=False)
#dO_dpar_jdem_to_basi = np.zeros_like(dO_dpar_jdem)
#dO_dpar_basi_to_jdem = np.zeros_like(dO_dpar_basi)
project_basi_to_jdem = np.zeros((jdem_pars.size, basi_pars.size))
response_derivs_jdem = np.zeros((response_pars.size, jdem_pars.size))
response_derivs_basi = np.zeros((response_pars.size, basi_pars.size))
for i in range(0, response_pars.size):
for j in range(0, jdem_pars.size):
response_derivs_jdem[i, j] = (
sw_survey_jdem.len_pow.Cs_pert[j,
0].cosmology[response_pars[i]] -
sw_survey_jdem.len_pow.Cs_pert[j, 1].cosmology[
response_pars[i]]) / (jdem_eps[j] * 2.)
response_derivs_basi[i, j] = (
sw_survey_basi.len_pow.Cs_pert[j,
0].cosmology[response_pars[i]] -
sw_survey_basi.len_pow.Cs_pert[j, 1].cosmology[
response_pars[i]]) / (basi_eps[j] * 2.)
project_jdem_to_basi = np.zeros((basi_pars.size, jdem_pars.size))
project_basi_to_jdem = np.zeros((jdem_pars.size, basi_pars.size))
for itr1 in range(0, basi_pars.size):
for itr2 in range(0, response_pars.size):
if response_pars[itr2] in jdem_pars:
name = response_pars[itr2]
i = np.argwhere(jdem_pars == name)[0, 0]
project_jdem_to_basi[itr1, i] = response_derivs_basi[itr2,
itr1]
for itr1 in range(0, jdem_pars.size):
for itr2 in range(0, response_pars.size):
if response_pars[itr2] in basi_pars:
name = response_pars[itr2]
i = np.argwhere(basi_pars == name)[0, 0]
project_basi_to_jdem[itr1, i] = response_derivs_jdem[itr2,
itr1]
assert np.allclose(np.dot(dO_dpar_jdem, project_jdem_to_basi.T),
dO_dpar_basi,
rtol=1.e-3,
atol=np.max(dO_dpar_basi) * 1.e-4)
assert np.allclose(np.dot(dO_dpar_basi, project_basi_to_jdem.T),
dO_dpar_jdem,
rtol=1.e-3,
atol=np.max(dO_dpar_jdem) * 1.e-4)
#basi p_space cannot currently do priors by itself
f_p_priors_basi = np.dot(
project_jdem_to_basi,
np.dot(SS_jdem.multi_f.fisher_priors.get_fisher(),
project_jdem_to_basi.T))
for i in range(0, 1):
f_np_jdem = SS_jdem.f_set_nopriors[i][2].get_fisher().copy()
f_np_basi = SS_basi.f_set_nopriors[i][2].get_fisher().copy()
f_np_jdem_to_basi = np.dot(project_jdem_to_basi,
np.dot(f_np_jdem, project_jdem_to_basi.T))
f_np_basi_to_jdem = np.dot(project_basi_to_jdem,
np.dot(f_np_basi, project_basi_to_jdem.T))
assert np.allclose(f_np_jdem_to_basi, f_np_basi, rtol=1.e-2)
assert np.allclose(f_np_basi_to_jdem, f_np_jdem, rtol=1.e-2)
f_p_jdem = SS_jdem.f_set[i][2].get_fisher().copy()
f_p_basi = SS_basi.f_set_nopriors[i][2].get_fisher().copy(
) + f_p_priors_basi.copy()
f_p_jdem_to_basi = np.dot(project_jdem_to_basi,
np.dot(f_p_jdem, project_jdem_to_basi.T))
f_p_basi_to_jdem = np.dot(project_basi_to_jdem,
np.dot(f_p_basi, project_basi_to_jdem.T))
assert np.allclose(f_p_jdem_to_basi, f_p_basi, rtol=1.e-2)
assert np.allclose(f_p_basi_to_jdem, f_p_jdem, rtol=1.e-2)
print(f_np_jdem / f_np_basi_to_jdem)
print(f_np_basi / f_np_jdem_to_basi)
#z_fine = np.arange(0.0001,z_max,0.0001)
z_fine = np.linspace(0.001, z_max, 2)
print("main: building basis")
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000
basis_params['x_grid_size'] = 100000
r_max = C.D_comov(z_max)
k_cut = x_cut / r_max
k_tests = np.linspace(20. / r_max, k_cut, 25)
n_basis = np.zeros(k_tests.size)
variances = np.zeros((k_tests.size, z_coarse.size - 1, z_coarse.size - 1))
time4 = time()
basis = SphBasisK(r_max, C, k_cut, basis_params, l_ceil=l_max)
time5 = time()
time2 = time()
pixelated = True
if pixelated:
res_healpix = 9
max_n_pixels = 12 * (2**res_healpix)**2
#n_pixels = np.unique(np.hstack([np.logspace(3,np.log10(max_n_pixels),40).astype(np.int),np.linspace(1000,max_n_pixels,40).astype(np.int)]))
n_pixels = np.array([max_n_pixels / 2]).astype(np.int)
#n_pixels = np.array([1000,2000,3000,4000,5000,10000,20000,30000,40000,49152])
n_bins = n_pixels.size
all_pixels = get_healpix_pixelation(res_choose=res_healpix)
#n_pixels = np.linspace(1,max_n_pixels,80).astype(np.int)#np.unique(np.hstack([np.logspace(0,np.log10(max_n_pixels),40).astype(np.int),np.linspace(1,max_n_pixels,40).astype(np.int)]))
else:
radii = np.array([0.1, 0.2, 0.3, 0.4, 0.8, 1.6, 3.])
def test_pipeline_consistency():
"""test full pipeline consistency with rotation jdem vs lihu"""
cosmo_base = defaults.cosmology_wmap.copy()
cosmo_base = cp.add_derived_pars(cosmo_base, 'jdem')
cosmo_base['de_model'] = 'constant_w'
cosmo_base['w'] = -1.
power_params = defaults.power_params.copy()
power_params.camb['maxkh'] = 1.
power_params.camb['kmax'] = 1.
power_params.camb['npoints'] = 1000
power_params.camb['accuracy'] = 2
power_params.camb['leave_h'] = False
cosmo_jdem = cosmo_base.copy()
cosmo_jdem['p_space'] = 'jdem'
C_fid_jdem = cp.CosmoPie(cosmo_jdem, 'jdem')
P_jdem = mps.MatterPower(C_fid_jdem, power_params.copy())
C_fid_jdem.set_power(P_jdem)
cosmo_lihu = cosmo_base.copy()
cosmo_lihu['p_space'] = 'lihu'
C_fid_lihu = cp.CosmoPie(cosmo_lihu, 'lihu')
P_lihu = mps.MatterPower(C_fid_lihu, power_params.copy())
C_fid_lihu.set_power(P_lihu)
zs = np.arange(0.2, 1.41, 0.40)
z_fine = np.linspace(0.001, 1.4, 1000)
geo_jdem = FullSkyGeo(zs, C_fid_jdem, z_fine)
geo_lihu = FullSkyGeo(zs, C_fid_lihu, z_fine)
jdem_pars = np.array(
['ns', 'Omegamh2', 'Omegabh2', 'OmegaLh2', 'LogAs', 'w'])
jdem_eps = np.array([0.002, 0.00025, 0.0001, 0.00025, 0.1, 0.01])
lihu_pars = np.array(['ns', 'Omegach2', 'Omegabh2', 'h', 'LogAs', 'w'])
lihu_eps = np.array([0.002, 0.00025, 0.0001, 0.00025, 0.1, 0.01])
sw_params = defaults.sw_survey_params.copy()
len_params = defaults.lensing_params.copy()
sw_observable_list = defaults.sw_observable_list.copy()
nz_wfirst_lens = NZWFirstEff(defaults.nz_params_wfirst_lens.copy())
prior_params = defaults.prior_fisher_params.copy()
basis_params = defaults.basis_params.copy()
sw_survey_jdem = sws.SWSurvey(geo_jdem, 'wfirst', C_fid_jdem, sw_params,
jdem_pars, jdem_eps, sw_observable_list,
len_params, nz_wfirst_lens)
sw_survey_lihu = sws.SWSurvey(geo_lihu, 'wfirst', C_fid_lihu, sw_params,
lihu_pars, lihu_eps, sw_observable_list,
len_params, nz_wfirst_lens)
#dO_dpar_jdem = sw_survey_jdem.get_dO_I_dpar_array()
#dO_dpar_lihu = sw_survey_lihu.get_dO_I_dpar_array()
response_pars = np.array([
'ns', 'Omegach2', 'Omegabh2', 'Omegamh2', 'OmegaLh2', 'h', 'LogAs', 'w'
])
response_derivs_jdem_pred = np.array(
[[1., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 1., 0., 1. / (2. * C_fid_jdem.cosmology['h']), 0., 0.],
[0., -1., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 1. / (2. * C_fid_jdem.cosmology['h']), 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0.], [0., 0., 0., 0., 0., 0., 0., 1.]]).T
response_derivs_lihu_pred = np.array(
[[1., 0., 0., 0., 0., 0., 0., 0.], [0., 1., 0., 1., -1., 0., 0., 0.],
[0., 0., 1., 1., -1., 0., 0., 0.],
[0., 0., 0., 0., 2. * C_fid_lihu.cosmology['h'], 1., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0.], [0., 0., 0., 0., 0., 0., 0., 1.]]).T
l_max = 24
r_max_jdem = geo_jdem.r_fine[-1]
k_cut_jdem = 30. / r_max_jdem
basis_jdem = SphBasisK(r_max_jdem,
C_fid_jdem,
k_cut_jdem,
basis_params,
l_ceil=l_max,
needs_m=True)
SS_jdem = SuperSurvey(np.array([sw_survey_jdem]),
np.array([]),
basis_jdem,
C_fid_jdem,
prior_params,
get_a=False,
do_unmitigated=True,
do_mitigated=False)
r_max_lihu = geo_lihu.r_fine[-1]
k_cut_lihu = 30. / r_max_lihu
basis_lihu = SphBasisK(r_max_lihu,
C_fid_lihu,
k_cut_lihu,
basis_params,
l_ceil=l_max,
needs_m=True)
SS_lihu = SuperSurvey(np.array([sw_survey_lihu]),
np.array([]),
basis_lihu,
C_fid_lihu,
prior_params,
get_a=False,
do_unmitigated=True,
do_mitigated=False)
#dO_dpar_jdem_to_lihu = np.zeros_like(dO_dpar_jdem)
#dO_dpar_lihu_to_jdem = np.zeros_like(dO_dpar_lihu)
project_lihu_to_jdem = np.zeros((jdem_pars.size, lihu_pars.size))
#f_g_jdem_to_lihu = np.zeros((lihu_pars.size,lihu_pars.size))
#f_g_lihu_to_jdem = np.zeros((jdem_pars.size,jdem_pars.size))
response_derivs_jdem = np.zeros((response_pars.size, jdem_pars.size))
response_derivs_lihu = np.zeros((response_pars.size, lihu_pars.size))
for i in range(0, response_pars.size):
for j in range(0, jdem_pars.size):
response_derivs_jdem[i, j] = (
sw_survey_jdem.len_pow.Cs_pert[j,
0].cosmology[response_pars[i]] -
sw_survey_jdem.len_pow.Cs_pert[j, 1].cosmology[
response_pars[i]]) / (jdem_eps[j] * 2.)
response_derivs_lihu[i, j] = (
sw_survey_lihu.len_pow.Cs_pert[j,
0].cosmology[response_pars[i]] -
sw_survey_lihu.len_pow.Cs_pert[j, 1].cosmology[
response_pars[i]]) / (lihu_eps[j] * 2.)
assert np.allclose(response_derivs_jdem, response_derivs_jdem_pred)
assert np.allclose(response_derivs_lihu, response_derivs_lihu_pred)
project_jdem_to_lihu = np.zeros((lihu_pars.size, jdem_pars.size))
project_lihu_to_jdem = np.zeros((jdem_pars.size, lihu_pars.size))
for itr1 in range(0, lihu_pars.size):
for itr2 in range(0, response_pars.size):
if response_pars[itr2] in jdem_pars:
name = response_pars[itr2]
i = np.argwhere(jdem_pars == name)[0, 0]
project_jdem_to_lihu[itr1, i] = response_derivs_lihu[itr2,
itr1]
for itr1 in range(0, jdem_pars.size):
for itr2 in range(0, response_pars.size):
if response_pars[itr2] in lihu_pars:
name = response_pars[itr2]
i = np.argwhere(lihu_pars == name)[0, 0]
project_lihu_to_jdem[itr1, i] = response_derivs_jdem[itr2,
itr1]
#assert np.allclose(np.dot(dO_dpar_jdem,project_jdem_to_lihu.T),dO_dpar_lihu,rtol=1.e-3,atol=np.max(dO_dpar_lihu)*1.e-4)
#assert np.allclose(np.dot(dO_dpar_lihu,project_lihu_to_jdem.T),dO_dpar_jdem,rtol=1.e-3,atol=np.max(dO_dpar_jdem)*1.e-4)
#lihu p_space cannot currently do priors by itself
f_p_priors_lihu = np.dot(
project_jdem_to_lihu,
np.dot(SS_jdem.multi_f.fisher_priors.get_fisher(),
project_jdem_to_lihu.T))
f_set_jdem_in = np.zeros(3, dtype=object)
f_set_lihu_in = np.zeros(3, dtype=object)
for i in range(0, 3):
f_set_jdem_in[i] = SS_jdem.f_set_nopriors[i][2].get_fisher().copy()
f_set_lihu_in[i] = SS_lihu.f_set_nopriors[i][2].get_fisher().copy()
f_np_lihu2 = rotate_jdem_to_lihu(f_set_jdem_in, C_fid_jdem)
f_np_jdem2 = rotate_lihu_to_jdem(f_set_lihu_in, C_fid_lihu)
f_np_lihu3 = rotate_jdem_to_lihu(f_np_jdem2, C_fid_jdem)
f_np_jdem3 = rotate_lihu_to_jdem(f_np_lihu2, C_fid_lihu)
for i in range(0, 3):
f_np_jdem = SS_jdem.f_set_nopriors[i][2].get_fisher().copy()
f_np_lihu = SS_lihu.f_set_nopriors[i][2].get_fisher().copy()
f_np_jdem_to_lihu = np.dot(project_jdem_to_lihu,
np.dot(f_np_jdem, project_jdem_to_lihu.T))
f_np_lihu_to_jdem = np.dot(project_lihu_to_jdem,
np.dot(f_np_lihu, project_lihu_to_jdem.T))
assert np.allclose(f_set_lihu_in[i], f_np_lihu3[i])
assert np.allclose(f_set_jdem_in[i], f_np_jdem3[i])
assert np.allclose(f_np_jdem_to_lihu, f_np_lihu2[i])
assert np.allclose(f_np_lihu_to_jdem, f_np_jdem2[i])
assert np.allclose(f_np_jdem_to_lihu, f_np_lihu, rtol=1.e-3)
assert np.allclose(f_np_lihu_to_jdem, f_np_jdem, rtol=1.e-3)
assert np.allclose(f_set_lihu_in[i], f_np_lihu2[i], rtol=1.e-3)
assert np.allclose(f_set_jdem_in[i], f_np_jdem2[i], rtol=1.e-3)
assert np.allclose(f_np_jdem3[i], f_np_jdem2[i], rtol=1.e-3)
assert np.allclose(f_np_lihu3[i], f_np_lihu2[i], rtol=1.e-3)
f_p_jdem = SS_jdem.f_set[i][2].get_fisher().copy()
f_p_lihu = SS_lihu.f_set_nopriors[i][2].get_fisher().copy(
) + f_p_priors_lihu.copy()
f_p_jdem_to_lihu = np.dot(project_jdem_to_lihu,
np.dot(f_p_jdem, project_jdem_to_lihu.T))
f_p_lihu_to_jdem = np.dot(project_lihu_to_jdem,
np.dot(f_p_lihu, project_lihu_to_jdem.T))
assert np.allclose(f_p_jdem_to_lihu, f_p_lihu, rtol=1.e-3)
assert np.allclose(f_p_lihu_to_jdem, f_p_jdem, rtol=1.e-3)
def test_full_sky():
"""do some tests with a full sky geo known results"""
#get dictionaries of parameters that various functions will need
#cosmo = defaults.cosmology_wmap.copy()
cosmo = { 'Omegabh2':0.02223,
'Omegach2':0.1153,
'Omegab' :0.04283392714316876,
'Omegac' :0.22216607285683124,
'Omegamh2':0.13752999999999999,
'OmegaL' :0.735,
'OmegaLh2':0.38145113207547166,
'Omegam' :0.265,
'H0' :72.04034509047493,
'sigma8' : 0.8269877678406697, #from the code
'h' :0.7204034509047493,
'Omegak' : 0.0,
'Omegakh2': 0.0,
'Omegar' : 0.0,
'Omegarh2': 0.0,
'ns' : 0.9608,
'tau' : 0.081,
'Yp' :0.299,
'As' : 2.464*10**-9,
'LogAs' :-19.821479791275138,
'w' :-1.0,
'de_model':'constant_w',#dark energy model
'mnu' :0.}
cosmo['de_model'] = 'constant_w'
cosmo['wa'] = 0.
cosmo['w0'] = -1.
cosmo['w'] = -1.
p_space = 'jdem'
camb_params = defaults.camb_params.copy()
camb_params['force_sigma8'] = False
camb_params['maxkh'] = 100.
camb_params['kmax'] = 30.
camb_params['npoints'] = 10000
camb_params['pivot_scalar'] = 0.002
power_params = defaults.power_params.copy()
power_params.camb = camb_params
power_params.camb['accuracy'] = 1
#prior_params = defaults.prior_fisher_params.copy()
zs = np.array([0.0001,3.])
z_fine = np.linspace(0.0001,zs[-1],10000)
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000*10
C = CosmoPie(cosmo,p_space=p_space)
l_max = 0
x_cut = 10*np.pi
z_max = z_fine[-1]+0.000001
r_max = C.D_comov(z_max)
k_cut = x_cut/r_max
P = MatterPower(C,power_params)
C.set_power(P)
geo1 = FullSkyGeo(zs,C,z_fine)
basis = SphBasisK(r_max,C,k_cut,basis_params,l_ceil=l_max,needs_m=True)
ddbar = basis.get_ddelta_bar_ddelta_alpha(geo1,tomography=True)
ns = np.arange(1,ddbar.size+1)
ddbar_pred = -3./(2.*np.pi**(5./2.))*(-1)**ns/ns**2
assert np.allclose(ddbar,ddbar_pred)
cov_pred = np.zeros((ns.size,ns.size))
xs = P.k*r_max
P_in = P.get_matter_power(np.array([0.]),pmodel='linear')[:,0]
for i1 in range(0,ns.size):
for i2 in range(i1,ns.size):
integrand1 = 8.*np.pi**3*(-1)**(ns[i1]+ns[i2])*ns[i1]**2*ns[i2]**2/r_max**3*np.sin(xs)**2/((ns[i1]**2*np.pi**2-xs**2)*(ns[i2]**2*np.pi**2-xs**2))
cov_pred[i1,i2] = np.trapz(integrand1*P_in,xs)
if i1!=i2:
cov_pred[i2,i1] = cov_pred[i1,i2]
cov_got = basis.get_covar_array()
var_pred = np.dot(ddbar_pred.T,np.dot(cov_pred,ddbar_pred))
var_got = basis.get_variance(geo1)
assert np.all(cov_got==cov_got.T)
assert np.allclose(basis.C_id[:,1],ns*np.pi/r_max)
assert np.allclose(cov_pred,cov_got,atol=1.e-15,rtol=1.e-3)
assert np.isclose(var_got[0,0],var_pred,atol=1.e-15,rtol=1.e-3)
ddbar_got2 = basis.get_dO_I_ddelta_alpha(geo1,geo1.r_fine**2)*3./r_max**3
assert np.allclose(ddbar,ddbar_got2,rtol=1.e-3)
#set some parameters for lensing
len_params['smodel'] = 'nzmatcher'
len_params['pmodel'] = 'halofit'
#create the lw basis
#z_max is the maximum radial extent of the basis
z_max = z_fine[-1] + 0.001
r_max = C.D_comov(z_max)
#k_cut is the maximum k value for the bessel function zeros that define the basis
x_cut = 80.
k_cut = x_cut / r_max
#l_max caps maximum l regardless of k
print("main: begin constructing basis for long wavelength fluctuations")
basis = SphBasisK(r_max,
C,
k_cut,
basis_params,
l_ceil=l_max,
needs_m=True)
print("main: finish constructing basis for long wavelength fluctuations")
#create the lw survey
geos = np.array([geo_wfirst, geo_lsst], dtype=object)
print("main: begin constructing LWSurvey for mitigation")
survey_lw = LWSurvey(geos,
'combined_survey',
basis,
C,
lw_params,
observable_list=lw_observable_list,
param_list=lw_param_list)
print("main: finish constructing LWSurvey for mitigation")
def test_half_sky():
"""do some tests with a half sky geo known results"""
#get dictionaries of parameters that various functions will need
cosmo = { 'Omegabh2':0.0222,
'Omegach2':0.1153,
'Omegab' :0.04283392714316876,
'Omegac' :0.22216607285683124,
'Omegamh2':0.13752999999999999,
'OmegaL' :0.735,
'OmegaLh2':0.38145113207547166,
'Omegam' :0.265,
'H0' :72.04034509047493,
'sigma8' : 0.8269877678406697, #from the code
'h' :0.7204034509047493,
'Omegak' : 0.0,
'Omegakh2': 0.0,
'Omegar' : 0.0,
'Omegarh2': 0.0,
'ns' : 0.9608,
'tau' : 0.081,
'Yp' :0.299,
'As' : 2.464*10**-9,
'LogAs' :-19.821479791275138,
'w' :-1.0,
'de_model':'constant_w',#dark energy model
'mnu' :0.}
cosmo['de_model'] = 'constant_w'
cosmo['wa'] = 0.
cosmo['w0'] = -1.
cosmo['w'] = -1.
p_space = 'jdem'
camb_params = defaults.camb_params.copy()
camb_params['force_sigma8'] = False
camb_params['maxkh'] = 100.
camb_params['kmax'] = 30.
camb_params['npoints'] = 10000
camb_params['pivot_scalar'] = 0.002
power_params = defaults.power_params.copy()
power_params.camb = camb_params
power_params.camb['accuracy'] = 1
#prior_params = defaults.prior_fisher_params.copy()
zs = np.array([0.0001,3.])
z_fine = np.linspace(0.0001,zs[-1],10000)
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000*10
#test with half sky using results calculated in mathematica
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000*10
C = CosmoPie(cosmo,p_space=p_space)
l_max = 4
x_cut = 10
z_max = z_fine[-1]+0.000001
r_max = C.D_comov(z_max)
k_cut = x_cut/r_max
geo1 = HalfSkyGeo(zs,C,z_fine)
P = MatterPower(C,power_params)
P.P_lin = 1./(P.k*r_max)
C.set_power(P)
basis = SphBasisK(r_max,C,k_cut,basis_params,l_ceil=l_max,needs_m=False)
basis2 = SphBasisK(r_max,C,k_cut,basis_params,l_ceil=l_max,needs_m=True)
ddbar = basis.get_ddelta_bar_ddelta_alpha(geo1,tomography=True)
ddbar2 = basis2.get_ddelta_bar_ddelta_alpha(geo1,tomography=True)
ddbar_got2 = basis.get_dO_I_ddelta_alpha(geo1,geo1.r_fine**2)*3./r_max**3
#ns = np.arange(1,ddbar.size+1)
cov_got = basis.get_covar_array()
cov_got2 = basis2.get_covar_array()
var_got = basis.get_variance(geo1)
var_got2 = basis2.get_variance(geo1)
cov_pred0 = np.array([[3.220393570704632e-11,-9.51309537893619e-12,9.955267964241254e-12],[-9.51309537893619e-12,5.937410951604845e-11,-1.2342996089442917e-11],[9.955267964241254e-12,-1.2342996089442917e-11,8.524795995567036e-11]])
cov_pred1 = np.array([[4.306831299006748e-11,-7.977015797357624e-12],[-7.977015797357624e-12,6.907871421795387e-11]])
cov_pred2 = np.array([[5.467066924435653e-11,-7.056047462103054e-12],[-7.056047462103054e-12,7.984696153964485e-11]])
cov_pred3 = np.array([[6.70079506270691e-11]])
cov_pred4 = np.array([[7.985214180284307e-11]])
cov_pred = np.zeros((ddbar.size,ddbar.size))
cov_pred[0:3,0:3] = cov_pred0
cov_pred[3:5,3:5] = cov_pred1
cov_pred[5:7,5:7] = cov_pred2
cov_pred[7,7] = cov_pred3
cov_pred[8,8] = cov_pred4
var_pred = np.dot(ddbar,np.dot(cov_pred,ddbar.T))
var_pred2 = np.dot(ddbar2,np.dot(cov_got2,ddbar2.T))
assert np.all(cov_got==cov_got.T)
assert np.all(cov_got2==cov_got2.T)
assert np.isclose(var_got[0,0],var_pred,atol=1.e-15,rtol=1.e-3)
assert np.isclose(var_got2[0,0],var_pred2,atol=1.e-15,rtol=1.e-3)
assert np.isclose(var_got2[0,0],var_pred,atol=1.e-15,rtol=1.e-3)
assert np.allclose(cov_pred,cov_got,atol=1.e-15,rtol=1.e-3)
assert np.allclose(ddbar,ddbar_got2,rtol=1.e-3,atol=1.e-15)
for itr in range(0,basis.C_id.shape[0]):
if basis.C_id[itr,0]>0 and np.mod(basis.C_id[itr,0],2)==0.:
assert ddbar[0,itr] == 0.
for itr in range(0,basis2.C_id.shape[0]):
if basis2.C_id[itr,0]>0 and np.mod(basis2.C_id[itr,0],2)==0.:
assert ddbar2[0,itr] == 0.
elif basis2.C_id[itr,2]!=0:
assert ddbar2[0,itr] == 0.
# geo2 = PolygonGeo(z_coarse,thetas,phis+phi1,theta_in,phi_in+phi1,C,z_fine,l_max,polygon_params)
# #geo1 = RectGeo(z_coarse,np.array([theta0,theta1]),np.array([phi0,phi1]),C,z_fine)
# #geo2 = RectGeo(z_coarse,np.array([theta0,theta1]),np.array([phi0,phi1])+phi1,C,z_fine)
print("main: building basis")
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample']*=1
basis_params['x_grid_size']*=10
r_max = C.D_comov(z_max)
k_cut = x_cut/r_max
k_tests = np.linspace(20./r_max,k_cut,100)
n_basis = np.zeros(k_tests.size)
variances = np.zeros(k_tests.size)
basis = SphBasisK(r_max,C,k_cut,basis_params,l_ceil=l_max)
for i in range(0,k_tests.size):
print("r_max,k_cut",r_max,k_tests[i])
n_basis[i] = np.sum(basis.C_id[:,1]<=k_tests[i])
variances[i] = basis.get_variance(geo1,k_cut_in=k_tests[i])
print("main: with k_cut="+str(k_tests[i])+" size="+str(n_basis[i])+" got variance="+str(variances[i]))
if do_plot:
import matplotlib.pyplot as plt
plt.plot(n_basis,variances)
plt.show()
print("main: getting variance")
variance_res = basis.get_variance(geo1)
time1 = time()
print("main: finished building in "+str(time1-time0)+"s")
print("main: building basis")
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000
basis_params['x_grid_size'] = 100000
r_max = C.D_comov(z_max)
k_cut = x_cut / r_max
k_tests = np.linspace(20. / r_max, k_cut, 25)
n_basis = np.zeros(k_tests.size)
variances = np.zeros((k_tests.size, z_coarse.size - 1, z_coarse.size - 1))
time4 = time()
basis = SphBasisK(r_max,
C,
k_cut,
basis_params,
l_ceil=l_max,
needs_m=False)
time5 = time()
time2 = time()
#geo1 = LSSTGeoSimpl(z_coarse,C,z_fine,l_max,polygon_params,phi0=0.,phi1=0.9202821591024097,deg0=-59,deg1=-10)#WFIRSTGeo(z_coarse,C,z_fine,l_max,polygon_params) #best con 2.43117008e-06
#geo1 = FullSkyGeo(z_coarse,C,z_fine)
geo1 = HalfSkyGeo(z_coarse, C, z_fine)
#geo1 = FullSkyPixelGeo(z_coarse,C,z_fine,l_max,6)
time3 = time()
#geo1 = WFIRSTGeo(z_coarse,C,z_fine,l_max,polygon_params) #best con 2.43117008e-06
#geo1 = CircleGeo(z_coarse,C,0.45509788222857989,100,z_fine,l_max,polygon_params)
#geo1 = LSSTGeoSimpl(z_coarse,C,z_fine,l_max,defaults.polygon_params.copy()) #best con 2.43117008e-06
print('main: r diffs', np.diff(geo1.rs))
print('main: theta width',
def test_rotational_invariance():
"""test invariance of results under global rotations"""
camb_params = { 'npoints':2000,
'minkh':1.1e-4,
'maxkh':1.476511342960e+02,
'kmax':1.476511342960e+02,
'leave_h':False,
'force_sigma8':False,
'return_sigma8':False,
'accuracy':1,
'pivot_scalar':0.002
}
print("main: building cosmology")
power_params = defaults.power_params.copy()
power_params.camb = camb_params
power_params.camb['accuracy'] = 1
power_params.camb['maxkh'] = 100.
power_params.camb['kmax'] = 30.
power_params.camb['npoints'] = 1000
C = CosmoPie(defaults.cosmology.copy(),p_space='jdem')
P_lin = mps.MatterPower(C,power_params)
C.set_power(P_lin)
l_max = 23
x_cut = 30.
print("main: building geometries")
polygon_params = defaults.polygon_params.copy()
polygon_params['n_double'] = 80
z_coarse = np.array([0.2,1.,2.,3.])
zs_lsst = np.linspace(0.,1.2,3)
#z_max = np.max(z_coarse)
#z_fine = np.arange(0.0001,z_max,0.0001)
z_fine = np.linspace(0.001,3.,500)
z_max = z_fine[-1]+0.001
print("main: building basis")
basis_params = defaults.basis_params.copy()
basis_params['n_bessel_oversample'] = 400000
basis_params['x_grid_size'] = 100000
r_max = C.D_comov(z_max)
k_cut = x_cut/r_max
basis = SphBasisK(r_max,C,k_cut,basis_params,l_ceil=l_max)
geo1 = WFIRSTGeo(z_coarse,C,z_fine,l_max,polygon_params)#HalfSkyGeo(z_coarse,C,z_fine)
geo2 = LSSTGeo(zs_lsst,C,z_fine,l_max,polygon_params)#HalfSkyGeo(z_coarse,C,z_fine)
geo1_rot1 = AlmRotGeo(geo1,C,z_coarse,z_fine,np.array([0.,np.pi/2.,np.pi]),polygon_params['n_double'])
geo1_rot2 = AlmRotGeo(geo1_rot1,C,z_coarse,z_fine,np.array([0.,np.pi/2.,np.pi]),polygon_params['n_double'])
geo1_rot3 = AlmRotGeo(geo1_rot2,C,z_coarse,z_fine,np.array([0.005,1.2496,1.72]),polygon_params['n_double'])
geo2_rot1 = AlmRotGeo(geo2,C,zs_lsst,z_fine,np.array([0.,np.pi/2.,np.pi]),polygon_params['n_double'])
geo2_rot2 = AlmRotGeo(geo2_rot1,C,zs_lsst,z_fine,np.array([0.,np.pi/2.,np.pi]),polygon_params['n_double'])
geo2_rot3 = AlmRotGeo(geo2_rot2,C,zs_lsst,z_fine,np.array([0.005,1.2496,1.72]),polygon_params['n_double'])
assert np.allclose(geo1.get_alm_array(l_max),geo1_rot2.get_alm_array(l_max))
var_geo1 = basis.get_variance(geo1,k_cut_in=k_cut)
var_geo1_rot1 = basis.get_variance(geo1_rot1,k_cut_in=k_cut)
var_geo1_rot2 = basis.get_variance(geo1_rot2,k_cut_in=k_cut)
var_geo1_rot3 = basis.get_variance(geo1_rot3,k_cut_in=k_cut)
assert np.allclose(var_geo1,var_geo1_rot1,atol=1.e-20,rtol=1.e-8)
assert np.allclose(var_geo1,var_geo1_rot2,atol=1.e-20,rtol=1.e-8)
assert np.allclose(var_geo1,var_geo1_rot3,atol=1.e-20,rtol=1.e-8)
var_geo2 = basis.get_variance(geo2,k_cut_in=k_cut)
var_geo2_rot1 = basis.get_variance(geo2_rot1,k_cut_in=k_cut)
var_geo2_rot2 = basis.get_variance(geo2_rot2,k_cut_in=k_cut)
var_geo2_rot3 = basis.get_variance(geo2_rot3,k_cut_in=k_cut)
assert np.allclose(var_geo2,var_geo2_rot1,atol=1.e-20,rtol=1.e-8)
assert np.allclose(var_geo2,var_geo2_rot2,atol=1.e-20,rtol=1.e-8)
assert np.allclose(var_geo2,var_geo2_rot3,atol=1.e-20,rtol=1.e-8)
cosmo_par_list = np.array(['ns','Omegamh2','Omegabh2','OmegaLh2','LogAs','w'])
cosmo_par_eps = np.array([0.002,0.00025,0.0001,0.00025,0.1,0.01])
nz_params_wfirst_lens = defaults.nz_params_wfirst_lens.copy()
nz_params_wfirst_lens['i_cut'] = 26.3
nz_params_wfirst_lens['data_source'] = './data/CANDELS-GOODSS2.dat'
nz_wfirst_lens = NZWFirstEff(nz_params_wfirst_lens)
sw_params = defaults.sw_survey_params.copy()
lw_params = defaults.lw_survey_params.copy()
sw_observable_list = defaults.sw_observable_list.copy()
lw_observable_list = defaults.lw_observable_list.copy()
len_params = defaults.lensing_params.copy()
mf_params = defaults.hmf_params.copy()
mf_params['n_grid'] = 2000
mf_params['log10_min_mass'] = 10.
n_params_lsst = defaults.nz_params_lsst_use.copy()
n_params_lsst['i_cut'] = 24.1 #gold standard subset of LSST 1 year (10 year 25.3)
dn_params = defaults.dn_params.copy()
dn_params['nz_select'] = 'LSST'
dn_params['sigma0'] = 0.1
lw_param_list = np.array([{'dn_params':dn_params,'n_params':n_params_lsst,'mf_params':mf_params}])
prior_params = defaults.prior_fisher_params.copy()
sw_survey_geo1 = SWSurvey(geo1,'geo1',C,sw_params,cosmo_par_list,cosmo_par_eps,sw_observable_list,len_params,nz_wfirst_lens)
sw_survey_geo1_rot1 = SWSurvey(geo1_rot1,'geo1_rot1',C,sw_params,cosmo_par_list,cosmo_par_eps,sw_observable_list,len_params,nz_wfirst_lens)
sw_survey_geo1_rot2 = SWSurvey(geo1_rot2,'geo1_rot2',C,sw_params,cosmo_par_list,cosmo_par_eps,sw_observable_list,len_params,nz_wfirst_lens)
sw_survey_geo1_rot3 = SWSurvey(geo1_rot3,'geo1_rot3',C,sw_params,cosmo_par_list,cosmo_par_eps,sw_observable_list,len_params,nz_wfirst_lens)
survey_lw1 = LWSurvey(np.array([geo1,geo2]),'lw1',basis,C,lw_params,observable_list=lw_observable_list,param_list=lw_param_list)
survey_lw1_rot1 = LWSurvey(np.array([geo1_rot1,geo2_rot1]),'lw1',basis,C,lw_params,observable_list=lw_observable_list,param_list=lw_param_list)
survey_lw1_rot2 = LWSurvey(np.array([geo1_rot2,geo2_rot2]),'lw1',basis,C,lw_params,observable_list=lw_observable_list,param_list=lw_param_list)
survey_lw1_rot3 = LWSurvey(np.array([geo1_rot3,geo2_rot3]),'lw1',basis,C,lw_params,observable_list=lw_observable_list,param_list=lw_param_list)
SS_geo1 = SuperSurvey(np.array([sw_survey_geo1]),np.array([survey_lw1]),basis,C,prior_params,get_a=True,do_unmitigated=True,do_mitigated=True,include_sw=True)
SS_geo1_rot1 = SuperSurvey(np.array([sw_survey_geo1_rot1]),np.array([survey_lw1_rot1]),basis,C,prior_params,get_a=True,do_unmitigated=True,do_mitigated=True,include_sw=True)
SS_geo1_rot2 = SuperSurvey(np.array([sw_survey_geo1_rot2]),np.array([survey_lw1_rot2]),basis,C,prior_params,get_a=True,do_unmitigated=True,do_mitigated=True,include_sw=True)
SS_geo1_rot3 = SuperSurvey(np.array([sw_survey_geo1_rot3]),np.array([survey_lw1_rot3]),basis,C,prior_params,get_a=True,do_unmitigated=True,do_mitigated=True,include_sw=True)
for i in xrange(0,3):
for j in xrange(1,3):
assert np.allclose(SS_geo1.f_set_nopriors[i][j].get_covar(),SS_geo1_rot1.f_set_nopriors[i][j].get_covar(),atol=1.e-30,rtol=1.e-8)
assert np.allclose(SS_geo1.f_set_nopriors[i][j].get_covar(),SS_geo1_rot2.f_set_nopriors[i][j].get_covar(),atol=1.e-30,rtol=1.e-8)
assert np.allclose(SS_geo1.f_set_nopriors[i][j].get_covar(),SS_geo1_rot3.f_set_nopriors[i][j].get_covar(),atol=1.e-30,rtol=1.e-8)
a_geo1 = SS_geo1.multi_f.get_a_lw()
a_geo1_rot1 = SS_geo1_rot1.multi_f.get_a_lw()
a_geo1_rot2 = SS_geo1_rot2.multi_f.get_a_lw()
a_geo1_rot3 = SS_geo1_rot3.multi_f.get_a_lw()
assert np.allclose(a_geo1[0],a_geo1_rot1[0],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[1],a_geo1_rot1[1],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[0],a_geo1_rot2[0],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[1],a_geo1_rot2[1],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[0],a_geo1_rot3[0],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[1],a_geo1_rot3[1],atol=1.e-20,rtol=1.e-8)
assert np.allclose(a_geo1[0],var_geo1,atol=1.e-30,rtol=1.e-13)
assert np.allclose(a_geo1_rot1[0],var_geo1_rot1,atol=1.e-30,rtol=1.e-11)
assert np.allclose(a_geo1_rot2[0],var_geo1_rot2,atol=1.e-30,rtol=1.e-11)
assert np.allclose(a_geo1_rot3[0],var_geo1_rot3,atol=1.e-30,rtol=1.e-11)
for i in xrange(0,2):
for j in xrange(0,2):
eig_geo1 = SS_geo1.eig_set[i][j][0]
eig_geo1_rot1 = SS_geo1_rot1.eig_set[i][j][0]
eig_geo1_rot2 = SS_geo1_rot2.eig_set[i][j][0]
eig_geo1_rot3 = SS_geo1_rot3.eig_set[i][j][0]
assert np.allclose(eig_geo1,eig_geo1_rot1)
assert np.allclose(eig_geo1,eig_geo1_rot2)
assert np.allclose(eig_geo1,eig_geo1_rot3)
def test_super_survey(de_model):
"""run some eigenvalue tests of SuperSurvey pipeline"""
t1 = time()
z_max = 1.35
l_max = 50
camb_params = defaults.camb_params.copy()
camb_params['force_sigma8'] = False
camb_params['kmax'] = 5.
camb_params['npoints'] = 1000
cosmo_fid = defaults.cosmology_jdem.copy()
cosmo_fid['w'] = -1.
cosmo_fid['w0'] = cosmo_fid['w']
cosmo_fid['wa'] = 0.
cosmo_fid['de_model'] = de_model
if cosmo_fid['de_model'] == 'jdem':
for i in range(0, 36):
cosmo_fid['ws36_' + str(i).zfill(2)] = cosmo_fid['w']
C = cp.CosmoPie(cosmology=cosmo_fid, p_space='jdem')
power_params = defaults.power_params.copy()
power_params.camb = camb_params
P = mps.MatterPower(C, power_params)
C.set_power(P)
r_max = C.D_comov(z_max)
print('this is r max and l_max', r_max, l_max)
phi1s = np.array([
-19., -19., -11., -11., 7., 25., 25., 43., 43., 50., 50., 50., 24., 5.,
5., 7., 7., -19.
]) * np.pi / 180.
theta1s = np.array([
-50., -35., -35., -19., -19., -19., -15.8, -15.8, -40., -40., -55.,
-78., -78., -78., -55., -55., -50., -50.
]) * np.pi / 180. + np.pi / 2.
phi_in1 = 7. / 180. * np.pi
theta_in1 = -35. * np.pi / 180. + np.pi / 2.
theta0 = np.pi / 4.
theta1 = 3. * np.pi / 4.
phi0 = 0.
phi1 = 3.074096023740458
phi2 = np.pi / 3.
phi3 = phi2 + (phi1 - phi0)
theta2s = np.array([theta0, theta1, theta1, theta0, theta0])
phi2s = np.array([phi0, phi0, phi1, phi1, phi0]) - phi1 / 2.
theta_in2 = np.pi / 2.
phi_in2 = 0.
res_choose = 7
Theta1 = [theta0, theta1]
Phi1 = [phi0, phi1]
Theta2 = [theta0, theta1]
Phi2 = [phi2, phi3]
zs = np.array([0.2, 0.43, .63, 0.9, 1.3])
z_fine = np.linspace(0.001, np.max(zs), 2000) #use linspace
use_poly = True
use_poly2 = True
if use_poly:
if use_poly2:
geo1 = PolygonGeo(zs, theta1s, phi1s, theta_in1, phi_in1, C,
z_fine, l_max, defaults.polygon_params.copy())
geo2 = PolygonGeo(zs, theta2s, phi2s, theta_in2, phi_in2, C,
z_fine, l_max, defaults.polygon_params.copy())
else:
geo1 = PolygonPixelGeo(zs, theta1s, phi1s, theta_in1, phi_in1, C,
z_fine, l_max, res_choose)
geo2 = PolygonPixelGeo(zs, theta2s, phi2s, theta_in2, phi_in2, C,
z_fine, l_max, res_choose)
else:
geo1 = RectGeo(zs, Theta1, Phi1, C, z_fine)
geo2 = RectGeo(zs, Theta2, Phi2, C, z_fine)
len_params = defaults.lensing_params.copy()
len_params['pmodel'] = 'halofit'
lenless_defaults = defaults.sw_survey_params.copy()
lenless_defaults['needs_lensing'] = False
if cosmo_fid['de_model'] == 'w0wa':
cosmo_par_list = np.array(
['ns', 'Omegamh2', 'Omegabh2', 'OmegaLh2', 'LogAs', 'w0', 'wa'])
cosmo_par_eps = np.array(
[0.002, 0.0005, 0.0001, 0.0005, 0.1, 0.01, 0.07])
elif cosmo_fid['de_model'] == 'constant_w':
cosmo_par_list = np.array(
['ns', 'Omegamh2', 'Omegabh2', 'OmegaLh2', 'LogAs', 'w'])
cosmo_par_eps = np.array([0.002, 0.0005, 0.0001, 0.0005, 0.1, 0.01])
elif cosmo_fid['de_model'] == 'jdem':
cosmo_par_list = ['ns', 'Omegamh2', 'Omegabh2', 'OmegaLh2', 'LogAs']
cosmo_par_list.extend(cp.JDEM_LIST)
cosmo_par_list = np.array(cosmo_par_list, dtype=object)
cosmo_par_eps = np.full(41, 0.5)
cosmo_par_eps[0:5] = np.array([0.002, 0.0005, 0.0001, 0.0005, 0.1])
else:
raise ValueError('not prepared to handle ' +
str(cosmo_fid['de_model']))
#note that currently (poorly implemented derivative) in jdem,
#OmegaLh2 and LogAs are both almost completely unconstrained but nondegenerate,
#while in basic, h and sigma8 are not constrained but are almost completely degenerate
nz_params = defaults.nz_params_wfirst_lens.copy()
from nz_wfirst import NZWFirst
nz_matcher = NZWFirst(nz_params)
len_params['smodel'] = 'nzmatcher'
sw_params = defaults.sw_survey_params.copy()
obs_list = defaults.sw_observable_list.copy()
survey_1 = SWSurvey(geo1, 's1', C, sw_params, cosmo_par_list,
cosmo_par_eps, obs_list, len_params, nz_matcher)
surveys_sw = np.array([survey_1])
geos = np.array([geo1, geo2])
k_cut = 0.005
basis = SphBasisK(r_max,
C,
k_cut,
defaults.basis_params.copy(),
l_ceil=100)
lw_param_list = defaults.lw_param_list.copy()
lw_observable_list = defaults.lw_observable_list.copy()
survey_3 = LWSurvey(geos,
'lw_survey1',
basis,
C,
defaults.lw_survey_params.copy(),
observable_list=lw_observable_list,
param_list=lw_param_list)
surveys_lw = np.array([survey_3])
print('main: this is r_max: ' + str(r_max))
SS = SuperSurvey(surveys_sw,
surveys_lw,
basis,
C,
defaults.prior_fisher_params.copy(),
get_a=False,
do_unmitigated=True,
do_mitigated=True,
include_sw=True)
t2 = time()
print("main: total run time " + str(t2 - t1) + " s")
mit_eigs_sw = SS.eig_set[0, 1]
no_mit_eigs_sw = SS.eig_set[0, 0]
mit_eigs_par = SS.eig_set[1, 1]
no_mit_eigs_par = SS.eig_set[1, 0]
#TODO check eigenvalue interlace for this projection
SS.print_standard_analysis()
# print("main: unmitigated sw lambda1,2: "+str(no_mit_eigs_sw[0][-1])+","+str(no_mit_eigs_sw[0][-2]))
# print("main: mitigated sw lambda1,2: "+str(mit_eigs_sw[0][-1])+","+str(mit_eigs_sw[0][-2]))
# print("main: n sw mit lambda>1.00000001: "+str(np.sum(np.abs(mit_eigs_sw[0])>1.00000001)))
# print("main: n sw no mit lambda>1.00000001: "+str(np.sum(np.abs(no_mit_eigs_sw[0])>1.00000001)))
# print("main: unmitigated par lambda1,2: "+str(no_mit_eigs_par[0][-1])+","+str(no_mit_eigs_par[0][-2]))
# print("main: mitigated par lambda1,2: "+str(mit_eigs_par[0][-1])+","+str(mit_eigs_par[0][-2]))
# print("main: n par mit lambda>1.00000001: "+str(np.sum(np.abs(mit_eigs_par[0])>1.00000001)))
# print("main: n par no mit lambda>1.00000001: "+str(np.sum(np.abs(no_mit_eigs_par[0])>1.00000001)))
v_no_mit_par = np.dot(SS.f_set_nopriors[0][2].get_cov_cholesky(),
no_mit_eigs_par[1])
v_mit_par = np.dot(SS.f_set_nopriors[0][2].get_cov_cholesky(),
mit_eigs_par[1])
v_no_mit_sw = np.dot(SS.f_set_nopriors[0][1].get_cov_cholesky(),
no_mit_eigs_sw[1])
v_mit_sw = np.dot(SS.f_set_nopriors[0][1].get_cov_cholesky(),
mit_eigs_sw[1])
test_v = True
v_test_fails = 0
if test_v:
m_mat_no_mit_par = np.identity(mit_eigs_par[0].size) + np.dot(
SS.f_set_nopriors[1][2].get_covar(),
SS.f_set_nopriors[0][2].get_fisher())
m_mat_mit_par = np.identity(mit_eigs_par[0].size) + np.dot(
SS.f_set_nopriors[2][2].get_covar(),
SS.f_set_nopriors[0][2].get_fisher())
if not np.allclose(
np.dot(m_mat_no_mit_par, v_no_mit_par) /
(1. + no_mit_eigs_par[0]), v_no_mit_par):
v_test_fails += 1
warn('some no mit eig vectors may be bad')
if not np.allclose(
np.dot(m_mat_mit_par, v_mit_par) /
(1. + mit_eigs_par[0]), v_mit_par):
v_test_fails += 1
warn('some mit eig vectors may be bad')
if v_test_fails == 0:
print("PASS: eigenvector decomposition checks passed")
else:
raise RuntimeError('FAIL: ' + str(v_test_fails) +
' eigenvector decomposition checks failed')
get_hold_mats = False
if get_hold_mats:
no_prior_hold = SS.f_set[0][2].get_fisher()
if C.de_model == 'jdem':
no_prior_project = prior_fisher.project_w0wa(
no_prior_hold, defaults.prior_fisher_params.copy(),
prior_fisher.JDEM_LABELS)
print('main: r diffs', np.diff(geo1.rs))
print('main: theta width',
(geo1.rs[1] + geo1.rs[0]) / 2. * (Theta1[1] - Theta1[0]))
print('main: phi width',
(geo1.rs[1] + geo1.rs[0]) / 2. * (Phi1[1] - Phi1[0]) * np.sin(
(Theta1[1] + Theta1[0]) / 2))
test_perturbation = True
pert_test_fails = 0
if test_perturbation:
#TOLERANCE below which an eigenvalue less than TOLERANCE*max eigenvalue is considered 0
REL_TOLERANCE = 10**-8
f0 = SS.multi_f.get_fisher(mf.f_spec_no_mit,
mf.f_return_lw)[0].get_fisher()
f1 = SS.multi_f.get_fisher(mf.f_spec_mit,
mf.f_return_lw)[0].get_fisher()
if not np.all(f0.T == f0):
pert_test_fails += 1
warn("unperturbed fisher matrix not symmetric, unacceptable")
if not np.all(f1.T == f1):
pert_test_fails += 1
warn("perturbed fisher matrix not symmetric, unacceptable")
#get eigenvalues and set numerically zero values to 0
eigf0 = np.linalg.eigh(f0)[0]
eigf0[np.abs(eigf0) < REL_TOLERANCE * np.max(np.abs(eigf0))] = 0.
eigf1 = np.linalg.eigh(f1)[0]
eigf1[np.abs(eigf1) < REL_TOLERANCE * np.max(np.abs(eigf1))] = 0.
#check positive semidefinite
if np.any(eigf0 < 0.):
pert_test_fails += 1
warn(
"unperturbed fisher matrix not positive definite within tolerance, unacceptable"
)
if np.any(eigf1 < 0.):
pert_test_fails += 1
warn(
"perturbed fisher matrix not positive definite within tolerance, unacceptable"
)
#check nondecresasing
diff_eig = eigf1 - eigf0
diff_eig[np.abs(diff_eig) < REL_TOLERANCE *
np.max(np.abs(diff_eig))] = 0
if np.any(diff_eig < 0):
pert_test_fails += 1
warn("some eigenvalues decreased within tolerance, unacceptable")
#check interlace theorem satisfied (eigenvalues cannot be reordered by more than rank of perturbation)
n_offset = SS.surveys_lw[0].get_total_rank()
rolled_eig = (eigf1[::-1][n_offset:eigf0.size] -
eigf0[::-1][0:eigf0.size - n_offset])
rolled_eig[np.abs(rolled_eig) < REL_TOLERANCE *
np.max(np.abs(rolled_eig))] = 0.
if np.any(rolled_eig > 0):
pert_test_fails += 1
warn("some eigenvalues fail interlace theorem, unacceptable")
c0 = SS.multi_f.get_fisher(mf.f_spec_no_mit,
mf.f_return_lw)[0].get_covar()
c1 = SS.multi_f.get_fisher(mf.f_spec_mit,
mf.f_return_lw)[0].get_covar()
if not np.all(c0 == c0.T):
pert_test_fails += 1
warn("unperturbed covariance not symmetric, unacceptable")
if not np.all(c1 == c1.T):
warn("perturbed covariance not symmetric, unacceptable")
eigc0 = np.linalg.eigh(c0)[0]
eigc1 = np.linalg.eigh(c1)[0]
if np.any(eigc0 < 0):
pert_test_fails += 1
warn(
"unperturbed covariance not positive semidefinite, unacceptable"
)
if np.any(eigc1 < 0):
pert_test_fails += 1
warn(
"perturbed covariance not positive semidefinite, unacceptable")
fdiff_eigc = (eigc1 - eigc0) / eigc0
fdiff_eigc[np.abs(fdiff_eigc) < REL_TOLERANCE] = 0.
if np.any(fdiff_eigc > 0):
pert_test_fails += 1
warn("some covariance eigenvalues increase, unacceptable")
if pert_test_fails == 0:
print("PASS: All fisher matrix sanity checks passed")
else:
raise RuntimeError("FAIL: " + str(pert_test_fails) +
" fisher matrix sanity checks failed")
test_eigs = True
eig_test_fails = 0
if test_eigs:
REL_TOLERANCE = 10**-8
c_ssc0 = SS.multi_f.get_fisher(
mf.f_spec_SSC_no_mit,
mf.f_return_sw)[1].get_covar() #SS.covs_sw[0].get_ssc_covar()
if not np.allclose(c_ssc0, c_ssc0.T):
eig_test_fails += 1
warn("unperturbed result covariance not symmetric, unacceptable")
c_ssc1 = SS.multi_f.get_fisher(
mf.f_spec_SSC_mit,
mf.f_return_sw)[1].get_covar() #SS.covs_sw[0].get_ssc_covar()
if not np.allclose(c_ssc1, c_ssc1.T):
eig_test_fails += 1
warn("perturbed result covariance not symmetric, unacceptable")
eigsys_ssc0 = np.linalg.eigh(c_ssc0)
eigsys_ssc1 = np.linalg.eigh(c_ssc1)
eig_ssc0 = eigsys_ssc0[0].copy()
eig_ssc1 = eigsys_ssc1[0].copy()
eig_ssc0[np.abs(eig_ssc0) < np.max(np.abs(eig_ssc0)) *
REL_TOLERANCE] = 0
eig_ssc1[np.abs(eig_ssc0) < np.max(np.abs(eig_ssc0)) *
REL_TOLERANCE] = 0
if np.any(eig_ssc0 < 0):
eig_test_fails += 1
warn(
"unperturbed result cov not positive semidefinite, unacceptable"
)
if np.any(eig_ssc1 < 0):
eig_test_fails += 1
warn(
"perturbed result cov not positive semidefinite, unacceptable")
cg = SS.f_set_nopriors[0][1].get_covar()
eigsys_cg = np.linalg.eigh(cg)
eig_mitprod = np.real(
np.linalg.eig(np.dot(np.linalg.inv(c_ssc0 + cg), c_ssc1 + cg))[0])
eig_mitprod[np.abs(eig_mitprod - 1.) < REL_TOLERANCE] = 1.
if np.any(eig_mitprod > 1):
eig_test_fails += 1
warn("mitigation making covariance worse, unacceptable")
n_offset = SS.surveys_lw[0].get_total_rank()
if np.sum(eig_mitprod < 1.) > n_offset:
eig_test_fails += 1
warn("mitigation changing too many eigenvalues, unacceptable")
eig_diff = eig_ssc1 - eig_ssc0
eig_diff[np.abs(eig_diff) < np.max(np.abs(eig_diff)) *
REL_TOLERANCE] = 0.
if np.any(eig_diff > 0):
eig_test_fails += 1
warn("mitigation making covariance worse, unacceptable")
if eig_test_fails == 0:
print("PASS: All sw eigenvalue sanity checks passed")
else:
raise RuntimeError("FAIL: " + str(pert_test_fails) +
" eigenvalue sanity checks failed")
do_eig_interlace_check = True
if do_eig_interlace_check:
eig_interlace_fails_mit = 0
eig_interlace_fails_no_mit = 0
n_sw = mit_eigs_sw[0].size
n_par = mit_eigs_par[0].size
d_n = n_sw - n_par
eig_l_mit_par = mit_eigs_par[0][::-1]
eig_l_no_mit_par = no_mit_eigs_par[0][::-1]
eig_l_mit_sw = mit_eigs_sw[0][::-1]
eig_l_no_mit_sw = no_mit_eigs_sw[0][::-1]
for i in range(0, n_par):
if eig_l_mit_par[i] > eig_l_mit_sw[i]:
eig_interlace_fails_mit += 1
if eig_l_no_mit_par[i] > eig_l_no_mit_sw[i]:
eig_interlace_fails_no_mit += 1
if eig_l_mit_par[i] < eig_l_mit_sw[i + d_n]:
eig_interlace_fails_mit += 1
if eig_l_no_mit_par[i] < eig_l_no_mit_sw[i + d_n]:
eig_interlace_fails_no_mit += 1
if eig_interlace_fails_mit == 0 and eig_interlace_fails_no_mit == 0:
print("PASS: All parameter eigenvalue interlace tests passed")
else:
raise RuntimeError(
"FAIL: " + str(eig_interlace_fails_mit) +
" mitigation and " + str(eig_interlace_fails_no_mit) +
" no mitigation failures in parameter eigenvalue interlace tests"
)