Update Julia/Python/Rust/Fortran bindings

Author: sebastiangrimberg

interface/ceed-fortran.c

@@ -449,6 +449,40 @@ CEED_EXTERN void fCeedBasisCreateH1(int *ceed, int *topo, int *num_comp, int *nn
   }
 }
 
+#define fCeedBasisCreateHdiv FORTRAN_NAME(ceedbasiscreatehdiv, CEEDBASISCREATEHDIV)
+CEED_EXTERN void fCeedBasisCreateHdiv(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *div,
+                                    const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) {
+  if (CeedBasis_count == CeedBasis_count_max) {
+    CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
+    CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
+  }
+
+  *err = CeedBasisCreateHdiv(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, div, qref, qweight,
+                           &CeedBasis_dict[CeedBasis_count]);
+
+  if (*err == 0) {
+    *basis = CeedBasis_count++;
+    CeedBasis_n++;
+  }
+}
+
+#define fCeedBasisCreateHcurl FORTRAN_NAME(ceedbasiscreatehcurl, CEEDBASISCREATEHCURL)
+CEED_EXTERN void fCeedBasisCreateHcurl(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *curl,
+                                    const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) {
+  if (CeedBasis_count == CeedBasis_count_max) {
+    CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
+    CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
+  }
+
+  *err = CeedBasisCreateHcurl(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, curl, qref, qweight,
+                           &CeedBasis_dict[CeedBasis_count]);
+
+  if (*err == 0) {
+    *basis = CeedBasis_count++;
+    CeedBasis_n++;
+  }
+}
+
 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW)
 CEED_EXTERN void fCeedBasisView(int *basis, int *err) { *err = CeedBasisView(CeedBasis_dict[*basis], stdout); }
 

julia/LibCEED.jl/src/generated/libceed_bindings.jl

@@ -389,14 +389,6 @@ function CeedBasisGetNumComponents(basis, num_comp)
     ccall((:CeedBasisGetNumComponents, libceed), Cint, (CeedBasis, Ptr{CeedInt}), basis, num_comp)
 end
 
-function CeedBasisGetNumQuadratureComponents(basis, q_comp)
-    ccall((:CeedBasisGetNumQuadratureComponents, libceed), Cint, (CeedBasis, Ptr{CeedInt}), basis, q_comp)
-end
-
-function CeedBasisGetNumCurlComponents(basis, curl_comp)
-    ccall((:CeedBasisGetNumCurlComponents, libceed), Cint, (CeedBasis, Ptr{CeedInt}), basis, curl_comp)
-end
-
 function CeedBasisGetNumNodes(basis, P)
     ccall((:CeedBasisGetNumNodes, libceed), Cint, (CeedBasis, Ptr{CeedInt}), basis, P)
 end
@@ -1034,6 +1026,10 @@ function CeedBasisReference(basis)
     ccall((:CeedBasisReference, libceed), Cint, (CeedBasis,), basis)
 end
 
+function CeedBasisGetNumQuadratureComponents(basis, eval_mode, q_comp)
+    ccall((:CeedBasisGetNumQuadratureComponents, libceed), Cint, (CeedBasis, CeedEvalMode, Ptr{CeedInt}), basis, eval_mode, q_comp)
+end
+
 function CeedBasisGetFlopsEstimate(basis, t_mode, eval_mode, flops)
     ccall((:CeedBasisGetFlopsEstimate, libceed), Cint, (CeedBasis, CeedTransposeMode, CeedEvalMode, Ptr{CeedSize}), basis, t_mode, eval_mode, flops)
 end
@@ -1062,6 +1058,10 @@ function CeedTensorContractApply(contract, A, B, C, J, t, t_mode, Add, u, v)
     ccall((:CeedTensorContractApply, libceed), Cint, (CeedTensorContract, CeedInt, CeedInt, CeedInt, CeedInt, Ptr{CeedScalar}, CeedTransposeMode, CeedInt, Ptr{CeedScalar}, Ptr{CeedScalar}), contract, A, B, C, J, t, t_mode, Add, u, v)
 end
 
+function CeedTensorContractStridedApply(contract, A, B, C, D, J, t, t_mode, add, u, v)
+    ccall((:CeedTensorContractStridedApply, libceed), Cint, (CeedTensorContract, CeedInt, CeedInt, CeedInt, CeedInt, CeedInt, Ptr{CeedScalar}, CeedTransposeMode, CeedInt, Ptr{CeedScalar}, Ptr{CeedScalar}), contract, A, B, C, D, J, t, t_mode, add, u, v)
+end
+
 function CeedTensorContractGetCeed(contract, ceed)
     ccall((:CeedTensorContractGetCeed, libceed), Cint, (CeedTensorContract, Ptr{Ceed}), contract, ceed)
 end

python/ceed_basis.py

