def discretize_fenics():
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
return mpi_wrap_model(_discretize_fenics, use_with=True, pickle_local_spaces=False)
else:
return _discretize_fenics()
def discretize_fenics():
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
return mpi_wrap_model(_discretize_fenics, use_with=True, pickle_local_spaces=False)
else:
return _discretize_fenics()
def discretize_fenics():
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
fom = mpi_wrap_model(_discretize_fenics, use_with=True, pickle_local_spaces=False)
else:
fom = _discretize_fenics()
return fom, fom.parameters.space((0.1, 1))
def discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order):
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
fom = mpi_wrap_model(lambda: _discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order),
use_with=True, pickle_local_spaces=False)
else:
fom = _discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order)
summary = f'''FEniCS model:
number of blocks: {xblocks}x{yblocks}
grid intervals: {grid_num_intervals}
finite element order: {element_order}
'''
return fom, summary
def discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order):
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
fom = mpi_wrap_model(lambda: _discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order),
use_with=True, pickle_local_spaces=False)
else:
fom = _discretize_fenics(xblocks, yblocks, grid_num_intervals, element_order)
summary = f'''FEniCS model:
number of blocks: {xblocks}x{yblocks}
grid intervals: {grid_num_intervals}
finite element order: {element_order}
'''
return fom, summary
def main(
dim: int = Argument(..., help='Spatial dimension of the problem.'),
n: int = Argument(
..., help='Number of mesh intervals per spatial dimension.'),
order: int = Argument(..., help='Finite element order.'),
):
"""Reduces a FEniCS-based nonlinear diffusion problem using POD/DEIM."""
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
local_models = mpi.call(mpi.function_call_manage, discretize, dim, n,
order)
fom = mpi_wrap_model(local_models,
use_with=True,
pickle_local_spaces=False)
else:
fom = discretize(dim, n, order)
parameter_space = fom.parameters.space((0, 1000.))
# ### ROM generation (POD/DEIM)
from pymor.algorithms.ei import ei_greedy
from pymor.algorithms.newton import newton
from pymor.algorithms.pod import pod
from pymor.operators.ei import EmpiricalInterpolatedOperator
from pymor.reductors.basic import StationaryRBReductor
U = fom.solution_space.empty()
residuals = fom.solution_space.empty()
for mu in parameter_space.sample_uniformly(10):
UU, data = newton(fom.operator,
fom.rhs.as_vector(),
mu=mu,
rtol=1e-6,
return_residuals=True)
U.append(UU)
residuals.append(data['residuals'])
dofs, cb, _ = ei_greedy(residuals, rtol=1e-7)
ei_op = EmpiricalInterpolatedOperator(fom.operator,
collateral_basis=cb,
interpolation_dofs=dofs,
triangular=True)
rb, svals = pod(U, rtol=1e-7)
fom_ei = fom.with_(operator=ei_op)
reductor = StationaryRBReductor(fom_ei, rb)
rom = reductor.reduce()
# the reductor currently removes all solver_options so we need to add them again
rom = rom.with_(operator=rom.operator.with_(
solver_options=fom.operator.solver_options))
# ### ROM validation
import time
import numpy as np
# ensure that FFC is not called during runtime measurements
rom.solve(1)
errs = []
speedups = []
for mu in parameter_space.sample_randomly(10):
tic = time.perf_counter()
U = fom.solve(mu)
t_fom = time.perf_counter() - tic
tic = time.perf_counter()
u_red = rom.solve(mu)
t_rom = time.perf_counter() - tic
U_red = reductor.reconstruct(u_red)
errs.append(((U - U_red).norm() / U.norm())[0])
speedups.append(t_fom / t_rom)
print(f'Maximum relative ROM error: {max(errs)}')
print(f'Median of ROM speedup: {np.median(speedups)}')
def fenics_nonlinear_demo(args):
DIM = int(args['DIM'])
N = int(args['N'])
ORDER = int(args['ORDER'])
from pymor.tools import mpi
if mpi.parallel:
from pymor.models.mpi import mpi_wrap_model
local_models = mpi.call(mpi.function_call_manage, discretize, DIM, N,
ORDER)
fom = mpi_wrap_model(local_models,
use_with=True,
pickle_local_spaces=False)
else:
fom = discretize(DIM, N, ORDER)
# ### ROM generation (POD/DEIM)
from pymor.algorithms.ei import ei_greedy
from pymor.algorithms.newton import newton
from pymor.algorithms.pod import pod
from pymor.operators.ei import EmpiricalInterpolatedOperator
from pymor.reductors.basic import StationaryRBReductor
U = fom.solution_space.empty()
residuals = fom.solution_space.empty()
for mu in fom.parameter_space.sample_uniformly(10):
UU, data = newton(fom.operator,
fom.rhs.as_vector(),
mu=mu,
rtol=1e-6,
return_residuals=True)
U.append(UU)
residuals.append(data['residuals'])
dofs, cb, _ = ei_greedy(residuals, rtol=1e-7)
ei_op = EmpiricalInterpolatedOperator(fom.operator,
collateral_basis=cb,
interpolation_dofs=dofs,
triangular=True)
rb, svals = pod(U, rtol=1e-7)
fom_ei = fom.with_(operator=ei_op)
reductor = StationaryRBReductor(fom_ei, rb)
rom = reductor.reduce()
# the reductor currently removes all solver_options so we need to add them again
rom = rom.with_(operator=rom.operator.with_(
solver_options=fom.operator.solver_options))
# ### ROM validation
import time
import numpy as np
# ensure that FFC is not called during runtime measurements
rom.solve(1)
errs = []
speedups = []
for mu in fom.parameter_space.sample_randomly(10):
tic = time.time()
U = fom.solve(mu)
t_fom = time.time() - tic
tic = time.time()
u_red = rom.solve(mu)
t_rom = time.time() - tic
U_red = reductor.reconstruct(u_red)
errs.append(((U - U_red).l2_norm() / U.l2_norm())[0])
speedups.append(t_fom / t_rom)
print(f'Maximum relative ROM error: {max(errs)}')
print(f'Median of ROM speedup: {np.median(speedups)}')
