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