Add documentation to DiscreteDerham

psydac/api/discretization.py

@@ -100,6 +100,12 @@ def discretize_derham(derham, domain_h, get_H1vec_space = False, *args, **kwargs
 
     **kwargs : list
         optional parameters for the space discretization
+
+    Returns
+    -------
+      : DiscreteDerham
+      The discrete De Rham sequence containing the discrete spaces, 
+      differential operators and projectors
     """
 
     ldim    = derham.shape

psydac/api/feec.py

@@ -86,51 +86,88 @@ def __init__(self, mapping, *spaces):
     #--------------------------------------------------------------------------
     @property
     def dim(self):
+        """dimension of the physical and logical space"""
         return self._dim
 
     @property
     def V0(self):
+        """First space of the De Rham sequence : H1 space"""
         return self._spaces[0]
 
     @property
     def V1(self):
+        """Second space of the De Rham sequence :
+        1d : L2 space
+        2d : either Hdiv or Hcurl space
+        3d : Hcurl space"""
         return self._spaces[1]
 
     @property
     def V2(self):
+        """Third space of the De Rham sequence :
+        2d : L2 space
+        3d : Hdiv space"""
         return self._spaces[2]
 
     @property
     def V3(self):
+        """Fourth space of the De Rham sequence : L2 space in 3d"""
         return self._spaces[3]
 
     @property
     def H1vec(self):
+        """Vectorial H1 space built has cartesian product of V0"""
         assert self.has_vec
         return self._H1vec
 
     @property
     def spaces(self):
+        """Spaces of the proper de Rham sequence (excluding Hvec)"""
         return self._spaces
 
     @property
     def mapping(self):
+        """The mapping from the logical space to the physical space of the discrete De Rham."""
         return self._mapping
 
     @property
     def callable_mapping(self):
+        """The mapping as a callable"""
         return self._callable_mapping
 
     @property
     def derivatives_as_matrices(self):
+        """Differential operators of the De Rham sequence as BlockLinearOperator"""
         return tuple(V.diff.matrix for V in self.spaces[:-1])
 
     @property
     def derivatives_as_operators(self):
+        """Differential operators of the De Rham sequence as DiffOperator"""
         return tuple(V.diff for V in self.spaces[:-1])
 
     #--------------------------------------------------------------------------
     def projectors(self, *, kind='global', nquads=None):
+        """Projectors mapping callable to FemFields of the De Rham sequence.
+
+        Parameters
+        ----------
+
+        kind : str
+            Type of the projection : at the moment, only global is accepted and
+            returns commuting projectors based on interpolation/histopolation 
+            for the De Rham sequence (GlobalProjector objects)
+
+        nquads : list(int) | tuple(int)
+            Number of quadrature points along each direction, to be used in Gauss
+            quadrature rule for computing the (approximated) degrees of freedom.
+
+        Returns
+        -------
+        P0, ..., Pn : callables
+            Projectors that can be called on any callable function that maps 
+            from the physical space to R (scalar case) or R^d (vector case) and
+            returns a FemField belonging to the i-th space of the De Rham sequence
+            """
 
         if not (kind == 'global'):
             raise NotImplementedError('only global projectors are available')