def _rush_larsen_scheme_generator_adm(rhs_form, solution, time, order,
generalized, perturbation):
"""Generates a list of forms and solutions for the adjoint
linearisation of the Rush-Larsen scheme
*Arguments*
rhs_form (ufl.Form)
A UFL form representing the rhs for a time differentiated equation
solution (_Function_)
The prognostic variable
time (_Constant_)
A Constant holding the time at the start of the time step
order (int)
The order of the scheme
generalized (bool)
If True generate a generalized Rush Larsen scheme, linearizing all
components.
perturbation (Function)
The vector on which we compute the adjoint action.
"""
DX = _check_form(rhs_form)
if DX != ufl.dP:
raise TypeError("Expected a form with a Pointintegral.")
# Create time step
dt = Constant(0.1)
# Get test function
# arguments = rhs_form.arguments()
# coefficients = rhs_form.coefficients()
# Get time dependent expressions
time_dep_expressions = _time_dependent_expressions(rhs_form, time)
# Extract rhs expressions from form
rhs_integrand = rhs_form.integrals()[0].integrand()
rhs_exprs, v = extract_tested_expressions(rhs_integrand)
vector_rhs = len(v.ufl_shape) > 0 and v.ufl_shape[0] > 1
system_size = v.ufl_shape[0] if vector_rhs else 1
# Fix for indexing of v for scalar expressions
v = v if vector_rhs else [v]
# Extract linear terms if not using generalized Rush Larsen
if not generalized:
linear_terms = _find_linear_terms(rhs_exprs, solution)
else:
linear_terms = [True for _ in range(system_size)]
# Wrap the rhs expressions into a ufl vector type
rhs_exprs = ufl.as_vector([rhs_exprs[i] for i in range(system_size)])
rhs_jac = ufl.diff(rhs_exprs, solution)
# Takes time!
if vector_rhs:
diff_rhs_exprs = [expand_indices(expand_derivatives(rhs_jac[ind, ind]))
for ind in range(system_size)]
soln = solution
else:
diff_rhs_exprs = [expand_indices(expand_derivatives(rhs_jac[0]))]
solution = [solution]
soln = solution[0]
ufl_stage_forms = []
dolfin_stage_forms = []
dt_stage_offsets = []
trial = TrialFunction(soln.function_space())
# Stage solutions (3 per order rhs, linearized, and final step)
# If 2nd order the final step for 1 step is a stage
if order == 1:
stage_solutions = []
# Fetch the original step
rl_ufl_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs,
linear_terms, system_size,
solution, None, dt, time, 1.0,
0.0, v, DX,
time_dep_expressions)
# If this is commented out, we don't get NaNs. Yhy is
# solution a list of length zero anyway?
rl_ufl_form = safe_action(safe_adjoint(derivative(rl_ufl_form, soln, trial)),
perturbation)
elif order == 2:
# Stage solution for order 2
fn_space = soln.function_space()
stage_solutions = [Function(fn_space, name="y_1/2"),
Function(fn_space, name="y_1"),
Function(fn_space, name="y_bar_1/2")]
y_half_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs,
linear_terms, system_size,
solution, None, dt, time, 0.5,
0.0, v, DX,
time_dep_expressions)
y_one_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs,
linear_terms, system_size,
solution, stage_solutions[0],
dt, time, 1.0, 0.5, v, DX,
time_dep_expressions)
y_bar_half_form = safe_action(safe_adjoint(derivative(y_one_form,
stage_solutions[0], trial)), perturbation)
rl_ufl_form = safe_action(safe_adjoint(derivative(y_one_form, soln, trial)), perturbation) + \
safe_action(safe_adjoint(derivative(y_half_form, soln, trial)), stage_solutions[2])
ufl_stage_forms.append([y_half_form])
ufl_stage_forms.append([y_one_form])
ufl_stage_forms.append([y_bar_half_form])
dolfin_stage_forms.append([Form(y_half_form)])
dolfin_stage_forms.append([Form(y_one_form)])
dolfin_stage_forms.append([Form(y_bar_half_form)])
# Get last stage form
last_stage = Form(rl_ufl_form)
human_form = "%srush larsen %s" % ("generalized " if generalized else "",
str(order))
return rhs_form, linear_terms, ufl_stage_forms, dolfin_stage_forms, last_stage, \
stage_solutions, dt, dt_stage_offsets, human_form, perturbation
def _rush_larsen_scheme_generator(rhs_form, solution, time, order, generalized):
"""Generates a list of forms and solutions for a given Butcher
tableau
*Arguments*
rhs_form (ufl.Form)
A UFL form representing the rhs for a time differentiated equation
solution (_Function_)
The prognostic variable
time (_Constant_)
A Constant holding the time at the start of the time step
order (int)
The order of the scheme
generalized (bool)
If True generate a generalized Rush Larsen scheme, linearizing all
components.
"""
DX = _check_form(rhs_form)
if DX != ufl.dP:
raise TypeError("Expected a form with a Pointintegral.")
# Create time step
dt = Constant(0.1)
# Get test function
# arguments = rhs_form.arguments()
# coefficients = rhs_form.coefficients()
# Get time dependent expressions
time_dep_expressions = _time_dependent_expressions(rhs_form, time)
# Extract rhs expressions from form
rhs_integrand = rhs_form.integrals()[0].integrand()
rhs_exprs, v = extract_tested_expressions(rhs_integrand)
vector_rhs = len(v.ufl_shape) > 0 and v.ufl_shape[0] > 1
system_size = v.ufl_shape[0] if vector_rhs else 1
# Fix for indexing of v for scalar expressions
v = v if vector_rhs else [v]
# Extract linear terms if not using generalized Rush Larsen
if not generalized:
linear_terms = _find_linear_terms(rhs_exprs, solution)
else:
linear_terms = [True for _ in range(system_size)]
# Wrap the rhs expressions into a ufl vector type
rhs_exprs = ufl.as_vector([rhs_exprs[i] for i in range(system_size)])
rhs_jac = ufl.diff(rhs_exprs, solution)
# Takes time!
if vector_rhs:
diff_rhs_exprs = [expand_indices(expand_derivatives(rhs_jac[ind, ind]))
for ind in range(system_size)]
else:
diff_rhs_exprs = [expand_indices(expand_derivatives(rhs_jac[0]))]
solution = [solution]
ufl_stage_forms = []
dolfin_stage_forms = []
dt_stage_offsets = []
# Stage solutions (3 per order rhs, linearized, and final step)
# If 2nd order the final step for 1 step is a stage
if order == 1:
stage_solutions = []
rl_ufl_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs, linear_terms,
system_size, solution, None, dt, time, 1.0,
0.0, v, DX, time_dep_expressions)
elif order == 2:
# Stage solution for order 2
if vector_rhs:
stage_solutions = [Function(solution.function_space(), name="y_1/2")]
else:
stage_solutions = [Function(solution[0].function_space(), name="y_1/2")]
stage_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs,
linear_terms, system_size,
solution, None, dt, time, 0.5,
0.0, v, DX,
time_dep_expressions)
rl_ufl_form = _rush_larsen_step(rhs_exprs, diff_rhs_exprs,
linear_terms, system_size,
solution, stage_solutions[0],
dt, time, 1.0, 0.5, v, DX,
time_dep_expressions)
ufl_stage_forms.append([stage_form])
dolfin_stage_forms.append([Form(stage_form)])
# Get last stage form
last_stage = Form(rl_ufl_form)
human_form = "%srush larsen %s" % ("generalized " if generalized else "",
str(order))
return rhs_form, linear_terms, ufl_stage_forms, dolfin_stage_forms, last_stage, \
stage_solutions, dt, dt_stage_offsets, human_form, None
