fuse-element 0.1.dev0__py3-none-any.whl

fuse/spaces/interpolation_spaces.py

@@ -0,0 +1,138 @@
+from functools import total_ordering
+
+
+@total_ordering
+class InterpolationSpace(object):
+    """Symbolic representation of an interpolation function space
+
+    This implements a subset of the methods of a Python set so that
+    other spaces can be tested for inclusion.
+    """
+
+    def __init__(self, name, shape=None, parents=None):
+        """Instantiate a InterpolationSpace object.
+
+        Args:
+            name: The name of this space,
+            parents: A set of spaces of which this
+            space is a subspace.
+        """
+        self.name = name
+        p = frozenset(parents or [])
+        # Ensure that the inclusion operations are transitive.
+        self.parents = p.union(*[p_.parents for p_ in p])
+
+    def __str__(self):
+        """Format as a string."""
+        return self.name
+
+    def __repr__(self):
+        """Representation."""
+        return f"InterpolationSpace({self.name!r}, {list(self.parents)!r})"
+
+    def __eq__(self, other):
+        """Check equality."""
+        return isinstance(other, InterpolationSpace) and self.name == other.name and self.shape == other.shape
+
+    def __ne__(self, other):
+        """Not equal."""
+        return not self == other
+
+    def __hash__(self):
+        """Hash."""
+        return hash(("InterpolationSpace", self.name))
+
+    def __lt__(self, other):
+        """In common with intrinsic Python sets, < indicates "is a proper subset of"."""
+        return other in self.parents
+
+    def _to_dict(self):
+        return {"space": str(self)}
+
+    def dict_id(self):
+        return "InterpolationSpace"
+
+    def _from_dict(obj_dict):
+        return InterpolationSpace(obj_dict["space"])
+
+
+class Sobolev(InterpolationSpace):
+    """
+    Describes the Sobolev Space W_m,p
+
+    Arguments:
+    - Derivatives (m): the numbers of derivatives that are required to exist
+    - Lebesgue (p): The L_p space the derivatives are required to be in
+    """
+
+    def __init__(self, derivatives, lebesgue, shape=None, name=None, parents=[]):
+        self.derivatives = derivatives
+        self.lebesgue = lebesgue
+        self.shape = shape
+
+        if name is None:
+            if derivatives == 0:
+                name = "L_" + str(lebesgue)
+            elif lebesgue == 2:
+                name = "H_" + str(derivatives)
+            else:
+                name = "W_" + str(derivatives) + ", " + str(lebesgue)
+
+        super(Sobolev, self).__init__(name, parents)
+
+    def __lt__(self, other):
+        """In common with intrinsic Python sets, < indicates "is a proper subset of"."""
+
+        if isinstance(other, Sobolev):
+            if self.lebesgue >= other.lebesgue:
+                return other.derivatives < self.derivatives or other in self.parents
+
+        return other in self.parents
+
+    def __call__(self, shape):
+        return Sobolev(self.derivatives, self.lebesgue, shape, name=self.name, parents=self.parents)
+
+
+class Continuous(InterpolationSpace):
+    """
+    Describes the continuous space C_n
+
+    Arguments:
+    - Derivatives(n): the number of times the functions can be continously differentiated
+    """
+
+    def __init__(self, derivatives, shape=None, parents=[]):
+        self.derivatives = derivatives
+        self.shape = shape
+        name = "C_" + str(derivatives)
+        super(Continuous, self).__init__(name, parents)
+
+    def __lt__(self, other):
+        """In common with intrinsic Python sets, < indicates "is a proper subset of"."""
+
+        if isinstance(other, Continuous):
+            return other.derivatives > self.derivatives
+
+        return other in self.parents
+
+    def __call__(self, shape):
+        return Continuous(self.derivatives, shape=shape, parents=self.parents)
+
+
+C0 = Continuous(0)
+L2 = Sobolev(0, 2)
+H1 = Sobolev(1, 2)
+HDiv = Sobolev(0, 2, name="HDiv", parents=[L2])
+HCurl = Sobolev(0, 2, name="HCurl", parents=[L2])
+
+# Want to have
+# c_0
+# c_n
+# w_m,p st mp < 1
+
+# h_n ~ w_n,2
+# l_2 ~ h_0
+# h_1
+
+# inclusions
+# c_0