@@ -339,6 +339,88 @@ def __init__(self, ceed, topo, ncomp, nnodes,
 # ------------------------------------------------------------------------------
 
 
+class BasisHdiv(Basis):
+    """Ceed Hdiv Basis: finite element non tensor-product basis for H(div) discretizations."""
+
+    # Constructor
+    def __init__(self, ceed, topo, ncomp, nnodes,
+                 nqpts, interp, grad, qref, qweight):
+
+        # Setup arguments
+        self._pointer = ffi.new("CeedBasis *")
+
+        self._ceed = ceed
+
+        interp_pointer = ffi.new("CeedScalar *")
+        interp_pointer = ffi.cast(
+            "CeedScalar *",
+            interp.__array_interface__['data'][0])
+
+        div_pointer = ffi.new("CeedScalar *")
+        div_pointer = ffi.cast(
+            "CeedScalar *",
+            grad.__array_interface__['data'][0])
+
+        qref_pointer = ffi.new("CeedScalar *")
+        qref_pointer = ffi.cast(
+            "CeedScalar *",
+            qref.__array_interface__['data'][0])
+
+        qweight_pointer = ffi.new("CeedScalar *")
+        qweight_pointer = ffi.cast(
+            "CeedScalar *",
+            qweight.__array_interface__['data'][0])
+
+        # libCEED call
+        err_code = lib.CeedBasisCreateHdiv(self._ceed._pointer[0], topo, ncomp,
+                                           nnodes, nqpts, interp_pointer,
+                                           div_pointer, qref_pointer,
+                                           qweight_pointer, self._pointer)
+
+# ------------------------------------------------------------------------------
+
+
+class BasisHcurl(Basis):
+    """Ceed Hcurl Basis: finite element non tensor-product basis for H(curl) discretizations."""
+
+    # Constructor
+    def __init__(self, ceed, topo, ncomp, nnodes,
+                 nqpts, interp, grad, qref, qweight):
+
+        # Setup arguments
+        self._pointer = ffi.new("CeedBasis *")
+
+        self._ceed = ceed
+
+        interp_pointer = ffi.new("CeedScalar *")
+        interp_pointer = ffi.cast(
+            "CeedScalar *",
+            interp.__array_interface__['data'][0])
+
+        curl_pointer = ffi.new("CeedScalar *")
+        curl_pointer = ffi.cast(
+            "CeedScalar *",
+            grad.__array_interface__['data'][0])
+
+        qref_pointer = ffi.new("CeedScalar *")
+        qref_pointer = ffi.cast(
+            "CeedScalar *",
+            qref.__array_interface__['data'][0])
+
+        qweight_pointer = ffi.new("CeedScalar *")
+        qweight_pointer = ffi.cast(
+            "CeedScalar *",
+            qweight.__array_interface__['data'][0])
+
+        # libCEED call
+        err_code = lib.CeedBasisCreateHcurl(self._ceed._pointer[0], topo, ncomp,
+                                            nnodes, nqpts, interp_pointer,
+                                            curl_pointer, qref_pointer,
+                                            qweight_pointer, self._pointer)
+
+# ------------------------------------------------------------------------------
+
+
 class TransposeBasis():
     """Transpose Ceed Basis: transpose of finite element tensor-product basis objects."""
 

rust/libceed/src/basis.rs

@@ -238,6 +238,84 @@ impl<'a> Basis<'a> {
         })
     }
 
+    pub fn create_Hdiv(
+        ceed: &crate::Ceed,
+        topo: crate::ElemTopology,
+        ncomp: usize,
+        nnodes: usize,
+        nqpts: usize,
+        interp: &[crate::Scalar],
+        div: &[crate::Scalar],
+        qref: &[crate::Scalar],
+        qweight: &[crate::Scalar],
+    ) -> crate::Result<Self> {
+        let mut ptr = std::ptr::null_mut();
+        let (topo, ncomp, nnodes, nqpts) = (
+            topo as bind_ceed::CeedElemTopology,
+            i32::try_from(ncomp).unwrap(),
+            i32::try_from(nnodes).unwrap(),
+            i32::try_from(nqpts).unwrap(),
+        );
+        let ierr = unsafe {
+            bind_ceed::CeedBasisCreateHdiv(
+                ceed.ptr,
+                topo,
+                ncomp,
+                nnodes,
+                nqpts,
+                interp.as_ptr(),
+                div.as_ptr(),
+                qref.as_ptr(),
+                qweight.as_ptr(),
+                &mut ptr,
+            )
+        };
+        ceed.check_error(ierr)?;
+        Ok(Self {
+            ptr,
+            _lifeline: PhantomData,
+        })
+    }
+
+    pub fn create_Hcurl(
+        ceed: &crate::Ceed,
+        topo: crate::ElemTopology,
+        ncomp: usize,
+        nnodes: usize,
+        nqpts: usize,
+        interp: &[crate::Scalar],
+        curl: &[crate::Scalar],
+        qref: &[crate::Scalar],
+        qweight: &[crate::Scalar],
+    ) -> crate::Result<Self> {
+        let mut ptr = std::ptr::null_mut();
+        let (topo, ncomp, nnodes, nqpts) = (
+            topo as bind_ceed::CeedElemTopology,
+            i32::try_from(ncomp).unwrap(),
+            i32::try_from(nnodes).unwrap(),
+            i32::try_from(nqpts).unwrap(),
+        );
+        let ierr = unsafe {
+            bind_ceed::CeedBasisCreateHcurl(
+                ceed.ptr,
+                topo,
+                ncomp,
+                nnodes,
+                nqpts,
+                interp.as_ptr(),
+                curl.as_ptr(),
+                qref.as_ptr(),
+                qweight.as_ptr(),
+                &mut ptr,
+            )
+        };
+        ceed.check_error(ierr)?;
+        Ok(Self {
+            ptr,
+            _lifeline: PhantomData,
+        })
+    }
+
     // Error handling
     #[doc(hidden)]
     fn check_error(&self, ierr: i32) -> crate::Result<i32> {