Merge branch 'main' into jhale/external-operator-2023

test/test_cell.py

@@ -59,3 +59,9 @@ def test_cells_2d(cell):
  assert cell.num_peaks() == cell.num_vertices()
 
 
+def test_tensorproductcell():
+ orig = ufl.TensorProductCell(ufl.interval, ufl.interval)
+ cell = orig.reconstruct()
+ assert cell.sub_cells() == orig.sub_cells()
+ assert cell.topological_dimension() == orig.topological_dimension()
+ assert cell.geometric_dimension() == orig.geometric_dimension()

test/test_complex.py

@@ -10,10 +10,10 @@
 from ufl.algorithms import estimate_total_polynomial_degree
 from ufl.algorithms.comparison_checker import do_comparison_check, ComplexComparisonError
 from ufl.algorithms.formtransformations import compute_form_adjoint
-from ufl import TestFunction, TrialFunction, triangle, FiniteElement, \
- as_ufl, inner, grad, dx, dot, outer, conj, sqrt, sin, cosh, \
- atan, ln, exp, as_tensor, real, imag, conditional, \
- min_value, max_value, gt, lt, cos, ge, le, Coefficient
+from ufl import (TestFunction, TrialFunction, triangle, FiniteElement,
+  as_ufl, inner, grad, dx, dot, outer, conj, sqrt, sin, cosh,
+  atan, ln, exp, as_tensor, real, imag, conditional,
+  min_value, max_value, gt, lt, cos, ge, le, Coefficient)
 
 
 def test_conj(self):

test/test_duals.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env py.test
 # -*- coding: utf-8 -*-
 
-from ufl import FiniteElement, FunctionSpace, MixedFunctionSpace, \
- Coefficient, Matrix, Cofunction, FormSum, Argument, Coargument,\
- TestFunction, TrialFunction, Adjoint, Action, \
- action, adjoint, derivative, tetrahedron, triangle, interval, dx
+from ufl import (FiniteElement, FunctionSpace, MixedFunctionSpace,
+  Coefficient, Matrix, Cofunction, FormSum, Argument, Coargument,
+  TestFunction, TrialFunction, Adjoint, Action,
+  action, adjoint, derivative, tetrahedron, triangle, interval, dx)
 from ufl.constantvalue import Zero
 from ufl.form import ZeroBaseForm
 

test/test_elements.py

@@ -229,3 +229,9 @@ def test_mse():
 
  element = FiniteElement('GLL-Edge L2', interval, degree - 1)
  assert element == eval(repr(element))
+
+
+def test_withmapping():
+ base = FiniteElement("CG", interval, 1)
+ element = WithMapping(base, "identity")
+ assert element == eval(repr(element))

test/test_new_ad.py

@@ -8,8 +8,9 @@
 from ufl.classes import Grad
 from ufl.algorithms import tree_format
 from ufl.algorithms.renumbering import renumber_indices
-from ufl.algorithms.apply_derivatives import apply_derivatives, GenericDerivativeRuleset, \
- GradRuleset, VariableRuleset, GateauxDerivativeRuleset
+from ufl.algorithms.apply_derivatives import (
+ apply_derivatives, GenericDerivativeRuleset,
+ GradRuleset, VariableRuleset, GateauxDerivativeRuleset)
 
 
 # Note: the old tests in test_automatic_differentiation.py are a bit messy

test/test_signature.py

@@ -9,8 +9,7 @@
 from ufl import *
 
 from ufl.classes import MultiIndex, FixedIndex
-from ufl.algorithms.signature import compute_multiindex_hashdata, \
- compute_terminal_hashdata
+from ufl.algorithms.signature import compute_multiindex_hashdata, compute_terminal_hashdata
 
 from itertools import chain
 

ufl/algorithms/signature.py

@@ -43,7 +43,6 @@ def compute_terminal_hashdata(expressions, renumbering):
  # arguments, and just take repr of the rest of the terminals while
  # we're iterating over them
  terminal_hashdata = {}
