feectools 0.1.0__py3-none-any.whl

feectools/fem/grid.py

@@ -0,0 +1,181 @@
+# coding: utf-8
+#
+# Copyright 2018 Yaman Güçlü
+
+import numpy as np
+
+from feectools.core.bsplines         import elements_spans
+from feectools.core.bsplines         import quadrature_grid
+from feectools.core.bsplines         import basis_ders_on_quad_grid
+from feectools.core.bsplines         import elevate_knots
+from feectools.utilities.quadratures import gauss_legendre
+from feectools.fem.splines           import SplineSpace
+
+__all__ = ('FemAssemblyGrid',)
+
+#==============================================================================
+class FemAssemblyGrid:
+    """
+    Class that collects all 1D information local to process that are necessary
+    for the correct assembly of l.h.s. matrix and r.h.s. vector in a finite
+    element method.
+
+    This works in the case of clamped and periodic splines, for a global or
+    distributed domain.
+
+    A 'TensorFemSpace' object will create one object of this class for each
+    1D space.
+
+    Parameters
+    ----------
+    space : SplineSpace
+        1D finite element space.
+
+    start : int
+        Index of first element local to process.
+
+    end : int
+        Index of last element local to process.
+
+    nquads : int
+        Number of quadrature points used in the Gauss-Legendre quadrature formula.
+
+    nderiv : int
+        Number of basis functions' derivatives to be precomputed at the Gauss
+        points (default: 1).
+
+    """
+    def __init__(self, space, start, end, *, nquads, nderiv=1):
+
+        assert isinstance(space, SplineSpace)
+        assert isinstance(start, int)
+        assert isinstance(end, int)
+        assert isinstance(nquads, int)
+        assert isinstance(nderiv, int)
+
+        # Useful shortcuts
+        T      = space.knots   # knots sequence
+        degree = space.degree  # spline degree
+        n      = space.nbasis  # total number of control points
+        grid   = space.breaks  # breakpoints
+
+        # Gauss-legendre quadrature rule
+        # print('[psy4str] here is a problem')
+        u, w = gauss_legendre(nquads) # TODO [psy4str] OLD DOESN'T WORK
+        # u, w = gauss_legendre(nquads + 1) # TODO [psy4str] NEW WORKS BUT WHY?
+
+        #-------------------------------------------
+        # GLOBAL GRID
+        #-------------------------------------------
+
+        # Lists of quadrature coordinates and weights on each element
+        global_points, global_weights = quadrature_grid(grid, u, w)
+
+        # List of basis function values on each element
+        global_basis = basis_ders_on_quad_grid(T, degree, global_points, nderiv, space.basis)
+
+        # List of spans on each element
+        # (Span is global index of last non-vanishing basis function)
+        global_spans = elements_spans(T, degree)
+
+        grid    = grid[start : end + 2]
+        spans   = global_spans  [start : end + 1].copy()
+        basis   = global_basis  [start : end + 1].copy()
+        points  = global_points [start : end + 1].copy()
+        weights = global_weights[start : end + 1].copy()
+
+        #-------------------------------------------
+        # DATA STORAGE IN OBJECT
+        #-------------------------------------------
+
+        # Quadrature data on extended distributed domain
+        self._num_elements = len(grid) - 1
+        self._num_quad_pts = len(u)
+        self._spans        = spans
+        self._basis        = basis
+        self._points       = points
+        self._weights      = weights
+        self._indices      = tuple(range(start, end + 1))
+        self._quad_rule_x  = u
+        self._quad_rule_w  = w
+
+        # Local index of start/end elements of domain partitioning
+        self._local_element_start = 0
+        self._local_element_end   = self._num_elements - 1
+
+    # ...
+    @property
+    def num_elements(self):
+        """ Number of elements over which integration should be performed.
+        """
+        return self._num_elements
+
+    # ...
+    @property
+    def num_quad_pts(self):
+        """ Number of quadrature points in each element.
+        """
+        return self._num_quad_pts
+
+    # ...
+    @property
+    def spans(self):
+        """ Span index in each element.
+        """
+        return self._spans
+
+    # ...
+    @property
+    def basis(self):
+        """ Basis function values (and their derivatives) at each quadrature point.
+        """
+        return self._basis
+
+    # ...
+    @property
+    def points(self):
+        """ Location of each quadrature point.
+        """
+        return self._points
+
+    # ...
+    @property
+    def weights(self):
+        """ Weight assigned to each quadrature point.
+        """
+        return self._weights
+
+    # ...
+    @property
+    def indices(self):
+        """ Global index of each element used in assembly process.
+        """
+        return self._indices
+
+    # ...
+    @property
+    def quad_rule_x(self):
+        """ Coordinates of quadrature points on canonical interval [-1,1].
+        """
+        return self._quad_rule_x
+
+    # ...
+    @property
+    def quad_rule_w(self):
+        """ Weights assigned to quadrature points on canonical interval [-1,1].
+        """
+        return self._quad_rule_w
+
+    # ...
+    @property
+    def local_element_start(self):
+        """ Local index of first element owned by process.
+        """
+        return self._local_element_start
+
+    # ...
+    @property
+    def local_element_end(self):
+        """ Local index of last element owned by process.
+        """
+        return self._local_element_end

