Adjust positions of DOFs not on vertices (#186)

* Fix #185

* Don't adjust position of point evaluations

Author: mscroggs

symfem/finite_element.py

@@ -423,20 +423,20 @@ def plot_dof_diagram(
 
             for dim, e in entities:
                 dofs = dofs_by_subentity[dim][e]
-                dofs.sort(key=lambda d: img.z(d.dof_point()))
+                dofs.sort(key=lambda d: img.z(d.adjusted_dof_point()))
                 for d in dofs:
                     direction = d.dof_direction()
                     if direction is not None:
                         shifted = False
                         for d2 in self.dofs:
-                            if d != d2 and d.dof_point() == d2.dof_point():
+                            if d != d2 and d.adjusted_dof_point() == d2.adjusted_dof_point():
                                 shifted = True
                                 break
-                        img.add_dof_arrow(d.dof_point(), direction, self.dofs.index(d),
+                        img.add_dof_arrow(d.adjusted_dof_point(), direction, self.dofs.index(d),
                                           colors.entity(d.entity[0]), shifted)
                     else:
                         img.add_dof_marker(
-                            d.dof_point(), self.dofs.index(d), colors.entity(d.entity[0]))
+                            d.adjusted_dof_point(), self.dofs.index(d), colors.entity(d.entity[0]))
 
         img.save(filename, plot_options=plot_options)
 

symfem/functionals.py

@@ -94,6 +94,17 @@ def dof_point(self) -> PointType:
         """Get the location of the DOF in the cell."""
         pass
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        point = self.dof_point()
+        if self.entity[0] == 0:
+            return point
+
+        midpoint = self.reference.sub_entity(*self.entity).midpoint()
+        return tuple(
+            m + sympy.Rational(7, 10) * (p - m)
+            for m, p in zip(midpoint, point))
+
     def eval_symbolic(self, function: AnyFunction) -> ScalarFunction:
         """Apply to the functional to a function."""
         e = self._eval_symbolic(function)
@@ -136,6 +147,10 @@ def dof_point(self) -> PointType:
         assert isinstance(pt, tuple)
         return pt
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         assert isinstance(self.point, VectorFunction)
@@ -165,6 +180,10 @@ def dof_point(self) -> PointType:
         assert isinstance(pt, tuple)
         return pt
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         assert isinstance(self.point, VectorFunction)
@@ -199,6 +218,10 @@ def dof_point(self) -> PointType:
         assert isinstance(pt, tuple)
         return pt
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def perform_mapping(
         self, fs: typing.List[AnyFunction], map: PointType, inverse_map: PointType, tdim: int
     ) -> typing.List[AnyFunction]:
@@ -273,6 +296,10 @@ def dof_direction(self) -> typing.Union[PointType, None]:
         assert isinstance(d, tuple)
         return d
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         assert isinstance(self.point, VectorFunction)
@@ -336,6 +363,10 @@ def dof_point(self) -> PointType:
         assert isinstance(pt, tuple)
         return pt
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         desc = "v\\mapsto"
@@ -383,6 +414,10 @@ def dof_direction(self) -> typing.Union[PointType, None]:
         assert isinstance(lv, tuple)
         return lv
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         assert isinstance(self.lvec, VectorFunction)
@@ -430,6 +465,10 @@ def dof_direction(self) -> typing.Union[PointType, None]:
             return v
         return None
 
+    def adjusted_dof_point(self) -> PointType:
+        """Get the adjusted position of the DOF in the cell for plotting."""
+        return self.dof_point()
+
     def get_tex(self) -> typing.Tuple[str, typing.List[str]]:
         """Get a representation of the functional as TeX, and list of terms involved."""
         desc = "\\boldsymbol{v}\\mapsto"