ceed-operator.c (38d0029a08e84b16bbdde77c27446234f5f09cf2) ceed-operator.c (7a982d89c751e293e39d23a7c44a161cef1fcd06)
1// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
2// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
3// reserved. See files LICENSE and NOTICE for details.
4//
5// This file is part of CEED, a collection of benchmarks, miniapps, software
6// libraries and APIs for efficient high-order finite element and spectral
7// element discretizations for exascale applications. For more information and
8// source code availability see http://github.com/ceed.

--- 6 unchanged lines hidden (view full) ---

15// testbed platforms, in support of the nation's exascale computing imperative.
16
17#include <ceed-impl.h>
18#include <ceed-backend.h>
19#include <string.h>
20#include <math.h>
21
22/// @file
1// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
2// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
3// reserved. See files LICENSE and NOTICE for details.
4//
5// This file is part of CEED, a collection of benchmarks, miniapps, software
6// libraries and APIs for efficient high-order finite element and spectral
7// element discretizations for exascale applications. For more information and
8// source code availability see http://github.com/ceed.

--- 6 unchanged lines hidden (view full) ---

15// testbed platforms, in support of the nation's exascale computing imperative.
16
17#include <ceed-impl.h>
18#include <ceed-backend.h>
19#include <string.h>
20#include <math.h>
21
22/// @file
23/// Implementation of public CeedOperator interfaces
24///
25/// @addtogroup CeedOperator
26/// @{
23/// Implementation of CeedOperator interfaces
27
24
25/// ----------------------------------------------------------------------------
26/// CeedOperator Library Internal Functions
27/// ----------------------------------------------------------------------------
28/// @addtogroup CeedOperatorDeveloper
29/// @{
30
28/**
31/**
32 @brief Duplicate a CeedOperator with a reference Ceed to fallback for advanced
33 CeedOperator functionality
34
35 @param op CeedOperator to create fallback for
36
37 @return An error code: 0 - success, otherwise - failure
38
39 @ref Developer
40**/
41int CeedOperatorCreateFallback(CeedOperator op) {
42 int ierr;
43
44 // Fallback Ceed
45 const char *resource, *fallbackresource;
46 ierr = CeedGetResource(op->ceed, &resource); CeedChk(ierr);
47 ierr = CeedGetOperatorFallbackResource(op->ceed, &fallbackresource);
48 CeedChk(ierr);
49 if (!strcmp(resource, fallbackresource))
50 // LCOV_EXCL_START
51 return CeedError(op->ceed, 1, "Backend %s cannot create an operator"
52 "fallback to resource %s", resource, fallbackresource);
53 // LCOV_EXCL_STOP
54
55 // Fallback Ceed
56 Ceed ceedref;
57 if (!op->ceed->opfallbackceed) {
58 ierr = CeedInit(fallbackresource, &ceedref); CeedChk(ierr);
59 ceedref->opfallbackparent = op->ceed;
60 op->ceed->opfallbackceed = ceedref;
61 }
62 ceedref = op->ceed->opfallbackceed;
63
64 // Clone Op
65 CeedOperator opref;
66 ierr = CeedCalloc(1, &opref); CeedChk(ierr);
67 memcpy(opref, op, sizeof(*opref)); CeedChk(ierr);
68 opref->data = NULL;
69 opref->setupdone = 0;
70 opref->ceed = ceedref;
71 ierr = ceedref->OperatorCreate(opref); CeedChk(ierr);
72 op->opfallback = opref;
73
74 // Clone QF
75 CeedQFunction qfref;
76 ierr = CeedCalloc(1, &qfref); CeedChk(ierr);
77 memcpy(qfref, (op->qf), sizeof(*qfref)); CeedChk(ierr);
78 qfref->data = NULL;
79 qfref->ceed = ceedref;
80 ierr = ceedref->QFunctionCreate(qfref); CeedChk(ierr);
81 opref->qf = qfref;
82 op->qffallback = qfref;
83
84 return 0;
85}
86
87/**
88 @brief Check if a CeedOperator is ready to be used.
89
90 @param[in] ceed Ceed object for error handling
91 @param[in] op CeedOperator to check
92
93 @return An error code: 0 - success, otherwise - failure
94
95 @ref Developer
96**/
97static int CeedOperatorCheckReady(Ceed ceed, CeedOperator op) {
98 CeedQFunction qf = op->qf;
99
100 if (op->composite) {
101 if (!op->numsub)
102 // LCOV_EXCL_START
103 return CeedError(ceed, 1, "No suboperators set");
104 // LCOV_EXCL_STOP
105 } else {
106 if (op->nfields == 0)
107 // LCOV_EXCL_START
108 return CeedError(ceed, 1, "No operator fields set");
109 // LCOV_EXCL_STOP
110 if (op->nfields < qf->numinputfields + qf->numoutputfields)
111 // LCOV_EXCL_START
112 return CeedError(ceed, 1, "Not all operator fields set");
113 // LCOV_EXCL_STOP
114 if (!op->hasrestriction)
115 // LCOV_EXCL_START
116 return CeedError(ceed, 1,"At least one restriction required");
117 // LCOV_EXCL_STOP
118 if (op->numqpoints == 0)
119 // LCOV_EXCL_START
120 return CeedError(ceed, 1,"At least one non-collocated basis required");
121 // LCOV_EXCL_STOP
122 }
123
124 return 0;
125}
126
127/**
128 @brief View a field of a CeedOperator
129
130 @param[in] field Operator field to view
131 @param[in] fieldnumber Number of field being viewed
132 @param[in] stream Stream to view to, e.g., stdout
133
134 @return An error code: 0 - success, otherwise - failure
135
136 @ref Utility
137**/
138static int CeedOperatorFieldView(CeedOperatorField field,
139 CeedQFunctionField qffield,
140 CeedInt fieldnumber, bool sub, bool in,
141 FILE *stream) {
142 const char *pre = sub ? " " : "";
143 const char *inout = in ? "Input" : "Output";
144
145 fprintf(stream, "%s %s Field [%d]:\n"
146 "%s Name: \"%s\"\n",
147 pre, inout, fieldnumber, pre, qffield->fieldname);
148
149 if (field->basis == CEED_BASIS_COLLOCATED)
150 fprintf(stream, "%s Collocated basis\n", pre);
151
152 if (field->vec == CEED_VECTOR_ACTIVE)
153 fprintf(stream, "%s Active vector\n", pre);
154 else if (field->vec == CEED_VECTOR_NONE)
155 fprintf(stream, "%s No vector\n", pre);
156
157 return 0;
158}
159
160/**
161 @brief View a single CeedOperator
162
163 @param[in] op CeedOperator to view
164 @param[in] sub Boolean flag for sub-operator
165 @param[in] stream Stream to write; typically stdout/stderr or a file
166
167 @return Error code: 0 - success, otherwise - failure
168
169 @ref Utility
170**/
171int CeedOperatorSingleView(CeedOperator op, bool sub, FILE *stream) {
172 int ierr;
173 const char *pre = sub ? " " : "";
174
175 CeedInt totalfields;
176 ierr = CeedOperatorGetNumArgs(op, &totalfields); CeedChk(ierr);
177
178 fprintf(stream, "%s %d Field%s\n", pre, totalfields, totalfields>1 ? "s" : "");
179
180 fprintf(stream, "%s %d Input Field%s:\n", pre, op->qf->numinputfields,
181 op->qf->numinputfields>1 ? "s" : "");
182 for (CeedInt i=0; i<op->qf->numinputfields; i++) {
183 ierr = CeedOperatorFieldView(op->inputfields[i], op->qf->inputfields[i],
184 i, sub, 1, stream); CeedChk(ierr);
185 }
186
187 fprintf(stream, "%s %d Output Field%s:\n", pre, op->qf->numoutputfields,
188 op->qf->numoutputfields>1 ? "s" : "");
189 for (CeedInt i=0; i<op->qf->numoutputfields; i++) {
190 ierr = CeedOperatorFieldView(op->outputfields[i], op->qf->inputfields[i],
191 i, sub, 0, stream); CeedChk(ierr);
192 }
193
194 return 0;
195}
196
197/// @}
198
199/// ----------------------------------------------------------------------------
200/// CeedOperator Backend API
201/// ----------------------------------------------------------------------------
202/// @addtogroup CeedOperatorBackend
203/// @{
204
205/**
206 @brief Get the Ceed associated with a CeedOperator
207
208 @param op CeedOperator
209 @param[out] ceed Variable to store Ceed
210
211 @return An error code: 0 - success, otherwise - failure
212
213 @ref Backend
214**/
215
216int CeedOperatorGetCeed(CeedOperator op, Ceed *ceed) {
217 *ceed = op->ceed;
218 return 0;
219}
220
221/**
222 @brief Get the number of elements associated with a CeedOperator
223
224 @param op CeedOperator
225 @param[out] numelem Variable to store number of elements
226
227 @return An error code: 0 - success, otherwise - failure
228
229 @ref Backend
230**/
231
232int CeedOperatorGetNumElements(CeedOperator op, CeedInt *numelem) {
233 if (op->composite)
234 // LCOV_EXCL_START
235 return CeedError(op->ceed, 1, "Not defined for composite operator");
236 // LCOV_EXCL_STOP
237
238 *numelem = op->numelements;
239 return 0;
240}
241
242/**
243 @brief Get the number of quadrature points associated with a CeedOperator
244
245 @param op CeedOperator
246 @param[out] numqpts Variable to store vector number of quadrature points
247
248 @return An error code: 0 - success, otherwise - failure
249
250 @ref Backend
251**/
252
253int CeedOperatorGetNumQuadraturePoints(CeedOperator op, CeedInt *numqpts) {
254 if (op->composite)
255 // LCOV_EXCL_START
256 return CeedError(op->ceed, 1, "Not defined for composite operator");
257 // LCOV_EXCL_STOP
258
259 *numqpts = op->numqpoints;
260 return 0;
261}
262
263/**
264 @brief Get the number of arguments associated with a CeedOperator
265
266 @param op CeedOperator
267 @param[out] numargs Variable to store vector number of arguments
268
269 @return An error code: 0 - success, otherwise - failure
270
271 @ref Backend
272**/
273
274int CeedOperatorGetNumArgs(CeedOperator op, CeedInt *numargs) {
275 if (op->composite)
276 // LCOV_EXCL_START
277 return CeedError(op->ceed, 1, "Not defined for composite operators");
278 // LCOV_EXCL_STOP
279
280 *numargs = op->nfields;
281 return 0;
282}
283
284/**
285 @brief Get the setup status of a CeedOperator
286
287 @param op CeedOperator
288 @param[out] setupdone Variable to store setup status
289
290 @return An error code: 0 - success, otherwise - failure
291
292 @ref Backend
293**/
294
295int CeedOperatorGetSetupStatus(CeedOperator op, bool *setupdone) {
296 *setupdone = op->setupdone;
297 return 0;
298}
299
300/**
301 @brief Get the QFunction associated with a CeedOperator
302
303 @param op CeedOperator
304 @param[out] qf Variable to store QFunction
305
306 @return An error code: 0 - success, otherwise - failure
307
308 @ref Backend
309**/
310
311int CeedOperatorGetQFunction(CeedOperator op, CeedQFunction *qf) {
312 if (op->composite)
313 // LCOV_EXCL_START
314 return CeedError(op->ceed, 1, "Not defined for composite operator");
315 // LCOV_EXCL_STOP
316
317 *qf = op->qf;
318 return 0;
319}
320
321/**
322 @brief Get the number of suboperators associated with a CeedOperator
323
324 @param op CeedOperator
325 @param[out] numsub Variable to store number of suboperators
326
327 @return An error code: 0 - success, otherwise - failure
328
329 @ref Backend
330**/
331
332int CeedOperatorGetNumSub(CeedOperator op, CeedInt *numsub) {
333 if (!op->composite)
334 // LCOV_EXCL_START
335 return CeedError(op->ceed, 1, "Not a composite operator");
336 // LCOV_EXCL_STOP
337
338 *numsub = op->numsub;
339 return 0;
340}
341
342/**
343 @brief Get the list of suboperators associated with a CeedOperator
344
345 @param op CeedOperator
346 @param[out] suboperators Variable to store list of suboperators
347
348 @return An error code: 0 - success, otherwise - failure
349
350 @ref Backend
351**/
352
353int CeedOperatorGetSubList(CeedOperator op, CeedOperator **suboperators) {
354 if (!op->composite)
355 // LCOV_EXCL_START
356 return CeedError(op->ceed, 1, "Not a composite operator");
357 // LCOV_EXCL_STOP
358
359 *suboperators = op->suboperators;
360 return 0;
361}
362
363/**
364 @brief Get the backend data of a CeedOperator
365
366 @param op CeedOperator
367 @param[out] data Variable to store data
368
369 @return An error code: 0 - success, otherwise - failure
370
371 @ref Backend
372**/
373
374int CeedOperatorGetData(CeedOperator op, void **data) {
375 *data = op->data;
376 return 0;
377}
378
379/**
380 @brief Set the backend data of a CeedOperator
381
382 @param[out] op CeedOperator
383 @param data Data to set
384
385 @return An error code: 0 - success, otherwise - failure
386
387 @ref Backend
388**/
389
390int CeedOperatorSetData(CeedOperator op, void **data) {
391 op->data = *data;
392 return 0;
393}
394
395/**
396 @brief Set the setup flag of a CeedOperator to True
397
398 @param op CeedOperator
399
400 @return An error code: 0 - success, otherwise - failure
401
402 @ref Backend
403**/
404
405int CeedOperatorSetSetupDone(CeedOperator op) {
406 op->setupdone = 1;
407 return 0;
408}
409
410/**
411 @brief Get the CeedOperatorFields of a CeedOperator
412
413 @param op CeedOperator
414 @param[out] inputfields Variable to store inputfields
415 @param[out] outputfields Variable to store outputfields
416
417 @return An error code: 0 - success, otherwise - failure
418
419 @ref Backend
420**/
421
422int CeedOperatorGetFields(CeedOperator op, CeedOperatorField **inputfields,
423 CeedOperatorField **outputfields) {
424 if (op->composite)
425 // LCOV_EXCL_START
426 return CeedError(op->ceed, 1, "Not defined for composite operator");
427 // LCOV_EXCL_STOP
428
429 if (inputfields) *inputfields = op->inputfields;
430 if (outputfields) *outputfields = op->outputfields;
431 return 0;
432}
433
434/**
435 @brief Get the CeedElemRestriction of a CeedOperatorField
436
437 @param opfield CeedOperatorField
438 @param[out] rstr Variable to store CeedElemRestriction
439
440 @return An error code: 0 - success, otherwise - failure
441
442 @ref Backend
443**/
444
445int CeedOperatorFieldGetElemRestriction(CeedOperatorField opfield,
446 CeedElemRestriction *rstr) {
447 *rstr = opfield->Erestrict;
448 return 0;
449}
450
451/**
452 @brief Get the CeedBasis of a CeedOperatorField
453
454 @param opfield CeedOperatorField
455 @param[out] basis Variable to store CeedBasis
456
457 @return An error code: 0 - success, otherwise - failure
458
459 @ref Backend
460**/
461
462int CeedOperatorFieldGetBasis(CeedOperatorField opfield, CeedBasis *basis) {
463 *basis = opfield->basis;
464 return 0;
465}
466
467/**
468 @brief Get the CeedVector of a CeedOperatorField
469
470 @param opfield CeedOperatorField
471 @param[out] vec Variable to store CeedVector
472
473 @return An error code: 0 - success, otherwise - failure
474
475 @ref Backend
476**/
477
478int CeedOperatorFieldGetVector(CeedOperatorField opfield, CeedVector *vec) {
479 *vec = opfield->vec;
480 return 0;
481}
482
483/// @}
484
485/// ----------------------------------------------------------------------------
486/// CeedOperator Public API
487/// ----------------------------------------------------------------------------
488/// @addtogroup CeedOperatorUser
489/// @{
490
491/**
29 @brief Create a CeedOperator and associate a CeedQFunction. A CeedBasis and
30 CeedElemRestriction can be associated with CeedQFunction fields with
31 \ref CeedOperatorSetField.
32
33 @param ceed A Ceed object where the CeedOperator will be created
34 @param qf QFunction defining the action of the operator at quadrature points
35 @param dqf QFunction defining the action of the Jacobian of @a qf (or
36 CEED_QFUNCTION_NONE)
37 @param dqfT QFunction defining the action of the transpose of the Jacobian
38 of @a qf (or CEED_QFUNCTION_NONE)
39 @param[out] op Address of the variable where the newly created
40 CeedOperator will be stored
41
42 @return An error code: 0 - success, otherwise - failure
43
492 @brief Create a CeedOperator and associate a CeedQFunction. A CeedBasis and
493 CeedElemRestriction can be associated with CeedQFunction fields with
494 \ref CeedOperatorSetField.
495
496 @param ceed A Ceed object where the CeedOperator will be created
497 @param qf QFunction defining the action of the operator at quadrature points
498 @param dqf QFunction defining the action of the Jacobian of @a qf (or
499 CEED_QFUNCTION_NONE)
500 @param dqfT QFunction defining the action of the transpose of the Jacobian
501 of @a qf (or CEED_QFUNCTION_NONE)
502 @param[out] op Address of the variable where the newly created
503 CeedOperator will be stored
504
505 @return An error code: 0 - success, otherwise - failure
506
44 @ref Basic
507 @ref User
45 */
46int CeedOperatorCreate(Ceed ceed, CeedQFunction qf, CeedQFunction dqf,
47 CeedQFunction dqfT, CeedOperator *op) {
48 int ierr;
49
50 if (!ceed->OperatorCreate) {
51 Ceed delegate;
52 ierr = CeedGetObjectDelegate(ceed, &delegate, "Operator"); CeedChk(ierr);

--- 35 unchanged lines hidden (view full) ---

88 @brief Create an operator that composes the action of several operators
89
90 @param ceed A Ceed object where the CeedOperator will be created
91 @param[out] op Address of the variable where the newly created
92 Composite CeedOperator will be stored
93
94 @return An error code: 0 - success, otherwise - failure
95
508 */
509int CeedOperatorCreate(Ceed ceed, CeedQFunction qf, CeedQFunction dqf,
510 CeedQFunction dqfT, CeedOperator *op) {
511 int ierr;
512
513 if (!ceed->OperatorCreate) {
514 Ceed delegate;
515 ierr = CeedGetObjectDelegate(ceed, &delegate, "Operator"); CeedChk(ierr);

--- 35 unchanged lines hidden (view full) ---

551 @brief Create an operator that composes the action of several operators
552
553 @param ceed A Ceed object where the CeedOperator will be created
554 @param[out] op Address of the variable where the newly created
555 Composite CeedOperator will be stored
556
557 @return An error code: 0 - success, otherwise - failure
558
96 @ref Basic
559 @ref User
97 */
98int CeedCompositeOperatorCreate(Ceed ceed, CeedOperator *op) {
99 int ierr;
100
101 if (!ceed->CompositeOperatorCreate) {
102 Ceed delegate;
103 ierr = CeedGetObjectDelegate(ceed, &delegate, "Operator"); CeedChk(ierr);
104

--- 33 unchanged lines hidden (view full) ---

138 @param b CeedBasis in which the field resides or CEED_BASIS_COLLOCATED
139 if collocated with quadrature points
140 @param v CeedVector to be used by CeedOperator or CEED_VECTOR_ACTIVE
141 if field is active or CEED_VECTOR_NONE if using
142 CEED_EVAL_WEIGHT in the QFunction
143
144 @return An error code: 0 - success, otherwise - failure
145
560 */
561int CeedCompositeOperatorCreate(Ceed ceed, CeedOperator *op) {
562 int ierr;
563
564 if (!ceed->CompositeOperatorCreate) {
565 Ceed delegate;
566 ierr = CeedGetObjectDelegate(ceed, &delegate, "Operator"); CeedChk(ierr);
567

--- 33 unchanged lines hidden (view full) ---

601 @param b CeedBasis in which the field resides or CEED_BASIS_COLLOCATED
602 if collocated with quadrature points
603 @param v CeedVector to be used by CeedOperator or CEED_VECTOR_ACTIVE
604 if field is active or CEED_VECTOR_NONE if using
605 CEED_EVAL_WEIGHT in the QFunction
606
607 @return An error code: 0 - success, otherwise - failure
608
146 @ref Basic
609 @ref User
147**/
148int CeedOperatorSetField(CeedOperator op, const char *fieldname,
149 CeedElemRestriction r, CeedBasis b, CeedVector v) {
150 int ierr;
151 if (op->composite)
152 // LCOV_EXCL_START
153 return CeedError(op->ceed, 1, "Cannot add field to composite operator.");
154 // LCOV_EXCL_STOP

--- 79 unchanged lines hidden (view full) ---

234/**
235 @brief Add a sub-operator to a composite CeedOperator
236
237 @param[out] compositeop Composite CeedOperator
238 @param subop Sub-operator CeedOperator
239
240 @return An error code: 0 - success, otherwise - failure
241
610**/
611int CeedOperatorSetField(CeedOperator op, const char *fieldname,
612 CeedElemRestriction r, CeedBasis b, CeedVector v) {
613 int ierr;
614 if (op->composite)
615 // LCOV_EXCL_START
616 return CeedError(op->ceed, 1, "Cannot add field to composite operator.");
617 // LCOV_EXCL_STOP

--- 79 unchanged lines hidden (view full) ---

697/**
698 @brief Add a sub-operator to a composite CeedOperator
699
700 @param[out] compositeop Composite CeedOperator
701 @param subop Sub-operator CeedOperator
702
703 @return An error code: 0 - success, otherwise - failure
704
242 @ref Basic
705 @ref User
243 */
244int CeedCompositeOperatorAddSub(CeedOperator compositeop, CeedOperator subop) {
245 if (!compositeop->composite)
246 // LCOV_EXCL_START
247 return CeedError(compositeop->ceed, 1, "CeedOperator is not a composite "
248 "operator");
249 // LCOV_EXCL_STOP
250

--- 4 unchanged lines hidden (view full) ---

255
256 compositeop->suboperators[compositeop->numsub] = subop;
257 subop->refcount++;
258 compositeop->numsub++;
259 return 0;
260}
261
262/**
706 */
707int CeedCompositeOperatorAddSub(CeedOperator compositeop, CeedOperator subop) {
708 if (!compositeop->composite)
709 // LCOV_EXCL_START
710 return CeedError(compositeop->ceed, 1, "CeedOperator is not a composite "
711 "operator");
712 // LCOV_EXCL_STOP
713

--- 4 unchanged lines hidden (view full) ---

718
719 compositeop->suboperators[compositeop->numsub] = subop;
720 subop->refcount++;
721 compositeop->numsub++;
722 return 0;
723}
724
725/**
263 @brief Duplicate a CeedOperator with a reference Ceed to fallback for advanced
264 CeedOperator functionality
265
266 @param op CeedOperator to create fallback for
267
268 @return An error code: 0 - success, otherwise - failure
269
270 @ref Developer
271**/
272int CeedOperatorCreateFallback(CeedOperator op) {
273 int ierr;
274
275 // Fallback Ceed
276 const char *resource, *fallbackresource;
277 ierr = CeedGetResource(op->ceed, &resource); CeedChk(ierr);
278 ierr = CeedGetOperatorFallbackResource(op->ceed, &fallbackresource);
279 CeedChk(ierr);
280 if (!strcmp(resource, fallbackresource))
281 // LCOV_EXCL_START
282 return CeedError(op->ceed, 1, "Backend %s cannot create an operator"
283 "fallback to resource %s", resource, fallbackresource);
284 // LCOV_EXCL_STOP
285
286 // Fallback Ceed
287 Ceed ceedref;
288 if (!op->ceed->opfallbackceed) {
289 ierr = CeedInit(fallbackresource, &ceedref); CeedChk(ierr);
290 ceedref->opfallbackparent = op->ceed;
291 op->ceed->opfallbackceed = ceedref;
292 }
293 ceedref = op->ceed->opfallbackceed;
294
295 // Clone Op
296 CeedOperator opref;
297 ierr = CeedCalloc(1, &opref); CeedChk(ierr);
298 memcpy(opref, op, sizeof(*opref)); CeedChk(ierr);
299 opref->data = NULL;
300 opref->setupdone = 0;
301 opref->ceed = ceedref;
302 ierr = ceedref->OperatorCreate(opref); CeedChk(ierr);
303 op->opfallback = opref;
304
305 // Clone QF
306 CeedQFunction qfref;
307 ierr = CeedCalloc(1, &qfref); CeedChk(ierr);
308 memcpy(qfref, (op->qf), sizeof(*qfref)); CeedChk(ierr);
309 qfref->data = NULL;
310 qfref->ceed = ceedref;
311 ierr = ceedref->QFunctionCreate(qfref); CeedChk(ierr);
312 opref->qf = qfref;
313 op->qffallback = qfref;
314
315 return 0;
316}
317
318/**
319 @brief Check if a CeedOperator is ready to be used.
320
321 @param[in] ceed Ceed object for error handling
322 @param[in] op CeedOperator to check
323
324 @return An error code: 0 - success, otherwise - failure
325
326 @ref Basic
327**/
328static int CeedOperatorCheckReady(Ceed ceed, CeedOperator op) {
329 CeedQFunction qf = op->qf;
330
331 if (op->composite) {
332 if (!op->numsub)
333 // LCOV_EXCL_START
334 return CeedError(ceed, 1, "No suboperators set");
335 // LCOV_EXCL_STOP
336 } else {
337 if (op->nfields == 0)
338 // LCOV_EXCL_START
339 return CeedError(ceed, 1, "No operator fields set");
340 // LCOV_EXCL_STOP
341 if (op->nfields < qf->numinputfields + qf->numoutputfields)
342 // LCOV_EXCL_START
343 return CeedError(ceed, 1, "Not all operator fields set");
344 // LCOV_EXCL_STOP
345 if (!op->hasrestriction)
346 // LCOV_EXCL_START
347 return CeedError(ceed, 1,"At least one restriction required");
348 // LCOV_EXCL_STOP
349 if (op->numqpoints == 0)
350 // LCOV_EXCL_START
351 return CeedError(ceed, 1,"At least one non-collocated basis required");
352 // LCOV_EXCL_STOP
353 }
354
355 return 0;
356}
357
358/**
359 @brief Assemble a linear CeedQFunction associated with a CeedOperator
360
361 This returns a CeedVector containing a matrix at each quadrature point
362 providing the action of the CeedQFunction associated with the CeedOperator.
363 The vector 'assembled' is of shape
364 [num_elements, num_input_fields, num_output_fields, num_quad_points]
365 and contains column-major matrices representing the action of the
366 CeedQFunction for a corresponding quadrature point on an element. Inputs and

--- 8 unchanged lines hidden (view full) ---

375 quadrature points
376 @param[out] rstr CeedElemRestriction for CeedVector containing assembled
377 CeedQFunction
378 @param request Address of CeedRequest for non-blocking completion, else
379 CEED_REQUEST_IMMEDIATE
380
381 @return An error code: 0 - success, otherwise - failure
382
726 @brief Assemble a linear CeedQFunction associated with a CeedOperator
727
728 This returns a CeedVector containing a matrix at each quadrature point
729 providing the action of the CeedQFunction associated with the CeedOperator.
730 The vector 'assembled' is of shape
731 [num_elements, num_input_fields, num_output_fields, num_quad_points]
732 and contains column-major matrices representing the action of the
733 CeedQFunction for a corresponding quadrature point on an element. Inputs and

--- 8 unchanged lines hidden (view full) ---

742 quadrature points
743 @param[out] rstr CeedElemRestriction for CeedVector containing assembled
744 CeedQFunction
745 @param request Address of CeedRequest for non-blocking completion, else
746 CEED_REQUEST_IMMEDIATE
747
748 @return An error code: 0 - success, otherwise - failure
749
383 @ref Basic
750 @ref User
384**/
385int CeedOperatorAssembleLinearQFunction(CeedOperator op, CeedVector *assembled,
386 CeedElemRestriction *rstr,
387 CeedRequest *request) {
388 int ierr;
389 Ceed ceed = op->ceed;
390 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
391

--- 21 unchanged lines hidden (view full) ---

413
414 @param op CeedOperator to assemble CeedQFunction
415 @param[out] assembled CeedVector to store assembled CeedOperator diagonal
416 @param request Address of CeedRequest for non-blocking completion, else
417 CEED_REQUEST_IMMEDIATE
418
419 @return An error code: 0 - success, otherwise - failure
420
751**/
752int CeedOperatorAssembleLinearQFunction(CeedOperator op, CeedVector *assembled,
753 CeedElemRestriction *rstr,
754 CeedRequest *request) {
755 int ierr;
756 Ceed ceed = op->ceed;
757 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
758

--- 21 unchanged lines hidden (view full) ---

780
781 @param op CeedOperator to assemble CeedQFunction
782 @param[out] assembled CeedVector to store assembled CeedOperator diagonal
783 @param request Address of CeedRequest for non-blocking completion, else
784 CEED_REQUEST_IMMEDIATE
785
786 @return An error code: 0 - success, otherwise - failure
787
421 @ref Basic
788 @ref User
422**/
423int CeedOperatorAssembleLinearDiagonal(CeedOperator op, CeedVector *assembled,
424 CeedRequest *request) {
425 int ierr;
426 Ceed ceed = op->ceed;
427 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
428
429 // Use backend version, if available

--- 28 unchanged lines hidden (view full) ---

458 @param op CeedOperator to create element inverses
459 @param[out] fdminv CeedOperator to apply the action of a FDM based inverse
460 for each element
461 @param request Address of CeedRequest for non-blocking completion, else
462 CEED_REQUEST_IMMEDIATE
463
464 @return An error code: 0 - success, otherwise - failure
465
789**/
790int CeedOperatorAssembleLinearDiagonal(CeedOperator op, CeedVector *assembled,
791 CeedRequest *request) {
792 int ierr;
793 Ceed ceed = op->ceed;
794 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
795
796 // Use backend version, if available

--- 28 unchanged lines hidden (view full) ---

825 @param op CeedOperator to create element inverses
826 @param[out] fdminv CeedOperator to apply the action of a FDM based inverse
827 for each element
828 @param request Address of CeedRequest for non-blocking completion, else
829 CEED_REQUEST_IMMEDIATE
830
831 @return An error code: 0 - success, otherwise - failure
832
466 @ref Advanced
833 @ref Backend
467**/
468int CeedOperatorCreateFDMElementInverse(CeedOperator op, CeedOperator *fdminv,
469 CeedRequest *request) {
470 int ierr;
471 Ceed ceed = op->ceed;
472 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
473
474 // Use backend version, if available

--- 7 unchanged lines hidden (view full) ---

482 // Assemble
483 ierr = op->opfallback->CreateFDMElementInverse(op->opfallback, fdminv,
484 request); CeedChk(ierr);
485 }
486
487 return 0;
488}
489
834**/
835int CeedOperatorCreateFDMElementInverse(CeedOperator op, CeedOperator *fdminv,
836 CeedRequest *request) {
837 int ierr;
838 Ceed ceed = op->ceed;
839 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
840
841 // Use backend version, if available

--- 7 unchanged lines hidden (view full) ---

849 // Assemble
850 ierr = op->opfallback->CreateFDMElementInverse(op->opfallback, fdminv,
851 request); CeedChk(ierr);
852 }
853
854 return 0;
855}
856
857/**
858 @brief View a CeedOperator
490
859
860 @param[in] op CeedOperator to view
861 @param[in] stream Stream to write; typically stdout/stderr or a file
862
863 @return Error code: 0 - success, otherwise - failure
864
865 @ref User
866**/
867int CeedOperatorView(CeedOperator op, FILE *stream) {
868 int ierr;
869
870 if (op->composite) {
871 fprintf(stream, "Composite CeedOperator\n");
872
873 for (CeedInt i=0; i<op->numsub; i++) {
874 fprintf(stream, " SubOperator [%d]:\n", i);
875 ierr = CeedOperatorSingleView(op->suboperators[i], 1, stream);
876 CeedChk(ierr);
877 }
878 } else {
879 fprintf(stream, "CeedOperator\n");
880 ierr = CeedOperatorSingleView(op, 0, stream); CeedChk(ierr);
881 }
882
883 return 0;
884}
885
491/**
492 @brief Apply CeedOperator to a vector
493
494 This computes the action of the operator on the specified (active) input,
495 yielding its (active) output. All inputs and outputs must be specified using
496 CeedOperatorSetField().
497
498 @param op CeedOperator to apply
499 @param[in] in CeedVector containing input state or CEED_VECTOR_NONE if
500 there are no active inputs
501 @param[out] out CeedVector to store result of applying operator (must be
502 distinct from @a in) or CEED_VECTOR_NONE if there are no
503 active outputs
504 @param request Address of CeedRequest for non-blocking completion, else
505 CEED_REQUEST_IMMEDIATE
506
507 @return An error code: 0 - success, otherwise - failure
508
886/**
887 @brief Apply CeedOperator to a vector
888
889 This computes the action of the operator on the specified (active) input,
890 yielding its (active) output. All inputs and outputs must be specified using
891 CeedOperatorSetField().
892
893 @param op CeedOperator to apply
894 @param[in] in CeedVector containing input state or CEED_VECTOR_NONE if
895 there are no active inputs
896 @param[out] out CeedVector to store result of applying operator (must be
897 distinct from @a in) or CEED_VECTOR_NONE if there are no
898 active outputs
899 @param request Address of CeedRequest for non-blocking completion, else
900 CEED_REQUEST_IMMEDIATE
901
902 @return An error code: 0 - success, otherwise - failure
903
509 @ref Basic
904 @ref User
510**/
511int CeedOperatorApply(CeedOperator op, CeedVector in, CeedVector out,
512 CeedRequest *request) {
513 int ierr;
514 Ceed ceed = op->ceed;
515 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
516
517 if (op->numelements) {

--- 59 unchanged lines hidden (view full) ---

577 active inputs
578 @param[out] out CeedVector to sum in result of applying operator (must be
579 distinct from @a in) or NULL if there are no active outputs
580 @param request Address of CeedRequest for non-blocking completion, else
581 CEED_REQUEST_IMMEDIATE
582
583 @return An error code: 0 - success, otherwise - failure
584
905**/
906int CeedOperatorApply(CeedOperator op, CeedVector in, CeedVector out,
907 CeedRequest *request) {
908 int ierr;
909 Ceed ceed = op->ceed;
910 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
911
912 if (op->numelements) {

--- 59 unchanged lines hidden (view full) ---

972 active inputs
973 @param[out] out CeedVector to sum in result of applying operator (must be
974 distinct from @a in) or NULL if there are no active outputs
975 @param request Address of CeedRequest for non-blocking completion, else
976 CEED_REQUEST_IMMEDIATE
977
978 @return An error code: 0 - success, otherwise - failure
979
585 @ref Basic
980 @ref User
586**/
587int CeedOperatorApplyAdd(CeedOperator op, CeedVector in, CeedVector out,
588 CeedRequest *request) {
589 int ierr;
590 Ceed ceed = op->ceed;
591 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
592
593 if (op->numelements) {

--- 15 unchanged lines hidden (view full) ---

609 }
610 }
611 }
612
613 return 0;
614}
615
616/**
981**/
982int CeedOperatorApplyAdd(CeedOperator op, CeedVector in, CeedVector out,
983 CeedRequest *request) {
984 int ierr;
985 Ceed ceed = op->ceed;
986 ierr = CeedOperatorCheckReady(ceed, op); CeedChk(ierr);
987
988 if (op->numelements) {

--- 15 unchanged lines hidden (view full) ---

1004 }
1005 }
1006 }
1007
1008 return 0;
1009}
1010
1011/**
617 @brief Get the Ceed associated with a CeedOperator
618
619 @param op CeedOperator
620 @param[out] ceed Variable to store Ceed
621
622 @return An error code: 0 - success, otherwise - failure
623
624 @ref Advanced
625**/
626
627int CeedOperatorGetCeed(CeedOperator op, Ceed *ceed) {
628 *ceed = op->ceed;
629 return 0;
630}
631
632/**
633 @brief Get the number of elements associated with a CeedOperator
634
635 @param op CeedOperator
636 @param[out] numelem Variable to store number of elements
637
638 @return An error code: 0 - success, otherwise - failure
639
640 @ref Advanced
641**/
642
643int CeedOperatorGetNumElements(CeedOperator op, CeedInt *numelem) {
644 if (op->composite)
645 // LCOV_EXCL_START
646 return CeedError(op->ceed, 1, "Not defined for composite operator");
647 // LCOV_EXCL_STOP
648
649 *numelem = op->numelements;
650 return 0;
651}
652
653/**
654 @brief Get the number of quadrature points associated with a CeedOperator
655
656 @param op CeedOperator
657 @param[out] numqpts Variable to store vector number of quadrature points
658
659 @return An error code: 0 - success, otherwise - failure
660
661 @ref Advanced
662**/
663
664int CeedOperatorGetNumQuadraturePoints(CeedOperator op, CeedInt *numqpts) {
665 if (op->composite)
666 // LCOV_EXCL_START
667 return CeedError(op->ceed, 1, "Not defined for composite operator");
668 // LCOV_EXCL_STOP
669
670 *numqpts = op->numqpoints;
671 return 0;
672}
673
674/**
675 @brief Get the number of arguments associated with a CeedOperator
676
677 @param op CeedOperator
678 @param[out] numargs Variable to store vector number of arguments
679
680 @return An error code: 0 - success, otherwise - failure
681
682 @ref Advanced
683**/
684
685int CeedOperatorGetNumArgs(CeedOperator op, CeedInt *numargs) {
686 if (op->composite)
687 // LCOV_EXCL_START
688 return CeedError(op->ceed, 1, "Not defined for composite operators");
689 // LCOV_EXCL_STOP
690
691 *numargs = op->nfields;
692 return 0;
693}
694
695/**
696 @brief Get the setup status of a CeedOperator
697
698 @param op CeedOperator
699 @param[out] setupdone Variable to store setup status
700
701 @return An error code: 0 - success, otherwise - failure
702
703 @ref Advanced
704**/
705
706int CeedOperatorGetSetupStatus(CeedOperator op, bool *setupdone) {
707 *setupdone = op->setupdone;
708 return 0;
709}
710
711/**
712 @brief Get the QFunction associated with a CeedOperator
713
714 @param op CeedOperator
715 @param[out] qf Variable to store QFunction
716
717 @return An error code: 0 - success, otherwise - failure
718
719 @ref Advanced
720**/
721
722int CeedOperatorGetQFunction(CeedOperator op, CeedQFunction *qf) {
723 if (op->composite)
724 // LCOV_EXCL_START
725 return CeedError(op->ceed, 1, "Not defined for composite operator");
726 // LCOV_EXCL_STOP
727
728 *qf = op->qf;
729 return 0;
730}
731
732/**
733 @brief Get the number of suboperators associated with a CeedOperator
734
735 @param op CeedOperator
736 @param[out] numsub Variable to store number of suboperators
737
738 @return An error code: 0 - success, otherwise - failure
739
740 @ref Advanced
741**/
742
743int CeedOperatorGetNumSub(CeedOperator op, CeedInt *numsub) {
744 if (!op->composite)
745 // LCOV_EXCL_START
746 return CeedError(op->ceed, 1, "Not a composite operator");
747 // LCOV_EXCL_STOP
748
749 *numsub = op->numsub;
750 return 0;
751}
752
753/**
754 @brief Get the list of suboperators associated with a CeedOperator
755
756 @param op CeedOperator
757 @param[out] suboperators Variable to store list of suboperators
758
759 @return An error code: 0 - success, otherwise - failure
760
761 @ref Advanced
762**/
763
764int CeedOperatorGetSubList(CeedOperator op, CeedOperator **suboperators) {
765 if (!op->composite)
766 // LCOV_EXCL_START
767 return CeedError(op->ceed, 1, "Not a composite operator");
768 // LCOV_EXCL_STOP
769
770 *suboperators = op->suboperators;
771 return 0;
772}
773
774/**
775 @brief Set the backend data of a CeedOperator
776
777 @param[out] op CeedOperator
778 @param data Data to set
779
780 @return An error code: 0 - success, otherwise - failure
781
782 @ref Advanced
783**/
784
785int CeedOperatorSetData(CeedOperator op, void **data) {
786 op->data = *data;
787 return 0;
788}
789
790/**
791 @brief Get the backend data of a CeedOperator
792
793 @param op CeedOperator
794 @param[out] data Variable to store data
795
796 @return An error code: 0 - success, otherwise - failure
797
798 @ref Advanced
799**/
800
801int CeedOperatorGetData(CeedOperator op, void **data) {
802 *data = op->data;
803 return 0;
804}
805
806/**
807 @brief Set the setup flag of a CeedOperator to True
808
809 @param op CeedOperator
810
811 @return An error code: 0 - success, otherwise - failure
812
813 @ref Advanced
814**/
815
816int CeedOperatorSetSetupDone(CeedOperator op) {
817 op->setupdone = 1;
818 return 0;
819}
820
821/**
822 @brief View a field of a CeedOperator
823
824 @param[in] field Operator field to view
825 @param[in] fieldnumber Number of field being viewed
826 @param[in] stream Stream to view to, e.g., stdout
827
828 @return An error code: 0 - success, otherwise - failure
829
830 @ref Utility
831**/
832static int CeedOperatorFieldView(CeedOperatorField field,
833 CeedQFunctionField qffield,
834 CeedInt fieldnumber, bool sub, bool in,
835 FILE *stream) {
836 const char *pre = sub ? " " : "";
837 const char *inout = in ? "Input" : "Output";
838
839 fprintf(stream, "%s %s Field [%d]:\n"
840 "%s Name: \"%s\"\n",
841 pre, inout, fieldnumber, pre, qffield->fieldname);
842
843 if (field->basis == CEED_BASIS_COLLOCATED)
844 fprintf(stream, "%s Collocated basis\n", pre);
845
846 if (field->vec == CEED_VECTOR_ACTIVE)
847 fprintf(stream, "%s Active vector\n", pre);
848 else if (field->vec == CEED_VECTOR_NONE)
849 fprintf(stream, "%s No vector\n", pre);
850
851 return 0;
852}
853
854/**
855 @brief View a single CeedOperator
856
857 @param[in] op CeedOperator to view
858 @param[in] sub Boolean flag for sub-operator
859 @param[in] stream Stream to write; typically stdout/stderr or a file
860
861 @return Error code: 0 - success, otherwise - failure
862
863 @ref Utility
864**/
865int CeedOperatorSingleView(CeedOperator op, bool sub, FILE *stream) {
866 int ierr;
867 const char *pre = sub ? " " : "";
868
869 CeedInt totalfields;
870 ierr = CeedOperatorGetNumArgs(op, &totalfields); CeedChk(ierr);
871
872 fprintf(stream, "%s %d Field%s\n", pre, totalfields, totalfields>1 ? "s" : "");
873
874 fprintf(stream, "%s %d Input Field%s:\n", pre, op->qf->numinputfields,
875 op->qf->numinputfields>1 ? "s" : "");
876 for (CeedInt i=0; i<op->qf->numinputfields; i++) {
877 ierr = CeedOperatorFieldView(op->inputfields[i], op->qf->inputfields[i],
878 i, sub, 1, stream); CeedChk(ierr);
879 }
880
881 fprintf(stream, "%s %d Output Field%s:\n", pre, op->qf->numoutputfields,
882 op->qf->numoutputfields>1 ? "s" : "");
883 for (CeedInt i=0; i<op->qf->numoutputfields; i++) {
884 ierr = CeedOperatorFieldView(op->outputfields[i], op->qf->inputfields[i],
885 i, sub, 0, stream); CeedChk(ierr);
886 }
887
888 return 0;
889}
890
891/**
892 @brief View a CeedOperator
893
894 @param[in] op CeedOperator to view
895 @param[in] stream Stream to write; typically stdout/stderr or a file
896
897 @return Error code: 0 - success, otherwise - failure
898
899 @ref Utility
900**/
901int CeedOperatorView(CeedOperator op, FILE *stream) {
902 int ierr;
903
904 if (op->composite) {
905 fprintf(stream, "Composite CeedOperator\n");
906
907 for (CeedInt i=0; i<op->numsub; i++) {
908 fprintf(stream, " SubOperator [%d]:\n", i);
909 ierr = CeedOperatorSingleView(op->suboperators[i], 1, stream);
910 CeedChk(ierr);
911 }
912 } else {
913 fprintf(stream, "CeedOperator\n");
914 ierr = CeedOperatorSingleView(op, 0, stream); CeedChk(ierr);
915 }
916
917 return 0;
918}
919
920/**
921 @brief Get the CeedOperatorFields of a CeedOperator
922
923 @param op CeedOperator
924 @param[out] inputfields Variable to store inputfields
925 @param[out] outputfields Variable to store outputfields
926
927 @return An error code: 0 - success, otherwise - failure
928
929 @ref Advanced
930**/
931
932int CeedOperatorGetFields(CeedOperator op, CeedOperatorField **inputfields,
933 CeedOperatorField **outputfields) {
934 if (op->composite)
935 // LCOV_EXCL_START
936 return CeedError(op->ceed, 1, "Not defined for composite operator");
937 // LCOV_EXCL_STOP
938
939 if (inputfields) *inputfields = op->inputfields;
940 if (outputfields) *outputfields = op->outputfields;
941 return 0;
942}
943
944/**
945 @brief Get the CeedElemRestriction of a CeedOperatorField
946
947 @param opfield CeedOperatorField
948 @param[out] rstr Variable to store CeedElemRestriction
949
950 @return An error code: 0 - success, otherwise - failure
951
952 @ref Advanced
953**/
954
955int CeedOperatorFieldGetElemRestriction(CeedOperatorField opfield,
956 CeedElemRestriction *rstr) {
957 *rstr = opfield->Erestrict;
958 return 0;
959}
960
961/**
962 @brief Get the CeedBasis of a CeedOperatorField
963
964 @param opfield CeedOperatorField
965 @param[out] basis Variable to store CeedBasis
966
967 @return An error code: 0 - success, otherwise - failure
968
969 @ref Advanced
970**/
971
972int CeedOperatorFieldGetBasis(CeedOperatorField opfield, CeedBasis *basis) {
973 *basis = opfield->basis;
974 return 0;
975}
976
977/**
978 @brief Get the CeedVector of a CeedOperatorField
979
980 @param opfield CeedOperatorField
981 @param[out] vec Variable to store CeedVector
982
983 @return An error code: 0 - success, otherwise - failure
984
985 @ref Advanced
986**/
987
988int CeedOperatorFieldGetVector(CeedOperatorField opfield, CeedVector *vec) {
989 *vec = opfield->vec;
990 return 0;
991}
992
993/**
994 @brief Destroy a CeedOperator
995
996 @param op CeedOperator to destroy
997
998 @return An error code: 0 - success, otherwise - failure
999
1012 @brief Destroy a CeedOperator
1013
1014 @param op CeedOperator to destroy
1015
1016 @return An error code: 0 - success, otherwise - failure
1017
1000 @ref Basic
1018 @ref User
1001**/
1002int CeedOperatorDestroy(CeedOperator *op) {
1003 int ierr;
1004
1005 if (!*op || --(*op)->refcount > 0) return 0;
1006 if ((*op)->Destroy) {
1007 ierr = (*op)->Destroy(*op); CeedChk(ierr);
1008 }

--- 55 unchanged lines hidden --- 		1019**/
1020int CeedOperatorDestroy(CeedOperator *op) {
1021 int ierr;
1022
1023 if (!*op || --(*op)->refcount > 0) return 0;
1024 if ((*op)->Destroy) {
1025 ierr = (*op)->Destroy(*op); CeedChk(ierr);
1026 }

--- 55 unchanged lines hidden ---