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