def test_points_shift():
"""Tests that shifted points are inside the unit square.
Also tests that all points are shifted the same, and that the shift
is random.
"""
J = 100
N = 1024
point_generation_method = 'mc'
seed = 42
points = point_gen.mc_points(J,N,point_generation_method,[0,1],seed)
shifted_points = point_gen.shift(points)
assert (-0.5 <= shifted_points).all() and (shifted_points <= 0.5).all()
# Checking points have been shifted by the same amount. If either
# point has, in any coordinate, been 'wrapped round', then the
# difference in their shifts will be 1 (the size of the hypercube).
shift_0 = shifted_points[0,:] - points[0,:]
shift_1 = shifted_points[1,:] - points[1,:]
# This is a bit of a hack, because arrays of truth values are
# complicated. It says that for every element of the arrays, either
# they are equal, or they differ by 1.
differences = (shift_0 - shift_1) * (np.abs(shift_0-shift_1) - 1)
assert np.allclose(differences,0)
# Heuristic check (similar to that in test_mc_points_correct) that
# the shift is random.
assert shift_0.mean() < 0.07
def test_lexicographic_ordering():
"""Tests whether lexicographic ordering works."""
points = point_gen.mc_points(20,2**5,'qmc',[0,1],seed=None,
order_lexicographically=True)
points_ordering = np.lexsort(points.transpose())
print(points_ordering,flush=True)
points_ordered = deepcopy(points_ordering)
points_ordered.sort()
print(points_ordered,flush=True)
assert (points_ordering == points_ordered).all()
def test_mc_points_correct():
"""Tests that Monte Carlo points are in the (centred) unit cube.
Also provides a quick 'check' that the points are random.
"""
J = 100
N = 1024
point_generation_method = 'mc'
seed = 42
section = [0,1]
points = point_gen.mc_points(J,N,point_generation_method,section,seed)
assert (-0.5 <= points).all() and (points <= 0.5).all()
# The following is a 'quick and dirty' check that the points are
# random - whether their average is near the centre of the cube. The
# threshold for 'near' is a heuristic that I chose by looking at
# generated random numbers.
assert np.isclose(points.mean(),0.0,atol=0.0025)
def test_qmc_points_correct():
"""Tests that Monte Carlo points are in the (centred) unit cube.
Also checks that they are the same as generated by Dirk Nuyens' code
(although given Dirks code underlies the code being tested, this
isn't a great test). But the test was written without looking at the
code being tested, so maybe that makes it slightly better.
"""
J = 100
N = 1024
point_generation_method = 'qmc'
points = point_gen.mc_points(J,N,point_generation_method,[0,1])
assert (-0.5 <= points).all() and (points <= 0.5).all()
true_points_gen = latticeseq_b2.latticeseq_b2(s=J)
for m in range(11):
true_points = true_points_gen.calc_block(m) - 0.5
if m == 0:
# Dealing with indexing
assert (true_points == points[0:1,:]).all()
else:
assert (true_points == points[2**(m-1):2**m,:]).all()
def find_nbpc_points(M,nearby_preconditioning_proportion,kl_like,J,point_generation_method,this_ensemble_points,shift_no):
"""Finds the points to use as 'centres' for nearby preconditioning, and
calculates which 'centre' corresponds to each qmc point.
"""
# Points are generated here, so this is presumably the place to do
# all the 'figuring out the centres' business. We distribute the
# points at the centres of the 'preconditioning balls' using a
# tensor product grid. Suppose we knew the radius of these balls
# (in a weighted L^1-metric) should be r. Then the spacing of the
# points in dimension j should be
# \[d_j = r / (J * \sqrt{lambda_j})\]
# (where the sqrt(lambda_j) are as in
# helmholtz_firedrake.coefficients.UniformKLLikeCoeff). In order to
# achieve this spacing, we would need \ceil(1/d_j) points in
# dimension j. However, we know the number of points, and we reverse
# engineer the above argument to get the radius of the balls, and
# the spacing in each dimension. Suppose for simplicity (and because
# there will be various other fudges and approximations in what
# follows) that we have 1/d_j points in each dimension. Then the
# total number of points is $r^{-J} \prod_{j=1}^J J
# \sqrt{\lambda_j}.$ If we specify that the total number of
# 'centres' is N_C, then we have
# \[r = J(\prod_{j=1}^J\sqrt{\lambda_j})^{-J}\],
# and thence we can determine d_j, and lay down equispaced points in
# dimension j with this spacing. We then assemble the points in all
# of stochastic space via tensor products. We then find the actual
# 'centres' by selecting the QMC points that are nearest to these
# 'ideal' centres. We then associated each and every QMC point with
# a 'centre' by selecting the closest 'centre'.
N = 2**M
num_centres = round(N*nearby_preconditioning_proportion)
sqrt_lambda = kl_like._sqrt_lambda
# Check this is a row vector
# We distribute the number of points at which to construct the
# preconditioners according to the decay of 1+sqrt(lambda_j).
#TODO - tidy this documentation We do a bit of a hack to generate
# the distribution of the centres in the different dimensions. We
# write a function that assumes we know the radius $r$ of the
# balls (in the funny metric), that we want, and then gives us the
# number of points in each dimension (well, not quite, because at
# this point the 'numbers of points' are not necessarily
# integers). We then optimise this function (it's nonlinear and
# nonsmooth) to find the (a?) value of $r$ that gives the correct
# number of centres. We then round all the decimal numbers to get
# a number of points that (we hope) isn't too far off.
#
# The reason why this is the right function to optimise, I'll
# write in later
def continuous_centre_nums(r):
return np.array([np.max((1.0,ii)) for ii in (float(J)*sqrt_lambda)/(2.0*r)])
def optim_fn(r):
return continuous_centre_nums(r).prod()-float(num_centres)
# Find appropriate endpoints for bisection optimisation
lower_bound = 0.1
while optim_fn(lower_bound) < 0:
lower_bound = 0.5 * lower_bound
upper_bound = 1.0
while optim_fn(upper_bound) > 0:
upper_bound = 2*upper_bound
out = optimize.bisect(optim_fn,lower_bound,upper_bound)
centre_nums = np.round(continuous_centre_nums(out))
# A better way to do this would be to find the closest point on the integer lattice - not even this, but I've no idea how easy/hard that is....
one_d_points = [-0.5+np.linspace(1.0/(jj+1.0),jj/(jj+1.0),int(jj)) for jj in centre_nums]
centres_meshgrid = np.meshgrid(*one_d_points)
proposed_centres = np.vstack([coord.flatten() for coord in centres_meshgrid]).transpose()
# Now to actually locate the centres at QMC points
all_qmc_points = point_gen.mc_points(
J,N,point_generation_method,section=[0,1],seed=1)
for ii_shift in range(shift_no+1):
# Needed because the outer code iteratively shifts the qmc
# points around
all_qmc_points = point_gen.shift(all_qmc_points,seed=shift_no)
centres = []
for proposed in proposed_centres:
nearest_point = np.argmin(weighted_L1_norm(proposed,all_qmc_points,sqrt_lambda))
potential_centre = all_qmc_points[nearest_point,:]
# We guard against a centre being selected twice
skip = False
for other_centre in centres:
if np.isclose(potential_centre,other_centre).all():
skip = True
if not skip:
centres.append(potential_centre)
centres = np.vstack(centres)
actual_num_centres = centres.shape[0]
# Now find out, for each QMC point in this ensemble member, which
# centre is nearest to it
num_points_this_ensemble = this_ensemble_points.shape[0]
nearest_centre = -np.ones(num_points_this_ensemble,dtype='int')
for ii_point in range(num_points_this_ensemble):
point = this_ensemble_points[ii_point,:]
nearest_centre[ii_point] = np.argmin(weighted_L1_norm(point,centres,sqrt_lambda))
# Check we've actually assigned a centre to each point
assert (nearest_centre >= 0).all()
return [centres,nearest_centre]
def generate_samples(k,h_spec,J,nu,M,
point_generation_method,
delta,lambda_mult,j_scaling,
qois,
num_spatial_cores,dim=2,
display_progress=False,physically_realistic=False,
nearby_preconditioning=False,
nearby_preconditioning_proportion=1):
"""Generates samples for Monte-Carlo methods for Helmholtz.
Computes an approximation to the root-mean-squared error in
Monte-Carlo or Quasi-Monte Carlo approximations of expectations of
quantities of interest associated with the solution of a stochastic
Helmholtz problem, where the randomness enters through a random
field refractive index, given by an artificial-KL expansion.
Parameters:
k - positive float - the wavenumber for which to do computations.
h_spec - 2-tuple - h_spec[0] should be a positive float and
h_spec[1] should be a float. These specify the values of the mesh
size h for which we will run experiments.
h = h_spec[0] * k**h_spec[1].
J - positive int - the stochastic dimension in the artificial-KL
expansion for which to do experiments.
nu - positive int - the number of random shifts to use in
randomly-shifted QMC methods. Combines with M to give number of
integration points for Monte Carlo.
M - positive int - Specifies the number of integration points for
which to do computations - NOTE: for Monte Carlo, the number of
integration points will be given by nu*(2**M). For Quasi-Monte
Carlo, we will sample 2**m integration points, and then randomly
shift these nu times as part of the estimator.
point_generation_method string - either 'mc' or 'qmc', specifying
Monte-Carlo point generation or Quasi-Monte-Carlo (based on an
off-the-shelf lattice rule). Monte-Carlo generation currently
doesn't work, and so throws an error.
delta - parameter controlling the rate of decay of the magntiude of
the coefficients in the artifical-KL expansion - see
helmholtz_firedrake.coefficients.UniformKLLikeCoeff for more
information.
lambda_mult - parameter controlling the absolute magntiude of the
coefficients in the artifical-KL expansion - see
helmholtz_firedrake.coefficients.UniformKLLikeCoeff for more
information.
j_scaling - parameter controlling the oscillation in the basis
functions in the artifical-KL expansion - see
helmholtz_firedrake.coefficients.UniformKLLikeCoeff for more
information.
qois - list of strings - the Quantities of Interest that are
computed. Currently the only options for the elements of the string
are:
'integral' - the integral of the solution over the domain.
'origin' the point value at the origin.
'top_right' the point value at (1,1)
'gradient_top_right' the gradient at (1,1)
There are also the options 'testing' and 'testing_qmc', but these
are used solely for testing the functions.
num_spatial_cores - int - the number of cores we want to use to
solve our PDE. (You need to specify this as we might use ensemble
parallelism to speed things up.)
dim - either 2 or 3 - the spatial dimension of the Helmholtz
Problem.
display_progress - boolean - if true, prints the sample number each
time we sample.
physically_realistic - boolean - if true, f and g correspond to a
scattered plane wave, n is cut off away from the truncation
boundary, and n is >= 0.1. Otherwise, f and g are given by a plane
wave. The 'false' option is used to verify regression tests.
nearby_preconditioning - boolean - if true, nearby preconditioning
is used in the solves. A proportion (given by nearby_preconditioning
proportion) of the realisations have their exact LU decompositions
computed, and then these are used as preconditioners for all the
other problems (where the preconditioner used is determined by the
nearest problem, in some metric, that has had a preconditioner
computed). Note that if ensembles are used to speed up the solution
time, some LU decompositions may be calculated more than once. But
for the purposes of assessing the effectiveness of the algorithm (in
terms of total # GMRES iterations), this isn't a problem.
nearby_preconditioning_proportion - float in [0,1]. See the text for
nearby_preconditioning above.
Output:
If point_generation_method is 'qmc', then
output is a list: [k,samples,n_coeffs,GMRES_its,]
k is a float - the wavenumber.
samples is a list of length nu, where each entry of samples is a
list of length num_qois, each entry of which is a numpy array of
length 2**M, each entry of which is either: (i) a (complex-valued)
float, or (ii) a numpy column vector, corresponding to a sample of
the QoI.
n_coeffs is a list of length nu, each entry of which is a 2**M by J
numpy array, each row of which contains the KL-coefficients needed
to generate the particular realisation of n.
GMRES_its is a list of length nu, each entry of which is a list of
length 2**M, containing ints - these are the number of GMRES
iterations required for each sample.
"""
if point_generation_method is 'mc':
raise NotImplementedError("Monte Carlo sampling currently doesn't work")
num_qois = len(qois)
mesh_points = hh_utils.h_to_num_cells(h_spec[0]*k**h_spec[1],
dim)
ensemble = fd.Ensemble(fd.COMM_WORLD,num_spatial_cores)
mesh = fd.UnitSquareMesh(mesh_points,mesh_points,comm=ensemble.comm)
comm = ensemble.ensemble_comm
n_coeffs = []
if point_generation_method is 'mc':
# This needs updating one I've figured out a way to do seeding
# in a parallel-appropriate way
N = nu*(2**M)
kl_mc_points = point_gen.mc_points(
J,N,point_generation_method,seed=1)
elif point_generation_method is 'qmc':
N = 2**M
kl_mc_points = point_gen.mc_points(
J,N,point_generation_method,section=[comm.rank,comm.size],seed=1)
n_0 = 1.0
kl_like = coeff.UniformKLLikeCoeff(
mesh,J,delta,lambda_mult,j_scaling,n_0,kl_mc_points)
# Create the problem
V = fd.FunctionSpace(mesh,"CG",1)
prob = hh.StochasticHelmholtzProblem(
k,V,A_stoch=None,n_stoch=kl_like,
**{'A_pre' : fd.as_matrix([[1.0,0.0],[0.0,1.0]])})
angle = np.pi/4.0
if physically_realistic:
make_physically_realistic(prob,angle)
else:
prob.f_g_plane_wave([np.cos(angle),np.sin(angle)])
if point_generation_method is 'mc':
samples = all_qoi_samples(prob,qois,ensemble.comm,display_progress)
elif point_generation_method == 'qmc':
samples = []
GMRES_its = []
for shift_no in range(nu):
if display_progress:
print('Shift number:',shift_no+1,flush=True)
# Randomly shift the points
prob.n_stoch.change_all_points(
point_gen.shift(kl_mc_points,seed=shift_no))
n_coeffs.append(deepcopy(prob.n_stoch.current_and_unsampled_points()))
if nearby_preconditioning:
[centres,nearest_centre] = find_nbpc_points(M,nearby_preconditioning_proportion,
prob.n_stoch,J,point_generation_method,
prob.n_stoch.current_and_unsampled_points(),
shift_no)
else:
centres = None
nearest_centre = None
[this_samples,this_GMRES_its] = all_qoi_samples(prob,qois,ensemble.comm,display_progress,
centres,nearest_centre,J,delta,lambda_mult,
j_scaling,n_0,angle,physically_realistic)
# For outputting samples and GMRES iterations
samples.append(this_samples)
GMRES_its.append(this_GMRES_its)
comm = ensemble.ensemble_comm
samples = fancy_allgather(comm,samples,'samples')
n_coeffs = fancy_allgather(comm,n_coeffs,'coeffs')
# Have to hack around GMRES_its because it's not *quite* in the
# right format
# list of list of Nones or Floats
# But if we don't use NBPC, then it's a list of Nones
GMRES_its = [[np.array(ii)] for ii in GMRES_its]
GMRES_its = fancy_allgather(comm,GMRES_its,'samples')
GMRES_its = [ii[0].tolist() for ii in GMRES_its]
return [k,samples,n_coeffs,GMRES_its,]