fuse/spaces/polynomial_spaces.py

@@ -0,0 +1,203 @@
+from FIAT.polynomial_set import ONPolynomialSet
+from FIAT.quadrature_schemes import create_quadrature
+from FIAT import expansions, polynomial_set, reference_element
+from itertools import chain
+from fuse.utils import tabulate_sympy, max_deg_sp_mat
+import sympy as sp
+import numpy as np
+
+
+class PolynomialSpace(object):
+    """
+    contains: the degree of the maximum degree Lagrange space that is spanned by this element. If this
+    element's polynomial space does not include the constant function, this function should
+    return -1.
+
+    maxdegree: the degree of the minimum degree Lagrange space that spans this element.If this
+    element contains basis functions that are not in any Lagrange space, this property should
+    be None.
+
+    mindegree: the degree of the polynomial in the space with the lowest degree.
+
+    Note that on a simplex cells, the polynomial space of Lagrange space is a complete polynomial
+    space, but on other cells this is not true. For example, on quadrilateral cells, the degree 1
+    Lagrange space includes the degree 2 polynomial xy.
+    """
+
+    def __init__(self, maxdegree, contains=None, mindegree=0, set_shape=False):
+        self.maxdegree = maxdegree
+        self.mindegree = mindegree
+
+        if not contains and mindegree == 0:
+            self.contains = maxdegree
+        elif not contains and mindegree >= 0:
+            self.contains = -1
+        else:
+            self.contains = contains
+
+        self.set_shape = set_shape
+
+    def complete(self):
+        return self.mindegree == self.maxdegree
+
+    def degree(self):
+        return self.maxdegree
+
+    def to_ON_polynomial_set(self, ref_el, k=None):
+        # how does super/sub degrees work here
+        if not isinstance(ref_el, reference_element.Cell):
+            ref_el = ref_el.to_fiat()
+        sd = ref_el.get_spatial_dimension()
+        if self.set_shape:
+            shape = (sd,)
+        else:
+            shape = tuple()
+
+        if self.mindegree > 0:
+            base_ON = ONPolynomialSet(ref_el, self.maxdegree, shape, scale="orthonormal")
+            dimPmin = expansions.polynomial_dimension(ref_el, self.mindegree)
+            dimPmax = expansions.polynomial_dimension(ref_el, self.maxdegree)
+            if self.set_shape:
+                indices = list(chain(*(range(i * dimPmin, i * dimPmax) for i in range(sd))))
+            else:
+                indices = list(range(dimPmin, dimPmax))
+            restricted_ON = base_ON.take(indices)
+            return restricted_ON
+        return ONPolynomialSet(ref_el, self.maxdegree, shape, scale="orthonormal")
+
+    def __repr__(self):
+        res = ""
+        if self.complete():
+            res += "P" + str(self.maxdegree)
+        elif self.mindegree > 0:
+            res = "P" + "(min " + str(self.mindegree) + " max " + str(self.maxdegree) + ")"
+        else:
+            res += "Psub" + str(self.contains) + "sup" + str(self.maxdegree)
+        if self.set_shape:
+            res += "^d"
+        return res
+
+    def __mul__(self, x):
+        """
+        When multiplying a Polynomial Space by a sympy object, you need to multiply with
+        the sympy object on the right. This is due to Sympy's implementation of __mul__ not
+        passing to this handler as it should.
+        """
+        if isinstance(x, sp.Symbol):
+            return ConstructedPolynomialSpace([x], [self])
+        elif isinstance(x, sp.Matrix):
+            return ConstructedPolynomialSpace([x], [self])
+        else:
+            raise TypeError(f'Cannot multiply a PolySpace with {type(x)}')
+
+    __rmul__ = __mul__
+
+    def __add__(self, x):
+        return ConstructedPolynomialSpace([1, 1], [self, x])
+
+    def restrict(self, min_degree, max_degree):
+        return PolynomialSpace(max_degree, contains=-1, mindegree=min_degree, set_shape=self.set_shape)
+
+    def _to_dict(self):
+        return {"set_shape": self.set_shape, "min": self.mindegree, "contains": self.contains, "max": self.maxdegree}
+
+    def dict_id(self):
+        return "PolynomialSpace"
+
+    def _from_dict(obj_dict):
+        return PolynomialSpace(obj_dict["max"], obj_dict["contains"], obj_dict["min"], obj_dict["set_shape"])
+
+
+class ConstructedPolynomialSpace(PolynomialSpace):
+    """
+    Sub degree is inherited from the largest of the component spaces,
+    super degree is unknown.
+
+    weights can either be 1 or a polynomial in x, where x in R^d
+    """
+    def __init__(self, weights, spaces):
+
+        self.weights = weights
+        self.spaces = spaces
+
+        maxdegree = max([space.maxdegree for space in spaces])
+        mindegree = min([space.mindegree for space in spaces])
+        vec = any([s.set_shape for s in spaces])
+
+        super(ConstructedPolynomialSpace, self).__init__(maxdegree, -1, mindegree, set_shape=vec)
+
+    def __repr__(self):
+        return "+".join([str(w) + "*" + str(x) for (w, x) in zip(self.weights, self.spaces)])
+
+    def to_ON_polynomial_set(self, ref_el):
+        if not isinstance(ref_el, reference_element.Cell):
+            ref_el = ref_el.to_fiat()
+        k = max([s.maxdegree for s in self.spaces])
+        space_poly_sets = [s.to_ON_polynomial_set(ref_el) for s in self.spaces]
+        sd = ref_el.get_spatial_dimension()
+
+        if all([w == 1 for w in self.weights]):
+            weighted_sets = space_poly_sets
+
+        # otherwise have to work on this through tabulation
+
+        Q = create_quadrature(ref_el, 2 * (k + 1))
+        Qpts, Qwts = Q.get_points(), Q.get_weights()
+        weighted_sets = []
+
+        for (space, w) in zip(space_poly_sets, self.weights):
+            if not (isinstance(w, sp.Expr) or isinstance(w, sp.Matrix)):
+                weighted_sets.append(space)
+            else:
+                w_deg = max_deg_sp_mat(w)
+                Pkpw = ONPolynomialSet(ref_el, space.degree + w_deg, scale="orthonormal")
+                vec_Pkpw = ONPolynomialSet(ref_el, space.degree + w_deg, (sd,), scale="orthonormal")
+
+                space_at_Qpts = space.tabulate(Qpts)[(0,) * sd]
+                Pkpw_at_Qpts = Pkpw.tabulate(Qpts)[(0,) * sd]
+
+                tabulated_expr = tabulate_sympy(w, Qpts).T
+                scaled_at_Qpts = space_at_Qpts[:, None, :] * tabulated_expr[None, :, :]
+                PkHw_coeffs = np.dot(np.multiply(scaled_at_Qpts, Qwts), Pkpw_at_Qpts.T)
+                weighted_sets.append(polynomial_set.PolynomialSet(ref_el,
+                                                                  space.degree + w_deg,
+                                                                  space.degree + w_deg,
+                                                                  vec_Pkpw.get_expansion_set(),
+                                                                  PkHw_coeffs))
+        combined_sets = weighted_sets[0]
+        for i in range(1, len(weighted_sets)):
+            combined_sets = polynomial_set.polynomial_set_union_normalized(combined_sets, weighted_sets[i])
+        return combined_sets
+
+    def __mul__(self, x):
+        return ConstructedPolynomialSpace([x*w for w in self.weights],
+                                          self.spaces)
+    __rmul__ = __mul__
+
+    def __add__(self, x):
+        return ConstructedPolynomialSpace(self.weights.extend([1]),
+                                          self.spaces.extend(x))
+
+    def _to_dict(self):
+        super_dict = super(ConstructedPolynomialSpace, self)._to_dict()
+        super_dict["spaces"] = self.spaces
+        super_dict["weights"] = self.weights
+        return super_dict
+
+    def dict_id(self):
+        return "ConstructedPolynomialSpace"
+
+    def _from_dict(obj_dict):
+        return ConstructedPolynomialSpace(obj_dict["weights"], obj_dict["spaces"])
+
+
+P0 = PolynomialSpace(0)
+P1 = PolynomialSpace(1)
+P2 = PolynomialSpace(2)
+P3 = PolynomialSpace(3)
+P4 = PolynomialSpace(4)
+
+Q1 = PolynomialSpace(1, 2)
+Q2 = PolynomialSpace(2, 3)
+Q3 = PolynomialSpace(3, 4)
+Q4 = PolynomialSpace(4, 5)

