Date: 2016-07-24T17:02:56+00:00

Actual source code: dtfv.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      1: #include <petsc/private/petscfvimpl.h> /*I "petscfv.h" I*/
      2: #include <petsc/private/dmpleximpl.h> /* For CellRefiner */
      3: #include <petscds.h>

      5: PetscClassId PETSCLIMITER_CLASSID = 0;

      7: PetscFunctionList PetscLimiterList              = NULL;
      8: PetscBool         PetscLimiterRegisterAllCalled = PETSC_FALSE;

     10: PetscBool Limitercite = PETSC_FALSE;
     11: const char LimiterCitation[] = "@article{BergerAftosmisMurman2005,\n"
     12:                                "  title   = {Analysis of slope limiters on irregular grids},\n"
     13:                                "  journal = {AIAA paper},\n"
     14:                                "  author  = {Marsha Berger and Michael J. Aftosmis and Scott M. Murman},\n"
     15:                                "  volume  = {490},\n"
     16:                                "  year    = {2005}\n}\n";

     20: /*@C
     21:   PetscLimiterRegister - Adds a new PetscLimiter implementation

     23:   Not Collective

     25:   Input Parameters:
     26: + name        - The name of a new user-defined creation routine
     27: - create_func - The creation routine itself

     29:   Notes:
     30:   PetscLimiterRegister() may be called multiple times to add several user-defined PetscLimiters

     32:   Sample usage:
     33: .vb
     34:     PetscLimiterRegister("my_lim", MyPetscLimiterCreate);
     35: .ve

     37:   Then, your PetscLimiter type can be chosen with the procedural interface via
     38: .vb
     39:     PetscLimiterCreate(MPI_Comm, PetscLimiter *);
     40:     PetscLimiterSetType(PetscLimiter, "my_lim");
     41: .ve
     42:    or at runtime via the option
     43: .vb
     44:     -petsclimiter_type my_lim
     45: .ve

     47:   Level: advanced

     49: .keywords: PetscLimiter, register
     50: .seealso: PetscLimiterRegisterAll(), PetscLimiterRegisterDestroy()

     52: @*/
     53: PetscErrorCode PetscLimiterRegister(const char sname[], PetscErrorCode (*function)(PetscLimiter))
     54: {

     58:   PetscFunctionListAdd(&PetscLimiterList, sname, function);
     59:   return(0);
     60: }

     64: /*@C
     65:   PetscLimiterSetType - Builds a particular PetscLimiter

     67:   Collective on PetscLimiter

     69:   Input Parameters:
     70: + lim  - The PetscLimiter object
     71: - name - The kind of limiter

     73:   Options Database Key:
     74: . -petsclimiter_type <type> - Sets the PetscLimiter type; use -help for a list of available types

     76:   Level: intermediate

     78: .keywords: PetscLimiter, set, type
     79: .seealso: PetscLimiterGetType(), PetscLimiterCreate()
     80: @*/
     81: PetscErrorCode PetscLimiterSetType(PetscLimiter lim, PetscLimiterType name)
     82: {
     83:   PetscErrorCode (*r)(PetscLimiter);
     84:   PetscBool      match;

     89:   PetscObjectTypeCompare((PetscObject) lim, name, &match);
     90:   if (match) return(0);

     92:   PetscLimiterRegisterAll();
     93:   PetscFunctionListFind(PetscLimiterList, name, &r);
     94:   if (!r) SETERRQ1(PetscObjectComm((PetscObject) lim), PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown PetscLimiter type: %s", name);

     96:   if (lim->ops->destroy) {
     97:     (*lim->ops->destroy)(lim);
     98:     lim->ops->destroy = NULL;
     99:   }
    100:   (*r)(lim);
    101:   PetscObjectChangeTypeName((PetscObject) lim, name);
    102:   return(0);
    103: }

    107: /*@C
    108:   PetscLimiterGetType - Gets the PetscLimiter type name (as a string) from the object.

    110:   Not Collective

    112:   Input Parameter:
    113: . lim  - The PetscLimiter

    115:   Output Parameter:
    116: . name - The PetscLimiter type name

    118:   Level: intermediate

    120: .keywords: PetscLimiter, get, type, name
    121: .seealso: PetscLimiterSetType(), PetscLimiterCreate()
    122: @*/
    123: PetscErrorCode PetscLimiterGetType(PetscLimiter lim, PetscLimiterType *name)
    124: {

    130:   PetscLimiterRegisterAll();
    131:   *name = ((PetscObject) lim)->type_name;
    132:   return(0);
    133: }

    137: /*@C
    138:   PetscLimiterView - Views a PetscLimiter

    140:   Collective on PetscLimiter

    142:   Input Parameter:
    143: + lim - the PetscLimiter object to view
    144: - v   - the viewer

    146:   Level: developer

    148: .seealso: PetscLimiterDestroy()
    149: @*/
    150: PetscErrorCode PetscLimiterView(PetscLimiter lim, PetscViewer v)
    151: {

    156:   if (!v) {PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject) lim), &v);}
    157:   if (lim->ops->view) {(*lim->ops->view)(lim, v);}
    158:   return(0);
    159: }

    163: /*@
    164:   PetscLimiterSetFromOptions - sets parameters in a PetscLimiter from the options database

    166:   Collective on PetscLimiter

    168:   Input Parameter:
    169: . lim - the PetscLimiter object to set options for

    171:   Level: developer

    173: .seealso: PetscLimiterView()
    174: @*/
    175: PetscErrorCode PetscLimiterSetFromOptions(PetscLimiter lim)
    176: {
    177:   const char    *defaultType;
    178:   char           name[256];
    179:   PetscBool      flg;

    184:   if (!((PetscObject) lim)->type_name) defaultType = PETSCLIMITERSIN;
    185:   else                                 defaultType = ((PetscObject) lim)->type_name;
    186:   PetscLimiterRegisterAll();

    188:   PetscObjectOptionsBegin((PetscObject) lim);
    189:   PetscOptionsFList("-petsclimiter_type", "Finite volume slope limiter", "PetscLimiterSetType", PetscLimiterList, defaultType, name, 256, &flg);
    190:   if (flg) {
    191:     PetscLimiterSetType(lim, name);
    192:   } else if (!((PetscObject) lim)->type_name) {
    193:     PetscLimiterSetType(lim, defaultType);
    194:   }
    195:   if (lim->ops->setfromoptions) {(*lim->ops->setfromoptions)(lim);}
    196:   /* process any options handlers added with PetscObjectAddOptionsHandler() */
    197:   PetscObjectProcessOptionsHandlers(PetscOptionsObject,(PetscObject) lim);
    198:   PetscOptionsEnd();
    199:   PetscLimiterViewFromOptions(lim, NULL, "-petsclimiter_view");
    200:   return(0);
    201: }

    205: /*@C
    206:   PetscLimiterSetUp - Construct data structures for the PetscLimiter

    208:   Collective on PetscLimiter

    210:   Input Parameter:
    211: . lim - the PetscLimiter object to setup

    213:   Level: developer

    215: .seealso: PetscLimiterView(), PetscLimiterDestroy()
    216: @*/
    217: PetscErrorCode PetscLimiterSetUp(PetscLimiter lim)
    218: {

    223:   if (lim->ops->setup) {(*lim->ops->setup)(lim);}
    224:   return(0);
    225: }

    229: /*@
    230:   PetscLimiterDestroy - Destroys a PetscLimiter object

    232:   Collective on PetscLimiter

    234:   Input Parameter:
    235: . lim - the PetscLimiter object to destroy

    237:   Level: developer

    239: .seealso: PetscLimiterView()
    240: @*/
    241: PetscErrorCode PetscLimiterDestroy(PetscLimiter *lim)
    242: {

    246:   if (!*lim) return(0);

    249:   if (--((PetscObject)(*lim))->refct > 0) {*lim = 0; return(0);}
    250:   ((PetscObject) (*lim))->refct = 0;

    252:   if ((*lim)->ops->destroy) {(*(*lim)->ops->destroy)(*lim);}
    253:   PetscHeaderDestroy(lim);
    254:   return(0);
    255: }

    259: /*@
    260:   PetscLimiterCreate - Creates an empty PetscLimiter object. The type can then be set with PetscLimiterSetType().

    262:   Collective on MPI_Comm

    264:   Input Parameter:
    265: . comm - The communicator for the PetscLimiter object

    267:   Output Parameter:
    268: . lim - The PetscLimiter object

    270:   Level: beginner

    272: .seealso: PetscLimiterSetType(), PETSCLIMITERSIN
    273: @*/
    274: PetscErrorCode PetscLimiterCreate(MPI_Comm comm, PetscLimiter *lim)
    275: {
    276:   PetscLimiter   l;

    281:   PetscCitationsRegister(LimiterCitation,&Limitercite);
    282:   *lim = NULL;
    283:   PetscFVInitializePackage();

    285:   PetscHeaderCreate(l, PETSCLIMITER_CLASSID, "PetscLimiter", "Finite Volume Slope Limiter", "PetscLimiter", comm, PetscLimiterDestroy, PetscLimiterView);

    287:   *lim = l;
    288:   return(0);
    289: }

    293: /* Limiters given in symmetric form following Berger, Aftosmis, and Murman 2005
    294:  *
    295:  * The classical flux-limited formulation is psi(r) where
    296:  *
    297:  * r = (u[0] - u[-1]) / (u[1] - u[0])
    298:  *
    299:  * The second order TVD region is bounded by
    300:  *
    301:  * psi_minmod(r) = min(r,1)      and        psi_superbee(r) = min(2, 2r, max(1,r))
    302:  *
    303:  * where all limiters are implicitly clipped to be non-negative. A more convenient slope-limited form is psi(r) =
    304:  * phi(r)(r+1)/2 in which the reconstructed interface values are
    305:  *
    306:  * u(v) = u[0] + phi(r) (grad u)[0] v
    307:  *
    308:  * where v is the vector from centroid to quadrature point. In these variables, the usual limiters become
    309:  *
    310:  * phi_minmod(r) = 2 min(1/(1+r),r/(1+r))   phi_superbee(r) = 2 min(2/(1+r), 2r/(1+r), max(1,r)/(1+r))
    311:  *
    312:  * For a nicer symmetric formulation, rewrite in terms of
    313:  *
    314:  * f = (u[0] - u[-1]) / (u[1] - u[-1])
    315:  *
    316:  * where r(f) = f/(1-f). Not that r(1-f) = (1-f)/f = 1/r(f) so the symmetry condition
    317:  *
    318:  * phi(r) = phi(1/r)
    319:  *
    320:  * becomes
    321:  *
    322:  * w(f) = w(1-f).
    323:  *
    324:  * The limiters below implement this final form w(f). The reference methods are
    325:  *
    326:  * w_minmod(f) = 2 min(f,(1-f))             w_superbee(r) = 4 min((1-f), f)
    327:  * */
    328: PetscErrorCode PetscLimiterLimit(PetscLimiter lim, PetscReal flim, PetscReal *phi)
    329: {

    335:   (*lim->ops->limit)(lim, flim, phi);
    336:   return(0);
    337: }

    341: PetscErrorCode PetscLimiterDestroy_Sin(PetscLimiter lim)
    342: {
    343:   PetscLimiter_Sin *l = (PetscLimiter_Sin *) lim->data;
    344:   PetscErrorCode    ierr;

    347:   PetscFree(l);
    348:   return(0);
    349: }

    353: PetscErrorCode PetscLimiterView_Sin_Ascii(PetscLimiter lim, PetscViewer viewer)
    354: {
    355:   PetscViewerFormat format;
    356:   PetscErrorCode    ierr;

    359:   PetscViewerGetFormat(viewer, &format);
    360:   PetscViewerASCIIPrintf(viewer, "Sin Slope Limiter:\n");
    361:   return(0);
    362: }

    366: PetscErrorCode PetscLimiterView_Sin(PetscLimiter lim, PetscViewer viewer)
    367: {
    368:   PetscBool      iascii;

    374:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    375:   if (iascii) {PetscLimiterView_Sin_Ascii(lim, viewer);}
    376:   return(0);
    377: }

    381: PetscErrorCode PetscLimiterLimit_Sin(PetscLimiter lim, PetscReal f, PetscReal *phi)
    382: {
    384:   *phi = PetscSinReal(PETSC_PI*PetscMax(0, PetscMin(f, 1)));
    385:   return(0);
    386: }

    390: PetscErrorCode PetscLimiterInitialize_Sin(PetscLimiter lim)
    391: {
    393:   lim->ops->view    = PetscLimiterView_Sin;
    394:   lim->ops->destroy = PetscLimiterDestroy_Sin;
    395:   lim->ops->limit   = PetscLimiterLimit_Sin;
    396:   return(0);
    397: }

    399: /*MC
    400:   PETSCLIMITERSIN = "sin" - A PetscLimiter object

    402:   Level: intermediate

    404: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    405: M*/

    409: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_Sin(PetscLimiter lim)
    410: {
    411:   PetscLimiter_Sin *l;
    412:   PetscErrorCode    ierr;

    416:   PetscNewLog(lim, &l);
    417:   lim->data = l;

    419:   PetscLimiterInitialize_Sin(lim);
    420:   return(0);
    421: }

    425: PetscErrorCode PetscLimiterDestroy_Zero(PetscLimiter lim)
    426: {
    427:   PetscLimiter_Zero *l = (PetscLimiter_Zero *) lim->data;
    428:   PetscErrorCode    ierr;

    431:   PetscFree(l);
    432:   return(0);
    433: }

    437: PetscErrorCode PetscLimiterView_Zero_Ascii(PetscLimiter lim, PetscViewer viewer)
    438: {
    439:   PetscViewerFormat format;
    440:   PetscErrorCode    ierr;

    443:   PetscViewerGetFormat(viewer, &format);
    444:   PetscViewerASCIIPrintf(viewer, "Zero Slope Limiter:\n");
    445:   return(0);
    446: }

    450: PetscErrorCode PetscLimiterView_Zero(PetscLimiter lim, PetscViewer viewer)
    451: {
    452:   PetscBool      iascii;

    458:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    459:   if (iascii) {PetscLimiterView_Zero_Ascii(lim, viewer);}
    460:   return(0);
    461: }

    465: PetscErrorCode PetscLimiterLimit_Zero(PetscLimiter lim, PetscReal f, PetscReal *phi)
    466: {
    468:   *phi = 0.0;
    469:   return(0);
    470: }

    474: PetscErrorCode PetscLimiterInitialize_Zero(PetscLimiter lim)
    475: {
    477:   lim->ops->view    = PetscLimiterView_Zero;
    478:   lim->ops->destroy = PetscLimiterDestroy_Zero;
    479:   lim->ops->limit   = PetscLimiterLimit_Zero;
    480:   return(0);
    481: }

    483: /*MC
    484:   PETSCLIMITERZERO = "zero" - A PetscLimiter object

    486:   Level: intermediate

    488: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    489: M*/

    493: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_Zero(PetscLimiter lim)
    494: {
    495:   PetscLimiter_Zero *l;
    496:   PetscErrorCode     ierr;

    500:   PetscNewLog(lim, &l);
    501:   lim->data = l;

    503:   PetscLimiterInitialize_Zero(lim);
    504:   return(0);
    505: }

    509: PetscErrorCode PetscLimiterDestroy_None(PetscLimiter lim)
    510: {
    511:   PetscLimiter_None *l = (PetscLimiter_None *) lim->data;
    512:   PetscErrorCode    ierr;

    515:   PetscFree(l);
    516:   return(0);
    517: }

    521: PetscErrorCode PetscLimiterView_None_Ascii(PetscLimiter lim, PetscViewer viewer)
    522: {
    523:   PetscViewerFormat format;
    524:   PetscErrorCode    ierr;

    527:   PetscViewerGetFormat(viewer, &format);
    528:   PetscViewerASCIIPrintf(viewer, "None Slope Limiter:\n");
    529:   return(0);
    530: }

    534: PetscErrorCode PetscLimiterView_None(PetscLimiter lim, PetscViewer viewer)
    535: {
    536:   PetscBool      iascii;

    542:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    543:   if (iascii) {PetscLimiterView_None_Ascii(lim, viewer);}
    544:   return(0);
    545: }

    549: PetscErrorCode PetscLimiterLimit_None(PetscLimiter lim, PetscReal f, PetscReal *phi)
    550: {
    552:   *phi = 1.0;
    553:   return(0);
    554: }

    558: PetscErrorCode PetscLimiterInitialize_None(PetscLimiter lim)
    559: {
    561:   lim->ops->view    = PetscLimiterView_None;
    562:   lim->ops->destroy = PetscLimiterDestroy_None;
    563:   lim->ops->limit   = PetscLimiterLimit_None;
    564:   return(0);
    565: }

    567: /*MC
    568:   PETSCLIMITERNONE = "none" - A PetscLimiter object

    570:   Level: intermediate

    572: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    573: M*/

    577: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_None(PetscLimiter lim)
    578: {
    579:   PetscLimiter_None *l;
    580:   PetscErrorCode    ierr;

    584:   PetscNewLog(lim, &l);
    585:   lim->data = l;

    587:   PetscLimiterInitialize_None(lim);
    588:   return(0);
    589: }

    593: PetscErrorCode PetscLimiterDestroy_Minmod(PetscLimiter lim)
    594: {
    595:   PetscLimiter_Minmod *l = (PetscLimiter_Minmod *) lim->data;
    596:   PetscErrorCode    ierr;

    599:   PetscFree(l);
    600:   return(0);
    601: }

    605: PetscErrorCode PetscLimiterView_Minmod_Ascii(PetscLimiter lim, PetscViewer viewer)
    606: {
    607:   PetscViewerFormat format;
    608:   PetscErrorCode    ierr;

    611:   PetscViewerGetFormat(viewer, &format);
    612:   PetscViewerASCIIPrintf(viewer, "Minmod Slope Limiter:\n");
    613:   return(0);
    614: }

    618: PetscErrorCode PetscLimiterView_Minmod(PetscLimiter lim, PetscViewer viewer)
    619: {
    620:   PetscBool      iascii;

    626:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    627:   if (iascii) {PetscLimiterView_Minmod_Ascii(lim, viewer);}
    628:   return(0);
    629: }

    633: PetscErrorCode PetscLimiterLimit_Minmod(PetscLimiter lim, PetscReal f, PetscReal *phi)
    634: {
    636:   *phi = 2*PetscMax(0, PetscMin(f, 1-f));
    637:   return(0);
    638: }

    642: PetscErrorCode PetscLimiterInitialize_Minmod(PetscLimiter lim)
    643: {
    645:   lim->ops->view    = PetscLimiterView_Minmod;
    646:   lim->ops->destroy = PetscLimiterDestroy_Minmod;
    647:   lim->ops->limit   = PetscLimiterLimit_Minmod;
    648:   return(0);
    649: }

    651: /*MC
    652:   PETSCLIMITERMINMOD = "minmod" - A PetscLimiter object

    654:   Level: intermediate

    656: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    657: M*/

    661: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_Minmod(PetscLimiter lim)
    662: {
    663:   PetscLimiter_Minmod *l;
    664:   PetscErrorCode    ierr;

    668:   PetscNewLog(lim, &l);
    669:   lim->data = l;

    671:   PetscLimiterInitialize_Minmod(lim);
    672:   return(0);
    673: }

    677: PetscErrorCode PetscLimiterDestroy_VanLeer(PetscLimiter lim)
    678: {
    679:   PetscLimiter_VanLeer *l = (PetscLimiter_VanLeer *) lim->data;
    680:   PetscErrorCode    ierr;

    683:   PetscFree(l);
    684:   return(0);
    685: }

    689: PetscErrorCode PetscLimiterView_VanLeer_Ascii(PetscLimiter lim, PetscViewer viewer)
    690: {
    691:   PetscViewerFormat format;
    692:   PetscErrorCode    ierr;

    695:   PetscViewerGetFormat(viewer, &format);
    696:   PetscViewerASCIIPrintf(viewer, "Van Leer Slope Limiter:\n");
    697:   return(0);
    698: }

    702: PetscErrorCode PetscLimiterView_VanLeer(PetscLimiter lim, PetscViewer viewer)
    703: {
    704:   PetscBool      iascii;

    710:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    711:   if (iascii) {PetscLimiterView_VanLeer_Ascii(lim, viewer);}
    712:   return(0);
    713: }

    717: PetscErrorCode PetscLimiterLimit_VanLeer(PetscLimiter lim, PetscReal f, PetscReal *phi)
    718: {
    720:   *phi = PetscMax(0, 4*f*(1-f));
    721:   return(0);
    722: }

    726: PetscErrorCode PetscLimiterInitialize_VanLeer(PetscLimiter lim)
    727: {
    729:   lim->ops->view    = PetscLimiterView_VanLeer;
    730:   lim->ops->destroy = PetscLimiterDestroy_VanLeer;
    731:   lim->ops->limit   = PetscLimiterLimit_VanLeer;
    732:   return(0);
    733: }

    735: /*MC
    736:   PETSCLIMITERVANLEER = "vanleer" - A PetscLimiter object

    738:   Level: intermediate

    740: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    741: M*/

    745: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_VanLeer(PetscLimiter lim)
    746: {
    747:   PetscLimiter_VanLeer *l;
    748:   PetscErrorCode    ierr;

    752:   PetscNewLog(lim, &l);
    753:   lim->data = l;

    755:   PetscLimiterInitialize_VanLeer(lim);
    756:   return(0);
    757: }

    761: PetscErrorCode PetscLimiterDestroy_VanAlbada(PetscLimiter lim)
    762: {
    763:   PetscLimiter_VanAlbada *l = (PetscLimiter_VanAlbada *) lim->data;
    764:   PetscErrorCode    ierr;

    767:   PetscFree(l);
    768:   return(0);
    769: }

    773: PetscErrorCode PetscLimiterView_VanAlbada_Ascii(PetscLimiter lim, PetscViewer viewer)
    774: {
    775:   PetscViewerFormat format;
    776:   PetscErrorCode    ierr;

    779:   PetscViewerGetFormat(viewer, &format);
    780:   PetscViewerASCIIPrintf(viewer, "Van Albada Slope Limiter:\n");
    781:   return(0);
    782: }

    786: PetscErrorCode PetscLimiterView_VanAlbada(PetscLimiter lim, PetscViewer viewer)
    787: {
    788:   PetscBool      iascii;

    794:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    795:   if (iascii) {PetscLimiterView_VanAlbada_Ascii(lim, viewer);}
    796:   return(0);
    797: }

    801: PetscErrorCode PetscLimiterLimit_VanAlbada(PetscLimiter lim, PetscReal f, PetscReal *phi)
    802: {
    804:   *phi = PetscMax(0, 2*f*(1-f) / (PetscSqr(f) + PetscSqr(1-f)));
    805:   return(0);
    806: }

    810: PetscErrorCode PetscLimiterInitialize_VanAlbada(PetscLimiter lim)
    811: {
    813:   lim->ops->view    = PetscLimiterView_VanAlbada;
    814:   lim->ops->destroy = PetscLimiterDestroy_VanAlbada;
    815:   lim->ops->limit   = PetscLimiterLimit_VanAlbada;
    816:   return(0);
    817: }

    819: /*MC
    820:   PETSCLIMITERVANALBADA = "vanalbada" - A PetscLimiter object

    822:   Level: intermediate

    824: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    825: M*/

    829: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_VanAlbada(PetscLimiter lim)
    830: {
    831:   PetscLimiter_VanAlbada *l;
    832:   PetscErrorCode    ierr;

    836:   PetscNewLog(lim, &l);
    837:   lim->data = l;

    839:   PetscLimiterInitialize_VanAlbada(lim);
    840:   return(0);
    841: }

    845: PetscErrorCode PetscLimiterDestroy_Superbee(PetscLimiter lim)
    846: {
    847:   PetscLimiter_Superbee *l = (PetscLimiter_Superbee *) lim->data;
    848:   PetscErrorCode    ierr;

    851:   PetscFree(l);
    852:   return(0);
    853: }

    857: PetscErrorCode PetscLimiterView_Superbee_Ascii(PetscLimiter lim, PetscViewer viewer)
    858: {
    859:   PetscViewerFormat format;
    860:   PetscErrorCode    ierr;

    863:   PetscViewerGetFormat(viewer, &format);
    864:   PetscViewerASCIIPrintf(viewer, "Superbee Slope Limiter:\n");
    865:   return(0);
    866: }

    870: PetscErrorCode PetscLimiterView_Superbee(PetscLimiter lim, PetscViewer viewer)
    871: {
    872:   PetscBool      iascii;

    878:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    879:   if (iascii) {PetscLimiterView_Superbee_Ascii(lim, viewer);}
    880:   return(0);
    881: }

    885: PetscErrorCode PetscLimiterLimit_Superbee(PetscLimiter lim, PetscReal f, PetscReal *phi)
    886: {
    888:   *phi = 4*PetscMax(0, PetscMin(f, 1-f));
    889:   return(0);
    890: }

    894: PetscErrorCode PetscLimiterInitialize_Superbee(PetscLimiter lim)
    895: {
    897:   lim->ops->view    = PetscLimiterView_Superbee;
    898:   lim->ops->destroy = PetscLimiterDestroy_Superbee;
    899:   lim->ops->limit   = PetscLimiterLimit_Superbee;
    900:   return(0);
    901: }

    903: /*MC
    904:   PETSCLIMITERSUPERBEE = "superbee" - A PetscLimiter object

    906:   Level: intermediate

    908: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    909: M*/

    913: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_Superbee(PetscLimiter lim)
    914: {
    915:   PetscLimiter_Superbee *l;
    916:   PetscErrorCode    ierr;

    920:   PetscNewLog(lim, &l);
    921:   lim->data = l;

    923:   PetscLimiterInitialize_Superbee(lim);
    924:   return(0);
    925: }

    929: PetscErrorCode PetscLimiterDestroy_MC(PetscLimiter lim)
    930: {
    931:   PetscLimiter_MC *l = (PetscLimiter_MC *) lim->data;
    932:   PetscErrorCode    ierr;

    935:   PetscFree(l);
    936:   return(0);
    937: }

    941: PetscErrorCode PetscLimiterView_MC_Ascii(PetscLimiter lim, PetscViewer viewer)
    942: {
    943:   PetscViewerFormat format;
    944:   PetscErrorCode    ierr;

    947:   PetscViewerGetFormat(viewer, &format);
    948:   PetscViewerASCIIPrintf(viewer, "MC Slope Limiter:\n");
    949:   return(0);
    950: }

    954: PetscErrorCode PetscLimiterView_MC(PetscLimiter lim, PetscViewer viewer)
    955: {
    956:   PetscBool      iascii;

    962:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    963:   if (iascii) {PetscLimiterView_MC_Ascii(lim, viewer);}
    964:   return(0);
    965: }

    969: /* aka Barth-Jespersen */
    970: PetscErrorCode PetscLimiterLimit_MC(PetscLimiter lim, PetscReal f, PetscReal *phi)
    971: {
    973:   *phi = PetscMin(1, 4*PetscMax(0, PetscMin(f, 1-f)));
    974:   return(0);
    975: }

    979: PetscErrorCode PetscLimiterInitialize_MC(PetscLimiter lim)
    980: {
    982:   lim->ops->view    = PetscLimiterView_MC;
    983:   lim->ops->destroy = PetscLimiterDestroy_MC;
    984:   lim->ops->limit   = PetscLimiterLimit_MC;
    985:   return(0);
    986: }

    988: /*MC
    989:   PETSCLIMITERMC = "mc" - A PetscLimiter object

    991:   Level: intermediate

    993: .seealso: PetscLimiterType, PetscLimiterCreate(), PetscLimiterSetType()
    994: M*/

    998: PETSC_EXTERN PetscErrorCode PetscLimiterCreate_MC(PetscLimiter lim)
    999: {
    1000:   PetscLimiter_MC *l;
    1001:   PetscErrorCode    ierr;

    1005:   PetscNewLog(lim, &l);
    1006:   lim->data = l;

    1008:   PetscLimiterInitialize_MC(lim);
    1009:   return(0);
    1010: }

    1012: PetscClassId PETSCFV_CLASSID = 0;

    1014: PetscFunctionList PetscFVList              = NULL;
    1015: PetscBool         PetscFVRegisterAllCalled = PETSC_FALSE;

    1019: /*@C
    1020:   PetscFVRegister - Adds a new PetscFV implementation

    1022:   Not Collective

    1024:   Input Parameters:
    1025: + name        - The name of a new user-defined creation routine
    1026: - create_func - The creation routine itself

    1028:   Notes:
    1029:   PetscFVRegister() may be called multiple times to add several user-defined PetscFVs

    1031:   Sample usage:
    1032: .vb
    1033:     PetscFVRegister("my_fv", MyPetscFVCreate);
    1034: .ve

    1036:   Then, your PetscFV type can be chosen with the procedural interface via
    1037: .vb
    1038:     PetscFVCreate(MPI_Comm, PetscFV *);
    1039:     PetscFVSetType(PetscFV, "my_fv");
    1040: .ve
    1041:    or at runtime via the option
    1042: .vb
    1043:     -petscfv_type my_fv
    1044: .ve

    1046:   Level: advanced

    1048: .keywords: PetscFV, register
    1049: .seealso: PetscFVRegisterAll(), PetscFVRegisterDestroy()

    1051: @*/
    1052: PetscErrorCode PetscFVRegister(const char sname[], PetscErrorCode (*function)(PetscFV))
    1053: {

    1057:   PetscFunctionListAdd(&PetscFVList, sname, function);
    1058:   return(0);
    1059: }

    1063: /*@C
    1064:   PetscFVSetType - Builds a particular PetscFV

    1066:   Collective on PetscFV

    1068:   Input Parameters:
    1069: + fvm  - The PetscFV object
    1070: - name - The kind of FVM space

    1072:   Options Database Key:
    1073: . -petscfv_type <type> - Sets the PetscFV type; use -help for a list of available types

    1075:   Level: intermediate

    1077: .keywords: PetscFV, set, type
    1078: .seealso: PetscFVGetType(), PetscFVCreate()
    1079: @*/
    1080: PetscErrorCode PetscFVSetType(PetscFV fvm, PetscFVType name)
    1081: {
    1082:   PetscErrorCode (*r)(PetscFV);
    1083:   PetscBool      match;

    1088:   PetscObjectTypeCompare((PetscObject) fvm, name, &match);
    1089:   if (match) return(0);

    1091:   PetscFVRegisterAll();
    1092:   PetscFunctionListFind(PetscFVList, name, &r);
    1093:   if (!r) SETERRQ1(PetscObjectComm((PetscObject) fvm), PETSC_ERR_ARG_UNKNOWN_TYPE, "Unknown PetscFV type: %s", name);

    1095:   if (fvm->ops->destroy) {
    1096:     (*fvm->ops->destroy)(fvm);
    1097:     fvm->ops->destroy = NULL;
    1098:   }
    1099:   (*r)(fvm);
    1100:   PetscObjectChangeTypeName((PetscObject) fvm, name);
    1101:   return(0);
    1102: }

    1106: /*@C
    1107:   PetscFVGetType - Gets the PetscFV type name (as a string) from the object.

    1109:   Not Collective

    1111:   Input Parameter:
    1112: . fvm  - The PetscFV

    1114:   Output Parameter:
    1115: . name - The PetscFV type name

    1117:   Level: intermediate

    1119: .keywords: PetscFV, get, type, name
    1120: .seealso: PetscFVSetType(), PetscFVCreate()
    1121: @*/
    1122: PetscErrorCode PetscFVGetType(PetscFV fvm, PetscFVType *name)
    1123: {

    1129:   PetscFVRegisterAll();
    1130:   *name = ((PetscObject) fvm)->type_name;
    1131:   return(0);
    1132: }

    1136: /*@C
    1137:   PetscFVView - Views a PetscFV

    1139:   Collective on PetscFV

    1141:   Input Parameter:
    1142: + fvm - the PetscFV object to view
    1143: - v   - the viewer

    1145:   Level: developer

    1147: .seealso: PetscFVDestroy()
    1148: @*/
    1149: PetscErrorCode PetscFVView(PetscFV fvm, PetscViewer v)
    1150: {

    1155:   if (!v) {PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject) fvm), &v);}
    1156:   if (fvm->ops->view) {(*fvm->ops->view)(fvm, v);}
    1157:   return(0);
    1158: }

    1162: /*@
    1163:   PetscFVSetFromOptions - sets parameters in a PetscFV from the options database

    1165:   Collective on PetscFV

    1167:   Input Parameter:
    1168: . fvm - the PetscFV object to set options for

    1170:   Level: developer

    1172: .seealso: PetscFVView()
    1173: @*/
    1174: PetscErrorCode PetscFVSetFromOptions(PetscFV fvm)
    1175: {
    1176:   const char    *defaultType;
    1177:   char           name[256];
    1178:   PetscBool      flg;

    1183:   if (!((PetscObject) fvm)->type_name) defaultType = PETSCFVUPWIND;
    1184:   else                                 defaultType = ((PetscObject) fvm)->type_name;
    1185:   PetscFVRegisterAll();

    1187:   PetscObjectOptionsBegin((PetscObject) fvm);
    1188:   PetscOptionsFList("-petscfv_type", "Finite volume discretization", "PetscFVSetType", PetscFVList, defaultType, name, 256, &flg);
    1189:   if (flg) {
    1190:     PetscFVSetType(fvm, name);
    1191:   } else if (!((PetscObject) fvm)->type_name) {
    1192:     PetscFVSetType(fvm, defaultType);
    1193:   }
    1194:   if (fvm->ops->setfromoptions) {(*fvm->ops->setfromoptions)(fvm);}
    1195:   /* process any options handlers added with PetscObjectAddOptionsHandler() */
    1196:   PetscObjectProcessOptionsHandlers(PetscOptionsObject,(PetscObject) fvm);
    1197:   PetscLimiterSetFromOptions(fvm->limiter);
    1198:   PetscOptionsEnd();
    1199:   PetscFVViewFromOptions(fvm, NULL, "-petscfv_view");
    1200:   return(0);
    1201: }

    1205: /*@
    1206:   PetscFVSetUp - Construct data structures for the PetscFV

    1208:   Collective on PetscFV

    1210:   Input Parameter:
    1211: . fvm - the PetscFV object to setup

    1213:   Level: developer

    1215: .seealso: PetscFVView(), PetscFVDestroy()
    1216: @*/
    1217: PetscErrorCode PetscFVSetUp(PetscFV fvm)
    1218: {

    1223:   PetscLimiterSetUp(fvm->limiter);
    1224:   if (fvm->ops->setup) {(*fvm->ops->setup)(fvm);}
    1225:   return(0);
    1226: }

    1230: /*@
    1231:   PetscFVDestroy - Destroys a PetscFV object

    1233:   Collective on PetscFV

    1235:   Input Parameter:
    1236: . fvm - the PetscFV object to destroy

    1238:   Level: developer

    1240: .seealso: PetscFVView()
    1241: @*/
    1242: PetscErrorCode PetscFVDestroy(PetscFV *fvm)
    1243: {
    1244:   PetscInt       i;

    1248:   if (!*fvm) return(0);

    1251:   if (--((PetscObject)(*fvm))->refct > 0) {*fvm = 0; return(0);}
    1252:   ((PetscObject) (*fvm))->refct = 0;

    1254:   for (i = 0; i < (*fvm)->numComponents; i++) {
    1255:     PetscFree((*fvm)->componentNames[i]);
    1256:   }
    1257:   PetscFree((*fvm)->componentNames);
    1258:   PetscLimiterDestroy(&(*fvm)->limiter);
    1259:   PetscDualSpaceDestroy(&(*fvm)->dualSpace);
    1260:   PetscFree((*fvm)->fluxWork);
    1261:   PetscQuadratureDestroy(&(*fvm)->quadrature);
    1262:   PetscFVRestoreTabulation((*fvm), 0, NULL, &(*fvm)->B, &(*fvm)->D, NULL /*&(*fvm)->H*/);

    1264:   if ((*fvm)->ops->destroy) {(*(*fvm)->ops->destroy)(*fvm);}
    1265:   PetscHeaderDestroy(fvm);
    1266:   return(0);
    1267: }

    1271: /*@
    1272:   PetscFVCreate - Creates an empty PetscFV object. The type can then be set with PetscFVSetType().

    1274:   Collective on MPI_Comm

    1276:   Input Parameter:
    1277: . comm - The communicator for the PetscFV object

    1279:   Output Parameter:
    1280: . fvm - The PetscFV object

    1282:   Level: beginner

    1284: .seealso: PetscFVSetType(), PETSCFVUPWIND
    1285: @*/
    1286: PetscErrorCode PetscFVCreate(MPI_Comm comm, PetscFV *fvm)
    1287: {
    1288:   PetscFV        f;

    1293:   *fvm = NULL;
    1294:   PetscFVInitializePackage();

    1296:   PetscHeaderCreate(f, PETSCFV_CLASSID, "PetscFV", "Finite Volume", "PetscFV", comm, PetscFVDestroy, PetscFVView);
    1297:   PetscMemzero(f->ops, sizeof(struct _PetscFVOps));

    1299:   PetscLimiterCreate(comm, &f->limiter);
    1300:   f->numComponents    = 1;
    1301:   f->dim              = 0;
    1302:   f->computeGradients = PETSC_FALSE;
    1303:   f->fluxWork         = NULL;
    1304:   PetscCalloc1(f->numComponents,&f->componentNames);

    1306:   *fvm = f;
    1307:   return(0);
    1308: }

    1312: /*@
    1313:   PetscFVSetLimiter - Set the limiter object

    1315:   Logically collective on PetscFV

    1317:   Input Parameters:
    1318: + fvm - the PetscFV object
    1319: - lim - The PetscLimiter

    1321:   Level: developer

    1323: .seealso: PetscFVGetLimiter()
    1324: @*/
    1325: PetscErrorCode PetscFVSetLimiter(PetscFV fvm, PetscLimiter lim)
    1326: {

    1332:   PetscLimiterDestroy(&fvm->limiter);
    1333:   PetscObjectReference((PetscObject) lim);
    1334:   fvm->limiter = lim;
    1335:   return(0);
    1336: }

    1340: /*@
    1341:   PetscFVGetLimiter - Get the limiter object

    1343:   Not collective

    1345:   Input Parameter:
    1346: . fvm - the PetscFV object

    1348:   Output Parameter:
    1349: . lim - The PetscLimiter

    1351:   Level: developer

    1353: .seealso: PetscFVSetLimiter()
    1354: @*/
    1355: PetscErrorCode PetscFVGetLimiter(PetscFV fvm, PetscLimiter *lim)
    1356: {
    1360:   *lim = fvm->limiter;
    1361:   return(0);
    1362: }

    1366: /*@
    1367:   PetscFVSetNumComponents - Set the number of field components

    1369:   Logically collective on PetscFV

    1371:   Input Parameters:
    1372: + fvm - the PetscFV object
    1373: - comp - The number of components

    1375:   Level: developer

    1377: .seealso: PetscFVGetNumComponents()
    1378: @*/
    1379: PetscErrorCode PetscFVSetNumComponents(PetscFV fvm, PetscInt comp)
    1380: {

    1385:   if (fvm->numComponents != comp) {
    1386:     PetscInt i;

    1388:     for (i = 0; i < fvm->numComponents; i++) {
    1389:       PetscFree(fvm->componentNames[i]);
    1390:     }
    1391:     PetscFree(fvm->componentNames);
    1392:     PetscCalloc1(comp,&fvm->componentNames);
    1393:   }
    1394:   fvm->numComponents = comp;
    1395:   PetscFree(fvm->fluxWork);
    1396:   PetscMalloc1(comp, &fvm->fluxWork);
    1397:   return(0);
    1398: }

    1402: /*@
    1403:   PetscFVGetNumComponents - Get the number of field components

    1405:   Not collective

    1407:   Input Parameter:
    1408: . fvm - the PetscFV object

    1410:   Output Parameter:
    1411: , comp - The number of components

    1413:   Level: developer

    1415: .seealso: PetscFVSetNumComponents()
    1416: @*/
    1417: PetscErrorCode PetscFVGetNumComponents(PetscFV fvm, PetscInt *comp)
    1418: {
    1422:   *comp = fvm->numComponents;
    1423:   return(0);
    1424: }

    1428: /*@C
    1429:   PetscFVSetComponentName - Set the name of a component (used in output and viewing)

    1431:   Logically collective on PetscFV
    1432:   Input Parameters:
    1433: + fvm - the PetscFV object
    1434: . comp - the component number
    1435: - name - the component name

    1437:   Level: developer

    1439: .seealso: PetscFVGetComponentName()
    1440: @*/
    1441: PetscErrorCode PetscFVSetComponentName(PetscFV fvm, PetscInt comp, const char *name)
    1442: {

    1446:   PetscFree(fvm->componentNames[comp]);
    1447:   PetscStrallocpy(name,&fvm->componentNames[comp]);
    1448:   return(0);
    1449: }

    1453: /*@C
    1454:   PetscFVGetComponentName - Get the name of a component (used in output and viewing)

    1456:   Logically collective on PetscFV
    1457:   Input Parameters:
    1458: + fvm - the PetscFV object
    1459: - comp - the component number

    1461:   Output Parameter:
    1462: . name - the component name

    1464:   Level: developer

    1466: .seealso: PetscFVSetComponentName()
    1467: @*/
    1468: PetscErrorCode PetscFVGetComponentName(PetscFV fvm, PetscInt comp, const char **name)
    1469: {
    1471:   *name = fvm->componentNames[comp];
    1472:   return(0);
    1473: }

    1477: /*@
    1478:   PetscFVSetSpatialDimension - Set the spatial dimension

    1480:   Logically collective on PetscFV

    1482:   Input Parameters:
    1483: + fvm - the PetscFV object
    1484: - dim - The spatial dimension

    1486:   Level: developer

    1488: .seealso: PetscFVGetSpatialDimension()
    1489: @*/
    1490: PetscErrorCode PetscFVSetSpatialDimension(PetscFV fvm, PetscInt dim)
    1491: {
    1494:   fvm->dim = dim;
    1495:   return(0);
    1496: }

    1500: /*@
    1501:   PetscFVGetSpatialDimension - Get the spatial dimension

    1503:   Logically collective on PetscFV

    1505:   Input Parameter:
    1506: . fvm - the PetscFV object

    1508:   Output Parameter:
    1509: . dim - The spatial dimension

    1511:   Level: developer

    1513: .seealso: PetscFVSetSpatialDimension()
    1514: @*/
    1515: PetscErrorCode PetscFVGetSpatialDimension(PetscFV fvm, PetscInt *dim)
    1516: {
    1520:   *dim = fvm->dim;
    1521:   return(0);
    1522: }

    1526: /*@
    1527:   PetscFVSetComputeGradients - Toggle computation of cell gradients

    1529:   Logically collective on PetscFV

    1531:   Input Parameters:
    1532: + fvm - the PetscFV object
    1533: - computeGradients - Flag to compute cell gradients

    1535:   Level: developer

    1537: .seealso: PetscFVGetComputeGradients()
    1538: @*/
    1539: PetscErrorCode PetscFVSetComputeGradients(PetscFV fvm, PetscBool computeGradients)
    1540: {
    1543:   fvm->computeGradients = computeGradients;
    1544:   return(0);
    1545: }

    1549: /*@
    1550:   PetscFVGetComputeGradients - Return flag for computation of cell gradients

    1552:   Not collective

    1554:   Input Parameter:
    1555: . fvm - the PetscFV object

    1557:   Output Parameter:
    1558: . computeGradients - Flag to compute cell gradients

    1560:   Level: developer

    1562: .seealso: PetscFVSetComputeGradients()
    1563: @*/
    1564: PetscErrorCode PetscFVGetComputeGradients(PetscFV fvm, PetscBool *computeGradients)
    1565: {
    1569:   *computeGradients = fvm->computeGradients;
    1570:   return(0);
    1571: }

    1575: /*@
    1576:   PetscFVSetQuadrature - Set the quadrature object

    1578:   Logically collective on PetscFV

    1580:   Input Parameters:
    1581: + fvm - the PetscFV object
    1582: - q - The PetscQuadrature

    1584:   Level: developer

    1586: .seealso: PetscFVGetQuadrature()
    1587: @*/
    1588: PetscErrorCode PetscFVSetQuadrature(PetscFV fvm, PetscQuadrature q)
    1589: {

    1594:   PetscQuadratureDestroy(&fvm->quadrature);
    1595:   PetscObjectReference((PetscObject) q);
    1596:   fvm->quadrature = q;
    1597:   return(0);
    1598: }

    1602: /*@
    1603:   PetscFVGetQuadrature - Get the quadrature object

    1605:   Not collective

    1607:   Input Parameter:
    1608: . fvm - the PetscFV object

    1610:   Output Parameter:
    1611: . lim - The PetscQuadrature

    1613:   Level: developer

    1615: .seealso: PetscFVSetQuadrature()
    1616: @*/
    1617: PetscErrorCode PetscFVGetQuadrature(PetscFV fvm, PetscQuadrature *q)
    1618: {
    1622:   if (!fvm->quadrature) {
    1623:     /* Create default 1-point quadrature */
    1624:     PetscReal     *points, *weights;

    1627:     PetscQuadratureCreate(PETSC_COMM_SELF, &fvm->quadrature);
    1628:     PetscCalloc1(fvm->dim, &points);
    1629:     PetscMalloc1(1, &weights);
    1630:     weights[0] = 1.0;
    1631:     PetscQuadratureSetData(fvm->quadrature, fvm->dim, 1, points, weights);
    1632:   }
    1633:   *q = fvm->quadrature;
    1634:   return(0);
    1635: }

    1639: /*@
    1640:   PetscFVGetDualSpace - Returns the PetscDualSpace used to define the inner product

    1642:   Not collective

    1644:   Input Parameter:
    1645: . fvm - The PetscFV object

    1647:   Output Parameter:
    1648: . sp - The PetscDualSpace object

    1650:   Note: A simple dual space is provided automatically, and the user typically will not need to override it.

    1652:   Level: developer

    1654: .seealso: PetscFVCreate()
    1655: @*/
    1656: PetscErrorCode PetscFVGetDualSpace(PetscFV fvm, PetscDualSpace *sp)
    1657: {
    1661:   if (!fvm->dualSpace) {
    1662:     DM              K;
    1663:     PetscQuadrature q;
    1664:     PetscInt        dim;
    1665:     PetscErrorCode  ierr;

    1667:     PetscFVGetSpatialDimension(fvm, &dim);
    1668:     PetscFVGetQuadrature(fvm, &q);
    1669:     PetscDualSpaceCreate(PetscObjectComm((PetscObject) fvm), &fvm->dualSpace);
    1670:     PetscDualSpaceSetType(fvm->dualSpace, PETSCDUALSPACESIMPLE);
    1671:     PetscDualSpaceCreateReferenceCell(fvm->dualSpace, dim, PETSC_FALSE, &K); /* TODO: The reference cell type should be held by the discretization object */
    1672:     PetscDualSpaceSetDM(fvm->dualSpace, K);
    1673:     DMDestroy(&K);
    1674:     PetscDualSpaceSimpleSetDimension(fvm->dualSpace, 1);
    1675:     PetscDualSpaceSimpleSetFunctional(fvm->dualSpace, 0, q);
    1676:   }
    1677:   *sp = fvm->dualSpace;
    1678:   return(0);
    1679: }

    1683: /*@
    1684:   PetscFVSetDualSpace - Sets the PetscDualSpace used to define the inner product

    1686:   Not collective

    1688:   Input Parameters:
    1689: + fvm - The PetscFV object
    1690: - sp  - The PetscDualSpace object

    1692:   Level: intermediate

    1694:   Note: A simple dual space is provided automatically, and the user typically will not need to override it.

    1696: .seealso: PetscFVCreate()
    1697: @*/
    1698: PetscErrorCode PetscFVSetDualSpace(PetscFV fvm, PetscDualSpace sp)
    1699: {

    1705:   PetscDualSpaceDestroy(&fvm->dualSpace);
    1706:   fvm->dualSpace = sp;
    1707:   PetscObjectReference((PetscObject) fvm->dualSpace);
    1708:   return(0);
    1709: }

    1713: PetscErrorCode PetscFVGetDefaultTabulation(PetscFV fvm, PetscReal **B, PetscReal **D, PetscReal **H)
    1714: {
    1715:   PetscInt         npoints;
    1716:   const PetscReal *points;
    1717:   PetscErrorCode   ierr;

    1724:   PetscQuadratureGetData(fvm->quadrature, NULL, &npoints, &points, NULL);
    1725:   if (!fvm->B) {PetscFVGetTabulation(fvm, npoints, points, &fvm->B, &fvm->D, NULL/*&fvm->H*/);}
    1726:   if (B) *B = fvm->B;
    1727:   if (D) *D = fvm->D;
    1728:   if (H) *H = fvm->H;
    1729:   return(0);
    1730: }

    1734: PetscErrorCode PetscFVGetTabulation(PetscFV fvm, PetscInt npoints, const PetscReal points[], PetscReal **B, PetscReal **D, PetscReal **H)
    1735: {
    1736:   PetscInt         pdim = 1; /* Dimension of approximation space P */
    1737:   PetscInt         dim;      /* Spatial dimension */
    1738:   PetscInt         comp;     /* Field components */
    1739:   PetscInt         p, d, c, e;
    1740:   PetscErrorCode   ierr;

    1748:   PetscFVGetSpatialDimension(fvm, &dim);
    1749:   PetscFVGetNumComponents(fvm, &comp);
    1750:   if (B) {PetscMalloc1(npoints*pdim*comp, B);}
    1751:   if (D) {PetscMalloc1(npoints*pdim*comp*dim, D);}
    1752:   if (H) {PetscMalloc1(npoints*pdim*comp*dim*dim, H);}
    1753:   if (B) {for (p = 0; p < npoints; ++p) for (d = 0; d < pdim; ++d) for (c = 0; c < comp; ++c) (*B)[(p*pdim + d)*comp + c] = 1.0;}
    1754:   if (D) {for (p = 0; p < npoints; ++p) for (d = 0; d < pdim; ++d) for (c = 0; c < comp; ++c) for (e = 0; e < dim; ++e) (*D)[((p*pdim + d)*comp + c)*dim + e] = 0.0;}
    1755:   if (H) {for (p = 0; p < npoints; ++p) for (d = 0; d < pdim; ++d) for (c = 0; c < comp; ++c) for (e = 0; e < dim*dim; ++e) (*H)[((p*pdim + d)*comp + c)*dim*dim + e] = 0.0;}
    1756:   return(0);
    1757: }

    1761: PetscErrorCode PetscFVRestoreTabulation(PetscFV fvm, PetscInt npoints, const PetscReal points[], PetscReal **B, PetscReal **D, PetscReal **H)
    1762: {

    1767:   if (B && *B) {PetscFree(*B);}
    1768:   if (D && *D) {PetscFree(*D);}
    1769:   if (H && *H) {PetscFree(*H);}
    1770:   return(0);
    1771: }

    1775: /*@C
    1776:   PetscFVComputeGradient - Compute the gradient reconstruction matrix for a given cell

    1778:   Input Parameters:
    1779: + fvm      - The PetscFV object
    1780: . numFaces - The number of cell faces which are not constrained
    1781: . dx       - The vector from the cell centroid to the neighboring cell centroid for each face

    1783:   Level: developer

    1785: .seealso: PetscFVCreate()
    1786: @*/
    1787: PetscErrorCode PetscFVComputeGradient(PetscFV fvm, PetscInt numFaces, PetscScalar dx[], PetscScalar grad[])
    1788: {

    1793:   if (fvm->ops->computegradient) {(*fvm->ops->computegradient)(fvm, numFaces, dx, grad);}
    1794:   return(0);
    1795: }

    1799: /*C
    1800:   PetscFVIntegrateRHSFunction - Produce the cell residual vector for a chunk of elements by quadrature integration

    1802:   Not collective

    1804:   Input Parameters:
    1805: + fvm          - The PetscFV object for the field being integrated
    1806: . prob         - The PetscDS specifing the discretizations and continuum functions
    1807: . field        - The field being integrated
    1808: . Nf           - The number of faces in the chunk
    1809: . fgeom        - The face geometry for each face in the chunk
    1810: . neighborVol  - The volume for each pair of cells in the chunk
    1811: . uL           - The state from the cell on the left
    1812: - uR           - The state from the cell on the right

    1814:   Output Parameter
    1815: + fluxL        - the left fluxes for each face
    1816: - fluxR        - the right fluxes for each face
    1817: */
    1818: PetscErrorCode PetscFVIntegrateRHSFunction(PetscFV fvm, PetscDS prob, PetscInt field, PetscInt Nf, PetscFVFaceGeom *fgeom, PetscReal *neighborVol,
    1819:                                            PetscScalar uL[], PetscScalar uR[], PetscScalar fluxL[], PetscScalar fluxR[])
    1820: {

    1825:   if (fvm->ops->integraterhsfunction) {(*fvm->ops->integraterhsfunction)(fvm, prob, field, Nf, fgeom, neighborVol, uL, uR, fluxL, fluxR);}
    1826:   return(0);
    1827: }

    1831: /*@
    1832:   PetscFVRefine - Create a "refined" PetscFV object that refines the reference cell into smaller copies. This is typically used
    1833:   to precondition a higher order method with a lower order method on a refined mesh having the same number of dofs (but more
    1834:   sparsity). It is also used to create an interpolation between regularly refined meshes.

    1836:   Input Parameter:
    1837: . fv - The initial PetscFV

    1839:   Output Parameter:
    1840: . fvRef - The refined PetscFV

    1842:   Level: developer

    1844: .seealso: PetscFVType, PetscFVCreate(), PetscFVSetType()
    1845: @*/
    1846: PetscErrorCode PetscFVRefine(PetscFV fv, PetscFV *fvRef)
    1847: {
    1848:   PetscDualSpace   Q, Qref;
    1849:   DM               K, Kref;
    1850:   PetscQuadrature  q, qref;
    1851:   CellRefiner      cellRefiner;
    1852:   PetscReal       *v0;
    1853:   PetscReal       *jac, *invjac;
    1854:   PetscInt         numComp, numSubelements, s;
    1855:   PetscErrorCode   ierr;

    1858:   PetscFVGetDualSpace(fv, &Q);
    1859:   PetscFVGetQuadrature(fv, &q);
    1860:   PetscDualSpaceGetDM(Q, &K);
    1861:   /* Create dual space */
    1862:   PetscDualSpaceDuplicate(Q, &Qref);
    1863:   DMRefine(K, PetscObjectComm((PetscObject) fv), &Kref);
    1864:   PetscDualSpaceSetDM(Qref, Kref);
    1865:   DMDestroy(&Kref);
    1866:   PetscDualSpaceSetUp(Qref);
    1867:   /* Create volume */
    1868:   PetscFVCreate(PetscObjectComm((PetscObject) fv), fvRef);
    1869:   PetscFVSetDualSpace(*fvRef, Qref);
    1870:   PetscFVGetNumComponents(fv,    &numComp);
    1871:   PetscFVSetNumComponents(*fvRef, numComp);
    1872:   PetscFVSetUp(*fvRef);
    1873:   /* Create quadrature */
    1874:   DMPlexGetCellRefiner_Internal(K, &cellRefiner);
    1875:   CellRefinerGetAffineTransforms_Internal(cellRefiner, &numSubelements, &v0, &jac, &invjac);
    1876:   PetscQuadratureExpandComposite(q, numSubelements, v0, jac, &qref);
    1877:   PetscDualSpaceSimpleSetDimension(Qref, numSubelements);
    1878:   for (s = 0; s < numSubelements; ++s) {
    1879:     PetscQuadrature  qs;
    1880:     const PetscReal *points, *weights;
    1881:     PetscReal       *p, *w;
    1882:     PetscInt         dim, npoints, np;

    1884:     PetscQuadratureCreate(PETSC_COMM_SELF, &qs);
    1885:     PetscQuadratureGetData(q, &dim, &npoints, &points, &weights);
    1886:     np   = npoints/numSubelements;
    1887:     PetscMalloc1(np*dim,&p);
    1888:     PetscMalloc1(np,&w);
    1889:     PetscMemcpy(p, &points[s*np*dim], np*dim * sizeof(PetscReal));
    1890:     PetscMemcpy(w, &weights[s*np],    np     * sizeof(PetscReal));
    1891:     PetscQuadratureSetData(qs, dim, np, p, w);
    1892:     PetscDualSpaceSimpleSetFunctional(Qref, s, qs);
    1893:     PetscQuadratureDestroy(&qs);
    1894:   }
    1895:   CellRefinerRestoreAffineTransforms_Internal(cellRefiner, &numSubelements, &v0, &jac, &invjac);
    1896:   PetscFVSetQuadrature(*fvRef, qref);
    1897:   PetscQuadratureDestroy(&qref);
    1898:   PetscDualSpaceDestroy(&Qref);
    1899:   return(0);
    1900: }

    1904: PetscErrorCode PetscFVDestroy_Upwind(PetscFV fvm)
    1905: {
    1906:   PetscFV_Upwind *b = (PetscFV_Upwind *) fvm->data;

    1910:   PetscFree(b);
    1911:   return(0);
    1912: }

    1916: PetscErrorCode PetscFVView_Upwind_Ascii(PetscFV fv, PetscViewer viewer)
    1917: {
    1918:   PetscInt          Nc, c;
    1919:   PetscViewerFormat format;
    1920:   PetscErrorCode    ierr;

    1923:   PetscFVGetNumComponents(fv, &Nc);
    1924:   PetscViewerGetFormat(viewer, &format);
    1925:   PetscViewerASCIIPrintf(viewer, "Upwind Finite Volume:\n");
    1926:   PetscViewerASCIIPrintf(viewer, "  num components: %d\n", Nc);
    1927:   for (c = 0; c < Nc; c++) {
    1928:     if (fv->componentNames[c]) {
    1929:       PetscViewerASCIIPrintf(viewer, "    component %d: %s\n", c, fv->componentNames[c]);
    1930:     }
    1931:   }
    1932:   return(0);
    1933: }

    1937: PetscErrorCode PetscFVView_Upwind(PetscFV fv, PetscViewer viewer)
    1938: {
    1939:   PetscBool      iascii;

    1945:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    1946:   if (iascii) {PetscFVView_Upwind_Ascii(fv, viewer);}
    1947:   return(0);
    1948: }

    1952: PetscErrorCode PetscFVSetUp_Upwind(PetscFV fvm)
    1953: {
    1955:   return(0);
    1956: }

    1960: /*
    1961:   neighborVol[f*2+0] contains the left  geom
    1962:   neighborVol[f*2+1] contains the right geom
    1963: */
    1964: PetscErrorCode PetscFVIntegrateRHSFunction_Upwind(PetscFV fvm, PetscDS prob, PetscInt field, PetscInt Nf, PetscFVFaceGeom *fgeom, PetscReal *neighborVol,
    1965:                                                   PetscScalar uL[], PetscScalar uR[], PetscScalar fluxL[], PetscScalar fluxR[])
    1966: {
    1967:   void         (*riemann)(PetscInt, PetscInt, const PetscReal x[], const PetscReal n[], const PetscScalar uL[], const PetscScalar uR[], PetscScalar flux[], void *ctx);
    1968:   void          *rctx;
    1969:   PetscScalar   *flux = fvm->fluxWork;
    1970:   PetscInt       dim, pdim, totDim, Nc, off, f, d;

    1974:   PetscDSGetTotalComponents(prob, &Nc);
    1975:   PetscDSGetTotalDimension(prob, &totDim);
    1976:   PetscDSGetFieldOffset(prob, field, &off);
    1977:   PetscDSGetRiemannSolver(prob, field, &riemann);
    1978:   PetscDSGetContext(prob, field, &rctx);
    1979:   PetscFVGetSpatialDimension(fvm, &dim);
    1980:   PetscFVGetNumComponents(fvm, &pdim);
    1981:   for (f = 0; f < Nf; ++f) {
    1982:     (*riemann)(dim, pdim, fgeom[f].centroid, fgeom[f].normal, &uL[f*Nc], &uR[f*Nc], flux, rctx);
    1983:     for (d = 0; d < pdim; ++d) {
    1984:       fluxL[f*totDim+off+d] = flux[d] / neighborVol[f*2+0];
    1985:       fluxR[f*totDim+off+d] = flux[d] / neighborVol[f*2+1];
    1986:     }
    1987:   }
    1988:   return(0);
    1989: }

    1993: PetscErrorCode PetscFVInitialize_Upwind(PetscFV fvm)
    1994: {
    1996:   fvm->ops->setfromoptions          = NULL;
    1997:   fvm->ops->setup                   = PetscFVSetUp_Upwind;
    1998:   fvm->ops->view                    = PetscFVView_Upwind;
    1999:   fvm->ops->destroy                 = PetscFVDestroy_Upwind;
    2000:   fvm->ops->integraterhsfunction    = PetscFVIntegrateRHSFunction_Upwind;
    2001:   return(0);
    2002: }

    2004: /*MC
    2005:   PETSCFVUPWIND = "upwind" - A PetscFV object

    2007:   Level: intermediate

    2009: .seealso: PetscFVType, PetscFVCreate(), PetscFVSetType()
    2010: M*/

    2014: PETSC_EXTERN PetscErrorCode PetscFVCreate_Upwind(PetscFV fvm)
    2015: {
    2016:   PetscFV_Upwind *b;
    2017:   PetscErrorCode  ierr;

    2021:   PetscNewLog(fvm,&b);
    2022:   fvm->data = b;

    2024:   PetscFVInitialize_Upwind(fvm);
    2025:   return(0);
    2026: }

    2028: #include <petscblaslapack.h>

    2032: PetscErrorCode PetscFVDestroy_LeastSquares(PetscFV fvm)
    2033: {
    2034:   PetscFV_LeastSquares *ls = (PetscFV_LeastSquares *) fvm->data;
    2035:   PetscErrorCode        ierr;

    2038:   PetscObjectComposeFunction((PetscObject) fvm, "PetscFVLeastSquaresSetMaxFaces_C", NULL);
    2039:   PetscFree4(ls->B, ls->Binv, ls->tau, ls->work);
    2040:   PetscFree(ls);
    2041:   return(0);
    2042: }

    2046: PetscErrorCode PetscFVView_LeastSquares_Ascii(PetscFV fv, PetscViewer viewer)
    2047: {
    2048:   PetscInt          Nc, c;
    2049:   PetscViewerFormat format;
    2050:   PetscErrorCode    ierr;

    2053:   PetscFVGetNumComponents(fv, &Nc);
    2054:   PetscViewerGetFormat(viewer, &format);
    2055:   PetscViewerASCIIPrintf(viewer, "Finite Volume with Least Squares Reconstruction:\n");
    2056:   PetscViewerASCIIPrintf(viewer, "  num components: %d\n", Nc);
    2057:   for (c = 0; c < Nc; c++) {
    2058:     if (fv->componentNames[c]) {
    2059:       PetscViewerASCIIPrintf(viewer, "    component %d: %s\n", c, fv->componentNames[c]);
    2060:     }
    2061:   }
    2062:   return(0);
    2063: }

    2067: PetscErrorCode PetscFVView_LeastSquares(PetscFV fv, PetscViewer viewer)
    2068: {
    2069:   PetscBool      iascii;

    2075:   PetscObjectTypeCompare((PetscObject) viewer, PETSCVIEWERASCII, &iascii);
    2076:   if (iascii) {PetscFVView_LeastSquares_Ascii(fv, viewer);}
    2077:   return(0);
    2078: }

    2082: PetscErrorCode PetscFVSetUp_LeastSquares(PetscFV fvm)
    2083: {
    2085:   return(0);
    2086: }

    2090: /* Overwrites A. Can only handle full-rank problems with m>=n */
    2091: static PetscErrorCode PetscFVLeastSquaresPseudoInverse_Static(PetscInt m,PetscInt mstride,PetscInt n,PetscScalar *A,PetscScalar *Ainv,PetscScalar *tau,PetscInt worksize,PetscScalar *work)
    2092: {
    2093:   PetscBool      debug = PETSC_FALSE;
    2095:   PetscBLASInt   M,N,K,lda,ldb,ldwork,info;
    2096:   PetscScalar    *R,*Q,*Aback,Alpha;

    2099:   if (debug) {
    2100:     PetscMalloc1(m*n,&Aback);
    2101:     PetscMemcpy(Aback,A,m*n*sizeof(PetscScalar));
    2102:   }

    2104:   PetscBLASIntCast(m,&M);
    2105:   PetscBLASIntCast(n,&N);
    2106:   PetscBLASIntCast(mstride,&lda);
    2107:   PetscBLASIntCast(worksize,&ldwork);
    2108:   PetscFPTrapPush(PETSC_FP_TRAP_OFF);
    2109:   LAPACKgeqrf_(&M,&N,A,&lda,tau,work,&ldwork,&info);
    2110:   PetscFPTrapPop();
    2111:   if (info) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"xGEQRF error");
    2112:   R = A; /* Upper triangular part of A now contains R, the rest contains the elementary reflectors */

    2114:   /* Extract an explicit representation of Q */
    2115:   Q    = Ainv;
    2116:   PetscMemcpy(Q,A,mstride*n*sizeof(PetscScalar));
    2117:   K    = N;                     /* full rank */
    2118:   LAPACKungqr_(&M,&N,&K,Q,&lda,tau,work,&ldwork,&info);
    2119:   if (info) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"xORGQR/xUNGQR error");

    2121:   /* Compute A^{-T} = (R^{-1} Q^T)^T = Q R^{-T} */
    2122:   Alpha = 1.0;
    2123:   ldb   = lda;
    2124:   BLAStrsm_("Right","Upper","ConjugateTranspose","NotUnitTriangular",&M,&N,&Alpha,R,&lda,Q,&ldb);
    2125:   /* Ainv is Q, overwritten with inverse */

    2127:   if (debug) {                      /* Check that pseudo-inverse worked */
    2128:     PetscScalar  Beta = 0.0;
    2129:     PetscBLASInt ldc;
    2130:     K   = N;
    2131:     ldc = N;
    2132:     BLASgemm_("ConjugateTranspose","Normal",&N,&K,&M,&Alpha,Ainv,&lda,Aback,&ldb,&Beta,work,&ldc);
    2133:     PetscScalarView(n*n,work,PETSC_VIEWER_STDOUT_SELF);
    2134:     PetscFree(Aback);
    2135:   }
    2136:   return(0);
    2137: }

    2141: /* Overwrites A. Can handle degenerate problems and m<n. */
    2142: static PetscErrorCode PetscFVLeastSquaresPseudoInverseSVD_Static(PetscInt m,PetscInt mstride,PetscInt n,PetscScalar *A,PetscScalar *Ainv,PetscScalar *tau,PetscInt worksize,PetscScalar *work)
    2143: {
    2144:   PetscBool      debug = PETSC_FALSE;
    2145:   PetscScalar   *Brhs, *Aback;
    2146:   PetscScalar   *tmpwork;
    2147:   PetscReal      rcond;
    2148: #if defined (PETSC_USE_COMPLEX)
    2149:   PetscInt       rworkSize;
    2150:   PetscReal     *rwork;
    2151: #endif
    2152:   PetscInt       i, j, maxmn;
    2153:   PetscBLASInt   M, N, lda, ldb, ldwork;
    2154:   PetscBLASInt   nrhs, irank, info;

    2158:   if (debug) {
    2159:     PetscMalloc1(m*n,&Aback);
    2160:     PetscMemcpy(Aback,A,m*n*sizeof(PetscScalar));
    2161:   }

    2163:   /* initialize to identity */
    2164:   tmpwork = Ainv;
    2165:   Brhs = work;
    2166:   maxmn = PetscMax(m,n);
    2167:   for (j=0; j<maxmn; j++) {
    2168:     for (i=0; i<maxmn; i++) Brhs[i + j*maxmn] = 1.0*(i == j);
    2169:   }

    2171:   PetscBLASIntCast(m,&M);
    2172:   PetscBLASIntCast(n,&N);
    2173:   PetscBLASIntCast(mstride,&lda);
    2174:   PetscBLASIntCast(maxmn,&ldb);
    2175:   PetscBLASIntCast(worksize,&ldwork);
    2176:   rcond = -1;
    2177:   PetscFPTrapPush(PETSC_FP_TRAP_OFF);
    2178:   nrhs  = M;
    2179: #if defined(PETSC_USE_COMPLEX)
    2180:   rworkSize = 5 * PetscMin(M,N);
    2181:   PetscMalloc1(rworkSize,&rwork);
    2182:   LAPACKgelss_(&M,&N,&nrhs,A,&lda,Brhs,&ldb, (PetscReal *) tau,&rcond,&irank,tmpwork,&ldwork,rwork,&info);
    2183:   PetscFPTrapPop();
    2184:   PetscFree(rwork);
    2185: #else
    2186:   nrhs  = M;
    2187:   LAPACKgelss_(&M,&N,&nrhs,A,&lda,Brhs,&ldb, (PetscReal *) tau,&rcond,&irank,tmpwork,&ldwork,&info);
    2188:   PetscFPTrapPop();
    2189: #endif
    2190:   if (info) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"xGELSS error");
    2191:   /* The following check should be turned into a diagnostic as soon as someone wants to do this intentionally */
    2192:   if (irank < PetscMin(M,N)) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_USER,"Rank deficient least squares fit, indicates an isolated cell with two colinear points");

    2194:   /* Brhs shaped (M,nrhs) column-major coldim=mstride was overwritten by Ainv shaped (N,nrhs) column-major coldim=maxmn.
    2195:    * Here we transpose to (N,nrhs) row-major rowdim=mstride. */
    2196:   for (i=0; i<n; i++) {
    2197:     for (j=0; j<nrhs; j++) Ainv[i*mstride+j] = Brhs[i + j*maxmn];
    2198:   }
    2199:   return(0);
    2200: }

    2202: #if 0
    2205: static PetscErrorCode PetscFVLeastSquaresDebugCell_Static(PetscFV fvm, PetscInt cell, DM dm, DM dmFace, PetscScalar *fgeom, DM dmCell, PetscScalar *cgeom)
    2206: {
    2207:   PetscReal       grad[2] = {0, 0};
    2208:   const PetscInt *faces;
    2209:   PetscInt        numFaces, f;
    2210:   PetscErrorCode  ierr;

    2213:   DMPlexGetConeSize(dm, cell, &numFaces);
    2214:   DMPlexGetCone(dm, cell, &faces);
    2215:   for (f = 0; f < numFaces; ++f) {
    2216:     const PetscInt *fcells;
    2217:     const CellGeom *cg1;
    2218:     const FaceGeom *fg;

    2220:     DMPlexGetSupport(dm, faces[f], &fcells);
    2221:     DMPlexPointLocalRead(dmFace, faces[f], fgeom, &fg);
    2222:     for (i = 0; i < 2; ++i) {
    2223:       PetscScalar du;

    2225:       if (fcells[i] == c) continue;
    2226:       DMPlexPointLocalRead(dmCell, fcells[i], cgeom, &cg1);
    2227:       du   = cg1->centroid[0] + 3*cg1->centroid[1] - (cg->centroid[0] + 3*cg->centroid[1]);
    2228:       grad[0] += fg->grad[!i][0] * du;
    2229:       grad[1] += fg->grad[!i][1] * du;
    2230:     }
    2231:   }
    2232:   PetscPrintf(PETSC_COMM_SELF, "cell[%d] grad (%g, %g)\n", cell, grad[0], grad[1]);
    2233:   return(0);
    2234: }
    2235: #endif

    2239: /*
    2240:   PetscFVComputeGradient - Compute the gradient reconstruction matrix for a given cell

    2242:   Input Parameters:
    2243: + fvm      - The PetscFV object
    2244: . numFaces - The number of cell faces which are not constrained
    2245: . dx       - The vector from the cell centroid to the neighboring cell centroid for each face

    2247:   Level: developer

    2249: .seealso: PetscFVCreate()
    2250: */
    2251: PetscErrorCode PetscFVComputeGradient_LeastSquares(PetscFV fvm, PetscInt numFaces, const PetscScalar dx[], PetscScalar grad[])
    2252: {
    2253:   PetscFV_LeastSquares *ls       = (PetscFV_LeastSquares *) fvm->data;
    2254:   const PetscBool       useSVD   = PETSC_TRUE;
    2255:   const PetscInt        maxFaces = ls->maxFaces;
    2256:   PetscInt              dim, f, d;
    2257:   PetscErrorCode        ierr;

    2260:   if (numFaces > maxFaces) {
    2261:     if (maxFaces < 0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "Reconstruction has not been initialized, call PetscFVLeastSquaresSetMaxFaces()");
    2262:     SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Number of input faces %D > %D maxfaces", numFaces, maxFaces);
    2263:   }
    2264:   PetscFVGetSpatialDimension(fvm, &dim);
    2265:   for (f = 0; f < numFaces; ++f) {
    2266:     for (d = 0; d < dim; ++d) ls->B[d*maxFaces+f] = dx[f*dim+d];
    2267:   }
    2268:   /* Overwrites B with garbage, returns Binv in row-major format */
    2269:   if (useSVD) {PetscFVLeastSquaresPseudoInverseSVD_Static(numFaces, maxFaces, dim, ls->B, ls->Binv, ls->tau, ls->workSize, ls->work);}
    2270:   else        {PetscFVLeastSquaresPseudoInverse_Static(numFaces, maxFaces, dim, ls->B, ls->Binv, ls->tau, ls->workSize, ls->work);}
    2271:   for (f = 0; f < numFaces; ++f) {
    2272:     for (d = 0; d < dim; ++d) grad[f*dim+d] = ls->Binv[d*maxFaces+f];
    2273:   }
    2274:   return(0);
    2275: }

    2279: /*
    2280:   neighborVol[f*2+0] contains the left  geom
    2281:   neighborVol[f*2+1] contains the right geom
    2282: */
    2283: PetscErrorCode PetscFVIntegrateRHSFunction_LeastSquares(PetscFV fvm, PetscDS prob, PetscInt field, PetscInt Nf, PetscFVFaceGeom *fgeom, PetscReal *neighborVol,
    2284:                                                         PetscScalar uL[], PetscScalar uR[], PetscScalar fluxL[], PetscScalar fluxR[])
    2285: {
    2286:   void         (*riemann)(PetscInt, PetscInt, const PetscReal x[], const PetscReal n[], const PetscScalar uL[], const PetscScalar uR[], PetscScalar flux[], void *ctx);
    2287:   void          *rctx;
    2288:   PetscScalar   *flux = fvm->fluxWork;
    2289:   PetscInt       dim, pdim, Nc, totDim, off, f, d;

    2293:   PetscDSGetTotalComponents(prob, &Nc);
    2294:   PetscDSGetTotalDimension(prob, &totDim);
    2295:   PetscDSGetFieldOffset(prob, field, &off);
    2296:   PetscDSGetRiemannSolver(prob, field, &riemann);
    2297:   PetscDSGetContext(prob, field, &rctx);
    2298:   PetscFVGetSpatialDimension(fvm, &dim);
    2299:   PetscFVGetNumComponents(fvm, &pdim);
    2300:   for (f = 0; f < Nf; ++f) {
    2301:     (*riemann)(dim, pdim, fgeom[f].centroid, fgeom[f].normal, &uL[f*Nc], &uR[f*Nc], flux, rctx);
    2302:     for (d = 0; d < pdim; ++d) {
    2303:       fluxL[f*totDim+off+d] = flux[d] / neighborVol[f*2+0];
    2304:       fluxR[f*totDim+off+d] = flux[d] / neighborVol[f*2+1];
    2305:     }
    2306:   }
    2307:   return(0);
    2308: }

    2312: static PetscErrorCode PetscFVLeastSquaresSetMaxFaces_LS(PetscFV fvm, PetscInt maxFaces)
    2313: {
    2314:   PetscFV_LeastSquares *ls = (PetscFV_LeastSquares *) fvm->data;
    2315:   PetscInt              dim, m, n, nrhs, minwork;
    2316:   PetscErrorCode        ierr;

    2320:   PetscFVGetSpatialDimension(fvm, &dim);
    2321:   PetscFree4(ls->B, ls->Binv, ls->tau, ls->work);
    2322:   ls->maxFaces = maxFaces;
    2323:   m       = ls->maxFaces;
    2324:   n       = dim;
    2325:   nrhs    = ls->maxFaces;
    2326:   minwork = 3*PetscMin(m,n) + PetscMax(2*PetscMin(m,n), PetscMax(PetscMax(m,n), nrhs)); /* required by LAPACK */
    2327:   ls->workSize = 5*minwork; /* We can afford to be extra generous */
    2328:   PetscMalloc4(ls->maxFaces*dim,&ls->B,ls->workSize,&ls->Binv,ls->maxFaces,&ls->tau,ls->workSize,&ls->work);
    2329:   return(0);
    2330: }

    2334: PetscErrorCode PetscFVInitialize_LeastSquares(PetscFV fvm)
    2335: {
    2337:   fvm->ops->setfromoptions          = NULL;
    2338:   fvm->ops->setup                   = PetscFVSetUp_LeastSquares;
    2339:   fvm->ops->view                    = PetscFVView_LeastSquares;
    2340:   fvm->ops->destroy                 = PetscFVDestroy_LeastSquares;
    2341:   fvm->ops->computegradient         = PetscFVComputeGradient_LeastSquares;
    2342:   fvm->ops->integraterhsfunction    = PetscFVIntegrateRHSFunction_LeastSquares;
    2343:   return(0);
    2344: }

    2346: /*MC
    2347:   PETSCFVLEASTSQUARES = "leastsquares" - A PetscFV object

    2349:   Level: intermediate

    2351: .seealso: PetscFVType, PetscFVCreate(), PetscFVSetType()
    2352: M*/

    2356: PETSC_EXTERN PetscErrorCode PetscFVCreate_LeastSquares(PetscFV fvm)
    2357: {
    2358:   PetscFV_LeastSquares *ls;
    2359:   PetscErrorCode        ierr;

    2363:   PetscNewLog(fvm, &ls);
    2364:   fvm->data = ls;

    2366:   ls->maxFaces = -1;
    2367:   ls->workSize = -1;
    2368:   ls->B        = NULL;
    2369:   ls->Binv     = NULL;
    2370:   ls->tau      = NULL;
    2371:   ls->work     = NULL;

    2373:   PetscFVSetComputeGradients(fvm, PETSC_TRUE);
    2374:   PetscFVInitialize_LeastSquares(fvm);
    2375:   PetscObjectComposeFunction((PetscObject) fvm, "PetscFVLeastSquaresSetMaxFaces_C", PetscFVLeastSquaresSetMaxFaces_LS);
    2376:   return(0);
    2377: }

    2381: /*@
    2382:   PetscFVLeastSquaresSetMaxFaces - Set the maximum number of cell faces for gradient reconstruction

    2384:   Not collective

    2386:   Input parameters:
    2387: + fvm      - The PetscFV object
    2388: - maxFaces - The maximum number of cell faces

    2390:   Level: intermediate

    2392: .seealso: PetscFVCreate(), PETSCFVLEASTSQUARES
    2393: @*/
    2394: PetscErrorCode PetscFVLeastSquaresSetMaxFaces(PetscFV fvm, PetscInt maxFaces)
    2395: {

    2400:   PetscTryMethod(fvm, "PetscFVLeastSquaresSetMaxFaces_C", (PetscFV,PetscInt), (fvm,maxFaces));
    2401:   return(0);
    2402: }