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