def actual_solution(self, Z):
# Taken from 'EFFECTS OF GRID STAGGERING ON NUMERICAL SCHEMES - Shih, Tan, Hwang'
X = SpatialCoordinate(Z.mesh())
(x, y) = X
""" Either implement the form in the paper by Shih, Tan, Hwang and then
use ufl to rescale, or just implement the rescaled version directly """
f = x**4 - 2 * x**3 + x**2
g = y**4 - y**2
from ufl.algorithms.apply_derivatives import apply_derivatives
df = apply_derivatives(grad(f)[0])
dg = apply_derivatives(grad(g)[1])
ddg = apply_derivatives(grad(dg)[1])
dddg = apply_derivatives(grad(ddg)[1])
F = 0.2 * x**5 - 0.5 * x**4 + (1. / 3.) * x**3
F1 = -4 * x**6 + 12 * x**5 - 14 * x**4 + 8 * x**3 - 2 * x**2
F2 = 0.5 * f**2
G1 = -24 * y**5 + 8 * y**3 - 4 * y
u = 8 * f * dg
v = -8 * df * g
p = (8. / self.Re) * (F * dddg + df * dg) + 64 * F2 * (g * ddg - dg**2)
u = replace(u, {X: 0.5 * X})
v = replace(v, {X: 0.5 * X})
p = replace(p, {X: 0.5 * X})
p = p - 0.25 * assemble(p * dx)
# u = (1./4.)*(-2 + x)**2 * x**2 * y * (-2 + y**2)
# v = -(1./4.)*x*(2 - 3*x + x**2)*y**2*(-4 + y**2)
# p = -(1./128.)*(-2+x)**4*x**4*y**2*(8-2*y**2+y**4)+(x*y*(-15*x**3+3*x**4+10*x**2*y**2+20*(-2+y**2)-30*x*(-2+y**2)))/(5*self.Re)
# p = p - (-(1408./33075.) + 8./(5*self.Re))
driver = as_vector([u, v])
return (driver, p)
def preprocess_expression(expression, complex_mode=False,
do_apply_restrictions=False):
"""Imitates the compute_form_data processing pipeline.
:arg complex_mode: Are we in complex UFL mode?
:arg do_apply_restrictions: Propogate restrictions to terminals?
Useful, for example, to preprocess non-scalar expressions, which
are not and cannot be forms.
"""
if complex_mode:
expression = do_comparison_check(expression)
else:
expression = remove_complex_nodes(expression)
expression = apply_algebra_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_function_pullbacks(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
if not complex_mode:
expression = remove_complex_nodes(expression)
if do_apply_restrictions:
expression = apply_restrictions(expression)
return expression
def preprocess_expression(expression):
"""Imitates the compute_form_data processing pipeline.
Useful, for example, to preprocess non-scalar expressions, which
are not and cannot be forms.
"""
expression = apply_algebra_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_function_pullbacks(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
return expression
def preprocess_expression(expression):
"""Imitates the compute_form_data processing pipeline.
Useful, for example, to preprocess non-scalar expressions, which
are not and cannot be forms.
"""
expression = apply_algebra_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_function_pullbacks(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
expression = apply_geometry_lowering(expression, preserve_geometry_types)
expression = apply_derivatives(expression)
return expression
def generateCode(predefined, expressions, coefficients=None, tempVars=True):
expressions = [applyRestrictions(expand_indices(apply_derivatives(apply_algebra_lowering(expr)))) for expr in expressions]
generator = CodeGenerator(predefined, coefficients, tempVars)
results = map_expr_dags(generator, expressions)
l = list(generator.using)
l.sort()
return l + generator.code, results
def test_literal_derivatives_are_zero():
cell = triangle
d = cell.geometric_dimension()
# Literals
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
E = PermutationSymbol(d)
literals = [one, two, I]
# Generic ruleset handles literals directly:
for l in literals:
for sh in [(), (d, ), (d, d + 1)]:
assert GenericDerivativeRuleset(sh)(l) == zero(l.ufl_shape + sh)
# Variables
v0 = variable(one)
v1 = variable(zero((d, )))
v2 = variable(I)
variables = [v0, v1, v2]
# Test literals via apply_derivatives and variable ruleset:
for l in literals:
for v in variables:
assert apply_derivatives(diff(l, v)) == zero(l.ufl_shape +
v.ufl_shape)
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
u0 = Coefficient(V0)
u1 = Coefficient(V1)
v0 = TestFunction(V0)
v1 = TestFunction(V1)
args = [(u0, v0), (u1, v1)]
# Test literals via apply_derivatives and variable ruleset:
for l in literals:
for u, v in args:
assert apply_derivatives(derivative(l, u, v)) == zero(l.ufl_shape +
v.ufl_shape)
# Test grad ruleset directly since grad(literal) is invalid:
assert GradRuleset(d)(one) == zero((d, ))
assert GradRuleset(d)(one) == zero((d, ))
def test_index_simplification_reference_grad(self):
mesh = Mesh(VectorElement("P", quadrilateral, 1))
i, = indices(1)
A = as_tensor(Indexed(Jacobian(mesh), MultiIndex((i, i))), (i,))
expr = apply_derivatives(apply_geometry_lowering(
apply_algebra_lowering(A[0])))
assert expr == ReferenceGrad(SpatialCoordinate(mesh))[0, 0]
assert expr.ufl_free_indices == ()
assert expr.ufl_shape == ()
def test_literal_derivatives_are_zero():
cell = triangle
d = cell.geometric_dimension()
# Literals
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
E = PermutationSymbol(d)
literals = [one, two, I]
# Generic ruleset handles literals directly:
for l in literals:
for sh in [(), (d,), (d, d+1)]:
assert GenericDerivativeRuleset(sh)(l) == zero(l.ufl_shape + sh)
# Variables
v0 = variable(one)
v1 = variable(zero((d,)))
v2 = variable(I)
variables = [v0, v1, v2]
# Test literals via apply_derivatives and variable ruleset:
for l in literals:
for v in variables:
assert apply_derivatives(diff(l, v)) == zero(l.ufl_shape + v.ufl_shape)
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
u0 = Coefficient(V0)
u1 = Coefficient(V1)
v0 = TestFunction(V0)
v1 = TestFunction(V1)
args = [(u0, v0), (u1, v1)]
# Test literals via apply_derivatives and variable ruleset:
for l in literals:
for u, v in args:
assert apply_derivatives(derivative(l, u, v)) == zero(l.ufl_shape + v.ufl_shape)
# Test grad ruleset directly since grad(literal) is invalid:
assert GradRuleset(d)(one) == zero((d,))
assert GradRuleset(d)(one) == zero((d,))
def gatherDerivatives(form, arguments=None):
if arguments is None:
arguments = form.arguments()
form = apply_derivatives(apply_algebra_lowering(form))
gatherer = DerivativeGatherer(arguments)
map_expr_dags(gatherer, [i.integrand() for i in form.integrals()])
return [
sorted(list(gatherer.derivatives[arg]), key=lambda d: len(d.ufl_shape))
for arg in arguments
]
def splitForm(form, arguments=None):
if arguments is None:
arguments = form.arguments()
form = applyRestrictions(form)
form = expand_indices(apply_derivatives(apply_algebra_lowering(form)))
form = applyRestrictions(form)
integrals = {}
for integral in form.integrals():
right = splitMultiLinearExpr(integral.integrand(), arguments)
left = integrals.get(integral.integral_type())
if left is not None:
right = sumTensorMaps(left, right)
integrals[integral.integral_type()] = right
return integrals
def expand_derivatives(form, **kwargs):
"""Expand all derivatives of expr.
In the returned expression g which is mathematically
equivalent to expr, there are no VariableDerivative
or CoefficientDerivative objects left, and Grad
objects have been propagated to Terminal nodes.
"""
# For a deprecation period (I see that dolfin-adjoint passes some
# args here)
if kwargs:
warning("Deprecation: expand_derivatives no longer takes any keyword arguments")
# Lower abstractions for tensor-algebra types into index notation
form = apply_algebra_lowering(form)
# Apply differentiation
form = apply_derivatives(form)
return form
def test_apply_derivatives_doesnt_change_expression_without_derivatives():
cell = triangle
d = cell.geometric_dimension()
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
# Literals
z = zero((3, 2))
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
literals = [z, one, two, I]
# Geometry
x = SpatialCoordinate(cell)
n = FacetNormal(cell)
volume = CellVolume(cell)
geometry = [x, n, volume]
# Arguments
v0 = TestFunction(V0)
v1 = TestFunction(V1)
arguments = [v0, v1]
# Coefficients
f0 = Coefficient(V0)
f1 = Coefficient(V1)
coefficients = [f0, f1]
# Expressions
e0 = f0 + f1
e1 = v0 * (f1 / 3 - f0**2)
e2 = exp(sin(cos(tan(ln(x[0])))))
expressions = [e0, e1, e2]
# Check that all are unchanged
for expr in literals + geometry + arguments + coefficients + expressions:
# Note the use of "is" here instead of ==, this property
# is important for efficiency and memory usage
assert apply_derivatives(expr) is expr
def test_apply_derivatives_doesnt_change_expression_without_derivatives():
cell = triangle
d = cell.geometric_dimension()
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
# Literals
z = zero((3, 2))
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
literals = [z, one, two, I]
# Geometry
x = SpatialCoordinate(cell)
n = FacetNormal(cell)
volume = CellVolume(cell)
geometry = [x, n, volume]
# Arguments
v0 = TestFunction(V0)
v1 = TestFunction(V1)
arguments = [v0, v1]
# Coefficients
f0 = Coefficient(V0)
f1 = Coefficient(V1)
coefficients = [f0, f1]
# Expressions
e0 = f0 + f1
e1 = v0 * (f1/3 - f0**2)
e2 = exp(sin(cos(tan(ln(x[0])))))
expressions = [e0, e1, e2]
# Check that all are unchanged
for expr in literals + geometry + arguments + coefficients + expressions:
# Note the use of "is" here instead of ==, this property
# is important for efficiency and memory usage
assert apply_derivatives(expr) is expr
def expand_derivatives(form, **kwargs):
"""Expand all derivatives of expr.
In the returned expression g which is mathematically
equivalent to expr, there are no VariableDerivative
or CoefficientDerivative objects left, and Grad
objects have been propagated to Terminal nodes.
"""
# For a deprecation period (I see that dolfin-adjoint passes some
# args here)
if kwargs:
warning(
"Deprecation: expand_derivatives no longer takes any keyword arguments"
)
# Lower abstractions for tensor-algebra types into index notation
form = apply_algebra_lowering(form)
# Apply differentiation
form = apply_derivatives(form)
return form
grad_rule,
ufl.differentiation.Div:
div_rule,
ufl.differentiation.Curl:
curl_rule,
ufl.differentiation.NablaGrad:
nabla_grad_rule,
ufl.differentiation.NablaDiv:
nabla_div_rule,
# Delegate job
# TODO here I disregard label
ufl.differentiation.Variable:
lambda e, s, r: ufl_to_sympy(e.ufl_operands[0], s, r),
# Diff and try again
ufl.differentiation.VariableDerivative:
lambda e, s, r: ufl_to_sympy(apply_derivatives(e), s, r),
# Indexing
ufl.indexed.Indexed:
indexed_rule,
ufl.tensors.ComponentTensor:
component_tensor_rule,
ufl.indexsum.IndexSum:
index_sum_rule,
}
# And now the rest
DEFAULT_RULES.update(
dict((node, make_rule(rule)) for (node, rule) in (
# Algebra
(ufl.algebra.Sum, lambda a, b: a + b),
(ufl.algebra.Abs, lambda a: abs(a)),
(ufl.algebra.Division, lambda a, b: a / b),
def test_grad_ruleset():
cell = triangle
d = cell.geometric_dimension()
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
V2 = FiniteElement("Lagrange", cell, 2)
W0 = VectorElement("DG", cell, 0)
W1 = VectorElement("Lagrange", cell, 1)
W2 = VectorElement("Lagrange", cell, 2)
# Literals
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
literals = [one, two, I]
# Geometry
x = SpatialCoordinate(cell)
n = FacetNormal(cell)
volume = CellVolume(cell)
geometry = [x, n, volume]
# Arguments
u0 = TestFunction(V0)
u1 = TestFunction(V1)
arguments = [u0, u1]
# Coefficients
r = Constant(cell)
vr = VectorConstant(cell)
f0 = Coefficient(V0)
f1 = Coefficient(V1)
f2 = Coefficient(V2)
vf0 = Coefficient(W0)
vf1 = Coefficient(W1)
vf2 = Coefficient(W2)
coefficients = [f0, f1, vf0, vf1]
# Expressions
e0 = f0 + f1
e1 = u0 * (f1/3 - f0**2)
e2 = exp(sin(cos(tan(ln(x[0])))))
expressions = [e0, e1, e2]
# Variables
v0 = variable(one)
v1 = variable(f1)
v2 = variable(f0*f1)
variables = [v0, v1, v2]
rules = GradRuleset(d)
# Literals
assert rules(one) == zero((d,))
assert rules(two) == zero((d,))
assert rules(I) == zero((d, d, d))
# Assumed piecewise constant geometry
for g in [n, volume]:
assert rules(g) == zero(g.ufl_shape + (d,))
# Non-constant geometry
assert rules(x) == I
# Arguments
for u in arguments:
assert rules(u) == grad(u)
# Piecewise constant coefficients (Constant)
assert rules(r) == zero((d,))
assert rules(vr) == zero((d, d))
assert rules(grad(r)) == zero((d, d))
assert rules(grad(vr)) == zero((d, d, d))
# Piecewise constant coefficients (DG0)
assert rules(f0) == zero((d,))
assert rules(vf0) == zero((d, d))
assert rules(grad(f0)) == zero((d, d))
assert rules(grad(vf0)) == zero((d, d, d))
# Piecewise linear coefficients
assert rules(f1) == grad(f1)
assert rules(vf1) == grad(vf1)
# assert rules(grad(f1)) == zero((d,d)) # TODO: Use degree to make this work
# assert rules(grad(vf1)) == zero((d,d,d))
# Piecewise quadratic coefficients
assert rules(grad(f2)) == grad(grad(f2))
assert rules(grad(vf2)) == grad(grad(vf2))
# Indexed coefficients
assert renumber_indices(apply_derivatives(grad(vf2[0]))) == renumber_indices(grad(vf2)[0, :])
assert renumber_indices(apply_derivatives(grad(vf2[1])[0])) == renumber_indices(grad(vf2)[1, 0])
# Grad of gradually more complex expressions
assert apply_derivatives(grad(2*f0)) == zero((d,))
assert renumber_indices(apply_derivatives(grad(2*f1))) == renumber_indices(2*grad(f1))
assert renumber_indices(apply_derivatives(grad(sin(f1)))) == renumber_indices(cos(f1) * grad(f1))
assert renumber_indices(apply_derivatives(grad(cos(f1)))) == renumber_indices(-sin(f1) * grad(f1))
def compile_ufl_kernel(expression, to_pts, to_element, fs):
import collections
from ufl.algorithms.apply_function_pullbacks import apply_function_pullbacks
from ufl.algorithms.apply_algebra_lowering import apply_algebra_lowering
from ufl.algorithms.apply_derivatives import apply_derivatives
from ufl.algorithms.apply_geometry_lowering import apply_geometry_lowering
from ufl.algorithms import extract_arguments, extract_coefficients
from gem import gem, impero_utils
from tsfc import fem, ufl_utils
from tsfc.coffee import generate as generate_coffee
from tsfc.kernel_interface import (KernelBuilderBase,
needs_cell_orientations,
cell_orientations_coffee_arg)
# Imitate the compute_form_data processing pipeline
#
# Unfortunately, we cannot call compute_form_data here, since
# we only have an expression, not a form
expression = apply_algebra_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_function_pullbacks(expression)
expression = apply_geometry_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_geometry_lowering(expression)
expression = apply_derivatives(expression)
# Replace coordinates (if any)
if expression.ufl_domain():
assert fs.mesh() == expression.ufl_domain()
expression = ufl_utils.replace_coordinates(expression, fs.mesh().coordinates)
if extract_arguments(expression):
return ValueError("Cannot interpolate UFL expression with Arguments!")
builder = KernelBuilderBase()
args = []
coefficients = extract_coefficients(expression)
for i, coefficient in enumerate(coefficients):
args.append(builder.coefficient(coefficient, "w_%d" % i))
point_index = gem.Index(name='p')
ir = fem.compile_ufl(expression,
cell=fs.mesh().ufl_cell(),
points=to_pts,
point_index=point_index,
coefficient_mapper=builder.coefficient_mapper)
assert len(ir) == 1
# Deal with non-scalar expressions
tensor_indices = ()
if fs.shape:
tensor_indices = tuple(gem.Index() for s in fs.shape)
ir = [gem.Indexed(ir[0], tensor_indices)]
# Build kernel body
return_var = gem.Variable('A', (len(to_pts),) + fs.shape)
return_expr = gem.Indexed(return_var, (point_index,) + tensor_indices)
impero_c = impero_utils.compile_gem([return_expr], ir, [point_index])
body = generate_coffee(impero_c, index_names={point_index: 'p'})
oriented = needs_cell_orientations(ir)
if oriented:
args.insert(0, cell_orientations_coffee_arg)
# Build kernel
args.insert(0, ast.Decl("double", ast.Symbol('A', rank=(len(to_pts),) + fs.shape)))
kernel_code = builder.construct_kernel("expression_kernel", args, body)
return op2.Kernel(kernel_code, kernel_code.name), oriented, coefficients
def compileUFL(form, patch, *args, **kwargs):
if isinstance(form, Equation):
form = form.lhs - form.rhs
if not isinstance(form, Form):
raise Exception("ufl.Form expected.")
if len(form.arguments()) < 2:
raise Exception("ConservationLaw model requires form with at least two arguments.")
phi_, u_ = form.arguments()
if phi_.ufl_function_space().scalar:
phi = TestFunction(phi_.ufl_function_space().toVectorSpace())
form = replace(form,{phi_:phi[0]})
else:
phi = phi_
if u_.ufl_function_space().scalar:
u = TrialFunction(u_.ufl_function_space().toVectorSpace())
form = replace(form,{u_:u[0]})
else:
u = u_
_, coeff_ = extract_arguments_and_coefficients(form)
coeff_ = set(coeff_)
# added for dirichlet treatment same as conservationlaw model
dirichletBCs = [arg for arg in args if isinstance(arg, DirichletBC)]
# remove the dirichletBCs
arg = [arg for arg in args if not isinstance(arg, DirichletBC)]
for dBC in dirichletBCs:
_, coeff__ = extract_arguments_and_coefficients(dBC.ufl_value)
coeff_ |= set(coeff__)
if patch is not None:
for a in patch:
try:
_, coeff__ = extract_arguments_and_coefficients(a)
coeff_ |= set(coeff__)
except:
pass # a might be a float/int and not a ufl expression
coeff = {c : c.toVectorCoefficient()[0] for c in coeff_ if len(c.ufl_shape) == 0 and not c.is_cellwise_constant()}
form = replace(form,coeff)
for bc in dirichletBCs:
bc.ufl_value = replace(bc.ufl_value, coeff)
if patch is not None:
patch = [a if not isinstance(a, Expr) else replace(a,coeff) for a in patch]
phi = form.arguments()[0]
dimRange = phi.ufl_shape[0]
u = form.arguments()[1]
du = Grad(u)
d2u = Grad(du)
ubar = Coefficient(u.ufl_function_space())
dubar = Grad(ubar)
d2ubar = Grad(dubar)
dimDomain = u.ufl_shape[0]
x = SpatialCoordinate(form.ufl_cell())
try:
field = u.ufl_function_space().field
except AttributeError:
field = "double"
# if exact solution is passed in subtract a(u,.) from the form
if "exact" in kwargs:
b = replace(form, {u: as_vector(kwargs["exact"])} )
form = form - b
dform = apply_derivatives(derivative(action(form, ubar), ubar, u))
source, flux, boundarySource = splitUFLForm(form)
linSource, linFlux, linBoundarySource = splitUFLForm(dform)
fluxDivergence, _, _ = splitUFLForm(inner(source.as_ufl() - div(flux.as_ufl()), phi) * dx(0))
# split linNVSource off linSource
# linSources = splitUFL2(u, du, d2u, linSource)
# linNVSource = linSources[2]
# linSource = linSources[0] + linSources[1]
if patch is not None:
model = ConservationLawModel(dimDomain, dimRange, u, modelSignature(form,*patch,*args))
else:
model = ConservationLawModel(dimDomain, dimRange, u, modelSignature(form,None,*args))
model._replaceCoeff = coeff
model.hasNeumanBoundary = not boundarySource.is_zero()
#expandform = expand_indices(expand_derivatives(expand_compounds(equation.lhs)))
#if expandform == adjoint(expandform):
# model.symmetric = 'true'
model.field = field
dirichletBCs = [arg for arg in args if isinstance(arg, DirichletBC)]
# deprecated
# if "dirichlet" in kwargs:
# dirichletBCs += [DirichletBC(u.ufl_function_space(), as_vector(value), bndId) for bndId, value in kwargs["dirichlet"].items()]
uflCoefficients = set(form.coefficients())
for bc in dirichletBCs:
_, c = extract_arguments_and_coefficients(bc.ufl_value)
uflCoefficients |= set(c)
if patch is not None:
for a in patch:
if isinstance(a, Expr):
_, c = extract_arguments_and_coefficients(a)
uflCoefficients |= set(c)
constants = dict()
coefficients = dict()
for coefficient in uflCoefficients:
try:
name = getattr(coefficient, "name")
except AttributeError:
name = str(coefficient)
if coefficient.is_cellwise_constant():
try:
parameter = getattr(coefficient, "parameter")
except AttributeError:
parameter = None
if len(coefficient.ufl_shape) == 0:
constants[coefficient] = model.addConstant('double', name=name, parameter=parameter)
elif len(coefficient.ufl_shape) == 1:
constants[coefficient] = model.addConstant('Dune::FieldVector< double, ' + str(coefficient.ufl_shape[0]) + ' >', name=name, parameter=parameter)
else:
Exception('Currently, only scalars and vectors are supported as constants')
else:
shape = coefficient.ufl_shape[0]
try:
coefficients[coefficient] = model.addCoefficient(
shape,
coefficient.cppTypeName,
name=name,
field=coefficient.ufl_function_space().field)
except AttributeError:
coefficients[coefficient] = model.addCoefficient(
shape,
coefficient.cppTypeName,
name=name)
model.coefficients = coefficients
model.constants = constants
tempVars = kwargs.get("tempVars", True)
predefined = {u: model.arg_u, du: model.arg_du, d2u: model.arg_d2u}
predefined[x] = UnformattedExpression('auto', 'entity().geometry().global( Dune::Fem::coordinate( ' + model.arg_x.name + ' ) )')
model.predefineCoefficients(predefined,'x')
model.source = generateCode(predefined, source, tempVars=tempVars)
model.flux = generateCode(predefined, flux, tempVars=tempVars)
predefined.update({ubar: model.arg_ubar, dubar: model.arg_dubar, d2ubar: model.arg_d2ubar})
model.linSource = generateCode(predefined, linSource, tempVars=tempVars)
model.linFlux = generateCode(predefined, linFlux, tempVars=tempVars)
# model.linNVSource = generateCode({u: arg, du: darg, d2u: d2arg, ubar: argbar, dubar: dargbar, d2ubar: d2argbar}, linNVSource, model.coefficients, tempVars)
predefined = {u: model.arg_u}
predefined[x] = UnformattedExpression('auto', 'entity().geometry().global( Dune::Fem::coordinate( ' + model.arg_x.name + ' ) )')
model.predefineCoefficients(predefined,'x')
model.alpha = generateCode(predefined, boundarySource, tempVars=tempVars)
predefined.update({ubar: model.arg_ubar})
model.linAlpha = generateCode(predefined, linBoundarySource, tempVars=tempVars)
predefined = {u: model.arg_u, du: model.arg_du, d2u: model.arg_d2u}
predefined[x] = UnformattedExpression('auto', 'entity().geometry().global( Dune::Fem::coordinate( ' + model.arg_x.name + ' ) )')
model.predefineCoefficients(predefined,'x')
model.fluxDivergence = generateCode(predefined, fluxDivergence, tempVars=tempVars)
if dirichletBCs:
model.hasDirichletBoundary = True
predefined = {}
predefined[x] = UnformattedExpression('auto', 'entity().geometry().global( Dune::Fem::coordinate( ' + model.arg_x.name + ' ) )')
model.predefineCoefficients(predefined,'x')
maxId = 0
codeDomains = []
bySubDomain = dict()
neuman = []
for bc in dirichletBCs:
if bc.subDomain in bySubDomain:
raise Exception('Multiply defined Dirichlet boundary for subdomain ' + str(bc.subDomain))
if not isinstance(bc.functionSpace, (FunctionSpace, FiniteElementBase)):
raise Exception('Function space must either be a ufl.FunctionSpace or a ufl.FiniteElement')
if isinstance(bc.functionSpace, FunctionSpace) and (bc.functionSpace != u.ufl_function_space()):
raise Exception('Space of trial function and dirichlet boundary function must be the same - note that boundary conditions on subspaces are not available, yet')
if isinstance(bc.functionSpace, FiniteElementBase) and (bc.functionSpace != u.ufl_element()):
raise Exception('Cannot handle boundary conditions on subspaces, yet')
if isinstance(bc.value, list):
neuman = [i for i, x in enumerate(bc.value) if x == None]
else:
neuman = []
value = ExprTensor(u.ufl_shape)
for key in value.keys():
value[key] = Indexed(bc.ufl_value, MultiIndex(tuple(FixedIndex(k) for k in key)))
if isinstance(bc.subDomain,int):
bySubDomain[bc.subDomain] = value,neuman
maxId = max(maxId, bc.subDomain)
else:
domain = ExprTensor(())
for key in domain.keys():
domain[key] = Indexed(bc.subDomain, MultiIndex(tuple(FixedIndex(k) for k in key)))
codeDomains.append( (value,neuman,domain) )
defaultCode = []
defaultCode.append(Declaration(Variable('int', 'domainId')))
defaultCode.append(Declaration(Variable('auto', 'tmp0'),
initializer=UnformattedExpression('auto','intersection.geometry().center()')))
for i,v in enumerate(codeDomains):
block = Block()
defaultCode.append(
generateDirichletDomainCode(predefined, v[2], tempVars=tempVars))
defaultCode.append('if (domainId)')
block = UnformattedBlock()
block.append('std::fill( dirichletComponent.begin(), dirichletComponent.end(), ' + str(maxId+i+1) + ' );')
if len(v[1])>0:
[block.append('dirichletComponent[' + str(c) + '] = 0;') for c in v[1]]
block.append('return true;')
defaultCode.append(block)
defaultCode.append(return_(False))
bndId = Variable('const int', 'bndId')
getBndId = UnformattedExpression('int', 'BoundaryIdProviderType::boundaryId( ' + model.arg_i.name + ' )')
switch = SwitchStatement(bndId, default=defaultCode)
for i,v in bySubDomain.items():
code = []
if len(v[1])>0:
[code.append('dirichletComponent[' + str(c) + '] = 0;') for c in v[1]]
code.append(return_(True))
switch.append(i, code)
model.isDirichletIntersection = [Declaration(bndId, initializer=getBndId),
UnformattedBlock('std::fill( dirichletComponent.begin(), dirichletComponent.end(), ' + bndId.name + ' );'),
switch
]
switch = SwitchStatement(model.arg_bndId, default=assign(model.arg_r, construct("RRangeType", 0)))
for i, v in bySubDomain.items():
switch.append(i, generateDirichletCode(predefined, v[0], tempVars=tempVars))
for i,v in enumerate(codeDomains):
switch.append(i+maxId+1, generateDirichletCode(predefined, v[0], tempVars=tempVars))
model.dirichlet = [switch]
return model
def test_grad_ruleset():
cell = triangle
d = cell.geometric_dimension()
V0 = FiniteElement("DG", cell, 0)
V1 = FiniteElement("Lagrange", cell, 1)
V2 = FiniteElement("Lagrange", cell, 2)
W0 = VectorElement("DG", cell, 0)
W1 = VectorElement("Lagrange", cell, 1)
W2 = VectorElement("Lagrange", cell, 2)
# Literals
one = as_ufl(1)
two = as_ufl(2.0)
I = Identity(d)
literals = [one, two, I]
# Geometry
x = SpatialCoordinate(cell)
n = FacetNormal(cell)
volume = CellVolume(cell)
geometry = [x, n, volume]
# Arguments
u0 = TestFunction(V0)
u1 = TestFunction(V1)
arguments = [u0, u1]
# Coefficients
r = Constant(cell)
vr = VectorConstant(cell)
f0 = Coefficient(V0)
f1 = Coefficient(V1)
f2 = Coefficient(V2)
vf0 = Coefficient(W0)
vf1 = Coefficient(W1)
vf2 = Coefficient(W2)
coefficients = [f0, f1, vf0, vf1]
# Expressions
e0 = f0 + f1
e1 = u0 * (f1 / 3 - f0**2)
e2 = exp(sin(cos(tan(ln(x[0])))))
expressions = [e0, e1, e2]
# Variables
v0 = variable(one)
v1 = variable(f1)
v2 = variable(f0 * f1)
variables = [v0, v1, v2]
rules = GradRuleset(d)
# Literals
assert rules(one) == zero((d, ))
assert rules(two) == zero((d, ))
assert rules(I) == zero((d, d, d))
# Assumed piecewise constant geometry
for g in [n, volume]:
assert rules(g) == zero(g.ufl_shape + (d, ))
# Non-constant geometry
assert rules(x) == I
# Arguments
for u in arguments:
assert rules(u) == grad(u)
# Piecewise constant coefficients (Constant)
assert rules(r) == zero((d, ))
assert rules(vr) == zero((d, d))
assert rules(grad(r)) == zero((d, d))
assert rules(grad(vr)) == zero((d, d, d))
# Piecewise constant coefficients (DG0)
assert rules(f0) == zero((d, ))
assert rules(vf0) == zero((d, d))
assert rules(grad(f0)) == zero((d, d))
assert rules(grad(vf0)) == zero((d, d, d))
# Piecewise linear coefficients
assert rules(f1) == grad(f1)
assert rules(vf1) == grad(vf1)
# assert rules(grad(f1)) == zero((d,d)) # TODO: Use degree to make this work
# assert rules(grad(vf1)) == zero((d,d,d))
# Piecewise quadratic coefficients
assert rules(grad(f2)) == grad(grad(f2))
assert rules(grad(vf2)) == grad(grad(vf2))
# Indexed coefficients
assert renumber_indices(apply_derivatives(grad(
vf2[0]))) == renumber_indices(grad(vf2)[0, :])
assert renumber_indices(apply_derivatives(grad(
vf2[1])[0])) == renumber_indices(grad(vf2)[1, 0])
# Grad of gradually more complex expressions
assert apply_derivatives(grad(2 * f0)) == zero((d, ))
assert renumber_indices(apply_derivatives(grad(
2 * f1))) == renumber_indices(2 * grad(f1))
assert renumber_indices(apply_derivatives(grad(
sin(f1)))) == renumber_indices(cos(f1) * grad(f1))
assert renumber_indices(apply_derivatives(grad(
cos(f1)))) == renumber_indices(-sin(f1) * grad(f1))
def compute_form_data(form,
# Default arguments configured to behave the way old FFC expects it:
do_apply_function_pullbacks=False,
do_apply_integral_scaling=False,
do_apply_geometry_lowering=False,
preserve_geometry_types=(),
do_apply_default_restrictions=True,
do_apply_restrictions=True,
do_estimate_degrees=True,
complex_mode=False,
):
# TODO: Move this to the constructor instead
self = FormData()
# --- Store untouched form for reference.
# The user of FormData may get original arguments,
# original coefficients, and form signature from this object.
# But be aware that the set of original coefficients are not
# the same as the ones used in the final UFC form.
# See 'reduced_coefficients' below.
self.original_form = form
# --- Pass form integrands through some symbolic manipulation
# Note: Default behaviour here will process form the way that is
# currently expected by vanilla FFC
# Check that the form does not try to compare complex quantities:
# if the quantites being compared are 'provably' real, wrap them
# with Real, otherwise throw an error.
if complex_mode:
form = do_comparison_check(form)
# Lower abstractions for tensor-algebra types into index notation,
# reducing the number of operators later algorithms and form
# compilers need to handle
form = apply_algebra_lowering(form)
# After lowering to index notation, remove any complex nodes that
# have been introduced but are not wanted when working in real mode,
# allowing for purely real forms to be written
if not complex_mode:
form = remove_complex_nodes(form)
# Apply differentiation before function pullbacks, because for
# example coefficient derivatives are more complicated to derive
# after coefficients are rewritten, and in particular for
# user-defined coefficient relations it just gets too messy
form = apply_derivatives(form)
# strip the coordinate derivatives away from the integral as they
# interfere with the integral grouping
(form, coordinate_derivatives) = strip_coordinate_derivatives(form)
# --- Group form integrals
# TODO: Refactor this, it's rather opaque what this does
# TODO: Is self.original_form.ufl_domains() right here?
# It will matter when we start including 'num_domains' in ufc form.
form = group_form_integrals(form, self.original_form.ufl_domains())
# attach coordinate derivatives again
form = attach_coordinate_derivatives(form, coordinate_derivatives)
# Estimate polynomial degree of integrands now, before applying
# any pullbacks and geometric lowering. Otherwise quad degrees
# blow up horrifically.
if do_estimate_degrees:
form = attach_estimated_degrees(form)
if do_apply_function_pullbacks:
# Rewrite coefficients and arguments in terms of their
# reference cell values with Piola transforms and symmetry
# transforms injected where needed.
# Decision: Not supporting grad(dolfin.Expression) without a
# Domain. Current dolfin works if Expression has a
# cell but this should be changed to a mesh.
form = apply_function_pullbacks(form)
# Scale integrals to reference cell frames
if do_apply_integral_scaling:
form = apply_integral_scaling(form)
# Apply default restriction to fully continuous terminals
if do_apply_default_restrictions:
form = apply_default_restrictions(form)
# Lower abstractions for geometric quantities into a smaller set
# of quantities, allowing the form compiler to deal with a smaller
# set of types and treating geometric quantities like any other
# expressions w.r.t. loop-invariant code motion etc.
if do_apply_geometry_lowering:
form = apply_geometry_lowering(form, preserve_geometry_types)
# Apply differentiation again, because the algorithms above can
# generate new derivatives or rewrite expressions inside
# derivatives
if do_apply_function_pullbacks or do_apply_geometry_lowering:
form = apply_derivatives(form)
# Neverending story: apply_derivatives introduces new Jinvs,
# which needs more geometry lowering
if do_apply_geometry_lowering:
form = apply_geometry_lowering(form, preserve_geometry_types)
# Lower derivatives that may have appeared
form = apply_derivatives(form)
form = apply_coordinate_derivatives(form)
# Propagate restrictions to terminals
if do_apply_restrictions:
form = apply_restrictions(form)
# --- Group integrals into IntegralData objects
# Most of the heavy lifting is done above in group_form_integrals.
self.integral_data = build_integral_data(form.integrals())
# --- Create replacements for arguments and coefficients
# Figure out which form coefficients each integral should enable
for itg_data in self.integral_data:
itg_coeffs = set()
# Get all coefficients in integrand
for itg in itg_data.integrals:
itg_coeffs.update(extract_coefficients(itg.integrand()))
# Store with IntegralData object
itg_data.integral_coefficients = itg_coeffs
# Figure out which coefficients from the original form are
# actually used in any integral (Differentiation may reduce the
# set of coefficients w.r.t. the original form)
reduced_coefficients_set = set()
for itg_data in self.integral_data:
reduced_coefficients_set.update(itg_data.integral_coefficients)
self.reduced_coefficients = sorted(reduced_coefficients_set,
key=lambda c: c.count())
self.num_coefficients = len(self.reduced_coefficients)
self.original_coefficient_positions = [i for i, c in enumerate(self.original_form.coefficients())
if c in self.reduced_coefficients]
# Store back into integral data which form coefficients are used
# by each integral
for itg_data in self.integral_data:
itg_data.enabled_coefficients = [bool(coeff in itg_data.integral_coefficients)
for coeff in self.reduced_coefficients]
# --- Collect some trivial data
# Get rank of form from argument list (assuming not a mixed arity form)
self.rank = len(self.original_form.arguments())
# Extract common geometric dimension (topological is not common!)
self.geometric_dimension = self.original_form.integrals()[0].ufl_domain().geometric_dimension()
# --- Build mapping from old incomplete element objects to new
# well defined elements. This is to support the Expression
# construct in dolfin which subclasses Coefficient but doesn't
# provide an element, and the Constant construct that doesn't
# provide the domain that a Coefficient is supposed to have. A
# future design iteration in UFL/UFC/FFC/DOLFIN may allow removal
# of this mapping with the introduction of UFL types for
# Expression-like functions that can be evaluated in quadrature
# points.
self.element_replace_map = _compute_element_mapping(self.original_form)
# Mappings from elements and coefficients that reside in form to
# objects with canonical numbering as well as completed cells and
# elements
renumbered_coefficients, function_replace_map = \
_build_coefficient_replace_map(self.reduced_coefficients,
self.element_replace_map)
self.function_replace_map = function_replace_map
# --- Store various lists of elements and sub elements (adds
# members to self)
_compute_form_data_elements(self,
self.original_form.arguments(),
renumbered_coefficients,
self.original_form.ufl_domains())
# --- Store number of domains for integral types
# TODO: Group this by domain first. For now keep a backwards
# compatible data structure.
self.max_subdomain_ids = _compute_max_subdomain_ids(self.integral_data)
# --- Checks
_check_elements(self)
_check_facet_geometry(self.integral_data)
# TODO: This is a very expensive check... Replace with something
# faster!
preprocessed_form = reconstruct_form_from_integral_data(self.integral_data)
# If in real mode, remove complex nodes entirely.
if not complex_mode:
preprocessed_form = remove_complex_nodes(preprocessed_form)
check_form_arity(preprocessed_form, self.original_form.arguments(), complex_mode) # Currently testing how fast this is
# TODO: This member is used by unit tests, change the tests to
# remove this!
self.preprocessed_form = preprocessed_form
return self
def compile_ufl_kernel(expression, to_pts, to_element, fs):
import collections
from ufl.algorithms.apply_function_pullbacks import apply_function_pullbacks
from ufl.algorithms.apply_algebra_lowering import apply_algebra_lowering
from ufl.algorithms.apply_derivatives import apply_derivatives
from ufl.algorithms.apply_geometry_lowering import apply_geometry_lowering
from ufl.algorithms import extract_arguments, extract_coefficients
from gem import gem, impero_utils
from tsfc import fem, ufl_utils
from tsfc.coffee import generate as generate_coffee
from tsfc.kernel_interface import (KernelBuilderBase,
needs_cell_orientations,
cell_orientations_coffee_arg)
# Imitate the compute_form_data processing pipeline
#
# Unfortunately, we cannot call compute_form_data here, since
# we only have an expression, not a form
expression = apply_algebra_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_function_pullbacks(expression)
expression = apply_geometry_lowering(expression)
expression = apply_derivatives(expression)
expression = apply_geometry_lowering(expression)
expression = apply_derivatives(expression)
# Replace coordinates (if any)
if expression.ufl_domain():
assert fs.mesh() == expression.ufl_domain()
expression = ufl_utils.replace_coordinates(expression, fs.mesh().coordinates)
if extract_arguments(expression):
return ValueError("Cannot interpolate UFL expression with Arguments!")
builder = KernelBuilderBase()
args = []
coefficients = extract_coefficients(expression)
for i, coefficient in enumerate(coefficients):
args.append(builder.coefficient(coefficient, "w_%d" % i))
point_index = gem.Index(name='p')
ir = fem.process('cell', fs.mesh().ufl_cell(), to_pts, None,
point_index, (), expression,
builder.coefficient_mapper,
collections.defaultdict(gem.Index))
assert len(ir) == 1
# Deal with non-scalar expressions
tensor_indices = ()
if fs.shape:
tensor_indices = tuple(gem.Index() for s in fs.shape)
ir = [gem.Indexed(ir[0], tensor_indices)]
# Build kernel body
return_var = gem.Variable('A', (len(to_pts),) + fs.shape)
return_expr = gem.Indexed(return_var, (point_index,) + tensor_indices)
impero_c = impero_utils.compile_gem([return_expr], ir, [point_index])
body = generate_coffee(impero_c, index_names={point_index: 'p'})
oriented = needs_cell_orientations(ir)
if oriented:
args.insert(0, cell_orientations_coffee_arg)
# Build kernel
args.insert(0, ast.Decl("double", ast.Symbol('A', rank=(len(to_pts),) + fs.shape)))
kernel_code = builder.construct_kernel("expression_kernel", args, body)
return op2.Kernel(kernel_code, kernel_code.name), oriented, coefficients
def _compileUFL(integrands, form, *args, tempVars=True):
if isinstance(form, Equation):
form = form.lhs - form.rhs
if not isinstance(form, Form):
raise ValueError("ufl.Form or ufl.Equation expected.")
# added for dirichlet treatment same as conservationlaw model
dirichletBCs = [arg for arg in args if isinstance(arg, DirichletBC)]
uflExpr = [form] + [bc.ufl_value for bc in dirichletBCs]
if len(form.arguments()) < 2:
raise ValueError(
"Integrands model requires form with at least two arguments.")
x = SpatialCoordinate(form.ufl_cell())
n = FacetNormal(form.ufl_cell())
cellVolume = CellVolume(form.ufl_cell())
maxCellEdgeLength = MaxCellEdgeLength(form.ufl_cell())
minCellEdgeLength = MinCellEdgeLength(form.ufl_cell())
facetArea = FacetArea(form.ufl_cell())
maxFacetEdgeLength = MaxFacetEdgeLength(form.ufl_cell())
minFacetEdgeLength = MinFacetEdgeLength(form.ufl_cell())
phi, u = form.arguments()
ubar = Coefficient(u.ufl_function_space())
derivatives = gatherDerivatives(form, [phi, u])
derivatives_phi = derivatives[0]
derivatives_u = derivatives[1]
derivatives_ubar = map_expr_dags(Replacer({u: ubar}), derivatives_u)
try:
integrands.field = u.ufl_function_space().field
except AttributeError:
pass
integrals = splitForm(form, [phi])
dform = apply_derivatives(derivative(action(form, ubar), ubar, u))
linearizedIntegrals = splitForm(dform, [phi, u])
if not set(
integrals.keys()) <= {'cell', 'exterior_facet', 'interior_facet'}:
raise Exception('unknown integral encountered in ' +
str(set(integrals.keys())) + '.')
if 'cell' in integrals.keys():
arg = Variable(integrands.domainValueTuple, 'u')
predefined = {
derivatives_u[i]: arg[i]
for i in range(len(derivatives_u))
}
predefined[x] = integrands.spatialCoordinate('x')
predefined[cellVolume] = integrands.cellVolume()
predefined[maxCellEdgeLength] = maxEdgeLength(
integrands.cellGeometry())
predefined[minCellEdgeLength] = minEdgeLength(
integrands.cellGeometry())
integrands.predefineCoefficients(predefined, False)
integrands.interior = generateUnaryCode(predefined,
derivatives_phi,
integrals['cell'],
tempVars=tempVars)
predefined = {
derivatives_ubar[i]: arg[i]
for i in range(len(derivatives_u))
}
predefined[x] = integrands.spatialCoordinate('x')
predefined[cellVolume] = integrands.cellVolume()
predefined[maxCellEdgeLength] = maxEdgeLength(
integrands.cellGeometry())
predefined[minCellEdgeLength] = minEdgeLength(
integrands.cellGeometry())
integrands.predefineCoefficients(predefined, False)
integrands.linearizedInterior = generateUnaryLinearizedCode(
predefined,
derivatives_phi,
derivatives_u,
linearizedIntegrals.get('cell'),
tempVars=tempVars)
if 'exterior_facet' in integrals.keys():
arg = Variable(integrands.domainValueTuple, 'u')
predefined = {
derivatives_u[i]: arg[i]
for i in range(len(derivatives_u))
}
predefined[x] = integrands.spatialCoordinate('x')
predefined[n] = integrands.facetNormal('x')
predefined[cellVolume] = integrands.cellVolume()
predefined[maxCellEdgeLength] = maxEdgeLength(
integrands.cellGeometry())
predefined[minCellEdgeLength] = minEdgeLength(
integrands.cellGeometry())
predefined[facetArea] = integrands.facetArea()
predefined[maxFacetEdgeLength] = maxEdgeLength(
integrands.facetGeometry())
predefined[minFacetEdgeLength] = minEdgeLength(
integrands.facetGeometry())
integrands.predefineCoefficients(predefined, False)
integrands.boundary = generateUnaryCode(predefined,
derivatives_phi,
integrals['exterior_facet'],
tempVars=tempVars)
predefined = {
derivatives_ubar[i]: arg[i]
for i in range(len(derivatives_u))
}
predefined[x] = integrands.spatialCoordinate('x')
predefined[n] = integrands.facetNormal('x')
predefined[cellVolume] = integrands.cellVolume()
predefined[maxCellEdgeLength] = maxEdgeLength(
integrands.cellGeometry())
predefined[minCellEdgeLength] = minEdgeLength(
integrands.cellGeometry())
predefined[facetArea] = integrands.facetArea()
predefined[maxFacetEdgeLength] = maxEdgeLength(
integrands.facetGeometry())
predefined[minFacetEdgeLength] = minEdgeLength(
integrands.facetGeometry())
integrands.predefineCoefficients(predefined, False)
integrands.linearizedBoundary = generateUnaryLinearizedCode(
predefined,
derivatives_phi,
derivatives_u,
linearizedIntegrals.get('exterior_facet'),
tempVars=tempVars)
if 'interior_facet' in integrals.keys():
argIn = Variable(integrands.domainValueTuple, 'uIn')
argOut = Variable(integrands.domainValueTuple, 'uOut')
predefined = {
derivatives_u[i](s): arg[i]
for i in range(len(derivatives_u))
for s, arg in (('+', argIn), ('-', argOut))
}
predefined[x] = integrands.spatialCoordinate('xIn')
predefined[n('+')] = integrands.facetNormal('xIn')
predefined[cellVolume('+')] = integrands.cellVolume('Side::in')
predefined[cellVolume('-')] = integrands.cellVolume('Side::out')
predefined[maxCellEdgeLength('+')] = maxEdgeLength(
integrands.cellGeometry('Side::in'))
predefined[maxCellEdgeLength('-')] = maxEdgeLength(
integrands.cellGeometry('Side::out'))
predefined[minCellEdgeLength('+')] = minEdgeLength(
integrands.cellGeometry('Side::in'))
predefined[minCellEdgeLength('-')] = minEdgeLength(
integrands.cellGeometry('Side::out'))
predefined[facetArea] = integrands.facetArea()
predefined[maxFacetEdgeLength] = maxEdgeLength(
integrands.facetGeometry())
predefined[minFacetEdgeLength] = minEdgeLength(
integrands.facetGeometry())
integrands.predefineCoefficients(predefined, True)
integrands.skeleton = generateBinaryCode(predefined,
derivatives_phi,
integrals['interior_facet'],
tempVars=tempVars)
predefined = {
derivatives_ubar[i](s): arg[i]
for i in range(len(derivatives_u))
for s, arg in (('+', argIn), ('-', argOut))
}
predefined[x] = integrands.spatialCoordinate('xIn')
predefined[n('+')] = integrands.facetNormal('xIn')
predefined[cellVolume('+')] = integrands.cellVolume('Side::in')
predefined[cellVolume('-')] = integrands.cellVolume('Side::out')
predefined[maxCellEdgeLength('+')] = maxEdgeLength(
integrands.cellGeometry('Side::in'))
predefined[maxCellEdgeLength('-')] = maxEdgeLength(
integrands.cellGeometry('Side::out'))
predefined[minCellEdgeLength('+')] = minEdgeLength(
integrands.cellGeometry('Side::in'))
predefined[minCellEdgeLength('-')] = minEdgeLength(
integrands.cellGeometry('Side::out'))
predefined[facetArea] = integrands.facetArea()
predefined[maxFacetEdgeLength] = maxEdgeLength(
integrands.facetGeometry())
predefined[minFacetEdgeLength] = minEdgeLength(
integrands.facetGeometry())
integrands.predefineCoefficients(predefined, True)
integrands.linearizedSkeleton = generateBinaryLinearizedCode(
predefined,
derivatives_phi,
derivatives_u,
linearizedIntegrals.get('interior_facet'),
tempVars=tempVars)
if dirichletBCs:
integrands.hasDirichletBoundary = True
predefined = {}
# predefined[x] = UnformattedExpression('auto', 'entity().geometry().global( Dune::Fem::coordinate( ' + integrands.arg_x.name + ' ) )')
predefined[x] = UnformattedExpression(
'auto', 'intersection.geometry().center( )')
integrands.predefineCoefficients(predefined, False)
maxId = 0
codeDomains = []
bySubDomain = dict()
neuman = []
wholeDomain = None
for bc in dirichletBCs:
if bc.subDomain in bySubDomain:
raise Exception(
'Multiply defined Dirichlet boundary for subdomain ' +
str(bc.subDomain))
if not isinstance(bc.functionSpace,
(FunctionSpace, FiniteElementBase)):
raise Exception(
'Function space must either be a ufl.FunctionSpace or a ufl.FiniteElement'
)
if isinstance(bc.functionSpace, FunctionSpace) and (
bc.functionSpace != u.ufl_function_space()):
raise Exception(
'Space of trial function and dirichlet boundary function must be the same - note that boundary conditions on subspaces are not available, yet'
)
if isinstance(bc.functionSpace, FiniteElementBase) and (
bc.functionSpace != u.ufl_element()):
raise Exception(
'Cannot handle boundary conditions on subspaces, yet')
if isinstance(bc.value, list):
neuman = [i for i, x in enumerate(bc.value) if x == None]
else:
neuman = []
value = ExprTensor(u.ufl_shape)
for key in value.keys():
value[key] = Indexed(
bc.ufl_value,
MultiIndex(tuple(FixedIndex(k) for k in key)))
if bc.subDomain is None:
wholeDomain = value, neuman
elif isinstance(bc.subDomain, int):
bySubDomain[bc.subDomain] = value, neuman
maxId = max(maxId, bc.subDomain)
else:
domain = ExprTensor(())
for key in domain.keys():
domain[key] = Indexed(
bc.subDomain,
MultiIndex(tuple(FixedIndex(k) for k in key)))
codeDomains.append((value, neuman, domain))
defaultCode = []
if len(codeDomains) > 0:
defaultCode.append(Declaration(Variable('int', 'domainId')))
# defaultCode.append(Declaration(Variable('auto', 'x'),
# initializer=UnformattedExpression('auto','intersection.geometry().center()')))
for i, v in enumerate(codeDomains):
block = Block()
block.append(
generateDirichletDomainCode(predefined,
v[2],
tempVars=tempVars))
block.append('if (domainId)')
ifBlock = UnformattedBlock()
ifBlock.append(
'std::fill( dirichletComponent.begin(), dirichletComponent.end(), '
+ str(maxId + i + 2) + ' );')
if len(v[1]) > 0:
[
ifBlock.append('dirichletComponent[' + str(c) + '] = 0;')
for c in v[1]
]
ifBlock.append('return true;')
block.append(ifBlock)
defaultCode.append(block)
if wholeDomain is not None:
block = UnformattedBlock()
block.append(
'std::fill( dirichletComponent.begin(), dirichletComponent.end(), '
+ str(maxId + 1) + ' );')
if len(wholeDomain[1]) > 0:
[
block.append('dirichletComponent[' + str(c) + '] = 0;')
for c in wholeDomain[1]
]
block.append('return true;')
defaultCode.append(block)
defaultCode.append(return_(False))
bndId = Variable('const int', 'bndId')
getBndId = UnformattedExpression(
'int', 'BoundaryIdProviderType::boundaryId( ' +
integrands.arg_i.name + ' )')
# getBndId = UnformattedExpression('int', 'boundaryIdGetter_.boundaryId( ' + integrands.arg_i.name + ' )')
switch = SwitchStatement(bndId, default=defaultCode)
for i, v in bySubDomain.items():
code = []
if len(v[1]) > 0:
[
code.append('dirichletComponent[' + str(c) + '] = 0;')
for c in v[1]
]
code.append(return_(True))
switch.append(i, code)
integrands.isDirichletIntersection = [
Declaration(bndId, initializer=getBndId),
UnformattedBlock(
'std::fill( dirichletComponent.begin(), dirichletComponent.end(), '
+ bndId.name + ' );'), switch
]
predefined[x] = UnformattedExpression(
'auto', 'entity().geometry().global( Dune::Fem::coordinate( ' +
integrands.arg_x.name + ' ) )')
if wholeDomain is None:
defaultCode = assign(integrands.arg_r, construct("RRangeType", 0))
else:
defaultCode = generateDirichletCode(predefined,
wholeDomain[0],
tempVars=tempVars)
switch = SwitchStatement(integrands.arg_bndId, default=defaultCode)
for i, v in bySubDomain.items():
switch.append(
i, generateDirichletCode(predefined, v[0], tempVars=tempVars))
for i, v in enumerate(codeDomains):
switch.append(
i + maxId + 2,
generateDirichletCode(predefined, v[0], tempVars=tempVars))
integrands.dirichlet = [switch]
return integrands
def compute_form_data(
form,
# Default arguments configured to behave the way old FFC expects it:
do_apply_function_pullbacks=False,
do_apply_integral_scaling=False,
do_apply_geometry_lowering=False,
preserve_geometry_types=(),
do_apply_default_restrictions=True,
do_apply_restrictions=True,
do_estimate_degrees=True,
):
# TODO: Move this to the constructor instead
self = FormData()
# --- Store untouched form for reference.
# The user of FormData may get original arguments,
# original coefficients, and form signature from this object.
# But be aware that the set of original coefficients are not
# the same as the ones used in the final UFC form.
# See 'reduced_coefficients' below.
self.original_form = form
# --- Pass form integrands through some symbolic manipulation
# Note: Default behaviour here will process form the way that is
# currently expected by vanilla FFC
# Lower abstractions for tensor-algebra types into index notation,
# reducing the number of operators later algorithms and form
# compilers need to handle
form = apply_algebra_lowering(form)
# Apply differentiation before function pullbacks, because for
# example coefficient derivatives are more complicated to derive
# after coefficients are rewritten, and in particular for
# user-defined coefficient relations it just gets too messy
form = apply_derivatives(form)
# --- Group form integrals
# TODO: Refactor this, it's rather opaque what this does
# TODO: Is self.original_form.ufl_domains() right here?
# It will matter when we start including 'num_domains' in ufc form.
form = group_form_integrals(form, self.original_form.ufl_domains())
# Estimate polynomial degree of integrands now, before applying
# any pullbacks and geometric lowering. Otherwise quad degrees
# blow up horrifically.
if do_estimate_degrees:
form = attach_estimated_degrees(form)
if do_apply_function_pullbacks:
# Rewrite coefficients and arguments in terms of their
# reference cell values with Piola transforms and symmetry
# transforms injected where needed.
# Decision: Not supporting grad(dolfin.Expression) without a
# Domain. Current dolfin works if Expression has a
# cell but this should be changed to a mesh.
form = apply_function_pullbacks(form)
# Scale integrals to reference cell frames
if do_apply_integral_scaling:
form = apply_integral_scaling(form)
# Apply default restriction to fully continuous terminals
if do_apply_default_restrictions:
form = apply_default_restrictions(form)
# Lower abstractions for geometric quantities into a smaller set
# of quantities, allowing the form compiler to deal with a smaller
# set of types and treating geometric quantities like any other
# expressions w.r.t. loop-invariant code motion etc.
if do_apply_geometry_lowering:
form = apply_geometry_lowering(form, preserve_geometry_types)
# Apply differentiation again, because the algorithms above can
# generate new derivatives or rewrite expressions inside
# derivatives
if do_apply_function_pullbacks or do_apply_geometry_lowering:
form = apply_derivatives(form)
# Neverending story: apply_derivatives introduces new Jinvs,
# which needs more geometry lowering
if do_apply_geometry_lowering:
form = apply_geometry_lowering(form, preserve_geometry_types)
# Lower derivatives that may have appeared
form = apply_derivatives(form)
# Propagate restrictions to terminals
if do_apply_restrictions:
form = apply_restrictions(form)
# --- Group integrals into IntegralData objects
# Most of the heavy lifting is done above in group_form_integrals.
self.integral_data = build_integral_data(form.integrals())
# --- Create replacements for arguments and coefficients
# Figure out which form coefficients each integral should enable
for itg_data in self.integral_data:
itg_coeffs = set()
# Get all coefficients in integrand
for itg in itg_data.integrals:
itg_coeffs.update(extract_coefficients(itg.integrand()))
# Store with IntegralData object
itg_data.integral_coefficients = itg_coeffs
# Figure out which coefficients from the original form are
# actually used in any integral (Differentiation may reduce the
# set of coefficients w.r.t. the original form)
reduced_coefficients_set = set()
for itg_data in self.integral_data:
reduced_coefficients_set.update(itg_data.integral_coefficients)
self.reduced_coefficients = sorted(reduced_coefficients_set,
key=lambda c: c.count())
self.num_coefficients = len(self.reduced_coefficients)
self.original_coefficient_positions = [
i for i, c in enumerate(self.original_form.coefficients())
if c in self.reduced_coefficients
]
# Store back into integral data which form coefficients are used
# by each integral
for itg_data in self.integral_data:
itg_data.enabled_coefficients = [
bool(coeff in itg_data.integral_coefficients)
for coeff in self.reduced_coefficients
]
# --- Collect some trivial data
# Get rank of form from argument list (assuming not a mixed arity form)
self.rank = len(self.original_form.arguments())
# Extract common geometric dimension (topological is not common!)
self.geometric_dimension = self.original_form.integrals()[0].ufl_domain(
).geometric_dimension()
# --- Build mapping from old incomplete element objects to new
# well defined elements. This is to support the Expression
# construct in dolfin which subclasses Coefficient but doesn't
# provide an element, and the Constant construct that doesn't
# provide the domain that a Coefficient is supposed to have. A
# future design iteration in UFL/UFC/FFC/DOLFIN may allow removal
# of this mapping with the introduction of UFL types for
# Expression-like functions that can be evaluated in quadrature
# points.
self.element_replace_map = _compute_element_mapping(self.original_form)
# Mappings from elements and coefficients that reside in form to
# objects with canonical numbering as well as completed cells and
# elements
renumbered_coefficients, function_replace_map = \
_build_coefficient_replace_map(self.reduced_coefficients,
self.element_replace_map)
self.function_replace_map = function_replace_map
# --- Store various lists of elements and sub elements (adds
# members to self)
_compute_form_data_elements(self, self.original_form.arguments(),
renumbered_coefficients,
self.original_form.ufl_domains())
# --- Store number of domains for integral types
# TODO: Group this by domain first. For now keep a backwards
# compatible data structure.
self.max_subdomain_ids = _compute_max_subdomain_ids(self.integral_data)
# --- Checks
_check_elements(self)
_check_facet_geometry(self.integral_data)
# TODO: This is a very expensive check... Replace with something
# faster!
preprocessed_form = reconstruct_form_from_integral_data(self.integral_data)
check_form_arity(
preprocessed_form,
self.original_form.arguments()) # Currently testing how fast this is
# TODO: This member is used by unit tests, change the tests to
# remove this!
self.preprocessed_form = preprocessed_form
return self
] * dimR), name='destE')
u = TrialFunction(space)
v = TestFunction(space)
x = SpatialCoordinate(space.cell())
ubar = space.interpolate(as_vector([
dot(x, x),
] * dimR), name="ubar")
a = (inner(0.5 * dot(u, u), v[0]) + inner(u[0] * grad(u), grad(v))) * dx
op = create.operator("galerkin", a, space)
A = linearOperator(op)
op.jacobian(ubar, A)
A(arg, destA)
da = apply_derivatives(derivative(action(a, ubar), ubar, u))
dop = create.operator("galerkin", da, space)
dop(arg, destB)
err = integrate(grid, (destA - destB)**2, 5)
# print("error=",err)
assert (err < 1e-15)
A = linearOperator(dop)
dop.jacobian(arg, A)
A(arg, destC)
err = integrate(grid, (destA - destC)**2, 5)
# print("error=",err)
assert (err < 1e-15)
###############################################################
