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