1 // Fortran interface 2 #include <ceed.h> 3 #include <ceed-impl.h> 4 #include <ceed-backend.h> 5 #include <ceed-fortran-name.h> 6 #include <stdlib.h> 7 #include <string.h> 8 9 #define FORTRAN_REQUEST_IMMEDIATE -1 10 #define FORTRAN_REQUEST_ORDERED -2 11 #define FORTRAN_NULL -3 12 #define FORTRAN_BASIS_COLLOCATED -1 13 #define FORTRAN_VECTOR_ACTIVE -1 14 #define FORTRAN_VECTOR_NONE -2 15 16 static Ceed *Ceed_dict = NULL; 17 static int Ceed_count = 0; 18 static int Ceed_n = 0; 19 static int Ceed_count_max = 0; 20 21 // This test should actually be for the gfortran version, but we don't currently 22 // have a configure system to determine that (TODO). At present, this will use 23 // the smaller integer when run with clang+gfortran=8, for example. (That is 24 // sketchy, but will likely work for users that don't have huge character 25 // strings.) 26 #if __GNUC__ >= 8 27 typedef size_t fortran_charlen_t; 28 #else 29 typedef int fortran_charlen_t; 30 #endif 31 32 #define Splice(a, b) a ## b 33 34 // Fortran strings are generally unterminated and the length is passed as an 35 // extra argument after all the normal arguments. Some compilers (I only know 36 // of Windows) place the length argument immediately after the string parameter 37 // (TODO). 38 // 39 // We can't just NULL-terminate the string in-place because that could overwrite 40 // other strings or attempt to write to read-only memory. This macro allocates 41 // a string to hold the null-terminated version of the string that C expects. 42 #define FIX_STRING(stringname) \ 43 char Splice(stringname, _c)[1024]; \ 44 if (Splice(stringname, _len) > 1023) \ 45 CeedError(NULL, 1, "Fortran string length too long %zd", (size_t)Splice(stringname, _len)); \ 46 strncpy(Splice(stringname, _c), stringname, Splice(stringname, _len)); \ 47 Splice(stringname, _c)[Splice(stringname, _len)] = 0; \ 48 49 #define fCeedInit FORTRAN_NAME(ceedinit,CEEDINIT) 50 void fCeedInit(const char *resource, int *ceed, int *err, 51 fortran_charlen_t resource_len) { 52 FIX_STRING(resource); 53 if (Ceed_count == Ceed_count_max) { 54 Ceed_count_max += Ceed_count_max/2 + 1; 55 CeedRealloc(Ceed_count_max, &Ceed_dict); 56 } 57 58 Ceed *ceed_ = &Ceed_dict[Ceed_count]; 59 *err = CeedInit(resource_c, ceed_); 60 61 if (*err == 0) { 62 *ceed = Ceed_count++; 63 Ceed_n++; 64 } 65 } 66 67 #define fCeedGetPreferredMemType \ 68 FORTRAN_NAME(ceedgetpreferredmemtype,CEEDGETPREFERREDMEMTYPE) 69 void fCeedGetPreferredMemType(int *ceed, int *type, int *err) { 70 *err = CeedGetPreferredMemType(Ceed_dict[*ceed], (CeedMemType *)type); 71 } 72 73 #define fCeedDestroy FORTRAN_NAME(ceeddestroy,CEEDDESTROY) 74 void fCeedDestroy(int *ceed, int *err) { 75 *err = CeedDestroy(&Ceed_dict[*ceed]); 76 77 if (*err == 0) { 78 Ceed_n--; 79 if (Ceed_n == 0) { 80 CeedFree(&Ceed_dict); 81 Ceed_count = 0; 82 Ceed_count_max = 0; 83 } 84 } 85 } 86 87 static CeedVector *CeedVector_dict = NULL; 88 static int CeedVector_count = 0; 89 static int CeedVector_n = 0; 90 static int CeedVector_count_max = 0; 91 92 #define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate,CEEDVECTORCREATE) 93 void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) { 94 if (CeedVector_count == CeedVector_count_max) { 95 CeedVector_count_max += CeedVector_count_max/2 + 1; 96 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 97 } 98 99 CeedVector *vec_ = &CeedVector_dict[CeedVector_count]; 100 *err = CeedVectorCreate(Ceed_dict[*ceed], *length, vec_); 101 102 if (*err == 0) { 103 *vec = CeedVector_count++; 104 CeedVector_n++; 105 } 106 } 107 108 #define fCeedVectorSetArray FORTRAN_NAME(ceedvectorsetarray,CEEDVECTORSETARRAY) 109 void fCeedVectorSetArray(int *vec, int *memtype, int *copymode, 110 CeedScalar *array, int64_t *offset, int *err) { 111 *err = CeedVectorSetArray(CeedVector_dict[*vec], *memtype, *copymode, 112 (CeedScalar *)(array + *offset)); 113 } 114 115 #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray,CEEDVECTORSYNCARRAY) 116 void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { 117 *err = CeedVectorSyncArray(CeedVector_dict[*vec], *memtype); 118 } 119 120 #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue,CEEDVECTORSETVALUE) 121 void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { 122 *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); 123 } 124 125 #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray,CEEDVECTORGETARRAY) 126 void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, 127 int64_t *offset, 128 int *err) { 129 CeedScalar *b; 130 CeedVector vec_ = CeedVector_dict[*vec]; 131 *err = CeedVectorGetArray(vec_, *memtype, &b); 132 *offset = b - array; 133 } 134 135 #define fCeedVectorGetArrayRead \ 136 FORTRAN_NAME(ceedvectorgetarrayread,CEEDVECTORGETARRAYREAD) 137 void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, 138 int64_t *offset, int *err) { 139 const CeedScalar *b; 140 CeedVector vec_ = CeedVector_dict[*vec]; 141 *err = CeedVectorGetArrayRead(vec_, *memtype, &b); 142 *offset = b - array; 143 } 144 145 #define fCeedVectorRestoreArray \ 146 FORTRAN_NAME(ceedvectorrestorearray,CEEDVECTORRESTOREARRAY) 147 void fCeedVectorRestoreArray(int *vec, CeedScalar *array, 148 int64_t *offset, int *err) { 149 *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &array); 150 *offset = 0; 151 } 152 153 #define fCeedVectorRestoreArrayRead \ 154 FORTRAN_NAME(ceedvectorrestorearrayread,CEEDVECTORRESTOREARRAYREAD) 155 void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, 156 int64_t *offset, int *err) { 157 *err = CeedVectorRestoreArrayRead(CeedVector_dict[*vec], &array); 158 *offset = 0; 159 } 160 161 #define fCeedVectorView FORTRAN_NAME(ceedvectorview,CEEDVECTORVIEW) 162 void fCeedVectorView(int *vec, int *err) { 163 *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); 164 } 165 166 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy,CEEDVECTORDESTROY) 167 void fCeedVectorDestroy(int *vec, int *err) { 168 *err = CeedVectorDestroy(&CeedVector_dict[*vec]); 169 170 if (*err == 0) { 171 CeedVector_n--; 172 if (CeedVector_n == 0) { 173 CeedFree(&CeedVector_dict); 174 CeedVector_count = 0; 175 CeedVector_count_max = 0; 176 } 177 } 178 } 179 180 static CeedElemRestriction *CeedElemRestriction_dict = NULL; 181 static int CeedElemRestriction_count = 0; 182 static int CeedElemRestriction_n = 0; 183 static int CeedElemRestriction_count_max = 0; 184 185 #define fCeedElemRestrictionCreate \ 186 FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) 187 void fCeedElemRestrictionCreate(int *ceed, int *nelements, 188 int *esize, int *nnodes, int *ncomp, 189 int *memtype, int *copymode, const int *indices, 190 int *elemrestriction, int *err) { 191 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 192 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 193 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 194 } 195 196 const int *indices_ = indices; 197 198 CeedElemRestriction *elemrestriction_ = 199 &CeedElemRestriction_dict[CeedElemRestriction_count]; 200 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, 201 *nnodes, *ncomp, *memtype, *copymode, 202 indices_, elemrestriction_); 203 204 if (*err == 0) { 205 *elemrestriction = CeedElemRestriction_count++; 206 CeedElemRestriction_n++; 207 } 208 } 209 210 #define fCeedElemRestrictionCreateIdentity \ 211 FORTRAN_NAME(ceedelemrestrictioncreateidentity, CEEDELEMRESTRICTIONCREATEIDENTITY) 212 void fCeedElemRestrictionCreateIdentity(int *ceed, int *nelements, 213 int *esize, int *nnodes, int *ncomp, 214 int *elemrestriction, int *err) { 215 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 216 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 217 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 218 } 219 220 CeedElemRestriction *elemrestriction_ = 221 &CeedElemRestriction_dict[CeedElemRestriction_count]; 222 *err = CeedElemRestrictionCreateIdentity(Ceed_dict[*ceed], *nelements, *esize, 223 *nnodes, *ncomp, elemrestriction_); 224 225 if (*err == 0) { 226 *elemrestriction = CeedElemRestriction_count++; 227 CeedElemRestriction_n++; 228 } 229 } 230 231 #define fCeedElemRestrictionCreateBlocked \ 232 FORTRAN_NAME(ceedelemrestrictioncreateblocked,CEEDELEMRESTRICTIONCREATEBLOCKED) 233 void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, 234 int *esize, int *blocksize, int *nnodes, 235 int *ncomp, int *mtype, int *cmode, 236 int *blkindices, int *elemrestriction, 237 int *err) { 238 239 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 240 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 241 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 242 } 243 244 CeedElemRestriction *elemrestriction_ = 245 &CeedElemRestriction_dict[CeedElemRestriction_count]; 246 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, 247 *blocksize, *nnodes, *ncomp, *mtype, 248 *cmode, blkindices, elemrestriction_); 249 250 if (*err == 0) { 251 *elemrestriction = CeedElemRestriction_count++; 252 CeedElemRestriction_n++; 253 } 254 } 255 256 static CeedRequest *CeedRequest_dict = NULL; 257 static int CeedRequest_count = 0; 258 static int CeedRequest_n = 0; 259 static int CeedRequest_count_max = 0; 260 261 #define fCeedElemRestrictionApply \ 262 FORTRAN_NAME(ceedelemrestrictionapply,CEEDELEMRESTRICTIONAPPLY) 263 void fCeedElemRestrictionApply(int *elemr, int *tmode, int *lmode, 264 int *uvec, int *ruvec, int *rqst, int *err) { 265 int createRequest = 1; 266 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 267 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 268 createRequest = 0; 269 270 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 271 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 272 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 273 } 274 275 CeedRequest *rqst_; 276 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 277 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 278 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 279 280 *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], *tmode, 281 *lmode, CeedVector_dict[*uvec], 282 CeedVector_dict[*ruvec], rqst_); 283 284 if (*err == 0 && createRequest) { 285 *rqst = CeedRequest_count++; 286 CeedRequest_n++; 287 } 288 } 289 290 #define fCeedElemRestrictionApplyBlock \ 291 FORTRAN_NAME(ceedelemrestrictionapplyblock,CEEDELEMRESTRICTIONAPPLYBLOCK) 292 void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, 293 int *lmode, 294 int *uvec, int *ruvec, int *rqst, int *err) { 295 int createRequest = 1; 296 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 297 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 298 createRequest = 0; 299 300 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 301 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 302 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 303 } 304 305 CeedRequest *rqst_; 306 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 307 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 308 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 309 310 *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, 311 *tmode, *lmode, CeedVector_dict[*uvec], 312 CeedVector_dict[*ruvec], rqst_); 313 314 if (*err == 0 && createRequest) { 315 *rqst = CeedRequest_count++; 316 CeedRequest_n++; 317 } 318 } 319 320 #define fCeedElemRestrictionGetMultiplicity \ 321 FORTRAN_NAME(ceedelemrestrictiongetmultiplicity,CEEDELEMRESTRICTIONGETMULTIPLICITY) 322 void fCeedElemRestrictionGetMultiplicity(int *elemr, int *mult, int *err) { 323 *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], 324 CeedVector_dict[*mult]); 325 } 326 327 #define fCeedElemRestrictionView \ 328 FORTRAN_NAME(ceedelemrestrictionview,CEEDELEMRESTRICTIONVIEW) 329 void fCeedElemRestrictionView(int *elemr, int *err) { 330 *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); 331 } 332 333 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 334 void fCeedRequestWait(int *rqst, int *err) { 335 // TODO Uncomment this once CeedRequestWait is implemented 336 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); 337 338 if (*err == 0) { 339 CeedRequest_n--; 340 if (CeedRequest_n == 0) { 341 CeedFree(&CeedRequest_dict); 342 CeedRequest_count = 0; 343 CeedRequest_count_max = 0; 344 } 345 } 346 } 347 348 #define fCeedElemRestrictionDestroy \ 349 FORTRAN_NAME(ceedelemrestrictiondestroy,CEEDELEMRESTRICTIONDESTROY) 350 void fCeedElemRestrictionDestroy(int *elem, int *err) { 351 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); 352 353 if (*err == 0) { 354 CeedElemRestriction_n--; 355 if (CeedElemRestriction_n == 0) { 356 CeedFree(&CeedElemRestriction_dict); 357 CeedElemRestriction_count = 0; 358 CeedElemRestriction_count_max = 0; 359 } 360 } 361 } 362 363 static CeedBasis *CeedBasis_dict = NULL; 364 static int CeedBasis_count = 0; 365 static int CeedBasis_n = 0; 366 static int CeedBasis_count_max = 0; 367 368 #define fCeedBasisCreateTensorH1Lagrange \ 369 FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) 370 void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, 371 int *ncomp, int *P, int *Q, int *quadmode, 372 int *basis, int *err) { 373 if (CeedBasis_count == CeedBasis_count_max) { 374 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 375 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 376 } 377 378 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *ncomp, *P, *Q, 379 *quadmode, 380 &CeedBasis_dict[CeedBasis_count]); 381 382 if (*err == 0) { 383 *basis = CeedBasis_count++; 384 CeedBasis_n++; 385 } 386 } 387 388 #define fCeedBasisCreateTensorH1 \ 389 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) 390 void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *ncomp, int *P1d, 391 int *Q1d, const CeedScalar *interp1d, 392 const CeedScalar *grad1d, 393 const CeedScalar *qref1d, 394 const CeedScalar *qweight1d, int *basis, 395 int *err) { 396 if (CeedBasis_count == CeedBasis_count_max) { 397 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 398 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 399 } 400 401 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *ncomp, *P1d, *Q1d, 402 interp1d, grad1d, qref1d, qweight1d, 403 &CeedBasis_dict[CeedBasis_count]); 404 405 if (*err == 0) { 406 *basis = CeedBasis_count++; 407 CeedBasis_n++; 408 } 409 } 410 411 #define fCeedBasisCreateH1 \ 412 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) 413 void fCeedBasisCreateH1(int *ceed, int *topo, int *ncomp, int *nnodes, 414 int *nqpts, const CeedScalar *interp, 415 const CeedScalar *grad, const CeedScalar *qref, 416 const CeedScalar *qweight, int *basis, int *err) { 417 if (CeedBasis_count == CeedBasis_count_max) { 418 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 419 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 420 } 421 422 *err = CeedBasisCreateH1(Ceed_dict[*ceed], *topo, *ncomp, *nnodes, *nqpts, 423 interp, grad, qref, qweight, 424 &CeedBasis_dict[CeedBasis_count]); 425 426 if (*err == 0) { 427 *basis = CeedBasis_count++; 428 CeedBasis_n++; 429 } 430 } 431 432 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW) 433 void fCeedBasisView(int *basis, int *err) { 434 *err = CeedBasisView(CeedBasis_dict[*basis], stdout); 435 } 436 437 #define fCeedQRFactorization \ 438 FORTRAN_NAME(ceedqrfactorization, CEEDQRFACTORIZATION) 439 void fCeedQRFactorization(int *ceed, CeedScalar *mat, CeedScalar *tau, int *m, 440 int *n, int *err) { 441 *err = CeedQRFactorization(Ceed_dict[*ceed], mat, tau, *m, *n); 442 } 443 444 #define fCeedSymmetricSchurDecomposition \ 445 FORTRAN_NAME(ceedsymmetricschurdecomposition, CEEDSYMMETRICSCHURDECOMPOSITION) 446 void fCeedSymmetricSchurDecomposition(int *ceed, CeedScalar *mat, 447 CeedScalar *lambda, int *n, int *err) { 448 *err = CeedSymmetricSchurDecomposition(Ceed_dict[*ceed], mat, lambda, *n); 449 } 450 451 #define fCeedSimultaneousDiagonalization \ 452 FORTRAN_NAME(ceedsimultaneousdiagonalization, CEEDSIMULTANEOUSDIAGONALIZATION) 453 void fCeedSimultaneousDiagonalization(int *ceed, CeedScalar *matA, 454 CeedScalar *matB, CeedScalar *x, 455 CeedScalar *lambda, int *n, int *err) { 456 *err = CeedSimultaneousDiagonalization(Ceed_dict[*ceed], matA, matB, x, 457 lambda, *n); 458 } 459 460 #define fCeedBasisGetCollocatedGrad \ 461 FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 462 void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colograd1d, 463 int *err) { 464 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colograd1d); 465 } 466 467 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) 468 void fCeedBasisApply(int *basis, int *nelem, int *tmode, int *emode, 469 int *u, int *v, int *err) { 470 *err = CeedBasisApply(CeedBasis_dict[*basis], *nelem, *tmode, *emode, 471 *u==FORTRAN_VECTOR_NONE? 472 CEED_VECTOR_NONE:CeedVector_dict[*u], 473 CeedVector_dict[*v]); 474 } 475 476 #define fCeedBasisGetNumNodes \ 477 FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) 478 void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { 479 *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); 480 } 481 482 #define fCeedBasisGetNumQuadraturePoints \ 483 FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) 484 void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { 485 *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); 486 } 487 488 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY) 489 void fCeedBasisDestroy(int *basis, int *err) { 490 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]); 491 492 if (*err == 0) { 493 CeedBasis_n--; 494 if (CeedBasis_n == 0) { 495 CeedFree(&CeedBasis_dict); 496 CeedBasis_count = 0; 497 CeedBasis_count_max = 0; 498 } 499 } 500 } 501 502 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE) 503 void fCeedGaussQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 504 int *err) { 505 *err = CeedGaussQuadrature(*Q, qref1d, qweight1d); 506 } 507 508 #define fCeedLobattoQuadrature \ 509 FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE) 510 void fCeedLobattoQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 511 int *err) { 512 *err = CeedLobattoQuadrature(*Q, qref1d, qweight1d); 513 } 514 515 static CeedQFunction *CeedQFunction_dict = NULL; 516 static int CeedQFunction_count = 0; 517 static int CeedQFunction_n = 0; 518 static int CeedQFunction_count_max = 0; 519 520 static int CeedQFunctionFortranStub(void *ctx, int nq, 521 const CeedScalar *const *u, 522 CeedScalar *const *v) { 523 fContext *fctx = ctx; 524 int ierr; 525 526 CeedScalar *ctx_ = (CeedScalar *) fctx->innerctx; 527 fctx->f((void *)ctx_,&nq,u[0],u[1],u[2],u[3],u[4],u[5],u[6], 528 u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15], 529 v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9], 530 v[10],v[11],v[12],v[13],v[14],v[15],&ierr); 531 return ierr; 532 } 533 534 #define fCeedQFunctionCreateInterior \ 535 FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) 536 void fCeedQFunctionCreateInterior(int *ceed, int *vlength, 537 void (*f)(void *ctx, int *nq, 538 const CeedScalar *u,const CeedScalar *u1, 539 const CeedScalar *u2,const CeedScalar *u3, 540 const CeedScalar *u4,const CeedScalar *u5, 541 const CeedScalar *u6,const CeedScalar *u7, 542 const CeedScalar *u8,const CeedScalar *u9, 543 const CeedScalar *u10,const CeedScalar *u11, 544 const CeedScalar *u12,const CeedScalar *u13, 545 const CeedScalar *u14,const CeedScalar *u15, 546 CeedScalar *v,CeedScalar *v1,CeedScalar *v2, 547 CeedScalar *v3,CeedScalar *v4, 548 CeedScalar *v5,CeedScalar *v6, 549 CeedScalar *v7,CeedScalar *v8, 550 CeedScalar *v9,CeedScalar *v10, 551 CeedScalar *v11,CeedScalar *v12, 552 CeedScalar *v13,CeedScalar *v14, 553 CeedScalar *v15,int *err), 554 const char *source, int *qf, int *err, 555 fortran_charlen_t source_len) { 556 FIX_STRING(source); 557 if (CeedQFunction_count == CeedQFunction_count_max) { 558 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 559 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 560 } 561 562 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 563 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vlength, 564 CeedQFunctionFortranStub, source_c, qf_); 565 566 if (*err == 0) { 567 *qf = CeedQFunction_count++; 568 CeedQFunction_n++; 569 } 570 571 fContext *fctx; 572 *err = CeedMalloc(1, &fctx); 573 if (*err) return; 574 fctx->f = f; fctx->innerctx = NULL; fctx->innerctxsize = 0; 575 576 *err = CeedQFunctionSetContext(*qf_, fctx, sizeof(fContext)); 577 578 (*qf_)->fortranstatus = true; 579 } 580 581 #define fCeedQFunctionCreateInteriorByName \ 582 FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME) 583 void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, 584 int *err, fortran_charlen_t name_len) { 585 FIX_STRING(name); 586 if (CeedQFunction_count == CeedQFunction_count_max) { 587 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 588 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 589 } 590 591 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 592 *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_); 593 594 if (*err == 0) { 595 *qf = CeedQFunction_count++; 596 CeedQFunction_n++; 597 } 598 } 599 600 #define fCeedQFunctionCreateIdentity \ 601 FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY) 602 void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, 603 int *outmode, int *qf, int *err) { 604 if (CeedQFunction_count == CeedQFunction_count_max) { 605 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 606 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 607 } 608 609 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 610 *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, *inmode, 611 *outmode, qf_); 612 613 if (*err == 0) { 614 *qf = CeedQFunction_count++; 615 CeedQFunction_n++; 616 } 617 } 618 619 #define fCeedQFunctionAddInput \ 620 FORTRAN_NAME(ceedqfunctionaddinput,CEEDQFUNCTIONADDINPUT) 621 void fCeedQFunctionAddInput(int *qf, const char *fieldname, 622 CeedInt *ncomp, CeedEvalMode *emode, int *err, 623 fortran_charlen_t fieldname_len) { 624 FIX_STRING(fieldname); 625 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 626 627 *err = CeedQFunctionAddInput(qf_, fieldname_c, *ncomp, *emode); 628 } 629 630 #define fCeedQFunctionAddOutput \ 631 FORTRAN_NAME(ceedqfunctionaddoutput,CEEDQFUNCTIONADDOUTPUT) 632 void fCeedQFunctionAddOutput(int *qf, const char *fieldname, 633 CeedInt *ncomp, CeedEvalMode *emode, int *err, 634 fortran_charlen_t fieldname_len) { 635 FIX_STRING(fieldname); 636 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 637 638 *err = CeedQFunctionAddOutput(qf_, fieldname_c, *ncomp, *emode); 639 } 640 641 #define fCeedQFunctionSetContext \ 642 FORTRAN_NAME(ceedqfunctionsetcontext,CEEDQFUNCTIONSETCONTEXT) 643 void fCeedQFunctionSetContext(int *qf, CeedScalar *ctx, CeedInt *n, int *err) { 644 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 645 646 fContext *fctx = qf_->ctx; 647 fctx->innerctx = ctx; 648 fctx->innerctxsize = ((size_t) *n)*sizeof(CeedScalar); 649 } 650 651 #define fCeedQFunctionApply \ 652 FORTRAN_NAME(ceedqfunctionapply,CEEDQFUNCTIONAPPLY) 653 //TODO Need Fixing, double pointer 654 void fCeedQFunctionApply(int *qf, int *Q, 655 int *u, int *u1, int *u2, int *u3, 656 int *u4, int *u5, int *u6, int *u7, 657 int *u8, int *u9, int *u10, int *u11, 658 int *u12, int *u13, int *u14, int *u15, 659 int *v, int *v1, int *v2, int *v3, 660 int *v4, int *v5, int *v6, int *v7, 661 int *v8, int *v9, int *v10, int *v11, 662 int *v12, int *v13, int *v14, int *v15, int *err) { 663 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 664 CeedVector *in; 665 *err = CeedCalloc(16, &in); 666 if (*err) return; 667 in[0] = *u==FORTRAN_NULL?NULL:CeedVector_dict[*u]; 668 in[1] = *u1==FORTRAN_NULL?NULL:CeedVector_dict[*u1]; 669 in[2] = *u2==FORTRAN_NULL?NULL:CeedVector_dict[*u2]; 670 in[3] = *u3==FORTRAN_NULL?NULL:CeedVector_dict[*u3]; 671 in[4] = *u4==FORTRAN_NULL?NULL:CeedVector_dict[*u4]; 672 in[5] = *u5==FORTRAN_NULL?NULL:CeedVector_dict[*u5]; 673 in[6] = *u6==FORTRAN_NULL?NULL:CeedVector_dict[*u6]; 674 in[7] = *u7==FORTRAN_NULL?NULL:CeedVector_dict[*u7]; 675 in[8] = *u8==FORTRAN_NULL?NULL:CeedVector_dict[*u8]; 676 in[9] = *u9==FORTRAN_NULL?NULL:CeedVector_dict[*u9]; 677 in[10] = *u10==FORTRAN_NULL?NULL:CeedVector_dict[*u10]; 678 in[11] = *u11==FORTRAN_NULL?NULL:CeedVector_dict[*u11]; 679 in[12] = *u12==FORTRAN_NULL?NULL:CeedVector_dict[*u12]; 680 in[13] = *u13==FORTRAN_NULL?NULL:CeedVector_dict[*u13]; 681 in[14] = *u14==FORTRAN_NULL?NULL:CeedVector_dict[*u14]; 682 in[15] = *u15==FORTRAN_NULL?NULL:CeedVector_dict[*u15]; 683 CeedVector *out; 684 *err = CeedCalloc(16, &out); 685 if (*err) return; 686 out[0] = *v==FORTRAN_NULL?NULL:CeedVector_dict[*v]; 687 out[1] = *v1==FORTRAN_NULL?NULL:CeedVector_dict[*v1]; 688 out[2] = *v2==FORTRAN_NULL?NULL:CeedVector_dict[*v2]; 689 out[3] = *v3==FORTRAN_NULL?NULL:CeedVector_dict[*v3]; 690 out[4] = *v4==FORTRAN_NULL?NULL:CeedVector_dict[*v4]; 691 out[5] = *v5==FORTRAN_NULL?NULL:CeedVector_dict[*v5]; 692 out[6] = *v6==FORTRAN_NULL?NULL:CeedVector_dict[*v6]; 693 out[7] = *v7==FORTRAN_NULL?NULL:CeedVector_dict[*v7]; 694 out[8] = *v8==FORTRAN_NULL?NULL:CeedVector_dict[*v8]; 695 out[9] = *v9==FORTRAN_NULL?NULL:CeedVector_dict[*v9]; 696 out[10] = *v10==FORTRAN_NULL?NULL:CeedVector_dict[*v10]; 697 out[11] = *v11==FORTRAN_NULL?NULL:CeedVector_dict[*v11]; 698 out[12] = *v12==FORTRAN_NULL?NULL:CeedVector_dict[*v12]; 699 out[13] = *v13==FORTRAN_NULL?NULL:CeedVector_dict[*v13]; 700 out[14] = *v14==FORTRAN_NULL?NULL:CeedVector_dict[*v14]; 701 out[15] = *v15==FORTRAN_NULL?NULL:CeedVector_dict[*v15]; 702 *err = CeedQFunctionApply(qf_, *Q, in, out); 703 if (*err) return; 704 705 *err = CeedFree(&in); 706 if (*err) return; 707 *err = CeedFree(&out); 708 } 709 710 #define fCeedQFunctionDestroy \ 711 FORTRAN_NAME(ceedqfunctiondestroy,CEEDQFUNCTIONDESTROY) 712 void fCeedQFunctionDestroy(int *qf, int *err) { 713 bool fstatus; 714 *err = CeedQFunctionGetFortranStatus(CeedQFunction_dict[*qf], &fstatus); 715 if (*err) return; 716 if (fstatus) { 717 fContext *fctx = CeedQFunction_dict[*qf]->ctx; 718 *err = CeedFree(&fctx); 719 if (*err) return; 720 } 721 722 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); 723 if (*err) return; 724 725 CeedQFunction_n--; 726 if (CeedQFunction_n == 0) { 727 *err = CeedFree(&CeedQFunction_dict); 728 CeedQFunction_count = 0; 729 CeedQFunction_count_max = 0; 730 } 731 } 732 733 static CeedOperator *CeedOperator_dict = NULL; 734 static int CeedOperator_count = 0; 735 static int CeedOperator_n = 0; 736 static int CeedOperator_count_max = 0; 737 738 #define fCeedOperatorCreate \ 739 FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) 740 void fCeedOperatorCreate(int *ceed, 741 int *qf, int *dqf, int *dqfT, int *op, int *err) { 742 if (CeedOperator_count == CeedOperator_count_max) 743 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 744 CeedOperator_dict = realloc(CeedOperator_dict, 745 sizeof(CeedOperator)*CeedOperator_count_max); 746 747 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 748 749 CeedQFunction dqf_ = NULL, dqfT_ = NULL; 750 if (*dqf != FORTRAN_NULL) dqf_ = CeedQFunction_dict[*dqf ]; 751 if (*dqfT != FORTRAN_NULL) dqfT_ = CeedQFunction_dict[*dqfT]; 752 753 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, 754 dqfT_, op_); 755 if (*err) return; 756 *op = CeedOperator_count++; 757 CeedOperator_n++; 758 } 759 760 #define fCeedCompositeOperatorCreate \ 761 FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) 762 void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { 763 if (CeedOperator_count == CeedOperator_count_max) 764 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 765 CeedOperator_dict = realloc(CeedOperator_dict, 766 sizeof(CeedOperator)*CeedOperator_count_max); 767 768 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 769 770 *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); 771 if (*err) return; 772 *op = CeedOperator_count++; 773 CeedOperator_n++; 774 } 775 776 #define fCeedOperatorSetField \ 777 FORTRAN_NAME(ceedoperatorsetfield,CEEDOPERATORSETFIELD) 778 void fCeedOperatorSetField(int *op, const char *fieldname, 779 int *r, int *lmode, int *b, int *v, int *err, 780 fortran_charlen_t fieldname_len) { 781 FIX_STRING(fieldname); 782 CeedElemRestriction r_; 783 CeedBasis b_; 784 CeedVector v_; 785 786 CeedOperator op_ = CeedOperator_dict[*op]; 787 788 if (*r == FORTRAN_NULL) { 789 r_ = NULL; 790 } else { 791 r_ = CeedElemRestriction_dict[*r]; 792 } 793 794 if (*b == FORTRAN_NULL) { 795 b_ = NULL; 796 } else if (*b == FORTRAN_BASIS_COLLOCATED) { 797 b_ = CEED_BASIS_COLLOCATED; 798 } else { 799 b_ = CeedBasis_dict[*b]; 800 } 801 if (*v == FORTRAN_NULL) { 802 v_ = NULL; 803 } else if (*v == FORTRAN_VECTOR_ACTIVE) { 804 v_ = CEED_VECTOR_ACTIVE; 805 } else if (*v == FORTRAN_VECTOR_NONE) { 806 v_ = CEED_VECTOR_NONE; 807 } else { 808 v_ = CeedVector_dict[*v]; 809 } 810 811 *err = CeedOperatorSetField(op_, fieldname_c, r_, *lmode, b_, v_); 812 } 813 814 #define fCeedCompositeOperatorAddSub \ 815 FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) 816 void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { 817 CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; 818 CeedOperator subop_ = CeedOperator_dict[*subop]; 819 820 *err = CeedCompositeOperatorAddSub(compositeop_, subop_); 821 if (*err) return; 822 } 823 824 #define fCeedOperatorAssembleLinearQFunction FORTRAN_NAME(ceedoperatorassemblelinearqfunction, CEEDOPERATORASSEMBLELINEARQFUNCTION) 825 void fCeedOperatorAssembleLinearQFunction(int *op, int *assembledvec, 826 int *assembledrstr, int *rqst, int *err) { 827 // Vector 828 if (CeedVector_count == CeedVector_count_max) { 829 CeedVector_count_max += CeedVector_count_max/2 + 1; 830 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 831 } 832 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 833 834 // Restriction 835 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 836 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 837 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 838 } 839 CeedElemRestriction *rstr_ = 840 &CeedElemRestriction_dict[CeedElemRestriction_count]; 841 842 int createRequest = 1; 843 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 844 if (*rqst == -1 || *rqst == -2) { 845 createRequest = 0; 846 } 847 848 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 849 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 850 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 851 } 852 853 CeedRequest *rqst_; 854 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 855 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 856 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 857 858 *err = CeedOperatorAssembleLinearQFunction(CeedOperator_dict[*op], 859 assembledvec_, rstr_, rqst_); 860 if (*err) return; 861 if (createRequest) { 862 *rqst = CeedRequest_count++; 863 CeedRequest_n++; 864 } 865 866 if (*err == 0) { 867 *assembledrstr = CeedElemRestriction_count++; 868 CeedElemRestriction_n++; 869 *assembledvec = CeedVector_count++; 870 CeedVector_n++; 871 } 872 } 873 874 #define fCeedOperatorAssembleLinearDiagonal FORTRAN_NAME(ceedoperatorassemblelineardiagonal, CEEDOPERATORASSEMBLELINEARDIAGONAL) 875 void fCeedOperatorAssembleLinearDiagonal(int *op, int *assembledvec, 876 int *rqst, int *err) { 877 // Vector 878 if (CeedVector_count == CeedVector_count_max) { 879 CeedVector_count_max += CeedVector_count_max/2 + 1; 880 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 881 } 882 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 883 884 int createRequest = 1; 885 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 886 if (*rqst == -1 || *rqst == -2) { 887 createRequest = 0; 888 } 889 890 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 891 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 892 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 893 } 894 895 CeedRequest *rqst_; 896 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 897 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 898 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 899 900 *err = CeedOperatorAssembleLinearDiagonal(CeedOperator_dict[*op], 901 assembledvec_, rqst_); 902 if (*err) return; 903 if (createRequest) { 904 *rqst = CeedRequest_count++; 905 CeedRequest_n++; 906 } 907 908 if (*err == 0) { 909 *assembledvec = CeedVector_count++; 910 CeedVector_n++; 911 } 912 } 913 914 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) 915 void fCeedOperatorApply(int *op, int *ustatevec, 916 int *resvec, int *rqst, int *err) { 917 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL 918 ? NULL : CeedVector_dict[*ustatevec]; 919 CeedVector resvec_ = *resvec == FORTRAN_NULL 920 ? NULL : CeedVector_dict[*resvec]; 921 922 int createRequest = 1; 923 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 924 if (*rqst == -1 || *rqst == -2) { 925 createRequest = 0; 926 } 927 928 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 929 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 930 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 931 } 932 933 CeedRequest *rqst_; 934 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 935 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 936 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 937 938 *err = CeedOperatorApply(CeedOperator_dict[*op], 939 ustatevec_, resvec_, rqst_); 940 if (*err) return; 941 if (createRequest) { 942 *rqst = CeedRequest_count++; 943 CeedRequest_n++; 944 } 945 } 946 947 #define fCeedOperatorApplyJacobian \ 948 FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) 949 void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, 950 int *dustatevec, int *dresvec, int *rqst, 951 int *err) { 952 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented 953 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], 954 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], 955 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); 956 } 957 958 #define fCeedOperatorDestroy \ 959 FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) 960 void fCeedOperatorDestroy(int *op, int *err) { 961 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); 962 if (*err) return; 963 CeedOperator_n--; 964 if (CeedOperator_n == 0) { 965 *err = CeedFree(&CeedOperator_dict); 966 CeedOperator_count = 0; 967 CeedOperator_count_max = 0; 968 } 969 } 970