1 // Copyright (c) 2017-2026, 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 // Fortran interface
9 #include <ceed-fortran-name.h>
10 #include <ceed-impl.h>
11 #include <ceed.h>
12 #include <ceed/backend.h>
13 #include <stdbool.h>
14 #include <stdint.h>
15 #include <stdio.h>
16 #include <string.h>
17
18 #define FORTRAN_REQUEST_IMMEDIATE -1
19 #define FORTRAN_REQUEST_ORDERED -2
20 #define FORTRAN_NULL -3
21 #define FORTRAN_STRIDES_BACKEND -4
22 #define FORTRAN_VECTOR_ACTIVE -5
23 #define FORTRAN_VECTOR_NONE -6
24 #define FORTRAN_ELEMRESTRICTION_NONE -7
25 #define FORTRAN_BASIS_NONE -8
26 #define FORTRAN_QFUNCTION_NONE -9
27
28 static Ceed *Ceed_dict = NULL;
29 static int Ceed_count = 0;
30 static int Ceed_n = 0;
31 static int Ceed_count_max = 0;
32
33 // This test should actually be for the gfortran version, but we don't currently
34 // have a configure system to determine that (TODO). At present, this will use
35 // the smaller integer when run with clang+gfortran=8, for example. (That is
36 // sketchy, but will likely work for users that don't have huge character
37 // strings.)
38 #if __GNUC__ >= 8
39 typedef size_t fortran_charlen_t;
40 #else
41 typedef int fortran_charlen_t;
42 #endif
43
44 #define Splice(a, b) a##b
45
46 // Fortran strings are generally unterminated and the length is passed as an
47 // extra argument after all the normal arguments. Some compilers (I only know
48 // of Windows) place the length argument immediately after the string parameter
49 // (TODO).
50 //
51 // We can't just NULL-terminate the string in-place because that could overwrite
52 // other strings or attempt to write to read-only memory. This macro allocates
53 // a string to hold the null-terminated version of the string that C expects.
54 #define FIX_STRING(stringname) \
55 char Splice(stringname, _c)[1024]; \
56 if (Splice(stringname, _len) > 1023) *err = CeedError(NULL, 1, "Fortran string length too long %zd", (size_t)Splice(stringname, _len)); \
57 strncpy(Splice(stringname, _c), stringname, Splice(stringname, _len)); \
58 Splice(stringname, _c)[Splice(stringname, _len)] = 0;
59
60 // -----------------------------------------------------------------------------
61 // Ceed
62 // -----------------------------------------------------------------------------
63 #define fCeedInit FORTRAN_NAME(ceedinit, CEEDINIT)
fCeedInit(const char * resource,int * ceed,int * err,fortran_charlen_t resource_len)64 CEED_EXTERN void fCeedInit(const char *resource, int *ceed, int *err, fortran_charlen_t resource_len) {
65 FIX_STRING(resource);
66 if (Ceed_count == Ceed_count_max) {
67 Ceed_count_max += Ceed_count_max / 2 + 1;
68 CeedRealloc(Ceed_count_max, &Ceed_dict);
69 }
70
71 Ceed *ceed_ = &Ceed_dict[Ceed_count];
72 *err = CeedInit(resource_c, ceed_);
73
74 if (*err == 0) {
75 *ceed = Ceed_count++;
76 Ceed_n++;
77 }
78 }
79
80 #define fCeedIsDeterministic FORTRAN_NAME(ceedisdeterministic, CEEDISDETERMINISTIC)
fCeedIsDeterministic(int * ceed,int * is_deterministic,int * err)81 CEED_EXTERN void fCeedIsDeterministic(int *ceed, int *is_deterministic, int *err) {
82 *err = CeedIsDeterministic(Ceed_dict[*ceed], (bool *)is_deterministic);
83 }
84
85 #define fCeedGetPreferredMemType FORTRAN_NAME(ceedgetpreferredmemtype, CEEDGETPREFERREDMEMTYPE)
fCeedGetPreferredMemType(int * ceed,int * type,int * err)86 CEED_EXTERN void fCeedGetPreferredMemType(int *ceed, int *type, int *err) { *err = CeedGetPreferredMemType(Ceed_dict[*ceed], (CeedMemType *)type); }
87
88 #define fCeedSetNumViewTabs FORTRAN_NAME(ceedsetnumviewtabs, CEEDSETNUMVIEWTABS)
fCeedSetNumViewTabs(int * ceed,int * num_tabs,int * err)89 CEED_EXTERN void fCeedSetNumViewTabs(int *ceed, int *num_tabs, int *err) { *err = CeedSetNumViewTabs(Ceed_dict[*ceed], *num_tabs); }
90
91 #define fCeedView FORTRAN_NAME(ceedview, CEEDVIEW)
fCeedView(int * ceed,int * err)92 CEED_EXTERN void fCeedView(int *ceed, int *err) { *err = CeedView(Ceed_dict[*ceed], stdout); }
93
94 #define fCeedDestroy FORTRAN_NAME(ceeddestroy, CEEDDESTROY)
fCeedDestroy(int * ceed,int * err)95 CEED_EXTERN void fCeedDestroy(int *ceed, int *err) {
96 if (*ceed == FORTRAN_NULL) return;
97 *err = CeedDestroy(&Ceed_dict[*ceed]);
98
99 if (*err == 0) {
100 *ceed = FORTRAN_NULL;
101 Ceed_n--;
102 if (Ceed_n == 0) {
103 CeedFree(&Ceed_dict);
104 Ceed_count = 0;
105 Ceed_count_max = 0;
106 }
107 }
108 }
109
110 // -----------------------------------------------------------------------------
111 // CeedVector
112 // -----------------------------------------------------------------------------
113 static CeedVector *CeedVector_dict = NULL;
114 static int CeedVector_count = 0;
115 static int CeedVector_n = 0;
116 static int CeedVector_count_max = 0;
117
118 #define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate, CEEDVECTORCREATE)
fCeedVectorCreate(int * ceed,int * length,int * vec,int * err)119 CEED_EXTERN void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) {
120 if (CeedVector_count == CeedVector_count_max) {
121 CeedVector_count_max += CeedVector_count_max / 2 + 1;
122 CeedRealloc(CeedVector_count_max, &CeedVector_dict);
123 }
124
125 CeedVector *vec_ = &CeedVector_dict[CeedVector_count];
126 *err = CeedVectorCreate(Ceed_dict[*ceed], *length, vec_);
127
128 if (*err == 0) {
129 *vec = CeedVector_count++;
130 CeedVector_n++;
131 }
132 }
133
134 #define fCeedVectorSetArray FORTRAN_NAME(ceedvectorsetarray, CEEDVECTORSETARRAY)
fCeedVectorSetArray(int * vec,int * memtype,int * copymode,CeedScalar * array,int64_t * offset,int * err)135 CEED_EXTERN void fCeedVectorSetArray(int *vec, int *memtype, int *copymode, CeedScalar *array, int64_t *offset, int *err) {
136 *err = CeedVectorSetArray(CeedVector_dict[*vec], (CeedMemType)*memtype, (CeedCopyMode)*copymode, (CeedScalar *)(array + *offset));
137 }
138
139 #define fCeedVectorTakeArray FORTRAN_NAME(ceedvectortakearray, CEEDVECTORTAKEARRAY)
fCeedVectorTakeArray(int * vec,int * memtype,CeedScalar * array,int64_t * offset,int * err)140 CEED_EXTERN void fCeedVectorTakeArray(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) {
141 CeedScalar *b;
142 CeedVector vec_ = CeedVector_dict[*vec];
143 *err = CeedVectorTakeArray(vec_, (CeedMemType)*memtype, &b);
144 *offset = b - array;
145 }
146
147 #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray, CEEDVECTORSYNCARRAY)
fCeedVectorSyncArray(int * vec,int * memtype,int * err)148 CEED_EXTERN void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { *err = CeedVectorSyncArray(CeedVector_dict[*vec], (CeedMemType)*memtype); }
149
150 #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue, CEEDVECTORSETVALUE)
fCeedVectorSetValue(int * vec,CeedScalar * value,int * err)151 CEED_EXTERN void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); }
152
153 #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray, CEEDVECTORGETARRAY)
fCeedVectorGetArray(int * vec,int * memtype,CeedScalar * array,int64_t * offset,int * err)154 CEED_EXTERN void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) {
155 CeedScalar *b;
156 CeedVector vec_ = CeedVector_dict[*vec];
157 *err = CeedVectorGetArray(vec_, (CeedMemType)*memtype, &b);
158 *offset = b - array;
159 }
160
161 #define fCeedVectorGetArrayRead FORTRAN_NAME(ceedvectorgetarrayread, CEEDVECTORGETARRAYREAD)
fCeedVectorGetArrayRead(int * vec,int * memtype,CeedScalar * array,int64_t * offset,int * err)162 CEED_EXTERN void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) {
163 const CeedScalar *b;
164 CeedVector vec_ = CeedVector_dict[*vec];
165 *err = CeedVectorGetArrayRead(vec_, (CeedMemType)*memtype, &b);
166 *offset = b - array;
167 }
168
169 #define fCeedVectorGetArrayWrite FORTRAN_NAME(ceedvectorgetarraywrite, CEEDVECTORGETARRAYWRITE)
fCeedVectorGetArrayWrite(int * vec,int * memtype,CeedScalar * array,int64_t * offset,int * err)170 CEED_EXTERN void fCeedVectorGetArrayWrite(int *vec, int *memtype, CeedScalar *array, int64_t *offset, int *err) {
171 CeedScalar *b;
172 CeedVector vec_ = CeedVector_dict[*vec];
173 *err = CeedVectorGetArrayWrite(vec_, (CeedMemType)*memtype, &b);
174 *offset = b - array;
175 }
176
177 #define fCeedVectorRestoreArray FORTRAN_NAME(ceedvectorrestorearray, CEEDVECTORRESTOREARRAY)
fCeedVectorRestoreArray(int * vec,CeedScalar * array,int64_t * offset,int * err)178 CEED_EXTERN void fCeedVectorRestoreArray(int *vec, CeedScalar *array, int64_t *offset, int *err) {
179 CeedScalar *offsetArray = array + *offset;
180 *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &offsetArray);
181 *offset = 0;
182 }
183
184 #define fCeedVectorRestoreArrayRead FORTRAN_NAME(ceedvectorrestorearrayread, CEEDVECTORRESTOREARRAYREAD)
fCeedVectorRestoreArrayRead(int * vec,const CeedScalar * array,int64_t * offset,int * err)185 CEED_EXTERN void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, int64_t *offset, int *err) {
186 *err = CeedVectorRestoreArrayRead(CeedVector_dict[*vec], &array);
187 *offset = 0;
188 }
189
190 #define fCeedVectorNorm FORTRAN_NAME(ceedvectornorm, CEEDVECTORNORM)
fCeedVectorNorm(int * vec,int * type,CeedScalar * norm,int * err)191 CEED_EXTERN void fCeedVectorNorm(int *vec, int *type, CeedScalar *norm, int *err) {
192 *err = CeedVectorNorm(CeedVector_dict[*vec], (CeedNormType)*type, norm);
193 }
194
195 #define fCeedVectorReciprocal FORTRAN_NAME(ceedvectorreciprocal, CEEDVECTORRECIPROCAL)
fCeedVectorReciprocal(int * vec,int * err)196 CEED_EXTERN void fCeedVectorReciprocal(int *vec, int *err) { *err = CeedVectorReciprocal(CeedVector_dict[*vec]); }
197
198 #define fCeedVectorSetNumViewTabs FORTRAN_NAME(ceedvectorsetnumviewtabs, CEEDVECTORSETNUMVIEWTABS)
fCeedVectorSetNumViewTabs(int * vec,int * num_tabs,int * err)199 CEED_EXTERN void fCeedVectorSetNumViewTabs(int *vec, int *num_tabs, int *err) { *err = CeedVectorSetNumViewTabs(CeedVector_dict[*vec], *num_tabs); }
200
201 #define fCeedVectorView FORTRAN_NAME(ceedvectorview, CEEDVECTORVIEW)
fCeedVectorView(int * vec,int * err)202 CEED_EXTERN void fCeedVectorView(int *vec, int *err) { *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); }
203
204 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy, CEEDVECTORDESTROY)
fCeedVectorDestroy(int * vec,int * err)205 CEED_EXTERN void fCeedVectorDestroy(int *vec, int *err) {
206 if (*vec == FORTRAN_NULL) return;
207 *err = CeedVectorDestroy(&CeedVector_dict[*vec]);
208
209 if (*err == 0) {
210 *vec = FORTRAN_NULL;
211 CeedVector_n--;
212 if (CeedVector_n == 0) {
213 CeedFree(&CeedVector_dict);
214 CeedVector_count = 0;
215 CeedVector_count_max = 0;
216 }
217 }
218 }
219
220 // -----------------------------------------------------------------------------
221 // CeedElemRestriction
222 // -----------------------------------------------------------------------------
223 static CeedElemRestriction *CeedElemRestriction_dict = NULL;
224 static int CeedElemRestriction_count = 0;
225 static int CeedElemRestriction_n = 0;
226 static int CeedElemRestriction_count_max = 0;
227
228 #define fCeedElemRestrictionCreate FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE)
fCeedElemRestrictionCreate(int * ceed,int * nelements,int * esize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,int * elemrestriction,int * err)229 CEED_EXTERN void fCeedElemRestrictionCreate(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize, int *memtype,
230 int *copymode, const int *offsets, int *elemrestriction, int *err) {
231 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
232 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
233 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
234 }
235
236 const int *offsets_ = offsets;
237
238 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
239 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype,
240 (CeedCopyMode)*copymode, offsets_, elemrestriction_);
241
242 if (*err == 0) {
243 *elemrestriction = CeedElemRestriction_count++;
244 CeedElemRestriction_n++;
245 }
246 }
247
248 #define fCeedElemRestrictionCreateOriented FORTRAN_NAME(ceedelemrestrictioncreateoriented, CEEDELEMRESTRICTIONCREATEORIENTED)
fCeedElemRestrictionCreateOriented(int * ceed,int * nelements,int * esize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,const bool * orients,int * elemrestriction,int * err)249 CEED_EXTERN void fCeedElemRestrictionCreateOriented(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize, int *memtype,
250 int *copymode, const int *offsets, const bool *orients, int *elemrestriction, int *err) {
251 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
252 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
253 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
254 }
255
256 const int *offsets_ = offsets;
257 const bool *orients_ = orients;
258
259 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
260 *err = CeedElemRestrictionCreateOriented(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype,
261 (CeedCopyMode)*copymode, offsets_, orients_, elemrestriction_);
262
263 if (*err == 0) {
264 *elemrestriction = CeedElemRestriction_count++;
265 CeedElemRestriction_n++;
266 }
267 }
268
269 #define fCeedElemRestrictionCreateCurlOriented FORTRAN_NAME(ceedelemrestrictioncreatecurloriented, CEEDELEMRESTRICTIONCREATECURLORIENTED)
fCeedElemRestrictionCreateCurlOriented(int * ceed,int * nelements,int * esize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,const int8_t * curlorients,int * elemrestriction,int * err)270 CEED_EXTERN void fCeedElemRestrictionCreateCurlOriented(int *ceed, int *nelements, int *esize, int *num_comp, int *comp_stride, int *lsize,
271 int *memtype, int *copymode, const int *offsets, const int8_t *curlorients,
272 int *elemrestriction, int *err) {
273 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
274 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
275 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
276 }
277
278 const int *offsets_ = offsets;
279 const int8_t *curlorients_ = curlorients;
280
281 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
282 *err = CeedElemRestrictionCreateCurlOriented(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype,
283 (CeedCopyMode)*copymode, offsets_, curlorients_, elemrestriction_);
284
285 if (*err == 0) {
286 *elemrestriction = CeedElemRestriction_count++;
287 CeedElemRestriction_n++;
288 }
289 }
290
291 #define fCeedElemRestrictionCreateStrided FORTRAN_NAME(ceedelemrestrictioncreatestrided, CEEDELEMRESTRICTIONCREATESTRIDED)
fCeedElemRestrictionCreateStrided(int * ceed,int * nelements,int * esize,int * num_comp,int * lsize,int * strides,int * elemrestriction,int * err)292 CEED_EXTERN void fCeedElemRestrictionCreateStrided(int *ceed, int *nelements, int *esize, int *num_comp, int *lsize, int *strides,
293 int *elemrestriction, int *err) {
294 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
295 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
296 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
297 }
298
299 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
300 *err = CeedElemRestrictionCreateStrided(Ceed_dict[*ceed], *nelements, *esize, *num_comp, *lsize,
301 *strides == FORTRAN_STRIDES_BACKEND ? CEED_STRIDES_BACKEND : strides, elemrestriction_);
302
303 if (*err == 0) {
304 *elemrestriction = CeedElemRestriction_count++;
305 CeedElemRestriction_n++;
306 }
307 }
308
309 #define fCeedElemRestrictionCreateBlocked FORTRAN_NAME(ceedelemrestrictioncreateblocked, CEEDELEMRESTRICTIONCREATEBLOCKED)
fCeedElemRestrictionCreateBlocked(int * ceed,int * nelements,int * esize,int * blocksize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,int * elemrestriction,int * err)310 CEED_EXTERN void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride, int *lsize,
311 int *memtype, int *copymode, const int *offsets, int *elemrestriction, int *err) {
312 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
313 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
314 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
315 }
316
317 const int *offsets_ = offsets;
318
319 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
320 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize, (CeedMemType)*memtype,
321 (CeedCopyMode)*copymode, offsets_, elemrestriction_);
322
323 if (*err == 0) {
324 *elemrestriction = CeedElemRestriction_count++;
325 CeedElemRestriction_n++;
326 }
327 }
328
329 #define fCeedElemRestrictionCreateBlockedOriented FORTRAN_NAME(ceedelemrestrictioncreateblockedoriented, CEEDELEMRESTRICTIONCREATEBLOCKEDORIENTED)
fCeedElemRestrictionCreateBlockedOriented(int * ceed,int * nelements,int * esize,int * blocksize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,const bool * orients,int * elemrestriction,int * err)330 CEED_EXTERN void fCeedElemRestrictionCreateBlockedOriented(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride,
331 int *lsize, int *memtype, int *copymode, const int *offsets, const bool *orients,
332 int *elemrestriction, int *err) {
333 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
334 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
335 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
336 }
337
338 const int *offsets_ = offsets;
339 const bool *orients_ = orients;
340
341 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
342 *err = CeedElemRestrictionCreateBlockedOriented(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize,
343 (CeedMemType)*memtype, (CeedCopyMode)*copymode, offsets_, orients_, elemrestriction_);
344
345 if (*err == 0) {
346 *elemrestriction = CeedElemRestriction_count++;
347 CeedElemRestriction_n++;
348 }
349 }
350
351 #define fCeedElemRestrictionCreateBlockedCurlOriented \
352 FORTRAN_NAME(ceedelemrestrictioncreateblockedcurloriented, CEEDELEMRESTRICTIONCREATEBLOCKEDCURLORIENTED)
fCeedElemRestrictionCreateBlockedCurlOriented(int * ceed,int * nelements,int * esize,int * blocksize,int * num_comp,int * comp_stride,int * lsize,int * memtype,int * copymode,const int * offsets,const int8_t * curlorients,int * elemrestriction,int * err)353 CEED_EXTERN void fCeedElemRestrictionCreateBlockedCurlOriented(int *ceed, int *nelements, int *esize, int *blocksize, int *num_comp, int *comp_stride,
354 int *lsize, int *memtype, int *copymode, const int *offsets, const int8_t *curlorients,
355 int *elemrestriction, int *err) {
356 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
357 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
358 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
359 }
360
361 const int *offsets_ = offsets;
362 const int8_t *curlorients_ = curlorients;
363
364 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
365 *err = CeedElemRestrictionCreateBlockedCurlOriented(Ceed_dict[*ceed], *nelements, *esize, *blocksize, *num_comp, *comp_stride, *lsize,
366 (CeedMemType)*memtype, (CeedCopyMode)*copymode, offsets_, curlorients_, elemrestriction_);
367
368 if (*err == 0) {
369 *elemrestriction = CeedElemRestriction_count++;
370 CeedElemRestriction_n++;
371 }
372 }
373
374 #define fCeedElemRestrictionCreateBlockedStrided FORTRAN_NAME(ceedelemrestrictioncreateblockedstrided, CEEDELEMRESTRICTIONCREATEBLOCKEDSTRIDED)
fCeedElemRestrictionCreateBlockedStrided(int * ceed,int * nelements,int * esize,int * blk_size,int * num_comp,int * lsize,int * strides,int * elemrestriction,int * err)375 CEED_EXTERN void fCeedElemRestrictionCreateBlockedStrided(int *ceed, int *nelements, int *esize, int *blk_size, int *num_comp, int *lsize,
376 int *strides, int *elemrestriction, int *err) {
377 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
378 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
379 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
380 }
381
382 CeedElemRestriction *elemrestriction_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
383 *err = CeedElemRestrictionCreateBlockedStrided(Ceed_dict[*ceed], *nelements, *esize, *blk_size, *num_comp, *lsize, strides, elemrestriction_);
384
385 if (*err == 0) {
386 *elemrestriction = CeedElemRestriction_count++;
387 CeedElemRestriction_n++;
388 }
389 }
390
391 static CeedRequest *CeedRequest_dict = NULL;
392 static int CeedRequest_count = 0;
393 static int CeedRequest_n = 0;
394 static int CeedRequest_count_max = 0;
395
396 #define fCeedElemRestrictionApply FORTRAN_NAME(ceedelemrestrictionapply, CEEDELEMRESTRICTIONAPPLY)
fCeedElemRestrictionApply(int * elemr,int * tmode,int * uvec,int * ruvec,int * rqst,int * err)397 CEED_EXTERN void fCeedElemRestrictionApply(int *elemr, int *tmode, int *uvec, int *ruvec, int *rqst, int *err) {
398 int createRequest = 1;
399 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
400 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) createRequest = 0;
401
402 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
403 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
404 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
405 }
406
407 CeedRequest *rqst_;
408 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE;
409 else if (*rqst == FORTRAN_REQUEST_ORDERED) rqst_ = CEED_REQUEST_ORDERED;
410 else rqst_ = &CeedRequest_dict[CeedRequest_count];
411
412 *err =
413 CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], (CeedTransposeMode)*tmode, CeedVector_dict[*uvec], CeedVector_dict[*ruvec], rqst_);
414
415 if (*err == 0 && createRequest) {
416 *rqst = CeedRequest_count++;
417 CeedRequest_n++;
418 }
419 }
420
421 #define fCeedElemRestrictionApplyBlock FORTRAN_NAME(ceedelemrestrictionapplyblock, CEEDELEMRESTRICTIONAPPLYBLOCK)
fCeedElemRestrictionApplyBlock(int * elemr,int * block,int * tmode,int * uvec,int * ruvec,int * rqst,int * err)422 CEED_EXTERN void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, int *uvec, int *ruvec, int *rqst, int *err) {
423 int createRequest = 1;
424 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
425 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) createRequest = 0;
426
427 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
428 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
429 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
430 }
431
432 CeedRequest *rqst_;
433 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE;
434 else if (*rqst == FORTRAN_REQUEST_ORDERED) rqst_ = CEED_REQUEST_ORDERED;
435 else rqst_ = &CeedRequest_dict[CeedRequest_count];
436
437 *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, (CeedTransposeMode)*tmode, CeedVector_dict[*uvec],
438 CeedVector_dict[*ruvec], rqst_);
439
440 if (*err == 0 && createRequest) {
441 *rqst = CeedRequest_count++;
442 CeedRequest_n++;
443 }
444 }
445
446 #define fCeedElemRestrictionGetMultiplicity FORTRAN_NAME(ceedelemrestrictiongetmultiplicity, CEEDELEMRESTRICTIONGETMULTIPLICITY)
fCeedElemRestrictionGetMultiplicity(int * elemr,int * mult,int * err)447 CEED_EXTERN void fCeedElemRestrictionGetMultiplicity(int *elemr, int *mult, int *err) {
448 *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], CeedVector_dict[*mult]);
449 }
450
451 #define fCeedElemRestrictionGetELayout FORTRAN_NAME(ceedelemrestrictiongetelayout, CEEDELEMRESTRICTIONGETELAYOUT)
fCeedElemRestrictionGetELayout(int * elemr,int * layout,int * err)452 CEED_EXTERN void fCeedElemRestrictionGetELayout(int *elemr, int *layout, int *err) {
453 CeedInt layout_c[3];
454 *err = CeedElemRestrictionGetELayout(CeedElemRestriction_dict[*elemr], layout_c);
455 for (int i = 0; i < 3; i++) layout[i] = layout_c[i];
456 }
457
458 #define fCeedElemRestrictionSetNumViewTabs FORTRAN_NAME(ceedelemrestrictionsetnumviewtabs, CEEDELEMRESTRICTIONSETNUMVIEWTABS)
fCeedElemRestrictionSetNumViewTabs(int * elemr,int * num_tabs,int * err)459 CEED_EXTERN void fCeedElemRestrictionSetNumViewTabs(int *elemr, int *num_tabs, int *err) {
460 *err = CeedElemRestrictionSetNumViewTabs(CeedElemRestriction_dict[*elemr], *num_tabs);
461 }
462
463 #define fCeedElemRestrictionView FORTRAN_NAME(ceedelemrestrictionview, CEEDELEMRESTRICTIONVIEW)
fCeedElemRestrictionView(int * elemr,int * err)464 CEED_EXTERN void fCeedElemRestrictionView(int *elemr, int *err) { *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); }
465
466 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT)
fCeedRequestWait(int * rqst,int * err)467 CEED_EXTERN void fCeedRequestWait(int *rqst, int *err) {
468 // TODO Uncomment this once CeedRequestWait is implemented
469 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]);
470
471 if (*err == 0) {
472 CeedRequest_n--;
473 if (CeedRequest_n == 0) {
474 CeedFree(&CeedRequest_dict);
475 CeedRequest_count = 0;
476 CeedRequest_count_max = 0;
477 }
478 }
479 }
480
481 #define fCeedElemRestrictionDestroy FORTRAN_NAME(ceedelemrestrictiondestroy, CEEDELEMRESTRICTIONDESTROY)
fCeedElemRestrictionDestroy(int * elem,int * err)482 CEED_EXTERN void fCeedElemRestrictionDestroy(int *elem, int *err) {
483 if (*elem == FORTRAN_NULL) return;
484 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]);
485
486 if (*err == 0) {
487 *elem = FORTRAN_NULL;
488 CeedElemRestriction_n--;
489 if (CeedElemRestriction_n == 0) {
490 CeedFree(&CeedElemRestriction_dict);
491 CeedElemRestriction_count = 0;
492 CeedElemRestriction_count_max = 0;
493 }
494 }
495 }
496
497 // -----------------------------------------------------------------------------
498 // CeedBasis
499 // -----------------------------------------------------------------------------
500 static CeedBasis *CeedBasis_dict = NULL;
501 static int CeedBasis_count = 0;
502 static int CeedBasis_n = 0;
503 static int CeedBasis_count_max = 0;
504
505 #define fCeedBasisCreateTensorH1Lagrange FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE)
fCeedBasisCreateTensorH1Lagrange(int * ceed,int * dim,int * num_comp,int * P,int * Q,int * quadmode,int * basis,int * err)506 CEED_EXTERN void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, int *num_comp, int *P, int *Q, int *quadmode, int *basis, int *err) {
507 if (CeedBasis_count == CeedBasis_count_max) {
508 CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
509 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
510 }
511
512 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *num_comp, *P, *Q, (CeedQuadMode)*quadmode, &CeedBasis_dict[CeedBasis_count]);
513
514 if (*err == 0) {
515 *basis = CeedBasis_count++;
516 CeedBasis_n++;
517 }
518 }
519
520 #define fCeedBasisCreateTensorH1 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1)
fCeedBasisCreateTensorH1(int * ceed,int * dim,int * num_comp,int * P_1d,int * Q_1d,const CeedScalar * interp_1d,const CeedScalar * grad_1d,const CeedScalar * q_ref_1d,const CeedScalar * q_weight_1d,int * basis,int * err)521 CEED_EXTERN void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *num_comp, int *P_1d, int *Q_1d, const CeedScalar *interp_1d,
522 const CeedScalar *grad_1d, const CeedScalar *q_ref_1d, const CeedScalar *q_weight_1d, int *basis,
523 int *err) {
524 if (CeedBasis_count == CeedBasis_count_max) {
525 CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
526 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
527 }
528
529 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *num_comp, *P_1d, *Q_1d, interp_1d, grad_1d, q_ref_1d, q_weight_1d,
530 &CeedBasis_dict[CeedBasis_count]);
531
532 if (*err == 0) {
533 *basis = CeedBasis_count++;
534 CeedBasis_n++;
535 }
536 }
537
538 #define fCeedBasisCreateH1 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1)
fCeedBasisCreateH1(int * ceed,int * topo,int * num_comp,int * nnodes,int * nqpts,const CeedScalar * interp,const CeedScalar * grad,const CeedScalar * qref,const CeedScalar * qweight,int * basis,int * err)539 CEED_EXTERN void fCeedBasisCreateH1(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *grad,
540 const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) {
541 if (CeedBasis_count == CeedBasis_count_max) {
542 CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
543 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
544 }
545
546 *err = CeedBasisCreateH1(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, grad, qref, qweight,
547 &CeedBasis_dict[CeedBasis_count]);
548
549 if (*err == 0) {
550 *basis = CeedBasis_count++;
551 CeedBasis_n++;
552 }
553 }
554
555 #define fCeedBasisCreateHdiv FORTRAN_NAME(ceedbasiscreatehdiv, CEEDBASISCREATEHDIV)
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)556 CEED_EXTERN void fCeedBasisCreateHdiv(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *div,
557 const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) {
558 if (CeedBasis_count == CeedBasis_count_max) {
559 CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
560 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
561 }
562
563 *err = CeedBasisCreateHdiv(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, div, qref, qweight,
564 &CeedBasis_dict[CeedBasis_count]);
565
566 if (*err == 0) {
567 *basis = CeedBasis_count++;
568 CeedBasis_n++;
569 }
570 }
571
572 #define fCeedBasisCreateHcurl FORTRAN_NAME(ceedbasiscreatehcurl, CEEDBASISCREATEHCURL)
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)573 CEED_EXTERN void fCeedBasisCreateHcurl(int *ceed, int *topo, int *num_comp, int *nnodes, int *nqpts, const CeedScalar *interp, const CeedScalar *curl,
574 const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) {
575 if (CeedBasis_count == CeedBasis_count_max) {
576 CeedBasis_count_max += CeedBasis_count_max / 2 + 1;
577 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict);
578 }
579
580 *err = CeedBasisCreateHcurl(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, *nnodes, *nqpts, interp, curl, qref, qweight,
581 &CeedBasis_dict[CeedBasis_count]);
582
583 if (*err == 0) {
584 *basis = CeedBasis_count++;
585 CeedBasis_n++;
586 }
587 }
588
589 #define fCeedBasisSetNumViewTabs FORTRAN_NAME(ceedbasissetnumviewtabs, CEEDBASISSETNUMVIEWTABS)
fCeedBasisSetNumViewTabs(int * basis,int * num_tabs,int * err)590 CEED_EXTERN void fCeedBasisSetNumViewTabs(int *basis, int *num_tabs, int *err) { *err = CeedBasisSetNumViewTabs(CeedBasis_dict[*basis], *num_tabs); }
591
592 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW)
fCeedBasisView(int * basis,int * err)593 CEED_EXTERN void fCeedBasisView(int *basis, int *err) { *err = CeedBasisView(CeedBasis_dict[*basis], stdout); }
594
595 #define fCeedBasisGetCollocatedGrad FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD)
fCeedBasisGetCollocatedGrad(int * basis,CeedScalar * colo_grad_1d,int * err)596 CEED_EXTERN void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colo_grad_1d, int *err) {
597 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colo_grad_1d);
598 }
599
600 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY)
fCeedBasisApply(int * basis,int * num_elem,int * tmode,int * eval_mode,int * u,int * v,int * err)601 CEED_EXTERN void fCeedBasisApply(int *basis, int *num_elem, int *tmode, int *eval_mode, int *u, int *v, int *err) {
602 *err = CeedBasisApply(CeedBasis_dict[*basis], *num_elem, (CeedTransposeMode)*tmode, (CeedEvalMode)*eval_mode,
603 *u == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*u], CeedVector_dict[*v]);
604 }
605
606 #define fCeedBasisGetNumNodes FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES)
fCeedBasisGetNumNodes(int * basis,int * P,int * err)607 CEED_EXTERN void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); }
608
609 #define fCeedBasisGetNumQuadraturePoints FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS)
fCeedBasisGetNumQuadraturePoints(int * basis,int * Q,int * err)610 CEED_EXTERN void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); }
611
612 #define fCeedBasisGetInterp1D FORTRAN_NAME(ceedbasisgetinterp1d, CEEDBASISGETINTERP1D)
fCeedBasisGetInterp1D(int * basis,CeedScalar * interp_1d,int64_t * offset,int * err)613 CEED_EXTERN void fCeedBasisGetInterp1D(int *basis, CeedScalar *interp_1d, int64_t *offset, int *err) {
614 const CeedScalar *interp1d_;
615 CeedBasis basis_ = CeedBasis_dict[*basis];
616 *err = CeedBasisGetInterp1D(basis_, &interp1d_);
617 *offset = interp1d_ - interp_1d;
618 }
619
620 #define fCeedBasisGetGrad1D FORTRAN_NAME(ceedbasisgetgrad1d, CEEDBASISGETGRAD1D)
fCeedBasisGetGrad1D(int * basis,CeedScalar * grad_1d,int64_t * offset,int * err)621 CEED_EXTERN void fCeedBasisGetGrad1D(int *basis, CeedScalar *grad_1d, int64_t *offset, int *err) {
622 const CeedScalar *grad1d_;
623 CeedBasis basis_ = CeedBasis_dict[*basis];
624 *err = CeedBasisGetGrad1D(basis_, &grad1d_);
625 *offset = grad1d_ - grad_1d;
626 }
627
628 #define fCeedBasisGetQRef FORTRAN_NAME(ceedbasisgetqref, CEEDBASISGETQREF)
fCeedBasisGetQRef(int * basis,CeedScalar * q_ref,int64_t * offset,int * err)629 CEED_EXTERN void fCeedBasisGetQRef(int *basis, CeedScalar *q_ref, int64_t *offset, int *err) {
630 const CeedScalar *qref_;
631 CeedBasis basis_ = CeedBasis_dict[*basis];
632 *err = CeedBasisGetQRef(basis_, &qref_);
633 *offset = qref_ - q_ref;
634 }
635
636 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy, CEEDBASISDESTROY)
fCeedBasisDestroy(int * basis,int * err)637 CEED_EXTERN void fCeedBasisDestroy(int *basis, int *err) {
638 if (*basis == FORTRAN_NULL) return;
639 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]);
640
641 if (*err == 0) {
642 *basis = FORTRAN_NULL;
643 CeedBasis_n--;
644 if (CeedBasis_n == 0) {
645 CeedFree(&CeedBasis_dict);
646 CeedBasis_count = 0;
647 CeedBasis_count_max = 0;
648 }
649 }
650 }
651
652 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE)
fCeedGaussQuadrature(int * Q,CeedScalar * q_ref_1d,CeedScalar * q_weight_1d,int * err)653 CEED_EXTERN void fCeedGaussQuadrature(int *Q, CeedScalar *q_ref_1d, CeedScalar *q_weight_1d, int *err) {
654 *err = CeedGaussQuadrature(*Q, q_ref_1d, q_weight_1d);
655 }
656
657 #define fCeedLobattoQuadrature FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE)
fCeedLobattoQuadrature(int * Q,CeedScalar * q_ref_1d,CeedScalar * q_weight_1d,int * err)658 CEED_EXTERN void fCeedLobattoQuadrature(int *Q, CeedScalar *q_ref_1d, CeedScalar *q_weight_1d, int *err) {
659 *err = CeedLobattoQuadrature(*Q, q_ref_1d, q_weight_1d);
660 }
661
662 // -----------------------------------------------------------------------------
663 // CeedQFunctionContext
664 // -----------------------------------------------------------------------------
665 static CeedQFunctionContext *CeedQFunctionContext_dict = NULL;
666 static int CeedQFunctionContext_count = 0;
667 static int CeedQFunctionContext_n = 0;
668 static int CeedQFunctionContext_count_max = 0;
669
670 #define fCeedQFunctionContextCreate FORTRAN_NAME(ceedqfunctioncontextcreate, CEEDQFUNCTIONCONTEXTCREATE)
fCeedQFunctionContextCreate(int * ceed,int * ctx,int * err)671 CEED_EXTERN void fCeedQFunctionContextCreate(int *ceed, int *ctx, int *err) {
672 if (CeedQFunctionContext_count == CeedQFunctionContext_count_max) {
673 CeedQFunctionContext_count_max += CeedQFunctionContext_count_max / 2 + 1;
674 CeedRealloc(CeedQFunctionContext_count_max, &CeedQFunctionContext_dict);
675 }
676
677 CeedQFunctionContext *ctx_ = &CeedQFunctionContext_dict[CeedQFunctionContext_count];
678
679 *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], ctx_);
680 if (*err) return;
681 *ctx = CeedQFunctionContext_count++;
682 CeedQFunctionContext_n++;
683 }
684
685 #define fCeedQFunctionContextSetData FORTRAN_NAME(ceedqfunctioncontextsetdata, CEEDQFUNCTIONCONTEXTSETDATA)
fCeedQFunctionContextSetData(int * ctx,int * memtype,int * copymode,CeedInt * n,CeedScalar * data,int64_t * offset,int * err)686 CEED_EXTERN void fCeedQFunctionContextSetData(int *ctx, int *memtype, int *copymode, CeedInt *n, CeedScalar *data, int64_t *offset, int *err) {
687 size_t ctx_size = ((size_t)*n) * sizeof(CeedScalar);
688 *err = CeedQFunctionContextSetData(CeedQFunctionContext_dict[*ctx], (CeedMemType)*memtype, (CeedCopyMode)*copymode, ctx_size, data + *offset);
689 }
690
691 #define fCeedQFunctionContextGetData FORTRAN_NAME(ceedqfunctioncontextgetdata, CEEDQFUNCTIONCONTEXTGETDATA)
fCeedQFunctionContextGetData(int * ctx,int * memtype,CeedScalar * data,int64_t * offset,int * err)692 CEED_EXTERN void fCeedQFunctionContextGetData(int *ctx, int *memtype, CeedScalar *data, int64_t *offset, int *err) {
693 CeedScalar *b;
694 CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx];
695 *err = CeedQFunctionContextGetData(ctx_, (CeedMemType)*memtype, &b);
696 *offset = b - data;
697 }
698
699 #define fCeedQFunctionContextRestoreData FORTRAN_NAME(ceedqfunctioncontextrestoredata, CEEDQFUNCTIONCONTEXTRESTOREDATA)
fCeedQFunctionContextRestoreData(int * ctx,CeedScalar * data,int64_t * offset,int * err)700 CEED_EXTERN void fCeedQFunctionContextRestoreData(int *ctx, CeedScalar *data, int64_t *offset, int *err) {
701 *err = CeedQFunctionContextRestoreData(CeedQFunctionContext_dict[*ctx], (void **)&data);
702 *offset = 0;
703 }
704
705 #define fCeedQFunctionContextSetNumViewTabs FORTRAN_NAME(ceedqfunctioncontextsetnumviewtabs, CEEDQFUNCTIONCONTEXTSETNUMVIEWTABS)
fCeedQFunctionContextSetNumViewTabs(int * ctx,int * num_tabs,int * err)706 CEED_EXTERN void fCeedQFunctionContextSetNumViewTabs(int *ctx, int *num_tabs, int *err) {
707 *err = CeedQFunctionContextSetNumViewTabs(CeedQFunctionContext_dict[*ctx], *num_tabs);
708 }
709
710 #define fCeedQFunctionContextView FORTRAN_NAME(ceedqfunctioncontextview, CEEDQFUNCTIONCONTEXTVIEW)
fCeedQFunctionContextView(int * ctx,int * err)711 CEED_EXTERN void fCeedQFunctionContextView(int *ctx, int *err) { *err = CeedQFunctionContextView(CeedQFunctionContext_dict[*ctx], stdout); }
712
713 #define fCeedQFunctionContextDestroy FORTRAN_NAME(ceedqfunctioncontextdestroy, CEEDQFUNCTIONCONTEXTDESTROY)
fCeedQFunctionContextDestroy(int * ctx,int * err)714 CEED_EXTERN void fCeedQFunctionContextDestroy(int *ctx, int *err) {
715 if (*ctx == FORTRAN_NULL) return;
716 *err = CeedQFunctionContextDestroy(&CeedQFunctionContext_dict[*ctx]);
717
718 if (*err == 0) {
719 *ctx = FORTRAN_NULL;
720 CeedQFunctionContext_n--;
721 if (CeedQFunctionContext_n == 0) {
722 CeedFree(&CeedQFunctionContext_dict);
723 CeedQFunctionContext_count = 0;
724 CeedQFunctionContext_count_max = 0;
725 }
726 }
727 }
728
729 // -----------------------------------------------------------------------------
730 // CeedQFunction
731 // -----------------------------------------------------------------------------
732 static CeedQFunction *CeedQFunction_dict = NULL;
733 static int CeedQFunction_count = 0;
734 static int CeedQFunction_n = 0;
735 static int CeedQFunction_count_max = 0;
736
CeedQFunctionFortranStub(void * ctx,int nq,const CeedScalar * const * u,CeedScalar * const * v)737 static int CeedQFunctionFortranStub(void *ctx, int nq, const CeedScalar *const *u, CeedScalar *const *v) {
738 CeedFortranContext fctx = ctx;
739 CeedQFunctionContext inner_ctx = fctx->inner_ctx;
740 int ierr;
741
742 CeedScalar *ctx_ = NULL;
743 // Note: Device backends are generating their own kernels from
744 // single source files, so only Host backends need to
745 // use this Fortran stub.
746 if (inner_ctx) {
747 ierr = CeedQFunctionContextGetData(inner_ctx, CEED_MEM_HOST, &ctx_);
748 CeedCall(ierr);
749 }
750
751 fctx->f((void *)ctx_, &nq, u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7], u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], v[0], v[1], v[2],
752 v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15], &ierr);
753
754 if (inner_ctx) {
755 ierr = CeedQFunctionContextRestoreData(inner_ctx, &ctx_);
756 CeedCall(ierr);
757 }
758
759 return ierr;
760 }
761
762 #define fCeedQFunctionCreateInterior FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR)
fCeedQFunctionCreateInterior(int * ceed,int * vec_length,void (* f)(void * ctx,int * nq,const CeedScalar * u,const CeedScalar * u1,const CeedScalar * u2,const CeedScalar * u3,const CeedScalar * u4,const CeedScalar * u5,const CeedScalar * u6,const CeedScalar * u7,const CeedScalar * u8,const CeedScalar * u9,const CeedScalar * u10,const CeedScalar * u11,const CeedScalar * u12,const CeedScalar * u13,const CeedScalar * u14,const CeedScalar * u15,CeedScalar * v,CeedScalar * v1,CeedScalar * v2,CeedScalar * v3,CeedScalar * v4,CeedScalar * v5,CeedScalar * v6,CeedScalar * v7,CeedScalar * v8,CeedScalar * v9,CeedScalar * v10,CeedScalar * v11,CeedScalar * v12,CeedScalar * v13,CeedScalar * v14,CeedScalar * v15,int * err),const char * source,int * qf,int * err,fortran_charlen_t source_len)763 CEED_EXTERN void fCeedQFunctionCreateInterior(
764 int *ceed, int *vec_length,
765 void (*f)(void *ctx, int *nq, const CeedScalar *u, const CeedScalar *u1, const CeedScalar *u2, const CeedScalar *u3, const CeedScalar *u4,
766 const CeedScalar *u5, const CeedScalar *u6, const CeedScalar *u7, const CeedScalar *u8, const CeedScalar *u9, const CeedScalar *u10,
767 const CeedScalar *u11, const CeedScalar *u12, const CeedScalar *u13, const CeedScalar *u14, const CeedScalar *u15, CeedScalar *v,
768 CeedScalar *v1, CeedScalar *v2, CeedScalar *v3, CeedScalar *v4, CeedScalar *v5, CeedScalar *v6, CeedScalar *v7, CeedScalar *v8,
769 CeedScalar *v9, CeedScalar *v10, CeedScalar *v11, CeedScalar *v12, CeedScalar *v13, CeedScalar *v14, CeedScalar *v15, int *err),
770 const char *source, int *qf, int *err, fortran_charlen_t source_len) {
771 FIX_STRING(source);
772 if (CeedQFunction_count == CeedQFunction_count_max) {
773 CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1;
774 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict);
775 }
776
777 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count];
778 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vec_length, CeedQFunctionFortranStub, source_c, qf_);
779
780 if (*err == 0) {
781 *qf = CeedQFunction_count++;
782 CeedQFunction_n++;
783 }
784
785 CeedFortranContext fctxdata;
786 *err = CeedCalloc(1, &fctxdata);
787 if (*err) return;
788 fctxdata->f = f;
789 fctxdata->inner_ctx = NULL;
790 CeedQFunctionContext fctx;
791 *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], &fctx);
792 if (*err) return;
793 *err = CeedQFunctionContextSetData(fctx, CEED_MEM_HOST, CEED_OWN_POINTER, sizeof(*fctxdata), fctxdata);
794 if (*err) return;
795 *err = CeedQFunctionSetContext(*qf_, fctx);
796 if (*err) return;
797 CeedQFunctionContextDestroy(&fctx);
798 if (*err) return;
799
800 *err = CeedQFunctionSetFortranStatus(*qf_, true);
801 }
802
803 #define fCeedQFunctionCreateInteriorByName FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME)
fCeedQFunctionCreateInteriorByName(int * ceed,const char * name,int * qf,int * err,fortran_charlen_t name_len)804 CEED_EXTERN void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, int *err, fortran_charlen_t name_len) {
805 FIX_STRING(name);
806 if (CeedQFunction_count == CeedQFunction_count_max) {
807 CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1;
808 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict);
809 }
810
811 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count];
812 *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_);
813
814 if (*err == 0) {
815 *qf = CeedQFunction_count++;
816 CeedQFunction_n++;
817 }
818 }
819
820 #define fCeedQFunctionCreateIdentity FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY)
fCeedQFunctionCreateIdentity(int * ceed,int * size,int * inmode,int * outmode,int * qf,int * err)821 CEED_EXTERN void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, int *outmode, int *qf, int *err) {
822 if (CeedQFunction_count == CeedQFunction_count_max) {
823 CeedQFunction_count_max += CeedQFunction_count_max / 2 + 1;
824 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict);
825 }
826
827 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count];
828 *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, (CeedEvalMode)*inmode, (CeedEvalMode)*outmode, qf_);
829
830 if (*err == 0) {
831 *qf = CeedQFunction_count++;
832 CeedQFunction_n++;
833 }
834 }
835
836 #define fCeedQFunctionAddInput FORTRAN_NAME(ceedqfunctionaddinput, CEEDQFUNCTIONADDINPUT)
fCeedQFunctionAddInput(int * qf,const char * field_name,CeedInt * num_comp,CeedEvalMode * eval_mode,int * err,fortran_charlen_t field_name_len)837 CEED_EXTERN void fCeedQFunctionAddInput(int *qf, const char *field_name, CeedInt *num_comp, CeedEvalMode *eval_mode, int *err,
838 fortran_charlen_t field_name_len) {
839 FIX_STRING(field_name);
840 CeedQFunction qf_ = CeedQFunction_dict[*qf];
841
842 *err = CeedQFunctionAddInput(qf_, field_name_c, *num_comp, *eval_mode);
843 }
844
845 #define fCeedQFunctionAddOutput FORTRAN_NAME(ceedqfunctionaddoutput, CEEDQFUNCTIONADDOUTPUT)
fCeedQFunctionAddOutput(int * qf,const char * field_name,CeedInt * num_comp,CeedEvalMode * eval_mode,int * err,fortran_charlen_t field_name_len)846 CEED_EXTERN void fCeedQFunctionAddOutput(int *qf, const char *field_name, CeedInt *num_comp, CeedEvalMode *eval_mode, int *err,
847 fortran_charlen_t field_name_len) {
848 FIX_STRING(field_name);
849 CeedQFunction qf_ = CeedQFunction_dict[*qf];
850
851 *err = CeedQFunctionAddOutput(qf_, field_name_c, *num_comp, *eval_mode);
852 }
853
854 #define fCeedQFunctionSetContext FORTRAN_NAME(ceedqfunctionsetcontext, CEEDQFUNCTIONSETCONTEXT)
fCeedQFunctionSetContext(int * qf,int * ctx,int * err)855 CEED_EXTERN void fCeedQFunctionSetContext(int *qf, int *ctx, int *err) {
856 CeedQFunction qf_ = CeedQFunction_dict[*qf];
857 CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx];
858
859 CeedQFunctionContext fctx;
860 *err = CeedQFunctionGetContext(qf_, &fctx);
861 if (*err) return;
862 CeedFortranContext fctxdata;
863 *err = CeedQFunctionContextGetData(fctx, CEED_MEM_HOST, &fctxdata);
864 if (*err) return;
865 fctxdata->inner_ctx = ctx_;
866 *err = CeedQFunctionContextRestoreData(fctx, (void **)&fctxdata);
867 if (*err) return;
868 *err = CeedQFunctionContextDestroy(&fctx);
869 }
870
871 #define fCeedQFunctionSetNumViewTabs FORTRAN_NAME(ceedqfunctionsetnumviewtabs, CEEDQFUNCTIONSETNUMVIEWTABS)
fCeedQFunctionSetNumViewTabs(int * qf,int * num_tabs,int * err)872 CEED_EXTERN void fCeedQFunctionSetNumViewTabs(int *qf, int *num_tabs, int *err) {
873 *err = CeedQFunctionSetNumViewTabs(CeedQFunction_dict[*qf], *num_tabs);
874 }
875
876 #define fCeedQFunctionView FORTRAN_NAME(ceedqfunctionview, CEEDQFUNCTIONVIEW)
fCeedQFunctionView(int * qf,int * err)877 CEED_EXTERN void fCeedQFunctionView(int *qf, int *err) {
878 CeedQFunction qf_ = CeedQFunction_dict[*qf];
879
880 *err = CeedQFunctionView(qf_, stdout);
881 }
882
883 #define fCeedQFunctionApply FORTRAN_NAME(ceedqfunctionapply, CEEDQFUNCTIONAPPLY)
884 // TODO Need Fixing, double pointer
fCeedQFunctionApply(int * qf,int * Q,int * u,int * u1,int * u2,int * u3,int * u4,int * u5,int * u6,int * u7,int * u8,int * u9,int * u10,int * u11,int * u12,int * u13,int * u14,int * u15,int * v,int * v1,int * v2,int * v3,int * v4,int * v5,int * v6,int * v7,int * v8,int * v9,int * v10,int * v11,int * v12,int * v13,int * v14,int * v15,int * err)885 CEED_EXTERN void fCeedQFunctionApply(int *qf, int *Q, int *u, int *u1, int *u2, int *u3, int *u4, int *u5, int *u6, int *u7, int *u8, int *u9,
886 int *u10, int *u11, int *u12, int *u13, int *u14, int *u15, int *v, int *v1, int *v2, int *v3, int *v4, int *v5,
887 int *v6, int *v7, int *v8, int *v9, int *v10, int *v11, int *v12, int *v13, int *v14, int *v15, int *err) {
888 CeedQFunction qf_ = CeedQFunction_dict[*qf];
889 CeedVector *in;
890 *err = CeedCalloc(CEED_FIELD_MAX, &in);
891 if (*err) return;
892 in[0] = *u == FORTRAN_NULL ? NULL : CeedVector_dict[*u];
893 in[1] = *u1 == FORTRAN_NULL ? NULL : CeedVector_dict[*u1];
894 in[2] = *u2 == FORTRAN_NULL ? NULL : CeedVector_dict[*u2];
895 in[3] = *u3 == FORTRAN_NULL ? NULL : CeedVector_dict[*u3];
896 in[4] = *u4 == FORTRAN_NULL ? NULL : CeedVector_dict[*u4];
897 in[5] = *u5 == FORTRAN_NULL ? NULL : CeedVector_dict[*u5];
898 in[6] = *u6 == FORTRAN_NULL ? NULL : CeedVector_dict[*u6];
899 in[7] = *u7 == FORTRAN_NULL ? NULL : CeedVector_dict[*u7];
900 in[8] = *u8 == FORTRAN_NULL ? NULL : CeedVector_dict[*u8];
901 in[9] = *u9 == FORTRAN_NULL ? NULL : CeedVector_dict[*u9];
902 in[10] = *u10 == FORTRAN_NULL ? NULL : CeedVector_dict[*u10];
903 in[11] = *u11 == FORTRAN_NULL ? NULL : CeedVector_dict[*u11];
904 in[12] = *u12 == FORTRAN_NULL ? NULL : CeedVector_dict[*u12];
905 in[13] = *u13 == FORTRAN_NULL ? NULL : CeedVector_dict[*u13];
906 in[14] = *u14 == FORTRAN_NULL ? NULL : CeedVector_dict[*u14];
907 in[15] = *u15 == FORTRAN_NULL ? NULL : CeedVector_dict[*u15];
908 CeedVector *out;
909 *err = CeedCalloc(CEED_FIELD_MAX, &out);
910 if (*err) return;
911 out[0] = *v == FORTRAN_NULL ? NULL : CeedVector_dict[*v];
912 out[1] = *v1 == FORTRAN_NULL ? NULL : CeedVector_dict[*v1];
913 out[2] = *v2 == FORTRAN_NULL ? NULL : CeedVector_dict[*v2];
914 out[3] = *v3 == FORTRAN_NULL ? NULL : CeedVector_dict[*v3];
915 out[4] = *v4 == FORTRAN_NULL ? NULL : CeedVector_dict[*v4];
916 out[5] = *v5 == FORTRAN_NULL ? NULL : CeedVector_dict[*v5];
917 out[6] = *v6 == FORTRAN_NULL ? NULL : CeedVector_dict[*v6];
918 out[7] = *v7 == FORTRAN_NULL ? NULL : CeedVector_dict[*v7];
919 out[8] = *v8 == FORTRAN_NULL ? NULL : CeedVector_dict[*v8];
920 out[9] = *v9 == FORTRAN_NULL ? NULL : CeedVector_dict[*v9];
921 out[10] = *v10 == FORTRAN_NULL ? NULL : CeedVector_dict[*v10];
922 out[11] = *v11 == FORTRAN_NULL ? NULL : CeedVector_dict[*v11];
923 out[12] = *v12 == FORTRAN_NULL ? NULL : CeedVector_dict[*v12];
924 out[13] = *v13 == FORTRAN_NULL ? NULL : CeedVector_dict[*v13];
925 out[14] = *v14 == FORTRAN_NULL ? NULL : CeedVector_dict[*v14];
926 out[15] = *v15 == FORTRAN_NULL ? NULL : CeedVector_dict[*v15];
927 *err = CeedQFunctionApply(qf_, *Q, in, out);
928 if (*err) return;
929
930 *err = CeedFree(&in);
931 if (*err) return;
932 *err = CeedFree(&out);
933 }
934
935 #define fCeedQFunctionDestroy FORTRAN_NAME(ceedqfunctiondestroy, CEEDQFUNCTIONDESTROY)
fCeedQFunctionDestroy(int * qf,int * err)936 CEED_EXTERN void fCeedQFunctionDestroy(int *qf, int *err) {
937 if (*qf == FORTRAN_NULL) return;
938
939 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]);
940 if (*err == 0) {
941 *qf = FORTRAN_NULL;
942 CeedQFunction_n--;
943 if (CeedQFunction_n == 0) {
944 *err = CeedFree(&CeedQFunction_dict);
945 CeedQFunction_count = 0;
946 CeedQFunction_count_max = 0;
947 }
948 }
949 }
950
951 // -----------------------------------------------------------------------------
952 // CeedOperator
953 // -----------------------------------------------------------------------------
954 static CeedOperator *CeedOperator_dict = NULL;
955 static int CeedOperator_count = 0;
956 static int CeedOperator_n = 0;
957 static int CeedOperator_count_max = 0;
958
959 #define fCeedOperatorCreate FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE)
fCeedOperatorCreate(int * ceed,int * qf,int * dqf,int * dqfT,int * op,int * err)960 CEED_EXTERN void fCeedOperatorCreate(int *ceed, int *qf, int *dqf, int *dqfT, int *op, int *err) {
961 if (CeedOperator_count == CeedOperator_count_max) {
962 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
963 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
964 }
965
966 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count];
967
968 CeedQFunction dqf_ = CEED_QFUNCTION_NONE, dqfT_ = CEED_QFUNCTION_NONE;
969 if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_ = CeedQFunction_dict[*dqf];
970 if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_ = CeedQFunction_dict[*dqfT];
971
972 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, dqfT_, op_);
973 if (*err) return;
974 *op = CeedOperator_count++;
975 CeedOperator_n++;
976 }
977
978 #define fCeedOperatorCreateComposite FORTRAN_NAME(ceedoperatorcreatecomposite, CEEDOPERATORCREATECOMPOSITE)
fCeedOperatorCreateComposite(int * ceed,int * op,int * err)979 CEED_EXTERN void fCeedOperatorCreateComposite(int *ceed, int *op, int *err) {
980 if (CeedOperator_count == CeedOperator_count_max) {
981 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
982 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
983 }
984
985 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count];
986
987 *err = CeedOperatorCreateComposite(Ceed_dict[*ceed], op_);
988 if (*err) return;
989 *op = CeedOperator_count++;
990 CeedOperator_n++;
991 }
992
993 #define fCeedOperatorSetField FORTRAN_NAME(ceedoperatorsetfield, CEEDOPERATORSETFIELD)
fCeedOperatorSetField(int * op,const char * field_name,int * r,int * b,int * v,int * err,fortran_charlen_t field_name_len)994 CEED_EXTERN void fCeedOperatorSetField(int *op, const char *field_name, int *r, int *b, int *v, int *err, fortran_charlen_t field_name_len) {
995 FIX_STRING(field_name);
996 CeedElemRestriction r_;
997 CeedBasis b_;
998 CeedVector v_;
999
1000 CeedOperator op_ = CeedOperator_dict[*op];
1001
1002 if (*r == FORTRAN_NULL) {
1003 r_ = NULL;
1004 } else if (*r == FORTRAN_ELEMRESTRICTION_NONE) {
1005 r_ = CEED_ELEMRESTRICTION_NONE;
1006 } else {
1007 r_ = CeedElemRestriction_dict[*r];
1008 }
1009
1010 if (*b == FORTRAN_NULL) {
1011 b_ = NULL;
1012 } else if (*b == FORTRAN_BASIS_NONE) {
1013 b_ = CEED_BASIS_NONE;
1014 } else {
1015 b_ = CeedBasis_dict[*b];
1016 }
1017 if (*v == FORTRAN_NULL) {
1018 v_ = NULL;
1019 } else if (*v == FORTRAN_VECTOR_ACTIVE) {
1020 v_ = CEED_VECTOR_ACTIVE;
1021 } else if (*v == FORTRAN_VECTOR_NONE) {
1022 v_ = CEED_VECTOR_NONE;
1023 } else {
1024 v_ = CeedVector_dict[*v];
1025 }
1026
1027 *err = CeedOperatorSetField(op_, field_name_c, r_, b_, v_);
1028 }
1029
1030 #define fCeedOperatorCompositeAddSub FORTRAN_NAME(ceedoperatorcompositeaddsub, CEEDOPERATORCOMPOSITEADDSUB)
fCeedOperatorCompositeAddSub(int * compositeop,int * subop,int * err)1031 CEED_EXTERN void fCeedOperatorCompositeAddSub(int *compositeop, int *subop, int *err) {
1032 CeedOperator compositeop_ = CeedOperator_dict[*compositeop];
1033 CeedOperator subop_ = CeedOperator_dict[*subop];
1034
1035 *err = CeedOperatorCompositeAddSub(compositeop_, subop_);
1036 }
1037
1038 #define fCeedOperatorSetName FORTRAN_NAME(ceedoperatorsetname, CEEDOPERATORSETNAME)
fCeedOperatorSetName(int * op,const char * name,int * err,fortran_charlen_t name_len)1039 CEED_EXTERN void fCeedOperatorSetName(int *op, const char *name, int *err, fortran_charlen_t name_len) {
1040 FIX_STRING(name);
1041 CeedOperator op_ = CeedOperator_dict[*op];
1042
1043 *err = CeedOperatorSetName(op_, name_c);
1044 }
1045
1046 #define fCeedOperatorSetNumViewTabs FORTRAN_NAME(ceedoperatorsetnumviewtabs, CEEDOPERATORSETNUMVIEWTABS)
fCeedOperatorSetNumViewTabs(int * op,int * ntabs,int * err)1047 CEED_EXTERN void fCeedOperatorSetNumViewTabs(int *op, int *ntabs, int *err) {
1048 CeedOperator op_ = CeedOperator_dict[*op];
1049
1050 *err = CeedOperatorSetNumViewTabs(op_, *ntabs);
1051 }
1052
1053 #define fCeedOperatorLinearAssembleQFunction FORTRAN_NAME(ceedoperatorlinearassembleqfunction, CEEDOPERATORLINEARASSEMBLEQFUNCTION)
fCeedOperatorLinearAssembleQFunction(int * op,int * assembledvec,int * assembledrstr,int * rqst,int * err)1054 CEED_EXTERN void fCeedOperatorLinearAssembleQFunction(int *op, int *assembledvec, int *assembledrstr, int *rqst, int *err) {
1055 // Vector
1056 if (CeedVector_count == CeedVector_count_max) {
1057 CeedVector_count_max += CeedVector_count_max / 2 + 1;
1058 CeedRealloc(CeedVector_count_max, &CeedVector_dict);
1059 }
1060 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count];
1061
1062 // Restriction
1063 if (CeedElemRestriction_count == CeedElemRestriction_count_max) {
1064 CeedElemRestriction_count_max += CeedElemRestriction_count_max / 2 + 1;
1065 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict);
1066 }
1067 CeedElemRestriction *rstr_ = &CeedElemRestriction_dict[CeedElemRestriction_count];
1068
1069 int createRequest = 1;
1070 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
1071 if (*rqst == -1 || *rqst == -2) {
1072 createRequest = 0;
1073 }
1074
1075 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
1076 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
1077 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
1078 }
1079
1080 CeedRequest *rqst_;
1081 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE;
1082 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED;
1083 else rqst_ = &CeedRequest_dict[CeedRequest_count];
1084
1085 *err = CeedOperatorLinearAssembleQFunction(CeedOperator_dict[*op], assembledvec_, rstr_, rqst_);
1086 if (*err) return;
1087 if (createRequest) {
1088 *rqst = CeedRequest_count++;
1089 CeedRequest_n++;
1090 }
1091
1092 if (*err == 0) {
1093 *assembledrstr = CeedElemRestriction_count++;
1094 CeedElemRestriction_n++;
1095 *assembledvec = CeedVector_count++;
1096 CeedVector_n++;
1097 }
1098 }
1099
1100 #define fCeedOperatorLinearAssembleDiagonal FORTRAN_NAME(ceedoperatorlinearassemblediagonal, CEEDOPERATORLINEARASSEMBLEDIAGONAL)
fCeedOperatorLinearAssembleDiagonal(int * op,int * assembledvec,int * rqst,int * err)1101 CEED_EXTERN void fCeedOperatorLinearAssembleDiagonal(int *op, int *assembledvec, int *rqst, int *err) {
1102 int createRequest = 1;
1103 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
1104 if (*rqst == -1 || *rqst == -2) {
1105 createRequest = 0;
1106 }
1107
1108 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
1109 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
1110 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
1111 }
1112
1113 CeedRequest *rqst_;
1114 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE;
1115 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED;
1116 else rqst_ = &CeedRequest_dict[CeedRequest_count];
1117
1118 *err = CeedOperatorLinearAssembleDiagonal(CeedOperator_dict[*op], CeedVector_dict[*assembledvec], rqst_);
1119 if (*err) return;
1120 if (createRequest) {
1121 *rqst = CeedRequest_count++;
1122 CeedRequest_n++;
1123 }
1124 }
1125
1126 #define fCeedOperatorMultigridLevelCreate FORTRAN_NAME(ceedoperatormultigridlevelcreate, CEEDOPERATORMULTIGRIDLEVELCREATE)
fCeedOperatorMultigridLevelCreate(int * opFine,int * pMultFine,int * rstrCoarse,int * basisCoarse,int * opCoarse,int * opProlong,int * opRestrict,int * err)1127 CEED_EXTERN void fCeedOperatorMultigridLevelCreate(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse, int *opCoarse, int *opProlong,
1128 int *opRestrict, int *err) {
1129 // Operators
1130 CeedOperator opCoarse_, opProlong_, opRestrict_;
1131
1132 // C interface call
1133 *err = CeedOperatorMultigridLevelCreate(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse],
1134 CeedBasis_dict[*basisCoarse], &opCoarse_, &opProlong_, &opRestrict_);
1135
1136 if (*err) return;
1137 while (CeedOperator_count + 2 >= CeedOperator_count_max) {
1138 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
1139 }
1140 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
1141 CeedOperator_dict[CeedOperator_count] = opCoarse_;
1142 *opCoarse = CeedOperator_count++;
1143 CeedOperator_dict[CeedOperator_count] = opProlong_;
1144 *opProlong = CeedOperator_count++;
1145 CeedOperator_dict[CeedOperator_count] = opRestrict_;
1146 *opRestrict = CeedOperator_count++;
1147 CeedOperator_n += 3;
1148 }
1149
1150 #define fCeedOperatorMultigridLevelCreateTensorH1 FORTRAN_NAME(ceedoperatormultigridlevelcreatetensorh1, CEEDOPERATORMULTIGRIDLEVELCREATETENSORH1)
fCeedOperatorMultigridLevelCreateTensorH1(int * opFine,int * pMultFine,int * rstrCoarse,int * basisCoarse,const CeedScalar * interpCtoF,int * opCoarse,int * opProlong,int * opRestrict,int * err)1151 CEED_EXTERN void fCeedOperatorMultigridLevelCreateTensorH1(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse,
1152 const CeedScalar *interpCtoF, int *opCoarse, int *opProlong, int *opRestrict, int *err) {
1153 // Operators
1154 CeedOperator opCoarse_, opProlong_, opRestrict_;
1155
1156 // C interface call
1157 *err = CeedOperatorMultigridLevelCreateTensorH1(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse],
1158 CeedBasis_dict[*basisCoarse], interpCtoF, &opCoarse_, &opProlong_, &opRestrict_);
1159
1160 if (*err) return;
1161 while (CeedOperator_count + 2 >= CeedOperator_count_max) {
1162 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
1163 }
1164 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
1165 CeedOperator_dict[CeedOperator_count] = opCoarse_;
1166 *opCoarse = CeedOperator_count++;
1167 CeedOperator_dict[CeedOperator_count] = opProlong_;
1168 *opProlong = CeedOperator_count++;
1169 CeedOperator_dict[CeedOperator_count] = opRestrict_;
1170 *opRestrict = CeedOperator_count++;
1171 CeedOperator_n += 3;
1172 }
1173
1174 #define fCeedOperatorMultigridLevelCreateH1 FORTRAN_NAME(ceedoperatormultigridlevelcreateh1, CEEDOPERATORMULTIGRIDLEVELCREATEH1)
fCeedOperatorMultigridLevelCreateH1(int * opFine,int * pMultFine,int * rstrCoarse,int * basisCoarse,const CeedScalar * interpCtoF,int * opCoarse,int * opProlong,int * opRestrict,int * err)1175 CEED_EXTERN void fCeedOperatorMultigridLevelCreateH1(int *opFine, int *pMultFine, int *rstrCoarse, int *basisCoarse, const CeedScalar *interpCtoF,
1176 int *opCoarse, int *opProlong, int *opRestrict, int *err) {
1177 // Operators
1178 CeedOperator opCoarse_, opProlong_, opRestrict_;
1179
1180 // C interface call
1181 *err = CeedOperatorMultigridLevelCreateH1(CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], CeedElemRestriction_dict[*rstrCoarse],
1182 CeedBasis_dict[*basisCoarse], interpCtoF, &opCoarse_, &opProlong_, &opRestrict_);
1183
1184 if (*err) return;
1185 while (CeedOperator_count + 2 >= CeedOperator_count_max) {
1186 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
1187 }
1188 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
1189 CeedOperator_dict[CeedOperator_count] = opCoarse_;
1190 *opCoarse = CeedOperator_count++;
1191 CeedOperator_dict[CeedOperator_count] = opProlong_;
1192 *opProlong = CeedOperator_count++;
1193 CeedOperator_dict[CeedOperator_count] = opRestrict_;
1194 *opRestrict = CeedOperator_count++;
1195 CeedOperator_n += 3;
1196 }
1197
1198 #define fCeedOperatorView FORTRAN_NAME(ceedoperatorview, CEEDOPERATORVIEW)
fCeedOperatorView(int * op,int * err)1199 CEED_EXTERN void fCeedOperatorView(int *op, int *err) {
1200 CeedOperator op_ = CeedOperator_dict[*op];
1201
1202 *err = CeedOperatorView(op_, stdout);
1203 }
1204
1205 #define fCeedOperatorCreateFDMElementInverse FORTRAN_NAME(ceedoperatorcreatefdmelementinverse, CEEDOPERATORCREATEFDMELEMENTINVERSE)
fCeedOperatorCreateFDMElementInverse(int * op,int * fdminv,int * rqst,int * err)1206 CEED_EXTERN void fCeedOperatorCreateFDMElementInverse(int *op, int *fdminv, int *rqst, int *err) {
1207 // Operator
1208 if (CeedOperator_count == CeedOperator_count_max) {
1209 CeedOperator_count_max += CeedOperator_count_max / 2 + 1;
1210 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict);
1211 }
1212 CeedOperator *fdminv_ = &CeedOperator_dict[CeedOperator_count];
1213
1214 int createRequest = 1;
1215 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
1216 if (*rqst == -1 || *rqst == -2) {
1217 createRequest = 0;
1218 }
1219
1220 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
1221 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
1222 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
1223 }
1224
1225 CeedRequest *rqst_;
1226 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE;
1227 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED;
1228 else rqst_ = &CeedRequest_dict[CeedRequest_count];
1229
1230 *err = CeedOperatorCreateFDMElementInverse(CeedOperator_dict[*op], fdminv_, rqst_);
1231 if (*err) return;
1232 if (createRequest) {
1233 *rqst = CeedRequest_count++;
1234 CeedRequest_n++;
1235 }
1236
1237 if (*err == 0) {
1238 *fdminv = CeedOperator_count++;
1239 CeedOperator_n++;
1240 }
1241 }
1242
1243 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY)
fCeedOperatorApply(int * op,int * ustatevec,int * resvec,int * rqst,int * err)1244 CEED_EXTERN void fCeedOperatorApply(int *op, int *ustatevec, int *resvec, int *rqst, int *err) {
1245 CeedVector ustatevec_ = (*ustatevec == FORTRAN_NULL) ? NULL : (*ustatevec == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*ustatevec]);
1246 CeedVector resvec_ = (*resvec == FORTRAN_NULL) ? NULL : (*resvec == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*resvec]);
1247
1248 int createRequest = 1;
1249 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
1250 if (*rqst == -1 || *rqst == -2) {
1251 createRequest = 0;
1252 }
1253
1254 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
1255 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
1256 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
1257 }
1258
1259 CeedRequest *rqst_;
1260 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE;
1261 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED;
1262 else rqst_ = &CeedRequest_dict[CeedRequest_count];
1263
1264 *err = CeedOperatorApply(CeedOperator_dict[*op], ustatevec_, resvec_, rqst_);
1265 if (*err) return;
1266 if (createRequest) {
1267 *rqst = CeedRequest_count++;
1268 CeedRequest_n++;
1269 }
1270 }
1271
1272 #define fCeedOperatorApplyAdd FORTRAN_NAME(ceedoperatorapplyadd, CEEDOPERATORAPPLYADD)
fCeedOperatorApplyAdd(int * op,int * ustatevec,int * resvec,int * rqst,int * err)1273 CEED_EXTERN void fCeedOperatorApplyAdd(int *op, int *ustatevec, int *resvec, int *rqst, int *err) {
1274 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL ? NULL : CeedVector_dict[*ustatevec];
1275 CeedVector resvec_ = *resvec == FORTRAN_NULL ? NULL : CeedVector_dict[*resvec];
1276
1277 int createRequest = 1;
1278 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1)
1279 if (*rqst == -1 || *rqst == -2) {
1280 createRequest = 0;
1281 }
1282
1283 if (createRequest && CeedRequest_count == CeedRequest_count_max) {
1284 CeedRequest_count_max += CeedRequest_count_max / 2 + 1;
1285 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict);
1286 }
1287
1288 CeedRequest *rqst_;
1289 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE;
1290 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED;
1291 else rqst_ = &CeedRequest_dict[CeedRequest_count];
1292
1293 *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], ustatevec_, resvec_, rqst_);
1294 if (*err) return;
1295 if (createRequest) {
1296 *rqst = CeedRequest_count++;
1297 CeedRequest_n++;
1298 }
1299 }
1300
1301 #define fCeedOperatorApplyJacobian FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN)
fCeedOperatorApplyJacobian(int * op,int * qdatavec,int * ustatevec,int * dustatevec,int * dresvec,int * rqst,int * err)1302 CEED_EXTERN void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, int *dustatevec, int *dresvec, int *rqst, int *err) {
1303 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented
1304 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec],
1305 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec],
1306 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]);
1307 }
1308
1309 #define fCeedOperatorDestroy FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY)
fCeedOperatorDestroy(int * op,int * err)1310 CEED_EXTERN void fCeedOperatorDestroy(int *op, int *err) {
1311 if (*op == FORTRAN_NULL) return;
1312 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]);
1313 if (*err == 0) {
1314 *op = FORTRAN_NULL;
1315 CeedOperator_n--;
1316 if (CeedOperator_n == 0) {
1317 *err = CeedFree(&CeedOperator_dict);
1318 CeedOperator_count = 0;
1319 CeedOperator_count_max = 0;
1320 }
1321 }
1322 }
1323
1324 // -----------------------------------------------------------------------------
1325