def __init__(self, cellname, geometric_dimension=None):
"Initialize basic cell description."
# The cellname must be one of the predefined names
ufl_assert(cellname in cellname2dim,
"Invalid cellname %s." % (cellname, ))
self._cellname = cellname
# The topological dimension is defined by the cell type
self._topological_dimension = cellname2dim[self._cellname]
# The geometric dimension defaults to equal
# the topological dimension if undefined
ufl_assert(
geometric_dimension is None
or isinstance(geometric_dimension, int),
"Expecting an integer dimension, not '%r'" %
(geometric_dimension, ))
self._geometric_dimension = geometric_dimension or self._topological_dimension
# Check for consistency in dimensions.
# NB! Note that the distinction between topological
# and geometric dimensions has yet to be used in
# practice, so don't trust it too much :)
ufl_assert(self._topological_dimension <= self._geometric_dimension,
"Cannot embed a %sD cell in %sD" %\
(istr(self._topological_dimension), istr(self._geometric_dimension)))
# Cache repr string
self._repr = "Cell(%r, %r)" % (self._cellname,
self._geometric_dimension)
# Attach expression nodes derived from this cell TODO: Derive these from domain instead
self._n = FacetNormal(self)
self._x = SpatialCoordinate(self)
self._xi = LocalCoordinate(self)
self._J = GeometryJacobi(self)
self._Jinv = InverseGeometryJacobi(self)
self._detJ = GeometryJacobiDeterminant(self)
self._volume = CellVolume(self)
self._circumradius = Circumradius(self)
self._cellsurfacearea = CellSurfaceArea(self)
self._facetarea = FacetArea(self)
self._minfacetedgelength = MinFacetEdgeLength(self)
self._maxfacetedgelength = MaxFacetEdgeLength(self)
self._facetdiameter = FacetDiameter(self)
def __str__(self):
"Format as string for pretty printing."
sym = ""
if isinstance(self._symmetry, dict):
tmp = ", ".join("%s -> %s" % (a,b) for (a,b) in self._symmetry.iteritems())
sym = " with symmetries (%s)" % tmp
elif self._symmetry:
sym = " with symmetry"
return "<%s tensor element of degree %s and shape %s on a %s%s>" % \
(self.family(), istr(self.degree()), self.value_shape(), self.domain(), sym)
def __init__(self, cellname, geometric_dimension=None):
"Initialize basic cell description."
# The cellname must be one of the predefined names
ufl_assert(cellname in cellname2dim, "Invalid cellname %s." % (cellname,))
self._cellname = cellname
# The topological dimension is defined by the cell type
self._topological_dimension = cellname2dim[self._cellname]
# The geometric dimension defaults to equal
# the topological dimension if undefined
ufl_assert(geometric_dimension is None or isinstance(geometric_dimension, int),
"Expecting an integer dimension, not '%r'" % (geometric_dimension,))
self._geometric_dimension = geometric_dimension or self._topological_dimension
# Check for consistency in dimensions.
# NB! Note that the distinction between topological
# and geometric dimensions has yet to be used in
# practice, so don't trust it too much :)
ufl_assert(self._topological_dimension <= self._geometric_dimension,
"Cannot embed a %sD cell in %sD" %\
(istr(self._topological_dimension), istr(self._geometric_dimension)))
# Cache repr string
self._repr = "Cell(%r, %r)" % (self._cellname, self._geometric_dimension)
# Attach expression nodes derived from this cell TODO: Derive these from domain instead
self._n = FacetNormal(self)
self._x = SpatialCoordinate(self)
self._xi = LocalCoordinate(self)
self._J = GeometryJacobi(self)
self._Jinv = InverseGeometryJacobi(self)
self._detJ = GeometryJacobiDeterminant(self)
self._volume = CellVolume(self)
self._circumradius = Circumradius(self)
self._cellsurfacearea = CellSurfaceArea(self)
self._facetarea = FacetArea(self)
self._minfacetedgelength = MinFacetEdgeLength(self)
self._maxfacetedgelength = MaxFacetEdgeLength(self)
self._facetdiameter = FacetDiameter(self)
def __str__(self):
return "<%s cell in %sD>" % (istr(self._cellname),
istr(self._geometric_dimension))
def __str__(self):
return "<%s cell in %sD>" % (istr(
self._cellname), istr(self._geometric_dimension))
def __init__(self,
family,
domain=None,
degree=None,
quad_scheme=None,
form_degree=None):
"""Create finite element
*Arguments*
family (string)
The finite element family
domain
The geometric domain
degree (int)
The polynomial degree (optional)
quad_scheme
The quadrature scheme (optional)
form_degree (int)
The form degree (FEEC notation, used when field is
viewed as k-form)
"""
if domain is None:
cell = None
else:
domain = as_domain(domain)
cell = domain.cell()
ufl_assert(cell is not None, "Missing cell in given domain.")
# Check whether this family is an alias for something else
if family in aliases:
(name, cell, r) = aliases[family](family, cell, degree,
form_degree)
#info_blue("%s, is an alias for %s " % (
# (family, cell, degree, form_degree),
# (name, cell, r)))
# FIXME: Need to init here with domain instead of using cell from aliases, is that ok?
ufl_assert(cell == domain.cell(),
"Breaking assumption in element alias mapping.")
self.__init__(name, domain, r, quad_scheme)
return
# Check that the element family exists
ufl_assert(family in ufl_elements,
'Unknown finite element "%s".' % family)
# Check that element data is valid (and also get common family name)
(family, self._short_name, value_rank, krange, cellnames) =\
ufl_elements[family]
# Validate cellname if a valid cell is specified
cellname = None if cell is None else cell.cellname()
ufl_assert(
cellname in cellnames,
'Cellname "%s" invalid for "%s" finite element.' %
(cellname, family))
# Validate degree if specified
if degree is not None:
ufl_assert(krange is not None,
'Degree "%s" invalid for "%s" finite element, '\
'should be None.' % (degree, family))
kmin, kmax = krange
ufl_assert(kmin is None or degree >= kmin,
'Degree "%s" invalid for "%s" finite element.' %\
(degree, family))
ufl_assert(kmax is None or degree <= kmax,
'Degree "%s" invalid for "%s" finite element.' %\
(istr(degree), family))
# Set value dimension (default to using geometric dimension in each axis)
if value_rank == 0:
value_shape = ()
else:
ufl_assert(
domain is not None,
"Cannot infer shape of element without a domain with geometric dimension."
)
dim = domain.geometric_dimension()
value_shape = (dim, ) * value_rank
# Initialize element data
super(FiniteElement, self).__init__(family, domain, degree,
quad_scheme, value_shape)
# Cache repr string
self._repr = "FiniteElement(%r, %r, %r, %r)" % (
self.family(), self.domain(), self.degree(),
self.quadrature_scheme())
def shortstr(self):
"Format as string for pretty printing."
return "%s%s(%s)" % (self._short_name, istr(
self.degree()), istr(self.quadrature_scheme()))
def __str__(self):
"Format as string for pretty printing."
qs = self.quadrature_scheme()
qs = "" if qs is None else "(%s)" % qs
return "<%s%s%s on a %s>" % (self._short_name, istr(self.degree()),\
qs, self.domain())
def __str__(self):
"Format as string for pretty printing."
return "<%s vector element of degree %s on a %s: %d x %s>" % \
(self.family(), istr(self.degree()), self.domain(),
len(self._sub_elements), self._sub_element)
def __init__(self, family, domain=None, degree=None, quad_scheme=None,
form_degree=None):
"""Create finite element
*Arguments*
family (string)
The finite element family
domain
The geometric domain
degree (int)
The polynomial degree (optional)
quad_scheme
The quadrature scheme (optional)
form_degree (int)
The form degree (FEEC notation, used when field is
viewed as k-form)
"""
if domain is None:
cell = None
else:
domain = as_domain(domain)
cell = domain.cell()
ufl_assert(cell is not None, "Missing cell in given domain.")
# Check whether this family is an alias for something else
if family in aliases:
(name, cell, r) = aliases[family](family, cell, degree, form_degree)
#info_blue("%s, is an alias for %s " % (
# (family, cell, degree, form_degree),
# (name, cell, r)))
# FIXME: Need to init here with domain instead of using cell from aliases, is that ok?
ufl_assert(cell == domain.cell(),
"Breaking assumption in element alias mapping.")
self.__init__(name, domain, r, quad_scheme)
return
# Check that the element family exists
ufl_assert(family in ufl_elements,
'Unknown finite element "%s".' % family)
# Check that element data is valid (and also get common family name)
(family, self._short_name, value_rank, krange, cellnames) =\
ufl_elements[family]
# Validate cellname if a valid cell is specified
cellname = None if cell is None else cell.cellname()
ufl_assert(cellname in cellnames,
'Cellname "%s" invalid for "%s" finite element.' % (cellname, family))
# Validate degree if specified
if degree is not None:
ufl_assert(krange is not None,
'Degree "%s" invalid for "%s" finite element, '\
'should be None.' % (degree, family))
kmin, kmax = krange
ufl_assert(kmin is None or degree >= kmin,
'Degree "%s" invalid for "%s" finite element.' %\
(degree, family))
ufl_assert(kmax is None or degree <= kmax,
'Degree "%s" invalid for "%s" finite element.' %\
(istr(degree), family))
# Set value dimension (default to using geometric dimension in each axis)
if value_rank == 0:
value_shape = ()
else:
ufl_assert(domain is not None,
"Cannot infer shape of element without a domain with geometric dimension.")
dim = domain.geometric_dimension()
value_shape = (dim,)*value_rank
# Initialize element data
super(FiniteElement, self).__init__(family, domain, degree,
quad_scheme, value_shape)
# Cache repr string
self._repr = "FiniteElement(%r, %r, %r, %r)" % (
self.family(), self.domain(), self.degree(), self.quadrature_scheme())
def shortstr(self):
"Format as string for pretty printing."
return "%s%s(%s)" % (self._short_name, istr(self.degree()),
istr(self.quadrature_scheme()))
def __str__(self):
"Format as string for pretty printing."
qs = self.quadrature_scheme()
qs = "" if qs is None else "(%s)" % qs
return "<%s%s%s on a %s>" % (self._short_name, istr(self.degree()),\
qs, self.domain())