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 test_lincomb_function():
for steps in (1, 10):
x = np.linspace(0, 1, num=steps)
zero = ConstantFunction(0.0, dim_domain=steps)
for zero in (ConstantFunction(0.0, dim_domain=steps),
GenericFunction(lambda X: np.zeros(X.shape[:-1]),
dim_domain=steps)):
for one in (ConstantFunction(1.0, dim_domain=steps),
GenericFunction(lambda X: np.ones(X.shape[:-1]),
dim_domain=steps), 1.0):
add = (zero + one) + 0
sub = (zero - one) + np.zeros(())
neg = -zero
assert np.allclose(sub(x), [-1])
assert np.allclose(add(x), [1.0])
assert np.allclose(neg(x), [0.0])
(repr(add), str(add), repr(one), str(one)
) # just to cover the respective special funcs too
mul = neg * 1.
assert np.allclose(mul(x), [0.0])
with pytest.raises(AssertionError):
zero + ConstantFunction(dim_domain=steps + 1)
with pytest.raises(AssertionError):
zero * ConstantFunction(dim_domain=steps)
with pytest.raises(AssertionError):
ConstantFunction(dim_domain=0)
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 = StationaryProblem(domain=domain, rhs=rhs, dirichlet_data=dirichlet, diffusion=diffusion)
grid, bi = discretize_domain_default(problem.domain, grid_type=gridtype)
m, data = discretize_stationary_cg(analytical_problem=problem, grid=grid, boundary_info=bi)
U = m.solve()
try:
visualize_patch(data['grid'], U=U, backend=backend)
except QtMissing as ie:
pytest.xfail("Qt missing")
finally:
stop_gui_processes()
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 thermalblock_factory(xblocks, yblocks, diameter, seed):
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.discretizers.elliptic import discretize_elliptic_cg
from pymor.functions.basic import GenericFunction
from pymor.operators.cg import InterpolationOperator
p = ThermalBlockProblem((xblocks, yblocks))
d, d_data = discretize_elliptic_cg(p, diameter)
f = GenericFunction(lambda X, mu: X[..., 0]**mu['exp'] + X[..., 1],
dim_domain=2, parameter_type={'exp': ()})
iop = InterpolationOperator(d_data['grid'], f)
U = d.operator.source.empty()
V = d.operator.range.empty()
np.random.seed(seed)
for exp in np.random.random(5):
U.append(iop.as_vector(exp))
for exp in np.random.random(6):
V.append(iop.as_vector(exp))
return d.operator, d.parameter_space.sample_randomly(1, seed=seed)[0], U, V, d.h1_product, d.l2_product
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('')
from pymor.analyticalproblems.helmholtz import helmholtz_problem
from pymor.analyticalproblems.thermalblock import thermal_block_problem
from pymor.functions.basic import GenericFunction, ConstantFunction, LincombFunction
from pymor.parameters.functionals import ExpressionParameterFunctional
picklable_thermalblock_problems = \
[thermal_block_problem(),
thermal_block_problem(num_blocks=(3, 2)),
thermal_block_problem(num_blocks=(1, 1)),
thermal_block_problem(num_blocks=(2, 2), parameter_range=(1., 100.))]
non_picklable_thermalblock_problems = \
[thermal_block_problem(num_blocks=(1, 3), parameter_range=(0.4, 0.5)).with_(
rhs=GenericFunction(dim_domain=2, mapping=lambda X: X[..., 0] + X[..., 1]))]
thermalblock_problems = picklable_thermalblock_problems + non_picklable_thermalblock_problems
burgers_problems = \
[burgers_problem(),
burgers_problem(v=0.2, circle=False),
burgers_problem(v=0.4, initial_data_type='bump'),
burgers_problem(parameter_range=(1., 1.3)),
burgers_problem_2d(),
burgers_problem_2d(torus=False, initial_data_type='bump', parameter_range=(1.3, 1.5))]
picklable_elliptic_problems = \
[StationaryProblem(domain=RectDomain(), rhs=ConstantFunction(dim_domain=2, value=1.)),
class A:
@staticmethod
def unimportable_function(x):
return np.max(x, axis=-1)
def get_function_with_closure(y):
def function_with_closure(x):
return np.concatenate((x + y, x - y), axis=-1)
return function_with_closure
generic_functions = \
[GenericFunction(lambda x: x, dim_domain=2, shape_range=(2,)),
GenericFunction(lambda x, mu: mu['c']*x, dim_domain=1, shape_range=(1,), parameter_type={'c': ()}),
GenericFunction(A.unimportable_function, dim_domain=7, shape_range=()),
GenericFunction(get_function_with_closure(42), dim_domain=1, shape_range=(2,))]
picklable_generic_functions = \
[GenericFunction(importable_function, dim_domain=3, shape_range=(1,))]
expression_functions = \
[ExpressionFunction('x', dim_domain=2, shape_range=(2,)),
ExpressionFunction("c*x", dim_domain=1, shape_range=(1,), parameter_type={'c': ()}),
ExpressionFunction("c[2]*sin(x)", dim_domain=1, shape_range=(1,), parameter_type={'c': (3,)})]
@pytest.fixture(params=constant_functions + generic_functions +
from pymor.analyticalproblems.elliptic import EllipticProblem
from pymor.analyticalproblems.thermalblock import ThermalBlockProblem
from pymor.functions.basic import GenericFunction, ConstantFunction
from pymor.parameters.functionals import ExpressionParameterFunctional
picklable_thermalblock_problems = \
[ThermalBlockProblem(),
ThermalBlockProblem(num_blocks=(3, 2)),
ThermalBlockProblem(num_blocks=(1, 1)),
ThermalBlockProblem(num_blocks=(2, 2), parameter_range=(1., 100.))]
non_picklable_thermalblock_problems = \
[ThermalBlockProblem(num_blocks=(1, 3), parameter_range=(0.4, 0.5),
rhs=GenericFunction(dim_domain=2, mapping=lambda X: X[..., 0] + X[..., 1]))]
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 = \