def select(self, dataset):
if dataset.shape != self.dataset_shape:
raise ValueError("shape mismatch (wrong factory)")
if not dataset.shape:
sink = dataset[...]
sink = np.empty(shape=self.sink_shape, dtype=dataset.dtype)
if debug: sink[...] = -47119999
for ssel, dsel in zip(iter_product(*self.sink_selectors),
iter_product(*self.source_selectors)):
sink[ssel] = dataset[dsel]
return DatasetSelection(self.sink_axes, sink)
def unfold_settings(exp_config):
'''
Unfold a command and get all possible
settings. Returned as an Iterable.
The possible settings are generated by taking
a Cartesian product over list fields of the command
Note: for `ratio` command, the `memory_budget` is calculated here in order to
avoid multiple runs of baseline trial
'''
setting_heading = list()
list_fields = list()
for (k, v) in exp_config.items():
if isinstance(v, list):
setting_heading.append(k)
list_fields.append(v)
if not list_fields:
yield exp_config
else:
for combo in iter_product(*list_fields):
# necessary to copy each time
# since the old data might be used later
result = exp_config.copy()
for i in range(len(list_fields)):
result[setting_heading[i]] = combo[i]
if result.get('kind') == 'ratio':
result['memory_budget'] *= result['ratio']
yield result
def dump_image_batch(X, file_name, max_size = 10, figsize = (10, 10)):
from itertools import product as iter_product
nrows = max_size
ncols = nrows
if 1 == 1:
if 1 == 1:
if 1 == 1:
shape = X.shape
figs, axes = plt.subplots(nrows, ncols, figsize = figsize,
squeeze = False)
for ax in axes.flatten():
ax.set_xticks([])
ax.set_yticks([])
ax.axis('off')
for i, (r, c) in enumerate(iter_product(range(nrows), range(ncols))):
if i >= shape[0]:
break
img = X[i].transpose((1, 2, 0))
axes[r, c].imshow(img, interpolation = 'none')
plt.savefig(os.path.join('', file_name))
#plt.cla()
plt.clf()
plt.close()
def parse_options(self, response):
product = response.meta['product']
options_found = 0
try:
ajax_url = response.meta['options_url']
data = json.loads(response.body)
options = iter_product(
*(map(lambda d: dict(attr_id=attr['id'], **d), attr['values'])
for attr in data.get('attributes', [])
if not attr['disabled']))
for options_selected in options:
new_product = Product(product)
for option in options_selected:
options_found += 1
opt_id = 'attributes[%s]' % option['attr_id']
opt_value_id = option['value_id']
# new_product['identifier'] += ':' + opt_value_id
new_product['name'] += ' ' + option['value']
ajax_url = add_or_replace_parameter(
ajax_url, opt_id, opt_value_id)
meta = response.meta.copy()
meta['product'] = new_product
yield Request(ajax_url,
callback=self.parse_options_prices,
meta=meta)
except Exception, e:
self.log('NO OPTIONS WARNING => %r' % e)
yield product
def solve_vibration_modes(self, num=20):
"""
Find the 'num' lowest generalized eigenvalues, along with eigenvectors. \n
Aₕu = ω²Mₕu
"""
if self.A_h is None:
self.generate_A_h()
if self.M_h is None:
self.generate_M_h()
eigvals_small, eigvecs_small = spla.eigsh(A=self.A_h, M=self.M_h,
k=num, which="LM", sigma=0.0)
self.num_eigenpairs = num
self.vibration_frequencies = eigvals_small
# List of the displacement eigenvectors for each eigenvalue:
self.vibration_eigenvectors = []
num_dof = int(self.num_nodes - len(self.dirichlet_BC_basis_functions)//2)
for k in range(num):
displacement_vec = np.zeros((num_dof, 2))
# Eigenvectors stored column-wise:
vibration_eigenvec = eigvecs_small[:, k]
for n, d in iter_product(range(num_dof), (0, 1)):
displacement_vec[n, d] = vibration_eigenvec[2*n + d]
self.vibration_eigenvectors.append(displacement_vec)
print("Done solving for eigenmodes!")
def generate_F_h(self):
"""
Generate the source vector. Sum over elements and add contributions from each basis function.
"""
# Source function f([x, y]) must be callable.
assert(callable(self.f))
# Making the full Source vector:
self.F_h = np.zeros(self.num_basis_functions)
# Reference triangle nodes:
eta1, eta2, eta3 = self.reference_triangle_nodes
T = self.reference_to_global_transformation
for k, element in enumerate(self.triang):
J_k = self.generate_jacobian(k)
det_J_k = la.det(J_k)
# Loop through nodes in each element and two components per node:
for (i, node), d in iter_product(enumerate(element), (0, 1)):
# print(f"i: {i}, d: {d}\tnode: {node}")
global_index = 2*node + d
# Integrand. ϕ_i_d^T⋅f([x, y]) = [(1-d)*ϕ_i, d*ϕ_i]^T⋅[f_1(x, y), f_2(x, y)]
# = ((1 - d)*f_1(x, y) + d*f_2(x, y))*ϕ_i(x, y)
integrand = lambda eta: self.f(T(eta, k, J_k))[d]*self.basis_functions[i](eta)
# Add contribution from basis function component d. Integrate over reference triangle.
self.F_h[global_index] += det_J_k*quadrature2D(integrand, eta1, eta2, eta3, self.quad_points)
# Reshape F_h to a column vector:
self.F_h = self.F_h.reshape(len(self.F_h), 1)
def state_to_array(dimensions: Tuple[int, ...], state: int):
arr = np.ndarray(dimensions, np.bool)
for coords in iter_product(*map(range, dimensions)):
arr[(*coords, )] = bool(state >> sum(c * product(*dimensions[:j])
for j, c in enumerate(coords))
& 1)
return arr
def plot_weights(W, plot_name, file_path = '.',
max_subplots = 100, max_figures = 64,
figsize = (28, 28)):
try:
W = W.get_value(borrow = True)
except:
W=W
''' W=np.reshape(W,(2,5,5,32))
W=np.swapaxes(W,0,3)
W=np.swapaxes(W,3,1)
W=np.swapaxes(W,2,3)'''
#W = W/4
shape = W.shape
assert((len(shape) == 2) or (len(shape) == 4))
max_val = np.max(W)
min_val = np.min(W)
if len(shape) == 2:
plt.figure(figsize = figsize)
plt.imshow(W, cmap = 'gray',#'jet',
vmax = max_val, vmin = min_val,
interpolation = 'none')
plt.axis('off')
plt.colorbar()
file_name = plot_name + '.png'
plt.savefig(os.path.join(file_path, file_name))
plt.clf()
plt.close()
return
nrows = min(np.ceil(np.sqrt(shape[1])).astype(int),
np.floor(np.sqrt(max_subplots)).astype(int))
ncols = nrows
'''
max_val = -np.inf
min_val = np.inf
for i in range(shape[0]):
tmp = np.mean(W[i], axis = 0)
max_val = max(max_val, np.max(tmp))
min_val = min(min_val, np.min(tmp))
'''
for j in range(min(shape[0], max_figures)):
figs, axes = plt.subplots(nrows, ncols, figsize = figsize,
squeeze = False)
for ax in axes.flatten():
ax.set_xticks([])
ax.set_yticks([])
ax.axis('off')
for i, (r, c) in enumerate(iter_product(range(nrows), range(ncols))):
if i >= shape[1]:
break
im = axes[r, c].imshow(W[j, i], cmap = 'Greens',#'jet',
vmax = max_val, vmin = min_val,
interpolation = 'none')
figs.colorbar(im, ax = axes.ravel().tolist())
file_name = plot_name + '_fmap' + str(j) + '.png'
plt.savefig(os.path.join(file_path, file_name))
plt.clf()
plt.close()
return
def ksgrid(self, ksgrid: np.ndarray):
self._ksgrid = ksgrid
p_range = self.params['kwargs']['npartitions_range']
kga_inertia = np.zeros(self.ksgrid.shape, dtype=np.float64)
for ij in iter_product(range(self.ksgrid.shape[0]),
range(self.ksgrid.shape[1])):
if self.n_clusters_out[ij] < self.ksgrid[ij].n_clusters:
kga_inertia[ij] = np.nan
else:
kga_inertia[ij] = self.ksgrid[ij].inertia_
self.kga_inertia_heatmap.set(kga_inertia,
ylabels=list(range(*p_range)),
cmap=self.kga_inertia_heatmap_cmap,
annot=False)
ixs_lowest = np.dstack(
np.unravel_index(np.argsort(kga_inertia.ravel()),
kga_inertia.shape))[0]
ixs_lowest[:, 0] += self.params['kwargs']['npartitions_range'][0]
self.inertia_sorted = pd.DataFrame.from_dict({
'n_clusters':
ixs_lowest[:, 0],
'trial':
ixs_lowest[:, 1]
})
self.kga_inertia_heatmap.show()
def gif(
iterations: int,
dimensions: Tuple[int, ...],
scaling: int,
path: str,
simulation: Iterator[int],
tpf: int = 50,
loop: bool = True,
**kwargs,
):
imgs = []
width, height = dimensions
for state in simulation:
img = Image.new("RGB", dimensions, (255, 255, 255))
data = img.load()
for x, y in iter_product(range(width), range(height)):
if state >> y * width + x & 1:
data[x, y] = (0, 0, 0)
imgs.append(
img.resize((scaling * width, scaling * height), Image.NEAREST))
imgs[0].save(
path,
format="GIF",
save_all=True,
append_images=imgs[1:],
duration=tpf,
loop=int(not loop),
)
def expand_parameters(arg_vals):
'''
Given a list of args and values
return a list of tuples
containing all possible sequences
of length n.
'''
arg_tuples = dict_to_tuples(arg_vals)
return [dict(args) for args in iter_product(*arg_tuples)]
def cosine_similarity_overlap(v1, v2):
intersect = len(v1 & v2)
for w1, w2 in iter_product(list(v1), list(v2)):
if (w1 in w2 or w2 in w1) and w1 != w2:
intersect += 0.5
if intersect > 0:
return intersect * 1. / np.sqrt(len(v1) * len(v2))
else:
return 0.
def get_gram_ratio(w2v, text1, text2, n_grams_1=1, n_grams_2=1, n_jobs=1):
t1 = list(ngrams(text1.split(), n_grams_1))
t2 = list(ngrams(text2.split(), n_grams_2))
pairs = list(iter_product(t1, t2, repeat=1))
res = list(map(lambda x: similarity(w2v, x), pairs))
if len(res) == 0:
return 0
else:
return np.mean(res)
def normalize(ring, f, kappa=None):
"If kappa is not set, normalize by the sum of values in the domain."
if kappa == None:
kappa = ring.zero
for args in iter_product(*[var.var_domain for var in f.domain]):
kappa = ring.add(kappa, f(*args))
def normalized(*args):
return ring.invmul(f(*args), kappa)
return Factor(normalized, f.domain)
def expand_parameters(arg_vals):
'''
Given a list of args and values
return a list of tuples
containing all possible sequences
of length n.
'''
arg_tuples = dict_to_tuples(arg_vals)
return [dict(args) for args in iter_product(*arg_tuples)]
def count_worker(dimensions, slice_sizes, neighborhood_radius, b, s, state, i):
return (b * (~state >> i & 1) + s * (state >> i & 1) >> sum(
state >> sum(
(i // slice_sizes[j] + offset) % dimensions[j] * slice_sizes[j]
for j, offset in enumerate(offsets))
& any(offset != 0 for offset in offsets) for offsets in iter_product(
*(range(-neighborhood_radius, neighborhood_radius + 1)
for _ in dimensions)))
& 1) << i
def pattern_worker(dimensions, slice_sizes, neighborhood_radius, patterns,
state, i):
return (patterns[sum(
(state >> sum(
(i // slice_sizes[k] + offset) % dimensions[k] * slice_sizes[k]
for k, offset in enumerate(offsets))
& 1) << j
for j, offsets in enumerate(
iter_product(*(range(-neighborhood_radius, neighborhood_radius + 1)
for _ in dimensions))))] << i)
def make_sample_index_iterator_maker(n, steps, r):
"""
Make a generator of iterators that iterate over n-uples of integers
that parametrize certain complex numbers on the unit circle with a
given number of steps on a semicircle.
"""
indr1 = range(1, steps + 1)
indr2 = range(-steps + 1, 0)
if r is None:
return lambda: iter_product(
indr1,
*[iter_chain(indr1, indr2) for _ in range(1, n)]
)
else:
if n == 1:
return lambda: iter(indr1)
else:
if r % n:
rr = [r, -r]
else:
rr = [r]
def make_2ind_iterator():
for i1 in indr1:
for m in rr:
i2 = (m - i1 + n - 1) % (2*n) - n + 1
yield (i1, i2)
if n == 2:
return make_2ind_iterator
elif n >= 3:
return lambda: map(
_splice_first,
iter_product( make_2ind_iterator(),
*[ iter_chain(indr1, indr2)
for _ in range(2, n) ] )
)
def __repr__(self):
table = [( ("(" + ", ".join([x.name for x in self.domain]) + ")", "value") )]
for args in iter_product(*[var.var_domain for var in self.domain]):
table.append( (str(args), str(self(*args))) )
arg_len = max([len(x[0]) for x in table])
val_len = max([len(x[1]) for x in table])
s = [table[0][0].ljust(arg_len) + " " + table[0][1]]
s.append(("-" * arg_len) + " " + ("-" * val_len))
for i in range(1,len(table)):
s.append(table[i][0].ljust(arg_len) + " " + table[i][1])
return '\n'.join(s)
def _compute_for_index_combinations(self, set_one, set_two):
"""
Computes value of kernel matrix for all combinations of given set of indices
"""
return np.array([
self._eval_kernel(idx_one, idx_two)
for idx_one, idx_two in iter_product(set_one, set_two)
],
dtype=self._sample.dtype).reshape(
len(set_one), len(set_two))
def affine_tryout(invM, pts_src, pts_dst, triangle_dst):
'''
Brute force for finding correct affine mapping
Biggest triangle maps to biggest triangle (what a Sherlock)
'''
n_pts = pts_src.shape[0]
pts_src_ext = np.hstack((pts_src, np.ones((n_pts, 1))))
pts_dst_ext = np.hstack((pts_dst, np.ones((n_pts, 1))))
# trying all combinations (some of them are invalid)
for (p0, p1), p2 in iter_product(iter_product(triangle_dst, triangle_dst),
triangle_dst):
N = find_affine(np.vstack((p0, p1, p2)))
# determinant of affine mapping has to be regular
if np.linalg.matrix_rank(N) == 3:
P = np.matmul(N, invM)
pts_src_mapped = np.matmul(P, pts_src_ext.T).T
valid, mapping = is_affine_valid(pts_src_mapped, pts_dst_ext)
if valid:
return P, mapping
return None, None
def generate_M_ref(self):
# 36 interactions.
M_ref = np.zeros((6, 6), dtype=float)
local_indices = (0, 1, 2)
d_pairs = ((0, 0), (0, 1), (1, 0), (1, 1))
for i, j, (d_i, d_j) in iter_product(local_indices, local_indices, d_pairs):
row, col = 2*i + d_i, 2*j + d_j
# Calculate the mass matrix on the reference element: det_J_k = 1.0
M_ref[row, col] = self.M_i_j(i, j, d_i, d_j, det_J_k=1.0)
return M_ref
def build_iterator(**kwargs):
parsers = {
'modes': parse_mode_pattern,
'days': parse_day_pattern,
'intervals': parse_time_intervals
}
iterables = []
for category, pattern in kwargs.items():
iterables.append(parsers[category](pattern))
return iter_product(*iterables)
def marginalize(ring, f, retain):
"Marginalize according to the addition operator of the ring."
bitmask = [var.name in retain for var in f.domain]
results = {}
for args in iter_product(*[var.var_domain for var in f.domain]):
reduced_args = tuple(compress(args,bitmask))
if reduced_args in results:
results[reduced_args] = ring.add(results[reduced_args], f(*args))
else:
results[reduced_args] = f(*args)
def marginalized(*args):
return results[args]
return Factor(marginalized, [var for var in f.domain if var.name in retain])
def MultiIndex_from_product_indices(indices):
"""Create MultiIndex from cartesian product of (Multi)Indices
Parameters
----------
indices: subclass of pandas.Index
Returns
-------
idx: pandas.MultiIndex
"""
names = np.concatenate(idx.names for idx in indices)
values = iter_product(indices)
return pd.MultiIndex.from_tuples(values, names=names)
def join(ring, f1, f2):
"Join two factors using the ring's multiplication operator."
f1_names = [var.name for var in f1.domain]
new_domain = f1.domain + [var for var in f2.domain if var.name not in f1_names]
new_names = [var.name for var in new_domain]
arg_pos2 = [new_names.index(var.name) for var in f2.domain]
results = {}
for args in iter_product(*[var.var_domain for var in new_domain]):
args1 = args[:len(f1_names)]
args2 = [args[x] for x in arg_pos2]
results[args] = ring.mul(f1(*args1), f2(*args2))
def merged(*args):
return results[args]
return Factor(merged, new_domain)
def join(self, args: List[Any]) -> Union[List[str], str]:
# expand everything that isn't a string to a list
args = [[item] if isinstance(item, str) else list(item)
for item in args]
# combine items into list corresponding to cartesian product
res = [''.join(flat_args) for flat_args in iter_product(*args)]
if len(res) > 1:
return res
if res:
return res[0]
return ''
def default_get(self, var_fields):
template = self.env['product.template'].browse(
self.env.context['active_id'])
values = iter_product(
*map(lambda x: x.value_ids.ids, template.attribute_line_ids))
val_list = list(values)
products = template.product_variant_ids
lines = []
for vals in val_list:
line_vals = {
'attributes': [(6, 0, list(vals))],
'product': self._product_by_variants(vals, products),
}
line_vals['old_product'] = line_vals['product']
lines.append((0, 0, line_vals))
return {'products': lines}
def default_get(self, var_fields):
template = self.env['product.template'].browse(
self.env.context['active_id'])
values = iter_product(*map(lambda x: x.value_ids.ids,
template.attribute_line_ids))
val_list = list(values)
products = template.product_variant_ids
lines = []
for vals in val_list:
line_vals = {
'values': [(6, 0, list(vals))],
'product': self._product_by_variants(vals, products),
}
line_vals['old_product'] = line_vals['product']
lines.append((0, 0, line_vals))
return {'products': lines}
def generate_axes(axes, count):
""" Returns an array of strings ['XX', 'XZ',...]
It splits up the individual characters of axes and permutates count times
So ('XY', 2) returns XX, XY, YX, YY.
Keyword arguments:
axis -- a string of any combination of X, Y, Z -- 'XY', 'XYZ'
count -- the number to permutate over.
Returns a string count characters long.
"""
array_axes = []
all_axes = iter_product(axes, repeat=count)
for b in all_axes:
array_axes.append(''.join(str(i) for i in b))
return array_axes
def set_plots(self, tuning_curves: Dict[str, np.ndarray],
y_units: List[str]):
"""
Set the subplots
:param input_arrays: padded input arrays (2D), shape is [num_samples, padded_peak_curve_length]
:param n_clusters: number of clusters
:param y_pred: cluster predictions (labels)
:param xzero_pos: set the zero position as the 'zero' position of the input array or the 'maxima' of the input array
:param error_band: Type of error band to show, one of either 'ci' or 'std'
"""
self.clear()
stim_types = list(tuning_curves.keys())
if len(stim_types) == 1:
self.ncols = 1
elif len(stim_types) < 5:
self.ncols = 2
else:
self.ncols = 3
self.nrows = ceil(len(tuning_curves.keys()) / self.ncols)
self.axs = self.fig.subplots(self.nrows, self.ncols)
self.fig.tight_layout()
for i, plot_ix in enumerate(
iter_product(range(self.nrows), range(self.ncols))):
if not i < len(stim_types):
break
stim_type = stim_types[i]
data = tuning_curves[stim_type]
if len(stim_types) == 1:
plot = self.axs
else:
plot = self.axs[plot_ix]
plot.plot(data[0], data[1], c='k')
plot.set_xlabel(stim_type)
plot.set_ylabel(f"{y_units} response")
self.draw()
def generate_nodes(self):
print("Generating nodes.")
# X-direction
print("Searching toward x-direction.")
Nx = self.find_node_candidates(self.T_x, self.x_bounds,
self.source.llx, self.source.urx)
for n in Nx:
print(n)
print("")
# Y-direction
print("Searching toward y-direction.")
Ny = self.find_node_candidates(self.T_y, self.y_bounds,
self.source.lly, self.source.ury)
for n in Ny:
print(n)
print("")
# Final node set
self.nodes = NodeSet()
remaining = set(self.sinks)
for nx, ny in iter_product(Nx, Ny):
sinks_nx = nx.sink_set
sinks_ny = ny.sink_set
sinks_new = sinks_nx.intersection(sinks_ny)
# if sinks_new in [sinks_nx, sinks_ny]:
if len(sinks_new) > 0:
node_new = Node(sinks_new)
self.nodes.add(node_new)
remaining = remaining - sinks_new
# Update movable region for each node
[n.update_movable_region(self.source) for n in self.nodes]
print("%d nodes are found (N^2=%d).\n" \
% (len(self.nodes), len(self.sinks)**2))
# if __debug__:
print("All the generated nodes:")
[print("\t%d : %s" % (i + 1, n)) for i, n in enumerate(self.nodes)]
def import_from_imagej(self, path: str):
"""
Uses read-roi package created by Hadrien Mary.
https://pypi.org/project/read-roi/
:param path: Full path to the ImageJ ROIs zip file
"""
ij_roi = read_imagej(path)
for k in ij_roi.keys():
if ij_roi[k]['type'] in ('oval', 'rectangle'):
width = ij_roi[k]['width']
height = ij_roi[k]['height']
left = ij_roi[k]['left']
top = ij_roi[k]['top']
if ij_roi[k]['type'] == 'oval':
x_bottom = left
y_bottom = top + height
ps = [x_bottom, y_bottom, width, height]
roi = ManualROI.from_ellipse(
positions=ps,
curve_plot_item=self.get_plot_item(),
view_box=self.vi.viewer.getView())
else:
ps = list(
iter_product((left, left + width),
(top, top + height)))
ps[2], ps[3] = ps[3], ps[
2] #swap coordinates so it draws coordinates in sequence
elif (ij_roi[k]['type'] == 'freehand'):
#freehand ROIs have large number of datapoints, so reducing it by a fifth
xs = ij_roi[k]['x'][::5]
ys = ij_roi[k]['y'][::5]
ps = list(zip(xs, ys))
else:
xs = ij_roi[k]['x']
ys = ij_roi[k]['y']
ps = list(zip(xs, ys))
if ij_roi[k]['type'] != 'oval':
roi = ManualROI.from_positions(
positions=ps,
curve_plot_item=self.get_plot_item(),
view_box=self.vi.viewer.getView())
self.roi_list.append(roi)
self.roi_list.reindex_colormap()
def compute_likelihoods(catalog_file,
out_file,
cosmo_dict,
nmodes,
dtheta,
n_z,
sigma=0.3,
RAmin = None, DECmin = None,
NRA = None, NDEC = None,
remove_z_problem=True,
fiducial_cosmology = None,
**kwargs):
"""
compute the likelihoods for a range of cosmologies
Parameters
----------
catalog_file : string or list of strings
location of the COSMOS catalog(s) to use
out_file : string
location to save likelihood output
Output will be a text file, with columns labeled
cosmo_dict : Dictionary
keys are arguments for cosmology object
values are the corresponding range
nmodes :
number of modes to use. This should be less than NRA*NDEC
alternatively, a list of integers can be supplied
dtheta : float
size of (square) pixels in arcmin
sigma : float (default = 0.3)
intrinsic ellipticity of galaxies
fiducial_cosmology : Cosmology object
the fiducial cosmology used for determination of KL vectors
if unspecified, it will be initialized from remaining kwargs
Other Parameters
----------------
n_z : `shear_KL_source.zdist.zdist` object
n_z(z) returns the galaxy distribution
If the following are unspecified, they will be determined from the data
RAmin/DECmin : float
minimum of RA/DEC bins (degrees).
NRA/NDEC : int
number of RA/DEC bins
"""
gamma, Ngal, noise, RArange, DECrange = get_gamma_vector(
catalog_file, dtheta, RAmin, DECmin, NRA, NDEC, N_bootstraps=10,
remove_z_problem=True)
if fiducial_cosmology is None:
fiducial_cosmology = Cosmology(**kwargs)
# use results of bootstrap resampling to compute
# the noise on observed shear
gamma = gamma.reshape(gamma.size)
Ngal = Ngal.reshape(Ngal.size)
noise = noise.reshape(noise.size)
i_sigma = np.where(Ngal > 1)
sigma_estimate = np.sqrt(np.mean(noise[i_sigma] * Ngal[i_sigma]))
print "average sigma: %.2g" % sigma_estimate
izero = np.where(Ngal <= 1)
noise[izero] = sigma_estimate ** 2
N_m_onehalf = noise ** -0.5
# noise = sigma^2 / Ngal
# correlation matrix takes a constant sigma and a variable
# ngal. So we'll encode the noise as an "effective Ngal"
# using the user-defined sigma.
Ngal_eff = sigma**2 / noise
Ngal_eff[np.where(Ngal == 0)] = 0
# construct fiducial correlation matrix
print ">> fiducial correlation matrix"
R_fid = shear_correlation_matrix(sigma, RArange, DECrange, Ngal_eff,
n_z,
whiten=True,
cosmo=fiducial_cosmology)
evals, evecs = np.linalg.eigh(R_fid)
isort = np.argsort(evals)[::-1]
evals = evals[isort]
evecs = evecs[:,isort]
#compute KL transform of data
a_data = np.dot(evecs.T, N_m_onehalf * gamma)
#iterate through all nmodes requested
if not hasattr(nmodes, '__iter__'):
nmodes = [nmodes]
cosmo_keys = cosmo_dict.keys()
cosmo_vals = [cosmo_dict[k] for k in cosmo_keys]
cosmo_kwargs = fiducial_cosmology.get_dict()
log2pi = np.log(2*np.pi)
OF = open(out_file, 'w')
OF.write('# fiducial cosmology: %s\n' % str(cosmo_kwargs))
OF.write('# ncut ')
OF.write(' '.join(cosmo_keys))
OF.write(' chi2 log|det(C)| log(Likelihood)\n')
for cosmo_tup in iter_product(*cosmo_vals):
cosmo_kwargs.update(dict(zip(cosmo_keys,cosmo_tup)))
#flat universe prior
cosmo_kwargs['Ol'] = 1. - cosmo_kwargs['Om']
print ">>", cosmo_keys, ['%.2g' % v for v in cosmo_tup]
R = shear_correlation_matrix(sigma, RArange, DECrange, Ngal_eff,
n_z,
whiten=True,
**cosmo_kwargs)
cosmo_args = (len(cosmo_keys) * " %.6g") % cosmo_tup
for ncut in nmodes:
evecs_n = evecs[:,:ncut]
a_n = a_data[:ncut]
C_n = np.dot(evecs_n.T, np.dot(R, evecs_n))
# compute chi2 = (a_n-<a_n>)^T C_n^-1 (a_n-<a_n>)
# model predicts <a> = 0 so this simplifies:
chi2_raw = np.dot(a_n.conj(), np.linalg.solve(C_n, a_n))
#chi2_raw is complex because a_n is complex. The imaginary
# part of chi2 should be zero (within machine precision), because
# C_n is Hermitian. We'll skip checking that this is the case.
chi2 = chi2_raw.real
s, logdetC = np.linalg.slogdet(C_n)
X0 = -0.5 * ncut * log2pi
X1 = -0.5 * logdetC
X2 = -0.5 * chi2
print chi2, logdetC, X0, X1, X2
OF.write("%i %s %.6g %.6g %.6g\n" % (ncut, cosmo_args, chi2,
logdetC, X0+X1+X2))
###
###
OF.close()
