def thermalblock_factory(xblocks, yblocks, diameter, seed):
from pymor.analyticalproblems.thermalblock import thermal_block_problem
from pymor.discretizers.cg import discretize_stationary_cg
from pymor.functions.basic import GenericFunction
from pymor.operators.cg import InterpolationOperator
p = thermal_block_problem((xblocks, yblocks))
d, d_data = discretize_stationary_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 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 discretize_instationary_cg(analytical_problem,
diameter=None,
domain_discretizer=None,
grid_type=None,
grid=None,
boundary_info=None,
num_values=None,
time_stepper=None,
nt=None,
preassemble=True):
"""Discretizes an |InstationaryProblem| with a |StationaryProblem| as stationary part
using finite elements.
Parameters
----------
analytical_problem
The |InstationaryProblem| to discretize.
diameter
If not `None`, `diameter` is passed as an argument to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If `None`, |discretize_domain_default| is used.
grid_type
If not `None`, this parameter is forwarded to `domain_discretizer` to specify
the type of the generated |Grid|.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The :class:`time-stepper <pymor.algorithms.timestepping.TimeStepperInterface>`
to be used by :class:`~pymor.models.basic.InstationaryModel.solve`.
nt
If `time_stepper` is not specified, the number of time steps for implicit
Euler time stepping.
preassemble
If `True`, preassemble all operators in the resulting |Model|.
Returns
-------
m
The |Model| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
:unassembled_m: In case `preassemble` is `True`, the generated |Model|
before preassembling operators.
"""
assert isinstance(analytical_problem, InstationaryProblem)
assert isinstance(analytical_problem.stationary_part, StationaryProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert (time_stepper is None) != (nt is None)
p = analytical_problem
m, data = discretize_stationary_cg(p.stationary_part,
diameter=diameter,
domain_discretizer=domain_discretizer,
grid_type=grid_type,
grid=grid,
boundary_info=boundary_info)
if p.initial_data.parametric:
I = InterpolationOperator(data['grid'], p.initial_data)
else:
I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim))
I = m.solution_space.make_array(I)
if time_stepper is None:
if p.stationary_part.diffusion is None:
time_stepper = ExplicitEulerTimeStepper(nt=nt)
else:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
mass = m.l2_0_product
m = InstationaryModel(operator=m.operator,
rhs=m.rhs,
mass=mass,
initial_data=I,
T=p.T,
products=m.products,
output_functional=m.output_functional,
time_stepper=time_stepper,
parameter_space=p.parameter_space,
visualizer=m.visualizer,
num_values=num_values,
name=f'{p.name}_CG')
if preassemble:
data['unassembled_m'] = m
m = preassemble_(m)
return m, data
def discretize_parabolic_cg(analytical_problem, diameter=None, domain_discretizer=None,
grid=None, boundary_info=None, num_values=None, time_stepper=None, nt=None):
"""Discretizes an |ParabolicProblem| using finite elements.
Parameters
----------
analytical_problem
The |ParabolicProblem| to discretize.
diameter
If not `None`, `diameter` is passed to the `domain_discretizer`.
domain_discretizer
Discretizer to be used for discretizing the analytical domain. This has
to be a function `domain_discretizer(domain_description, diameter, ...)`.
If further arguments should be passed to the discretizer, use
:func:`functools.partial`. If `None`, |discretize_domain_default| is used.
grid
Instead of using a domain discretizer, the |Grid| can also be passed directly
using this parameter.
boundary_info
A |BoundaryInfo| specifying the boundary types of the grid boundary entities.
Must be provided if `grid` is specified.
num_values
The number of returned vectors of the solution trajectory. If `None`, each
intermediate vector that is calculated is returned.
time_stepper
The time-stepper to be used by :class:`~pymor.discretizations.basic.InstationaryDiscretization.solve`. Has to
satisfy the :class:`~pymor.algorithms.timestepping.TimeStepperInterface`.
nt
The number of time-steps. If provided implicit euler time-stepping is used.
Returns
-------
discretization
The |Discretization| that has been generated.
data
Dictionary with the following entries:
:grid: The generated |Grid|.
:boundary_info: The generated |BoundaryInfo|.
"""
assert isinstance(analytical_problem, ParabolicProblem)
assert grid is None or boundary_info is not None
assert boundary_info is None or grid is not None
assert grid is None or domain_discretizer is None
assert time_stepper is None or nt is None
p = analytical_problem
d, data = discretize_elliptic_cg(p.elliptic_part(), diameter=diameter, domain_discretizer=domain_discretizer,
grid=grid, boundary_info=boundary_info)
if p.initial_data.parametric:
I = InterpolationOperator(data['grid'], p.initial_data)
else:
I = p.initial_data.evaluate(data['grid'].centers(data['grid'].dim))
I = NumpyVectorArray(I, copy=False)
if time_stepper is None:
time_stepper = ImplicitEulerTimeStepper(nt=nt)
mass = d.l2_0_product
discretization = InstationaryDiscretization(operator=d.operator, rhs=d.rhs, mass=mass, initial_data=I, T=p.T,
products=d.products, time_stepper=time_stepper,
parameter_space=d.parameter_space, visualizer=d.visualizer,
num_values=num_values, name='{}_CG'.format(p.name))
return discretization, data