feectools/fem/partitioning.py

@@ -0,0 +1,344 @@
+# -*- coding: UTF-8 -*-
+import os
+
+import numpy as np
+
+from feectools.ddm.cart       import CartDecomposition, InterfaceCartDecomposition, create_interfaces_cart
+from feectools.core.bsplines  import elements_spans
+from feectools.fem.vector     import VectorFemSpace
+
+
+__all__ = (
+    'partition_coefficients',
+    'get_minus_starts_ends',
+    'get_plus_starts_ends',
+    'create_cart',
+    'construct_interface_spaces',
+    'construct_reduced_interface_spaces'
+)
+
+
+def partition_coefficients(domain_decomposition, spaces, min_blocks=None):
+    """
+    Partition the coefficients starting from the grid decomposition.
+
+    Parameters
+    ----------
+
+    domain_decomposition: DomainDecomposition
+        The distributed topological domain.
+
+    spaces: list of SplineSpace
+        The 1d spline spaces that construct the tensor fem space.
+
+    min_blocks: list of int
+        The minimum number of coefficients owned by a process.
+
+    Returns
+    -------
+
+    global_starts: list of list of int
+        The starts of the coefficients for every process along each direction.
+
+    global_ends: list of list of int
+        The ends of the coefficients for every process along each direction.
+
+    """
+    npts         = [V.nbasis   for V in spaces]
+    multiplicity = [V.multiplicity for V in spaces]
+
+    ndims         = len(npts)
+    global_starts = [None] * ndims
+    global_ends   = [None] * ndims
+
+    for axis in range(ndims):
+        es = domain_decomposition.global_element_starts[axis]
+        ee = domain_decomposition.global_element_ends  [axis]
+        m  = multiplicity[axis]
+
+        global_ends  [axis]     = m*(ee+1)-1
+        global_ends  [axis][-1] = npts[axis]-1
+        global_starts[axis]     = np.array([0] + (global_ends[axis][:-1]+1).tolist())
+
+    if min_blocks is None:
+        min_blocks = [None] * ndims
+
+    for s, e, V, mb in zip(global_starts, global_ends, spaces, min_blocks):
+        if V.periodic or mb is None:
+            assert all(e-s+1 >= V.degree), f"Local number of elements (after domain decomposition) is to small for spline degree p={V.degree}: {e-s+1} is not >= {V.degree} everywhere.\n \
+            You can:\n \
+                1. increase Nel\n \
+                2. lower p\n \
+                3. decrease the MPI size."
+        else:
+            assert all(e-s+1 >= mb)
+
+    return global_starts, global_ends
+
+#------------------------------------------------------------------------------
+def get_minus_starts_ends(plus_starts, plus_ends, minus_npts, plus_npts, minus_axis, plus_axis,
+                          minus_ext, plus_ext, minus_pads, plus_pads, minus_shifts, plus_shifts,
+                          diff):
+    """
+    Compute the coefficients needed by the minus patch in a given interface.
+    """
+    starts = [max(0,s-m*p) for s,m,p in zip(plus_starts, minus_shifts, minus_pads)]
+    ends   = [min(n,e+m*p) for e,n,m,p in zip(plus_ends, minus_npts, minus_shifts, minus_pads)]
+    starts[minus_axis] = 0 if minus_ext == -1 else ends[minus_axis]-minus_pads[minus_axis]
+    ends[minus_axis]   = ends[minus_axis] if minus_ext == 1 else minus_pads[minus_axis]
+    return starts, ends
+
+#------------------------------------------------------------------------------
+def get_plus_starts_ends(minus_starts, minus_ends, minus_npts, plus_npts, minus_axis, plus_axis,
+                         minus_ext, plus_ext, minus_pads, plus_pads, minus_shifts, plus_shifts,
+                         diff):
+    """
+    Compute the coefficients needed by the plus patch in a given interface.
+    """
+    starts = [max(0,s-m*p) for s,m,p in zip(minus_starts, plus_shifts, plus_pads)]
+    ends   = [min(n,e+m*p) for e,n,m,p in zip(minus_ends, plus_npts, plus_shifts, plus_pads)]
+    starts[plus_axis] = 0 if plus_ext == -1 else ends[plus_axis]-plus_pads[plus_axis]
+    ends[plus_axis]   = ends[plus_axis] if plus_ext == 1 else plus_pads[plus_axis]
+    return starts, ends
+
+#------------------------------------------------------------------------------
+def create_cart(domain_decomposition, spaces):
+    """
+    Compute the cartesian decomposition of the coefficient space.
+    Two different cases are possible:
+    
+    - Single patch :
+        We distribute the coefficients using all the processes provided by the given communicator.
+    - Multiple patches :
+        We decompose the provided communicator in a list of smaller disjoint intra-communicators,
+        and decompose the coefficients of each patch with an assigned intra-communicator.
+
+    Parameters
+    ----------
+    domain_decomposition : DomainDecomposition | tuple of DomainDecomposition
+
+    spaces : list of list of 1D global Spline spaces
+        The 1D global spline spaces that will be distributed.
+
+    Returns
+    -------
+    cart : tuple of CartDecomposition
+        Cartesian decomposition of the coefficient space for each patch in the domain.
+
+    """
+
+    if len(spaces) == 1:
+        domain_decomposition = domain_decomposition[0]
+        spaces       = spaces[0]
+        npts         = [V.nbasis for V in spaces]
+        pads         = [V._pads  for V in spaces]
+        multiplicity = [V.multiplicity for V in spaces]
+
+        global_starts, global_ends = partition_coefficients(domain_decomposition, spaces)
+
+        carts = [CartDecomposition(
+                domain_decomposition = domain_decomposition,
+                npts          = npts,
+                global_starts = global_starts,
+                global_ends   = global_ends,
+                pads          = pads,
+                shifts        = multiplicity)]
+    else:
+        carts = []
+        for i in range(len(spaces)):
+            npts         = [V.nbasis for V in spaces[i]]
+            pads         = [V._pads  for V in spaces[i]]
+            multiplicity = [V.multiplicity for V in spaces[i]]
+
+            global_starts, global_ends = partition_coefficients(
+                    domain_decomposition[i],
+                    spaces[i],
+                    min_blocks=[p+1 for p in pads])
+
+            new_cart = CartDecomposition(
+                            domain_decomposition = domain_decomposition[i],
+                            npts          = npts,
+                            global_starts = global_starts,
+                            global_ends   = global_ends,
+                            pads          = pads,
+                            shifts        = multiplicity)
+
+            carts.append(new_cart)
+
+        carts = tuple(carts)
+
+    return carts
+
+#------------------------------------------------------------------------------
+def construct_interface_spaces(domain_decomposition, g_spaces, carts, interiors, connectivity):
+    """ 
+    Create the fem spaces for each interface in the domain given by the connectivity.
+
+    Parameters
+    ----------
+    domain_decomposition : DomainDecomposition
+
+    g_spaces : dict
+     dictionary that contains the tensor-fem space for each patch.
+
+    cart: <CartDecomposition|MultiCartDecomposition>
+        Cartesian decomposition of the coefficient space.
+
+    interiors: list of Sympde.topology.Domain
+      List of the multipatch domain interiors.
+
+    connectivity: dict
+       The connectivity of the multipatch domain.
+    """
+    if not connectivity:return
+    comm = domain_decomposition.comm
+    interfaces_cart = None
+    if comm is not None:
+        if connectivity:
+            communication_info = (get_minus_starts_ends, get_plus_starts_ends)
+            interfaces_cart = create_interfaces_cart(domain_decomposition, carts, connectivity.copy(), communication_info=communication_info)
+
+    for i,j in connectivity:
+        if comm is None:
+            cart_minus = carts[i]
+            cart_plus  = carts[j]
+        else:
+            if not carts[i].is_comm_null and not carts[j].is_comm_null:
+                cart_minus = carts[i]
+                cart_plus  = carts[j]
+            elif (i,j) in interfaces_cart:
+                cart_minus = interfaces_cart[i,j]
+                cart_plus  = interfaces_cart[i,j]
+            else:
+                continue
+
+        ((axis_minus, ext_minus), (axis_plus , ext_plus)) = connectivity[i, j]
+
+        g_spaces[interiors[i]].create_interface_space(axis_minus, ext_minus, cart=cart_minus)
+        g_spaces[interiors[j]].create_interface_space(axis_plus , ext_plus , cart=cart_plus)
+
+        max_ncells = tuple(max(ni,nj) for ni,nj in zip(g_spaces[interiors[i]].ncells,g_spaces[interiors[j]].ncells))
+        cart_minus = g_spaces[interiors[i]].get_refined_space(max_ncells).coeff_space.cart
+        cart_plus  = g_spaces[interiors[j]].get_refined_space(max_ncells).coeff_space.cart
+        if isinstance(cart_minus, InterfaceCartDecomposition):
+            cart = InterfaceCartDecomposition(cart_minus._cart_minus, cart_plus._cart_plus,
+                                              cart_minus._comm, [axis_minus, axis_plus], [ext_minus, ext_plus],
+                                              [cart_minus.ranks_in_topo_minus, cart_plus.ranks_in_topo_plus],
+                                              [cart_minus._local_group_minus, cart_plus._local_group_plus],
+                                              [cart_minus._local_comm_minus, cart_plus._local_comm_plus],
+                                              [cart_minus._root_rank_minus, cart_plus._root_rank_plus],
+                                              [], reduce_elements=True)
+
+            cart_minus = cart
+            cart_plus  = cart
+            cart.set_interface_communication_infos(get_minus_starts_ends, get_plus_starts_ends)
+
+        if any(nci!=ncj for nci,ncj in zip(max_ncells, g_spaces[interiors[i]].ncells)):
+            g_spaces[interiors[i]].get_refined_space(max_ncells).create_interface_space(axis_minus, ext_minus, cart=cart_minus)
+            g_spaces[interiors[j]].get_refined_space(max_ncells).create_interface_space(axis_plus , ext_plus , cart=cart_plus)
+
+#------------------------------------------------------------------------------
+def construct_reduced_interface_spaces(spaces, reduced_spaces, interiors, connectivity):
+    """
+    Create the reduced spaces for the interface coefficients.
+
+    Parameters
+    ----------
+
+    spaces: dict
+        The tensor FEM spaces that we want to reduce for each patch.
+
+    reduced_spaces: dict
+        The reduced coefficient space for each patch.
+
+    interiors: list of Sympde.topology.Domain
+        The patches that construct the multipatch domain.
+        
+    connectivity: dict
+       The connectivity of the multipatch domain.
+
+    """
+    for i,j in connectivity:
+        ((axis_i, ext_i), (axis_j , ext_j)) = connectivity[i, j]
+
+        patch_i = interiors[i]
+        patch_j = interiors[j]
+        space_i = spaces[patch_i].interfaces.get((axis_i, ext_i), None)
+        space_j = spaces[patch_j].interfaces.get((axis_j, ext_j), None)
+
+        if space_i is None or space_j is None: continue
+
+        cart_i  = space_i.coeff_space.cart
+        cart_j  = space_j.coeff_space.cart
+
+        if isinstance(cart_i, InterfaceCartDecomposition):
+            assert cart_i is cart_j
+            if isinstance(reduced_spaces[patch_i], VectorFemSpace):
+                for Vi,Vj in zip(reduced_spaces[patch_i].spaces, reduced_spaces[patch_j].spaces):
+                    npts_i = [Vik.nbasis for Vik in Vi.spaces]
+                    npts_j = [Vik.nbasis for Vik in Vj.spaces]
+                    global_starts_i = Vi.coeff_space.cart.global_starts
+                    global_starts_j = Vj.coeff_space.cart.global_starts
+                    global_ends_i   = Vi.coeff_space.cart.global_ends
+                    global_ends_j   = Vj.coeff_space.cart.global_ends
+                    shifts_i        = Vi.coeff_space.cart.shifts
+                    shifts_j        = Vj.coeff_space.cart.shifts
+                    cart_ij         = cart_i.reduce_npts(Vi.coeff_space.cart, Vj.coeff_space.cart)
+                    cart_ij.set_interface_communication_infos(get_minus_starts_ends, get_plus_starts_ends)
+                    Vi.create_interface_space(axis_i, ext_i, cart=cart_ij)
+                    Vj.create_interface_space(axis_j, ext_j, cart=cart_ij)
+
+                    cart = InterfaceCartDecomposition(cart_ij._cart_minus, cart_ij._cart_plus,
+                                                      cart_ij._comm, [axis_i, axis_j], [ext_i, ext_j],
+                                                      [cart_ij.ranks_in_topo_minus, cart_ij.ranks_in_topo_plus],
+                                                      [cart_ij._local_group_minus, cart_ij._local_group_plus],
+                                                      [cart_ij._local_comm_minus, cart_ij._local_comm_plus],
+                                                      [cart_ij._root_rank_minus, cart_ij._root_rank_plus],
+                                                      [], reduce_elements=True)
+
+                    cart.set_interface_communication_infos(get_minus_starts_ends, get_plus_starts_ends)
+                    max_ncells = tuple(max(ni,nj) for ni,nj in zip(Vi.ncells,Vj.ncells))
+                    Vi.get_refined_space(max_ncells).create_interface_space(axis_i, ext_i, cart=cart)
+                    Vj.get_refined_space(max_ncells).create_interface_space(axis_j, ext_j, cart=cart)
+            else:
+                Vi = reduced_spaces[patch_i]
+                Vj = reduced_spaces[patch_j]
+                npts_i = [Vik.nbasis for Vik in Vi.spaces]
+                npts_j = [Vik.nbasis for Vik in Vj.spaces]
+                cart_ij  = cart_i.reduce_npts(Vi.coeff_space.cart, Vj.coeff_space.cart)
+                cart_ij.set_interface_communication_infos(get_minus_starts_ends, get_plus_starts_ends)
+                Vi.create_interface_space(axis_i, ext_i, cart=cart_ij)
+                Vj.create_interface_space(axis_j, ext_j, cart=cart_ij)
+
+                cart = InterfaceCartDecomposition(cart_ij._cart_minus, cart_ij._cart_plus,
+                                                  cart_ij._comm, [axis_i, axis_j], [ext_i, ext_j],
+                                                  [cart_ij.ranks_in_topo_minus, cart_ij.ranks_in_topo_plus],
+                                                  [cart_ij._local_group_minus, cart_ij._local_group_plus],
+                                                  [cart_ij._local_comm_minus, cart_ij._local_comm_plus],
+                                                  [cart_ij._root_rank_minus, cart_ij._root_rank_plus],
+                                                  [], reduce_elements=True)
+
+                cart.set_interface_communication_infos(get_minus_starts_ends, get_plus_starts_ends)
+                max_ncells = tuple(max(ni,nj) for ni,nj in zip(Vi.ncells,Vj.ncells))
+                Vi.get_refined_space(max_ncells).create_interface_space(axis_i, ext_i, cart=cart)
+                Vj.get_refined_space(max_ncells).create_interface_space(axis_j, ext_j, cart=cart)
+        else:
+            if isinstance(reduced_spaces[patch_i], VectorFemSpace):
+                for Vi,Vj in zip(reduced_spaces[patch_i].spaces, reduced_spaces[patch_j].spaces):
+                    Vi.create_interface_space(axis_i, ext_i, cart=Vi.coeff_space.cart)
+                    Vj.create_interface_space(axis_j , ext_j , cart=Vj.coeff_space.cart)
+                    max_ncells = tuple(max(ni,nj) for ni,nj in zip(Vi.ncells,Vj.ncells))
+                    cart_i = Vi.get_refined_space(max_ncells).coeff_space.cart
+                    cart_j = Vj.get_refined_space(max_ncells).coeff_space.cart
+                    Vi.get_refined_space(max_ncells).create_interface_space(axis_i, ext_i, cart=cart_i)
+                    Vj.get_refined_space(max_ncells).create_interface_space(axis_j, ext_j, cart=cart_j)
+            else:
+                Vi = reduced_spaces[patch_i]
+                Vj = reduced_spaces[patch_j]
+                Vi.create_interface_space(axis_i, ext_i, cart=Vi.coeff_space.cart)
+                Vj.create_interface_space(axis_j , ext_j , cart=Vj.coeff_space.cart)
+                max_ncells = tuple(max(ni,nj) for ni,nj in zip(Vi.ncells,Vj.ncells))
+                cart_i = Vi.get_refined_space(max_ncells).coeff_space.cart
+                cart_j = Vj.get_refined_space(max_ncells).coeff_space.cart
+                Vi.get_refined_space(max_ncells).create_interface_space(axis_i, ext_i, cart=cart_i)
+                Vj.get_refined_space(max_ncells).create_interface_space(axis_j, ext_j, cart=cart_j)

