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