def cg2_demo(nrhs, n, plot):
rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim_domain=2) # NOQA
rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=2) # NOQA
assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.')
rhs = eval('rhs{}'.format(nrhs))
d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=2)
d1 = GenericFunction(lambda X: X[..., 0], dim_domain=2)
parameter_space = CubicParameterSpace({'diffusionl': 0}, 0.1, 1)
f0 = ProjectionParameterFunctional('diffusionl', 0)
f1 = GenericParameterFunctional(lambda mu: 1, {})
print('Solving on TriaGrid(({0},{0}))'.format(n))
print('Setup Problem ...')
problem = EllipticProblem(domain=RectDomain(), rhs=rhs, diffusion_functions=(d0, d1),
diffusion_functionals=(f0, f1), name='2DProblem')
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / n)
print('The parameter type is {}'.format(discretization.parameter_type))
U = discretization.type_solution.empty(discretization.dim_solution)
for mu in parameter_space.sample_uniformly(10):
U.append(discretization.solve(mu))
if plot:
print('Plot ...')
discretization.visualize(U, title='Solution for diffusionl in [0.1, 1]')
def __init__(self, args):
self.args = args
self.first = True
self.problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']),
parameter_range=(PARAM_MIN, PARAM_MAX))
self.discretization, pack = discretize_elliptic_cg(self.problem, diameter=m.sqrt(2) / args['--grid'])
self.grid = pack['grid']
def cg_oned_demo(nrhs, n, plot):
rhs0 = GenericFunction(lambda X: np.ones(X.shape) * 10, dim_domain=1)
rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=1)
assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.')
rhs = eval('rhs{}'.format(nrhs))
d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=1)
d1 = GenericFunction(lambda X: X[..., 0], dim_domain=1)
parameter_space = CubicParameterSpace({'diffusionl': 1}, 0.1, 1)
f0 = ProjectionParameterFunctional(parameter_space, 'diffusionl')
f1 = GenericParameterFunctional(parameter_space, lambda mu: 1)
print('Solving on OnedGrid(({0},{0}))'.format(n))
print('Setup Problem ...')
problem = EllipticProblem(domain=LineDomain(), rhs=rhs, diffusion_functions=(d0, d1), diffusion_functionals=(f0, f1),
dirichlet_data=ConstantFunction(value=0, dim_domain=1))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=1 / n)
print(discretization.parameter_info())
for mu in parameter_space.sample_uniformly(4):
print('Solving for mu = {} ...'.format(mu))
U = discretization.solve(mu)
if plot:
print('Plot ...')
discretization.visualize(U)
print('')
def parabolic_demo():
p = ThermalBlockProblem(parameter_range=(0.01, 1))
d, d_data = discretize_elliptic_cg(p, diameter=1./100)
mu = next(d.parameter_space.sample_randomly(1))
U0 = NumpyVectorArray(np.zeros(d.operator.dim_source))
R = implicit_euler(d.operator, d.rhs, d.l2_product, U0, 0, 1, 10, mu)
visualize_glumpy_patch(d.rhs.grid, R)
def parabolic_demo():
p = ThermalBlockProblem(parameter_range=(0.01, 1))
d_stat, d_data = discretize_elliptic_cg(p, diameter=1./100)
U0 = NumpyVectorArray(np.zeros(d_stat.operator.source.dim))
time_stepper = ImplicitEulerTimeStepper(50)
d = InstationaryDiscretization(operator=d_stat.operator, rhs=d_stat.rhs, mass=d_stat.l2_product,
initial_data=U0, T=1, products=d_stat.products, time_stepper=time_stepper,
parameter_space=d_stat.parameter_space, visualizer=d_stat.visualizer)
mu = next(d.parameter_space.sample_randomly(1))
R = d.solve(mu)
d.visualize(R)
def test_visualize_patch(backend_gridtype):
backend, gridtype = backend_gridtype
domain = LineDomain() if gridtype is OnedGrid else RectDomain()
dim = 1 if gridtype is OnedGrid else 2
rhs = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim) # NOQA
dirichlet = GenericFunction(lambda X: np.zeros(X.shape[:-1]), dim) # NOQA
diffusion = GenericFunction(lambda X: np.ones(X.shape[:-1]), dim) # NOQA
problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, diffusion_functions=(diffusion,))
grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype)
discretization, data = discretize_elliptic_cg(analytical_problem=problem, grid=grid, boundary_info=bi)
U = discretization.solve()
visualize_patch(data['grid'], U=U, backend=backend)
sleep(2) # so gui has a chance to popup
for child in multiprocessing.active_children():
child.terminate()
def cg_demo(nrhs, ndirichlet, nneumann, rect_grid=False):
rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2) # NOQA
rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2) # NOQA
dirichlet0 = GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2) # NOQA
dirichlet1 = GenericFunction(lambda X: np.ones(X.shape[:-1]), 2) # NOQA
dirichlet2 = GenericFunction(lambda X: X[..., 0], 2) # NOQA
domain0 = RectDomain() # NOQA
domain1 = RectDomain(right=BoundaryType('neumann')) # NOQA
domain2 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')) # NOQA
domain3 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann')) # NOQA
assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.')
rhs = eval('rhs{}'.format(nrhs))
assert 0 <= ndirichlet <= 2, ValueError('Invalid boundary number.')
dirichlet = eval('dirichlet{}'.format(ndirichlet))
assert 0 <= nneumann <= 3, ValueError('Invalid neumann boundary count.')
domain = eval('domain{}'.format(nneumann))
for n in [32, 128]:
grid_name = '{1}(({0},{0}))'.format(n, 'RectGrid' if rect_grid else 'TriaGrid' )
print('Solving on {0}'.format(grid_name))
print('Setup problem ...')
problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet)
print('Discretize ...')
grid, bi = discretize_domain_default(problem.domain, diameter=m.sqrt(2) / n, grid_type=RectGrid if rect_grid else TriaGrid)
discretization, _ = discretize_elliptic_cg(analytical_problem=problem, grid=grid, boundary_info=bi)
print('Solve ...')
U = discretization.solve()
print('Plot ...')
discretization.visualize(U, title=grid_name)
print('')
def cg_demo(nrhs, ndirichlet, nneumann):
rhs0 = GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2) # NOQA
rhs1 = GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2) # NOQA
dirichlet0 = GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2) # NOQA
dirichlet1 = GenericFunction(lambda X: np.ones(X.shape[:-1]), 2) # NOQA
dirichlet2 = GenericFunction(lambda X: X[..., 0], 2) # NOQA
domain0 = RectDomain() # NOQA
domain1 = RectDomain(right=BoundaryType('neumann')) # NOQA
domain2 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')) # NOQA
domain3 = RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann')) # NOQA
assert 0 <= nrhs <= 1, ValueError('Invalid rhs number.')
rhs = eval('rhs{}'.format(nrhs))
assert 0 <= ndirichlet <= 2, ValueError('Invalid boundary number.')
dirichlet = eval('dirichlet{}'.format(ndirichlet))
assert 0 <= nneumann <= 3, ValueError('Invalid neumann boundary count.')
domain = eval('domain{}'.format(nneumann))
for n in [32, 128]:
print('Solving on TriaGrid(({0},{0}))'.format(n))
print('Setup problem ...')
problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet)
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / n)
print('Solve ...')
U = discretization.solve()
print('Plot ...')
discretization.visualize(U, title='Triagrid(({0},{0}))'.format(n))
print('')
def thermalblock_demo(args):
args['XBLOCKS'] = int(args['XBLOCKS'])
args['YBLOCKS'] = int(args['YBLOCKS'])
args['--grid'] = int(args['--grid'])
args['SNAPSHOTS'] = int(args['SNAPSHOTS'])
args['RBSIZE'] = int(args['RBSIZE'])
args['--test'] = int(args['--test'])
args['--pod-norm'] = args['--pod-norm'].lower()
assert args['--pod-norm'] in {'trivial', 'h1'}
print('Solving on TriaGrid(({0},{0}))'.format(args['--grid']))
print('Setup Problem ...')
problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid'])
print('The parameter type is {}'.format(discretization.parameter_type))
if args['--plot-solutions']:
print('Showing some solutions')
Us = tuple()
legend = tuple()
for mu in discretization.parameter_space.sample_randomly(2):
print('Solving for diffusion = \n{} ... '.format(mu['diffusion']))
sys.stdout.flush()
Us = Us + (discretization.solve(mu),)
legend = legend + (str(mu['diffusion']),)
discretization.visualize(Us, legend=legend, title='Detailed Solutions for different parameters', block=True)
print('RB generation ...')
tic = time.time()
print('Solving on training set ...')
S_train = list(discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']))
snapshots = discretization.operator.type_source.empty(discretization.operator.dim_source, reserve=len(S_train))
for mu in S_train:
snapshots.append(discretization.solve(mu))
print('Performing POD ...')
pod_product = discretization.h1_product if args['--pod-norm'] == 'h1' else None
rb = pod(snapshots, modes=args['RBSIZE'], product=pod_product)[0]
print('Reducing ...')
reductor = reduce_generic_rb
rb_discretization, reconstructor, _ = reductor(discretization, rb)
toc = time.time()
t_offline = toc - tic
print('\nSearching for maximum error on random snapshots ...')
tic = time.time()
h1_err_max = -1
cond_max = -1
for mu in discretization.parameter_space.sample_randomly(args['--test']):
print('Solving RB-Scheme for mu = {} ... '.format(mu), end='')
URB = reconstructor.reconstruct(rb_discretization.solve(mu))
U = discretization.solve(mu)
h1_err = discretization.h1_norm(U - URB)[0]
cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix)
if h1_err > h1_err_max:
h1_err_max = h1_err
Umax = U
URBmax = URB
mumax = mu
if cond > cond_max:
cond_max = cond
cond_max_mu = mu
print('H1-error = {}, condition = {}'.format(h1_err, cond))
toc = time.time()
t_est = toc - tic
real_rb_size = len(rb)
print('''
*** RESULTS ***
Problem:
number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]}
h: sqrt(2)/{args[--grid]}
POD basis generation:
number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]})
pod norm: {args[--pod-norm]}
prescribed basis size: {args[RBSIZE]}
actual basis size: {real_rb_size}
elapsed time: {t_offline}
Stochastic error estimation:
number of samples: {args[--test]}
maximal H1-error: {h1_err_max} (mu = {mumax})
maximal condition of system matrix: {cond_max} (mu = {cond_max_mu})
elapsed time: {t_est}
'''.format(**locals()))
sys.stdout.flush()
if args['--plot-err']:
discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'),
title='Maximum Error Solution', separate_colorbars=True, block=True)
def thermalblock_demo(args):
args['XBLOCKS'] = int(args['XBLOCKS'])
args['YBLOCKS'] = int(args['YBLOCKS'])
args['--grid'] = int(args['--grid'])
args['SNAPSHOTS'] = int(args['SNAPSHOTS'])
args['RBSIZE'] = int(args['RBSIZE'])
args['--test'] = int(args['--test'])
args['--estimator-norm'] = args['--estimator-norm'].lower()
assert args['--estimator-norm'] in {'trivial', 'h1'}
args['--extension-alg'] = args['--extension-alg'].lower()
assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt'}
print('Solving on TriaGrid(({0},{0}))'.format(args['--grid']))
print('Setup Problem ...')
problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid'])
print('The parameter type is {}'.format(discretization.parameter_type))
if args['--plot-solutions']:
print('Showing some solutions')
Us = tuple()
legend = tuple()
for mu in discretization.parameter_space.sample_randomly(2):
print('Solving for diffusion = \n{} ... '.format(mu['diffusion']))
sys.stdout.flush()
Us = Us + (discretization.solve(mu),)
legend = legend + (str(mu['diffusion']),)
discretization.visualize(Us, legend=legend, title='Detailed Solutions for different parameters', block=True)
print('RB generation ...')
error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None
reductor = partial(reduce_stationary_affine_linear, error_product=error_product)
extension_algorithms = {'trivial': trivial_basis_extension,
'gram_schmidt': gram_schmidt_basis_extension,
'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product)}
extension_algorithm = extension_algorithms[args['--extension-alg']]
greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']),
use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm,
extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE'])
rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor']
print('\nSearching for maximum error on random snapshots ...')
def error_analysis(d, rd, rc, mus):
print('N = {}: '.format(rd.operator.dim_source), end='')
h1_err_max = -1
h1_est_max = -1
cond_max = -1
for mu in mus:
print('.', end='')
u = rd.solve(mu)
URB = rc.reconstruct(u)
U = d.solve(mu)
h1_err = d.h1_norm(U - URB)[0]
h1_est = rd.estimate(u, mu=mu)
cond = np.linalg.cond(rd.operator.assemble(mu)._matrix)
if h1_err > h1_err_max:
h1_err_max = h1_err
mumax = mu
if h1_est > h1_est_max:
h1_est_max = h1_est
mu_est_max = mu
if cond > cond_max:
cond_max = cond
cond_max_mu = mu
print()
return h1_err_max, mumax, h1_est_max, mu_est_max, cond_max, cond_max_mu
tic = time.time()
real_rb_size = len(greedy_data['basis'])
if args['--plot-error-sequence']:
N_count = min(real_rb_size - 1, 25)
Ns = np.linspace(1, real_rb_size, N_count).astype(np.int)
else:
Ns = np.array([real_rb_size])
rd_rcs = [reduce_to_subbasis(rb_discretization, N, reconstructor)[:2] for N in Ns]
mus = list(discretization.parameter_space.sample_randomly(args['--test']))
errs, err_mus, ests, est_mus, conds, cond_mus = zip(*(error_analysis(discretization, rd, rc, mus)
for rd, rc in rd_rcs))
h1_err_max = errs[-1]
mumax = err_mus[-1]
cond_max = conds[-1]
cond_max_mu = cond_mus[-1]
toc = time.time()
t_est = toc - tic
print('''
*** RESULTS ***
Problem:
number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]}
h: sqrt(2)/{args[--grid]}
Greedy basis generation:
number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]})
used estimator: {args[--with-estimator]}
estimator norm: {args[--estimator-norm]}
extension method: {args[--extension-alg]}
prescribed basis size: {args[RBSIZE]}
actual basis size: {real_rb_size}
elapsed time: {greedy_data[time]}
Stochastic error estimation:
number of samples: {args[--test]}
maximal H1-error: {h1_err_max} (mu = {mumax})
maximal condition of system matrix: {cond_max} (mu = {cond_max_mu})
elapsed time: {t_est}
'''.format(**locals()))
sys.stdout.flush()
if args['--plot-error-sequence']:
plt.semilogy(Ns, errs, Ns, ests)
plt.legend(('error', 'estimator'))
plt.show()
if args['--plot-err']:
U = discretization.solve(mumax)
URB = reconstructor.reconstruct(rb_discretization.solve(mumax))
discretization.visualize((U, URB, U - URB), legend=('Detailed Solution', 'Reduced Solution', 'Error'),
title='Maximum Error Solution', separate_colorbars=True, block=True)
def thermalblock_demo(args):
args['XBLOCKS'] = int(args['XBLOCKS'])
args['YBLOCKS'] = int(args['YBLOCKS'])
args['--grid'] = int(args['--grid'])
args['SNAPSHOTS'] = int(args['SNAPSHOTS'])
args['RBSIZE'] = int(args['RBSIZE'])
args['--test'] = int(args['--test'])
args['--estimator-norm'] = args['--estimator-norm'].lower()
assert args['--estimator-norm'] in {'trivial', 'h1'}
args['--extension-alg'] = args['--extension-alg'].lower()
assert args['--extension-alg'] in {'trivial', 'gram_schmidt', 'h1_gram_schmidt', 'numpy_trivial',
'numpy_gram_schmidt'}
args['--reductor'] = args['--reductor'].lower()
assert args['--reductor'] in {'default', 'numpy_default'}
print('Solving on TriaGrid(({0},{0}))'.format(args['--grid']))
print('Setup Problem ...')
problem = ThermalBlockProblem(num_blocks=(args['XBLOCKS'], args['YBLOCKS']))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=m.sqrt(2) / args['--grid'])
print(discretization.parameter_info())
if args['--plot-solutions']:
print('Showing some solutions')
for mu in discretization.parameter_space.sample_randomly(2):
print('Solving for diffusion = \n{} ... '.format(mu['diffusion']))
sys.stdout.flush()
U = discretization.solve(mu)
discretization.visualize(U)
print('RB generation ...')
error_product = discretization.h1_product if args['--estimator-norm'] == 'h1' else None
reductors = {'default': partial(reduce_stationary_affine_linear, error_product=error_product),
'numpy_default': partial(numpy_reduce_stationary_affine_linear, error_product=error_product)}
reductor = reductors[args['--reductor']]
extension_algorithms = {'trivial': trivial_basis_extension,
'gram_schmidt': gram_schmidt_basis_extension,
'h1_gram_schmidt': partial(gram_schmidt_basis_extension, product=discretization.h1_product),
'numpy_trivial': numpy_trivial_basis_extension,
'numpy_gram_schmidt': numpy_gram_schmidt_basis_extension}
extension_algorithm = extension_algorithms[args['--extension-alg']]
greedy_data = greedy(discretization, reductor, discretization.parameter_space.sample_uniformly(args['SNAPSHOTS']),
use_estimator=args['--with-estimator'], error_norm=discretization.h1_norm,
extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE'])
rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor']
print('\nSearching for maximum error on random snapshots ...')
tic = time.time()
h1_err_max = -1
cond_max = -1
for mu in discretization.parameter_space.sample_randomly(args['--test']):
print('Solving RB-Scheme for mu = {} ... '.format(mu), end='')
URB = reconstructor.reconstruct(rb_discretization.solve(mu))
U = discretization.solve(mu)
h1_err = discretization.h1_norm(U - URB)[0]
cond = np.linalg.cond(rb_discretization.operator.assemble(mu)._matrix)
if h1_err > h1_err_max:
h1_err_max = h1_err
Umax = U
URBmax = URB
mumax = mu
if cond > cond_max:
cond_max = cond
cond_max_mu = mu
print('H1-error = {}, condition = {}'.format(h1_err, cond))
toc = time.time()
t_est = toc - tic
real_rb_size = len(greedy_data['data'])
print('''
*** RESULTS ***
Problem:
number of blocks: {args[XBLOCKS]}x{args[YBLOCKS]}
h: sqrt(2)/{args[--grid]}
Greedy basis generation:
number of snapshots: {args[SNAPSHOTS]}^({args[XBLOCKS]}x{args[YBLOCKS]})
used estimator: {args[--with-estimator]}
estimator norm: {args[--estimator-norm]}
extension method: {args[--extension-alg]}
prescribed basis size: {args[RBSIZE]}
actual basis size: {real_rb_size}
elapsed time: {greedy_data[time]}
Stochastic error estimation:
number of samples: {args[--test]}
maximal H1-error: {h1_err_max} (mu = {mumax})
maximal condition of system matrix: {cond_max} (mu = {cond_max_mu})
elapsed time: {t_est}
'''.format(**locals()))
sys.stdout.flush()
if args['--plot-err']:
discretization.visualize(U - URB)
