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/ceed.h> 19 #include <ceed/backend.h> 20 #include <ceed-impl.h> 21 #include <ceed-fortran-name.h> 22 #include <stdbool.h> 23 #include <stdint.h> 24 #include <stdio.h> 25 #include <string.h> 26 27 #define FORTRAN_REQUEST_IMMEDIATE -1 28 #define FORTRAN_REQUEST_ORDERED -2 29 #define FORTRAN_NULL -3 30 #define FORTRAN_STRIDES_BACKEND -4 31 #define FORTRAN_VECTOR_ACTIVE -5 32 #define FORTRAN_VECTOR_NONE -6 33 #define FORTRAN_ELEMRESTRICTION_NONE -7 34 #define FORTRAN_BASIS_COLLOCATED -8 35 #define FORTRAN_QFUNCTION_NONE -9 36 37 static Ceed *Ceed_dict = NULL; 38 static int Ceed_count = 0; 39 static int Ceed_n = 0; 40 static int Ceed_count_max = 0; 41 42 // This test should actually be for the gfortran version, but we don't currently 43 // have a configure system to determine that (TODO). At present, this will use 44 // the smaller integer when run with clang+gfortran=8, for example. (That is 45 // sketchy, but will likely work for users that don't have huge character 46 // strings.) 47 #if __GNUC__ >= 8 48 typedef size_t fortran_charlen_t; 49 #else 50 typedef int fortran_charlen_t; 51 #endif 52 53 #define Splice(a, b) a ## b 54 55 // Fortran strings are generally unterminated and the length is passed as an 56 // extra argument after all the normal arguments. Some compilers (I only know 57 // of Windows) place the length argument immediately after the string parameter 58 // (TODO). 59 // 60 // We can't just NULL-terminate the string in-place because that could overwrite 61 // other strings or attempt to write to read-only memory. This macro allocates 62 // a string to hold the null-terminated version of the string that C expects. 63 #define FIX_STRING(stringname) \ 64 char Splice(stringname, _c)[1024]; \ 65 if (Splice(stringname, _len) > 1023) \ 66 *err = CeedError(NULL, 1, "Fortran string length too long %zd", (size_t)Splice(stringname, _len)); \ 67 strncpy(Splice(stringname, _c), stringname, Splice(stringname, _len)); \ 68 Splice(stringname, _c)[Splice(stringname, _len)] = 0; \ 69 70 // ----------------------------------------------------------------------------- 71 // Ceed 72 // ----------------------------------------------------------------------------- 73 #define fCeedInit FORTRAN_NAME(ceedinit,CEEDINIT) 74 void fCeedInit(const char *resource, int *ceed, int *err, 75 fortran_charlen_t resource_len) { 76 FIX_STRING(resource); 77 if (Ceed_count == Ceed_count_max) { 78 Ceed_count_max += Ceed_count_max/2 + 1; 79 CeedRealloc(Ceed_count_max, &Ceed_dict); 80 } 81 82 Ceed *ceed_ = &Ceed_dict[Ceed_count]; 83 *err = CeedInit(resource_c, ceed_); 84 85 if (*err == 0) { 86 *ceed = Ceed_count++; 87 Ceed_n++; 88 } 89 } 90 91 #define fCeedIsDeterministic \ 92 FORTRAN_NAME(ceedisdeterministic,CEEDISDETERMINISTIC) 93 void fCeedIsDeterministic(int *ceed, int *is_deterministic, int *err) { 94 *err = CeedIsDeterministic(Ceed_dict[*ceed], (bool *)is_deterministic); 95 } 96 97 #define fCeedGetPreferredMemType \ 98 FORTRAN_NAME(ceedgetpreferredmemtype,CEEDGETPREFERREDMEMTYPE) 99 void fCeedGetPreferredMemType(int *ceed, int *type, int *err) { 100 *err = CeedGetPreferredMemType(Ceed_dict[*ceed], (CeedMemType *)type); 101 } 102 103 #define fCeedView FORTRAN_NAME(ceedview,CEEDVIEW) 104 void fCeedView(int *ceed, int *err) { 105 *err = CeedView(Ceed_dict[*ceed], stdout); 106 } 107 108 #define fCeedDestroy FORTRAN_NAME(ceeddestroy,CEEDDESTROY) 109 void fCeedDestroy(int *ceed, int *err) { 110 if (*ceed == FORTRAN_NULL) return; 111 *err = CeedDestroy(&Ceed_dict[*ceed]); 112 113 if (*err == 0) { 114 *ceed = FORTRAN_NULL; 115 Ceed_n--; 116 if (Ceed_n == 0) { 117 CeedFree(&Ceed_dict); 118 Ceed_count = 0; 119 Ceed_count_max = 0; 120 } 121 } 122 } 123 124 // ----------------------------------------------------------------------------- 125 // CeedVector 126 // ----------------------------------------------------------------------------- 127 static CeedVector *CeedVector_dict = NULL; 128 static int CeedVector_count = 0; 129 static int CeedVector_n = 0; 130 static int CeedVector_count_max = 0; 131 132 #define fCeedVectorCreate FORTRAN_NAME(ceedvectorcreate,CEEDVECTORCREATE) 133 void fCeedVectorCreate(int *ceed, int *length, int *vec, int *err) { 134 if (CeedVector_count == CeedVector_count_max) { 135 CeedVector_count_max += CeedVector_count_max/2 + 1; 136 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 137 } 138 139 CeedVector *vec_ = &CeedVector_dict[CeedVector_count]; 140 *err = CeedVectorCreate(Ceed_dict[*ceed], *length, vec_); 141 142 if (*err == 0) { 143 *vec = CeedVector_count++; 144 CeedVector_n++; 145 } 146 } 147 148 #define fCeedVectorSetArray FORTRAN_NAME(ceedvectorsetarray,CEEDVECTORSETARRAY) 149 void fCeedVectorSetArray(int *vec, int *memtype, int *copymode, 150 CeedScalar *array, int64_t *offset, int *err) { 151 *err = CeedVectorSetArray(CeedVector_dict[*vec], (CeedMemType)*memtype, 152 (CeedCopyMode)*copymode, 153 (CeedScalar *)(array + *offset)); 154 } 155 156 #define fCeedVectorTakeArray FORTRAN_NAME(ceedvectortakearray,CEEDVECTORTAKEARRAY) 157 void fCeedVectorTakeArray(int *vec, int *memtype, CeedScalar *array, 158 int64_t *offset, int *err) { 159 CeedScalar *b; 160 CeedVector vec_ = CeedVector_dict[*vec]; 161 *err = CeedVectorTakeArray(vec_, (CeedMemType)*memtype, &b); 162 *offset = b - array; 163 } 164 165 #define fCeedVectorSyncArray FORTRAN_NAME(ceedvectorsyncarray,CEEDVECTORSYNCARRAY) 166 void fCeedVectorSyncArray(int *vec, int *memtype, int *err) { 167 *err = CeedVectorSyncArray(CeedVector_dict[*vec], (CeedMemType)*memtype); 168 } 169 170 #define fCeedVectorSetValue FORTRAN_NAME(ceedvectorsetvalue,CEEDVECTORSETVALUE) 171 void fCeedVectorSetValue(int *vec, CeedScalar *value, int *err) { 172 *err = CeedVectorSetValue(CeedVector_dict[*vec], *value); 173 } 174 175 #define fCeedVectorGetArray FORTRAN_NAME(ceedvectorgetarray,CEEDVECTORGETARRAY) 176 void fCeedVectorGetArray(int *vec, int *memtype, CeedScalar *array, 177 int64_t *offset, int *err) { 178 CeedScalar *b; 179 CeedVector vec_ = CeedVector_dict[*vec]; 180 *err = CeedVectorGetArray(vec_, (CeedMemType)*memtype, &b); 181 *offset = b - array; 182 } 183 184 #define fCeedVectorGetArrayRead \ 185 FORTRAN_NAME(ceedvectorgetarrayread,CEEDVECTORGETARRAYREAD) 186 void fCeedVectorGetArrayRead(int *vec, int *memtype, CeedScalar *array, 187 int64_t *offset, int *err) { 188 const CeedScalar *b; 189 CeedVector vec_ = CeedVector_dict[*vec]; 190 *err = CeedVectorGetArrayRead(vec_, (CeedMemType)*memtype, &b); 191 *offset = b - array; 192 } 193 194 #define fCeedVectorRestoreArray \ 195 FORTRAN_NAME(ceedvectorrestorearray,CEEDVECTORRESTOREARRAY) 196 void fCeedVectorRestoreArray(int *vec, CeedScalar *array, 197 int64_t *offset, int *err) { 198 CeedScalar *offsetArray = array + *offset; 199 *err = CeedVectorRestoreArray(CeedVector_dict[*vec], &offsetArray); 200 *offset = 0; 201 } 202 203 #define fCeedVectorRestoreArrayRead \ 204 FORTRAN_NAME(ceedvectorrestorearrayread,CEEDVECTORRESTOREARRAYREAD) 205 void fCeedVectorRestoreArrayRead(int *vec, const CeedScalar *array, 206 int64_t *offset, int *err) { 207 *err = CeedVectorRestoreArrayRead(CeedVector_dict[*vec], &array); 208 *offset = 0; 209 } 210 211 #define fCeedVectorNorm \ 212 FORTRAN_NAME(ceedvectornorm,CEEDVECTORNORM) 213 void fCeedVectorNorm(int *vec, int *type, CeedScalar *norm, int *err) { 214 *err = CeedVectorNorm(CeedVector_dict[*vec], (CeedNormType)*type, norm); 215 } 216 217 #define fCeedVectorReciprocal \ 218 FORTRAN_NAME(ceedvectorreciprocal,CEEDVECTORRECIPROCAL) 219 void fCeedVectorReciprocal(int *vec, int *err) { 220 *err = CeedVectorReciprocal(CeedVector_dict[*vec]); 221 } 222 223 #define fCeedVectorView FORTRAN_NAME(ceedvectorview,CEEDVECTORVIEW) 224 void fCeedVectorView(int *vec, int *err) { 225 *err = CeedVectorView(CeedVector_dict[*vec], "%12.8f", stdout); 226 } 227 228 #define fCeedVectorDestroy FORTRAN_NAME(ceedvectordestroy,CEEDVECTORDESTROY) 229 void fCeedVectorDestroy(int *vec, int *err) { 230 if (*vec == FORTRAN_NULL) return; 231 *err = CeedVectorDestroy(&CeedVector_dict[*vec]); 232 233 if (*err == 0) { 234 *vec = FORTRAN_NULL; 235 CeedVector_n--; 236 if (CeedVector_n == 0) { 237 CeedFree(&CeedVector_dict); 238 CeedVector_count = 0; 239 CeedVector_count_max = 0; 240 } 241 } 242 } 243 244 // ----------------------------------------------------------------------------- 245 // CeedElemRestriction 246 // ----------------------------------------------------------------------------- 247 static CeedElemRestriction *CeedElemRestriction_dict = NULL; 248 static int CeedElemRestriction_count = 0; 249 static int CeedElemRestriction_n = 0; 250 static int CeedElemRestriction_count_max = 0; 251 252 #define fCeedElemRestrictionCreate \ 253 FORTRAN_NAME(ceedelemrestrictioncreate, CEEDELEMRESTRICTIONCREATE) 254 void fCeedElemRestrictionCreate(int *ceed, int *nelements, int *esize, 255 int *num_comp, int *comp_stride, int *lsize, 256 int *memtype, int *copymode, const int *offsets, 257 int *elemrestriction, int *err) { 258 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 259 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 260 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 261 } 262 263 const int *offsets_ = offsets; 264 265 CeedElemRestriction *elemrestriction_ = 266 &CeedElemRestriction_dict[CeedElemRestriction_count]; 267 *err = CeedElemRestrictionCreate(Ceed_dict[*ceed], *nelements, *esize, 268 *num_comp, *comp_stride, *lsize, 269 (CeedMemType)*memtype, 270 (CeedCopyMode)*copymode, offsets_, 271 elemrestriction_); 272 273 if (*err == 0) { 274 *elemrestriction = CeedElemRestriction_count++; 275 CeedElemRestriction_n++; 276 } 277 } 278 279 #define fCeedElemRestrictionCreateStrided \ 280 FORTRAN_NAME(ceedelemrestrictioncreatestrided, CEEDELEMRESTRICTIONCREATESTRIDED) 281 void fCeedElemRestrictionCreateStrided(int *ceed, int *nelements, int *esize, 282 int *num_comp, int *lsize, int *strides, 283 int *elemrestriction, int *err) { 284 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 285 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 286 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 287 } 288 289 CeedElemRestriction *elemrestriction_ = 290 &CeedElemRestriction_dict[CeedElemRestriction_count]; 291 *err = CeedElemRestrictionCreateStrided(Ceed_dict[*ceed], *nelements, *esize, 292 *num_comp, *lsize, 293 *strides == FORTRAN_STRIDES_BACKEND ? 294 CEED_STRIDES_BACKEND : strides, 295 elemrestriction_); 296 if (*err == 0) { 297 *elemrestriction = CeedElemRestriction_count++; 298 CeedElemRestriction_n++; 299 } 300 } 301 302 #define fCeedElemRestrictionCreateBlocked \ 303 FORTRAN_NAME(ceedelemrestrictioncreateblocked,CEEDELEMRESTRICTIONCREATEBLOCKED) 304 void fCeedElemRestrictionCreateBlocked(int *ceed, int *nelements, int *esize, 305 int *blocksize, int *num_comp, 306 int *comp_stride, int *lsize, 307 int *mtype, int *cmode, 308 int *blkindices, int *elemrestriction, 309 int *err) { 310 311 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 312 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 313 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 314 } 315 316 CeedElemRestriction *elemrestriction_ = 317 &CeedElemRestriction_dict[CeedElemRestriction_count]; 318 *err = CeedElemRestrictionCreateBlocked(Ceed_dict[*ceed], 319 *nelements, *esize, *blocksize, 320 *num_comp, *comp_stride, *lsize, 321 (CeedMemType)*mtype, 322 (CeedCopyMode)*cmode, blkindices, 323 elemrestriction_); 324 325 if (*err == 0) { 326 *elemrestriction = CeedElemRestriction_count++; 327 CeedElemRestriction_n++; 328 } 329 } 330 331 #define fCeedElemRestrictionCreateBlockedStrided \ 332 FORTRAN_NAME(ceedelemrestrictioncreateblockedstrided, CEEDELEMRESTRICTIONCREATEBLOCKEDSTRIDED) 333 void fCeedElemRestrictionCreateBlockedStrided(int *ceed, int *nelements, 334 int *esize, int *blk_size, int *num_comp, int *lsize, int *strides, 335 int *elemrestriction, int *err) { 336 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 337 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 338 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 339 } 340 341 CeedElemRestriction *elemrestriction_ = 342 &CeedElemRestriction_dict[CeedElemRestriction_count]; 343 *err = CeedElemRestrictionCreateBlockedStrided(Ceed_dict[*ceed], *nelements, 344 *esize, *blk_size, *num_comp, *lsize, strides, elemrestriction_); 345 if (*err == 0) { 346 *elemrestriction = CeedElemRestriction_count++; 347 CeedElemRestriction_n++; 348 } 349 } 350 351 static CeedRequest *CeedRequest_dict = NULL; 352 static int CeedRequest_count = 0; 353 static int CeedRequest_n = 0; 354 static int CeedRequest_count_max = 0; 355 356 #define fCeedElemRestrictionApply \ 357 FORTRAN_NAME(ceedelemrestrictionapply,CEEDELEMRESTRICTIONAPPLY) 358 void fCeedElemRestrictionApply(int *elemr, int *tmode, int *uvec, int *ruvec, 359 int *rqst, int *err) { 360 int createRequest = 1; 361 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 362 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 363 createRequest = 0; 364 365 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 366 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 367 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 368 } 369 370 CeedRequest *rqst_; 371 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 372 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 373 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 374 375 *err = CeedElemRestrictionApply(CeedElemRestriction_dict[*elemr], 376 (CeedTransposeMode)*tmode, 377 CeedVector_dict[*uvec], 378 CeedVector_dict[*ruvec], rqst_); 379 380 if (*err == 0 && createRequest) { 381 *rqst = CeedRequest_count++; 382 CeedRequest_n++; 383 } 384 } 385 386 #define fCeedElemRestrictionApplyBlock \ 387 FORTRAN_NAME(ceedelemrestrictionapplyblock,CEEDELEMRESTRICTIONAPPLYBLOCK) 388 void fCeedElemRestrictionApplyBlock(int *elemr, int *block, int *tmode, 389 int *uvec, int *ruvec, int *rqst, int *err) { 390 int createRequest = 1; 391 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 392 if (*rqst == FORTRAN_REQUEST_IMMEDIATE || *rqst == FORTRAN_REQUEST_ORDERED) 393 createRequest = 0; 394 395 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 396 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 397 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 398 } 399 400 CeedRequest *rqst_; 401 if (*rqst == FORTRAN_REQUEST_IMMEDIATE) rqst_ = CEED_REQUEST_IMMEDIATE; 402 else if (*rqst == FORTRAN_REQUEST_ORDERED ) rqst_ = CEED_REQUEST_ORDERED; 403 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 404 405 *err = CeedElemRestrictionApplyBlock(CeedElemRestriction_dict[*elemr], *block, 406 (CeedTransposeMode)*tmode, CeedVector_dict[*uvec], 407 CeedVector_dict[*ruvec], rqst_); 408 409 if (*err == 0 && createRequest) { 410 *rqst = CeedRequest_count++; 411 CeedRequest_n++; 412 } 413 } 414 415 #define fCeedElemRestrictionGetMultiplicity \ 416 FORTRAN_NAME(ceedelemrestrictiongetmultiplicity,CEEDELEMRESTRICTIONGETMULTIPLICITY) 417 void fCeedElemRestrictionGetMultiplicity(int *elemr, int *mult, int *err) { 418 *err = CeedElemRestrictionGetMultiplicity(CeedElemRestriction_dict[*elemr], 419 CeedVector_dict[*mult]); 420 } 421 422 #define fCeedElemRestrictionGetELayout \ 423 FORTRAN_NAME(ceedelemrestrictiongetelayout,CEEDELEMRESTRICTIONGETELAYOUT) 424 void fCeedElemRestrictionGetELayout(int *elemr, int *layout, int *err) { 425 CeedInt layout_c[3]; 426 *err = CeedElemRestrictionGetELayout(CeedElemRestriction_dict[*elemr], 427 &layout_c); 428 for (int i=0; i<3; i++) 429 layout[i] = layout_c[i]; 430 } 431 432 #define fCeedElemRestrictionView \ 433 FORTRAN_NAME(ceedelemrestrictionview,CEEDELEMRESTRICTIONVIEW) 434 void fCeedElemRestrictionView(int *elemr, int *err) { 435 *err = CeedElemRestrictionView(CeedElemRestriction_dict[*elemr], stdout); 436 } 437 438 #define fCeedRequestWait FORTRAN_NAME(ceedrequestwait, CEEDREQUESTWAIT) 439 void fCeedRequestWait(int *rqst, int *err) { 440 // TODO Uncomment this once CeedRequestWait is implemented 441 //*err = CeedRequestWait(&CeedRequest_dict[*rqst]); 442 443 if (*err == 0) { 444 CeedRequest_n--; 445 if (CeedRequest_n == 0) { 446 CeedFree(&CeedRequest_dict); 447 CeedRequest_count = 0; 448 CeedRequest_count_max = 0; 449 } 450 } 451 } 452 453 #define fCeedElemRestrictionDestroy \ 454 FORTRAN_NAME(ceedelemrestrictiondestroy,CEEDELEMRESTRICTIONDESTROY) 455 void fCeedElemRestrictionDestroy(int *elem, int *err) { 456 if (*elem == FORTRAN_NULL) return; 457 *err = CeedElemRestrictionDestroy(&CeedElemRestriction_dict[*elem]); 458 459 if (*err == 0) { 460 *elem = FORTRAN_NULL; 461 CeedElemRestriction_n--; 462 if (CeedElemRestriction_n == 0) { 463 CeedFree(&CeedElemRestriction_dict); 464 CeedElemRestriction_count = 0; 465 CeedElemRestriction_count_max = 0; 466 } 467 } 468 } 469 470 // ----------------------------------------------------------------------------- 471 // CeedBasis 472 // ----------------------------------------------------------------------------- 473 static CeedBasis *CeedBasis_dict = NULL; 474 static int CeedBasis_count = 0; 475 static int CeedBasis_n = 0; 476 static int CeedBasis_count_max = 0; 477 478 #define fCeedBasisCreateTensorH1Lagrange \ 479 FORTRAN_NAME(ceedbasiscreatetensorh1lagrange, CEEDBASISCREATETENSORH1LAGRANGE) 480 void fCeedBasisCreateTensorH1Lagrange(int *ceed, int *dim, 481 int *num_comp, int *P, int *Q, int *quadmode, 482 int *basis, int *err) { 483 if (CeedBasis_count == CeedBasis_count_max) { 484 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 485 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 486 } 487 488 *err = CeedBasisCreateTensorH1Lagrange(Ceed_dict[*ceed], *dim, *num_comp, *P, 489 *Q, 490 (CeedQuadMode)*quadmode, 491 &CeedBasis_dict[CeedBasis_count]); 492 493 if (*err == 0) { 494 *basis = CeedBasis_count++; 495 CeedBasis_n++; 496 } 497 } 498 499 #define fCeedBasisCreateTensorH1 \ 500 FORTRAN_NAME(ceedbasiscreatetensorh1, CEEDBASISCREATETENSORH1) 501 void fCeedBasisCreateTensorH1(int *ceed, int *dim, int *num_comp, int *P_1d, 502 int *Q_1d, const CeedScalar *interp_1d, 503 const CeedScalar *grad_1d, 504 const CeedScalar *q_ref_1d, 505 const CeedScalar *q_weight_1d, int *basis, 506 int *err) { 507 if (CeedBasis_count == CeedBasis_count_max) { 508 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 509 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 510 } 511 512 *err = CeedBasisCreateTensorH1(Ceed_dict[*ceed], *dim, *num_comp, *P_1d, *Q_1d, 513 interp_1d, grad_1d, q_ref_1d, q_weight_1d, 514 &CeedBasis_dict[CeedBasis_count]); 515 516 if (*err == 0) { 517 *basis = CeedBasis_count++; 518 CeedBasis_n++; 519 } 520 } 521 522 #define fCeedBasisCreateH1 \ 523 FORTRAN_NAME(ceedbasiscreateh1, CEEDBASISCREATEH1) 524 void fCeedBasisCreateH1(int *ceed, int *topo, int *num_comp, int *nnodes, 525 int *nqpts, const CeedScalar *interp, 526 const CeedScalar *grad, const CeedScalar *qref, 527 const CeedScalar *qweight, int *basis, int *err) { 528 if (CeedBasis_count == CeedBasis_count_max) { 529 CeedBasis_count_max += CeedBasis_count_max/2 + 1; 530 CeedRealloc(CeedBasis_count_max, &CeedBasis_dict); 531 } 532 533 *err = CeedBasisCreateH1(Ceed_dict[*ceed], (CeedElemTopology)*topo, *num_comp, 534 *nnodes, *nqpts, interp, grad, qref, qweight, 535 &CeedBasis_dict[CeedBasis_count]); 536 537 if (*err == 0) { 538 *basis = CeedBasis_count++; 539 CeedBasis_n++; 540 } 541 } 542 543 #define fCeedBasisView FORTRAN_NAME(ceedbasisview, CEEDBASISVIEW) 544 void fCeedBasisView(int *basis, int *err) { 545 *err = CeedBasisView(CeedBasis_dict[*basis], stdout); 546 } 547 548 #define fCeedQRFactorization \ 549 FORTRAN_NAME(ceedqrfactorization, CEEDQRFACTORIZATION) 550 void fCeedQRFactorization(int *ceed, CeedScalar *mat, CeedScalar *tau, int *m, 551 int *n, int *err) { 552 *err = CeedQRFactorization(Ceed_dict[*ceed], mat, tau, *m, *n); 553 } 554 555 #define fCeedHouseholderApplyQ \ 556 FORTRAN_NAME(ceedhouseholderapplyq, CEEDHOUSEHOLDERAPPLYQ) 557 void fCeedHouseholderApplyQ(CeedScalar *A, CeedScalar *Q, CeedScalar *tau, 558 int *t_mode, 559 int *m, int *n, int *k, int *row, int *col, int *err) { 560 *err = CeedHouseholderApplyQ(A, Q, tau, (CeedTransposeMode)*t_mode, *m, *n, *k, 561 *row, *col); 562 } 563 564 #define fCeedSymmetricSchurDecomposition \ 565 FORTRAN_NAME(ceedsymmetricschurdecomposition, CEEDSYMMETRICSCHURDECOMPOSITION) 566 void fCeedSymmetricSchurDecomposition(int *ceed, CeedScalar *mat, 567 CeedScalar *lambda, int *n, int *err) { 568 *err = CeedSymmetricSchurDecomposition(Ceed_dict[*ceed], mat, lambda, *n); 569 } 570 571 #define fCeedSimultaneousDiagonalization \ 572 FORTRAN_NAME(ceedsimultaneousdiagonalization, CEEDSIMULTANEOUSDIAGONALIZATION) 573 void fCeedSimultaneousDiagonalization(int *ceed, CeedScalar *matA, 574 CeedScalar *matB, CeedScalar *x, 575 CeedScalar *lambda, int *n, int *err) { 576 *err = CeedSimultaneousDiagonalization(Ceed_dict[*ceed], matA, matB, x, 577 lambda, *n); 578 } 579 580 #define fCeedBasisGetCollocatedGrad \ 581 FORTRAN_NAME(ceedbasisgetcollocatedgrad, CEEDBASISGETCOLLOCATEDGRAD) 582 void fCeedBasisGetCollocatedGrad(int *basis, CeedScalar *colo_grad_1d, 583 int *err) { 584 *err = CeedBasisGetCollocatedGrad(CeedBasis_dict[*basis], colo_grad_1d); 585 } 586 587 #define fCeedBasisApply FORTRAN_NAME(ceedbasisapply, CEEDBASISAPPLY) 588 void fCeedBasisApply(int *basis, int *num_elem, int *tmode, int *eval_mode, 589 int *u, int *v, int *err) { 590 *err = CeedBasisApply(CeedBasis_dict[*basis], *num_elem, 591 (CeedTransposeMode)*tmode, 592 (CeedEvalMode)*eval_mode, 593 *u == FORTRAN_VECTOR_NONE ? CEED_VECTOR_NONE : CeedVector_dict[*u], 594 CeedVector_dict[*v]); 595 } 596 597 #define fCeedBasisGetNumNodes \ 598 FORTRAN_NAME(ceedbasisgetnumnodes, CEEDBASISGETNUMNODES) 599 void fCeedBasisGetNumNodes(int *basis, int *P, int *err) { 600 *err = CeedBasisGetNumNodes(CeedBasis_dict[*basis], P); 601 } 602 603 #define fCeedBasisGetNumQuadraturePoints \ 604 FORTRAN_NAME(ceedbasisgetnumquadraturepoints, CEEDBASISGETNUMQUADRATUREPOINTS) 605 void fCeedBasisGetNumQuadraturePoints(int *basis, int *Q, int *err) { 606 *err = CeedBasisGetNumQuadraturePoints(CeedBasis_dict[*basis], Q); 607 } 608 609 #define fCeedBasisGetInterp1D \ 610 FORTRAN_NAME(ceedbasisgetinterp1d, CEEDBASISGETINTERP1D) 611 void fCeedBasisGetInterp1D(int *basis, CeedScalar *interp_1d, int64_t *offset, 612 int *err) { 613 const CeedScalar *interp1d_; 614 CeedBasis basis_ = CeedBasis_dict[*basis]; 615 *err = CeedBasisGetInterp1D(basis_, &interp1d_); 616 *offset = interp1d_ - interp_1d; 617 } 618 619 #define fCeedBasisGetGrad1D \ 620 FORTRAN_NAME(ceedbasisgetgrad1d, CEEDBASISGETGRAD1D) 621 void fCeedBasisGetGrad1D(int *basis, CeedScalar *grad_1d, int64_t *offset, 622 int *err) { 623 const CeedScalar *grad1d_; 624 CeedBasis basis_ = CeedBasis_dict[*basis]; 625 *err = CeedBasisGetGrad1D(basis_, &grad1d_); 626 *offset = grad1d_ - grad_1d; 627 } 628 629 #define fCeedBasisGetQRef \ 630 FORTRAN_NAME(ceedbasisgetqref, CEEDBASISGETQREF) 631 void fCeedBasisGetQRef(int *basis, CeedScalar *q_ref, int64_t *offset, 632 int *err) { 633 const CeedScalar *qref_; 634 CeedBasis basis_ = CeedBasis_dict[*basis]; 635 *err = CeedBasisGetQRef(basis_, &qref_); 636 *offset = qref_ - q_ref; 637 } 638 639 #define fCeedBasisDestroy FORTRAN_NAME(ceedbasisdestroy,CEEDBASISDESTROY) 640 void fCeedBasisDestroy(int *basis, int *err) { 641 if (*basis == FORTRAN_NULL) return; 642 *err = CeedBasisDestroy(&CeedBasis_dict[*basis]); 643 644 if (*err == 0) { 645 *basis = FORTRAN_NULL; 646 CeedBasis_n--; 647 if (CeedBasis_n == 0) { 648 CeedFree(&CeedBasis_dict); 649 CeedBasis_count = 0; 650 CeedBasis_count_max = 0; 651 } 652 } 653 } 654 655 #define fCeedGaussQuadrature FORTRAN_NAME(ceedgaussquadrature, CEEDGAUSSQUADRATURE) 656 void fCeedGaussQuadrature(int *Q, CeedScalar *q_ref_1d, CeedScalar *q_weight_1d, 657 int *err) { 658 *err = CeedGaussQuadrature(*Q, q_ref_1d, q_weight_1d); 659 } 660 661 #define fCeedLobattoQuadrature \ 662 FORTRAN_NAME(ceedlobattoquadrature, CEEDLOBATTOQUADRATURE) 663 void fCeedLobattoQuadrature(int *Q, CeedScalar *q_ref_1d, 664 CeedScalar *q_weight_1d, 665 int *err) { 666 *err = CeedLobattoQuadrature(*Q, q_ref_1d, q_weight_1d); 667 } 668 669 // ----------------------------------------------------------------------------- 670 // CeedQFunctionContext 671 // ----------------------------------------------------------------------------- 672 static CeedQFunctionContext *CeedQFunctionContext_dict = NULL; 673 static int CeedQFunctionContext_count = 0; 674 static int CeedQFunctionContext_n = 0; 675 static int CeedQFunctionContext_count_max = 0; 676 677 #define fCeedQFunctionContextCreate \ 678 FORTRAN_NAME(ceedqfunctioncontextcreate,CEEDQFUNCTIONCONTEXTCREATE) 679 void fCeedQFunctionContextCreate(int *ceed, int *ctx, int *err) { 680 if (CeedQFunctionContext_count == CeedQFunctionContext_count_max) { 681 CeedQFunctionContext_count_max += CeedQFunctionContext_count_max/2 + 1; 682 CeedRealloc(CeedQFunctionContext_count_max, &CeedQFunctionContext_dict); 683 } 684 685 CeedQFunctionContext *ctx_ = 686 &CeedQFunctionContext_dict[CeedQFunctionContext_count]; 687 688 *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], ctx_); 689 if (*err) return; 690 *ctx = CeedQFunctionContext_count++; 691 CeedQFunctionContext_n++; 692 } 693 694 #define fCeedQFunctionContextSetData \ 695 FORTRAN_NAME(ceedqfunctioncontextsetdata,CEEDQFUNCTIONCONTEXTSETDATA) 696 void fCeedQFunctionContextSetData(int *ctx, int *memtype, int *copymode, 697 CeedInt *n, 698 CeedScalar *data, int64_t *offset, int *err) { 699 size_t ctx_size = ((size_t) *n)*sizeof(CeedScalar); 700 *err = CeedQFunctionContextSetData(CeedQFunctionContext_dict[*ctx], 701 (CeedMemType)*memtype, 702 (CeedCopyMode)*copymode, ctx_size, 703 data + *offset); 704 } 705 706 #define fCeedQFunctionContextGetData \ 707 FORTRAN_NAME(ceedqfunctioncontextgetdata,CEEDQFUNCTIONCONTEXTGETDATA) 708 void fCeedQFunctionContextGetData(int *ctx, int *memtype, CeedScalar *data, 709 int64_t *offset, int *err) { 710 CeedScalar *b; 711 CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx]; 712 *err = CeedQFunctionContextGetData(ctx_, (CeedMemType)*memtype, &b); 713 *offset = b - data; 714 } 715 716 #define fCeedQFunctionContextRestoreData \ 717 FORTRAN_NAME(ceedqfunctioncontextrestoredata,CEEDQFUNCTIONCONTEXTRESTOREDATA) 718 void fCeedQFunctionContextRestoreData(int *ctx, CeedScalar *data, 719 int64_t *offset, int *err) { 720 *err = CeedQFunctionContextRestoreData(CeedQFunctionContext_dict[*ctx], 721 (void **)&data); 722 *offset = 0; 723 } 724 725 #define fCeedQFunctionContextView \ 726 FORTRAN_NAME(ceedqfunctioncontextview,CEEDQFUNCTIONCONTEXTVIEW) 727 void fCeedQFunctionContextView(int *ctx, int *err) { 728 *err = CeedQFunctionContextView(CeedQFunctionContext_dict[*ctx], stdout); 729 } 730 731 #define fCeedQFunctionContextDestroy \ 732 FORTRAN_NAME(ceedqfunctioncontextdestroy,CEEDQFUNCTIONCONTEXTDESTROY) 733 void fCeedQFunctionContextDestroy(int *ctx, int *err) { 734 if (*ctx == FORTRAN_NULL) return; 735 *err = CeedQFunctionContextDestroy(&CeedQFunctionContext_dict[*ctx]); 736 737 if (*err == 0) { 738 *ctx = FORTRAN_NULL; 739 CeedQFunctionContext_n--; 740 if (CeedQFunctionContext_n == 0) { 741 CeedFree(&CeedQFunctionContext_dict); 742 CeedQFunctionContext_count = 0; 743 CeedQFunctionContext_count_max = 0; 744 } 745 } 746 } 747 748 // ----------------------------------------------------------------------------- 749 // CeedQFunction 750 // ----------------------------------------------------------------------------- 751 static CeedQFunction *CeedQFunction_dict = NULL; 752 static int CeedQFunction_count = 0; 753 static int CeedQFunction_n = 0; 754 static int CeedQFunction_count_max = 0; 755 756 static int CeedQFunctionFortranStub(void *ctx, int nq, 757 const CeedScalar *const *u, 758 CeedScalar *const *v) { 759 CeedFortranContext fctx = ctx; 760 CeedQFunctionContext innerctx = fctx->innerctx; 761 int ierr; 762 763 CeedScalar *ctx_ = NULL; 764 // Note: Device backends are generating their own kernels from 765 // single source files, so only Host backends need to 766 // use this Fortran stub. 767 if (innerctx) { 768 ierr = CeedQFunctionContextGetData(innerctx, CEED_MEM_HOST, &ctx_); 769 CeedChk(ierr); 770 } 771 772 fctx->f((void *)ctx_,&nq,u[0],u[1],u[2],u[3],u[4],u[5],u[6], 773 u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15], 774 v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9], 775 v[10],v[11],v[12],v[13],v[14],v[15],&ierr); 776 777 if (innerctx) { 778 ierr = CeedQFunctionContextRestoreData(innerctx, (void *)&ctx_); 779 CeedChk(ierr); 780 } 781 782 return ierr; 783 } 784 785 #define fCeedQFunctionCreateInterior \ 786 FORTRAN_NAME(ceedqfunctioncreateinterior, CEEDQFUNCTIONCREATEINTERIOR) 787 void fCeedQFunctionCreateInterior(int *ceed, int *vec_length, 788 void (*f)(void *ctx, int *nq, 789 const CeedScalar *u,const CeedScalar *u1, 790 const CeedScalar *u2,const CeedScalar *u3, 791 const CeedScalar *u4,const CeedScalar *u5, 792 const CeedScalar *u6,const CeedScalar *u7, 793 const CeedScalar *u8,const CeedScalar *u9, 794 const CeedScalar *u10,const CeedScalar *u11, 795 const CeedScalar *u12,const CeedScalar *u13, 796 const CeedScalar *u14,const CeedScalar *u15, 797 CeedScalar *v,CeedScalar *v1,CeedScalar *v2, 798 CeedScalar *v3,CeedScalar *v4, 799 CeedScalar *v5,CeedScalar *v6, 800 CeedScalar *v7,CeedScalar *v8, 801 CeedScalar *v9,CeedScalar *v10, 802 CeedScalar *v11,CeedScalar *v12, 803 CeedScalar *v13,CeedScalar *v14, 804 CeedScalar *v15,int *err), 805 const char *source, int *qf, int *err, 806 fortran_charlen_t source_len) { 807 FIX_STRING(source); 808 if (CeedQFunction_count == CeedQFunction_count_max) { 809 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 810 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 811 } 812 813 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 814 *err = CeedQFunctionCreateInterior(Ceed_dict[*ceed], *vec_length, 815 CeedQFunctionFortranStub, source_c, qf_); 816 817 if (*err == 0) { 818 *qf = CeedQFunction_count++; 819 CeedQFunction_n++; 820 } 821 822 CeedFortranContext fctxdata; 823 *err = CeedCalloc(1, &fctxdata); 824 if (*err) return; 825 fctxdata->f = f; fctxdata->innerctx = NULL; 826 CeedQFunctionContext fctx; 827 *err = CeedQFunctionContextCreate(Ceed_dict[*ceed], &fctx); 828 if (*err) return; 829 *err = CeedQFunctionContextSetData(fctx, CEED_MEM_HOST, CEED_OWN_POINTER, 830 sizeof(*fctxdata), fctxdata); 831 if (*err) return; 832 *err = CeedQFunctionSetContext(*qf_, fctx); 833 if (*err) return; 834 CeedQFunctionContextDestroy(&fctx); 835 if (*err) return; 836 837 *err = CeedQFunctionSetFortranStatus(*qf_, true); 838 } 839 840 #define fCeedQFunctionCreateInteriorByName \ 841 FORTRAN_NAME(ceedqfunctioncreateinteriorbyname, CEEDQFUNCTIONCREATEINTERIORBYNAME) 842 void fCeedQFunctionCreateInteriorByName(int *ceed, const char *name, int *qf, 843 int *err, fortran_charlen_t name_len) { 844 FIX_STRING(name); 845 if (CeedQFunction_count == CeedQFunction_count_max) { 846 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 847 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 848 } 849 850 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 851 *err = CeedQFunctionCreateInteriorByName(Ceed_dict[*ceed], name_c, qf_); 852 853 if (*err == 0) { 854 *qf = CeedQFunction_count++; 855 CeedQFunction_n++; 856 } 857 } 858 859 #define fCeedQFunctionCreateIdentity \ 860 FORTRAN_NAME(ceedqfunctioncreateidentity, CEEDQFUNCTIONCREATEIDENTITY) 861 void fCeedQFunctionCreateIdentity(int *ceed, int *size, int *inmode, 862 int *outmode, int *qf, int *err) { 863 if (CeedQFunction_count == CeedQFunction_count_max) { 864 CeedQFunction_count_max += CeedQFunction_count_max/2 + 1; 865 CeedRealloc(CeedQFunction_count_max, &CeedQFunction_dict); 866 } 867 868 CeedQFunction *qf_ = &CeedQFunction_dict[CeedQFunction_count]; 869 *err = CeedQFunctionCreateIdentity(Ceed_dict[*ceed], *size, 870 (CeedEvalMode)*inmode, 871 (CeedEvalMode)*outmode, qf_); 872 873 if (*err == 0) { 874 *qf = CeedQFunction_count++; 875 CeedQFunction_n++; 876 } 877 } 878 879 #define fCeedQFunctionAddInput \ 880 FORTRAN_NAME(ceedqfunctionaddinput,CEEDQFUNCTIONADDINPUT) 881 void fCeedQFunctionAddInput(int *qf, const char *field_name, 882 CeedInt *num_comp, CeedEvalMode *eval_mode, int *err, 883 fortran_charlen_t field_name_len) { 884 FIX_STRING(field_name); 885 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 886 887 *err = CeedQFunctionAddInput(qf_, field_name_c, *num_comp, *eval_mode); 888 } 889 890 #define fCeedQFunctionAddOutput \ 891 FORTRAN_NAME(ceedqfunctionaddoutput,CEEDQFUNCTIONADDOUTPUT) 892 void fCeedQFunctionAddOutput(int *qf, const char *field_name, 893 CeedInt *num_comp, CeedEvalMode *eval_mode, int *err, 894 fortran_charlen_t field_name_len) { 895 FIX_STRING(field_name); 896 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 897 898 *err = CeedQFunctionAddOutput(qf_, field_name_c, *num_comp, *eval_mode); 899 } 900 901 #define fCeedQFunctionSetContext \ 902 FORTRAN_NAME(ceedqfunctionsetcontext,CEEDQFUNCTIONSETCONTEXT) 903 void fCeedQFunctionSetContext(int *qf, int *ctx, int *err) { 904 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 905 CeedQFunctionContext ctx_ = CeedQFunctionContext_dict[*ctx]; 906 907 CeedQFunctionContext fctx; 908 *err = CeedQFunctionGetContext(qf_, &fctx); 909 if (*err) return; 910 CeedFortranContext fctxdata; 911 *err = CeedQFunctionContextGetData(fctx, CEED_MEM_HOST, &fctxdata); 912 if (*err) return; 913 fctxdata->innerctx = ctx_; 914 *err = CeedQFunctionContextRestoreData(fctx, (void **)&fctxdata); 915 } 916 917 #define fCeedQFunctionView \ 918 FORTRAN_NAME(ceedqfunctionview,CEEDQFUNCTIONVIEW) 919 void fCeedQFunctionView(int *qf, int *err) { 920 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 921 922 *err = CeedQFunctionView(qf_, stdout); 923 } 924 925 #define fCeedQFunctionApply \ 926 FORTRAN_NAME(ceedqfunctionapply,CEEDQFUNCTIONAPPLY) 927 //TODO Need Fixing, double pointer 928 void fCeedQFunctionApply(int *qf, int *Q, 929 int *u, int *u1, int *u2, int *u3, 930 int *u4, int *u5, int *u6, int *u7, 931 int *u8, int *u9, int *u10, int *u11, 932 int *u12, int *u13, int *u14, int *u15, 933 int *v, int *v1, int *v2, int *v3, 934 int *v4, int *v5, int *v6, int *v7, 935 int *v8, int *v9, int *v10, int *v11, 936 int *v12, int *v13, int *v14, int *v15, int *err) { 937 CeedQFunction qf_ = CeedQFunction_dict[*qf]; 938 CeedVector *in; 939 *err = CeedCalloc(16, &in); 940 if (*err) return; 941 in[0] = *u==FORTRAN_NULL?NULL:CeedVector_dict[*u]; 942 in[1] = *u1==FORTRAN_NULL?NULL:CeedVector_dict[*u1]; 943 in[2] = *u2==FORTRAN_NULL?NULL:CeedVector_dict[*u2]; 944 in[3] = *u3==FORTRAN_NULL?NULL:CeedVector_dict[*u3]; 945 in[4] = *u4==FORTRAN_NULL?NULL:CeedVector_dict[*u4]; 946 in[5] = *u5==FORTRAN_NULL?NULL:CeedVector_dict[*u5]; 947 in[6] = *u6==FORTRAN_NULL?NULL:CeedVector_dict[*u6]; 948 in[7] = *u7==FORTRAN_NULL?NULL:CeedVector_dict[*u7]; 949 in[8] = *u8==FORTRAN_NULL?NULL:CeedVector_dict[*u8]; 950 in[9] = *u9==FORTRAN_NULL?NULL:CeedVector_dict[*u9]; 951 in[10] = *u10==FORTRAN_NULL?NULL:CeedVector_dict[*u10]; 952 in[11] = *u11==FORTRAN_NULL?NULL:CeedVector_dict[*u11]; 953 in[12] = *u12==FORTRAN_NULL?NULL:CeedVector_dict[*u12]; 954 in[13] = *u13==FORTRAN_NULL?NULL:CeedVector_dict[*u13]; 955 in[14] = *u14==FORTRAN_NULL?NULL:CeedVector_dict[*u14]; 956 in[15] = *u15==FORTRAN_NULL?NULL:CeedVector_dict[*u15]; 957 CeedVector *out; 958 *err = CeedCalloc(16, &out); 959 if (*err) return; 960 out[0] = *v==FORTRAN_NULL?NULL:CeedVector_dict[*v]; 961 out[1] = *v1==FORTRAN_NULL?NULL:CeedVector_dict[*v1]; 962 out[2] = *v2==FORTRAN_NULL?NULL:CeedVector_dict[*v2]; 963 out[3] = *v3==FORTRAN_NULL?NULL:CeedVector_dict[*v3]; 964 out[4] = *v4==FORTRAN_NULL?NULL:CeedVector_dict[*v4]; 965 out[5] = *v5==FORTRAN_NULL?NULL:CeedVector_dict[*v5]; 966 out[6] = *v6==FORTRAN_NULL?NULL:CeedVector_dict[*v6]; 967 out[7] = *v7==FORTRAN_NULL?NULL:CeedVector_dict[*v7]; 968 out[8] = *v8==FORTRAN_NULL?NULL:CeedVector_dict[*v8]; 969 out[9] = *v9==FORTRAN_NULL?NULL:CeedVector_dict[*v9]; 970 out[10] = *v10==FORTRAN_NULL?NULL:CeedVector_dict[*v10]; 971 out[11] = *v11==FORTRAN_NULL?NULL:CeedVector_dict[*v11]; 972 out[12] = *v12==FORTRAN_NULL?NULL:CeedVector_dict[*v12]; 973 out[13] = *v13==FORTRAN_NULL?NULL:CeedVector_dict[*v13]; 974 out[14] = *v14==FORTRAN_NULL?NULL:CeedVector_dict[*v14]; 975 out[15] = *v15==FORTRAN_NULL?NULL:CeedVector_dict[*v15]; 976 *err = CeedQFunctionApply(qf_, *Q, in, out); 977 if (*err) return; 978 979 *err = CeedFree(&in); 980 if (*err) return; 981 *err = CeedFree(&out); 982 } 983 984 #define fCeedQFunctionDestroy \ 985 FORTRAN_NAME(ceedqfunctiondestroy,CEEDQFUNCTIONDESTROY) 986 void fCeedQFunctionDestroy(int *qf, int *err) { 987 if (*qf == FORTRAN_NULL) return; 988 989 *err = CeedQFunctionDestroy(&CeedQFunction_dict[*qf]); 990 if (*err == 0) { 991 *qf = FORTRAN_NULL; 992 CeedQFunction_n--; 993 if (CeedQFunction_n == 0) { 994 *err = CeedFree(&CeedQFunction_dict); 995 CeedQFunction_count = 0; 996 CeedQFunction_count_max = 0; 997 } 998 } 999 } 1000 1001 // ----------------------------------------------------------------------------- 1002 // CeedOperator 1003 // ----------------------------------------------------------------------------- 1004 static CeedOperator *CeedOperator_dict = NULL; 1005 static int CeedOperator_count = 0; 1006 static int CeedOperator_n = 0; 1007 static int CeedOperator_count_max = 0; 1008 1009 #define fCeedOperatorCreate \ 1010 FORTRAN_NAME(ceedoperatorcreate, CEEDOPERATORCREATE) 1011 void fCeedOperatorCreate(int *ceed, 1012 int *qf, int *dqf, int *dqfT, int *op, int *err) { 1013 if (CeedOperator_count == CeedOperator_count_max) { 1014 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1015 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1016 } 1017 1018 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 1019 1020 CeedQFunction dqf_ = CEED_QFUNCTION_NONE, dqfT_ = CEED_QFUNCTION_NONE; 1021 if (*dqf != FORTRAN_QFUNCTION_NONE) dqf_ = CeedQFunction_dict[*dqf ]; 1022 if (*dqfT != FORTRAN_QFUNCTION_NONE) dqfT_ = CeedQFunction_dict[*dqfT]; 1023 1024 *err = CeedOperatorCreate(Ceed_dict[*ceed], CeedQFunction_dict[*qf], dqf_, 1025 dqfT_, op_); 1026 if (*err) return; 1027 *op = CeedOperator_count++; 1028 CeedOperator_n++; 1029 } 1030 1031 #define fCeedCompositeOperatorCreate \ 1032 FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) 1033 void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { 1034 if (CeedOperator_count == CeedOperator_count_max) { 1035 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1036 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1037 } 1038 1039 CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; 1040 1041 *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); 1042 if (*err) return; 1043 *op = CeedOperator_count++; 1044 CeedOperator_n++; 1045 } 1046 1047 #define fCeedOperatorSetField \ 1048 FORTRAN_NAME(ceedoperatorsetfield,CEEDOPERATORSETFIELD) 1049 void fCeedOperatorSetField(int *op, const char *field_name, int *r, int *b, 1050 int *v, int *err, fortran_charlen_t field_name_len) { 1051 FIX_STRING(field_name); 1052 CeedElemRestriction r_; 1053 CeedBasis b_; 1054 CeedVector v_; 1055 1056 CeedOperator op_ = CeedOperator_dict[*op]; 1057 1058 if (*r == FORTRAN_NULL) { 1059 r_ = NULL; 1060 } else if (*r == FORTRAN_ELEMRESTRICTION_NONE) { 1061 r_ = CEED_ELEMRESTRICTION_NONE; 1062 } else { 1063 r_ = CeedElemRestriction_dict[*r]; 1064 } 1065 1066 if (*b == FORTRAN_NULL) { 1067 b_ = NULL; 1068 } else if (*b == FORTRAN_BASIS_COLLOCATED) { 1069 b_ = CEED_BASIS_COLLOCATED; 1070 } else { 1071 b_ = CeedBasis_dict[*b]; 1072 } 1073 if (*v == FORTRAN_NULL) { 1074 v_ = NULL; 1075 } else if (*v == FORTRAN_VECTOR_ACTIVE) { 1076 v_ = CEED_VECTOR_ACTIVE; 1077 } else if (*v == FORTRAN_VECTOR_NONE) { 1078 v_ = CEED_VECTOR_NONE; 1079 } else { 1080 v_ = CeedVector_dict[*v]; 1081 } 1082 1083 *err = CeedOperatorSetField(op_, field_name_c, r_, b_, v_); 1084 } 1085 1086 #define fCeedCompositeOperatorAddSub \ 1087 FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) 1088 void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { 1089 CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; 1090 CeedOperator subop_ = CeedOperator_dict[*subop]; 1091 1092 *err = CeedCompositeOperatorAddSub(compositeop_, subop_); 1093 if (*err) return; 1094 } 1095 1096 #define fCeedOperatorLinearAssembleQFunction \ 1097 FORTRAN_NAME(ceedoperatorlinearassembleqfunction, CEEDOPERATORLINEARASSEMBLEQFUNCTION) 1098 void fCeedOperatorLinearAssembleQFunction(int *op, int *assembledvec, 1099 int *assembledrstr, int *rqst, int *err) { 1100 // Vector 1101 if (CeedVector_count == CeedVector_count_max) { 1102 CeedVector_count_max += CeedVector_count_max/2 + 1; 1103 CeedRealloc(CeedVector_count_max, &CeedVector_dict); 1104 } 1105 CeedVector *assembledvec_ = &CeedVector_dict[CeedVector_count]; 1106 1107 // Restriction 1108 if (CeedElemRestriction_count == CeedElemRestriction_count_max) { 1109 CeedElemRestriction_count_max += CeedElemRestriction_count_max/2 + 1; 1110 CeedRealloc(CeedElemRestriction_count_max, &CeedElemRestriction_dict); 1111 } 1112 CeedElemRestriction *rstr_ = 1113 &CeedElemRestriction_dict[CeedElemRestriction_count]; 1114 1115 int createRequest = 1; 1116 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1117 if (*rqst == -1 || *rqst == -2) { 1118 createRequest = 0; 1119 } 1120 1121 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1122 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1123 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1124 } 1125 1126 CeedRequest *rqst_; 1127 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1128 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1129 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1130 1131 *err = CeedOperatorLinearAssembleQFunction(CeedOperator_dict[*op], 1132 assembledvec_, rstr_, rqst_); 1133 if (*err) return; 1134 if (createRequest) { 1135 *rqst = CeedRequest_count++; 1136 CeedRequest_n++; 1137 } 1138 1139 if (*err == 0) { 1140 *assembledrstr = CeedElemRestriction_count++; 1141 CeedElemRestriction_n++; 1142 *assembledvec = CeedVector_count++; 1143 CeedVector_n++; 1144 } 1145 } 1146 1147 #define fCeedOperatorLinearAssembleDiagonal \ 1148 FORTRAN_NAME(ceedoperatorlinearassemblediagonal, CEEDOPERATORLINEARASSEMBLEDIAGONAL) 1149 void fCeedOperatorLinearAssembleDiagonal(int *op, int *assembledvec, 1150 int *rqst, int *err) { 1151 int createRequest = 1; 1152 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1153 if (*rqst == -1 || *rqst == -2) { 1154 createRequest = 0; 1155 } 1156 1157 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1158 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1159 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1160 } 1161 1162 CeedRequest *rqst_; 1163 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1164 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1165 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1166 1167 *err = CeedOperatorLinearAssembleDiagonal(CeedOperator_dict[*op], 1168 CeedVector_dict[*assembledvec], rqst_); 1169 if (*err) return; 1170 if (createRequest) { 1171 *rqst = CeedRequest_count++; 1172 CeedRequest_n++; 1173 } 1174 } 1175 1176 #define fCeedOperatorMultigridLevelCreate \ 1177 FORTRAN_NAME(ceedoperatormultigridlevelcreate, CEEDOPERATORMULTIGRIDLEVELCREATE) 1178 void fCeedOperatorMultigridLevelCreate(int *opFine, int *pMultFine, 1179 int *rstrCoarse, int *basisCoarse, int *opCoarse, 1180 int *opProlong, int *opRestrict, int *err) { 1181 // Operators 1182 CeedOperator opCoarse_, opProlong_, opRestrict_; 1183 1184 // C interface call 1185 *err = CeedOperatorMultigridLevelCreate( 1186 CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], 1187 CeedElemRestriction_dict[*rstrCoarse], 1188 CeedBasis_dict[*basisCoarse], 1189 &opCoarse_, &opProlong_, &opRestrict_); 1190 1191 if (*err) return; 1192 while (CeedOperator_count + 2 >= CeedOperator_count_max) { 1193 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1194 } 1195 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1196 CeedOperator_dict[CeedOperator_count] = opCoarse_; 1197 *opCoarse = CeedOperator_count++; 1198 CeedOperator_dict[CeedOperator_count] = opProlong_; 1199 *opProlong = CeedOperator_count++; 1200 CeedOperator_dict[CeedOperator_count] = opRestrict_; 1201 *opRestrict = CeedOperator_count++; 1202 CeedOperator_n += 3; 1203 } 1204 1205 #define fCeedOperatorMultigridLevelCreateTensorH1 \ 1206 FORTRAN_NAME(ceedoperatormultigridlevelcreatetensorh1, CEEDOPERATORMULTIGRIDLEVELCREATETENSORH1) 1207 void fCeedOperatorMultigridLevelCreateTensorH1(int *opFine, int *pMultFine, 1208 int *rstrCoarse, int *basisCoarse, const CeedScalar *interpCtoF, 1209 int *opCoarse, int *opProlong, int *opRestrict, int *err) { 1210 // Operators 1211 CeedOperator opCoarse_, opProlong_, opRestrict_; 1212 1213 // C interface call 1214 *err = CeedOperatorMultigridLevelCreateTensorH1( 1215 CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], 1216 CeedElemRestriction_dict[*rstrCoarse], CeedBasis_dict[*basisCoarse], 1217 interpCtoF, &opCoarse_, &opProlong_, &opRestrict_); 1218 1219 if (*err) return; 1220 while (CeedOperator_count + 2 >= CeedOperator_count_max) { 1221 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1222 } 1223 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1224 CeedOperator_dict[CeedOperator_count] = opCoarse_; 1225 *opCoarse = CeedOperator_count++; 1226 CeedOperator_dict[CeedOperator_count] = opProlong_; 1227 *opProlong = CeedOperator_count++; 1228 CeedOperator_dict[CeedOperator_count] = opRestrict_; 1229 *opRestrict = CeedOperator_count++; 1230 CeedOperator_n += 3; 1231 } 1232 1233 #define fCeedOperatorMultigridLevelCreateH1 \ 1234 FORTRAN_NAME(ceedoperatormultigridlevelcreateh1, CEEDOPERATORMULTIGRIDLEVELCREATEH1) 1235 void fCeedOperatorMultigridLevelCreateH1(int *opFine, int *pMultFine, 1236 int *rstrCoarse, int *basisCoarse, const CeedScalar *interpCtoF, 1237 int *opCoarse, int *opProlong, int *opRestrict, int *err) { 1238 // Operators 1239 CeedOperator opCoarse_, opProlong_, opRestrict_; 1240 1241 // C interface call 1242 *err = CeedOperatorMultigridLevelCreateH1( 1243 CeedOperator_dict[*opFine], CeedVector_dict[*pMultFine], 1244 CeedElemRestriction_dict[*rstrCoarse], CeedBasis_dict[*basisCoarse], 1245 interpCtoF, &opCoarse_, &opProlong_, &opRestrict_); 1246 1247 if (*err) return; 1248 while (CeedOperator_count + 2 >= CeedOperator_count_max) { 1249 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1250 } 1251 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1252 CeedOperator_dict[CeedOperator_count] = opCoarse_; 1253 *opCoarse = CeedOperator_count++; 1254 CeedOperator_dict[CeedOperator_count] = opProlong_; 1255 *opProlong = CeedOperator_count++; 1256 CeedOperator_dict[CeedOperator_count] = opRestrict_; 1257 *opRestrict = CeedOperator_count++; 1258 CeedOperator_n += 3; 1259 } 1260 1261 #define fCeedOperatorView \ 1262 FORTRAN_NAME(ceedoperatorview,CEEDOPERATORVIEW) 1263 void fCeedOperatorView(int *op, int *err) { 1264 CeedOperator op_ = CeedOperator_dict[*op]; 1265 1266 *err = CeedOperatorView(op_, stdout); 1267 } 1268 1269 #define fCeedOperatorCreateFDMElementInverse \ 1270 FORTRAN_NAME(ceedoperatorcreatefdmelementinverse, CEEDOPERATORCREATEFDMELEMENTINVERSE) 1271 void fCeedOperatorCreateFDMElementInverse(int *op, int *fdminv, 1272 int *rqst, int *err) { 1273 // Operator 1274 if (CeedOperator_count == CeedOperator_count_max) { 1275 CeedOperator_count_max += CeedOperator_count_max/2 + 1; 1276 CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); 1277 } 1278 CeedOperator *fdminv_ = 1279 &CeedOperator_dict[CeedOperator_count]; 1280 1281 int createRequest = 1; 1282 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1283 if (*rqst == -1 || *rqst == -2) { 1284 createRequest = 0; 1285 } 1286 1287 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1288 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1289 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1290 } 1291 1292 CeedRequest *rqst_; 1293 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1294 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1295 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1296 1297 *err = CeedOperatorCreateFDMElementInverse(CeedOperator_dict[*op], 1298 fdminv_, rqst_); 1299 if (*err) return; 1300 if (createRequest) { 1301 *rqst = CeedRequest_count++; 1302 CeedRequest_n++; 1303 } 1304 1305 if (*err == 0) { 1306 *fdminv = CeedOperator_count++; 1307 CeedOperator_n++; 1308 } 1309 } 1310 1311 #define fCeedOperatorApply FORTRAN_NAME(ceedoperatorapply, CEEDOPERATORAPPLY) 1312 void fCeedOperatorApply(int *op, int *ustatevec, 1313 int *resvec, int *rqst, int *err) { 1314 CeedVector ustatevec_ = (*ustatevec == FORTRAN_NULL) ? 1315 NULL : (*ustatevec == FORTRAN_VECTOR_NONE ? 1316 CEED_VECTOR_NONE : CeedVector_dict[*ustatevec]); 1317 CeedVector resvec_ = (*resvec == FORTRAN_NULL) ? 1318 NULL : (*resvec == FORTRAN_VECTOR_NONE ? 1319 CEED_VECTOR_NONE : CeedVector_dict[*resvec]); 1320 1321 int createRequest = 1; 1322 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1323 if (*rqst == -1 || *rqst == -2) { 1324 createRequest = 0; 1325 } 1326 1327 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1328 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1329 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1330 } 1331 1332 CeedRequest *rqst_; 1333 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1334 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1335 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1336 1337 *err = CeedOperatorApply(CeedOperator_dict[*op], 1338 ustatevec_, resvec_, rqst_); 1339 if (*err) return; 1340 if (createRequest) { 1341 *rqst = CeedRequest_count++; 1342 CeedRequest_n++; 1343 } 1344 } 1345 1346 #define fCeedOperatorApplyAdd FORTRAN_NAME(ceedoperatorapplyadd, CEEDOPERATORAPPLYADD) 1347 void fCeedOperatorApplyAdd(int *op, int *ustatevec, 1348 int *resvec, int *rqst, int *err) { 1349 CeedVector ustatevec_ = *ustatevec == FORTRAN_NULL 1350 ? NULL : CeedVector_dict[*ustatevec]; 1351 CeedVector resvec_ = *resvec == FORTRAN_NULL 1352 ? NULL : CeedVector_dict[*resvec]; 1353 1354 int createRequest = 1; 1355 // Check if input is CEED_REQUEST_ORDERED(-2) or CEED_REQUEST_IMMEDIATE(-1) 1356 if (*rqst == -1 || *rqst == -2) { 1357 createRequest = 0; 1358 } 1359 1360 if (createRequest && CeedRequest_count == CeedRequest_count_max) { 1361 CeedRequest_count_max += CeedRequest_count_max/2 + 1; 1362 CeedRealloc(CeedRequest_count_max, &CeedRequest_dict); 1363 } 1364 1365 CeedRequest *rqst_; 1366 if (*rqst == -1) rqst_ = CEED_REQUEST_IMMEDIATE; 1367 else if (*rqst == -2) rqst_ = CEED_REQUEST_ORDERED; 1368 else rqst_ = &CeedRequest_dict[CeedRequest_count]; 1369 1370 *err = CeedOperatorApplyAdd(CeedOperator_dict[*op], 1371 ustatevec_, resvec_, rqst_); 1372 if (*err) return; 1373 if (createRequest) { 1374 *rqst = CeedRequest_count++; 1375 CeedRequest_n++; 1376 } 1377 } 1378 1379 #define fCeedOperatorApplyJacobian \ 1380 FORTRAN_NAME(ceedoperatorapplyjacobian, CEEDOPERATORAPPLYJACOBIAN) 1381 void fCeedOperatorApplyJacobian(int *op, int *qdatavec, int *ustatevec, 1382 int *dustatevec, int *dresvec, int *rqst, 1383 int *err) { 1384 // TODO Uncomment this when CeedOperatorApplyJacobian is implemented 1385 // *err = CeedOperatorApplyJacobian(CeedOperator_dict[*op], CeedVector_dict[*qdatavec], 1386 // CeedVector_dict[*ustatevec], CeedVector_dict[*dustatevec], 1387 // CeedVector_dict[*dresvec], &CeedRequest_dict[*rqst]); 1388 } 1389 1390 #define fCeedOperatorDestroy \ 1391 FORTRAN_NAME(ceedoperatordestroy, CEEDOPERATORDESTROY) 1392 void fCeedOperatorDestroy(int *op, int *err) { 1393 if (*op == FORTRAN_NULL) return; 1394 *err = CeedOperatorDestroy(&CeedOperator_dict[*op]); 1395 if (*err == 0) { 1396 *op = FORTRAN_NULL; 1397 CeedOperator_n--; 1398 if (CeedOperator_n == 0) { 1399 *err = CeedFree(&CeedOperator_dict); 1400 CeedOperator_count = 0; 1401 CeedOperator_count_max = 0; 1402 } 1403 } 1404 } 1405 1406 // ----------------------------------------------------------------------------- 1407