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