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