1 // Fortran interface 2 #include <ceed.h> 3 #include <ceed-impl.h> 4 #include <ceed-backend.h> 5 #include <ceed-fortran-name.h> 6 #include <stdlib.h> 7 #include <string.h> 8 9 #define FORTRAN_REQUEST_IMMEDIATE -1 10 #define FORTRAN_REQUEST_ORDERED -2 11 #define FORTRAN_NULL -3 12 #define FORTRAN_BASIS_COLLOCATED -1 13 #define FORTRAN_VECTOR_ACTIVE -1 14 #define FORTRAN_VECTOR_NONE -2 15 #define FORTRAN_QFUNCTION_NONE -1 16 17 static Ceed *Ceed_dict = NULL; 18 static int Ceed_count = 0; 19 static int Ceed_n = 0; 20 static int Ceed_count_max = 0; 21 22 // This test should actually be for the gfortran version, but we don't currently 23 // have a configure system to determine that (TODO). At present, this will use 24 // the smaller integer when run with clang+gfortran=8, for example. (That is 25 // sketchy, but will likely work for users that don't have huge character 26 // strings.) 27 #if __GNUC__ >= 8 28 typedef size_t fortran_charlen_t; 29 #else 30 typedef int fortran_charlen_t; 31 #endif 32 33 #define Splice(a, b) a ## b 34 35 // Fortran strings are generally unterminated and the length is passed as an 36 // extra argument after all the normal arguments. Some compilers (I only know 37 // of Windows) place the length argument immediately after the string parameter 38 // (TODO). 39 // 40 // We can't just NULL-terminate the string in-place because that could overwrite 41 // other strings or attempt to write to read-only memory. This macro allocates 42 // a string to hold the null-terminated version of the string that C expects. 43 #define FIX_STRING(stringname) \ 44 char Splice(stringname, _c)[1024]; \ 45 if (Splice(stringname, _len) > 1023) \ 46 CeedError(NULL, 1, "Fortran string length too long %zd", (size_t)Splice(stringname, _len)); \ 47 strncpy(Splice(stringname, _c), stringname, Splice(stringname, _len)); \ 48 Splice(stringname, _c)[Splice(stringname, _len)] = 0; \ 49 50 #define fCeedInit FORTRAN_NAME(ceedinit,CEEDINIT) 51 void fCeedInit(const char *resource, int *ceed, int *err, 52 fortran_charlen_t resource_len) { 53 FIX_STRING(resource); 54 if (Ceed_count == Ceed_count_max) { 55 Ceed_count_max += Ceed_count_max/2 + 1; 56 CeedRealloc(Ceed_count_max, &Ceed_dict); 57 } 58 59 Ceed *ceed_ = &Ceed_dict[Ceed_count]; 60 *err = CeedInit(resource_c, ceed_); 61 62 if (*err == 0) { 63 *ceed = Ceed_count++; 64 Ceed_n++; 65 } 66 } 67 68 #define fCeedGetPreferredMemType \ 69 FORTRAN_NAME(ceedgetpreferredmemtype,CEEDGETPREFERREDMEMTYPE) 70 void fCeedGetPreferredMemType(int *ceed, int *type, int *err) { 71 *err = CeedGetPreferredMemType(Ceed_dict[*ceed], (CeedMemType *)type); 72 } 73 74 #define fCeedDestroy FORTRAN_NAME(ceeddestroy,CEEDDESTROY) 75 void fCeedDestroy(int *ceed, int *err) { 76 *err = CeedDestroy(&Ceed_dict[*ceed]); 77 78 if (*err == 0) { 79 Ceed_n--; 80 if (Ceed_n == 0) { 81 CeedFree(&Ceed_dict); 82 Ceed_count = 0; 83 Ceed_count_max = 0; 84 } 85 } 86 } 87 88 static CeedVector *CeedVector_dict = NULL; 89 static int CeedVector_count = 0; 90 static int CeedVector_n = 0; 91 static int CeedVector_count_max = 0; 92 93 #define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate,CEEDVECTORCREATE) 94 void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) { 95 if (CeedVector_count == CeedVector_count_max) { 96 CeedVector_count_max += CeedVector_count_max/2 + 1; 97 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 98 } 99 100 CeedVector *vec_ = &CeedVector_dict[CeedVector_count]; 101 *err = CeedVectorCreate(Ceed_dict[*ceed], *length, vec_); 102 103 if (*err == 0) { 104 *vec = CeedVector_count++; 105 CeedVector_n++; 106 } 107 } 108 109 #define fCeedVectorSetArray FORTRAN_NAME(ceedvectorsetarray,CEEDVECTORSETARRAY) 110 void fCeedVectorSetArray(int *vec, int *memtype, int *copymode, 111 CeedScalar *array, int64_t *offset, int *err) { 112 *err = CeedVectorSetArray(CeedVector_dict[*vec], *memtype, *copymode, 113 (CeedScalar *)(array + *offset)); 114 } 115 116 #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray,CEEDVECTORSYNCARRAY) 117 void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { 118 *err = CeedVectorSyncArray(CeedVector_dict[*vec], *memtype); 119 } 120 121 #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue,CEEDVECTORSETVALUE) 122 void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { 123 *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); 124 } 125 126 #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray,CEEDVECTORGETARRAY) 127 void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, 128 int64_t *offset, 129 int *err) { 130 CeedScalar *b; 131 CeedVector vec_ = CeedVector_dict[*vec]; 132 *err = CeedVectorGetArray(vec_, *memtype, &b); 133 *offset = b - array; 134 } 135 136 #define fCeedVectorGetArrayRead \ 137 FORTRAN_NAME(ceedvectorgetarrayread,CEEDVECTORGETARRAYREAD) 138 void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, 139 int64_t *offset, int *err) { 140 const CeedScalar *b; 141 CeedVector vec_ = CeedVector_dict[*vec]; 142 *err = CeedVectorGetArrayRead(vec_, *memtype, &b); 143 *offset = b - array; 144 } 145 146 #define fCeedVectorRestoreArray \ 147 FORTRAN_NAME(ceedvectorrestorearray,CEEDVECTORRESTOREARRAY) 148 void fCeedVectorRestoreArray(int *vec, CeedScalar *array, 149 int64_t *offset, int *err) { 150 *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &array); 151 *offset = 0; 152 } 153 154 #define fCeedVectorRestoreArrayRead \ 155 FORTRAN_NAME(ceedvectorrestorearrayread,CEEDVECTORRESTOREARRAYREAD) 156 void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, 157 int64_t *offset, int *err) { 158 *err = CeedVectorRestoreArrayRead(CeedVector_dict[*vec], &array); 159 *offset = 0; 160 } 161 162 #define fCeedVectorView FORTRAN_NAME(ceedvectorview,CEEDVECTORVIEW) 163 void fCeedVectorView(int *vec, int *err) { 164 *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); 165 } 166 167 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy,CEEDVECTORDESTROY) 168 void fCeedVectorDestroy(int *vec, int *err) { 169 *err = CeedVectorDestroy(&CeedVector_dict[*vec]); 170 171 if (*err == 0) { 172 CeedVector_n--; 173 if (CeedVector_n == 0) { 174 CeedFree(&CeedVector_dict); 175 CeedVector_count = 0; 176 CeedVector_count_max = 0; 177 } 178 } 179 } 180 181 static CeedElemRestriction *CeedElemRestriction_dict = NULL; 182 static int CeedElemRestriction_count = 0; 183 static int CeedElemRestriction_n = 0; 184 static int CeedElemRestriction_count_max = 0; 185 186 #define fCeedElemRestrictionCreate \ 187 FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) 188 void fCeedElemRestrictionCreate(int *ceed, int *nelements, 189 int *esize, int *nnodes, int *ncomp, 190 int *memtype, int *copymode, const int *indices, 191 int *elemrestriction, int *err) { 192 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 193 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 194 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 195 } 196 197 const int *indices_ = indices; 198 199 CeedElemRestriction *elemrestriction_ = 200 &CeedElemRestriction_dict[CeedElemRestriction_count]; 201 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, 202 *nnodes, *ncomp, *memtype, *copymode, 203 indices_, elemrestriction_); 204 205 if (*err == 0) { 206 *elemrestriction = CeedElemRestriction_count++; 207 CeedElemRestriction_n++; 208 } 209 } 210 211 #define fCeedElemRestrictionCreateIdentity \ 212 FORTRAN_NAME(ceedelemrestrictioncreateidentity, CEEDELEMRESTRICTIONCREATEIDENTITY) 213 void fCeedElemRestrictionCreateIdentity(int *ceed, int *nelements, 214 int *esize, int *nnodes, int *ncomp, 215 int *elemrestriction, int *err) { 216 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 217 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 218 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 219 } 220 221 CeedElemRestriction *elemrestriction_ = 222 &CeedElemRestriction_dict[CeedElemRestriction_count]; 223 *err = CeedElemRestrictionCreateIdentity(Ceed_dict[*ceed], *nelements, *esize, 224 *nnodes, *ncomp, elemrestriction_); 225 226 if (*err == 0) { 227 *elemrestriction = CeedElemRestriction_count++; 228 CeedElemRestriction_n++; 229 } 230 } 231 232 #define fCeedElemRestrictionCreateBlocked \ 233 FORTRAN_NAME(ceedelemrestrictioncreateblocked,CEEDELEMRESTRICTIONCREATEBLOCKED) 234 void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, 235 int *esize, int *blocksize, int *nnodes, 236 int *ncomp, int *mtype, int *cmode, 237 int *blkindices, int *elemrestriction, 238 int *err) { 239 240 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 241 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 242 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 243 } 244 245 CeedElemRestriction *elemrestriction_ = 246 &CeedElemRestriction_dict[CeedElemRestriction_count]; 247 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, 248 *blocksize, *nnodes, *ncomp, *mtype, 249 *cmode, blkindices, elemrestriction_); 250 251 if (*err == 0) { 252 *elemrestriction = CeedElemRestriction_count++; 253 CeedElemRestriction_n++; 254 } 255 } 256 257 static CeedRequest *CeedRequest_dict = NULL; 258 static int CeedRequest_count = 0; 259 static int CeedRequest_n = 0; 260 static int CeedRequest_count_max = 0; 261 262 #define fCeedElemRestrictionApply \ 263 FORTRAN_NAME(ceedelemrestrictionapply,CEEDELEMRESTRICTIONAPPLY) 264 void fCeedElemRestrictionApply(int *elemr, int *tmode, int *lmode, 265 int *uvec, int *ruvec, int *rqst, int *err) { 266 int createRequest = 1; 267 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 268 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 269 createRequest = 0; 270 271 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 272 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 273 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 274 } 275 276 CeedRequest *rqst_; 277 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 278 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 279 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 280 281 *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], *tmode, 282 *lmode, CeedVector_dict[*uvec], 283 CeedVector_dict[*ruvec], rqst_); 284 285 if (*err == 0 && createRequest) { 286 *rqst = CeedRequest_count++; 287 CeedRequest_n++; 288 } 289 } 290 291 #define fCeedElemRestrictionApplyBlock \ 292 FORTRAN_NAME(ceedelemrestrictionapplyblock,CEEDELEMRESTRICTIONAPPLYBLOCK) 293 void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, 294 int *lmode, 295 int *uvec, int *ruvec, int *rqst, int *err) { 296 int createRequest = 1; 297 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 298 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 299 createRequest = 0; 300 301 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 302 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 303 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 304 } 305 306 CeedRequest *rqst_; 307 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 308 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 309 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 310 311 *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, 312 *tmode, *lmode, CeedVector_dict[*uvec], 313 CeedVector_dict[*ruvec], rqst_); 314 315 if (*err == 0 && createRequest) { 316 *rqst = CeedRequest_count++; 317 CeedRequest_n++; 318 } 319 } 320 321 #define fCeedElemRestrictionGetMultiplicity \ 322 FORTRAN_NAME(ceedelemrestrictiongetmultiplicity,CEEDELEMRESTRICTIONGETMULTIPLICITY) 323 void fCeedElemRestrictionGetMultiplicity(int *elemr, int *mult, int *err) { 324 *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], 325 CeedVector_dict[*mult]); 326 } 327 328 #define fCeedElemRestrictionView \ 329 FORTRAN_NAME(ceedelemrestrictionview,CEEDELEMRESTRICTIONVIEW) 330 void fCeedElemRestrictionView(int *elemr, int *err) { 331 *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); 332 } 333 334 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 335 void fCeedRequestWait(int *rqst, int *err) { 336 // TODO Uncomment this once CeedRequestWait is implemented 337 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); 338 339 if (*err == 0) { 340 CeedRequest_n--; 341 if (CeedRequest_n == 0) { 342 CeedFree(&CeedRequest_dict); 343 CeedRequest_count = 0; 344 CeedRequest_count_max = 0; 345 } 346 } 347 } 348 349 #define fCeedElemRestrictionDestroy \ 350 FORTRAN_NAME(ceedelemrestrictiondestroy,CEEDELEMRESTRICTIONDESTROY) 351 void fCeedElemRestrictionDestroy(int *elem, int *err) { 352 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); 353 354 if (*err == 0) { 355 CeedElemRestriction_n--; 356 if (CeedElemRestriction_n == 0) { 357 CeedFree(&CeedElemRestriction_dict); 358 CeedElemRestriction_count = 0; 359 CeedElemRestriction_count_max = 0; 360 } 361 } 362 } 363 364 static CeedBasis *CeedBasis_dict = NULL; 365 static int CeedBasis_count = 0; 366 static int CeedBasis_n = 0; 367 static int CeedBasis_count_max = 0; 368 369 #define fCeedBasisCreateTensorH1Lagrange \ 370 FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) 371 void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, 372 int *ncomp, int *P, int *Q, int *quadmode, 373 int *basis, int *err) { 374 if (CeedBasis_count == CeedBasis_count_max) { 375 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 376 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 377 } 378 379 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *ncomp, *P, *Q, 380 *quadmode, 381 &CeedBasis_dict[CeedBasis_count]); 382 383 if (*err == 0) { 384 *basis = CeedBasis_count++; 385 CeedBasis_n++; 386 } 387 } 388 389 #define fCeedBasisCreateTensorH1 \ 390 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) 391 void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *ncomp, int *P1d, 392 int *Q1d, const CeedScalar *interp1d, 393 const CeedScalar *grad1d, 394 const CeedScalar *qref1d, 395 const CeedScalar *qweight1d, int *basis, 396 int *err) { 397 if (CeedBasis_count == CeedBasis_count_max) { 398 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 399 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 400 } 401 402 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *ncomp, *P1d, *Q1d, 403 interp1d, grad1d, qref1d, qweight1d, 404 &CeedBasis_dict[CeedBasis_count]); 405 406 if (*err == 0) { 407 *basis = CeedBasis_count++; 408 CeedBasis_n++; 409 } 410 } 411 412 #define fCeedBasisCreateH1 \ 413 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) 414 void fCeedBasisCreateH1(int *ceed, int *topo, int *ncomp, int *nnodes, 415 int *nqpts, const CeedScalar *interp, 416 const CeedScalar *grad, const CeedScalar *qref, 417 const CeedScalar *qweight, int *basis, int *err) { 418 if (CeedBasis_count == CeedBasis_count_max) { 419 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 420 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 421 } 422 423 *err = CeedBasisCreateH1(Ceed_dict[*ceed], *topo, *ncomp, *nnodes, *nqpts, 424 interp, grad, qref, qweight, 425 &CeedBasis_dict[CeedBasis_count]); 426 427 if (*err == 0) { 428 *basis = CeedBasis_count++; 429 CeedBasis_n++; 430 } 431 } 432 433 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW) 434 void fCeedBasisView(int *basis, int *err) { 435 *err = CeedBasisView(CeedBasis_dict[*basis], stdout); 436 } 437 438 #define fCeedQRFactorization \ 439 FORTRAN_NAME(ceedqrfactorization, CEEDQRFACTORIZATION) 440 void fCeedQRFactorization(int *ceed, CeedScalar *mat, CeedScalar *tau, int *m, 441 int *n, int *err) { 442 *err = CeedQRFactorization(Ceed_dict[*ceed], mat, tau, *m, *n); 443 } 444 445 #define fCeedSymmetricSchurDecomposition \ 446 FORTRAN_NAME(ceedsymmetricschurdecomposition, CEEDSYMMETRICSCHURDECOMPOSITION) 447 void fCeedSymmetricSchurDecomposition(int *ceed, CeedScalar *mat, 448 CeedScalar *lambda, int *n, int *err) { 449 *err = CeedSymmetricSchurDecomposition(Ceed_dict[*ceed], mat, lambda, *n); 450 } 451 452 #define fCeedSimultaneousDiagonalization \ 453 FORTRAN_NAME(ceedsimultaneousdiagonalization, CEEDSIMULTANEOUSDIAGONALIZATION) 454 void fCeedSimultaneousDiagonalization(int *ceed, CeedScalar *matA, 455 CeedScalar *matB, CeedScalar *x, 456 CeedScalar *lambda, int *n, int *err) { 457 *err = CeedSimultaneousDiagonalization(Ceed_dict[*ceed], matA, matB, x, 458 lambda, *n); 459 } 460 461 #define fCeedBasisGetCollocatedGrad \ 462 FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 463 void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colograd1d, 464 int *err) { 465 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colograd1d); 466 } 467 468 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) 469 void fCeedBasisApply(int *basis, int *nelem, int *tmode, int *emode, 470 int *u, int *v, int *err) { 471 *err = CeedBasisApply(CeedBasis_dict[*basis], *nelem, *tmode, *emode, 472 *u==FORTRAN_VECTOR_NONE? 473 CEED_VECTOR_NONE:CeedVector_dict[*u], 474 CeedVector_dict[*v]); 475 } 476 477 #define fCeedBasisGetNumNodes \ 478 FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) 479 void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { 480 *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); 481 } 482 483 #define fCeedBasisGetNumQuadraturePoints \ 484 FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) 485 void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { 486 *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); 487 } 488 489 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY) 490 void fCeedBasisDestroy(int *basis, int *err) { 491 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]); 492 493 if (*err == 0) { 494 CeedBasis_n--; 495 if (CeedBasis_n == 0) { 496 CeedFree(&CeedBasis_dict); 497 CeedBasis_count = 0; 498 CeedBasis_count_max = 0; 499 } 500 } 501 } 502 503 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE) 504 void fCeedGaussQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 505 int *err) { 506 *err = CeedGaussQuadrature(*Q, qref1d, qweight1d); 507 } 508 509 #define fCeedLobattoQuadrature \ 510 FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE) 511 void fCeedLobattoQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 512 int *err) { 513 *err = CeedLobattoQuadrature(*Q, qref1d, qweight1d); 514 } 515 516 static CeedQFunction *CeedQFunction_dict = NULL; 517 static int CeedQFunction_count = 0; 518 static int CeedQFunction_n = 0; 519 static int CeedQFunction_count_max = 0; 520 521 static int CeedQFunctionFortranStub(void *ctx, int nq, 522 const CeedScalar *const *u, 523 CeedScalar *const *v) { 524 fContext *fctx = ctx; 525 int ierr; 526 527 CeedScalar *ctx_ = (CeedScalar *) fctx->innerctx; 528 fctx->f((void *)ctx_,&nq,u[0],u[1],u[2],u[3],u[4],u[5],u[6], 529 u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15], 530 v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9], 531 v[10],v[11],v[12],v[13],v[14],v[15],&ierr); 532 return ierr; 533 } 534 535 #define fCeedQFunctionCreateInterior \ 536 FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) 537 void fCeedQFunctionCreateInterior(int *ceed, int *vlength, 538 void (*f)(void *ctx, int *nq, 539 const CeedScalar *u,const CeedScalar *u1, 540 const CeedScalar *u2,const CeedScalar *u3, 541 const CeedScalar *u4,const CeedScalar *u5, 542 const CeedScalar *u6,const CeedScalar *u7, 543 const CeedScalar *u8,const CeedScalar *u9, 544 const CeedScalar *u10,const CeedScalar *u11, 545 const CeedScalar *u12,const CeedScalar *u13, 546 const CeedScalar *u14,const CeedScalar *u15, 547 CeedScalar *v,CeedScalar *v1,CeedScalar *v2, 548 CeedScalar *v3,CeedScalar *v4, 549 CeedScalar *v5,CeedScalar *v6, 550 CeedScalar *v7,CeedScalar *v8, 551 CeedScalar *v9,CeedScalar *v10, 552 CeedScalar *v11,CeedScalar *v12, 553 CeedScalar *v13,CeedScalar *v14, 554 CeedScalar *v15,int *err), 555 const char *source, int *qf, int *err, 556 fortran_charlen_t source_len) { 557 FIX_STRING(source); 558 if (CeedQFunction_count == CeedQFunction_count_max) { 559 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 560 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 561 } 562 563 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 564 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vlength, 565 CeedQFunctionFortranStub, source_c, qf_); 566 567 if (*err == 0) { 568 *qf = CeedQFunction_count++; 569 CeedQFunction_n++; 570 } 571 572 fContext *fctx; 573 *err = CeedMalloc(1, &fctx); 574 if (*err) return; 575 fctx->f = f; fctx->innerctx = NULL; fctx->innerctxsize = 0; 576 577 *err = CeedQFunctionSetContext(*qf_, fctx, sizeof(fContext)); 578 579 (*qf_)->fortranstatus = true; 580 } 581 582 #define fCeedQFunctionCreateInteriorByName \ 583 FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME) 584 void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, 585 int *err, fortran_charlen_t name_len) { 586 FIX_STRING(name); 587 if (CeedQFunction_count == CeedQFunction_count_max) { 588 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 589 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 590 } 591 592 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 593 *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_); 594 595 if (*err == 0) { 596 *qf = CeedQFunction_count++; 597 CeedQFunction_n++; 598 } 599 } 600 601 #define fCeedQFunctionCreateIdentity \ 602 FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY) 603 void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, 604 int *outmode, int *qf, int *err) { 605 if (CeedQFunction_count == CeedQFunction_count_max) { 606 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 607 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 608 } 609 610 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 611 *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, *inmode, 612 *outmode, qf_); 613 614 if (*err == 0) { 615 *qf = CeedQFunction_count++; 616 CeedQFunction_n++; 617 } 618 } 619 620 #define fCeedQFunctionAddInput \ 621 FORTRAN_NAME(ceedqfunctionaddinput,CEEDQFUNCTIONADDINPUT) 622 void fCeedQFunctionAddInput(int *qf, const char *fieldname, 623 CeedInt *ncomp, CeedEvalMode *emode, int *err, 624 fortran_charlen_t fieldname_len) { 625 FIX_STRING(fieldname); 626 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 627 628 *err = CeedQFunctionAddInput(qf_, fieldname_c, *ncomp, *emode); 629 } 630 631 #define fCeedQFunctionAddOutput \ 632 FORTRAN_NAME(ceedqfunctionaddoutput,CEEDQFUNCTIONADDOUTPUT) 633 void fCeedQFunctionAddOutput(int *qf, const char *fieldname, 634 CeedInt *ncomp, CeedEvalMode *emode, int *err, 635 fortran_charlen_t fieldname_len) { 636 FIX_STRING(fieldname); 637 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 638 639 *err = CeedQFunctionAddOutput(qf_, fieldname_c, *ncomp, *emode); 640 } 641 642 #define fCeedQFunctionSetContext \ 643 FORTRAN_NAME(ceedqfunctionsetcontext,CEEDQFUNCTIONSETCONTEXT) 644 void fCeedQFunctionSetContext(int *qf, CeedScalar *ctx, CeedInt *n, int *err) { 645 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 646 647 fContext *fctx = qf_->ctx; 648 fctx->innerctx = ctx; 649 fctx->innerctxsize = ((size_t) *n)*sizeof(CeedScalar); 650 } 651 652 #define fCeedQFunctionView \ 653 FORTRAN_NAME(ceedqfunctionview,CEEDQFUNCTIONVIEW) 654 void fCeedQFunctionView(int *qf, int *err) { 655 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 656 657 *err = CeedQFunctionView(qf_, stdout); 658 } 659 660 #define fCeedQFunctionApply \ 661 FORTRAN_NAME(ceedqfunctionapply,CEEDQFUNCTIONAPPLY) 662 //TODO Need Fixing, double pointer 663 void fCeedQFunctionApply(int *qf, int *Q, 664 int *u, int *u1, int *u2, int *u3, 665 int *u4, int *u5, int *u6, int *u7, 666 int *u8, int *u9, int *u10, int *u11, 667 int *u12, int *u13, int *u14, int *u15, 668 int *v, int *v1, int *v2, int *v3, 669 int *v4, int *v5, int *v6, int *v7, 670 int *v8, int *v9, int *v10, int *v11, 671 int *v12, int *v13, int *v14, int *v15, int *err) { 672 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 673 CeedVector *in; 674 *err = CeedCalloc(16, &in); 675 if (*err) return; 676 in[0] = *u==FORTRAN_NULL?NULL:CeedVector_dict[*u]; 677 in[1] = *u1==FORTRAN_NULL?NULL:CeedVector_dict[*u1]; 678 in[2] = *u2==FORTRAN_NULL?NULL:CeedVector_dict[*u2]; 679 in[3] = *u3==FORTRAN_NULL?NULL:CeedVector_dict[*u3]; 680 in[4] = *u4==FORTRAN_NULL?NULL:CeedVector_dict[*u4]; 681 in[5] = *u5==FORTRAN_NULL?NULL:CeedVector_dict[*u5]; 682 in[6] = *u6==FORTRAN_NULL?NULL:CeedVector_dict[*u6]; 683 in[7] = *u7==FORTRAN_NULL?NULL:CeedVector_dict[*u7]; 684 in[8] = *u8==FORTRAN_NULL?NULL:CeedVector_dict[*u8]; 685 in[9] = *u9==FORTRAN_NULL?NULL:CeedVector_dict[*u9]; 686 in[10] = *u10==FORTRAN_NULL?NULL:CeedVector_dict[*u10]; 687 in[11] = *u11==FORTRAN_NULL?NULL:CeedVector_dict[*u11]; 688 in[12] = *u12==FORTRAN_NULL?NULL:CeedVector_dict[*u12]; 689 in[13] = *u13==FORTRAN_NULL?NULL:CeedVector_dict[*u13]; 690 in[14] = *u14==FORTRAN_NULL?NULL:CeedVector_dict[*u14]; 691 in[15] = *u15==FORTRAN_NULL?NULL:CeedVector_dict[*u15]; 692 CeedVector *out; 693 *err = CeedCalloc(16, &out); 694 if (*err) return; 695 out[0] = *v==FORTRAN_NULL?NULL:CeedVector_dict[*v]; 696 out[1] = *v1==FORTRAN_NULL?NULL:CeedVector_dict[*v1]; 697 out[2] = *v2==FORTRAN_NULL?NULL:CeedVector_dict[*v2]; 698 out[3] = *v3==FORTRAN_NULL?NULL:CeedVector_dict[*v3]; 699 out[4] = *v4==FORTRAN_NULL?NULL:CeedVector_dict[*v4]; 700 out[5] = *v5==FORTRAN_NULL?NULL:CeedVector_dict[*v5]; 701 out[6] = *v6==FORTRAN_NULL?NULL:CeedVector_dict[*v6]; 702 out[7] = *v7==FORTRAN_NULL?NULL:CeedVector_dict[*v7]; 703 out[8] = *v8==FORTRAN_NULL?NULL:CeedVector_dict[*v8]; 704 out[9] = *v9==FORTRAN_NULL?NULL:CeedVector_dict[*v9]; 705 out[10] = *v10==FORTRAN_NULL?NULL:CeedVector_dict[*v10]; 706 out[11] = *v11==FORTRAN_NULL?NULL:CeedVector_dict[*v11]; 707 out[12] = *v12==FORTRAN_NULL?NULL:CeedVector_dict[*v12]; 708 out[13] = *v13==FORTRAN_NULL?NULL:CeedVector_dict[*v13]; 709 out[14] = *v14==FORTRAN_NULL?NULL:CeedVector_dict[*v14]; 710 out[15] = *v15==FORTRAN_NULL?NULL:CeedVector_dict[*v15]; 711 *err = CeedQFunctionApply(qf_, *Q, in, out); 712 if (*err) return; 713 714 *err = CeedFree(&in); 715 if (*err) return; 716 *err = CeedFree(&out); 717 } 718 719 #define fCeedQFunctionDestroy \ 720 FORTRAN_NAME(ceedqfunctiondestroy,CEEDQFUNCTIONDESTROY) 721 void fCeedQFunctionDestroy(int *qf, int *err) { 722 bool fstatus; 723 *err = CeedQFunctionGetFortranStatus(CeedQFunction_dict[*qf], &fstatus); 724 if (*err) return; 725 if (fstatus) { 726 fContext *fctx = CeedQFunction_dict[*qf]->ctx; 727 *err = CeedFree(&fctx); 728 if (*err) return; 729 } 730 731 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); 732 if (*err) return; 733 734 CeedQFunction_n--; 735 if (CeedQFunction_n == 0) { 736 *err = CeedFree(&CeedQFunction_dict); 737 CeedQFunction_count = 0; 738 CeedQFunction_count_max = 0; 739 } 740 } 741 742 static CeedOperator *CeedOperator_dict = NULL; 743 static int CeedOperator_count = 0; 744 static int CeedOperator_n = 0; 745 static int CeedOperator_count_max = 0; 746 747 #define fCeedOperatorCreate \ 748 FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) 749 void fCeedOperatorCreate(int *ceed, 750 int *qf, int *dqf, int *dqfT, int *op, int *err) { 751 if (CeedOperator_count == CeedOperator_count_max) 752 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 753 CeedOperator_dict = realloc(CeedOperator_dict, 754 sizeof(CeedOperator)*CeedOperator_count_max); 755 756 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 757 758 CeedQFunction dqf_ = CEED_QFUNCTION_NONE, dqfT_ = CEED_QFUNCTION_NONE; 759 if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_ = CeedQFunction_dict[*dqf ]; 760 if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_ = CeedQFunction_dict[*dqfT]; 761 762 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, 763 dqfT_, op_); 764 if (*err) return; 765 *op = CeedOperator_count++; 766 CeedOperator_n++; 767 } 768 769 #define fCeedCompositeOperatorCreate \ 770 FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) 771 void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { 772 if (CeedOperator_count == CeedOperator_count_max) 773 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 774 CeedOperator_dict = realloc(CeedOperator_dict, 775 sizeof(CeedOperator)*CeedOperator_count_max); 776 777 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 778 779 *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); 780 if (*err) return; 781 *op = CeedOperator_count++; 782 CeedOperator_n++; 783 } 784 785 #define fCeedOperatorSetField \ 786 FORTRAN_NAME(ceedoperatorsetfield,CEEDOPERATORSETFIELD) 787 void fCeedOperatorSetField(int *op, const char *fieldname, 788 int *r, int *lmode, int *b, int *v, int *err, 789 fortran_charlen_t fieldname_len) { 790 FIX_STRING(fieldname); 791 CeedElemRestriction r_; 792 CeedBasis b_; 793 CeedVector v_; 794 795 CeedOperator op_ = CeedOperator_dict[*op]; 796 797 if (*r == FORTRAN_NULL) { 798 r_ = NULL; 799 } else { 800 r_ = CeedElemRestriction_dict[*r]; 801 } 802 803 if (*b == FORTRAN_NULL) { 804 b_ = NULL; 805 } else if (*b == FORTRAN_BASIS_COLLOCATED) { 806 b_ = CEED_BASIS_COLLOCATED; 807 } else { 808 b_ = CeedBasis_dict[*b]; 809 } 810 if (*v == FORTRAN_NULL) { 811 v_ = NULL; 812 } else if (*v == FORTRAN_VECTOR_ACTIVE) { 813 v_ = CEED_VECTOR_ACTIVE; 814 } else if (*v == FORTRAN_VECTOR_NONE) { 815 v_ = CEED_VECTOR_NONE; 816 } else { 817 v_ = CeedVector_dict[*v]; 818 } 819 820 *err = CeedOperatorSetField(op_, fieldname_c, r_, *lmode, b_, v_); 821 } 822 823 #define fCeedCompositeOperatorAddSub \ 824 FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) 825 void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { 826 CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; 827 CeedOperator subop_ = CeedOperator_dict[*subop]; 828 829 *err = CeedCompositeOperatorAddSub(compositeop_, subop_); 830 if (*err) return; 831 } 832 833 #define fCeedOperatorAssembleLinearQFunction FORTRAN_NAME(ceedoperatorassemblelinearqfunction, CEEDOPERATORASSEMBLELINEARQFUNCTION) 834 void fCeedOperatorAssembleLinearQFunction(int *op, int *assembledvec, 835 int *assembledrstr, int *rqst, int *err) { 836 // Vector 837 if (CeedVector_count == CeedVector_count_max) { 838 CeedVector_count_max += CeedVector_count_max/2 + 1; 839 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 840 } 841 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 842 843 // Restriction 844 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 845 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 846 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 847 } 848 CeedElemRestriction *rstr_ = 849 &CeedElemRestriction_dict[CeedElemRestriction_count]; 850 851 int createRequest = 1; 852 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 853 if (*rqst == -1 || *rqst == -2) { 854 createRequest = 0; 855 } 856 857 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 858 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 859 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 860 } 861 862 CeedRequest *rqst_; 863 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 864 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 865 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 866 867 *err = CeedOperatorAssembleLinearQFunction(CeedOperator_dict[*op], 868 assembledvec_, rstr_, rqst_); 869 if (*err) return; 870 if (createRequest) { 871 *rqst = CeedRequest_count++; 872 CeedRequest_n++; 873 } 874 875 if (*err == 0) { 876 *assembledrstr = CeedElemRestriction_count++; 877 CeedElemRestriction_n++; 878 *assembledvec = CeedVector_count++; 879 CeedVector_n++; 880 } 881 } 882 883 #define fCeedOperatorAssembleLinearDiagonal FORTRAN_NAME(ceedoperatorassemblelineardiagonal, CEEDOPERATORASSEMBLELINEARDIAGONAL) 884 void fCeedOperatorAssembleLinearDiagonal(int *op, int *assembledvec, 885 int *rqst, int *err) { 886 // Vector 887 if (CeedVector_count == CeedVector_count_max) { 888 CeedVector_count_max += CeedVector_count_max/2 + 1; 889 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 890 } 891 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 892 893 int createRequest = 1; 894 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 895 if (*rqst == -1 || *rqst == -2) { 896 createRequest = 0; 897 } 898 899 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 900 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 901 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 902 } 903 904 CeedRequest *rqst_; 905 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 906 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 907 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 908 909 *err = CeedOperatorAssembleLinearDiagonal(CeedOperator_dict[*op], 910 assembledvec_, rqst_); 911 if (*err) return; 912 if (createRequest) { 913 *rqst = CeedRequest_count++; 914 CeedRequest_n++; 915 } 916 917 if (*err == 0) { 918 *assembledvec = CeedVector_count++; 919 CeedVector_n++; 920 } 921 } 922 923 #define fCeedOperatorView \ 924 FORTRAN_NAME(ceedoperatorview,CEEDOPERATORVIEW) 925 void fCeedOperatorView(int *op, int *err) { 926 CeedOperator op_ = CeedOperator_dict[*op]; 927 928 *err = CeedOperatorView(op_, stdout); 929 } 930 931 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) 932 void fCeedOperatorApply(int *op, int *ustatevec, 933 int *resvec, int *rqst, int *err) { 934 CeedVector ustatevec_ = (*ustatevec == FORTRAN_NULL) ? 935 NULL : (*ustatevec == FORTRAN_VECTOR_NONE ? 936 CEED_VECTOR_NONE : CeedVector_dict[*ustatevec]); 937 CeedVector resvec_ = (*resvec == FORTRAN_NULL) ? 938 NULL : (*resvec == FORTRAN_VECTOR_NONE ? 939 CEED_VECTOR_NONE : CeedVector_dict[*resvec]); 940 941 int createRequest = 1; 942 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 943 if (*rqst == -1 || *rqst == -2) { 944 createRequest = 0; 945 } 946 947 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 948 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 949 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 950 } 951 952 CeedRequest *rqst_; 953 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 954 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 955 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 956 957 *err = CeedOperatorApply(CeedOperator_dict[*op], 958 ustatevec_, resvec_, rqst_); 959 if (*err) return; 960 if (createRequest) { 961 *rqst = CeedRequest_count++; 962 CeedRequest_n++; 963 } 964 } 965 966 #define fCeedOperatorApplyAdd FORTRAN_NAME(ceedoperatorapplyadd, CEEDOPERATORAPPLYADD) 967 void fCeedOperatorApplyAdd(int *op, int *ustatevec, 968 int *resvec, int *rqst, int *err) { 969 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL 970 ? NULL : CeedVector_dict[*ustatevec]; 971 CeedVector resvec_ = *resvec == FORTRAN_NULL 972 ? NULL : CeedVector_dict[*resvec]; 973 974 int createRequest = 1; 975 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 976 if (*rqst == -1 || *rqst == -2) { 977 createRequest = 0; 978 } 979 980 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 981 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 982 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 983 } 984 985 CeedRequest *rqst_; 986 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 987 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 988 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 989 990 *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], 991 ustatevec_, resvec_, rqst_); 992 if (*err) return; 993 if (createRequest) { 994 *rqst = CeedRequest_count++; 995 CeedRequest_n++; 996 } 997 } 998 999 #define fCeedOperatorApplyJacobian \ 1000 FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) 1001 void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, 1002 int *dustatevec, int *dresvec, int *rqst, 1003 int *err) { 1004 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented 1005 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], 1006 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], 1007 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); 1008 } 1009 1010 #define fCeedOperatorDestroy \ 1011 FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) 1012 void fCeedOperatorDestroy(int *op, int *err) { 1013 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); 1014 if (*err) return; 1015 CeedOperator_n--; 1016 if (CeedOperator_n == 0) { 1017 *err = CeedFree(&CeedOperator_dict); 1018 CeedOperator_count = 0; 1019 CeedOperator_count_max = 0; 1020 } 1021 } 1022