Actual source code: fasgalerkin.c
petsc-3.10.5 2019-03-28
Report Typos and Errors

      1:  #include <../src/snes/impls/fas/fasimpls.h>

      3: /*@
      4:    SNESFASGetGalerkin - Gets if the coarse problems are formed by projection to the fine problem

      6:    Input Parameter:
      7: .  snes - the nonlinear solver context

      9:    Output parameter:
     10: .  flg - the status of the galerkin problem

     12:    Level: advanced

     14: .keywords: FAS, galerkin

     16: .seealso: SNESFASSetLevels(), SNESFASSetGalerkin()
     17: @*/
     18: PetscErrorCode SNESFASGetGalerkin(SNES snes, PetscBool *flg)
     19: {
     20:   SNES_FAS * fas = (SNES_FAS*)snes->data;

     23:   *flg = fas->galerkin;
     24:   return(0);
     25: }

     27: /*@
     28:    SNESFASSetGalerkin - Sets coarse problems as formed by projection to the fine problem

     30:    Input Parameter:
     31: .  snes - the nonlinear solver context
     32: .  flg - the status of the galerkin problem

     34:    Level: advanced

     36: .keywords: FAS, galerkin

     38: .seealso: SNESFASSetLevels(), SNESFASGetGalerkin()
     39: @*/
     40: PetscErrorCode SNESFASSetGalerkin(SNES snes, PetscBool flg)
     41: {
     42:   SNES_FAS       * fas = (SNES_FAS*)snes->data;

     46:   fas->galerkin = flg;
     47:   if (fas->next) {SNESFASSetGalerkin(fas->next, flg);}
     48:   return(0);
     49: }

     51: /*@C
     52:    SNESFASGalerkinFunctionDefault - Computes the Galerkin FAS function

     54:    Input Parameters:
     55: .  snes - the nonlinear solver context
     56: .  X - input vector
     57: .  ctx - the FAS context

     59:    Output Parameter:
     60: .  F - output vector

     62:    Notes:
     63:    The Galerkin FAS function evalutation is defined as
     64: $  F^l(x^l) = I^l_0 F^0(P^0_l x^l)

     66:    Level: developer

     68: .keywords: FAS, galerkin

     70: .seealso: SNESFASGetGalerkin(), SNESFASSetGalerkin()
     71: @*/
     72: PetscErrorCode SNESFASGalerkinFunctionDefault(SNES snes, Vec X, Vec F, void *ctx)
     73: {
     74:   SNES           fassnes;
     75:   SNES_FAS       *fas;
     76:   SNES_FAS       *prevfas;
     77:   SNES           prevsnes;
     78:   Vec            b_temp;

     82:   /* prolong to the fine level and evaluate there. */
     83:   fassnes  = (SNES)ctx;
     84:   fas      = (SNES_FAS*)fassnes->data;
     85:   prevsnes = fas->previous;
     86:   prevfas  = (SNES_FAS*)prevsnes->data;
     87:   /* interpolate down the solution */
     88:   MatInterpolate(prevfas->interpolate, X, prevfas->Xg);
     89:   /* the RHS we care about is at the coarsest level */
     90:   b_temp            = prevsnes->vec_rhs;
     91:   prevsnes->vec_rhs = NULL;
     92:   SNESComputeFunction(prevsnes, prevfas->Xg, prevfas->Fg);
     93:   prevsnes->vec_rhs = b_temp;
     94:   /* restrict up the function */
     95:   MatRestrict(prevfas->restrct, prevfas->Fg, F);
     96:   return(0);
     97: }