def _compute_expression_ir(expression, index, prefix, analysis, parameters,
visualise):
logger.info("Computing IR for expression {}".format(index))
# Compute representation
ir = {}
original_expression = (expression[2], expression[1])
sig = naming.compute_signature([original_expression], "", parameters)
ir["name"] = "expression_{!s}".format(sig)
original_expression = expression[2]
points = expression[1]
expression = expression[0]
try:
cell = expression.ufl_domain().ufl_cell()
except AttributeError:
# This case corresponds to a spatially constant expression without any dependencies
cell = None
# Prepare dimensions of all unique element in expression, including
# elements for arguments, coefficients and coordinate mappings
ir["element_dimensions"] = {
ufl_element: create_element(ufl_element).space_dimension()
for ufl_element in analysis.unique_elements
}
# Extract dimensions for elements of arguments only
arguments = ufl.algorithms.extract_arguments(expression)
argument_elements = tuple(f.ufl_element() for f in arguments)
argument_dimensions = [
ir["element_dimensions"][ufl_element]
for ufl_element in argument_elements
]
tensor_shape = argument_dimensions
ir["tensor_shape"] = tensor_shape
ir["expression_shape"] = list(expression.ufl_shape)
coefficients = ufl.algorithms.extract_coefficients(expression)
coefficient_numbering = {}
for i, coeff in enumerate(coefficients):
coefficient_numbering[coeff] = i
# Add coefficient numbering to IR
ir["coefficient_numbering"] = coefficient_numbering
original_coefficient_positions = []
original_coefficients = ufl.algorithms.extract_coefficients(
original_expression)
for coeff in coefficients:
original_coefficient_positions.append(
original_coefficients.index(coeff))
ir["original_coefficient_positions"] = original_coefficient_positions
coefficient_elements = tuple(f.ufl_element() for f in coefficients)
offsets = {}
_offset = 0
for i, el in enumerate(coefficient_elements):
offsets[coefficients[i]] = _offset
_offset += ir["element_dimensions"][el]
# Copy offsets also into IR
ir["coefficient_offsets"] = offsets
ir["integral_type"] = "expression"
ir["entitytype"] = "cell"
# Build offsets for Constants
original_constant_offsets = {}
_offset = 0
for constant in ufl.algorithms.analysis.extract_constants(expression):
original_constant_offsets[constant] = _offset
_offset += numpy.product(constant.ufl_shape, dtype=numpy.int)
ir["original_constant_offsets"] = original_constant_offsets
ir["points"] = points
weights = numpy.array([1.0] * points.shape[0])
rule = QuadratureRule(points, weights)
integrands = {rule: expression}
if cell is None:
assert len(ir["original_coefficient_positions"]) == 0 and len(
ir["original_constant_offsets"]) == 0
expression_ir = compute_integral_ir(cell, ir["integral_type"],
ir["entitytype"], integrands,
tensor_shape, parameters, visualise)
ir.update(expression_ir)
return ir_expression(**ir)
def _compute_integral_ir(form_data, form_index, prefix, element_numbers,
integral_names, parameters, visualise):
"""Compute intermediate represention for form integrals."""
_entity_types = {
"cell": "cell",
"exterior_facet": "facet",
"interior_facet": "facet",
"vertex": "vertex",
"custom": "cell"
}
# Iterate over groups of integrals
irs = []
for itg_data_index, itg_data in enumerate(form_data.integral_data):
logger.info("Computing IR for integral in integral group {}".format(
itg_data_index))
# Compute representation
entitytype = _entity_types[itg_data.integral_type]
cell = itg_data.domain.ufl_cell()
cellname = cell.cellname()
tdim = cell.topological_dimension()
assert all(tdim == itg.ufl_domain().topological_dimension()
for itg in itg_data.integrals)
ir = {
"integral_type": itg_data.integral_type,
"subdomain_id": itg_data.subdomain_id,
"rank": form_data.rank,
"geometric_dimension": form_data.geometric_dimension,
"topological_dimension": tdim,
"entitytype": entitytype,
"num_facets": cell.num_facets(),
"num_vertices": cell.num_vertices(),
"needs_oriented": form_needs_oriented_jacobian(form_data),
"enabled_coefficients": itg_data.enabled_coefficients,
"cell_shape": cellname
}
# Get element space dimensions
unique_elements = element_numbers.keys()
ir["element_dimensions"] = {
ufl_element: create_element(ufl_element).space_dimension()
for ufl_element in unique_elements
}
ir["element_ids"] = {
ufl_element: i
for i, ufl_element in enumerate(unique_elements)
}
# Create dimensions of primary indices, needed to reset the argument
# 'A' given to tabulate_tensor() by the assembler.
argument_dimensions = [
ir["element_dimensions"][ufl_element]
for ufl_element in form_data.argument_elements
]
# Compute shape of element tensor
if ir["integral_type"] == "interior_facet":
ir["tensor_shape"] = [2 * dim for dim in argument_dimensions]
else:
ir["tensor_shape"] = argument_dimensions
integral_type = itg_data.integral_type
cell = itg_data.domain.ufl_cell()
# Group integrands with the same quadrature rule
grouped_integrands = {}
for integral in itg_data.integrals:
md = integral.metadata() or {}
scheme = md["quadrature_rule"]
degree = md["quadrature_degree"]
if scheme == "custom":
points = md["quadrature_points"]
weights = md["quadrature_weights"]
elif scheme == "vertex":
# FIXME: Could this come from FIAT?
#
# The vertex scheme, i.e., averaging the function value in the
# vertices and multiplying with the simplex volume, is only of
# order 1 and inferior to other generic schemes in terms of
# error reduction. Equation systems generated with the vertex
# scheme have some properties that other schemes lack, e.g., the
# mass matrix is a simple diagonal matrix. This may be
# prescribed in certain cases.
if degree > 1:
warnings.warn(
"Explicitly selected vertex quadrature (degree 1), but requested degree is {}."
.format(degree))
if cellname == "tetrahedron":
points, weights = (numpy.array([[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]]),
numpy.array([
1.0 / 24.0, 1.0 / 24.0, 1.0 / 24.0,
1.0 / 24.0
]))
elif cellname == "triangle":
points, weights = (numpy.array([[0.0, 0.0], [1.0, 0.0],
[0.0, 1.0]]),
numpy.array(
[1.0 / 6.0, 1.0 / 6.0, 1.0 / 6.0]))
elif cellname == "interval":
# Trapezoidal rule
return (numpy.array([[0.0], [1.0]]),
numpy.array([1.0 / 2.0, 1.0 / 2.0]))
else:
(points, weights) = create_quadrature_points_and_weights(
integral_type, cell, degree, scheme)
points = numpy.asarray(points)
weights = numpy.asarray(weights)
rule = QuadratureRule(points, weights)
if rule not in grouped_integrands:
grouped_integrands[rule] = []
grouped_integrands[rule].append(integral.integrand())
sorted_integrals = {}
for rule, integrands in grouped_integrands.items():
integrands_summed = sorted_expr_sum(integrands)
integral_new = Integral(integrands_summed, itg_data.integral_type,
itg_data.domain, itg_data.subdomain_id, {},
None)
sorted_integrals[rule] = integral_new
# TODO: See if coefficient_numbering can be removed
# Build coefficient numbering for UFC interface here, to avoid
# renumbering in UFL and application of replace mapping
coefficient_numbering = {}
for i, f in enumerate(form_data.reduced_coefficients):
coefficient_numbering[f] = i
# Add coefficient numbering to IR
ir["coefficient_numbering"] = coefficient_numbering
index_to_coeff = sorted([(v, k)
for k, v in coefficient_numbering.items()])
offsets = {}
width = 2 if integral_type in ("interior_facet") else 1
_offset = 0
for k, el in zip(index_to_coeff, form_data.coefficient_elements):
offsets[k[1]] = _offset
_offset += width * ir["element_dimensions"][el]
# Copy offsets also into IR
ir["coefficient_offsets"] = offsets
# Build offsets for Constants
original_constant_offsets = {}
_offset = 0
for constant in form_data.original_form.constants():
original_constant_offsets[constant] = _offset
_offset += numpy.product(constant.ufl_shape, dtype=numpy.int)
ir["original_constant_offsets"] = original_constant_offsets
ir["precision"] = itg_data.metadata["precision"]
# Create map from number of quadrature points -> integrand
integrands = {
rule: integral.integrand()
for rule, integral in sorted_integrals.items()
}
# Build more specific intermediate representation
integral_ir = compute_integral_ir(itg_data.domain.ufl_cell(),
itg_data.integral_type,
ir["entitytype"], integrands,
ir["tensor_shape"], parameters,
visualise)
ir.update(integral_ir)
# Fetch name
ir["name"] = integral_names[(form_index, itg_data_index)]
irs.append(ir_integral(**ir))
return irs
