def elliptic_oned_demo(args):
args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER'])
assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError('Invalid problem number.')
args['N'] = int(args['N'])
rhss = [GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, dim_domain=1),
GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, dim_domain=1)]
rhs = rhss[args['PROBLEM-NUMBER']]
d0 = GenericFunction(lambda X: 1 - X[..., 0], dim_domain=1)
d1 = GenericFunction(lambda X: X[..., 0], dim_domain=1)
parameter_space = CubicParameterSpace({'diffusionl': 0}, 0.1, 1)
f0 = ProjectionParameterFunctional('diffusionl', 0)
f1 = GenericParameterFunctional(lambda mu: 1, {})
print('Solving on OnedGrid(({0},{0}))'.format(args['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),
name='1DProblem')
print('Discretize ...')
discretizer = discretize_elliptic_fv if args['--fv'] else discretize_elliptic_cg
discretization, _ = discretizer(problem, diameter=1 / args['N'])
print('The parameter type is {}'.format(discretization.parameter_type))
U = discretization.solution_space.empty()
for mu in parameter_space.sample_uniformly(10):
U.append(discretization.solve(mu))
print('Plot ...')
discretization.visualize(U, title='Solution for diffusionl in [0.1, 1]')
def elliptic_part(self):
return EllipticProblem(
domain=self.domain,
rhs=self.rhs,
diffusion_functions=self.diffusion_functions,
diffusion_functionals=self.diffusion_functionals,
dirichlet_data=self.dirichlet_data,
neumann_data=self.neumann_data,
parameter_space=self.parameter_space,
name='{}_elliptic_part'.format(self.name))
def elliptic_demo(args):
args['PROBLEM-NUMBER'] = int(args['PROBLEM-NUMBER'])
assert 0 <= args['PROBLEM-NUMBER'] <= 1, ValueError('Invalid problem number')
args['DIRICHLET-NUMBER'] = int(args['DIRICHLET-NUMBER'])
assert 0 <= args['DIRICHLET-NUMBER'] <= 2, ValueError('Invalid Dirichlet boundary number.')
args['NEUMANN-NUMBER'] = int(args['NEUMANN-NUMBER'])
assert 0 <= args['NEUMANN-NUMBER'] <= 2, ValueError('Invalid Neumann boundary number.')
args['NEUMANN-COUNT'] = int(args['NEUMANN-COUNT'])
assert 0 <= args['NEUMANN-COUNT'] <= 3, ValueError('Invalid Neumann boundary count.')
rhss = [GenericFunction(lambda X: np.ones(X.shape[:-1]) * 10, 2),
GenericFunction(lambda X: (X[..., 0] - 0.5) ** 2 * 1000, 2)]
dirichlets = [GenericFunction(lambda X: np.zeros(X.shape[:-1]), 2),
GenericFunction(lambda X: np.ones(X.shape[:-1]), 2),
GenericFunction(lambda X: X[..., 0], 2)]
neumanns = [None,
ConstantFunction(3., dim_domain=2),
GenericFunction(lambda X: 50*(0.1 <= X[..., 1]) * (X[..., 1] <= 0.2)
+50*(0.8 <= X[..., 1]) * (X[..., 1] <= 0.9), 2)]
domains = [RectDomain(),
RectDomain(right=BoundaryType('neumann')),
RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann')),
RectDomain(right=BoundaryType('neumann'), top=BoundaryType('neumann'), bottom=BoundaryType('neumann'))]
rhs = rhss[args['PROBLEM-NUMBER']]
dirichlet = dirichlets[args['DIRICHLET-NUMBER']]
neumann = neumanns[args['NEUMANN-NUMBER']]
domain = domains[args['NEUMANN-COUNT']]
for n in [32, 128]:
grid_name = '{1}(({0},{0}))'.format(n, 'RectGrid' if args['--rect'] else 'TriaGrid')
print('Solving on {0}'.format(grid_name))
print('Setup problem ...')
problem = EllipticProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, neumann_data=neumann)
print('Discretize ...')
if args['--rect']:
grid, bi = discretize_domain_default(problem.domain, diameter=m.sqrt(2) / n, grid_type=RectGrid)
else:
grid, bi = discretize_domain_default(problem.domain, diameter=1. / n, grid_type=TriaGrid)
discretizer = discretize_elliptic_fv if args['--fv'] else discretize_elliptic_cg
discretization, _ = discretizer(analytical_problem=problem, grid=grid, boundary_info=bi)
print('Solve ...')
U = discretization.solve()
print('Plot ...')
discretization.visualize(U, title=grid_name)
print('')
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 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()
try:
visualize_patch(data['grid'], U=U, backend=backend)
except PySideMissing as ie:
pytest.xfail("PySide missing")
finally:
stop_gui_processes()
return result
if __name__ == "__main__":
from pymor.analyticalproblems.elliptic import EllipticProblem
from pymor.domaindescriptions.basic import RectDomain
from pymor.functions.basic import ConstantFunction
from my_discretize_elliptic_cg import discretize_elliptic_cg
from lmor.localizer import NumpyLocalizer
from lmor.partitioner import build_subspaces, partition_any_grid
coarse_grid_resolution = 10
p = EllipticProblem(domain=RectDomain([[0, 0], [1, 1]]),
diffusion_functions=(ConstantFunction(1.,
dim_domain=2), ),
diffusion_functionals=(1., ),
rhs=ConstantFunction(1., dim_domain=2))
d, data = discretize_elliptic_cg(p, diameter=0.01)
grid = data["grid"]
subspaces, subspaces_per_codim = build_subspaces(*partition_any_grid(
grid, num_intervals=(coarse_grid_resolution, coarse_grid_resolution)))
localizer = NumpyLocalizer(d.solution_space, subspaces['dofs'])
images = d.solution_space.empty()
fdict = localized_pou(subspaces, subspaces_per_codim, localizer,
coarse_grid_resolution, grid)
for space in sorted(fdict):
lvec = localizer.localize_vector_array(
def thermalblock_demo(args):
args['--grid'] = int(args['--grid'])
args['RBSIZE'] = int(args['RBSIZE'])
args['--test'] = int(args['--test'])
args['--ipython-engines'] = int(args['--ipython-engines'])
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'}
args['--reductor'] = args['--reductor'].lower()
assert args['--reductor'] in {'traditional', 'residual_basis'}
args['--cache-region'] = args['--cache-region'].lower()
args['--validation-mus'] = int(args['--validation-mus'])
args['--rho'] = float(args['--rho'])
args['--gamma'] = float(args['--gamma'])
args['--theta'] = float(args['--theta'])
print('Solving on TriaGrid(({0},{0}))'.format(args['--grid']))
print('Setup Problem ...')
problem = ThermalBlockProblem(num_blocks=(2, 2))
functionals = [ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[1]**2', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[0]', {'diffusion': (2,)}),
ExpressionParameterFunctional('diffusion[1]', {'diffusion': (2,)})]
problem = EllipticProblem(domain=problem.domain,
diffusion_functions=problem.diffusion_functions,
diffusion_functionals=functionals,
rhs=problem.rhs,
parameter_space=CubicParameterSpace({'diffusion': (2,)}, 0.1, 1.))
print('Discretize ...')
discretization, _ = discretize_elliptic_cg(problem, diameter=1. / args['--grid'])
if args['--list-vector-array']:
from pymor.playground.discretizers.numpylistvectorarray import convert_to_numpy_list_vector_array
discretization = convert_to_numpy_list_vector_array(discretization)
if args['--cache-region'] != 'none':
discretization.enable_caching(args['--cache-region'])
print('The parameter type is {}'.format(discretization.parameter_type))
if args['--plot-solutions']:
print('Showing some solutions')
Us = ()
legend = ()
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 ...')
product = discretization.h1_0_semi_product if args['--estimator-norm'] == 'h1' else None
coercivity_estimator=ExpressionParameterFunctional('min([diffusion[0], diffusion[1]**2])', discretization.parameter_type)
reductors = {'residual_basis': partial(reduce_coercive, product=product,
coercivity_estimator=coercivity_estimator),
'traditional': partial(reduce_coercive_simple, product=product,
coercivity_estimator=coercivity_estimator)}
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_0_semi_product)}
extension_algorithm = extension_algorithms[args['--extension-alg']]
pool = new_parallel_pool(ipython_num_engines=args['--ipython-engines'], ipython_profile=args['--ipython-profile'])
greedy_data = adaptive_greedy(discretization, reductor,
validation_mus=args['--validation-mus'], rho=args['--rho'], gamma=args['--gamma'],
theta=args['--theta'],
use_estimator=not args['--without-estimator'], error_norm=discretization.h1_0_semi_norm,
extension_algorithm=extension_algorithm, max_extensions=args['RBSIZE'],
visualize=args['--visualize-refinement'])
rb_discretization, reconstructor = greedy_data['reduced_discretization'], greedy_data['reconstructor']
if args['--pickle']:
print('\nWriting reduced discretization to file {} ...'.format(args['--pickle'] + '_reduced'))
with open(args['--pickle'] + '_reduced', 'wb') as f:
dump(rb_discretization, f)
print('Writing detailed discretization and reconstructor to file {} ...'.format(args['--pickle'] + '_detailed'))
with open(args['--pickle'] + '_detailed', 'wb') as f:
dump((discretization, reconstructor), f)
print('\nSearching for maximum error on random snapshots ...')
results = reduction_error_analysis(rb_discretization,
discretization=discretization,
reconstructor=reconstructor,
estimator=True,
error_norms=(discretization.h1_0_semi_norm,),
condition=True,
test_mus=args['--test'],
basis_sizes=25 if args['--plot-error-sequence'] else 1,
plot=True,
pool=pool)
real_rb_size = rb_discretization.solution_space.dim
print('''
*** RESULTS ***
Problem:
number of blocks: 2x2
h: sqrt(2)/{args[--grid]}
Greedy basis generation:
estimator disabled: {args[--without-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]}
'''.format(**locals()))
print(results['summary'])
sys.stdout.flush()
if args['--plot-error-sequence']:
from matplotlib import pyplot as plt
plt.show(results['figure'])
if args['--plot-err']:
mumax = results['max_error_mus'][0, -1]
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)
thermalblock_problems = picklable_thermalblock_problems + non_picklable_thermalblock_problems
burgers_problems = \
[BurgersProblem(),
BurgersProblem(v=0.2, circle=False),
BurgersProblem(v=0.4, initial_data_type='bump'),
BurgersProblem(parameter_range=(1., 1.3)),
Burgers2DProblem(),
Burgers2DProblem(torus=False, initial_data_type='bump', parameter_range=(1.3, 1.5))]
picklable_elliptic_problems = \
[EllipticProblem()]
non_picklable_elliptic_problems = \
[EllipticProblem(rhs=ConstantFunction(dim_domain=2, value=21.),
diffusion_functions=[GenericFunction(dim_domain=2,
mapping=lambda X,p=p: X[...,0]**p) for p in range(5)],
diffusion_functionals=[ExpressionParameterFunctional('max(mu["exp"], {})'.format(m),
parameter_type={'exp': ()})
for m in range(5)])]
elliptic_problems = picklable_thermalblock_problems + non_picklable_elliptic_problems
picklable_advection_problems = \