def setUp(self):
"""
Set up problem.
"""
import numpy.random as rnd
rnd.seed(1)
self.inputs = samp.sample_set(1)
self.outputs = samp.sample_set(1)
self.lam_domain = np.zeros((1, 2))
self.lam_domain[:, 0] = 0.0
self.lam_domain[:, 1] = 1.0
self.inputs.set_domain(self.lam_domain)
self.inputs.set_values(rnd.rand(100,))
self.num_l_emulate = 1001
self.inputs = bsam.random_sample_set('r',
self.inputs.get_domain(), num_samples=1001, globalize=True)
self.outputs.set_values(2.0*self.inputs._values)
Q_ref = np.mean(self.outputs._values, axis=0)
self.inputs_emulated = bsam.random_sample_set('r',
self.inputs.get_domain(), num_samples=self.num_l_emulate,
globalize=True)
self.output_prob = simpleFunP.regular_partition_uniform_distribution_rectangle_scaled(
self.outputs, Q_ref=Q_ref, rect_scale=0.2, cells_per_dimension=1)
self.disc = samp.discretization(input_sample_set=self.inputs,
output_sample_set=self.outputs,
output_probability_set=self.output_prob,
emulated_input_sample_set=self.inputs_emulated)
def setUp(self):
"""
Set up problem.
"""
import numpy.random as rnd
rnd.seed(1)
self.inputs = samp.sample_set(1)
self.outputs = samp.sample_set(1)
self.lam_domain = np.zeros((1, 2))
self.lam_domain[:, 0] = 0.0
self.lam_domain[:, 1] = 1.0
self.inputs.set_domain(self.lam_domain)
self.inputs.set_values(rnd.rand(100, ))
self.num_l_emulate = 1001
self.inputs = bsam.random_sample_set('r',
self.inputs.get_domain(),
num_samples=1001,
globalize=True)
self.outputs.set_values(2.0 * self.inputs._values)
Q_ref = np.mean(self.outputs._values, axis=0)
self.inputs_emulated = bsam.random_sample_set(
'r',
self.inputs.get_domain(),
num_samples=self.num_l_emulate,
globalize=True)
self.output_prob = simpleFunP.regular_partition_uniform_distribution_rectangle_scaled(
self.outputs, Q_ref=Q_ref, rect_scale=0.2, cells_per_dimension=1)
self.disc = samp.discretization(
input_sample_set=self.inputs,
output_sample_set=self.outputs,
output_probability_set=self.output_prob,
emulated_input_sample_set=self.inputs_emulated)
def Test_linears(self):
"""
Test for piecewise linears.
"""
iss = bsam.random_sample_set(
'r',
self.sur.input_disc._input_sample_set._domain,
num_samples=20,
globalize=False)
sur_disc = self.sur.generate_for_input_set(iss, order=1)
sur_disc.check_nums()
self.assertEqual(sur_disc._output_sample_set._dim, 2)
nptest.assert_array_equal(
sur_disc._input_sample_set._domain,
self.sur.input_disc._input_sample_set._domain)
sur_disc._input_sample_set._values_local[0, :]
s_set = sur_disc._input_sample_set.copy()
sur_disc.set_io_ptr()
regions_local = np.equal(sur_disc._io_ptr_local, 0)
s_set.set_region_local(regions_local)
s_set.local_to_global()
s_set.check_num()
self.sur.calculate_prob_for_sample_set_region(s_set,
regions=[0],
update_input=True)
def unit_center_set(dim=1, num_samples=100, delta=1, reg=False):
r"""
Make a unit hyper-rectangle sample set with positive probability
inside an inscribed hyper-rectangle that has sidelengths delta,
with its center at `np.array([[0.5]]*dim).
(Useful for testing).
:param int dim: dimension
:param int num_samples: number of samples
:param float delta: sidelength of region with positive probability
:param bool reg: regular sampling (`num_samples` = per dimension)
:rtype: :class:`bet.sample.sample_set`
:returns: sample set object
"""
s_set = sample.sample_set(dim)
s_set.set_domain(np.array([[0, 1]] * dim))
if reg:
s = bsam.regular_sample_set(s_set, num_samples)
else:
s = bsam.random_sample_set('r', s_set, num_samples)
dd = delta / 2.0
if dim > 1:
probs = 1 * (np.sum(np.logical_and(s._values <=
(0.5 + dd), s._values >=
(0.5 - dd)),
axis=1) >= dim)
else:
probs = 1 * (np.logical_and(s._values <= (0.5 + dd), s._values >=
(0.5 - dd)))
s.set_probabilities(probs / np.sum(probs)) # uniform probabilities
s.estimate_volume_mc()
s.global_to_local()
return s
def unit_top_set(dim=1, num_samples=100, delta=1, reg=False):
r"""
First define a unit hyper-box sample set. Then, construct a hyper-box
with a corner at ``np.array([[1.0]]*dim)`` with side-lengths ``delta``
inside of this domain that has probability 1.
(Useful for testing).
:param int dim: dimension
:param int num_samples: number of samples
:param float delta: sidelength of region with positive probability
:param bool reg: regular sampling (`num_samples` = per dimension)
:rtype: :class:`bet.sample.sample_set`
:returns: sample set object
"""
s_set = sample.sample_set(dim)
s_set.set_domain(np.array([[0, 1]] * dim))
if reg:
s = bsam.regular_sample_set(s_set, num_samples)
else:
s = bsam.random_sample_set('r', s_set, num_samples)
dd = delta
if dim == 1:
probs = 1 * (s._values >= (1 - dd))
else:
probs = 1 * (np.sum(s._values >= (1 - dd), axis=1) >= dim)
s.set_probabilities(probs / np.sum(probs)) # uniform probabilities
s.estimate_volume_mc()
s.global_to_local()
return s
def compare(left_set, right_set, num_mc_points=1000, choice='input'):
r"""
This is a convience function to quickly instantiate and return
a `~bet.postProcess.comparison` object.
.. seealso::
:class:`bet.compareP.comparison`
:meth:`bet.compareP.compare_inputs`
:meth:`bet.compareP.compare_outputs`
:param left set: sample set in left position
:type left set: :class:`bet.sample.sample_set_base`
:param right set: sample set in right position
:type right set: :class:`bet.sample.sample_set_base`
:param int num_mc_points: number of values of sample set to return
:param choice: If discretization, choose 'input' (default) or 'output'
:type choice: string
:rtype: :class:`~bet.postProcess.compareP.comparison`
:returns: comparison object
"""
# extract sample set
if isinstance(left_set, samp.discretization):
msg = 'Discretization passed. '
if choice == 'input':
msg += 'Using input sample set.'
left_set = left_set.get_input_sample_set()
else:
msg += 'Using output sample set.'
left_set = left_set.get_output_sample_set()
logging.info(msg)
if isinstance(right_set, samp.discretization):
msg = 'Discretization passed. '
if choice == 'input':
msg += 'Using input sample set.'
right_set = right_set.get_input_sample_set()
else:
msg += 'Using output sample set.'
right_set = right_set.get_output_sample_set()
logging.info(msg)
if not num_mc_points > 0:
raise ValueError("Please specify positive num_mc_points")
# make integration sample set
assert left_set.get_dim() == right_set.get_dim()
assert np.array_equal(left_set.get_domain(), right_set.get_domain())
comp_set = samp.sample_set(left_set.get_dim())
comp_set.set_domain(right_set.get_domain())
comp_set = bsam.random_sample_set('r', comp_set, num_mc_points)
# to be generating a new random sample set pass an integer argument
comp = comparison(comp_set, left_set, right_set)
return comp
def postprocess(station_nums, ref_num):
filename = 'P_q' + str(station_nums[0] + 1) + '_q'
if len(station_nums) == 3:
filename += '_q' + str(station_nums[2] + 1)
filename += '_ref_' + str(ref_num + 1)
data = Q[:, station_nums]
output_sample_set = sample.sample_set(data.shape[1])
output_sample_set.set_values(data)
q_ref = Q_ref[ref_num, station_nums]
# Create Simple function approximation
# Save points used to parition D for simple function approximation and the
# approximation itself (this can be used to make close comparisions...)
output_probability_set = sfun.regular_partition_uniform_distribution_rectangle_scaled(
output_sample_set, q_ref, rect_scale=0.15,
cells_per_dimension=np.ones((data.shape[1],)))
num_l_emulate = 1e4
set_emulated = bsam.random_sample_set('r', lam_domain, num_l_emulate)
my_disc = sample.discretization(input_sample_set, output_sample_set,
output_probability_set, emulated_input_sample_set=set_emulated)
print("Finished emulating lambda samples")
# Calculate P on lambda emulate
print("Calculating prob_on_emulated_samples")
calcP.prob_on_emulated_samples(my_disc)
sample.save_discretization(
my_disc,
filename,
"prob_on_emulated_samples_solution")
# Calclate P on the actual samples with assumption that voronoi cells have
# equal size
input_sample_set.estimate_volume_mc()
print("Calculating prob")
calcP.prob(my_disc)
sample.save_discretization(my_disc, filename, "prob_solution")
# Calculate P on the actual samples estimating voronoi cell volume with MC
# integration
calcP.prob_with_emulated_volumes(my_disc)
print("Calculating prob_with_emulated_volumes")
sample.save_discretization(
my_disc,
filename,
"prob_with_emulated_volumes_solution")
def postprocess(station_nums, ref_num):
filename = 'P_q'+str(station_nums[0]+1)+'_q'
if len(station_nums) == 3:
filename += '_q'+str(station_nums[2]+1)
filename += '_ref_'+str(ref_num+1)
data = Q[:, station_nums]
output_sample_set = sample.sample_set(data.shape[1])
output_sample_set.set_values(data)
q_ref = Q_ref[ref_num, station_nums]
# Create Simple function approximation
# Save points used to parition D for simple function approximation and the
# approximation itself (this can be used to make close comparisions...)
output_probability_set = sfun.regular_partition_uniform_distribution_rectangle_scaled(\
output_sample_set, q_ref, rect_scale=0.15,
cells_per_dimension=np.ones((data.shape[1],)))
num_l_emulate = 1e4
set_emulated = bsam.random_sample_set('r', lam_domain, num_l_emulate)
my_disc = sample.discretization(input_sample_set, output_sample_set,
output_probability_set, emulated_input_sample_set=set_emulated)
print "Finished emulating lambda samples"
# Calculate P on lambda emulate
print "Calculating prob_on_emulated_samples"
calcP.prob_on_emulated_samples(my_disc)
sample.save_discretization(my_disc, filename, "prob_on_emulated_samples_solution")
# Calclate P on the actual samples with assumption that voronoi cells have
# equal size
input_sample_set.estimate_volume_mc()
print "Calculating prob"
calcP.prob(my_disc)
sample.save_discretization(my_disc, filename, "prob_solution")
# Calculate P on the actual samples estimating voronoi cell volume with MC
# integration
calcP.prob_with_emulated_volumes(my_disc)
print "Calculating prob_with_emulated_volumes"
sample.save_discretization(my_disc, filename, "prob_with_emulated_volumes_solution")
def setUp(self):
self.inputs = samp.sample_set(3)
self.outputs = samp.sample_set(2)
self.inputs.set_values(np.loadtxt(data_path + "/3to2_samples.txt.gz"))
self.outputs.set_values(np.loadtxt(data_path + "/3to2_data.txt.gz"))
Q_ref = np.array([0.422, 0.9385])
self.output_prob = simpleFunP.regular_partition_uniform_distribution_rectangle_scaled(
self.outputs, Q_ref=Q_ref, rect_scale=0.2, cells_per_dimension=1)
self.inputs.set_domain(np.array([[0.0, 1.0],
[0.0, 1.0],
[0.0, 1.0]]))
import numpy.random as rnd
rnd.seed(1)
self.inputs_emulated = bsam.random_sample_set('r',
self.inputs.get_domain(), num_samples=1001, globalize=True)
self.disc = samp.discretization(input_sample_set=self.inputs,
output_sample_set=self.outputs,
output_probability_set=self.output_prob,
emulated_input_sample_set=self.inputs_emulated)
def Test_linears(self):
"""
Test for piecewise linears.
"""
iss = bsam.random_sample_set('r',
self.sur.input_disc._input_sample_set._domain,
num_samples = 10,
globalize=False)
sur_disc = self.sur.generate_for_input_set(iss, order=1)
sur_disc.check_nums()
self.assertEqual(sur_disc._output_sample_set._dim, 2)
nptest.assert_array_equal(sur_disc._input_sample_set._domain,
self.sur.input_disc._input_sample_set._domain)
sur_disc._input_sample_set._values_local[0,:]
s_set = sur_disc._input_sample_set.copy()
sur_disc.set_io_ptr()
regions_local = np.equal(sur_disc._io_ptr_local, 0)
s_set.set_region_local(regions_local)
s_set.local_to_global()
s_set.check_num()
self.sur.calculate_prob_for_sample_set_region(s_set,
regions=[0],
update_input=True)
'''
This script solves a poisson equation with a random field.
(\grad \dot (rand_field \grad(u)) = -f)
The random field is approximated using simple functions
'''
# Load all the data that are fixed for this problem
execfile("examples/Porous_Media_SimpleFuncs/loadData.py")
# create a simple function object
rect_simple_func = rectSimpleFunc(mesh, partition, dimension)
param_dim = rect_simple_func.num_basis
lam_domain = np.repeat([[1.0, 2.0]], param_dim, axis=0)
inp_samples = bs.random_sample_set(r, lam_domain, numSamplesSimple)
coeff_samples = inp_samples.get_values()
coeff_samples = coeff_samples.transpose()
print np.shape(coeff_samples)
# coeff_samples = calculateP.emulate_iid_lebesgue(lam_domain=lam_domain,
# num_l_emulate=numSamplesSimple)
# coeff_samples = coeff_samples.transpose()
"""
for each sample of the coefficients, generate the simple function
field and solve the pde.
"""
print " Start sampling simple functions "
for i in range(0, numSamplesSimple):
# Interface BET to the approximate model and create discretization object.
sampler = bsam.sampler(lb_model, error_estimates=True, jacobians=True)
input_samples = samp.sample_set(3)
input_samples.set_domain(np.array([[0.0, 1.0],
[0.0, 1.0],
[0.0, 1.0]]))
my_disc = sampler.create_random_discretization("random", input_samples, num_samples=1000)
# Define output probability
rect_domain = np.array([[0.5, 1.5], [1.25, 2.25]])
simpleFunP.regular_partition_uniform_distribution_rectangle_domain( data_set=my_disc, rect_domain=rect_domain)
# Make emulated input sets
emulated_inputs = bsam.random_sample_set('r',
my_disc._input_sample_set._domain,
num_samples = 10001,
globalize=False)
emulated_inputs2 = bsam.random_sample_set('r',
my_disc._input_sample_set._domain,
num_samples = 10001,
globalize=False)
# Make exact discretization
my_disc_exact = my_disc.copy()
my_disc_exact._output_sample_set._values_local = my_disc._output_sample_set._values_local + my_disc._output_sample_set._error_estimates_local
my_disc_exact._output_sample_set._error_estimates_local = np.zeros(my_disc_exact._output_sample_set._error_estimates_local.shape)
my_disc_exact._output_sample_set.local_to_global()
my_disc_exact.set_emulated_input_sample_set(emulated_inputs2)
# Interface BET to the approximate model and create discretization object.
sampler = bsam.sampler(lb_model, error_estimates=True, jacobians=True)
input_samples = samp.sample_set(3)
input_samples.set_domain(np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]))
my_disc = sampler.create_random_discretization("random",
input_samples,
num_samples=1000)
# Define output probability
rect_domain = np.array([[0.5, 1.5], [1.25, 2.25]])
simpleFunP.regular_partition_uniform_distribution_rectangle_domain(
data_set=my_disc, rect_domain=rect_domain)
# Make emulated input sets
emulated_inputs = bsam.random_sample_set('r',
my_disc._input_sample_set._domain,
num_samples=10001,
globalize=False)
emulated_inputs2 = bsam.random_sample_set('r',
my_disc._input_sample_set._domain,
num_samples=10001,
globalize=False)
# Make exact discretization
my_disc_exact = my_disc.copy()
my_disc_exact._output_sample_set._values_local = my_disc._output_sample_set._values_local + my_disc._output_sample_set._error_estimates_local
my_disc_exact._output_sample_set._error_estimates_local = np.zeros(
my_disc_exact._output_sample_set._error_estimates_local.shape)
my_disc_exact._output_sample_set.local_to_global()
my_disc_exact.set_emulated_input_sample_set(emulated_inputs2)
'''
This script solves a poisson equation with a random field.
(\grad \dot (rand_field \grad(u)) = -f)
The random field is approximated using simple functions
'''
# Load all the data that are fixed for this problem
execfile("examples/Porous_Media_SimpleFuncs/loadData.py")
# create a simple function object
rect_simple_func = rectSimpleFunc(mesh, partition, dimension)
param_dim = rect_simple_func.num_basis
lam_domain = np.repeat([[1.0, 2.0]], param_dim, axis=0)
inp_samples = bs.random_sample_set(r, lam_domain, numSamplesSimple)
coeff_samples = inp_samples.get_values()
coeff_samples = coeff_samples.transpose()
print np.shape(coeff_samples)
# coeff_samples = calculateP.emulate_iid_lebesgue(lam_domain=lam_domain,
# num_l_emulate=numSamplesSimple)
# coeff_samples = coeff_samples.transpose()
"""
for each sample of the coefficients, generate the simple function
field and solve the pde.
"""
print " Start sampling simple functions "
