def get_fisher(self, initial_state=fm.REP_COVAR, silent=True):
"""Get FisherMatrix object for the covariance matrix computed by the basis."""
if initial_state == fm.REP_FISHER:
return fm.FisherMatrix(self.get_fisher_array(),
input_type=fm.REP_FISHER,
initial_state=fm.REP_FISHER,
silent=silent)
elif initial_state == fm.REP_COVAR:
return fm.FisherMatrix(self.get_covar_array(),
input_type=fm.REP_COVAR,
initial_state=fm.REP_COVAR,
silent=silent)
elif initial_state == fm.REP_CHOL:
return fm.FisherMatrix(self.get_cov_cholesky_array(),
input_type=fm.REP_CHOL,
initial_state=fm.REP_CHOL,
silent=silent)
else:
return fm.FisherMatrix(self.get_covar_array(),
input_type=fm.REP_COVAR,
initial_state=initial_state,
silent=silent)
def fisher_params(request, fisher_input):
"""iterate thorugh fisher matrix starting params and fisher matrices"""
if request.param[0] == fm.REP_FISHER:
internal_mat = fisher_input.fab.copy('F')
elif request.param[0] == fm.REP_COVAR:
internal_mat = fisher_input.cov.copy('F')
elif request.param[0] == fm.REP_CHOL:
internal_mat = fisher_input.chol_cov.copy('F')
elif request.param[0] == fm.REP_CHOL_INV:
internal_mat = fisher_input.chol_cov_i.copy('F')
fisher = fm.FisherMatrix(internal_mat,
input_type=request.param[0],
initial_state=request.param[1])
return FisherWithManual(fisher_input, fisher)
def get_sw_fisher(self, f_spec, fisher_from_lw):
""" helper for get_fisher, get a sw fisher with given projected lw matrix
with or without gaussian and nongaussian components"""
if fisher_from_lw is None:
if f_spec['sw_g'] or f_spec['sw_ng']:
sw_result = fm.FisherMatrix(np.zeros((self.n_sw, self.n_sw)),
fm.REP_COVAR,
silent=True)
else:
return None
else:
sw_result = copy.deepcopy(fisher_from_lw)
if f_spec['sw_g']:
sw_result.add_covar(self.sw_g_covar)
if f_spec['sw_ng']:
sw_result.add_covar(self.sw_ng_covar)
return sw_result
def __init__(self, de_model, params, fisher_in=None, labels_in=None):
""" de_model: 'jdem','constant_w','w0wa',or 'none'
params:
row_strip: indexes of rows to remove from source file
fisher_source: source file
n_full: how many total params there are
n_row: how many de params there are
z_step: z spacing of de params for jdem
fisher_in: if not None, use this matrix instead of reading from file
labels_in: array of labels for the axis elements"""
self.params = params
self.de_model = de_model
#read in matrix
if fisher_in is None:
self.unprocessed_mat = read_prior_fisher(self.params)
self.unprocessed_labels = JDEM_LABELS
else:
self.unprocessed_mat = fisher_in
if labels_in is None:
raise ValueError('labels_in must be set if fisher_in is set')
self.unprocessed_labels = labels_in
#strip unwanted rows
self.stripped_mat, self.stripped_labels = fix_elements(
self.unprocessed_mat, params, self.unprocessed_labels)
#project to correct de model
if de_model == 'jdem':
self.processed_mat = self.stripped_mat
self.processed_labels = self.stripped_labels.copy()
elif de_model == 'constant_w':
self.processed_mat, self.processed_labels = project_w0(
self.stripped_mat, params, self.stripped_labels)
elif de_model == 'w0wa':
self.processed_mat, self.processed_labels = project_w0wa(
self.stripped_mat, params, self.stripped_labels)
elif de_model == 'none':
self.processed_mat, self.processed_labels = project_no_de(
self.stripped_mat, params, self.stripped_labels)
else:
raise ValueError('unrecognized de_model ' + str(de_model))
self.fisher_matrix = fm.FisherMatrix(self.processed_mat,
input_type=fm.REP_FISHER,
initial_state=fm.REP_FISHER,
fix_input=True)
f_set_lihu = np.zeros(3, dtype=object)
f_set_mat_jdem1 = np.zeros(3, dtype=object)
for i in range(0, 3):
f_set_mat_jdem1[i] = f_set[i][2].get_fisher()
f_set_lihu_prior[i] = np.zeros(3, dtype=object)
f_set_lihu[i] = np.zeros(3, dtype=object)
f_set_jdem_prior[i] = np.zeros(3, dtype=object)
C = CosmoPie(cosmo.copy(), 'jdem')
f_set_mat_lihu1 = rotate_jdem_to_lihu(deepcopy(f_set_mat_jdem1), C)
f_set_mat_lihu_h_prior = deepcopy(f_set_mat_lihu1)
f_set_mat_lihu_h_prior[0][3, 3] += 1.e4
f_set_mat_lihu_h_prior[1][3, 3] += 1.e4
f_set_mat_lihu_h_prior[2][3, 3] += 1.e4
f_set_mat_jdem_h_prior = deepcopy(
rotate_lihu_to_jdem(f_set_mat_lihu_h_prior, C))
for i in range(0, 3):
f_set_lihu_prior[i][2] = fm.FisherMatrix(f_set_mat_lihu_h_prior[i],
fm.REP_FISHER)
f_set_lihu[i][2] = fm.FisherMatrix(f_set_mat_lihu1[i], fm.REP_FISHER)
f_set_jdem_prior[i][2] = fm.FisherMatrix(f_set_mat_jdem_h_prior[i],
fm.REP_FISHER)
fig3 = make_standard_ellipse_plot(f_set_jdem_prior,
cosmo_par_list,
fontsize=12,
labelsize=6,
fontsize_legend=10,
left_space=0.08,
bottom_space=0.06)
plt.show(fig3)
def __init__(self,
basis,
sw_survey,
lw_surveys,
prior_params,
needs_a=False,
do_mit=True):
"""
master class for managing fisher matrix manipulations between bases
inputs:
basis: an LWBasis object
sw_survey: an SWSurvey object
lw_surveys: a list of LWSurvey objects to be combined into mitigation strategy
prior_params: params for the prior fisher matrix to use in cosmological parameter space
"""
print("MultiFisher: began initialization")
self.basis = basis
self.sw_survey = sw_survey
self.lw_surveys = lw_surveys
self.prior_params = prior_params
self.needs_a = needs_a
self.do_mit = do_mit
#prepare to project lw basis to sw basis
self.n_sw = self.sw_survey.get_total_dimension()
self.lw_F_no_mit = None
self.lw_F_mit = None
self.lw_to_sw_array = None
print("MultiFisher: getting projection matrices")
self.lw_to_sw_array = self.get_lw_to_sw_array()
self.sw_to_par_array = sw_survey.get_dO_I_dpar_array()
#TODO eliminate from main loop
if self.needs_a:
print("MultiFisher: getting lw no mit variance")
self.a_vals = np.zeros(2, dtype=object)
self.lw_F_no_mit = self.get_lw_fisher(f_spec_SSC_no_mit,
initial_state=fm.REP_CHOL)
self.project_lw_a = self.basis.get_ddelta_bar_ddelta_alpha(
self.sw_survey.geo, tomography=True)
self.a_vals[0] = self.lw_F_no_mit.project_covar(
self.project_lw_a.T, destructive=True).get_covar()
self.lw_F_no_mit = None
else:
self.a_vals = None
self.project_lw_a = None
#self.lw_F_no_mit = self.get_lw_fisher(f_spec_SSC_no_mit,initial_state=fm.REP_CHOL)
print("MultiFisher: projecting lw no mit covariance")
#self.sw_f_ssc_no_mit = self.lw_F_no_mit.project_covar(self.get_lw_to_sw_array(),destructive=False)
vs_perturb, sigma2s_perturb = self.lw_surveys[0].observables[
0].get_perturbing_vector()
sw_cov_ssc, sw_cov_ssc_mit = self.basis.perturb_and_project_covar(
vs_perturb, self.get_lw_to_sw_array(), sigma2s_perturb)
self.sw_f_ssc_no_mit = fm.FisherMatrix(sw_cov_ssc, fm.REP_COVAR,
fm.REP_COVAR)
self.sw_f_ssc_mit = fm.FisherMatrix(sw_cov_ssc_mit, fm.REP_COVAR,
fm.REP_COVAR)
sw_cov_ssc = None
sw_cov_ssc_mit = None
vs_perturb = None
sigma2s_perturb = None
#self.sw_f_ssc_mit2 = fm.FisherMatrix(self.basis.perturb_and_project_covar(vs_perturb,self.get_lw_to_sw_array(),sigma2s_perturb),fm.REP_COVAR,fm.REP_COVAR)
#self.lw_F_no_mit = None
if do_mit:
print("MultiFisher: getting lw mit covariance")
#self.lw_F_mit = self.get_lw_fisher(f_spec_SSC_mit,initial_state=fm.REP_FISHER)
#self.lw_F_mit = self.get_lw_fisher(f_spec_SSC_mit,initial_state=fm.REP_COVAR)
if self.needs_a:
print("MultiFisher: getting lw mit variance ")
self.a_vals[1] = self.lw_F_mit.project_covar(
self.project_lw_a.T).get_covar()
print("MultiFisher: projecting lw mit covariance")
#self.sw_f_ssc_mit = self.lw_F_mit.project_covar(self.get_lw_to_sw_array(),destructive=False)
#self.lw_F_mit = None
else:
self.sw_f_ssc_mit = None
#accumulate lw covariances onto fisher_tot
#for i in range(0,self.lw_surveys.size):
# self.lw_surveys[i].fisher_accumulate(self.lw_F_mit)
#self.lw_F_mit.switch_rep(fm.REP_CHOL_INV)
#self.lw_F_no_mit.switch_rep(fm.REP_CHOL_INV)
#self.lw_F_mit = None
self.lw_to_sw_array = None
#sw covariances to add
print("MultiFisher: getting sw covariance matrices")
self.sw_non_SSC_covars = self.sw_survey.get_non_SSC_sw_covar_arrays()
self.sw_g_covar = fm.FisherMatrix(self.sw_non_SSC_covars[0],
fm.REP_COVAR,
fm.REP_COVAR,
silent=True)
self.sw_ng_covar = fm.FisherMatrix(self.sw_non_SSC_covars[1],
fm.REP_COVAR,
fm.REP_COVAR,
silent=True)
if self.sw_survey.C.p_space == 'jdem':
self.fisher_prior_obj = prior_fisher.PriorFisher(
self.sw_survey.C.de_model, self.prior_params)
self.fisher_priors = self.fisher_prior_obj.get_fisher()
else:
warn('Current priors do not support p_space ' +
str(self.sw_survey.C.p_space) + ', defaulting to 0 priors')
self.fisher_prior_obj = None
self.fisher_priors = fm.FisherMatrix(np.zeros(
(self.sw_to_par_array.shape[1],
self.sw_to_par_array.shape[1])),
fm.REP_FISHER,
fm.REP_FISHER,
silent=True)
print("MultiFisher: finished initialization")
def test_get_eig_metric_rand(fisher_params):
"""test get_cov_eig_metric"""
cov = fisher_params.fisher_input.cov.copy()
fisher = copy.deepcopy(fisher_params.fisher)
metric_mat = np.random.rand(cov.shape[0], cov.shape[1])
metric_mat = np.dot(metric_mat.T, metric_mat)
metric_mat_inv = np.linalg.pinv(metric_mat)
metric = fm.FisherMatrix(metric_mat,
input_type=fm.REP_COVAR,
initial_state=fm.REP_COVAR)
eigs_1 = fisher.get_cov_eig_metric(metric)
atol_loc = np.max(np.abs(eigs_1[0] - 1.)) * atol_rel_use
m_mat = np.dot(cov, metric_mat_inv)
eigs_3 = spl.eig(m_mat)
#check matrix is positive semidefinite
assert np.all(eigs_3[0] > 0.)
assert np.all(np.abs(np.imag(eigs_3[0] - 1.))[::-1] < atol_loc)
#check eigenvalues match
assert np.allclose(np.sort(eigs_1[0] - 1.),
np.sort(np.real(eigs_3[0] - 1.)),
atol=atol_loc,
rtol=rtol_use)
chol_metric = spl.cholesky(metric_mat, lower=True)
chol_inv_metric = npl.pinv(chol_metric)
alt_mat = np.dot(chol_inv_metric, np.dot(cov, chol_inv_metric.T))
#u vectors
eigvs_4 = np.dot(chol_inv_metric, eigs_3[1])
#v vectors
eigvs_5 = np.dot(chol_metric, eigs_1[1])
#check eigenvalues work
assert np.allclose(np.dot(m_mat, eigs_3[1]),
eigs_3[0] * eigs_3[1],
atol=atol_loc,
rtol=rtol_use)
assert np.allclose(np.dot(alt_mat, eigs_1[1]),
eigs_1[0] * eigs_1[1],
atol=atol_loc,
rtol=rtol_use)
assert np.allclose(np.identity(cov.shape[0]),
np.dot(eigs_1[1].T, eigs_1[1]),
atol=atol_loc,
rtol=rtol_use)
p_mat0 = np.dot(eigs_3[1].T, np.dot(metric_mat_inv, eigs_3[1]))
p_mat0_use = p_mat0 - np.diag(np.diag(p_mat0))
assert np.allclose(np.zeros(cov.shape),
p_mat0_use,
atol=atol_loc,
rtol=rtol_use)
#check cholesky transforms eigenvalues as expected
p_mat1 = np.dot(eigvs_4.T, eigvs_4)
p_mat1_use = p_mat1 - np.diag(np.diag(p_mat1))
assert np.allclose(np.zeros(cov.shape),
p_mat1_use,
atol=atol_loc,
rtol=rtol_use)
assert np.allclose(np.dot(alt_mat, eigvs_4), (eigs_3[0] * eigvs_4),
atol=atol_loc,
rtol=rtol_use)
p_mat2 = np.dot(eigvs_5.T, np.dot(metric_mat_inv, eigvs_5))
p_mat2_use = p_mat2 - np.diag(np.diag(p_mat2))
assert np.allclose(np.zeros(cov.shape),
p_mat2_use,
atol=atol_loc,
rtol=rtol_use)
assert np.allclose(np.dot(m_mat, eigvs_5),
eigs_1[0] * eigvs_5,
atol=atol_loc,
rtol=rtol_use)
#test eig product matches identity
eigs_1_prod = np.product(eigs_1[0])
eigs_1_prod_true = np.linalg.det(cov) / np.linalg.det(metric_mat)
assert np.isclose(eigs_1_prod, eigs_1_prod_true)
def get_fisher(self):
"""get the fisher matrix, cholesky is sqrt"""
Nab_f = fm.FisherMatrix(np.diagflat(np.sqrt(self.Nab_i)),
input_type=fm.REP_CHOL_INV)
return Nab_f.project_fisher(self.vs)