def __repr__(self):
r = "Zero(%s, %s, %s)" % (
repr(self.ufl_shape),
repr(self.ufl_free_indices),
repr(self.ufl_index_dimensions),
)
return as_native_str(r)
def __repr__(self):
"Compute repr string of form. This can be huge for complicated forms."
# Warning used for making sure we don't use this in the general pipeline:
#warning("Calling repr on form is potentially expensive and should be avoided except during debugging.")
# Not caching this because it can be huge
itgs = ", ".join(repr(itg) for itg in self.integrals())
r = "Form([" + itgs + "])"
return as_native_str(r)
def __init__(self, *elements):
self._elements = elements
cell = elements[0].cell()
if not all(e.cell() == cell for e in elements[1:]):
error("Cell mismatch for sub elements of enriched element.")
if isinstance(elements[0].degree(), int):
degrees = {e.degree() for e in elements} - {None}
degree = max(degrees) if degrees else None
else:
degree = tuple(map(max, zip(*[e.degree() for e in elements])))
# We can allow the scheme not to be defined, but all defined
# should be equal
quad_schemes = [e.quadrature_scheme() for e in elements]
quad_schemes = [qs for qs in quad_schemes if qs is not None]
quad_scheme = quad_schemes[0] if quad_schemes else None
if not all(qs == quad_scheme for qs in quad_schemes):
error("Quadrature scheme mismatch.")
value_shape = elements[0].value_shape()
if not all(e.value_shape() == value_shape for e in elements[1:]):
error("Element value shape mismatch.")
reference_value_shape = elements[0].reference_value_shape()
if not all(e.reference_value_shape() == reference_value_shape
for e in elements[1:]):
error("Element reference value shape mismatch.")
# mapping = elements[0].mapping() # FIXME: This fails for a mixed subelement here.
# if not all(e.mapping() == mapping for e in elements[1:]):
# error("Element mapping mismatch.")
# Get name of subclass: EnrichedElement or NodalEnrichedElement
class_name = as_native_str(self.__class__.__name__)
# Initialize element data
FiniteElementBase.__init__(self, class_name, cell, degree, quad_scheme,
value_shape, reference_value_shape)
# Cache repr string
self._repr = as_native_str(
"%s(%s)" % (class_name, ", ".join(repr(e)
for e in self._elements)))
def __repr__(self):
r = "Integral(%s, %s, %s, %s, %s, %s)" % (
repr(self._integrand),
repr(self._integral_type),
repr(self._ufl_domain),
repr(self._subdomain_id),
repr(self._metadata),
repr(self._subdomain_data),
)
return as_native_str(r)
def __repr__(self):
# For standard cells, return name of builtin cell object if
# possible. This reduces the size of the repr strings for
# domains, elements, etc. as well
gdim = self.geometric_dimension()
tdim = self.topological_dimension()
name = self.cellname()
if gdim == tdim and name in cellname2dim:
r = name
else:
r = "Cell(%s, %s)" % (repr(name), repr(gdim))
return as_native_str(r)
def __init__(self, element):
self._element = element
self._repr = as_native_str("BrokenElement(%s)" % repr(element))
family = "BrokenElement"
cell = element.cell()
degree = element.degree()
quad_scheme = element.quadrature_scheme()
value_shape = element.value_shape()
reference_value_shape = element.reference_value_shape()
FiniteElementBase.__init__(self, family, cell, degree, quad_scheme,
value_shape, reference_value_shape)
def __init__(self, element):
self._element = element
self._repr = as_native_str("HDivElement(%s)" % repr(element))
family = "TensorProductElement"
cell = element.cell()
degree = element.degree()
quad_scheme = element.quadrature_scheme()
value_shape = (element.cell().geometric_dimension(), )
reference_value_shape = (element.cell().topological_dimension(), )
# Skipping TensorProductElement constructor! Bad code smell, refactor to avoid this non-inheritance somehow.
FiniteElementBase.__init__(self, family, cell, degree, quad_scheme,
value_shape, reference_value_shape)
def attach_ufl_id(cls):
"""Equip class with ``.ufl_id()`` and handle bookkeeping.
Usage:
1. Apply to class::
@attach_ufl_id
class MyClass(object):
2. If ``__slots__`` is defined, include ``_ufl_id`` attribute::
__slots__ = ("_ufl_id",)
3. Add keyword argument to constructor::
def __init__(self, *args, ufl_id=None):
4. Call ``self._init_ufl_id`` with ``ufl_id`` and assign to ``._ufl_id``
attribute::
self._ufl_id = self._init_ufl_id(ufl_id)
Result:
``MyClass().ufl_id()`` returns unique value for each constructed object.
"""
def _get_ufl_id(self):
"Return the ufl_id of this object."
return self._ufl_id
def _init_ufl_id(cls):
"Initialize new ufl_id for the object under construction."
# Bind cls with closure here
def init_ufl_id(self, ufl_id):
if ufl_id is None:
ufl_id = cls._ufl_global_id
cls._ufl_global_id = max(ufl_id, cls._ufl_global_id) + 1
return ufl_id
return init_ufl_id
# Modify class:
if hasattr(cls, "__slots__"):
assert as_native_str("_ufl_id") in cls.__slots__
cls._ufl_global_id = 0
cls.ufl_id = _get_ufl_id
cls._init_ufl_id = _init_ufl_id(cls)
return cls
def __repr__(self):
"Return a repr string for this Measure."
global integral_type_to_measure_name
args = []
args.append(repr(self._integral_type))
if self._subdomain_id is not None:
args.append("subdomain_id=%s" % repr(self._subdomain_id))
if self._domain is not None:
args.append("domain=%s" % repr(self._domain))
if self._metadata: # Stored as EmptyDict if None
args.append("metadata=%s" % repr(self._metadata))
if self._subdomain_data is not None:
args.append("subdomain_data=%s" % repr(self._subdomain_data))
r = "%s(%s)" % (type(self).__name__, ', '.join(args))
return as_native_str(r)
def __init__(self, function_space, count=None):
FormArgument.__init__(self)
counted_init(self, count, Coefficient)
if isinstance(function_space, FiniteElementBase):
# For legacy support for .ufl files using cells, we map
# the cell to The Default Mesh
element = function_space
domain = default_domain(element.cell())
function_space = FunctionSpace(domain, element)
elif not isinstance(function_space, AbstractFunctionSpace):
error("Expecting a FunctionSpace or FiniteElement.")
self._ufl_function_space = function_space
self._ufl_shape = function_space.ufl_element().value_shape()
self._repr = as_native_str(
"Coefficient(%s, %s)" %
(repr(self._ufl_function_space), repr(self._count)))
def __init__(self, element, restriction_domain):
if not isinstance(element, FiniteElementBase):
error("Expecting a finite element instance.")
if restriction_domain not in valid_restriction_domains:
error("Expecting one of the strings %s." %
(valid_restriction_domains, ))
FiniteElementBase.__init__(self, "RestrictedElement", element.cell(),
element.degree(),
element.quadrature_scheme(),
element.value_shape(),
element.reference_value_shape())
self._element = element
self._restriction_domain = restriction_domain
self._repr = as_native_str(
"RestrictedElement(%s, %s)" %
(repr(self._element), repr(self._restriction_domain)))
def __init__(self, function_space, number, part=None):
FormArgument.__init__(self)
if isinstance(function_space, FiniteElementBase):
# For legacy support for .ufl files using cells, we map the cell to
# the default Mesh
element = function_space
domain = default_domain(element.cell())
function_space = FunctionSpace(domain, element)
elif not isinstance(function_space, AbstractFunctionSpace):
error("Expecting a FunctionSpace or FiniteElement.")
self._ufl_function_space = function_space
self._ufl_shape = function_space.ufl_element().value_shape()
if not isinstance(number, numbers.Integral):
error("Expecting an int for number, not %s" % (number, ))
if part is not None and not isinstance(part, numbers.Integral):
error("Expecting None or an int for part, not %s" % (part, ))
self._number = number
self._part = part
self._repr = as_native_str("Argument(%s, %s, %s)" % (repr(
self._ufl_function_space), repr(self._number), repr(self._part)))
def __repr__(self):
"Default repr string construction for operators."
# This should work for most cases
r = "%s(%s)" % (self._ufl_class_.__name__, ", ".join(
repr(op) for op in self.ufl_operands))
return as_native_str(r)
def __repr__(self):
r = "%s(%s)" % (type(self).__name__, repr(self._value))
return as_native_str(r)
def __repr__(self):
r = "Label(%d)" % self._count
return as_native_str(r)
def __init__(self,
family,
cell=None,
degree=None,
form_degree=None,
quad_scheme=None,
variant=None):
"""Create finite element.
*Arguments*
family (string)
The finite element family
cell
The geometric cell
degree (int)
The polynomial degree (optional)
form_degree (int)
The form degree (FEEC notation, used when field is
viewed as k-form)
quad_scheme
The quadrature scheme (optional)
variant
Hint for the local basis function variant (optional)
"""
# Note: Unfortunately, dolfin sometimes passes None for
# cell. Until this is fixed, allow it:
if cell is not None:
cell = as_cell(cell)
family, short_name, degree, value_shape, reference_value_shape, sobolev_space, mapping = canonical_element_description(
family, cell, degree, form_degree)
# TODO: Move these to base? Might be better to instead
# simplify base though.
self._sobolev_space = sobolev_space
self._mapping = mapping
self._short_name = short_name
self._variant = variant
# Finite elements on quadrilaterals have an IrreducibleInt as degree
if cell is not None:
if cell.cellname() == "quadrilateral":
from ufl.algorithms.estimate_degrees import IrreducibleInt
degree = IrreducibleInt(degree)
# Type check variant
if variant is not None and not isinstance(variant, str):
raise ValueError("Illegal variant: must be string or None")
# Initialize element data
FiniteElementBase.__init__(self, family, cell, degree, quad_scheme,
value_shape, reference_value_shape)
# Cache repr string
qs = self.quadrature_scheme()
if qs is None:
quad_str = ""
else:
quad_str = ", quad_scheme=%s" % repr(qs)
v = self.variant()
if v is None:
var_str = ""
else:
var_str = ", variant=%s" % repr(qs)
self._repr = as_native_str("FiniteElement(%s, %s, %s%s%s)" %
(repr(self.family()), repr(self.cell()),
repr(self.degree()), quad_str, var_str))
assert '"' not in self._repr
def __repr__(self):
r = "ExprList(*%s)" % repr(self.ufl_operands)
return as_native_str(r)
def __repr__(self):
r = "TensorProductMesh(%s, %s)" % (repr(
self._ufl_meshes), repr(self._ufl_id))
return as_native_str(r)
def __repr__(self):
r = "SobolevSpace(%s, %s)" % (repr(self.name), repr(list(
self.parents)))
return as_native_str(r)
def __repr__(self):
r = "Identity(%d)" % self._dim
return as_native_str(r)
def __repr__(self):
r = "FunctionSpace(%s, %s)" % (repr(
self._ufl_domain), repr(self._ufl_element))
return as_native_str(r)
def __repr__(self):
r = "TensorProductFunctionSpace(*%s)" % repr(self._ufl_function_spaces)
return as_native_str(r)
def __repr__(self):
r = "MixedFunctionSpace(*%s)" % repr(self._ufl_function_spaces)
return as_native_str(r)
def __repr__(self):
r = "%s(%s)" % (self._ufl_class_.__name__, repr(self._domain))
return as_native_str(r)
def __repr__(self):
tdim = self.topological_dimension()
r = "MeshView(%s, %s, %s)" % (repr(
self._ufl_mesh), repr(tdim), repr(self._ufl_id))
return as_native_str(r)
def __repr__(self):
r = "PermutationSymbol(%d)" % self._dim
return as_native_str(r)
def __repr__(self):
r = "Equation(%s, %s)" % (repr(self.lhs), repr(self.rhs))
return as_native_str(r)
def __repr__(self):
r = "Mesh(%s, %s)" % (repr(
self._ufl_coordinate_element), repr(self._ufl_id))
return as_native_str(r)
