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) 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 fCeedSetNumViewTabs FORTRAN_NAME(ceedsetnumviewtabs, CEEDSETNUMVIEWTABS) 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) 92 CEED_EXTERN void fCeedView(int *ceed, int *err) { *err = CeedView(Ceed_dict[*ceed], stdout); } 93 94 #define fCeedDestroy FORTRAN_NAME(ceeddestroy, CEEDDESTROY) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 196 CEED_EXTERN void fCeedVectorReciprocal(int *vec, int *err) { *err = CeedVectorReciprocal(CeedVector_dict[*vec]); } 197 198 #define fCeedVectorSetNumViewTabs FORTRAN_NAME(ceedvectorsetnumviewtabs, CEEDVECTORSETNUMVIEWTABS) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 464 CEED_EXTERN void fCeedElemRestrictionView(int *elemr, int *err) { *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); } 465 466 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 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) 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) 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) 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) 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) 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) 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) 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) 593 CEED_EXTERN void fCeedBasisView(int *basis, int *err) { *err = CeedBasisView(CeedBasis_dict[*basis], stdout); } 594 595 #define fCeedBasisGetCollocatedGrad FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 711 CEED_EXTERN void fCeedQFunctionContextView(int *ctx, int *err) { *err = CeedQFunctionContextView(CeedQFunctionContext_dict[*ctx], stdout); } 712 713 #define fCeedQFunctionContextDestroy FORTRAN_NAME(ceedqfunctioncontextdestroy, CEEDQFUNCTIONCONTEXTDESTROY) 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 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) 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) 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) 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) 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) 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) 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) 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) 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 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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