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