Refactor tests to reduce use of output

interface/ceed-basis.c

@@ -551,10 +551,9 @@ int CeedBasisCreateTensorH1Lagrange(Ceed ceed, CeedInt dim, CeedInt num_comp,
       c1 = c2;
     }
   }
-  //  // Pass to CeedBasisCreateTensorH1
+  // Pass to CeedBasisCreateTensorH1
   ierr = CeedBasisCreateTensorH1(ceed, dim, num_comp, P, Q, interp_1d, grad_1d,
-                                 q_ref_1d,
-                                 q_weight_1d, basis); CeedChk(ierr);
+                                 q_ref_1d, q_weight_1d, basis); CeedChk(ierr);
 cleanup:
   ierr2 = CeedFree(&interp_1d); CeedChk(ierr2);
   ierr2 = CeedFree(&grad_1d); CeedChk(ierr2);

interface/ceed-fortran.c

@@ -552,6 +552,15 @@ void fCeedQRFactorization(int *ceed, CeedScalar *mat, CeedScalar *tau, int *m,
   *err = CeedQRFactorization(Ceed_dict[*ceed], mat, tau, *m, *n);
 }
 
+#define fCeedHouseholderApplyQ \
+    FORTRAN_NAME(ceedhouseholderapplyq, CEEDHOUSEHOLDERAPPLYQ)
+void fCeedHouseholderApplyQ(CeedScalar *A, CeedScalar *Q, CeedScalar *tau,
+                            int *t_mode,
+                            int *m, int *n, int *k, int *row, int *col, int *err) {
+  *err = CeedHouseholderApplyQ(A, Q, tau, (CeedTransposeMode)*t_mode, *m, *n, *k,
+                               *row, *col);
+}
+
 #define fCeedSymmetricSchurDecomposition \
     FORTRAN_NAME(ceedsymmetricschurdecomposition, CEEDSYMMETRICSCHURDECOMPOSITION)
 void fCeedSymmetricSchurDecomposition(int *ceed, CeedScalar *mat,
@@ -607,6 +616,26 @@ void fCeedBasisGetInterp1D(int *basis, CeedScalar *interp_1d, int64_t *offset,
   *offset = interp1d_ - interp_1d;
 }
 
+#define fCeedBasisGetGrad1D \
+    FORTRAN_NAME(ceedbasisgetgrad1d, CEEDBASISGETGRAD1D)
+void fCeedBasisGetGrad1D(int *basis, CeedScalar *grad_1d, int64_t *offset,
+                         int *err) {
+  const CeedScalar *grad1d_;
+  CeedBasis basis_ = CeedBasis_dict[*basis];
+  *err = CeedBasisGetGrad1D(basis_, &grad1d_);
+  *offset = grad1d_ - grad_1d;
+}
+
+#define fCeedBasisGetQRef \
+    FORTRAN_NAME(ceedbasisgetqref, CEEDBASISGETQREF)
+void fCeedBasisGetQRef(int *basis, CeedScalar *q_ref, int64_t *offset,
+                       int *err) {
+  const CeedScalar *qref_;
+  CeedBasis basis_ = CeedBasis_dict[*basis];
+  *err = CeedBasisGetQRef(basis_, &qref_);
+  *offset = qref_ - q_ref;
+}
+
 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY)
 void fCeedBasisDestroy(int *basis, int *err) {
   if (*basis == FORTRAN_NULL) return;

python/build_ceed_cffi.py

@@ -36,6 +36,7 @@
     header = '\n'.join(lines)
     header = header.split("static inline CeedInt CeedIntPow", 1)[0]
     header += '\nextern int CeedVectorGetState(CeedVector, uint64_t*);'
+    header += '\nextern int CeedElemRestrictionGetELayout(CeedElemRestriction, CeedInt *layout);'
     # Note: cffi cannot handle vargs
     header = re.sub("va_list", "const char *", header)
 ffibuilder.cdef(header)

python/ceed_elemrestriction.py

@@ -131,6 +131,29 @@ def get_multiplicity(self):
         # Return
         return mult
 
+    # Get ElemRestrition Layout
+    def get_layout(self):
+        """Get the element vector layout of an ElemRestriction.
+
+           Returns:
+             layout: Vector containing layout array, stored as [nodes, components, elements].
+                     The data for node i, component j, element k in the element
+                     vector is given by i*layout[0] + j*layout[1] + k*layout[2]."""
+
+        # Create output array
+        layout = np.zeros(3, dtype="int32")
+        array_pointer = ffi.cast(
+            "CeedInt *",
+            layout.__array_interface__['data'][0])
+
+        # libCEED call
+        err_code = lib.CeedElemRestrictionGetELayout(
+            self._pointer[0], array_pointer)
+        self._ceed._check_error(err_code)
+
+        # Return
+        return layout
+
 # ------------------------------------------------------------------------------