def create_element(ufl_element):
# Create element signature for caching (just use UFL element)
element_signature = ufl_element
# Check cache
if element_signature in _cache:
debug("Reusing element from cache")
return _cache[element_signature]
# Create regular FIAT finite element
if isinstance(ufl_element, ufl.FiniteElement):
element = _create_fiat_element(ufl_element)
# Create mixed element (implemented by FFC)
elif isinstance(ufl_element, ufl.MixedElement):
elements = _extract_elements(ufl_element)
element = MixedElement(elements)
# Create element union (implemented by FFC)
elif isinstance(ufl_element, ufl.EnrichedElement):
elements = [create_element(e) for e in ufl_element._elements]
element = EnrichedElement(elements)
# Create restricted element(implemented by FFC)
elif isinstance(ufl_element, ufl.RestrictedElement):
element = _create_restricted_element(ufl_element)
else:
error("Cannot handle this element type: %s" % str(ufl_element))
# Store in cache
_cache[element_signature] = element
return element
def create_element(ufl_element):
# Create element signature for caching (just use UFL element)
element_signature = ufl_element
# Check cache
element = _cache.get(element_signature, None)
if element:
debug("Reusing element from cache")
return element
if isinstance(ufl_element, ufl.MixedElement):
# Create mixed element (implemented by FFC)
elements = _extract_elements(ufl_element)
element = MixedElement(elements)
elif isinstance(ufl_element, ufl.RestrictedElement):
# Create restricted element(implemented by FFC)
element = _create_restricted_element(ufl_element)
elif isinstance(ufl_element,
(ufl.FiniteElement, ufl.OuterProductElement,
ufl.EnrichedElement, ufl.BrokenElement, ufl.TraceElement,
ufl.FacetElement, ufl.InteriorElement)):
# Create regular FIAT finite element
element = _create_fiat_element(ufl_element)
else:
error("Cannot handle this element type: %s" % str(ufl_element))
# Store in cache
_cache[element_signature] = element
return element
def _global_dimension(element):
"Compute intermediate representation for global_dimension."
if not isinstance(element, MixedElement):
if isinstance(element, SpaceOfReals):
return ([], 1)
return (_num_dofs_per_entity(element), 0)
elements = []
reals = []
num_reals = 0
for (i, e) in enumerate(element.elements()):
if not isinstance(e, SpaceOfReals):
elements += [e]
else:
num_reals += 1
element = MixedElement(elements)
return (_num_dofs_per_entity(element), num_reals)
def _create_restricted_element(ufl_element):
"Create an FFC representation for an UFL RestrictedElement."
if not isinstance(ufl_element, ufl.RestrictedElement):
error("create_restricted_element expects an ufl.RestrictedElement")
base_element = ufl_element.element()
domain = ufl_element.cell_restriction()
# If simple element -> create RestrictedElement from fiat_element
if isinstance(base_element, ufl.FiniteElement):
element = _create_fiat_element(base_element)
return RestrictedElement(element, _indices(element, domain), domain)
# If restricted mixed element -> convert to mixed restricted element
if isinstance(base_element, ufl.MixedElement):
elements = _extract_elements(base_element, domain)
return MixedElement(elements)
error("Cannot create restricted element from %s" % str(ufl_element))