xref: /libCEED/include/ceed/ceed.h (revision ca94c3ddc8f82b7d93a79f9e4812e99b8be840ff) 
1 /// Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors.
2 /// All Rights Reserved. See the top-level LICENSE and NOTICE files for details.
3 ///
4 /// SPDX-License-Identifier: BSD-2-Clause
5 ///
6 /// This file is part of CEED:  http://github.com/ceed
7 
8 /// @file
9 /// Public header for user and utility components of libCEED
10 #ifndef CEED_H
11 #define CEED_H
12 
13 /// @defgroup Ceed Ceed: core components
14 /// @defgroup CeedVector CeedVector: storing and manipulating vectors
15 /// @defgroup CeedElemRestriction CeedElemRestriction: restriction from local vectors to elements
16 /// @defgroup CeedBasis CeedBasis: fully discrete finite element-like objects
17 /// @defgroup CeedQFunction CeedQFunction: independent operations at quadrature points
18 /// @defgroup CeedOperator CeedOperator: composed FE-type operations on vectors
19 ///
20 /// @page FunctionCategories libCEED: Types of Functions libCEED provides three different header files depending upon the type of functions a user
21 /// requires.
22 /// @section Utility Utility Functions
23 ///    These functions are intended general utilities that may be useful to libCEED developers and users.
24 ///    These functions can generally be found in `"ceed.h"`.
25 /// @section User User Functions
26 ///    These functions are intended to be used by general users of libCEED and can generally be found in `"ceed.h"`.
27 /// @section Advanced Advanced Functions
28 ///    These functions are intended to be used by advanced users of libCEED and can generally be found in `"ceed.h"`.
29 /// @section Backend Backend Developer Functions
30 ///    These functions are intended to be used by backend developers of libCEED and can generally be found in `"ceed-backend.h"`.
31 /// @section Developer Library Developer Functions
32 ///    These functions are intended to be used by library developers of libCEED and can generally be found in `"ceed-impl.h"`.
33 
34 #if !defined(CEED_SKIP_VISIBILITY)
35 #define CEED_VISIBILITY(mode) __attribute__((visibility(#mode)))
36 #else
37 #define CEED_VISIBILITY(mode)
38 #endif
39 
40 /*
41   CEED_EXTERN is used in this header to denote all publicly visible symbols.
42 
43   No other file should declare publicly visible symbols, thus it should never be used outside `"ceed.h"`.
44 */
45 #if defined(__clang_analyzer__)
46 #define CEED_EXTERN extern
47 #elif defined(__cplusplus)
48 #define CEED_EXTERN extern "C" CEED_VISIBILITY(default)
49 #else
50 #define CEED_EXTERN extern CEED_VISIBILITY(default)
51 #endif
52 
53 #include <stdarg.h>
54 #include <stdbool.h>
55 #include <stdio.h>
56 
57 /*
58   Typedefs and macros used in public interfaces and user `CeedQFunction` source
59 */
60 #include "types.h"  // IWYU pragma: export
61 
62 /*
63   This line prevents IWYU from suggesting "ceed.h"
64 */
65 // IWYU pragma: private, include <ceed.h>
66 
67 /// Library context created by CeedInit()
68 /// @ingroup CeedUser
69 typedef struct Ceed_private *Ceed;
70 /// Non-blocking Ceed interfaces return a CeedRequest.
71 /// To perform an operation immediately, pass @ref CEED_REQUEST_IMMEDIATE instead.
72 /// @ingroup CeedUser
73 typedef struct CeedRequest_private *CeedRequest;
74 /// Handle for vectors over the field @ref CeedScalar
75 /// @ingroup CeedVectorUser
76 typedef struct CeedVector_private *CeedVector;
77 /// Handle for object describing restriction to elements
78 /// @ingroup CeedElemRestrictionUser
79 typedef struct CeedElemRestriction_private *CeedElemRestriction;
80 /// Handle for object describing discrete finite element evaluations
81 /// @ingroup CeedBasisUser
82 typedef struct CeedBasis_private *CeedBasis;
83 /// Handle for object describing CeedQFunction fields
84 /// @ingroup CeedQFunctionBackend
85 typedef struct CeedQFunctionField_private *CeedQFunctionField;
86 /// Handle for object describing functions evaluated independently at quadrature points
87 /// @ingroup CeedQFunctionUser
88 typedef struct CeedQFunction_private *CeedQFunction;
89 /// Handle for object describing CeedOperator fields
90 /// @ingroup CeedOperatorBackend
91 typedef struct CeedOperatorField_private *CeedOperatorField;
92 /// Handle for object describing context data for CeedQFunctions
93 /// @ingroup CeedQFunctionUser
94 typedef struct CeedQFunctionContext_private *CeedQFunctionContext;
95 /// Handle for object describing registered fields for CeedQFunctionContext
96 /// @ingroup CeedQFunctionUser
97 typedef struct CeedContextFieldLabel_private *CeedContextFieldLabel;
98 /// Handle for object describing FE-type operators acting on vectors
99 ///
100 /// Given an element restriction \f$E\f$, basis evaluator \f$B\f$, and quadrature function\f$f\f$, a `CeedOperator` expresses operations of the form \f$E^T B^T f(B E u)\f$ acting on the vector \f$u\f$.
101 /// @ingroup CeedOperatorUser
102 typedef struct CeedOperator_private *CeedOperator;
103 
104 CEED_EXTERN int CeedRegistryGetList(size_t *n, char ***const resources, CeedInt **array);
105 CEED_EXTERN int CeedInit(const char *resource, Ceed *ceed);
106 CEED_EXTERN int CeedSetStream(Ceed ceed, void *handle);
107 CEED_EXTERN int CeedReferenceCopy(Ceed ceed, Ceed *ceed_copy);
108 CEED_EXTERN int CeedGetResource(Ceed ceed, const char **resource);
109 CEED_EXTERN int CeedIsDeterministic(Ceed ceed, bool *is_deterministic);
110 CEED_EXTERN int CeedAddJitSourceRoot(Ceed ceed, const char *jit_source_root);
111 CEED_EXTERN int CeedView(Ceed ceed, FILE *stream);
112 CEED_EXTERN int CeedDestroy(Ceed *ceed);
113 CEED_EXTERN int CeedErrorImpl(Ceed ceed, const char *filename, int lineno, const char *func, int ecode, const char *format, ...);
114 
115 /// Raise an error on `Ceed` object
116 ///
117 /// @param ceed `Ceed` library context or `NULL`
118 /// @param ecode Error code (int)
119 /// @param ... printf-style format string followed by arguments as needed
120 ///
121 /// @ingroup Ceed
122 /// @sa CeedSetErrorHandler()
123 #define CeedError(ceed, ecode, ...) (CeedErrorImpl((ceed), __FILE__, __LINE__, __func__, (ecode), __VA_ARGS__), (ecode))
124 
125 /// Ceed error handlers
126 typedef int (*CeedErrorHandler)(Ceed, const char *, int, const char *, int, const char *, va_list *);
127 CEED_EXTERN int CeedSetErrorHandler(Ceed ceed, CeedErrorHandler handler);
128 CEED_EXTERN int CeedGetErrorMessage(Ceed ceed, const char **err_msg);
129 CEED_EXTERN int CeedResetErrorMessage(Ceed ceed, const char **err_msg);
130 CEED_EXTERN int CeedErrorReturn(Ceed ceed, const char *filename, int line_no, const char *func, int err_code, const char *format, va_list *args);
131 CEED_EXTERN int CeedErrorStore(Ceed ceed, const char *filename, int line_no, const char *func, int err_code, const char *format, va_list *args);
132 CEED_EXTERN int CeedErrorAbort(Ceed ceed, const char *filename, int line_no, const char *func, int err_code, const char *format, va_list *args);
133 CEED_EXTERN int CeedErrorExit(Ceed ceed, const char *filename, int line_no, const char *func, int err_code, const char *format, va_list *args);
134 
135 /// libCEED library version numbering
136 /// @ingroup Ceed
137 #define CEED_VERSION_MAJOR 0
138 #define CEED_VERSION_MINOR 12
139 #define CEED_VERSION_PATCH 0
140 #define CEED_VERSION_RELEASE false
141 
142 /// Compile-time check that the the current library version is at least as recent as the specified version.
143 /// This macro is typically used in
144 /// @code
145 /// #if CEED_VERSION_GE(0, 8, 0)
146 ///   code path that needs at least 0.8.0
147 /// #else
148 ///   fallback code for older versions
149 /// #endif
150 /// @endcode
151 ///
152 /// A non-release version always compares as positive infinity.
153 ///
154 /// @param major   Major version
155 /// @param minor   Minor version
156 /// @param patch   Patch (subminor) version
157 ///
158 /// @ingroup Ceed
159 /// @sa CeedGetVersion()
160 #define CEED_VERSION_GE(major, minor, patch) \
161   (!CEED_VERSION_RELEASE ||                  \
162    (CEED_VERSION_MAJOR > major ||            \
163     (CEED_VERSION_MAJOR == major && (CEED_VERSION_MINOR > minor || (CEED_VERSION_MINOR == minor && CEED_VERSION_PATCH >= patch)))))
164 
165 CEED_EXTERN int CeedGetVersion(int *major, int *minor, int *patch, bool *release);
166 
167 CEED_EXTERN int CeedGetScalarType(CeedScalarType *scalar_type);
168 
169 /// String names for enum pretty printing
170 CEED_EXTERN const char *const *CeedErrorTypes;
171 CEED_EXTERN const char *const  CeedMemTypes[];
172 CEED_EXTERN const char *const  CeedCopyModes[];
173 CEED_EXTERN const char *const  CeedTransposeModes[];
174 CEED_EXTERN const char *const  CeedEvalModes[];
175 CEED_EXTERN const char *const  CeedQuadModes[];
176 CEED_EXTERN const char *const  CeedElemTopologies[];
177 CEED_EXTERN const char *const  CeedContextFieldTypes[];
178 
179 CEED_EXTERN int CeedGetPreferredMemType(Ceed ceed, CeedMemType *type);
180 
181 CEED_EXTERN int CeedVectorCreate(Ceed ceed, CeedSize len, CeedVector *vec);
182 CEED_EXTERN int CeedVectorReferenceCopy(CeedVector vec, CeedVector *vec_copy);
183 CEED_EXTERN int CeedVectorCopy(CeedVector vec, CeedVector vec_copy);
184 CEED_EXTERN int CeedVectorSetArray(CeedVector vec, CeedMemType mem_type, CeedCopyMode copy_mode, CeedScalar *array);
185 CEED_EXTERN int CeedVectorSetValue(CeedVector vec, CeedScalar value);
186 CEED_EXTERN int CeedVectorSyncArray(CeedVector vec, CeedMemType mem_type);
187 CEED_EXTERN int CeedVectorTakeArray(CeedVector vec, CeedMemType mem_type, CeedScalar **array);
188 CEED_EXTERN int CeedVectorGetArray(CeedVector vec, CeedMemType mem_type, CeedScalar **array);
189 CEED_EXTERN int CeedVectorGetArrayRead(CeedVector vec, CeedMemType mem_type, const CeedScalar **array);
190 CEED_EXTERN int CeedVectorGetArrayWrite(CeedVector vec, CeedMemType mem_type, CeedScalar **array);
191 CEED_EXTERN int CeedVectorRestoreArray(CeedVector vec, CeedScalar **array);
192 CEED_EXTERN int CeedVectorRestoreArrayRead(CeedVector vec, const CeedScalar **array);
193 CEED_EXTERN int CeedVectorNorm(CeedVector vec, CeedNormType type, CeedScalar *norm);
194 CEED_EXTERN int CeedVectorScale(CeedVector x, CeedScalar alpha);
195 CEED_EXTERN int CeedVectorAXPY(CeedVector y, CeedScalar alpha, CeedVector x);
196 CEED_EXTERN int CeedVectorAXPBY(CeedVector y, CeedScalar alpha, CeedScalar beta, CeedVector x);
197 CEED_EXTERN int CeedVectorPointwiseMult(CeedVector w, CeedVector x, CeedVector y);
198 CEED_EXTERN int CeedVectorReciprocal(CeedVector vec);
199 CEED_EXTERN int CeedVectorViewRange(CeedVector vec, CeedSize start, CeedSize stop, CeedInt step, const char *fp_fmt, FILE *stream);
200 CEED_EXTERN int CeedVectorView(CeedVector vec, const char *fp_fmt, FILE *stream);
201 CEED_EXTERN int CeedVectorGetCeed(CeedVector vec, Ceed *ceed);
202 CEED_EXTERN int CeedVectorGetLength(CeedVector vec, CeedSize *length);
203 CEED_EXTERN int CeedVectorDestroy(CeedVector *vec);
204 
205 CEED_EXTERN CeedRequest *const CEED_REQUEST_IMMEDIATE;
206 CEED_EXTERN CeedRequest *const CEED_REQUEST_ORDERED;
207 CEED_EXTERN int                CeedRequestWait(CeedRequest *req);
208 
209 /// Argument for @ref CeedOperatorSetField() to use active input or output.
210 /// @ingroup CeedVector
211 CEED_EXTERN const CeedVector CEED_VECTOR_ACTIVE;
212 
213 /// Argument for @ref CeedOperatorSetField() to use no `CeedVector`.
214 /// Only use this option with @ref CeedEvalMode @ref CEED_EVAL_WEIGHT.
215 /// @ingroup CeedVector
216 CEED_EXTERN const CeedVector CEED_VECTOR_NONE;
217 
218 /// Argument for @ref CeedOperatorSetField() that no basis operation is needed to translate between the E-vector and the Q-vector.
219 /// Only use this option with @ref CeedEvalMode @ref CEED_EVAL_NONE.
220 /// @ingroup CeedBasis
221 CEED_EXTERN const CeedBasis CEED_BASIS_NONE;
222 
223 CEED_EXTERN const CeedBasis CEED_BASIS_COLLOCATED;
224 
225 /// Argument for @ref CeedOperatorSetField() to use no `CeedElemRestriction`.
226 /// Only use this option with @ref CeedEvalMode @ref CEED_EVAL_WEIGHT.
227 /// @ingroup CeedElemRestriction
228 CEED_EXTERN const CeedElemRestriction CEED_ELEMRESTRICTION_NONE;
229 
230 /// Argument for @ref CeedOperatorCreate() that `CeedQFunction` is not created by user.
231 /// Only used for `CeedQFunction` `dqf` and `dqfT`.
232 /// If implemented, a backend may attempt to provide the action of these `CeedQFunction`.
233 /// @ingroup CeedQFunction
234 CEED_EXTERN const CeedQFunction CEED_QFUNCTION_NONE;
235 
236 /// Argument for @ref CeedElemRestrictionCreateStrided() that L-vector is in the Ceed backend's preferred layout.
237 /// This argument should only be used with vectors created by a Ceed backend.
238 /// @ingroup CeedElemRestriction
239 CEED_EXTERN const CeedInt CEED_STRIDES_BACKEND[3];
240 
241 CEED_EXTERN int CeedElemRestrictionCreate(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt num_comp, CeedInt comp_stride, CeedSize l_size,
242                                           CeedMemType mem_type, CeedCopyMode copy_mode, const CeedInt *offsets, CeedElemRestriction *rstr);
243 CEED_EXTERN int CeedElemRestrictionCreateOriented(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt num_comp, CeedInt comp_stride,
244                                                   CeedSize l_size, CeedMemType mem_type, CeedCopyMode copy_mode, const CeedInt *offsets,
245                                                   const bool *orients, CeedElemRestriction *rstr);
246 CEED_EXTERN int CeedElemRestrictionCreateCurlOriented(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt num_comp, CeedInt comp_stride,
247                                                       CeedSize l_size, CeedMemType mem_type, CeedCopyMode copy_mode, const CeedInt *offsets,
248                                                       const CeedInt8 *curl_orients, CeedElemRestriction *rstr);
249 CEED_EXTERN int CeedElemRestrictionCreateStrided(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt num_comp, CeedSize l_size,
250                                                  const CeedInt strides[3], CeedElemRestriction *rstr);
251 CEED_EXTERN int CeedElemRestrictionCreateAtPoints(Ceed ceed, CeedInt num_elem, CeedInt num_points, CeedInt num_comp, CeedSize l_size,
252                                                   CeedMemType mem_type, CeedCopyMode copy_mode, const CeedInt *offsets, CeedElemRestriction *rstr);
253 CEED_EXTERN int CeedElemRestrictionCreateBlocked(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt block_size, CeedInt num_comp,
254                                                  CeedInt comp_stride, CeedSize l_size, CeedMemType mem_type, CeedCopyMode copy_mode,
255                                                  const CeedInt *offsets, CeedElemRestriction *rstr);
256 CEED_EXTERN int CeedElemRestrictionCreateBlockedOriented(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt block_size, CeedInt num_comp,
257                                                          CeedInt comp_stride, CeedSize l_size, CeedMemType mem_type, CeedCopyMode copy_mode,
258                                                          const CeedInt *offsets, const bool *orients, CeedElemRestriction *rstr);
259 CEED_EXTERN int CeedElemRestrictionCreateBlockedCurlOriented(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt block_size, CeedInt num_comp,
260                                                              CeedInt comp_stride, CeedSize l_size, CeedMemType mem_type, CeedCopyMode copy_mode,
261                                                              const CeedInt *offsets, const CeedInt8 *curl_orients, CeedElemRestriction *rstr);
262 CEED_EXTERN int CeedElemRestrictionCreateBlockedStrided(Ceed ceed, CeedInt num_elem, CeedInt elem_size, CeedInt block_size, CeedInt num_comp,
263                                                         CeedSize l_size, const CeedInt strides[3], CeedElemRestriction *rstr);
264 CEED_EXTERN int CeedElemRestrictionCreateUnsignedCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_unsigned);
265 CEED_EXTERN int CeedElemRestrictionCreateUnorientedCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_unoriented);
266 CEED_EXTERN int CeedElemRestrictionReferenceCopy(CeedElemRestriction rstr, CeedElemRestriction *rstr_copy);
267 CEED_EXTERN int CeedElemRestrictionCreateVector(CeedElemRestriction rstr, CeedVector *lvec, CeedVector *evec);
268 CEED_EXTERN int CeedElemRestrictionApply(CeedElemRestriction rstr, CeedTransposeMode t_mode, CeedVector u, CeedVector ru, CeedRequest *request);
269 CEED_EXTERN int CeedElemRestrictionApplyAtPointsInElement(CeedElemRestriction rstr, CeedInt elem, CeedTransposeMode t_mode, CeedVector u,
270                                                           CeedVector ru, CeedRequest *request);
271 CEED_EXTERN int CeedElemRestrictionApplyBlock(CeedElemRestriction rstr, CeedInt block, CeedTransposeMode t_mode, CeedVector u, CeedVector ru,
272                                               CeedRequest *request);
273 CEED_EXTERN int CeedElemRestrictionGetCeed(CeedElemRestriction rstr, Ceed *ceed);
274 CEED_EXTERN int CeedElemRestrictionGetCompStride(CeedElemRestriction rstr, CeedInt *comp_stride);
275 CEED_EXTERN int CeedElemRestrictionGetNumElements(CeedElemRestriction rstr, CeedInt *num_elem);
276 CEED_EXTERN int CeedElemRestrictionGetElementSize(CeedElemRestriction rstr, CeedInt *elem_size);
277 CEED_EXTERN int CeedElemRestrictionGetNumPoints(CeedElemRestriction rstr, CeedInt *num_points);
278 CEED_EXTERN int CeedElemRestrictionGetNumPointsInElement(CeedElemRestriction rstr, CeedInt elem, CeedInt *num_points);
279 CEED_EXTERN int CeedElemRestrictionGetMaxPointsInElement(CeedElemRestriction rstr, CeedInt *max_points);
280 CEED_EXTERN int CeedElemRestrictionGetLVectorSize(CeedElemRestriction rstr, CeedSize *l_size);
281 CEED_EXTERN int CeedElemRestrictionGetNumComponents(CeedElemRestriction rstr, CeedInt *num_comp);
282 CEED_EXTERN int CeedElemRestrictionGetNumBlocks(CeedElemRestriction rstr, CeedInt *num_block);
283 CEED_EXTERN int CeedElemRestrictionGetBlockSize(CeedElemRestriction rstr, CeedInt *block_size);
284 CEED_EXTERN int CeedElemRestrictionGetMultiplicity(CeedElemRestriction rstr, CeedVector mult);
285 CEED_EXTERN int CeedElemRestrictionView(CeedElemRestriction rstr, FILE *stream);
286 CEED_EXTERN int CeedElemRestrictionDestroy(CeedElemRestriction *rstr);
287 
288 // The formalism here is that we have the structure
289 //  \int_\Omega v^T f_0(u, \nabla u, qdata) + (\nabla v)^T f_1(u, \nabla u, qdata)
290 // where gradients are with respect to the reference element.
291 
292 CEED_EXTERN int CeedBasisCreateTensorH1Lagrange(Ceed ceed, CeedInt dim, CeedInt num_comp, CeedInt P, CeedInt Q, CeedQuadMode quad_mode,
293                                                 CeedBasis *basis);
294 CEED_EXTERN int CeedBasisCreateTensorH1(Ceed ceed, CeedInt dim, CeedInt num_comp, CeedInt P_1d, CeedInt Q_1d, const CeedScalar *interp_1d,
295                                         const CeedScalar *grad_1d, const CeedScalar *q_ref_1d, const CeedScalar *q_weight_1d, CeedBasis *basis);
296 CEED_EXTERN int CeedBasisCreateH1(Ceed ceed, CeedElemTopology topo, CeedInt num_comp, CeedInt num_nodes, CeedInt nqpts, const CeedScalar *interp,
297                                   const CeedScalar *grad, const CeedScalar *q_ref, const CeedScalar *q_weights, CeedBasis *basis);
298 CEED_EXTERN int CeedBasisCreateHdiv(Ceed ceed, CeedElemTopology topo, CeedInt num_comp, CeedInt num_nodes, CeedInt nqpts, const CeedScalar *interp,
299                                     const CeedScalar *div, const CeedScalar *q_ref, const CeedScalar *q_weights, CeedBasis *basis);
300 CEED_EXTERN int CeedBasisCreateHcurl(Ceed ceed, CeedElemTopology topo, CeedInt num_comp, CeedInt num_nodes, CeedInt nqpts, const CeedScalar *interp,
301                                      const CeedScalar *curl, const CeedScalar *q_ref, const CeedScalar *q_weights, CeedBasis *basis);
302 CEED_EXTERN int CeedBasisCreateProjection(CeedBasis basis_from, CeedBasis basis_to, CeedBasis *basis_project);
303 CEED_EXTERN int CeedBasisReferenceCopy(CeedBasis basis, CeedBasis *basis_copy);
304 CEED_EXTERN int CeedBasisView(CeedBasis basis, FILE *stream);
305 CEED_EXTERN int CeedBasisApply(CeedBasis basis, CeedInt num_elem, CeedTransposeMode t_mode, CeedEvalMode eval_mode, CeedVector u, CeedVector v);
306 CEED_EXTERN int CeedBasisApplyAtPoints(CeedBasis basis, CeedInt num_points, CeedTransposeMode t_mode, CeedEvalMode eval_mode, CeedVector x_ref,
307                                        CeedVector u, CeedVector v);
308 CEED_EXTERN int CeedBasisGetCeed(CeedBasis basis, Ceed *ceed);
309 CEED_EXTERN int CeedBasisGetDimension(CeedBasis basis, CeedInt *dim);
310 CEED_EXTERN int CeedBasisGetTopology(CeedBasis basis, CeedElemTopology *topo);
311 CEED_EXTERN int CeedBasisGetNumComponents(CeedBasis basis, CeedInt *num_comp);
312 CEED_EXTERN int CeedBasisGetNumNodes(CeedBasis basis, CeedInt *P);
313 CEED_EXTERN int CeedBasisGetNumNodes1D(CeedBasis basis, CeedInt *P_1d);
314 CEED_EXTERN int CeedBasisGetNumQuadraturePoints(CeedBasis basis, CeedInt *Q);
315 CEED_EXTERN int CeedBasisGetNumQuadraturePoints1D(CeedBasis basis, CeedInt *Q_1d);
316 CEED_EXTERN int CeedBasisGetQRef(CeedBasis basis, const CeedScalar **q_ref);
317 CEED_EXTERN int CeedBasisGetQWeights(CeedBasis basis, const CeedScalar **q_weights);
318 CEED_EXTERN int CeedBasisGetInterp(CeedBasis basis, const CeedScalar **interp);
319 CEED_EXTERN int CeedBasisGetInterp1D(CeedBasis basis, const CeedScalar **interp_1d);
320 CEED_EXTERN int CeedBasisGetGrad(CeedBasis basis, const CeedScalar **grad);
321 CEED_EXTERN int CeedBasisGetGrad1D(CeedBasis basis, const CeedScalar **grad_1d);
322 CEED_EXTERN int CeedBasisGetDiv(CeedBasis basis, const CeedScalar **div);
323 CEED_EXTERN int CeedBasisGetCurl(CeedBasis basis, const CeedScalar **curl);
324 CEED_EXTERN int CeedBasisDestroy(CeedBasis *basis);
325 
326 CEED_EXTERN int CeedGaussQuadrature(CeedInt Q, CeedScalar *q_ref_1d, CeedScalar *q_weight_1d);
327 CEED_EXTERN int CeedLobattoQuadrature(CeedInt Q, CeedScalar *q_ref_1d, CeedScalar *q_weight_1d);
328 
329 /** Handle for the user provided `CeedQFunction` callback function
330 
331  @param[in,out] ctx User-defined context set using @ref CeedQFunctionSetContext() or `NULL`
332  @param[in] Q       Number of quadrature points at which to evaluate
333  @param[in] in      Array of pointers to each input argument in the order provided by the user in @ref CeedQFunctionAddInput().
334                       Each array has shape `[dim, num_comp, Q]` where `dim` is the geometric dimension for @ref CEED_EVAL_GRAD (`dim=1` for @ref CEED_EVAL_INTERP) and `num_comp` is the number of field components (`num_comp=1` for scalar fields).
335                       This results in indexing the `i`th input at quadrature point `j` as `in[i][(d*num_comp + c)*Q + j]`.
336  @param[out]   out  Array of pointers to each output array in the order provided using @ref CeedQFunctionAddOutput().
337                       The shapes are as above for `in`.
338 
339  @return An error code: 0 - success, otherwise - failure
340 
341  @ingroup CeedQFunction
342 **/
343 typedef int (*CeedQFunctionUser)(void *ctx, const CeedInt Q, const CeedScalar *const *in, CeedScalar *const *out);
344 
345 CEED_EXTERN int CeedQFunctionCreateInterior(Ceed ceed, CeedInt vec_length, CeedQFunctionUser f, const char *source, CeedQFunction *qf);
346 CEED_EXTERN int CeedQFunctionCreateInteriorByName(Ceed ceed, const char *name, CeedQFunction *qf);
347 CEED_EXTERN int CeedQFunctionCreateIdentity(Ceed ceed, CeedInt size, CeedEvalMode in_mode, CeedEvalMode out_mode, CeedQFunction *qf);
348 CEED_EXTERN int CeedQFunctionReferenceCopy(CeedQFunction qf, CeedQFunction *qf_copy);
349 CEED_EXTERN int CeedQFunctionAddInput(CeedQFunction qf, const char *field_name, CeedInt size, CeedEvalMode eval_mode);
350 CEED_EXTERN int CeedQFunctionAddOutput(CeedQFunction qf, const char *field_name, CeedInt size, CeedEvalMode eval_mode);
351 CEED_EXTERN int CeedQFunctionGetFields(CeedQFunction qf, CeedInt *num_input_fields, CeedQFunctionField **input_fields, CeedInt *num_output_fields,
352                                        CeedQFunctionField **output_fields);
353 CEED_EXTERN int CeedQFunctionSetContext(CeedQFunction qf, CeedQFunctionContext ctx);
354 CEED_EXTERN int CeedQFunctionSetContextWritable(CeedQFunction qf, bool is_writable);
355 CEED_EXTERN int CeedQFunctionSetUserFlopsEstimate(CeedQFunction qf, CeedSize flops);
356 CEED_EXTERN int CeedQFunctionView(CeedQFunction qf, FILE *stream);
357 CEED_EXTERN int CeedQFunctionGetCeed(CeedQFunction qf, Ceed *ceed);
358 CEED_EXTERN int CeedQFunctionApply(CeedQFunction qf, CeedInt Q, CeedVector *u, CeedVector *v);
359 CEED_EXTERN int CeedQFunctionDestroy(CeedQFunction *qf);
360 
361 CEED_EXTERN int CeedQFunctionFieldGetName(CeedQFunctionField qf_field, char **field_name);
362 CEED_EXTERN int CeedQFunctionFieldGetSize(CeedQFunctionField qf_field, CeedInt *size);
363 CEED_EXTERN int CeedQFunctionFieldGetEvalMode(CeedQFunctionField qf_field, CeedEvalMode *eval_mode);
364 
365 /** Handle for the user provided @ref CeedQFunctionContextDestroy() callback function
366 
367  @param[in,out] data  User `CeedQFunctionContext` data
368 
369  @return An error code: 0 - success, otherwise - failure
370 
371  @ingroup CeedQFunction
372 **/
373 typedef int (*CeedQFunctionContextDataDestroyUser)(void *data);
374 
375 CEED_EXTERN int CeedQFunctionContextCreate(Ceed ceed, CeedQFunctionContext *ctx);
376 CEED_EXTERN int CeedQFunctionContextReferenceCopy(CeedQFunctionContext ctx, CeedQFunctionContext *ctx_copy);
377 CEED_EXTERN int CeedQFunctionContextSetData(CeedQFunctionContext ctx, CeedMemType mem_type, CeedCopyMode copy_mode, size_t size, void *data);
378 CEED_EXTERN int CeedQFunctionContextTakeData(CeedQFunctionContext ctx, CeedMemType mem_type, void *data);
379 CEED_EXTERN int CeedQFunctionContextGetData(CeedQFunctionContext ctx, CeedMemType mem_type, void *data);
380 CEED_EXTERN int CeedQFunctionContextGetDataRead(CeedQFunctionContext ctx, CeedMemType mem_type, void *data);
381 CEED_EXTERN int CeedQFunctionContextRestoreData(CeedQFunctionContext ctx, void *data);
382 CEED_EXTERN int CeedQFunctionContextRestoreDataRead(CeedQFunctionContext ctx, void *data);
383 CEED_EXTERN int CeedQFunctionContextRegisterDouble(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values,
384                                                    const char *field_description);
385 CEED_EXTERN int CeedQFunctionContextRegisterInt32(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values,
386                                                   const char *field_description);
387 CEED_EXTERN int CeedQFunctionContextRegisterBoolean(CeedQFunctionContext ctx, const char *field_name, size_t field_offset, size_t num_values,
388                                                     const char *field_description);
389 CEED_EXTERN int CeedQFunctionContextGetAllFieldLabels(CeedQFunctionContext ctx, const CeedContextFieldLabel **field_labels, CeedInt *num_fields);
390 CEED_EXTERN int CeedContextFieldLabelGetDescription(CeedContextFieldLabel label, const char **field_name, size_t *field_offset, size_t *num_values,
391                                                     const char **field_description, CeedContextFieldType *field_type);
392 CEED_EXTERN int CeedQFunctionContextGetContextSize(CeedQFunctionContext ctx, size_t *ctx_size);
393 CEED_EXTERN int CeedQFunctionContextView(CeedQFunctionContext ctx, FILE *stream);
394 CEED_EXTERN int CeedQFunctionContextSetDataDestroy(CeedQFunctionContext ctx, CeedMemType f_mem_type, CeedQFunctionContextDataDestroyUser f);
395 CEED_EXTERN int CeedQFunctionContextDestroy(CeedQFunctionContext *ctx);
396 
397 CEED_EXTERN int CeedOperatorCreate(Ceed ceed, CeedQFunction qf, CeedQFunction dqf, CeedQFunction dqfT, CeedOperator *op);
398 CEED_EXTERN int CeedOperatorCreateAtPoints(Ceed ceed, CeedQFunction qf, CeedQFunction dqf, CeedQFunction dqfT, CeedOperator *op);
399 CEED_EXTERN int CeedCompositeOperatorCreate(Ceed ceed, CeedOperator *op);
400 CEED_EXTERN int CeedOperatorReferenceCopy(CeedOperator op, CeedOperator *op_copy);
401 CEED_EXTERN int CeedOperatorSetField(CeedOperator op, const char *field_name, CeedElemRestriction r, CeedBasis b, CeedVector v);
402 CEED_EXTERN int CeedOperatorGetFields(CeedOperator op, CeedInt *num_input_fields, CeedOperatorField **input_fields, CeedInt *num_output_fields,
403                                       CeedOperatorField **output_fields);
404 
405 CEED_EXTERN int CeedOperatorAtPointsSetPoints(CeedOperator op, CeedElemRestriction rstr_points, CeedVector point_coords);
406 CEED_EXTERN int CeedOperatorAtPointsGetPoints(CeedOperator op, CeedElemRestriction *rstr_points, CeedVector *point_coords);
407 CEED_EXTERN int CeedCompositeOperatorAddSub(CeedOperator composite_op, CeedOperator sub_op);
408 CEED_EXTERN int CeedCompositeOperatorGetNumSub(CeedOperator op, CeedInt *num_suboperators);
409 CEED_EXTERN int CeedCompositeOperatorGetSubList(CeedOperator op, CeedOperator **sub_operators);
410 CEED_EXTERN int CeedOperatorCheckReady(CeedOperator op);
411 CEED_EXTERN int CeedOperatorGetActiveVectorLengths(CeedOperator op, CeedSize *input_size, CeedSize *output_size);
412 CEED_EXTERN int CeedOperatorSetQFunctionAssemblyReuse(CeedOperator op, bool reuse_assembly_data);
413 CEED_EXTERN int CeedOperatorSetQFunctionAssemblyDataUpdateNeeded(CeedOperator op, bool needs_data_update);
414 CEED_EXTERN int CeedOperatorLinearAssembleQFunction(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request);
415 CEED_EXTERN int CeedOperatorLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr,
416                                                                  CeedRequest *request);
417 CEED_EXTERN int CeedOperatorLinearAssembleDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
418 CEED_EXTERN int CeedOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
419 CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
420 CEED_EXTERN int CeedOperatorLinearAssembleAddPointBlockDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
421 CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonalSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols);
422 CEED_EXTERN int CeedOperatorLinearAssembleSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols);
423 CEED_EXTERN int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values);
424 CEED_EXTERN int CeedCompositeOperatorGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult);
425 CEED_EXTERN int CeedOperatorMultigridLevelCreate(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse,
426                                                  CeedBasis basis_coarse, CeedOperator *op_coarse, CeedOperator *op_prolong,
427                                                  CeedOperator *op_restrict);
428 CEED_EXTERN int CeedOperatorMultigridLevelCreateTensorH1(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse,
429                                                          CeedBasis basis_coarse, const CeedScalar *interp_c_to_f, CeedOperator *op_coarse,
430                                                          CeedOperator *op_prolong, CeedOperator *op_restrict);
431 CEED_EXTERN int CeedOperatorMultigridLevelCreateH1(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse,
432                                                    CeedBasis basis_coarse, const CeedScalar *interp_c_to_f, CeedOperator *op_coarse,
433                                                    CeedOperator *op_prolong, CeedOperator *op_restrict);
434 CEED_EXTERN int CeedOperatorCreateFDMElementInverse(CeedOperator op, CeedOperator *fdm_inv, CeedRequest *request);
435 CEED_EXTERN int CeedOperatorSetName(CeedOperator op, const char *name);
436 CEED_EXTERN int CeedOperatorView(CeedOperator op, FILE *stream);
437 CEED_EXTERN int CeedOperatorGetCeed(CeedOperator op, Ceed *ceed);
438 CEED_EXTERN int CeedOperatorGetNumElements(CeedOperator op, CeedInt *num_elem);
439 CEED_EXTERN int CeedOperatorGetNumQuadraturePoints(CeedOperator op, CeedInt *num_qpts);
440 CEED_EXTERN int CeedOperatorGetFlopsEstimate(CeedOperator op, CeedSize *flops);
441 CEED_EXTERN int CeedOperatorGetContext(CeedOperator op, CeedQFunctionContext *ctx);
442 CEED_EXTERN int CeedOperatorGetContextFieldLabel(CeedOperator op, const char *field_name, CeedContextFieldLabel *field_label);
443 CEED_EXTERN int CeedOperatorSetContextDouble(CeedOperator op, CeedContextFieldLabel field_label, double *values);
444 CEED_EXTERN int CeedOperatorGetContextDoubleRead(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const double **values);
445 CEED_EXTERN int CeedOperatorRestoreContextDoubleRead(CeedOperator op, CeedContextFieldLabel field_label, const double **values);
446 CEED_EXTERN int CeedOperatorSetContextInt32(CeedOperator op, CeedContextFieldLabel field_label, int32_t *values);
447 CEED_EXTERN int CeedOperatorGetContextInt32Read(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const int32_t **values);
448 CEED_EXTERN int CeedOperatorRestoreContextInt32Read(CeedOperator op, CeedContextFieldLabel field_label, const int32_t **values);
449 CEED_EXTERN int CeedOperatorSetContextBoolean(CeedOperator op, CeedContextFieldLabel field_label, bool *values);
450 CEED_EXTERN int CeedOperatorGetContextBooleanRead(CeedOperator op, CeedContextFieldLabel field_label, size_t *num_values, const bool **values);
451 CEED_EXTERN int CeedOperatorRestoreContextBooleanRead(CeedOperator op, CeedContextFieldLabel field_label, const bool **values);
452 CEED_EXTERN int CeedOperatorApply(CeedOperator op, CeedVector in, CeedVector out, CeedRequest *request);
453 CEED_EXTERN int CeedOperatorApplyAdd(CeedOperator op, CeedVector in, CeedVector out, CeedRequest *request);
454 CEED_EXTERN int CeedOperatorDestroy(CeedOperator *op);
455 
456 CEED_EXTERN int CeedOperatorGetFieldByName(CeedOperator op, const char *field_name, CeedOperatorField *op_field);
457 CEED_EXTERN int CeedOperatorFieldGetName(CeedOperatorField op_field, char **field_name);
458 CEED_EXTERN int CeedOperatorFieldGetElemRestriction(CeedOperatorField op_field, CeedElemRestriction *rstr);
459 CEED_EXTERN int CeedOperatorFieldGetBasis(CeedOperatorField op_field, CeedBasis *basis);
460 CEED_EXTERN int CeedOperatorFieldGetVector(CeedOperatorField op_field, CeedVector *vec);
461 
462 /**
463   @brief Return integer power
464 
465   @param[in] base  The base to exponentiate
466   @param[in] power The power to raise the base to
467 
468   @return base^power
469 
470   @ref Utility
471 **/
472 static inline CeedInt CeedIntPow(CeedInt base, CeedInt power) {
473   CeedInt result = 1;
474   while (power) {
475     if (power & 1) result *= base;
476     power >>= 1;
477     base *= base;
478   }
479   return result;
480 }
481 
482 /**
483   @brief Return minimum of two integers
484 
485   @param[in] a The first integer to compare
486   @param[in] b The second integer to compare
487 
488   @return The minimum of the two integers
489 
490   @ref Utility
491 **/
492 static inline CeedInt CeedIntMin(CeedInt a, CeedInt b) { return a < b ? a : b; }
493 
494 /**
495   @brief Return maximum of two integers
496 
497   @param[in] a The first integer to compare
498   @param[in] b The second integer to compare
499 
500   @return The maximum of the two integers
501 
502   @ref Utility
503 **/
504 static inline CeedInt CeedIntMax(CeedInt a, CeedInt b) { return a > b ? a : b; }
505 
506 // Used to ensure initialization before CeedInit()
507 CEED_EXTERN int CeedRegisterAll(void);
508 // Used to ensure initialization before CeedQFunctionCreate*()
509 CEED_EXTERN int CeedQFunctionRegisterAll(void);
510 
511 #endif  // CEED_H
512