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 fCeedVectorView FORTRAN_NAME(ceedvectorview,CEEDVECTORVIEW) 179 void fCeedVectorView(int *vec, int *err) { 180 *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); 181 } 182 183 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy,CEEDVECTORDESTROY) 184 void fCeedVectorDestroy(int *vec, int *err) { 185 *err = CeedVectorDestroy(&CeedVector_dict[*vec]); 186 187 if (*err == 0) { 188 CeedVector_n--; 189 if (CeedVector_n == 0) { 190 CeedFree(&CeedVector_dict); 191 CeedVector_count = 0; 192 CeedVector_count_max = 0; 193 } 194 } 195 } 196 197 static CeedElemRestriction *CeedElemRestriction_dict = NULL; 198 static int CeedElemRestriction_count = 0; 199 static int CeedElemRestriction_n = 0; 200 static int CeedElemRestriction_count_max = 0; 201 202 #define fCeedElemRestrictionCreate \ 203 FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) 204 void fCeedElemRestrictionCreate(int *ceed, int *nelements, 205 int *esize, int *nnodes, int *ncomp, 206 int *memtype, int *copymode, const int *indices, 207 int *elemrestriction, int *err) { 208 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 209 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 210 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 211 } 212 213 const int *indices_ = indices; 214 215 CeedElemRestriction *elemrestriction_ = 216 &CeedElemRestriction_dict[CeedElemRestriction_count]; 217 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, 218 *nnodes, *ncomp, *memtype, *copymode, 219 indices_, elemrestriction_); 220 221 if (*err == 0) { 222 *elemrestriction = CeedElemRestriction_count++; 223 CeedElemRestriction_n++; 224 } 225 } 226 227 #define fCeedElemRestrictionCreateIdentity \ 228 FORTRAN_NAME(ceedelemrestrictioncreateidentity, CEEDELEMRESTRICTIONCREATEIDENTITY) 229 void fCeedElemRestrictionCreateIdentity(int *ceed, int *nelements, 230 int *esize, int *nnodes, int *ncomp, 231 int *elemrestriction, int *err) { 232 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 233 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 234 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 235 } 236 237 CeedElemRestriction *elemrestriction_ = 238 &CeedElemRestriction_dict[CeedElemRestriction_count]; 239 *err = CeedElemRestrictionCreateIdentity(Ceed_dict[*ceed], *nelements, *esize, 240 *nnodes, *ncomp, elemrestriction_); 241 242 if (*err == 0) { 243 *elemrestriction = CeedElemRestriction_count++; 244 CeedElemRestriction_n++; 245 } 246 } 247 248 #define fCeedElemRestrictionCreateBlocked \ 249 FORTRAN_NAME(ceedelemrestrictioncreateblocked,CEEDELEMRESTRICTIONCREATEBLOCKED) 250 void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, 251 int *esize, int *blocksize, int *nnodes, 252 int *ncomp, int *mtype, int *cmode, 253 int *blkindices, int *elemrestriction, 254 int *err) { 255 256 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 257 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 258 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 259 } 260 261 CeedElemRestriction *elemrestriction_ = 262 &CeedElemRestriction_dict[CeedElemRestriction_count]; 263 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, 264 *blocksize, *nnodes, *ncomp, *mtype, 265 *cmode, blkindices, elemrestriction_); 266 267 if (*err == 0) { 268 *elemrestriction = CeedElemRestriction_count++; 269 CeedElemRestriction_n++; 270 } 271 } 272 273 static CeedRequest *CeedRequest_dict = NULL; 274 static int CeedRequest_count = 0; 275 static int CeedRequest_n = 0; 276 static int CeedRequest_count_max = 0; 277 278 #define fCeedElemRestrictionApply \ 279 FORTRAN_NAME(ceedelemrestrictionapply,CEEDELEMRESTRICTIONAPPLY) 280 void fCeedElemRestrictionApply(int *elemr, int *tmode, int *lmode, 281 int *uvec, int *ruvec, int *rqst, int *err) { 282 int createRequest = 1; 283 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 284 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 285 createRequest = 0; 286 287 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 288 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 289 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 290 } 291 292 CeedRequest *rqst_; 293 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 294 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 295 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 296 297 *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], *tmode, 298 *lmode, CeedVector_dict[*uvec], 299 CeedVector_dict[*ruvec], rqst_); 300 301 if (*err == 0 && createRequest) { 302 *rqst = CeedRequest_count++; 303 CeedRequest_n++; 304 } 305 } 306 307 #define fCeedElemRestrictionApplyBlock \ 308 FORTRAN_NAME(ceedelemrestrictionapplyblock,CEEDELEMRESTRICTIONAPPLYBLOCK) 309 void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, 310 int *lmode, 311 int *uvec, int *ruvec, int *rqst, int *err) { 312 int createRequest = 1; 313 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 314 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 315 createRequest = 0; 316 317 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 318 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 319 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 320 } 321 322 CeedRequest *rqst_; 323 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 324 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 325 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 326 327 *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, 328 *tmode, *lmode, CeedVector_dict[*uvec], 329 CeedVector_dict[*ruvec], rqst_); 330 331 if (*err == 0 && createRequest) { 332 *rqst = CeedRequest_count++; 333 CeedRequest_n++; 334 } 335 } 336 337 #define fCeedElemRestrictionGetMultiplicity \ 338 FORTRAN_NAME(ceedelemrestrictiongetmultiplicity,CEEDELEMRESTRICTIONGETMULTIPLICITY) 339 void fCeedElemRestrictionGetMultiplicity(int *elemr, int *lmode, int *mult, 340 int *err) { 341 *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], 342 *lmode, CeedVector_dict[*mult]); 343 } 344 345 #define fCeedElemRestrictionView \ 346 FORTRAN_NAME(ceedelemrestrictionview,CEEDELEMRESTRICTIONVIEW) 347 void fCeedElemRestrictionView(int *elemr, int *err) { 348 *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); 349 } 350 351 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 352 void fCeedRequestWait(int *rqst, int *err) { 353 // TODO Uncomment this once CeedRequestWait is implemented 354 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); 355 356 if (*err == 0) { 357 CeedRequest_n--; 358 if (CeedRequest_n == 0) { 359 CeedFree(&CeedRequest_dict); 360 CeedRequest_count = 0; 361 CeedRequest_count_max = 0; 362 } 363 } 364 } 365 366 #define fCeedElemRestrictionDestroy \ 367 FORTRAN_NAME(ceedelemrestrictiondestroy,CEEDELEMRESTRICTIONDESTROY) 368 void fCeedElemRestrictionDestroy(int *elem, int *err) { 369 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); 370 371 if (*err == 0) { 372 CeedElemRestriction_n--; 373 if (CeedElemRestriction_n == 0) { 374 CeedFree(&CeedElemRestriction_dict); 375 CeedElemRestriction_count = 0; 376 CeedElemRestriction_count_max = 0; 377 } 378 } 379 } 380 381 static CeedBasis *CeedBasis_dict = NULL; 382 static int CeedBasis_count = 0; 383 static int CeedBasis_n = 0; 384 static int CeedBasis_count_max = 0; 385 386 #define fCeedBasisCreateTensorH1Lagrange \ 387 FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) 388 void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, 389 int *ncomp, int *P, int *Q, int *quadmode, 390 int *basis, int *err) { 391 if (CeedBasis_count == CeedBasis_count_max) { 392 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 393 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 394 } 395 396 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *ncomp, *P, *Q, 397 *quadmode, 398 &CeedBasis_dict[CeedBasis_count]); 399 400 if (*err == 0) { 401 *basis = CeedBasis_count++; 402 CeedBasis_n++; 403 } 404 } 405 406 #define fCeedBasisCreateTensorH1 \ 407 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) 408 void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *ncomp, int *P1d, 409 int *Q1d, const CeedScalar *interp1d, 410 const CeedScalar *grad1d, 411 const CeedScalar *qref1d, 412 const CeedScalar *qweight1d, int *basis, 413 int *err) { 414 if (CeedBasis_count == CeedBasis_count_max) { 415 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 416 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 417 } 418 419 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *ncomp, *P1d, *Q1d, 420 interp1d, grad1d, qref1d, qweight1d, 421 &CeedBasis_dict[CeedBasis_count]); 422 423 if (*err == 0) { 424 *basis = CeedBasis_count++; 425 CeedBasis_n++; 426 } 427 } 428 429 #define fCeedBasisCreateH1 \ 430 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) 431 void fCeedBasisCreateH1(int *ceed, int *topo, int *ncomp, int *nnodes, 432 int *nqpts, const CeedScalar *interp, 433 const CeedScalar *grad, const CeedScalar *qref, 434 const CeedScalar *qweight, int *basis, int *err) { 435 if (CeedBasis_count == CeedBasis_count_max) { 436 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 437 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 438 } 439 440 *err = CeedBasisCreateH1(Ceed_dict[*ceed], *topo, *ncomp, *nnodes, *nqpts, 441 interp, grad, qref, qweight, 442 &CeedBasis_dict[CeedBasis_count]); 443 444 if (*err == 0) { 445 *basis = CeedBasis_count++; 446 CeedBasis_n++; 447 } 448 } 449 450 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW) 451 void fCeedBasisView(int *basis, int *err) { 452 *err = CeedBasisView(CeedBasis_dict[*basis], stdout); 453 } 454 455 #define fCeedQRFactorization \ 456 FORTRAN_NAME(ceedqrfactorization, CEEDQRFACTORIZATION) 457 void fCeedQRFactorization(int *ceed, CeedScalar *mat, CeedScalar *tau, int *m, 458 int *n, int *err) { 459 *err = CeedQRFactorization(Ceed_dict[*ceed], mat, tau, *m, *n); 460 } 461 462 #define fCeedSymmetricSchurDecomposition \ 463 FORTRAN_NAME(ceedsymmetricschurdecomposition, CEEDSYMMETRICSCHURDECOMPOSITION) 464 void fCeedSymmetricSchurDecomposition(int *ceed, CeedScalar *mat, 465 CeedScalar *lambda, int *n, int *err) { 466 *err = CeedSymmetricSchurDecomposition(Ceed_dict[*ceed], mat, lambda, *n); 467 } 468 469 #define fCeedSimultaneousDiagonalization \ 470 FORTRAN_NAME(ceedsimultaneousdiagonalization, CEEDSIMULTANEOUSDIAGONALIZATION) 471 void fCeedSimultaneousDiagonalization(int *ceed, CeedScalar *matA, 472 CeedScalar *matB, CeedScalar *x, 473 CeedScalar *lambda, int *n, int *err) { 474 *err = CeedSimultaneousDiagonalization(Ceed_dict[*ceed], matA, matB, x, 475 lambda, *n); 476 } 477 478 #define fCeedBasisGetCollocatedGrad \ 479 FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 480 void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colograd1d, 481 int *err) { 482 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colograd1d); 483 } 484 485 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) 486 void fCeedBasisApply(int *basis, int *nelem, int *tmode, int *emode, 487 int *u, int *v, int *err) { 488 *err = CeedBasisApply(CeedBasis_dict[*basis], *nelem, *tmode, *emode, 489 *u==FORTRAN_VECTOR_NONE? 490 CEED_VECTOR_NONE:CeedVector_dict[*u], 491 CeedVector_dict[*v]); 492 } 493 494 #define fCeedBasisGetNumNodes \ 495 FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) 496 void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { 497 *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); 498 } 499 500 #define fCeedBasisGetNumQuadraturePoints \ 501 FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) 502 void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { 503 *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); 504 } 505 506 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY) 507 void fCeedBasisDestroy(int *basis, int *err) { 508 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]); 509 510 if (*err == 0) { 511 CeedBasis_n--; 512 if (CeedBasis_n == 0) { 513 CeedFree(&CeedBasis_dict); 514 CeedBasis_count = 0; 515 CeedBasis_count_max = 0; 516 } 517 } 518 } 519 520 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE) 521 void fCeedGaussQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 522 int *err) { 523 *err = CeedGaussQuadrature(*Q, qref1d, qweight1d); 524 } 525 526 #define fCeedLobattoQuadrature \ 527 FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE) 528 void fCeedLobattoQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 529 int *err) { 530 *err = CeedLobattoQuadrature(*Q, qref1d, qweight1d); 531 } 532 533 static CeedQFunction *CeedQFunction_dict = NULL; 534 static int CeedQFunction_count = 0; 535 static int CeedQFunction_n = 0; 536 static int CeedQFunction_count_max = 0; 537 538 static int CeedQFunctionFortranStub(void *ctx, int nq, 539 const CeedScalar *const *u, 540 CeedScalar *const *v) { 541 fContext *fctx = ctx; 542 int ierr; 543 544 CeedScalar *ctx_ = (CeedScalar *) fctx->innerctx; 545 fctx->f((void *)ctx_,&nq,u[0],u[1],u[2],u[3],u[4],u[5],u[6], 546 u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15], 547 v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9], 548 v[10],v[11],v[12],v[13],v[14],v[15],&ierr); 549 return ierr; 550 } 551 552 #define fCeedQFunctionCreateInterior \ 553 FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) 554 void fCeedQFunctionCreateInterior(int *ceed, int *vlength, 555 void (*f)(void *ctx, int *nq, 556 const CeedScalar *u,const CeedScalar *u1, 557 const CeedScalar *u2,const CeedScalar *u3, 558 const CeedScalar *u4,const CeedScalar *u5, 559 const CeedScalar *u6,const CeedScalar *u7, 560 const CeedScalar *u8,const CeedScalar *u9, 561 const CeedScalar *u10,const CeedScalar *u11, 562 const CeedScalar *u12,const CeedScalar *u13, 563 const CeedScalar *u14,const CeedScalar *u15, 564 CeedScalar *v,CeedScalar *v1,CeedScalar *v2, 565 CeedScalar *v3,CeedScalar *v4, 566 CeedScalar *v5,CeedScalar *v6, 567 CeedScalar *v7,CeedScalar *v8, 568 CeedScalar *v9,CeedScalar *v10, 569 CeedScalar *v11,CeedScalar *v12, 570 CeedScalar *v13,CeedScalar *v14, 571 CeedScalar *v15,int *err), 572 const char *source, int *qf, int *err, 573 fortran_charlen_t source_len) { 574 FIX_STRING(source); 575 if (CeedQFunction_count == CeedQFunction_count_max) { 576 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 577 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 578 } 579 580 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 581 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vlength, 582 CeedQFunctionFortranStub, source_c, qf_); 583 584 if (*err == 0) { 585 *qf = CeedQFunction_count++; 586 CeedQFunction_n++; 587 } 588 589 fContext *fctx; 590 *err = CeedMalloc(1, &fctx); 591 if (*err) return; 592 fctx->f = f; fctx->innerctx = NULL; fctx->innerctxsize = 0; 593 594 *err = CeedQFunctionSetContext(*qf_, fctx, sizeof(fContext)); 595 596 (*qf_)->fortranstatus = true; 597 } 598 599 #define fCeedQFunctionCreateInteriorByName \ 600 FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME) 601 void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, 602 int *err, fortran_charlen_t name_len) { 603 FIX_STRING(name); 604 if (CeedQFunction_count == CeedQFunction_count_max) { 605 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 606 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 607 } 608 609 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 610 *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_); 611 612 if (*err == 0) { 613 *qf = CeedQFunction_count++; 614 CeedQFunction_n++; 615 } 616 } 617 618 #define fCeedQFunctionCreateIdentity \ 619 FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY) 620 void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, 621 int *outmode, int *qf, int *err) { 622 if (CeedQFunction_count == CeedQFunction_count_max) { 623 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 624 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 625 } 626 627 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 628 *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, *inmode, 629 *outmode, qf_); 630 631 if (*err == 0) { 632 *qf = CeedQFunction_count++; 633 CeedQFunction_n++; 634 } 635 } 636 637 #define fCeedQFunctionAddInput \ 638 FORTRAN_NAME(ceedqfunctionaddinput,CEEDQFUNCTIONADDINPUT) 639 void fCeedQFunctionAddInput(int *qf, const char *fieldname, 640 CeedInt *ncomp, CeedEvalMode *emode, int *err, 641 fortran_charlen_t fieldname_len) { 642 FIX_STRING(fieldname); 643 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 644 645 *err = CeedQFunctionAddInput(qf_, fieldname_c, *ncomp, *emode); 646 } 647 648 #define fCeedQFunctionAddOutput \ 649 FORTRAN_NAME(ceedqfunctionaddoutput,CEEDQFUNCTIONADDOUTPUT) 650 void fCeedQFunctionAddOutput(int *qf, const char *fieldname, 651 CeedInt *ncomp, CeedEvalMode *emode, int *err, 652 fortran_charlen_t fieldname_len) { 653 FIX_STRING(fieldname); 654 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 655 656 *err = CeedQFunctionAddOutput(qf_, fieldname_c, *ncomp, *emode); 657 } 658 659 #define fCeedQFunctionSetContext \ 660 FORTRAN_NAME(ceedqfunctionsetcontext,CEEDQFUNCTIONSETCONTEXT) 661 void fCeedQFunctionSetContext(int *qf, CeedScalar *ctx, CeedInt *n, int *err) { 662 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 663 664 fContext *fctx = qf_->ctx; 665 fctx->innerctx = ctx; 666 fctx->innerctxsize = ((size_t) *n)*sizeof(CeedScalar); 667 } 668 669 #define fCeedQFunctionView \ 670 FORTRAN_NAME(ceedqfunctionview,CEEDQFUNCTIONVIEW) 671 void fCeedQFunctionView(int *qf, int *err) { 672 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 673 674 *err = CeedQFunctionView(qf_, stdout); 675 } 676 677 #define fCeedQFunctionApply \ 678 FORTRAN_NAME(ceedqfunctionapply,CEEDQFUNCTIONAPPLY) 679 //TODO Need Fixing, double pointer 680 void fCeedQFunctionApply(int *qf, int *Q, 681 int *u, int *u1, int *u2, int *u3, 682 int *u4, int *u5, int *u6, int *u7, 683 int *u8, int *u9, int *u10, int *u11, 684 int *u12, int *u13, int *u14, int *u15, 685 int *v, int *v1, int *v2, int *v3, 686 int *v4, int *v5, int *v6, int *v7, 687 int *v8, int *v9, int *v10, int *v11, 688 int *v12, int *v13, int *v14, int *v15, int *err) { 689 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 690 CeedVector *in; 691 *err = CeedCalloc(16, &in); 692 if (*err) return; 693 in[0] = *u==FORTRAN_NULL?NULL:CeedVector_dict[*u]; 694 in[1] = *u1==FORTRAN_NULL?NULL:CeedVector_dict[*u1]; 695 in[2] = *u2==FORTRAN_NULL?NULL:CeedVector_dict[*u2]; 696 in[3] = *u3==FORTRAN_NULL?NULL:CeedVector_dict[*u3]; 697 in[4] = *u4==FORTRAN_NULL?NULL:CeedVector_dict[*u4]; 698 in[5] = *u5==FORTRAN_NULL?NULL:CeedVector_dict[*u5]; 699 in[6] = *u6==FORTRAN_NULL?NULL:CeedVector_dict[*u6]; 700 in[7] = *u7==FORTRAN_NULL?NULL:CeedVector_dict[*u7]; 701 in[8] = *u8==FORTRAN_NULL?NULL:CeedVector_dict[*u8]; 702 in[9] = *u9==FORTRAN_NULL?NULL:CeedVector_dict[*u9]; 703 in[10] = *u10==FORTRAN_NULL?NULL:CeedVector_dict[*u10]; 704 in[11] = *u11==FORTRAN_NULL?NULL:CeedVector_dict[*u11]; 705 in[12] = *u12==FORTRAN_NULL?NULL:CeedVector_dict[*u12]; 706 in[13] = *u13==FORTRAN_NULL?NULL:CeedVector_dict[*u13]; 707 in[14] = *u14==FORTRAN_NULL?NULL:CeedVector_dict[*u14]; 708 in[15] = *u15==FORTRAN_NULL?NULL:CeedVector_dict[*u15]; 709 CeedVector *out; 710 *err = CeedCalloc(16, &out); 711 if (*err) return; 712 out[0] = *v==FORTRAN_NULL?NULL:CeedVector_dict[*v]; 713 out[1] = *v1==FORTRAN_NULL?NULL:CeedVector_dict[*v1]; 714 out[2] = *v2==FORTRAN_NULL?NULL:CeedVector_dict[*v2]; 715 out[3] = *v3==FORTRAN_NULL?NULL:CeedVector_dict[*v3]; 716 out[4] = *v4==FORTRAN_NULL?NULL:CeedVector_dict[*v4]; 717 out[5] = *v5==FORTRAN_NULL?NULL:CeedVector_dict[*v5]; 718 out[6] = *v6==FORTRAN_NULL?NULL:CeedVector_dict[*v6]; 719 out[7] = *v7==FORTRAN_NULL?NULL:CeedVector_dict[*v7]; 720 out[8] = *v8==FORTRAN_NULL?NULL:CeedVector_dict[*v8]; 721 out[9] = *v9==FORTRAN_NULL?NULL:CeedVector_dict[*v9]; 722 out[10] = *v10==FORTRAN_NULL?NULL:CeedVector_dict[*v10]; 723 out[11] = *v11==FORTRAN_NULL?NULL:CeedVector_dict[*v11]; 724 out[12] = *v12==FORTRAN_NULL?NULL:CeedVector_dict[*v12]; 725 out[13] = *v13==FORTRAN_NULL?NULL:CeedVector_dict[*v13]; 726 out[14] = *v14==FORTRAN_NULL?NULL:CeedVector_dict[*v14]; 727 out[15] = *v15==FORTRAN_NULL?NULL:CeedVector_dict[*v15]; 728 *err = CeedQFunctionApply(qf_, *Q, in, out); 729 if (*err) return; 730 731 *err = CeedFree(&in); 732 if (*err) return; 733 *err = CeedFree(&out); 734 } 735 736 #define fCeedQFunctionDestroy \ 737 FORTRAN_NAME(ceedqfunctiondestroy,CEEDQFUNCTIONDESTROY) 738 void fCeedQFunctionDestroy(int *qf, int *err) { 739 bool fstatus; 740 *err = CeedQFunctionGetFortranStatus(CeedQFunction_dict[*qf], &fstatus); 741 if (*err) return; 742 if (fstatus) { 743 fContext *fctx = CeedQFunction_dict[*qf]->ctx; 744 *err = CeedFree(&fctx); 745 if (*err) return; 746 } 747 748 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); 749 if (*err) return; 750 751 CeedQFunction_n--; 752 if (CeedQFunction_n == 0) { 753 *err = CeedFree(&CeedQFunction_dict); 754 CeedQFunction_count = 0; 755 CeedQFunction_count_max = 0; 756 } 757 } 758 759 static CeedOperator *CeedOperator_dict = NULL; 760 static int CeedOperator_count = 0; 761 static int CeedOperator_n = 0; 762 static int CeedOperator_count_max = 0; 763 764 #define fCeedOperatorCreate \ 765 FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) 766 void fCeedOperatorCreate(int *ceed, 767 int *qf, int *dqf, int *dqfT, int *op, int *err) { 768 if (CeedOperator_count == CeedOperator_count_max) 769 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 770 CeedOperator_dict = realloc(CeedOperator_dict, 771 sizeof(CeedOperator)*CeedOperator_count_max); 772 773 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 774 775 CeedQFunction dqf_ = CEED_QFUNCTION_NONE, dqfT_ = CEED_QFUNCTION_NONE; 776 if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_ = CeedQFunction_dict[*dqf ]; 777 if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_ = CeedQFunction_dict[*dqfT]; 778 779 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, 780 dqfT_, op_); 781 if (*err) return; 782 *op = CeedOperator_count++; 783 CeedOperator_n++; 784 } 785 786 #define fCeedCompositeOperatorCreate \ 787 FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) 788 void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { 789 if (CeedOperator_count == CeedOperator_count_max) 790 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 791 CeedOperator_dict = realloc(CeedOperator_dict, 792 sizeof(CeedOperator)*CeedOperator_count_max); 793 794 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 795 796 *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); 797 if (*err) return; 798 *op = CeedOperator_count++; 799 CeedOperator_n++; 800 } 801 802 #define fCeedOperatorSetField \ 803 FORTRAN_NAME(ceedoperatorsetfield,CEEDOPERATORSETFIELD) 804 void fCeedOperatorSetField(int *op, const char *fieldname, 805 int *r, int *lmode, int *b, int *v, int *err, 806 fortran_charlen_t fieldname_len) { 807 FIX_STRING(fieldname); 808 CeedElemRestriction r_; 809 CeedBasis b_; 810 CeedVector v_; 811 812 CeedOperator op_ = CeedOperator_dict[*op]; 813 814 if (*r == FORTRAN_NULL) { 815 r_ = NULL; 816 } else { 817 r_ = CeedElemRestriction_dict[*r]; 818 } 819 820 if (*b == FORTRAN_NULL) { 821 b_ = NULL; 822 } else if (*b == FORTRAN_BASIS_COLLOCATED) { 823 b_ = CEED_BASIS_COLLOCATED; 824 } else { 825 b_ = CeedBasis_dict[*b]; 826 } 827 if (*v == FORTRAN_NULL) { 828 v_ = NULL; 829 } else if (*v == FORTRAN_VECTOR_ACTIVE) { 830 v_ = CEED_VECTOR_ACTIVE; 831 } else if (*v == FORTRAN_VECTOR_NONE) { 832 v_ = CEED_VECTOR_NONE; 833 } else { 834 v_ = CeedVector_dict[*v]; 835 } 836 837 *err = CeedOperatorSetField(op_, fieldname_c, r_, *lmode, b_, v_); 838 } 839 840 #define fCeedCompositeOperatorAddSub \ 841 FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) 842 void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { 843 CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; 844 CeedOperator subop_ = CeedOperator_dict[*subop]; 845 846 *err = CeedCompositeOperatorAddSub(compositeop_, subop_); 847 if (*err) return; 848 } 849 850 #define fCeedOperatorAssembleLinearQFunction FORTRAN_NAME(ceedoperatorassemblelinearqfunction, CEEDOPERATORASSEMBLELINEARQFUNCTION) 851 void fCeedOperatorAssembleLinearQFunction(int *op, int *assembledvec, 852 int *assembledrstr, int *rqst, int *err) { 853 // Vector 854 if (CeedVector_count == CeedVector_count_max) { 855 CeedVector_count_max += CeedVector_count_max/2 + 1; 856 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 857 } 858 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 859 860 // Restriction 861 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 862 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 863 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 864 } 865 CeedElemRestriction *rstr_ = 866 &CeedElemRestriction_dict[CeedElemRestriction_count]; 867 868 int createRequest = 1; 869 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 870 if (*rqst == -1 || *rqst == -2) { 871 createRequest = 0; 872 } 873 874 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 875 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 876 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 877 } 878 879 CeedRequest *rqst_; 880 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 881 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 882 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 883 884 *err = CeedOperatorAssembleLinearQFunction(CeedOperator_dict[*op], 885 assembledvec_, rstr_, rqst_); 886 if (*err) return; 887 if (createRequest) { 888 *rqst = CeedRequest_count++; 889 CeedRequest_n++; 890 } 891 892 if (*err == 0) { 893 *assembledrstr = CeedElemRestriction_count++; 894 CeedElemRestriction_n++; 895 *assembledvec = CeedVector_count++; 896 CeedVector_n++; 897 } 898 } 899 900 #define fCeedOperatorAssembleLinearDiagonal FORTRAN_NAME(ceedoperatorassemblelineardiagonal, CEEDOPERATORASSEMBLELINEARDIAGONAL) 901 void fCeedOperatorAssembleLinearDiagonal(int *op, int *assembledvec, 902 int *rqst, int *err) { 903 // Vector 904 if (CeedVector_count == CeedVector_count_max) { 905 CeedVector_count_max += CeedVector_count_max/2 + 1; 906 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 907 } 908 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 909 910 int createRequest = 1; 911 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 912 if (*rqst == -1 || *rqst == -2) { 913 createRequest = 0; 914 } 915 916 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 917 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 918 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 919 } 920 921 CeedRequest *rqst_; 922 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 923 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 924 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 925 926 *err = CeedOperatorAssembleLinearDiagonal(CeedOperator_dict[*op], 927 assembledvec_, rqst_); 928 if (*err) return; 929 if (createRequest) { 930 *rqst = CeedRequest_count++; 931 CeedRequest_n++; 932 } 933 934 if (*err == 0) { 935 *assembledvec = CeedVector_count++; 936 CeedVector_n++; 937 } 938 } 939 940 #define fCeedOperatorView \ 941 FORTRAN_NAME(ceedoperatorview,CEEDOPERATORVIEW) 942 void fCeedOperatorView(int *op, int *err) { 943 CeedOperator op_ = CeedOperator_dict[*op]; 944 945 *err = CeedOperatorView(op_, stdout); 946 } 947 948 #define fCeedOperatorCreateFDMElementInverse FORTRAN_NAME(ceedoperatorcreatefdmelementinverse, CEEDOPERATORCREATEFDMELEMENTINVERSE) 949 void fCeedOperatorCreateFDMElementInverse(int *op, int *fdminv, 950 int *rqst, int *err) { 951 // Operator 952 if (CeedOperator_count == CeedOperator_count_max) { 953 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 954 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 955 } 956 CeedOperator *fdminv_ = 957 &CeedOperator_dict[CeedOperator_count]; 958 959 int createRequest = 1; 960 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 961 if (*rqst == -1 || *rqst == -2) { 962 createRequest = 0; 963 } 964 965 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 966 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 967 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 968 } 969 970 CeedRequest *rqst_; 971 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 972 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 973 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 974 975 *err = CeedOperatorCreateFDMElementInverse(CeedOperator_dict[*op], 976 fdminv_, rqst_); 977 if (*err) return; 978 if (createRequest) { 979 *rqst = CeedRequest_count++; 980 CeedRequest_n++; 981 } 982 983 if (*err == 0) { 984 *fdminv = CeedOperator_count++; 985 CeedOperator_n++; 986 } 987 } 988 989 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) 990 void fCeedOperatorApply(int *op, int *ustatevec, 991 int *resvec, int *rqst, int *err) { 992 CeedVector ustatevec_ = (*ustatevec == FORTRAN_NULL) ? 993 NULL : (*ustatevec == FORTRAN_VECTOR_NONE ? 994 CEED_VECTOR_NONE : CeedVector_dict[*ustatevec]); 995 CeedVector resvec_ = (*resvec == FORTRAN_NULL) ? 996 NULL : (*resvec == FORTRAN_VECTOR_NONE ? 997 CEED_VECTOR_NONE : CeedVector_dict[*resvec]); 998 999 int createRequest = 1; 1000 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1001 if (*rqst == -1 || *rqst == -2) { 1002 createRequest = 0; 1003 } 1004 1005 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1006 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1007 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1008 } 1009 1010 CeedRequest *rqst_; 1011 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1012 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1013 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1014 1015 *err = CeedOperatorApply(CeedOperator_dict[*op], 1016 ustatevec_, resvec_, rqst_); 1017 if (*err) return; 1018 if (createRequest) { 1019 *rqst = CeedRequest_count++; 1020 CeedRequest_n++; 1021 } 1022 } 1023 1024 #define fCeedOperatorApplyAdd FORTRAN_NAME(ceedoperatorapplyadd, CEEDOPERATORAPPLYADD) 1025 void fCeedOperatorApplyAdd(int *op, int *ustatevec, 1026 int *resvec, int *rqst, int *err) { 1027 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL 1028 ? NULL : CeedVector_dict[*ustatevec]; 1029 CeedVector resvec_ = *resvec == FORTRAN_NULL 1030 ? NULL : CeedVector_dict[*resvec]; 1031 1032 int createRequest = 1; 1033 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1034 if (*rqst == -1 || *rqst == -2) { 1035 createRequest = 0; 1036 } 1037 1038 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1039 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1040 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1041 } 1042 1043 CeedRequest *rqst_; 1044 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1045 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1046 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1047 1048 *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], 1049 ustatevec_, resvec_, rqst_); 1050 if (*err) return; 1051 if (createRequest) { 1052 *rqst = CeedRequest_count++; 1053 CeedRequest_n++; 1054 } 1055 } 1056 1057 #define fCeedOperatorApplyJacobian \ 1058 FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) 1059 void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, 1060 int *dustatevec, int *dresvec, int *rqst, 1061 int *err) { 1062 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented 1063 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], 1064 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], 1065 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); 1066 } 1067 1068 #define fCeedOperatorDestroy \ 1069 FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) 1070 void fCeedOperatorDestroy(int *op, int *err) { 1071 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); 1072 if (*err) return; 1073 CeedOperator_n--; 1074 if (CeedOperator_n == 0) { 1075 *err = CeedFree(&CeedOperator_dict); 1076 CeedOperator_count = 0; 1077 CeedOperator_count_max = 0; 1078 } 1079 } 1080