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