fuse/traces.py

@@ -0,0 +1,196 @@
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+from fuse.utils import sympy_to_numpy
+
+
+class Trace():
+
+    def __init__(self, cell):
+        self.domain = cell
+
+    def __call__(self, trace_entity, g):
+        raise NotImplementedError("Trace uninstanitated")
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        raise NotImplementedError("Trace uninstanitated")
+
+    def tabulate(self, Qpts, trace_entity, g):
+        raise NotImplementedError("Tabulation uninstantiated")
+
+    def _to_dict(self):
+        return {"trace": str(self)}
+
+    def dict_id(self):
+        return "Trace"
+
+    def _from_dict(obj_dict):
+        # might want to actually save these as functions or something for ambiguity?
+        tr_id = obj_dict["trace"]
+        if tr_id == "H1":
+            return TrH1
+        elif tr_id == "HDiv":
+            return TrHDiv
+        elif tr_id == "HCurl":
+            return TrHCurl
+        elif tr_id == "Grad":
+            return TrGrad
+        elif tr_id == "Hess":
+            return TrHess
+        raise ValueError("Trace not found")
+
+
+class TrH1(Trace):
+
+    def __init__(self, cell):
+        super(TrH1, self).__init__(cell)
+
+    def __call__(self, v, trace_entity, g):
+        return v
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        ax.scatter(*coord, **kwargs)
+
+    def tabulate(self, Qpts, trace_entity, g):
+        return np.ones_like(Qpts)
+
+    def __repr__(self):
+        return "H1"
+
+
+class TrHDiv(Trace):
+
+    def __init__(self, cell):
+        super(TrHDiv, self).__init__(cell)
+
+    def __call__(self, v, trace_entity, g):
+        def apply(*x):
+            result = np.dot(self.tabulate(None, trace_entity, g), np.array(v(*x)).squeeze())
+            if isinstance(result, np.float64):
+                # todo: might always be a float
+                return (result,)
+            return tuple(result)
+        return apply
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        # plot dofs of the type associated with this space
+        permuted = self.domain.permute_entities(g, trace_entity.dimension)
+        orientation = [o for (ent, o) in permuted if ent == trace_entity.id][0]
+
+        entityBasis = np.array(trace_entity.orient(orientation).basis_vectors())
+        cellEntityBasis = np.array(self.domain.basis_vectors(entity=trace_entity))
+        basis = np.matmul(entityBasis, cellEntityBasis)
+        if len(coord) == 2:
+            vec = np.matmul(np.array([[0, 1], [-1, 0]]), basis.T)
+        else:
+            vec = np.cross(basis[0], basis[1])
+        ax.quiver(*coord, *vec, **kwargs)
+
+    def tabulate(self, Qpts, trace_entity, g):
+        entityBasis = np.array(trace_entity.basis_vectors())
+        cellEntityBasis = np.array(self.domain.basis_vectors(entity=trace_entity))
+        basis = np.matmul(entityBasis, cellEntityBasis)
+
+        if trace_entity.dimension == 1:
+            result = np.matmul(basis, np.array([[0, -1], [1, 0]]))
+        elif trace_entity.dimension == 2:
+            result = np.cross(basis[0], basis[1])
+        else:
+            raise ValueError("Immersion of HDiv edges not defined in 3D")
+
+        return result
+
+    def __repr__(self):
+        return "HDiv"
+
+
+class TrHCurl(Trace):
+
+    def __init__(self, cell):
+        super(TrHCurl, self).__init__(cell)
+
+    def __call__(self, v, trace_entity, g):
+        def apply(*x):
+            result = np.dot(self.tabulate(None, trace_entity, g), np.array(v(*x)).squeeze())
+            if isinstance(result, np.float64):
+                return (result,)
+            return tuple(result)
+        return apply
+
+    def tabulate(self, Qpts, trace_entity, g):
+        tangent = np.array(trace_entity.basis_vectors())
+        subEntityBasis = np.array(self.domain.basis_vectors(entity=trace_entity))
+        result = np.matmul(tangent, subEntityBasis)
+        return result
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        permuted = self.domain.permute_entities(g, trace_entity.dimension)
+        orientation = [o for (ent, o) in permuted if ent == trace_entity.id][0]
+
+        tangent = np.array(trace_entity.orient(orientation).basis_vectors())
+        subEntityBasis = np.array(self.domain.basis_vectors(entity=trace_entity))
+        vec = np.matmul(tangent, subEntityBasis)[0]
+        ax.quiver(*coord, *vec, **kwargs)
+
+    def __repr__(self):
+        return "HCurl"
+
+
+class TrGrad(Trace):
+
+    def __init__(self, cell):
+        super(TrGrad, self).__init__(cell)
+
+    def __call__(self, v, trace_entity, g):
+        # Compute grad v and then dot with tangent rotated according to the group member
+        tangent = np.array(g(np.array(self.domain.basis_vectors())[0]))
+
+        def apply(*x):
+            X = sp.DeferredVector('x')
+            dX = tuple([X[i] for i in range(self.domain.dim())])
+            compute_v = v(*dX, sym=True)
+            grad_v = sp.Matrix([sp.diff(compute_v, dX[i]) for i in range(len(dX))])
+            eval_grad_v = sympy_to_numpy(grad_v, dX, v.attach_func(*x))
+            result = np.dot(tangent, np.array(eval_grad_v))
+
+            if not hasattr(result, "__iter__"):
+                return (result,)
+            return tuple(result)
+        return apply
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        circle1 = plt.Circle(coord, 0.075, fill=False, **kwargs)
+        ax.add_patch(circle1)
+
+    def __repr__(self):
+        return "Grad"
+
+
+class TrHess(Trace):
+
+    def __init__(self, cell):
+        super(TrHess, self).__init__(cell)
+
+    def __call__(self, v, trace_entity, g):
+        b0, b1 = self.domain.basis_vectors()
+        tangent0 = np.array(g(b0))
+        tangent1 = np.array(g(b1))
+
+        def apply(*x):
+            X = sp.DeferredVector('x')
+
+            dX = tuple([X[i] for i in range(self.domain.dim())])
+            hess_v = sp.Matrix([[sp.diff(v(*dX, sym=True), dX[i], dX[j]) for i in range(len(dX))] for j in range(len(dX))])
+            eval_hess_v = sympy_to_numpy(hess_v, dX, v.attach_func(*x))
+            result = np.dot(np.matmul(tangent0, np.array(eval_hess_v)), tangent1)
+            if not hasattr(result, "__iter__"):
+                return (result,)
+            return tuple(result)
+        return apply
+
+    def plot(self, ax, coord, trace_entity, g, **kwargs):
+        circle1 = plt.Circle(coord, 0.15, fill=False, **kwargs)
+        ax.add_patch(circle1)
+
+    def __repr__(self):
+        return "Hess"