def _sorted_integrals(integrals):
"""Sort integrals by domain id, integral type, subdomain id
for a more stable signature computation."""
# Group integrals in multilevel dict by keys
# [domain][integral_type][subdomain_id]
integrals_dict = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for integral in integrals:
d = integral.ufl_domain()
if d is None:
error("Each integral in a form must have a uniquely defined integration domain.")
it = integral.integral_type()
si = integral.subdomain_id()
integrals_dict[d][it][si] += [integral]
all_integrals = []
# Order integrals canonically to increase signature stability
for d in sort_domains(integrals_dict):
for it in sorted(integrals_dict[d]): # str is sortable
for si in sorted(integrals_dict[d][it],
key=lambda x: (type(x).__name__, x)): # int/str are sortable
unsorted_integrals = integrals_dict[d][it][si]
# TODO: At this point we could order integrals by
# metadata and integrand, or even add the
# integrands with the same metadata. This is
# done in
# accumulate_integrands_with_same_metadata in
# algorithms/domain_analysis.py and would
# further increase the signature stability.
all_integrals.extend(unsorted_integrals)
# integrals_dict[d][it][si] = unsorted_integrals
return tuple(all_integrals) # integrals_dict
def _square_matrix_shape(self, A):
sh = A.ufl_shape
if sh[0] != sh[1]:
error("Expecting square matrix.")
if sh[0] is None:
error("Unknown dimension.")
return sh
def extract_subelement_component(self, i):
"""Extract direct subelement index and subelement relative
component index for a given component index."""
if isinstance(i, int):
i = (i,)
self._check_component(i)
# Select between indexing modes
if len(self.value_shape()) == 1:
# Indexing into a long vector of flattened subelement
# shapes
j, = i
# Find subelement for this index
for sub_element_index, e in enumerate(self._sub_elements):
sh = e.value_shape()
si = product(sh)
if j < si:
break
j -= si
if j < 0:
error("Moved past last value component!")
# Convert index into a shape tuple
st = shape_to_strides(sh)
component = unflatten_index(j, st)
else:
# Indexing into a multidimensional tensor where subelement
# index is first axis
sub_element_index = i[0]
if sub_element_index >= len(self._sub_elements):
error("Illegal component index (dimension %d)." % sub_element_index)
component = i[1:]
return (sub_element_index, component)
def replace_integral_domains(form, common_domain): # TODO: Move elsewhere
"""Given a form and a domain, assign a common integration domain to
all integrals.
Does not modify the input form (``Form`` should always be
immutable). This is to support ill formed forms with no domain
specified, sometimes occurring in pydolfin, e.g. assemble(1*dx,
mesh=mesh).
"""
domains = form.ufl_domains()
if common_domain is not None:
gdim = common_domain.geometric_dimension()
tdim = common_domain.topological_dimension()
if not all((gdim == domain.geometric_dimension() and
tdim == domain.topological_dimension())
for domain in domains):
error("Common domain does not share dimensions with form domains.")
reconstruct = False
integrals = []
for itg in form.integrals():
domain = itg.ufl_domain()
if domain != common_domain:
itg = itg.reconstruct(domain=common_domain)
reconstruct = True
integrals.append(itg)
if reconstruct:
form = Form(integrals)
return form
def extract_subelement_reference_component(self, i):
"""Extract direct subelement index and subelement relative
reference_component index for a given reference_component index."""
if isinstance(i, int):
i = (i,)
self._check_reference_component(i)
# Select between indexing modes
assert len(self.reference_value_shape()) == 1
# Indexing into a long vector of flattened subelement shapes
j, = i
# Find subelement for this index
for sub_element_index, e in enumerate(self._sub_elements):
sh = e.reference_value_shape()
si = product(sh)
if j < si:
break
j -= si
if j < 0:
error("Moved past last value reference_component!")
# Convert index into a shape tuple
st = shape_to_strides(sh)
reference_component = unflatten_index(j, st)
return (sub_element_index, reference_component)
def tree_format(expression, indentation=0, parentheses=True):
s = ""
if isinstance(expression, Form):
form = expression
integrals = form.integrals()
integral_types = sorted(set(itg.integral_type() for itg in integrals))
itgs = []
for integral_type in integral_types:
itgs += list(form.integrals_by_type(integral_type))
ind = _indent_string(indentation)
s += ind + "Form:\n"
s += "\n".join(tree_format(itg, indentation + 1, parentheses) for itg in itgs)
elif isinstance(expression, Integral):
ind = _indent_string(indentation)
s += ind + "Integral:\n"
ind = _indent_string(indentation + 1)
s += ind + "integral type: %s\n" % expression.integral_type()
s += ind + "subdomain id: %s\n" % expression.subdomain_id()
s += ind + "integrand:\n"
s += tree_format(expression._integrand, indentation + 2, parentheses)
elif isinstance(expression, Expr):
s += _tree_format_expression(expression, indentation, parentheses)
else:
error("Invalid object type %s" % type(expression))
return s
def form_info(form):
if not isinstance(form, Form):
error("Expecting a Form.")
bf = form.arguments()
cf = form.coefficients()
s = "Form info:\n"
s += " rank: %d\n" % len(bf)
s += " num_coefficients: %d\n" % len(cf)
s += "\n"
for f in cf:
if f._name:
s += "\n"
s += " Coefficient %d is named '%s'" % (f._count, f._name)
s += "\n"
integrals = form.integrals()
integral_types = sorted(set(itg.integral_type() for itg in integrals))
for integral_type in integral_types:
itgs = form.integrals_by_type(integral_type)
s += " num_{0}_integrals: {1}\n".format(integral_type, len(itgs))
s += "\n"
for integral_type in integral_types:
itgs = form.integrals_by_type(integral_type)
for itg in itgs:
s += integral_info(itg)
s += "\n"
return s
def reference_grad(self, o):
"Represent ref_grad(ref_grad(f)) as RefGrad(RefGrad(f))."
# Check that o is a "differential terminal"
if not isinstance(o.ufl_operands[0],
(ReferenceGrad, ReferenceValue, Terminal)):
error("Expecting only grads applied to a terminal.")
return ReferenceGrad(o)
def __init__(self, *expressions):
Operator.__init__(self, expressions)
# Checks
indexset = set(self.ufl_operands[0].ufl_free_indices)
if not all(not (indexset ^ set(e.ufl_free_indices)) for e in self.ufl_operands):
error("Can't combine subtensor expressions with different sets of free indices.")
def power(self, o, fp, gp):
f, g = o.ufl_operands
if not is_true_ufl_scalar(f):
error("Expecting scalar expression f in f**g.")
if not is_true_ufl_scalar(g):
error("Expecting scalar expression g in f**g.")
# Derivation of the general case: o = f(x)**g(x)
# do/df = g * f**(g-1) = g / f * o
# do/dg = ln(f) * f**g = ln(f) * o
# do/df * df + do/dg * dg = o * (g / f * df + ln(f) * dg)
if isinstance(gp, Zero):
# This probably produces better results for the common
# case of f**constant
op = fp * g * f**(g-1)
else:
# Note: This produces expressions like (1/w)*w**5 instead of w**4
# op = o * (fp * g / f + gp * ln(f)) # This reuses o
op = f**(g-1) * (g*fp + f*ln(f)*gp) # This gives better accuracy in dolfin integration test
# Example: d/dx[x**(x**3)]:
# f = x
# g = x**3
# df = 1
# dg = 3*x**2
# op1 = o * (fp * g / f + gp * ln(f))
# = x**(x**3) * (x**3/x + 3*x**2*ln(x))
# op2 = f**(g-1) * (g*fp + f*ln(f)*gp)
# = x**(x**3-1) * (x**3 + x*3*x**2*ln(x))
return op
def math_function(self, o, df):
# FIXME: Introduce a UserOperator type instead of this hack
# and define user derivative() function properly
if hasattr(o, 'derivative'):
f, = o.ufl_operands
return df * o.derivative()
error("Unknown math function.")
def equals_func_with_collision_measuring(self, other):
# Call equals
equal = equals_func(self, other)
# Get properties
st = type(self)
ot = type(other)
sn = st.__name__
on = ot.__name__
sh = hash(self)
oh = hash(other)
key = (sn, on)
# If hashes are the same but objects are not equal, we have a
# collision
hash_total[key] += 1
if sh == oh and not equal:
hash_collisions[key] += 1
elif sh != oh and equal:
error("Equal objects must always have the same hash! Objects are:\n{0}\n{1}".format(self, other))
elif sh == oh and equal:
hash_equals[key] += 1
elif sh != oh and not equal:
hash_notequals[key] += 1
return equal
def spatial_coordinate(self, o):
do = self._w2v.get(o)
# d x /d x => Argument(x.function_space())
if do is not None:
return do
else:
error("Not implemented: CoordinateDerivative found a SpatialCoordinate that is different from the one being differentiated.")
def apply_nested_forward_ad(expr, dim):
if isinstance(expr, Terminal):
# A terminal needs no differentiation applied
return expr
elif not isinstance(expr, Derivative):
# Apply AD recursively to children
preops = expr.operands()
postops = tuple(apply_nested_forward_ad(o, dim) for o in preops)
# Reconstruct if necessary
need_reconstruct = not (preops == postops) # FIXME: Is this efficient? O(n)?
if need_reconstruct:
expr = expr.reconstruct(*postops)
return expr
elif isinstance(expr, Grad):
# Apply AD recursively to children
f, = expr.operands()
f = apply_nested_forward_ad(f, dim)
# Apply Grad-specialized AD to expanded child
return compute_grad_forward_ad(f, dim)
elif isinstance(expr, VariableDerivative):
# Apply AD recursively to children
f, v = expr.operands()
f = apply_nested_forward_ad(f, dim)
# Apply Variable-specialized AD to expanded child
return compute_variable_forward_ad(f, v, dim)
elif isinstance(expr, CoefficientDerivative):
# Apply AD recursively to children
f, w, v, cd = expr.operands()
f = apply_nested_forward_ad(f, dim)
# Apply Coefficient-specialized AD to expanded child
return compute_coefficient_forward_ad(f, w, v, cd, dim)
else:
error("Unknown type.")
def register_element2(family, value_rank, sobolev_space, mapping,
degree_range, cellnames):
"Register new finite element family."
if family in ufl_elements:
error('Finite element \"%s\" has already been registered.' % family)
ufl_elements[family] = (family, family, value_rank, sobolev_space,
mapping, degree_range, cellnames)
def index_sum(self, o):
A, i = o.operands()
# Consider the following case:
# (v[i]*u[i]).dx(i)
# which is represented like
# SpatialDerivative(IndexSum(..., i), i)
# if we move the derivative inside the sum,
# then the derivative suddenly gets accumulated,
# which is completely wrong!
if self._var_free_indices:
if i[0] in self._var_free_indices:
error("Index scope collision. Work around this by reusing indices less in different expressions.\n"\
"An example where this occurs is (v[i]*v[i]).dx(i) where the same index i\n"\
"is bound to an index sum inside the derivative .dx(i).")
# TODO: OR get around this by temporarily setting _var_free_indices to nothing?
#store = self._var_free_indices
#self._var_free_indices = nothing?
#visit children
#self._var_free_indices = store
# But... What would this mean? Will it be correct?
# TODO: Get around this with relabeling algorithm!
# j = Index()
# A = relabel(A, { i0: j })
# i = (j,)
A2, Ap = self.visit(A)
o = self.reuse_if_possible(o, A2, i)
op = IndexSum(Ap, i)
return (o, op)
def math_function(self, o, a):
if hasattr(o, 'derivative'): # FIXME: Introduce a UserOperator type instead of this hack
f, fp = a
o = self.reuse_if_possible(o, f)
op = fp * o.derivative()
return (o, op)
error("Unknown math function.")
def apply_geometry_lowering(form, preserve_types=()):
"""Change GeometricQuantity objects in expression to the lowest level GeometricQuantity objects.
Assumes the expression is preprocessed or at least that derivatives have been expanded.
@param form:
An Expr or Form.
"""
if isinstance(form, Form):
newintegrals = [apply_geometry_lowering(integral, preserve_types)
for integral in form.integrals()]
return Form(newintegrals)
elif isinstance(form, Integral):
integral = form
if integral.integral_type() in (custom_integral_types + point_integral_types):
automatic_preserve_types = [SpatialCoordinate, Jacobian]
else:
automatic_preserve_types = [CellCoordinate]
preserve_types = set(preserve_types) | set(automatic_preserve_types)
mf = GeometryLoweringApplier(preserve_types)
newintegrand = map_expr_dag(mf, integral.integrand())
return integral.reconstruct(integrand=newintegrand)
elif isinstance(form, Expr):
expr = form
mf = GeometryLoweringApplier(preserve_types)
return map_expr_dag(mf, expr)
else:
error("Invalid type %s" % (form.__class__.__name__,))
def __init__(self, coordinate_element, ufl_id=None, cargo=None):
self._ufl_id = self._init_ufl_id(ufl_id)
# Store reference to object that will not be used by UFL
self._ufl_cargo = cargo
if cargo is not None and cargo.ufl_id() != self._ufl_id:
error("Expecting cargo object (e.g. dolfin.Mesh) to have the same ufl_id.")
# No longer accepting coordinates provided as a Coefficient
from ufl.coefficient import Coefficient
if isinstance(coordinate_element, Coefficient):
error("Expecting a coordinate element in the ufl.Mesh construct.")
# Accept a cell in place of an element for brevity Mesh(triangle)
if isinstance(coordinate_element, AbstractCell):
from ufl.finiteelement import VectorElement
cell = coordinate_element
coordinate_element = VectorElement("Lagrange", cell, 1,
dim=cell.geometric_dimension())
# Store coordinate element
self._ufl_coordinate_element = coordinate_element
# Derive dimensions from element
gdim, = coordinate_element.value_shape()
tdim = coordinate_element.cell().topological_dimension()
AbstractDomain.__init__(self, tdim, gdim)
def compute_form_action(form, coefficient):
"""Compute the action of a form on a Coefficient.
This works simply by replacing the last Argument
with a Coefficient on the same function space (element).
The form returned will thus have one Argument less
and one additional Coefficient at the end if no
Coefficient has been provided.
"""
# TODO: Check whatever makes sense for coefficient
# Extract all arguments
arguments = form.arguments()
parts = [arg.part() for arg in arguments]
if set(parts) - {None}:
error("compute_form_action cannot handle parts.")
# Pick last argument (will be replaced)
u = arguments[-1]
fs = u.ufl_function_space()
if coefficient is None:
coefficient = Coefficient(fs)
elif coefficient.ufl_function_space() != fs:
debug("Computing action of form on a coefficient in a different function space.")
return replace(form, {u: coefficient})
def cell_normal(self, o):
if self._preserve_types[o._ufl_typecode_]:
return o
domain = o.ufl_domain()
gdim = domain.geometric_dimension()
tdim = domain.topological_dimension()
if tdim == gdim - 1: # n-manifold embedded in n-1 space
i = Index()
J = self.jacobian(Jacobian(domain))
if tdim == 2:
# Surface in 3D
t0 = as_vector(J[i, 0], i)
t1 = as_vector(J[i, 1], i)
cell_normal = cross_expr(t0, t1)
elif tdim == 1:
# Line in 2D (cell normal is 'up' for a line pointing
# to the 'right')
cell_normal = as_vector((-J[1, 0], J[0, 0]))
else:
error("Cell normal not implemented for tdim %d, gdim %d" % (tdim, gdim))
# Return normalized vector, sign corrected by cell
# orientation
co = CellOrientation(domain)
return co * cell_normal / sqrt(cell_normal[i]*cell_normal[i])
else:
error("What do you want cell normal in gdim={0}, tdim={1} to be?".format(gdim, tdim))
def extract_arguments_and_coefficients(a):
"""Build two sorted lists of all arguments and coefficients
in a, which can be a Form, Integral or Expr."""
# This function is faster than extract_arguments + extract_coefficients
# for large forms, and has more validation built in.
# Extract lists of all form argument instances
terminals = extract_type(a, FormArgument)
arguments = [f for f in terminals if isinstance(f, Argument)]
coefficients = [f for f in terminals if isinstance(f, Coefficient)]
# Build count: instance mappings, should be one to one
bfcounts = dict((f, f.count()) for f in arguments)
fcounts = dict((f, f.count()) for f in coefficients)
if len(bfcounts) != len(set(bfcounts.values())):
msg = """\
Found different Arguments with same counts.
Did you combine test or trial functions from different spaces?
The Arguments found are:\n%s""" % "\n".join(" %s" % f for f in arguments)
error(msg)
if len(fcounts) != len(set(fcounts.values())):
msg = """\
Found different coefficients with same counts.
The arguments found are:\n%s""" % "\n".join(" %s" % f for f in coefficients)
error(msg)
# Passed checks, so we can safely sort the instances by count
arguments = sorted_by_count(arguments)
coefficients = sorted_by_count(coefficients)
return arguments, coefficients
def cofactor(self, o, A):
# TODO: Find common subexpressions here.
# TODO: Better implementation?
sh = self._square_matrix_shape(A)
if sh[0] == 2:
return as_matrix([[A[1,1],-A[1,0]],[-A[0,1],A[0,0]]])
elif sh[0] == 3:
return as_matrix([
[A[1,1]*A[2,2] - A[2,1]*A[1,2],A[2,0]*A[1,2] - A[1,0]*A[2,2], - A[2,0]*A[1,1] + A[1,0]*A[2,1]],
[A[2,1]*A[0,2] - A[0,1]*A[2,2],A[0,0]*A[2,2] - A[2,0]*A[0,2], - A[0,0]*A[2,1] + A[2,0]*A[0,1]],
[A[0,1]*A[1,2] - A[1,1]*A[0,2],A[1,0]*A[0,2] - A[0,0]*A[1,2], - A[1,0]*A[0,1] + A[0,0]*A[1,1]]
])
elif sh[0] == 4:
return as_matrix([
[-A[3,1]*A[2,2]*A[1,3] - A[3,2]*A[2,3]*A[1,1] + A[1,3]*A[3,2]*A[2,1] + A[3,1]*A[2,3]*A[1,2] + A[2,2]*A[1,1]*A[3,3] - A[3,3]*A[2,1]*A[1,2],
-A[1,0]*A[2,2]*A[3,3] + A[2,0]*A[3,3]*A[1,2] + A[2,2]*A[1,3]*A[3,0] - A[2,3]*A[3,0]*A[1,2] + A[1,0]*A[3,2]*A[2,3] - A[1,3]*A[3,2]*A[2,0],
A[1,0]*A[3,3]*A[2,1] + A[2,3]*A[1,1]*A[3,0] - A[2,0]*A[1,1]*A[3,3] - A[1,3]*A[3,0]*A[2,1] - A[1,0]*A[3,1]*A[2,3] + A[3,1]*A[1,3]*A[2,0],
A[3,0]*A[2,1]*A[1,2] + A[1,0]*A[3,1]*A[2,2] + A[3,2]*A[2,0]*A[1,1] - A[2,2]*A[1,1]*A[3,0] - A[3,1]*A[2,0]*A[1,2] - A[1,0]*A[3,2]*A[2,1]],
[ A[3,1]*A[2,2]*A[0,3] + A[0,2]*A[3,3]*A[2,1] + A[0,1]*A[3,2]*A[2,3] - A[3,1]*A[0,2]*A[2,3] - A[0,1]*A[2,2]*A[3,3] - A[3,2]*A[0,3]*A[2,1],
-A[2,2]*A[0,3]*A[3,0] - A[0,2]*A[2,0]*A[3,3] - A[3,2]*A[2,3]*A[0,0] + A[2,2]*A[3,3]*A[0,0] + A[0,2]*A[2,3]*A[3,0] + A[3,2]*A[2,0]*A[0,3],
A[3,1]*A[2,3]*A[0,0] - A[0,1]*A[2,3]*A[3,0] - A[3,1]*A[2,0]*A[0,3] - A[3,3]*A[0,0]*A[2,1] + A[0,3]*A[3,0]*A[2,1] + A[0,1]*A[2,0]*A[3,3],
A[3,2]*A[0,0]*A[2,1] - A[0,2]*A[3,0]*A[2,1] + A[0,1]*A[2,2]*A[3,0] + A[3,1]*A[0,2]*A[2,0] - A[0,1]*A[3,2]*A[2,0] - A[3,1]*A[2,2]*A[0,0]],
[ A[3,1]*A[1,3]*A[0,2] - A[0,2]*A[1,1]*A[3,3] - A[3,1]*A[0,3]*A[1,2] + A[3,2]*A[1,1]*A[0,3] + A[0,1]*A[3,3]*A[1,2] - A[0,1]*A[1,3]*A[3,2],
A[1,3]*A[3,2]*A[0,0] - A[1,0]*A[3,2]*A[0,3] - A[1,3]*A[0,2]*A[3,0] + A[0,3]*A[3,0]*A[1,2] + A[1,0]*A[0,2]*A[3,3] - A[3,3]*A[0,0]*A[1,2],
-A[1,0]*A[0,1]*A[3,3] + A[0,1]*A[1,3]*A[3,0] - A[3,1]*A[1,3]*A[0,0] - A[1,1]*A[0,3]*A[3,0] + A[1,0]*A[3,1]*A[0,3] + A[1,1]*A[3,3]*A[0,0],
A[0,2]*A[1,1]*A[3,0] - A[3,2]*A[1,1]*A[0,0] - A[0,1]*A[3,0]*A[1,2] - A[1,0]*A[3,1]*A[0,2] + A[3,1]*A[0,0]*A[1,2] + A[1,0]*A[0,1]*A[3,2]],
[ A[0,3]*A[2,1]*A[1,2] + A[0,2]*A[2,3]*A[1,1] + A[0,1]*A[2,2]*A[1,3] - A[2,2]*A[1,1]*A[0,3] - A[1,3]*A[0,2]*A[2,1] - A[0,1]*A[2,3]*A[1,2],
A[1,0]*A[2,2]*A[0,3] + A[1,3]*A[0,2]*A[2,0] - A[1,0]*A[0,2]*A[2,3] - A[2,0]*A[0,3]*A[1,2] - A[2,2]*A[1,3]*A[0,0] + A[2,3]*A[0,0]*A[1,2],
-A[0,1]*A[1,3]*A[2,0] + A[2,0]*A[1,1]*A[0,3] + A[1,3]*A[0,0]*A[2,1] - A[1,0]*A[0,3]*A[2,1] + A[1,0]*A[0,1]*A[2,3] - A[2,3]*A[1,1]*A[0,0],
A[1,0]*A[0,2]*A[2,1] - A[0,2]*A[2,0]*A[1,1] + A[0,1]*A[2,0]*A[1,2] + A[2,2]*A[1,1]*A[0,0] - A[1,0]*A[0,1]*A[2,2] - A[0,0]*A[2,1]*A[1,2]]
])
error("Cofactor not implemented for dimension %s." % sh[0])
def _check_form_arity(preprocessed_form):
# Check that we don't have a mixed linear/bilinear form or
# anything like that
# FIXME: This is slooow and should be moved to form compiler
# and/or replaced with something faster
if 1 != len(compute_form_arities(preprocessed_form)):
error("All terms in form must have same rank.")
def ufl2dot(expression, formname="a", nodeoffset=0, begin=True, end=True,
labeling="repr", object_names=None):
if labeling == "repr":
labeller = ReprLabeller()
elif labeling == "compact":
labeller = CompactLabeller(object_names or {})
print(object_names)
if isinstance(expression, Form):
form = expression
subgraphs = []
k = 0
for itg in form.integrals():
prefix = "itg%d_" % k
integralkey = "%s%s" % (itg.integral_type(), itg.subdomain_id())
integrallabel = "%s %s" % (itg.integral_type().capitalize().replace("_", " "), "integral")
integrallabel += " %s" % (itg.subdomain_id(),)
integrand = itg.integrand()
nodes = {}
edges = []
build_entities(integrand, nodes, edges, nodeoffset, prefix,
labeller)
rootnode = nodes[id(integrand)][0]
entitylist = format_entities(nodes, edges)
integralnode = "%s_%s" % (formname, integralkey)
subgraphs.append(integralgraphformat % {
'node': integralnode,
'label': integrallabel,
'formname': formname,
'root': rootnode,
'entities': entitylist, })
nodeoffset += len(nodes)
s = ""
if begin:
s += 'digraph ufl_form\n{\n node [shape="box"] ;\n'
s += ' form_%s [label="Form %s"] ;' % (formname, formname)
s += "\n".join(subgraphs)
if end:
s += "\n}"
elif isinstance(expression, Expr):
nodes = {}
edges = []
build_entities(expression, nodes, edges, nodeoffset, '', labeller)
entitylist = format_entities(nodes, edges)
s = exprgraphformat % entitylist
nodeoffset += len(nodes)
else:
error("Invalid object type %s" % type(expression))
return s, nodeoffset
def multiply_block_interior_facets(point_index, unames, ttypes, unique_tables, unique_table_num_dofs):
rank = len(unames)
tables = [unique_tables.get(name) for name in unames]
num_dofs = tuple(unique_table_num_dofs[name] for name in unames)
num_entities = max([1] + [tbl.shape[0] for tbl in tables if tbl is not None])
ptable = numpy.zeros((num_entities,)*rank + num_dofs)
for facets in itertools.product(*[range(num_entities)]*rank):
vectors = []
for i, tbl in enumerate(tables):
if tbl is None:
assert ttypes[i] == "ones"
vectors.append(numpy.ones((num_dofs[i],)))
else:
# Some tables are compacted along entities or points
e = 0 if tbl.shape[0] == 1 else facets[i]
q = 0 if tbl.shape[1] == 1 else point_index
vectors.append(tbl[e, q, :])
if rank > 1:
assert rank == 2
ptable[facets[0], facets[1], ...] = numpy.outer(*vectors)
elif rank == 1:
ptable[facets[0], :] = vectors[0]
else:
error("Nothing to multiply!")
return ptable
def _check_elements(form_data):
for element in chain(form_data.unique_elements,
form_data.unique_sub_elements):
if element.family() is None:
error("Found element with undefined familty: %s" % repr(element))
if element.cell() is None:
error("Found element with undefined cell: %s" % repr(element))
def deviatoric(self, o, A):
sh = self._square_matrix_shape(A)
if sh[0] == 2:
return as_matrix([[-1./2*A[1,1]+1./2*A[0,0],A[0,1]],[A[1,0],1./2*A[1,1]-1./2*A[0,0]]])
elif sh[0] == 3:
return as_matrix([[-1./3*A[1,1]-1./3*A[2,2]+2./3*A[0,0],A[0,1],A[0,2]],[A[1,0],2./3*A[1,1]-1./3*A[2,2]-1./3*A[0,0],A[1,2]],[A[2,0],A[2,1],-1./3*A[1,1]+2./3*A[2,2]-1./3*A[0,0]]])
error("dev(A) not implemented for dimension %s." % sh[0])
def __init__(self, integrals):
# Basic input checking (further compatibilty analysis happens
# later)
if not all(isinstance(itg, Integral) for itg in integrals):
error("Expecting list of integrals.")
# Store integrals sorted canonically to increase signature
# stability
self._integrals = _sorted_integrals(integrals)
# Internal variables for caching domain data
self._integration_domains = None
self._domain_numbering = None
# Internal variables for caching subdomain data
self._subdomain_data = None
# Internal variables for caching form argument data
self._arguments = None
self._coefficients = None
self._coefficient_numbering = None
# Internal variables for caching of hash and signature after
# first request
self._hash = None
self._signature = None
# Never use this internally in ufl!
self._cache = {}
def compute_form_with_arity(form, arity, arguments=None):
"""Compute parts of form of given arity."""
# Extract all arguments in form
if arguments is None:
arguments = form.arguments()
parts = [arg.part() for arg in arguments]
if set(parts) - {None}:
error("compute_form_with_arity cannot handle parts.")
if len(arguments) < arity:
warning("Form has no parts with arity %d." % arity)
return 0*form
# Assuming that the form is not a sum of terms
# that depend on different arguments, e.g. (u+v)*dx
# would result in just v*dx. But that doesn't make
# any sense anyway.
sub_arguments = set(arguments[:arity])
pe = PartExtracter(sub_arguments)
def _transform(e):
e, provides = pe.visit(e)
if provides == sub_arguments:
return e
return Zero()
return map_integrands(_transform, form)
def coefficient_derivative(self, o):
error("Derivatives should be applied before executing replace.")
def reference_grad(self, o, *dummy_ops):
error(
"Not expecting reference grad while applying change to reference grad."
)
def coefficient_derivative(self, o, *dummy_ops):
error(
"Coefficient derivatives should be expanded before applying change to reference grad."
)
def perp(v):
"UFL operator: Take the perp of *v*, i.e. :math:`(-v_1, +v_0)`."
v = as_ufl(v)
if v.ufl_shape != (2,):
error("Expecting a 2D vector expression.")
return as_vector((-v[1], v[0]))
def grad(self, o):
# Peel off the Grads and count them, and get restriction if
# it's between the grad and the terminal
ngrads = 0
restricted = ''
rv = False
while not o._ufl_is_terminal_:
if isinstance(o, Grad):
o, = o.ufl_operands
ngrads += 1
elif isinstance(o, Restricted):
restricted = o.side()
o, = o.ufl_operands
elif isinstance(o, ReferenceValue):
rv = True
o, = o.ufl_operands
else:
error("Invalid type %s" % o._ufl_class_.__name__)
f = o
if rv:
f = ReferenceValue(f)
# Get domain and create Jacobian inverse object
domain = o.ufl_domain()
Jinv = JacobianInverse(domain)
if is_cellwise_constant(Jinv):
# Optimise slightly by turning Grad(Grad(...)) into
# J^(-T)J^(-T)RefGrad(RefGrad(...))
# rather than J^(-T)RefGrad(J^(-T)RefGrad(...))
# Create some new indices
ii = indices(len(f.ufl_shape)) # Indices to get to the scalar component of f
jj = indices(ngrads) # Indices to sum over the local gradient axes with the inverse Jacobian
kk = indices(ngrads) # Indices for the leftover inverse Jacobian axes
# Preserve restricted property
if restricted:
Jinv = Jinv(restricted)
f = f(restricted)
# Apply the same number of ReferenceGrad without mappings
lgrad = f
for i in range(ngrads):
lgrad = ReferenceGrad(lgrad)
# Apply mappings with scalar indexing operations (assumes
# ReferenceGrad(Jinv) is zero)
jinv_lgrad_f = lgrad[ii + jj]
for j, k in zip(jj, kk):
jinv_lgrad_f = Jinv[j, k] * jinv_lgrad_f
# Wrap back in tensor shape, derivative axes at the end
jinv_lgrad_f = as_tensor(jinv_lgrad_f, ii + kk)
else:
# J^(-T)RefGrad(J^(-T)RefGrad(...))
# Preserve restricted property
if restricted:
Jinv = Jinv(restricted)
f = f(restricted)
jinv_lgrad_f = f
for foo in range(ngrads):
ii = indices(len(jinv_lgrad_f.ufl_shape)) # Indices to get to the scalar component of f
j, k = indices(2)
lgrad = ReferenceGrad(jinv_lgrad_f)
jinv_lgrad_f = Jinv[j, k] * lgrad[ii + (j,)]
# Wrap back in tensor shape, derivative axes at the end
jinv_lgrad_f = as_tensor(jinv_lgrad_f, ii + (k,))
return jinv_lgrad_f
def _mapped(self, t):
# Check that we have a valid input object
if not isinstance(t, Terminal):
error("Expecting a Terminal.")
# Get modifiers accumulated by previous handler calls
ngrads = self._ngrads
restricted = self._restricted
avg = self._avg
if avg != "":
error("Averaging not implemented.") # FIXME
# These are the global (g) and reference (r) values
if isinstance(t, FormArgument):
g = t
r = ReferenceValue(g)
elif isinstance(t, GeometricQuantity):
g = t
r = g
else:
error("Unexpected type {0}.".format(type(t).__name__))
# Some geometry mapping objects we may need multiple times below
domain = t.ufl_domain()
J = Jacobian(domain)
detJ = JacobianDeterminant(domain)
K = JacobianInverse(domain)
# Restrict geometry objects if applicable
if restricted:
J = J(restricted)
detJ = detJ(restricted)
K = K(restricted)
# Create Hdiv mapping from possibly restricted geometry objects
Mdiv = (1.0 / detJ) * J
# Get component indices of global and reference terminal objects
gtsh = g.ufl_shape
# rtsh = r.ufl_shape
gtcomponents = compute_indices(gtsh)
# rtcomponents = compute_indices(rtsh)
# Create core modified terminal, with eventual
# layers of grad applied directly to the terminal,
# then eventual restriction applied last
for i in range(ngrads):
g = Grad(g)
r = ReferenceGrad(r)
if restricted:
g = g(restricted)
r = r(restricted)
# Get component indices of global and reference objects with
# grads applied
gsh = g.ufl_shape
# rsh = r.ufl_shape
# gcomponents = compute_indices(gsh)
# rcomponents = compute_indices(rsh)
# Get derivative component indices
dsh = gsh[len(gtsh):]
dcomponents = compute_indices(dsh)
# Create nested array to hold expressions for global
# components mapped from reference values
def ndarray(shape):
if len(shape) == 0:
return [None]
elif len(shape) == 1:
return [None] * shape[-1]
else:
return [ndarray(shape[1:]) for i in range(shape[0])]
global_components = ndarray(gsh)
# Compute mapping from reference values for each global component
for gtc in gtcomponents:
if isinstance(t, FormArgument):
# Find basic subelement and element-local component
# ec, element, eoffset = t.ufl_element().extract_component2(gtc) # FIXME: Translate this correctly
eoffset = 0
ec, element = t.ufl_element().extract_reference_component(gtc)
# Select mapping M from element, pick row emapping =
# M[ec,:], or emapping = [] if no mapping
if isinstance(element, MixedElement):
error("Expecting a basic element here.")
mapping = element.mapping()
if mapping == "contravariant Piola": # S == HDiv:
# Handle HDiv elements with contravariant piola
# mapping contravariant_hdiv_mapping = (1/det J) *
# J * PullbackOf(o)
ec, = ec
emapping = Mdiv[ec, :]
elif mapping == "covariant Piola": # S == HCurl:
# Handle HCurl elements with covariant piola mapping
# covariant_hcurl_mapping = JinvT * PullbackOf(o)
ec, = ec
emapping = K[:, ec] # Column of K is row of K.T
elif mapping == "identity":
emapping = None
else:
error("Unknown mapping {0}".format(mapping))
elif isinstance(t, GeometricQuantity):
eoffset = 0
emapping = None
else:
error("Unexpected type {0}.".format(type(t).__name__))
# Create indices
# if rtsh:
# i = Index()
if len(dsh) != ngrads:
error("Mismatch between derivative shape and ngrads.")
if ngrads:
ii = indices(ngrads)
else:
ii = ()
# Apply mapping row to reference object
if emapping: # Mapped, always nonscalar terminal Not
# using IndexSum for the mapping row dot product to
# keep it simple, because we don't have a slice type
emapped_ops = [emapping[s] * Indexed(r, MultiIndex((FixedIndex(eoffset + s),) + ii))
for s in range(len(emapping))]
emapped = sum(emapped_ops[1:], emapped_ops[0])
elif gtc: # Nonscalar terminal, unmapped
emapped = Indexed(r, MultiIndex((FixedIndex(eoffset),) + ii))
elif ngrads: # Scalar terminal, unmapped, with derivatives
emapped = Indexed(r, MultiIndex(ii))
else: # Scalar terminal, unmapped, no derivatives
emapped = r
for di in dcomponents:
# Multiply derivative mapping rows, parameterized by
# free column indices
dmapping = as_ufl(1)
for j in range(ngrads):
dmapping *= K[ii[j], di[j]] # Row of K is column of JinvT
# Compute mapping from reference values for this
# particular global component
global_value = dmapping * emapped
# Apply index sums
# if rtsh:
# global_value = IndexSum(global_value, MultiIndex((i,)))
# for j in range(ngrads): # Applied implicitly in the dmapping * emapped above
# global_value = IndexSum(global_value, MultiIndex((ii[j],)))
# This is the component index into the full object
# with grads applied
gc = gtc + di
# Insert in nested list
comp = global_components
for i in gc[:-1]:
comp = comp[i]
comp[0 if gc == () else gc[-1]] = global_value
# Wrap nested list in as_tensor unless we have a scalar
# expression
if gsh:
tensor = as_tensor(global_components)
else:
tensor, = global_components
return tensor
def evaluate(self, x, mapping, component, index_values):
"""Evaluate expression at given coordinate with given values for terminals."""
error("Symbolic evaluation of %s not available." %
self._ufl_class_.__name__)
def as_form(form):
"Convert to form if not a form, otherwise return form."
if not isinstance(form, Form):
error("Unable to convert object to a UFL form: %s" % ufl_err_str(form))
return form
def analyse_key(ii, rank):
"""Takes something the user might input as an index tuple
inside [], which could include complete slices (:) and
ellipsis (...), and returns tuples of actual UFL index objects.
The return value is a tuple (indices, axis_indices),
each being a tuple of IndexBase instances.
The return value 'indices' corresponds to all
input objects of these types:
- Index
- FixedIndex
- int => Wrapped in FixedIndex
The return value 'axis_indices' corresponds to all
input objects of these types:
- Complete slice (:) => Replaced by a single new index
- Ellipsis (...) => Replaced by multiple new indices
"""
# Wrap in tuple
if not isinstance(ii, (tuple, MultiIndex)):
ii = (ii, )
else:
# Flatten nested tuples, happens with f[...,ii] where ii is a
# tuple of indices
jj = []
for j in ii:
if isinstance(j, (tuple, MultiIndex)):
jj.extend(j)
else:
jj.append(j)
ii = tuple(jj)
# Convert all indices to Index or FixedIndex objects. If there is
# an ellipsis, split the indices into before and after.
axis_indices = set()
pre = []
post = []
indexlist = pre
for i in ii:
if i == Ellipsis:
# Switch from pre to post list when an ellipsis is
# encountered
if indexlist is not pre:
error("Found duplicate ellipsis.")
indexlist = post
else:
# Convert index to a proper type
if isinstance(i, numbers.Integral):
idx = FixedIndex(i)
elif isinstance(i, IndexBase):
idx = i
elif isinstance(i, slice):
if i == slice(None):
idx = Index()
axis_indices.add(idx)
else:
# TODO: Use ListTensor to support partial slices?
error(
"Partial slices not implemented, only complete slices like [:]"
)
else:
error("Can't convert this object to index: %s" % (i, ))
# Store index in pre or post list
indexlist.append(idx)
# Handle ellipsis as a number of complete slices, that is create a
# number of new axis indices
num_axis = rank - len(pre) - len(post)
if indexlist is post:
ellipsis_indices = indices(num_axis)
axis_indices.update(ellipsis_indices)
else:
ellipsis_indices = ()
# Construct final tuples to return
all_indices = tuple(chain(pre, ellipsis_indices, post))
axis_indices = tuple(i for i in all_indices if i in axis_indices)
return all_indices, axis_indices
def interpret_ufl_namespace(namespace):
"Takes a namespace dict from an executed ufl file and converts it to a FileData object."
# Object to hold all returned data
ufd = FileData()
# Extract object names for Form, Coefficient and FiniteElementBase objects
# The use of id(obj) as key in object_names is necessary
# because we need to distinguish between instances,
# and not just between objects with different values.
for name, value in sorted_by_key(namespace):
# Store objects by reserved name OR instance id
reserved_names = ("unknown", ) # Currently only one reserved name
if name in reserved_names:
# Store objects with reserved names
ufd.reserved_objects[name] = value
# FIXME: Remove after FFC is updated to use reserved_objects:
ufd.object_names[name] = value
ufd.object_by_name[name] = value
elif isinstance(value, (FiniteElementBase, Coefficient, Constant,
Argument, Form, Expr, Mesh)):
# Store instance <-> name mappings for important objects
# without a reserved name
ufd.object_names[id(value)] = name
ufd.object_by_name[name] = value
# Get list of exported forms
forms = namespace.get("forms")
if forms is None:
# Get forms from object_by_name, which has already mapped
# tuple->Form where needed
def get_form(name):
form = ufd.object_by_name.get(name)
return form if isinstance(form, Form) else None
a_form = get_form("a")
L_form = get_form("L")
M_form = get_form("M")
forms = [a_form, L_form, M_form]
# Add forms F and J if not "a" and "L" are used
if a_form is None or L_form is None:
F_form = get_form("F")
J_form = get_form("J")
forms += [F_form, J_form]
# Remove Nones
forms = [f for f in forms if isinstance(f, Form)]
ufd.forms = forms
# Validate types
if not isinstance(ufd.forms, (list, tuple)):
error("Expecting 'forms' to be a list or tuple, not '%s'." %
type(ufd.forms))
if not all(isinstance(a, Form) for a in ufd.forms):
error("Expecting 'forms' to be a list of Form instances.")
# Get list of exported elements
elements = namespace.get("elements")
if elements is None:
elements = [ufd.object_by_name.get(name) for name in ("element", )]
elements = [e for e in elements if e is not None]
ufd.elements = elements
# Validate types
if not isinstance(ufd.elements, (list, tuple)):
error("Expecting 'elements' to be a list or tuple, not '%s'." %
type(ufd.elements))
if not all(isinstance(e, FiniteElementBase) for e in ufd.elements):
error(
"Expecting 'elements' to be a list of FiniteElementBase instances."
)
# Get list of exported coefficients
# TODO: Temporarily letting 'coefficients' override 'functions',
# but allow 'functions' for compatibility
functions = namespace.get("functions", [])
if functions:
warning(
"Deprecation warning: Rename 'functions' to 'coefficients' to export coefficients."
)
ufd.coefficients = namespace.get("coefficients", functions)
# Validate types
if not isinstance(ufd.coefficients, (list, tuple)):
error("Expecting 'coefficients' to be a list or tuple, not '%s'." %
type(ufd.coefficients))
if not all(isinstance(e, Coefficient) for e in ufd.coefficients):
error(
"Expecting 'coefficients' to be a list of Coefficient instances.")
# Get list of exported expressions
ufd.expressions = namespace.get("expressions", [])
# Validate types
if not isinstance(ufd.expressions, (list, tuple)):
error("Expecting 'expressions' to be a list or tuple, not '%s'." %
type(ufd.expressions))
if not all(isinstance(e, Expr) for e in ufd.expressions):
error("Expecting 'expressions' to be a list of Expr instances.")
# Get list of mesh objects
meshes = namespace.get("meshes")
if meshes is None:
meshes = [ufd.object_by_name.get(name) for name in ("mesh", )]
meshes = [m for m in meshes if m is not None]
ufd.meshes = meshes
# Validate types
if not isinstance(ufd.coefficients, (list, tuple)):
error("Expecting 'meshes' to be a list or tuple, not '%s'." %
type(ufd.meshes))
if not all(isinstance(m, Mesh) for m in ufd.meshes):
error("Expecting 'meshes' to be a list of Mesh instances.")
# Return file data
return ufd
def _mult(a, b):
# Discover repeated indices, which results in index sums
afi = a.ufl_free_indices
bfi = b.ufl_free_indices
afid = a.ufl_index_dimensions
bfid = b.ufl_index_dimensions
fi, fid, ri, rid = merge_overlapping_indices(afi, afid, bfi, bfid)
# Pick out valid non-scalar products here (dot products):
# - matrix-matrix (A*B, M*grad(u)) => A . B
# - matrix-vector (A*v) => A . v
s1, s2 = a.ufl_shape, b.ufl_shape
r1, r2 = len(s1), len(s2)
if r1 == 0 and r2 == 0:
# Create scalar product
p = Product(a, b)
ti = ()
elif r1 == 0 or r2 == 0:
# Scalar - tensor product
if r2 == 0:
a, b = b, a
# Check for zero, simplifying early if possible
if isinstance(a, Zero) or isinstance(b, Zero):
shape = s1 or s2
return Zero(shape, fi, fid)
# Repeated indices are allowed, like in:
# v[i]*M[i,:]
# Apply product to scalar components
ti = indices(len(b.ufl_shape))
p = Product(a, b[ti])
elif r1 == 2 and r2 in (1, 2): # Matrix-matrix or matrix-vector
if ri:
error("Not expecting repeated indices in non-scalar product.")
# Check for zero, simplifying early if possible
if isinstance(a, Zero) or isinstance(b, Zero):
shape = s1[:-1] + s2[1:]
return Zero(shape, fi, fid)
# Return dot product in index notation
ai = indices(len(a.ufl_shape) - 1)
bi = indices(len(b.ufl_shape) - 1)
k = indices(1)
p = a[ai + k] * b[k + bi]
ti = ai + bi
else:
error("Invalid ranks {0} and {1} in product.".format(r1, r2))
# TODO: I think applying as_tensor after index sums results in
# cleaner expression graphs.
# Wrap as tensor again
if ti:
p = as_tensor(p, ti)
# If any repeated indices were found, apply implicit summation
# over those
for i in ri:
mi = MultiIndex((Index(count=i), ))
p = IndexSum(p, mi)
return p
def sub_forms_by_domain(form):
"Return a list of forms each with an integration domain"
if not isinstance(form, Form):
error("Unable to convert object to a UFL form: %s" % ufl_err_str(form))
return [Form(form.integrals_by_domain(domain)) for domain in form.ufl_domains()]
def __init__(self, A):
CompoundTensorOperator.__init__(self, (A,))
if len(A.ufl_shape) != 2:
error("Transposed is only defined for rank 2 tensors.")
def _restrict(self, side):
if side == "+":
return PositiveRestricted(self)
if side == "-":
return NegativeRestricted(self)
error("Invalid side '%s' in restriction operator." % (side, ))
def __rmul__(self, scalar):
if not is_scalar_constant_expression(scalar):
error("An integral can only be multiplied by a "
"globally constant scalar expression.")
return self.reconstruct(scalar * self._integrand)
def canonical_element_description(family, cell, order, form_degree):
"""Given basic element information, return corresponding element information on canonical form.
Input: family, cell, (polynomial) order, form_degree
Output: family (canonical), short_name (for printing), order, value shape,
reference value shape, sobolev_space.
This is used by the FiniteElement constructor to ved input
data against the element list and aliases defined in ufl.
"""
# Get domain dimensions
if cell is not None:
tdim = cell.topological_dimension()
gdim = cell.geometric_dimension()
if isinstance(cell, Cell):
cellname = cell.cellname()
else:
cellname = None
else:
tdim = None
gdim = None
cellname = None
# Catch general FEEC notation "P" and "S"
if form_degree is not None and family in ("P", "S"):
family, order = feec_element(family, tdim, order, form_degree)
# Check whether this family is an alias for something else
while family in aliases:
if tdim is None:
error("Need dimension to handle element aliases.")
(family, order) = aliases[family](family, tdim, order, form_degree)
# Check that the element family exists
if family not in ufl_elements:
error('Unknown finite element "%s".' % family)
# Check that element data is valid (and also get common family
# name)
(family, short_name, value_rank, sobolev_space, mapping, krange,
cellnames) = ufl_elements[family]
# Accept CG/DG on all kind of cells, but use Q/DQ on "product" cells
if cellname in set(cubes) - set(simplices) or isinstance(
cell, TensorProductCell):
if family == "Lagrange":
family = "Q"
elif family == "Discontinuous Lagrange":
if order >= 1:
warning(
"Discontinuous Lagrange element requested on %s, creating DQ element."
% cell.cellname())
family = "DQ"
# Validate cellname if a valid cell is specified
if not (cellname is None or cellname in cellnames):
error('Cellname "%s" invalid for "%s" finite element.' %
(cellname, family))
# Validate order if specified
if order is not None:
if krange is None:
error('Order "%s" invalid for "%s" finite element, '
'should be None.' % (order, family))
kmin, kmax = krange
if not (kmin is None or (asarray(order) >= kmin).all()):
error('Order "%s" invalid for "%s" finite element.' %
(order, family))
if not (kmax is None or (asarray(order) <= kmax).all()):
error('Order "%s" invalid for "%s" finite element.' %
(istr(order), family))
# Override sobolev_space for piecewise constants (TODO: necessary?)
if order == 0:
sobolev_space = L2
if value_rank == 2:
# Tensor valued fundamental elements in HEin have this shape
if gdim is None or tdim is None:
error(
"Cannot infer shape of element without topological and geometric dimensions."
)
reference_value_shape = (tdim, tdim)
value_shape = (gdim, gdim)
elif value_rank == 1:
# Vector valued fundamental elements in HDiv and HCurl have a shape
if gdim is None or tdim is None:
error(
"Cannot infer shape of element without topological and geometric dimensions."
)
reference_value_shape = (tdim, )
value_shape = (gdim, )
elif value_rank == 0:
# All other elements are scalar values
reference_value_shape = ()
value_shape = ()
else:
error("Invalid value rank %d." % value_rank)
return family, short_name, order, value_shape, reference_value_shape, sobolev_space, mapping
def compute_form_adjoint(form, reordered_arguments=None):
"""Compute the adjoint of a bilinear form.
This works simply by swapping the number and part of the two arguments,
but keeping their elements and places in the integrand expressions.
"""
arguments = form.arguments()
parts = [arg.part() for arg in arguments]
if set(parts) - {None}:
error("compute_form_adjoint cannot handle parts.")
if len(arguments) != 2:
error("Expecting bilinear form.")
v, u = arguments
if v.number() >= u.number():
error("Mistaken assumption in code!")
if reordered_arguments is None:
reordered_u = Argument(u.ufl_function_space(),
number=v.number(),
part=v.part())
reordered_v = Argument(v.ufl_function_space(),
number=u.number(),
part=u.part())
else:
reordered_u, reordered_v = reordered_arguments
if reordered_u.number() >= reordered_v.number():
error("Ordering of new arguments is the same as the old arguments!")
if reordered_u.part() != v.part():
error("Ordering of new arguments is the same as the old arguments!")
if reordered_v.part() != u.part():
error("Ordering of new arguments is the same as the old arguments!")
if reordered_u.ufl_function_space() != u.ufl_function_space():
error(
"Element mismatch between new and old arguments (trial functions)."
)
if reordered_v.ufl_function_space() != v.ufl_function_space():
error(
"Element mismatch between new and old arguments (test functions).")
return map_integrands(Conj, replace(form, {
v: reordered_v,
u: reordered_u
}))
def num_edges(self):
"The number of cell edges."
error("Not defined for TensorProductCell.")
def grad(self, g):
# If we hit this type, it has already been propagated to a
# coefficient (or grad of a coefficient), # FIXME: Assert
# this! so we need to take the gradient of the variation or
# return zero. Complications occur when dealing with
# derivatives w.r.t. single components...
# Figure out how many gradients are around the inner terminal
ngrads = 0
o = g
while isinstance(o, Grad):
o, = o.ufl_operands
ngrads += 1
if not isinstance(o, FormArgument):
error("Expecting gradient of a FormArgument, not %s" % ufl_err_str(o))
def apply_grads(f):
for i in range(ngrads):
f = Grad(f)
return f
# Find o among all w without any indexing, which makes this
# easy
for (w, v) in zip(self._w, self._v):
if o == w and isinstance(v, FormArgument):
# Case: d/dt [w + t v]
return apply_grads(v)
# If o is not among coefficient derivatives, return do/dw=0
gprimesum = Zero(g.ufl_shape)
def analyse_variation_argument(v):
# Analyse variation argument
if isinstance(v, FormArgument):
# Case: d/dt [w[...] + t v]
vval, vcomp = v, ()
elif isinstance(v, Indexed):
# Case: d/dt [w + t v[...]]
# Case: d/dt [w[...] + t v[...]]
vval, vcomp = v.ufl_operands
vcomp = tuple(vcomp)
else:
error("Expecting argument or component of argument.")
if not all(isinstance(k, FixedIndex) for k in vcomp):
error("Expecting only fixed indices in variation.")
return vval, vcomp
def compute_gprimeterm(ngrads, vval, vcomp, wshape, wcomp):
# Apply gradients directly to argument vval, and get the
# right indexed scalar component(s)
kk = indices(ngrads)
Dvkk = apply_grads(vval)[vcomp+kk]
# Place scalar component(s) Dvkk into the right tensor
# positions
if wshape:
Ejj, jj = unit_indexed_tensor(wshape, wcomp)
else:
Ejj, jj = 1, ()
gprimeterm = as_tensor(Ejj*Dvkk, jj+kk)
return gprimeterm
# Accumulate contributions from variations in different
# components
for (w, v) in zip(self._w, self._v):
# Analyse differentiation variable coefficient
if isinstance(w, FormArgument):
if not w == o:
continue
wshape = w.ufl_shape
if isinstance(v, FormArgument):
# Case: d/dt [w + t v]
return apply_grads(v)
elif isinstance(v, ListTensor):
# Case: d/dt [w + t <...,v,...>]
for wcomp, vsub in unwrap_list_tensor(v):
if not isinstance(vsub, Zero):
vval, vcomp = analyse_variation_argument(vsub)
gprimesum = gprimesum + compute_gprimeterm(ngrads, vval, vcomp, wshape, wcomp)
else:
if wshape != ():
error("Expecting scalar coefficient in this branch.")
# Case: d/dt [w + t v[...]]
wval, wcomp = w, ()
vval, vcomp = analyse_variation_argument(v)
gprimesum = gprimesum + compute_gprimeterm(ngrads, vval,
vcomp, wshape,
wcomp)
elif isinstance(w, Indexed): # This path is tested in unit tests, but not actually used?
# Case: d/dt [w[...] + t v[...]]
# Case: d/dt [w[...] + t v]
wval, wcomp = w.ufl_operands
if not wval == o:
continue
assert isinstance(wval, FormArgument)
if not all(isinstance(k, FixedIndex) for k in wcomp):
error("Expecting only fixed indices in differentiation variable.")
wshape = wval.ufl_shape
vval, vcomp = analyse_variation_argument(v)
gprimesum = gprimesum + compute_gprimeterm(ngrads, vval, vcomp, wshape, wcomp)
else:
error("Expecting coefficient or component of coefficient.")
# FIXME: Handle other coefficient derivatives: oprimes =
# self._cd.get(o)
if 0:
oprimes = self._cd.get(o)
if oprimes is None:
if self._cd:
# TODO: Make it possible to silence this message
# in particular? It may be good to have for
# debugging...
warning("Assuming d{%s}/d{%s} = 0." % (o, self._w))
else:
# Make sure we have a tuple to match the self._v tuple
if not isinstance(oprimes, tuple):
oprimes = (oprimes,)
if len(oprimes) != len(self._v):
error("Got a tuple of arguments, expecting a"
" matching tuple of coefficient derivatives.")
# Compute dg/dw_j = dg/dw_h : v.
# Since we may actually have a tuple of oprimes and vs
# in a 'mixed' space, sum over them all to get the
# complete inner product. Using indices to define a
# non-compound inner product.
for (oprime, v) in zip(oprimes, self._v):
error("FIXME: Figure out how to do this with ngrads")
so, oi = as_scalar(oprime)
rv = len(v.ufl_shape)
oi1 = oi[:-rv]
oi2 = oi[-rv:]
prod = so*v[oi2]
if oi1:
gprimesum += as_tensor(prod, oi1)
else:
gprimesum += prod
return gprimesum
def __mul__(self, scalar):
if not is_python_scalar(scalar):
error("Cannot multiply an integral with non-constant values.")
return self.reconstruct(scalar * self._integrand)
def fixme(self, o):
error("FIXME: Unimplemented differentiation handler for type {0}.".format(o._ufl_class_.__name__))
def sum(self, x):
"""
Return the terms that might eventually yield the correct
parts(!)
The logic required for sums is a bit elaborate:
A sum may contain terms providing different arguments. We
should return (a sum of) a suitable subset of these
terms. Those should all provide the same arguments.
For each term in a sum, there are 2 simple possibilities:
1a) The relevant part of the term is zero -> skip.
1b) The term provides more arguments than we want -> skip
2) If all terms fall into the above category, we can just
return zero.
Any remaining terms may provide exactly the arguments we want,
or fewer. This is where things start getting interesting.
3) Bottom-line: if there are terms with providing different
arguments -- provide terms that contain the most arguments. If
there are terms providing different sets of same size -> throw
error (e.g. Argument(-1) + Argument(-2))
"""
parts_that_provide = {}
# 1. Skip terms that provide too much
original_terms = x.ufl_operands
assert len(original_terms) == 2
for term in original_terms:
# Visit this term in the sum
part, term_provides = self.visit(term)
# If this part is zero or it provides more than we want,
# skip it
if isinstance(part, Zero) or (term_provides - self._want):
continue
# Add the contributions from this part to temporary list
term_provides = frozenset(term_provides)
if term_provides in parts_that_provide:
parts_that_provide[term_provides] += [part]
else:
parts_that_provide[term_provides] = [part]
# 2. If there are no remaining terms, return zero
if not parts_that_provide:
return (zero_expr(x), set())
# 3. Return the terms that provide the biggest set
most_provided = frozenset()
for (provideds,
parts) in parts_that_provide.items(): # TODO: Just sort instead?
# Throw error if size of sets are equal (and not zero)
if len(provideds) == len(most_provided) and len(most_provided):
error(
"Don't know what to do with sums with different Arguments."
)
if provideds > most_provided:
most_provided = provideds
terms = parts_that_provide[most_provided]
if len(terms) == 2:
x = self.reuse_if_possible(x, *terms)
else:
x, = terms
return (x, most_provided)
def derivative(self, o):
error("Unhandled derivative type {0}, nested differentiation has failed.".format(o._ufl_class_.__name__))
def reference_grad(self, o):
error("Currently no support for ReferenceGrad in CoefficientDerivative.")
def unexpected(self, o):
error("Unexpected type {0} in AD rules.".format(o._ufl_class_.__name__))
def reference_value(self, o):
error("Currently no support for ReferenceValue in CoefficientDerivative.")
def expr(self, o):
error("Missing differentiation handler for type {0}. Have you added a new type?".format(o._ufl_class_.__name__))
def override(self, o):
error("Type {0} must be overridden in specialized AD rule set.".format(o._ufl_class_.__name__))
def grad(self, o):
"Variable derivative of a gradient of a terminal must be 0."
# Check that o is a "differential terminal"
if not isinstance(o.ufl_operands[0], (Grad, Terminal)):
error("Expecting only grads applied to a terminal.")
return self.independent_terminal(o)
def reference_grad(self, o):
"Variable derivative of a gradient of a terminal must be 0."
if not isinstance(o.ufl_operands[0],
(ReferenceGrad, ReferenceValue)):
error("Unexpected argument to reference_grad.")
return self.independent_terminal(o)
