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, int *err) { 111 *err = CeedVectorSetArray(CeedVector_dict[*vec], *memtype, *copymode, array); 112 } 113 114 #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray,CEEDVECTORSYNCARRAY) 115 void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { 116 *err = CeedVectorSyncArray(CeedVector_dict[*vec], *memtype); 117 } 118 119 #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue,CEEDVECTORSETVALUE) 120 void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { 121 *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); 122 } 123 124 #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray,CEEDVECTORGETARRAY) 125 void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, 126 int64_t *offset, 127 int *err) { 128 CeedScalar *b; 129 CeedVector vec_ = CeedVector_dict[*vec]; 130 *err = CeedVectorGetArray(vec_, *memtype, &b); 131 *offset = b - array; 132 } 133 134 #define fCeedVectorGetArrayRead \ 135 FORTRAN_NAME(ceedvectorgetarrayread,CEEDVECTORGETARRAYREAD) 136 void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, 137 int64_t *offset, int *err) { 138 const CeedScalar *b; 139 CeedVector vec_ = CeedVector_dict[*vec]; 140 *err = CeedVectorGetArrayRead(vec_, *memtype, &b); 141 *offset = b - array; 142 } 143 144 #define fCeedVectorRestoreArray \ 145 FORTRAN_NAME(ceedvectorrestorearray,CEEDVECTORRESTOREARRAY) 146 void fCeedVectorRestoreArray(int *vec, CeedScalar *array, 147 int64_t *offset, int *err) { 148 *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &array); 149 *offset = 0; 150 } 151 152 #define fCeedVectorRestoreArrayRead \ 153 FORTRAN_NAME(ceedvectorrestorearrayread,CEEDVECTORRESTOREARRAYREAD) 154 void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, 155 int64_t *offset, int *err) { 156 *err = CeedVectorRestoreArrayRead(CeedVector_dict[*vec], &array); 157 *offset = 0; 158 } 159 160 #define fCeedVectorView FORTRAN_NAME(ceedvectorview,CEEDVECTORVIEW) 161 void fCeedVectorView(int *vec, int *err) { 162 *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); 163 } 164 165 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy,CEEDVECTORDESTROY) 166 void fCeedVectorDestroy(int *vec, int *err) { 167 *err = CeedVectorDestroy(&CeedVector_dict[*vec]); 168 169 if (*err == 0) { 170 CeedVector_n--; 171 if (CeedVector_n == 0) { 172 CeedFree(&CeedVector_dict); 173 CeedVector_count = 0; 174 CeedVector_count_max = 0; 175 } 176 } 177 } 178 179 static CeedElemRestriction *CeedElemRestriction_dict = NULL; 180 static int CeedElemRestriction_count = 0; 181 static int CeedElemRestriction_n = 0; 182 static int CeedElemRestriction_count_max = 0; 183 184 #define fCeedElemRestrictionCreate \ 185 FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) 186 void fCeedElemRestrictionCreate(int *ceed, int *nelements, 187 int *esize, int *ndof, int *ncomp, int *memtype, int *copymode, 188 const int *indices, int *elemrestriction, int *err) { 189 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 190 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 191 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 192 } 193 194 const int *indices_ = indices; 195 196 CeedElemRestriction *elemrestriction_ = 197 &CeedElemRestriction_dict[CeedElemRestriction_count]; 198 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, *ndof, 199 *ncomp, 200 *memtype, *copymode, indices_, elemrestriction_); 201 202 if (*err == 0) { 203 *elemrestriction = CeedElemRestriction_count++; 204 CeedElemRestriction_n++; 205 } 206 } 207 208 #define fCeedElemRestrictionCreateIdentity \ 209 FORTRAN_NAME(ceedelemrestrictioncreateidentity, CEEDELEMRESTRICTIONCREATEIDENTITY) 210 void fCeedElemRestrictionCreateIdentity(int *ceed, int *nelements, 211 int *esize, int *ndof, int *ncomp, 212 int *elemrestriction, int *err) { 213 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 214 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 215 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 216 } 217 218 CeedElemRestriction *elemrestriction_ = 219 &CeedElemRestriction_dict[CeedElemRestriction_count]; 220 *err = CeedElemRestrictionCreateIdentity(Ceed_dict[*ceed], *nelements, *esize, 221 *ndof, 222 *ncomp, elemrestriction_); 223 224 if (*err == 0) { 225 *elemrestriction = CeedElemRestriction_count++; 226 CeedElemRestriction_n++; 227 } 228 } 229 230 #define fCeedElemRestrictionCreateBlocked \ 231 FORTRAN_NAME(ceedelemrestrictioncreateblocked,CEEDELEMRESTRICTIONCREATEBLOCKED) 232 void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, 233 int *esize, int *blocksize, int *ndof, int *ncomp, 234 int *mtype, int *cmode, 235 int *blkindices, int *elemrestriction, int *err) { 236 237 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 238 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 239 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 240 } 241 242 CeedElemRestriction *elemrestriction_ = 243 &CeedElemRestriction_dict[CeedElemRestriction_count]; 244 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], *nelements, *esize, 245 *blocksize, *ndof, *ncomp, *mtype, *cmode, blkindices, 246 elemrestriction_); 247 248 if (*err == 0) { 249 *elemrestriction = CeedElemRestriction_count++; 250 CeedElemRestriction_n++; 251 } 252 } 253 254 static CeedRequest *CeedRequest_dict = NULL; 255 static int CeedRequest_count = 0; 256 static int CeedRequest_n = 0; 257 static int CeedRequest_count_max = 0; 258 259 #define fCeedElemRestrictionApply \ 260 FORTRAN_NAME(ceedelemrestrictionapply,CEEDELEMRESTRICTIONAPPLY) 261 void fCeedElemRestrictionApply(int *elemr, int *tmode, int *lmode, 262 int *uvec, int *ruvec, int *rqst, int *err) { 263 int createRequest = 1; 264 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 265 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 266 createRequest = 0; 267 268 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 269 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 270 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 271 } 272 273 CeedRequest *rqst_; 274 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 275 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 276 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 277 278 *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], *tmode, 279 *lmode, CeedVector_dict[*uvec], CeedVector_dict[*ruvec], rqst_); 280 281 if (*err == 0 && createRequest) { 282 *rqst = CeedRequest_count++; 283 CeedRequest_n++; 284 } 285 } 286 287 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 288 void fCeedRequestWait(int *rqst, int *err) { 289 // TODO Uncomment this once CeedRequestWait is implemented 290 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); 291 292 if (*err == 0) { 293 CeedRequest_n--; 294 if (CeedRequest_n == 0) { 295 CeedFree(&CeedRequest_dict); 296 CeedRequest_count = 0; 297 CeedRequest_count_max = 0; 298 } 299 } 300 } 301 302 #define fCeedElemRestrictionDestroy \ 303 FORTRAN_NAME(ceedelemrestrictiondestroy,CEEDELEMRESTRICTIONDESTROY) 304 void fCeedElemRestrictionDestroy(int *elem, int *err) { 305 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); 306 307 if (*err == 0) { 308 CeedElemRestriction_n--; 309 if (CeedElemRestriction_n == 0) { 310 CeedFree(&CeedElemRestriction_dict); 311 CeedElemRestriction_count = 0; 312 CeedElemRestriction_count_max = 0; 313 } 314 } 315 } 316 317 static CeedBasis *CeedBasis_dict = NULL; 318 static int CeedBasis_count = 0; 319 static int CeedBasis_n = 0; 320 static int CeedBasis_count_max = 0; 321 322 #define fCeedBasisCreateTensorH1Lagrange \ 323 FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) 324 void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, 325 int *ncomp, int *P, int *Q, int *quadmode, int *basis, 326 int *err) { 327 if (CeedBasis_count == CeedBasis_count_max) { 328 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 329 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 330 } 331 332 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *ncomp, *P, *Q, 333 *quadmode, &CeedBasis_dict[CeedBasis_count]); 334 335 if (*err == 0) { 336 *basis = CeedBasis_count++; 337 CeedBasis_n++; 338 } 339 } 340 341 #define fCeedBasisCreateTensorH1 \ 342 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) 343 void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *ncomp, int *P1d, 344 int *Q1d, const CeedScalar *interp1d, const CeedScalar *grad1d, 345 const CeedScalar *qref1d, const CeedScalar *qweight1d, int *basis, int *err) { 346 if (CeedBasis_count == CeedBasis_count_max) { 347 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 348 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 349 } 350 351 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *ncomp, *P1d, *Q1d, 352 interp1d, grad1d, 353 qref1d, qweight1d, &CeedBasis_dict[CeedBasis_count]); 354 355 if (*err == 0) { 356 *basis = CeedBasis_count++; 357 CeedBasis_n++; 358 } 359 } 360 361 #define fCeedBasisCreateH1 \ 362 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) 363 void fCeedBasisCreateH1(int *ceed, int *topo, int *ncomp, int *ndof, 364 int *nqpts, const CeedScalar *interp, const CeedScalar *grad, 365 const CeedScalar *qref, const CeedScalar *qweight, int *basis, int *err) { 366 if (CeedBasis_count == CeedBasis_count_max) { 367 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 368 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 369 } 370 371 *err = CeedBasisCreateH1(Ceed_dict[*ceed], *topo, *ncomp, 372 *ndof, *nqpts, interp, grad, 373 qref, qweight, &CeedBasis_dict[CeedBasis_count]); 374 375 if (*err == 0) { 376 *basis = CeedBasis_count++; 377 CeedBasis_n++; 378 } 379 } 380 381 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW) 382 void fCeedBasisView(int *basis, int *err) { 383 *err = CeedBasisView(CeedBasis_dict[*basis], stdout); 384 } 385 386 #define fCeedQRFactorization \ 387 FORTRAN_NAME(ceedqrfactorization, CEEDQRFACTORIZATION) 388 void fCeedQRFactorization(CeedScalar *mat, CeedScalar *tau, int *m, int *n, 389 int *err) { 390 *err = CeedQRFactorization(mat, tau, *m, *n); 391 } 392 393 #define fCeedBasisGetCollocatedGrad \ 394 FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 395 void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colograd1d, 396 int *err) { 397 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colograd1d); 398 } 399 400 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) 401 void fCeedBasisApply(int *basis, int *nelem, int *tmode, int *emode, 402 int *u, int *v, int *err) { 403 *err = CeedBasisApply(CeedBasis_dict[*basis], *nelem, *tmode, *emode, 404 *u==FORTRAN_NULL?NULL:CeedVector_dict[*u], 405 CeedVector_dict[*v]); 406 } 407 408 #define fCeedBasisGetNumNodes \ 409 FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) 410 void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { 411 *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); 412 } 413 414 #define fCeedBasisGetNumQuadraturePoints \ 415 FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) 416 void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { 417 *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); 418 } 419 420 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY) 421 void fCeedBasisDestroy(int *basis, int *err) { 422 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]); 423 424 if (*err == 0) { 425 CeedBasis_n--; 426 if (CeedBasis_n == 0) { 427 CeedFree(&CeedBasis_dict); 428 CeedBasis_count = 0; 429 CeedBasis_count_max = 0; 430 } 431 } 432 } 433 434 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE) 435 void fCeedGaussQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 436 int *err) { 437 *err = CeedGaussQuadrature(*Q, qref1d, qweight1d); 438 } 439 440 #define fCeedLobattoQuadrature \ 441 FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE) 442 void fCeedLobattoQuadrature(int *Q, CeedScalar *qref1d, CeedScalar *qweight1d, 443 int *err) { 444 *err = CeedLobattoQuadrature(*Q, qref1d, qweight1d); 445 } 446 447 static CeedQFunction *CeedQFunction_dict = NULL; 448 static int CeedQFunction_count = 0; 449 static int CeedQFunction_n = 0; 450 static int CeedQFunction_count_max = 0; 451 452 static int CeedQFunctionFortranStub(void *ctx, int nq, 453 const CeedScalar *const *u, CeedScalar *const *v) { 454 fContext *fctx = ctx; 455 int ierr; 456 457 CeedScalar *ctx_ = (CeedScalar *) fctx->innerctx; 458 fctx->f((void *)ctx_,&nq,u[0],u[1],u[2],u[3],u[4],u[5],u[6], 459 u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15], 460 v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9], 461 v[10],v[11],v[12],v[13],v[14],v[15],&ierr); 462 return ierr; 463 } 464 465 #define fCeedQFunctionCreateInterior \ 466 FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) 467 void fCeedQFunctionCreateInterior(int *ceed, int *vlength, 468 void (*f)(void *ctx, int *nq, 469 const CeedScalar *u,const CeedScalar *u1, 470 const CeedScalar *u2,const CeedScalar *u3, 471 const CeedScalar *u4,const CeedScalar *u5, 472 const CeedScalar *u6,const CeedScalar *u7, 473 const CeedScalar *u8,const CeedScalar *u9, 474 const CeedScalar *u10,const CeedScalar *u11, 475 const CeedScalar *u12,const CeedScalar *u13, 476 const CeedScalar *u14,const CeedScalar *u15, 477 CeedScalar *v,CeedScalar *v1,CeedScalar *v2, 478 CeedScalar *v3,CeedScalar *v4,CeedScalar *v5, 479 CeedScalar *v6,CeedScalar *v7,CeedScalar *v8, 480 CeedScalar *v9,CeedScalar *v10,CeedScalar *v11, 481 CeedScalar *v12,CeedScalar *v13,CeedScalar *v14, 482 CeedScalar *v15,int *err), 483 const char *focca, int *qf, int *err, 484 fortran_charlen_t focca_len) { 485 FIX_STRING(focca); 486 if (CeedQFunction_count == CeedQFunction_count_max) { 487 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 488 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 489 } 490 491 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 492 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vlength, 493 CeedQFunctionFortranStub, focca_c, qf_); 494 495 if (*err == 0) { 496 *qf = CeedQFunction_count++; 497 CeedQFunction_n++; 498 499 } 500 501 fContext *fctx; 502 *err = CeedMalloc(1, &fctx); 503 if (*err) return; 504 fctx->f = f; fctx->innerctx = NULL; fctx->innerctxsize = 0; 505 506 *err = CeedQFunctionSetContext(*qf_, fctx, sizeof(fContext)); 507 508 (*qf_)->fortranstatus = true; 509 } 510 511 #define fCeedQFunctionAddInput \ 512 FORTRAN_NAME(ceedqfunctionaddinput,CEEDQFUNCTIONADDINPUT) 513 void fCeedQFunctionAddInput(int *qf, const char *fieldname, 514 CeedInt *ncomp, CeedEvalMode *emode, int *err, 515 fortran_charlen_t fieldname_len) { 516 FIX_STRING(fieldname); 517 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 518 519 *err = CeedQFunctionAddInput(qf_, fieldname_c, *ncomp, *emode); 520 } 521 522 #define fCeedQFunctionAddOutput \ 523 FORTRAN_NAME(ceedqfunctionaddoutput,CEEDQFUNCTIONADDOUTPUT) 524 void fCeedQFunctionAddOutput(int *qf, const char *fieldname, 525 CeedInt *ncomp, CeedEvalMode *emode, int *err, 526 fortran_charlen_t fieldname_len) { 527 FIX_STRING(fieldname); 528 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 529 530 *err = CeedQFunctionAddOutput(qf_, fieldname_c, *ncomp, *emode); 531 } 532 533 #define fCeedQFunctionSetContext \ 534 FORTRAN_NAME(ceedqfunctionsetcontext,CEEDQFUNCTIONSETCONTEXT) 535 void fCeedQFunctionSetContext(int *qf, CeedScalar *ctx, CeedInt *n, int *err) { 536 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 537 538 fContext *fctx = qf_->ctx; 539 fctx->innerctx = ctx; 540 fctx->innerctxsize = ((size_t) *n)*sizeof(CeedScalar); 541 } 542 543 #define fCeedQFunctionApply \ 544 FORTRAN_NAME(ceedqfunctionapply,CEEDQFUNCTIONAPPLY) 545 //TODO Need Fixing, double pointer 546 void fCeedQFunctionApply(int *qf, int *Q, 547 int *u, int *u1, int *u2, int *u3, 548 int *u4, int *u5, int *u6, int *u7, 549 int *u8, int *u9, int *u10, int *u11, 550 int *u12, int *u13, int *u14, int *u15, 551 int *v, int *v1, int *v2, int *v3, 552 int *v4, int *v5, int *v6, int *v7, 553 int *v8, int *v9, int *v10, int *v11, 554 int *v12, int *v13, int *v14, int *v15, int *err) { 555 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 556 CeedVector *in; 557 *err = CeedCalloc(16, &in); 558 if (*err) return; 559 in[0] = *u==FORTRAN_NULL?NULL:CeedVector_dict[*u]; 560 in[1] = *u1==FORTRAN_NULL?NULL:CeedVector_dict[*u1]; 561 in[2] = *u2==FORTRAN_NULL?NULL:CeedVector_dict[*u2]; 562 in[3] = *u3==FORTRAN_NULL?NULL:CeedVector_dict[*u3]; 563 in[4] = *u4==FORTRAN_NULL?NULL:CeedVector_dict[*u4]; 564 in[5] = *u5==FORTRAN_NULL?NULL:CeedVector_dict[*u5]; 565 in[6] = *u6==FORTRAN_NULL?NULL:CeedVector_dict[*u6]; 566 in[7] = *u7==FORTRAN_NULL?NULL:CeedVector_dict[*u7]; 567 in[8] = *u8==FORTRAN_NULL?NULL:CeedVector_dict[*u8]; 568 in[9] = *u9==FORTRAN_NULL?NULL:CeedVector_dict[*u9]; 569 in[10] = *u10==FORTRAN_NULL?NULL:CeedVector_dict[*u10]; 570 in[11] = *u11==FORTRAN_NULL?NULL:CeedVector_dict[*u11]; 571 in[12] = *u12==FORTRAN_NULL?NULL:CeedVector_dict[*u12]; 572 in[13] = *u13==FORTRAN_NULL?NULL:CeedVector_dict[*u13]; 573 in[14] = *u14==FORTRAN_NULL?NULL:CeedVector_dict[*u14]; 574 in[15] = *u15==FORTRAN_NULL?NULL:CeedVector_dict[*u15]; 575 CeedVector *out; 576 *err = CeedCalloc(16, &out); 577 if (*err) return; 578 out[0] = *v==FORTRAN_NULL?NULL:CeedVector_dict[*v]; 579 out[1] = *v1==FORTRAN_NULL?NULL:CeedVector_dict[*v1]; 580 out[2] = *v2==FORTRAN_NULL?NULL:CeedVector_dict[*v2]; 581 out[3] = *v3==FORTRAN_NULL?NULL:CeedVector_dict[*v3]; 582 out[4] = *v4==FORTRAN_NULL?NULL:CeedVector_dict[*v4]; 583 out[5] = *v5==FORTRAN_NULL?NULL:CeedVector_dict[*v5]; 584 out[6] = *v6==FORTRAN_NULL?NULL:CeedVector_dict[*v6]; 585 out[7] = *v7==FORTRAN_NULL?NULL:CeedVector_dict[*v7]; 586 out[8] = *v8==FORTRAN_NULL?NULL:CeedVector_dict[*v8]; 587 out[9] = *v9==FORTRAN_NULL?NULL:CeedVector_dict[*v9]; 588 out[10] = *v10==FORTRAN_NULL?NULL:CeedVector_dict[*v10]; 589 out[11] = *v11==FORTRAN_NULL?NULL:CeedVector_dict[*v11]; 590 out[12] = *v12==FORTRAN_NULL?NULL:CeedVector_dict[*v12]; 591 out[13] = *v13==FORTRAN_NULL?NULL:CeedVector_dict[*v13]; 592 out[14] = *v14==FORTRAN_NULL?NULL:CeedVector_dict[*v14]; 593 out[15] = *v15==FORTRAN_NULL?NULL:CeedVector_dict[*v15]; 594 *err = CeedQFunctionApply(qf_, *Q, in, out); 595 if (*err) return; 596 597 *err = CeedFree(&in); 598 if (*err) return; 599 *err = CeedFree(&out); 600 } 601 602 #define fCeedQFunctionDestroy \ 603 FORTRAN_NAME(ceedqfunctiondestroy,CEEDQFUNCTIONDESTROY) 604 void fCeedQFunctionDestroy(int *qf, int *err) { 605 fContext *fctx = CeedQFunction_dict[*qf]->ctx; 606 *err = CeedFree(&fctx); 607 if (*err) return; 608 609 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); 610 if (*err) return; 611 612 CeedQFunction_n--; 613 if (CeedQFunction_n == 0) { 614 *err = CeedFree(&CeedQFunction_dict); 615 CeedQFunction_count = 0; 616 CeedQFunction_count_max = 0; 617 } 618 } 619 620 static CeedOperator *CeedOperator_dict = NULL; 621 static int CeedOperator_count = 0; 622 static int CeedOperator_n = 0; 623 static int CeedOperator_count_max = 0; 624 625 #define fCeedOperatorCreate \ 626 FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) 627 void fCeedOperatorCreate(int *ceed, 628 int *qf, int *dqf, int *dqfT, int *op, int *err) { 629 if (CeedOperator_count == CeedOperator_count_max) 630 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 631 CeedOperator_dict = 632 realloc(CeedOperator_dict, sizeof(CeedOperator)*CeedOperator_count_max); 633 634 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 635 636 CeedQFunction dqf_ = NULL, dqfT_ = NULL; 637 if (*dqf != FORTRAN_NULL) dqf_ = CeedQFunction_dict[*dqf ]; 638 if (*dqfT != FORTRAN_NULL) dqfT_ = CeedQFunction_dict[*dqfT]; 639 640 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, 641 dqfT_, op_); 642 if (*err) return; 643 *op = CeedOperator_count++; 644 CeedOperator_n++; 645 } 646 647 #define fCeedCompositeOperatorCreate \ 648 FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) 649 void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { 650 if (CeedOperator_count == CeedOperator_count_max) 651 CeedOperator_count_max += CeedOperator_count_max/2 + 1, 652 CeedOperator_dict = 653 realloc(CeedOperator_dict, sizeof(CeedOperator)*CeedOperator_count_max); 654 655 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 656 657 *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); 658 if (*err) return; 659 *op = CeedOperator_count++; 660 CeedOperator_n++; 661 } 662 663 #define fCeedOperatorSetField \ 664 FORTRAN_NAME(ceedoperatorsetfield,CEEDOPERATORSETFIELD) 665 void fCeedOperatorSetField(int *op, const char *fieldname, 666 int *r, int *lmode, int *b, int *v, int *err, 667 fortran_charlen_t fieldname_len) { 668 FIX_STRING(fieldname); 669 CeedElemRestriction r_; 670 CeedBasis b_; 671 CeedVector v_; 672 673 CeedOperator op_ = CeedOperator_dict[*op]; 674 675 if (*r == FORTRAN_NULL) { 676 r_ = NULL; 677 } else { 678 r_ = CeedElemRestriction_dict[*r]; 679 } 680 681 if (*b == FORTRAN_NULL) { 682 b_ = NULL; 683 } else if (*b == FORTRAN_BASIS_COLLOCATED) { 684 b_ = CEED_BASIS_COLLOCATED; 685 } else { 686 b_ = CeedBasis_dict[*b]; 687 } 688 if (*v == FORTRAN_NULL) { 689 v_ = NULL; 690 } else if (*v == FORTRAN_VECTOR_ACTIVE) { 691 v_ = CEED_VECTOR_ACTIVE; 692 } else if (*v == FORTRAN_VECTOR_NONE) { 693 v_ = CEED_VECTOR_NONE; 694 } else { 695 v_ = CeedVector_dict[*v]; 696 } 697 698 *err = CeedOperatorSetField(op_, fieldname_c, r_, *lmode, b_, v_); 699 } 700 701 #define fCeedCompositeOperatorAddSub \ 702 FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) 703 void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { 704 CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; 705 CeedOperator subop_ = CeedOperator_dict[*subop]; 706 707 *err = CeedCompositeOperatorAddSub(compositeop_, subop_); 708 if (*err) return; 709 } 710 711 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) 712 void fCeedOperatorApply(int *op, int *ustatevec, 713 int *resvec, int *rqst, int *err) { 714 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL 715 ? NULL : CeedVector_dict[*ustatevec]; 716 CeedVector resvec_ = *resvec == FORTRAN_NULL 717 ? NULL : CeedVector_dict[*resvec]; 718 719 int createRequest = 1; 720 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 721 if (*rqst == -1 || *rqst == -2) { 722 createRequest = 0; 723 } 724 725 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 726 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 727 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 728 } 729 730 CeedRequest *rqst_; 731 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 732 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 733 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 734 735 *err = CeedOperatorApply(CeedOperator_dict[*op], 736 ustatevec_, resvec_, rqst_); 737 if (*err) return; 738 if (createRequest) { 739 *rqst = CeedRequest_count++; 740 CeedRequest_n++; 741 } 742 } 743 744 #define fCeedOperatorApplyJacobian \ 745 FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) 746 void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, 747 int *dustatevec, int *dresvec, int *rqst, int *err) { 748 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented 749 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], 750 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], 751 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); 752 } 753 754 #define fCeedOperatorDestroy \ 755 FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) 756 void fCeedOperatorDestroy(int *op, int *err) { 757 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); 758 if (*err) return; 759 CeedOperator_n--; 760 if (CeedOperator_n == 0) { 761 *err = CeedFree(&CeedOperator_dict); 762 CeedOperator_count = 0; 763 CeedOperator_count_max = 0; 764 } 765 } 766