feectools/fem/projectors.py

@@ -0,0 +1,160 @@
+import numpy as np
+
+from sympde.topology            import element_of
+from sympde.topology.space      import ScalarFunction
+from sympde.topology.mapping    import Mapping
+from sympde.calculus            import dot
+from sympde.expr.expr           import LinearForm, integral
+
+from feectools.api.settings        import PSYDAC_BACKENDS
+
+from feectools.linalg.kron         import KroneckerDenseMatrix
+from feectools.core.bsplines       import hrefinement_matrix
+from feectools.linalg.stencil      import StencilVectorSpace
+from feectools.fem.basic           import FemSpace
+
+__all__ = ('knots_to_insert', 'knot_insertion_projection_operator')
+
+def knots_to_insert(coarse_grid, fine_grid, tol=1e-14):
+    """ Compute the point difference between the fine grid and coarse grid."""
+#    assert len(coarse_grid)*2-2 == len(fine_grid)-1
+    indices1 =  (np.abs(fine_grid  [:,None] - coarse_grid) < tol).any(0)
+    indices2 = ~(np.abs(coarse_grid[:,None] - fine_grid  ) < tol).any(0)
+
+    intersection = coarse_grid[indices1]
+    T            = fine_grid[indices2]
+
+    assert abs(intersection-coarse_grid).max()<tol
+    return T
+
+
+def knot_insertion_projection_operator(domain, codomain):
+    """
+    Compute the projection operator based on the knot insertion technique.
+
+    Return a linear operator which projects an element of the domain to an
+    element of the codomain. Domain and codomain are scalar spline spaces over
+    a cuboid, built as the tensor product of 1D spline spaces. In particular,
+    domain and codomain have the same multi-degree (p1, p2, ...).
+
+    This function returns a LinearOperator K working at the level of the
+    spline coefficients, which are represented by StencilVector objects.
+
+    Thanks to the tensor-product structure of the spline spaces, the projection
+    operator is the Kronecker product of 1D projection operators K[i] operating
+    between 1D spaces. Each 1D operators is represented by a dense matrix:
+
+        K = K[0] x K[1] x ...
+
+    For each dimension i the 1D grids defined by the breakpoints of the two
+    spaces are assumed to be identical, or one nested into the other. Let nd[i]
+    and nc[i] be the number of cells along dimension i for domain and codomain,
+    respectively. We then have three different cases:
+
+    1. nd[i] == nc[i]:
+       The two 1D grids are assumed identical, and K[i] is the identity matrix.
+
+    2. nd[i] < nc[i]:
+       The 1D grid of the domain is assumed nested into the 1D grid of the
+       codomain, hence the 1D spline space of the domain is a subspace of the
+       1D spline space of the codomain. In this case we build K[i] using the
+       knot insertion algorithm.
+
+    3. nd[i] > nc[i]:
+       The 1D grid of the codomain is assumed nested into the 1D grid of the
+       domain, hence the 1D spline space of the codomain is a subspace of the
+       1D spline space of the domain. In this case we build K[i] as the
+       transpose of the matrix obtained using the knot insertion algorithm from
+       the codomain to the domain.
+
+    Parameters
+    ----------
+    domain : TensorFemSpace
+        Domain of the projection operator.
+
+    codomain : TensorFemSpace
+        Codomain of the projection operator.
+
+    Returns
+    -------
+    KroneckerDenseMatrix
+        Matrix representation of the projection operator. This is a
+        LinearOperator acting on the spline coefficients.
+
+    """
+    ops = []
+    for d, c in zip(domain.spaces, codomain.spaces):
+
+        if d.ncells > c.ncells:
+            Ts = knots_to_insert(c.breaks, d.breaks)
+            P  = hrefinement_matrix(Ts, c.degree, c.knots)
+
+            if d.basis == 'M':
+                assert c.basis == 'M'
+                P = np.diag(1 / d._scaling_array) @ P @ np.diag(c._scaling_array)
+
+            ops.append(P.T)
+
+        elif d.ncells < c.ncells:
+            Ts = knots_to_insert(d.breaks, c.breaks)
+            P  = hrefinement_matrix(Ts, d.degree, d.knots)
+
+            if d.basis == 'M':
+                assert c.basis == 'M'
+                P = np.diag(1 / c._scaling_array) @ P @ np.diag(d._scaling_array)
+
+            ops.append(P)
+
+        else:
+            ops.append(np.eye(d.nbasis))
+
+    return KroneckerDenseMatrix(domain.coeff_space, codomain.coeff_space, *ops)
+
+
+def get_dual_dofs(Vh, f, domain_h, backend_language="python", return_format='stencil_array'):
+    """
+    return the dual dofs tilde_sigma_i(f) = < Lambda_i, f >_{L2} i = 1, .. dim(Vh)) of a given function f, as a stencil array or numpy array
+
+    Parameters
+    ----------
+    Vh : FemSpace
+        The discrete space for the dual dofs
+
+    f : <sympy.Expr>
+        The function used for evaluation
+
+    domain_h : 
+        The discrete domain corresponding to Vh
+
+    backend_language: <str>
+        The backend used to accelerate the code
+
+    return_format: <str>
+        The format of the dofs, can be 'stencil_array' or 'numpy_array'
+
+    Returns
+    -------
+    tilde_f: <Vector|ndarray>
+        The dual dofs
+    """
+
+    from feectools.api.discretization  import discretize 
+
+    assert isinstance(Vh, FemSpace)
+
+    V  = Vh.symbolic_space
+    v  = element_of(V, name='v')
+
+    if Vh.is_vector_valued: 
+        expr   = dot(f,v)
+    else:
+        expr   = f*v
+
+    l        = LinearForm(v, integral( V.domain, expr))
+    lh       = discretize(l, domain_h, Vh, backend=PSYDAC_BACKENDS[backend_language])
+    tilde_f  = lh.assemble()
+
+    if return_format == 'numpy_array':
+        return tilde_f.toarray()
+    else:
+        return tilde_f