- labels = {}
  index_numbering = {}
  for expression in expressions:
  for expr in traverse_unique_terminals(expression):
@@ -69,12 +68,7 @@ def compute_terminal_hashdata(expressions, renumbering):
  data = expr._ufl_signature_data_(renumbering)
 
  elif isinstance(expr, Label):
- # Numbering labels as we visit them # TODO: Include in
- # renumbering
- data = labels.get(expr)
- if data is None:
- data = "L%d" % len(labels)
- labels[expr] = data
+ data = expr._ufl_signature_data_(renumbering)
 
  elif isinstance(expr, ExprList):
  # Not really a terminal but can have 0 operands...

ufl/argument.py

@@ -130,7 +130,7 @@ def __eq__(self, other):
  are the same ufl element but different dolfin function spaces.
  """
  return (
- type(self) == type(other) and self._number == other._number and # noqa: W504
+ type(self) is type(other) and self._number == other._number and # noqa: W504
  self._part == other._part and self._ufl_function_space == other._ufl_function_space
  )
 

ufl/cell.py

@@ -63,7 +63,7 @@ def reconstruct(self, **kwargs: typing.Any) -> Cell:
 
  def __lt__(self, other: AbstractCell) -> bool:
  """Define an arbitrarily chosen but fixed sort order for all cells."""
- if type(self) == type(other):
+ if type(self) is type(other):
  s = (self.geometric_dimension(), self.topological_dimension())
  o = (other.geometric_dimension(), other.topological_dimension())
  if s != o:
@@ -409,7 +409,7 @@ def reconstruct(self, **kwargs: typing.Any) -> Cell:
  gdim = value
  else:
  raise TypeError(f"reconstruct() got unexpected keyword argument '{key}'")
- return TensorProductCell(self._cellname, geometric_dimension=gdim)
+ return TensorProductCell(*self._cells, geometric_dimension=gdim)
 
 
 def simplex(topological_dimension: int, geometric_dimension: typing.Optional[int] = None):

ufl/coefficient.py

@@ -19,28 +19,27 @@
 from ufl.functionspace import AbstractFunctionSpace, FunctionSpace, MixedFunctionSpace
 from ufl.form import BaseForm
 from ufl.split_functions import split
-from ufl.utils.counted import counted_init
+from ufl.utils.counted import Counted
 from ufl.duals import is_primal, is_dual
 
 # --- The Coefficient class represents a coefficient in a form ---
 
 
-class BaseCoefficient(object):
+class BaseCoefficient(Counted):
  """UFL form argument type: Parent Representation of a form coefficient."""
 
  # Slots are disabled here because they cause trouble in PyDOLFIN
  # multiple inheritance pattern:
  # __slots__ = ("_count", "_ufl_function_space", "_repr", "_ufl_shape")
  _ufl_noslots_ = True
  __slots__ = ()
- _globalcount = 0
  _ufl_is_abstract_ = True
 
  def __getnewargs__(self):
  return (self._ufl_function_space, self._count)
 
  def __init__(self, function_space, count=None):
- counted_init(self, count, Coefficient)
+ Counted.__init__(self, count, Coefficient)
 
  if isinstance(function_space, FiniteElementBase):
  # For legacy support for .ufl files using cells, we map
@@ -57,9 +56,6 @@ def __init__(self, function_space, count=None):
  self._repr = "BaseCoefficient(%s, %s)" % (
  repr(self._ufl_function_space), repr(self._count))
 
- def count(self):
- return self._count
-
  @property
  def ufl_shape(self):
  "Return the associated UFL shape."
@@ -111,14 +107,14 @@ class Cofunction(BaseCoefficient, BaseForm):
 
  __slots__ = (
  "_count",
+ "_counted_class",
  "_arguments",
  "_ufl_function_space",
  "ufl_operands",
  "_repr",
  "_ufl_shape",
  "_hash"
  )
- # _globalcount = 0
  _primal = False
  _dual = True
 
@@ -161,7 +157,6 @@ class Coefficient(FormArgument, BaseCoefficient):
  """UFL form argument type: Representation of a form coefficient."""
 
  _ufl_noslots_ = True
- _globalcount = 0
  _primal = True
  _dual = False
 

ufl/constant.py

@@ -11,17 +11,16 @@
 from ufl.core.ufl_type import ufl_type
 from ufl.core.terminal import Terminal
 from ufl.domain import as_domain
-from ufl.utils.counted import counted_init
+from ufl.utils.counted import Counted
 
 
 @ufl_type()
-class Constant(Terminal):
+class Constant(Terminal, Counted):
  _ufl_noslots_ = True
- _globalcount = 0
 
  def __init__(self, domain, shape=(), count=None):
  Terminal.__init__(self)
- counted_init(self, count=count, countedclass=Constant)
+ Counted.__init__(self, count, Constant)
 
  self._ufl_domain = as_domain(domain)
  self._ufl_shape = shape
@@ -31,9 +30,6 @@ def __init__(self, domain, shape=(), count=None):
  self._repr = "Constant({}, {}, {})".format(
  repr(self._ufl_domain), repr(self._ufl_shape), repr(self._count))
 
- def count(self):
- return self._count
-
  @property
  def ufl_shape(self):
  return self._ufl_shape

ufl/core/multiindex.py

@@ -10,7 +10,7 @@
 # Modified by Massimiliano Leoni, 2016.
 
 
-from ufl.utils.counted import counted_init
+from ufl.utils.counted import Counted
 from ufl.core.ufl_type import ufl_type
 from ufl.core.terminal import Terminal
 
@@ -70,20 +70,15 @@ def __repr__(self):
  return r
 
 
-class Index(IndexBase):
+class Index(IndexBase, Counted):
  """UFL value: An index with no value assigned.
 
  Used to represent free indices in Einstein indexing notation."""
- __slots__ = ("_count",)
-
- _globalcount = 0
+ __slots__ = ("_count", "_counted_class")
 
  def __init__(self, count=None):
  IndexBase.__init__(self)
- counted_init(self, count, Index)
-
- def count(self):
- return self._count
+ Counted.__init__(self, count, Index)
 
  def __hash__(self):
  return hash(("Index", self._count))

ufl/core/ufl_type.py

@@ -39,7 +39,7 @@ def __hash__(self) -> int:
  return hash(self._ufl_hash_data_())
 
  def __eq__(self, other):
- return type(self) == type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
+ return type(self) is type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
 
  def __ne__(self, other):
  return not self.__eq__(other)
@@ -61,7 +61,7 @@ def __hash__(self):
 
  def __eq__(self, other):
  "__eq__ implementation attached in attach_operators_from_hash_data"
- return type(self) == type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
+ return type(self) is type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
  cls.__eq__ = __eq__
 
  def __ne__(self, other):

ufl/exprequals.py

@@ -15,7 +15,7 @@ def expr_equals(self, other):
 
  # Fast cutoffs for common cases, type difference or hash
  # difference will cutoff more or less all nonequal types
- if type(self) != type(other) or hash(self) != hash(other):
+ if type(self) is not type(other) or hash(self) != hash(other):
  return False
 
  # Large objects are costly to compare with themselves

ufl/finiteelement/finiteelementbase.py

@@ -83,7 +83,7 @@ def __hash__(self):
 
  def __eq__(self, other):
  "Compute element equality for insertion in hashmaps."
- return type(self) == type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
+ return type(self) is type(other) and self._ufl_hash_data_() == other._ufl_hash_data_()
 
  def __ne__(self, other):
  "Compute element inequality for insertion in hashmaps."

ufl/finiteelement/hdivcurl.py

@@ -119,7 +119,7 @@ def __getattr__(self, attr):
  (type(self).__name__, attr))
 
  def __repr__(self):
- return f"WithMapping({repr(self.wrapee)}, {self._mapping})"
+ return f"WithMapping({repr(self.wrapee)}, '{self._mapping}')"
 
  def value_shape(self):
  gdim = self.cell().geometric_dimension()