Update adapter and partitioned-heat-conduction

fenicsxprecice/expression_core.py

@@ -2,7 +2,6 @@
 This module provides a mechanism to imterpolate point data acquired from preCICE into FEniCSx Expressions.
 """
 
-from dolfinx import UserExpression
 from .adapter_core import FunctionType
 from scipy.interpolate import Rbf
 from scipy.linalg import lstsq
@@ -15,10 +14,12 @@
 logger.setLevel(level=logging.INFO)
 
 
-class CouplingExpression(UserExpression):
+class CouplingExpression():
     """
     Creates functional representation (for FEniCSx) of nodal data provided by preCICE.
     """
+    def __init__(self, dims):
+        self._dimension = dims
 
     def set_function_type(self, function_type):
         self._function_type = function_type
@@ -39,13 +40,10 @@ def update_boundary_data(self, vals, coords_x, coords_y=None, coords_z=None):
             Z coordinate of points of which point data is provided.
         """
         self._coords_x = coords_x
-        self._dimension = 3
         if coords_y is None:
-            self._dimension -= 1
             coords_y = np.zeros(self._coords_x.shape)
         self._coords_y = coords_y
         if coords_z is None:
-            self._dimension -= 1
             coords_z = np.zeros(self._coords_x.shape)
 
         self._coords_y = coords_y
@@ -55,7 +53,7 @@ def update_boundary_data(self, vals, coords_x, coords_y=None, coords_z=None):
         self._f = self.create_interpolant()
 
         if self.is_scalar_valued():
-            assert (self._vals.shape == self._coords_x.shape)
+            assert (self._vals.shape[0] == self._coords_x.shape[0])
         elif self.is_vector_valued():
             assert (self._vals.shape[0] == self._coords_x.shape[0])
 
@@ -100,20 +98,16 @@ def create_interpolant(self, x):
         raise Exception("Please use one of the classes derived from this class, that implements an actual strategy for"
                         "interpolation.")
 
-    def eval(self, value, x):
+    def __call__(self, x):
         """
         Evaluates expression at x using self.interpolate(x) and stores result to value.
 
         Parameters
         ----------
-        value : double
-            Buffer where result has to be returned to.
         x : double
             Coordinate where expression has to be evaluated.
         """
-        return_value = self.interpolate(x)
-        for i in range(self._vals.ndim):
-            value[i] = return_value[i]
+        return self.interpolate(x)
 
     def is_scalar_valued(self):
         """
@@ -124,17 +118,7 @@ def is_scalar_valued(self):
         tag : bool
             True if function being interpolated is scalar-valued, False otherwise.
         """
-        try:
-            if self._vals.ndim == 1:
-                assert(self._function_type is FunctionType.SCALAR)
-                return True
-            elif self._vals.ndim > 1:
-                assert(self._function_type is FunctionType.VECTOR)
-                return False
-            else:
-                raise Exception("Dimension of the function is 0 or negative!")
-        except AttributeError:
-            return self._function_type is FunctionType.SCALAR
+        return self._function_type is FunctionType.SCALAR
 
     def is_vector_valued(self):
         """
@@ -145,17 +129,7 @@ def is_vector_valued(self):
         tag : bool
             True if function being interpolated is vector-valued, False otherwise.
         """
-        try:
-            if self._vals.ndim > 1:
-                assert(self._function_type is FunctionType.VECTOR)
-                return True
-            elif self._vals.ndim == 1:
-                assert(self._function_type is FunctionType.SCALAR)
-                return False
-            else:
-                raise Exception("Dimension of the function is 0 or negative!")
-        except AttributeError:
-            return self._function_type is FunctionType.VECTOR
+        return self._function_type is FunctionType.VECTOR
 
 
 class SegregatedRBFInterpolationExpression(CouplingExpression):
@@ -200,7 +174,8 @@ def create_interpolant(self):
         interpolant = []
 
         if self.is_scalar_valued():  # check if scalar or vector-valued
-            interpolant.append(self.segregated_interpolant_2d(self._coords_x, self._coords_y, self._vals))
+            for d in range(1):
+                interpolant.append(self.segregated_interpolant_2d(self._coords_x, self._coords_y, self._vals[:, d]))
         elif self.is_vector_valued():
             for d in range(2):
                 interpolant.append(self.segregated_interpolant_2d(self._coords_x, self._coords_y, self._vals[:, d]))
@@ -215,34 +190,12 @@ def interpolate(self, x):
         """
         assert (self._dimension == 2)  # current implementation only supports two dimensions
 
-        return_value = self._vals.ndim * [None]
-
-        for i in range(self._vals.ndim):
-            return_value[i] = self._f[i](x[0], x[1])
+
+
+        if self.is_scalar_valued():
+            return_value = [self._f[0](x[0], x[1])]
+        if self.is_vector_valued():
+            return_value = self._vals.ndim * [None]
+            for i in range(self._vals.ndim):
+                return_value[i] = self._f[i](x[0], x[1])
         return return_value
-
-
-class EmptyExpression(CouplingExpression):
-    """A dummy expression that can be used for implementing a coupling boundary condition, if the participant's mesh has
-    no vertices on the coupling domain. Only used for parallel runs.
-
-    Example:
-    We want solve
-    F = u * v / dt * dx + dot(grad(u), grad(v)) * dx - (u_n / dt + f) * v * dx + v * coupling_expression * ds
-    The user defines F, but does not know whether the rank even has vertices on the Neumann coupling boundary.
-    If the rank does not have any vertices on the Neumann coupling boundary the coupling_expression is an
-    EmptyExpression. This "deactivates" the Neumann BC for that specific rank.
-    """
-
-    def eval(self, value, x):
-        """ Evaluates expression at x. For EmptyExpression always returns zero.
-
-        :param x: coordinate where expression has to be evaluated
-        :param value: buffer where result has to be returned to
-        """
-        assert(MPI.COMM_WORLD.Get_size() > 1)
-        for i in range(self._vals.ndim):
-            value[i] = 0
-
-    def update_boundary_data(self, vals, coords_x, coords_y=None, coords_z=None):
-        pass  # an EmptyExpression is never updated