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