SnesCtx.hpp

Go to the documentation of this file.

/**
 * \file SnesCtx.hpp
 * \brief Context for PETSc SNES, i.e. nonlinear solver
 * \author Anonymous contributor under MIT license
 */
 
#ifndef __SNESCTX_HPP__
#define __SNESCTX_HPP__
 
namespace MoFEM {
 
/** \brief Interface for nonlinear (SNES) solver
 * \ingroup mofem_petsc_solvers
 */
struct SnesCtx {
 
  using PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr;
  using FEMethodsSequence = MoFEM::FEMethodsSequence;
  using BasicMethodsSequence = MoFEM::BasicMethodsSequence;
  using HookFunction = boost::function<MoFEMErrorCode(
      SNES snes, Vec x, Vec F, boost::shared_ptr<CacheTuple> cache_ptr,
      void *ctx)>;
 
  SnesCtx(Interface &m_field, std::string problem_name);
 
  virtual ~SnesCtx();
 
  /**
   * @return return reference to vector with FEMethod to calculate tangent
   * matrix
   */
  FEMethodsSequence &getSetOperators();
 
  /**
   * @return return vector to vector with FEMethod to calculate residual
   */
  FEMethodsSequence &getComputeRhs();
 
  /**
   * The sequence of BasicMethod is executed before residual is calculated. It
   * can be used to setup data structures, e.g. zero global variable which is
   * integrated in domain, e.g. for calculation of strain energy.
   *
   * @return reference to BasicMethod for preprocessing
   */
  BasicMethodsSequence &getPreProcComputeRhs();
 
  /**
   * The sequence of BasicMethod is executed after residual is calculated. It
   * can be used to setup data structures, e.g. aggregate data from processors
   * or to apply essential boundary conditions.
   *
   * @return reference to BasicMethod for postprocessing
   */
  BasicMethodsSequence &getPostProcComputeRhs();
 
  /**
   * @return reference to BasicMethod for preprocessing
   */
  BasicMethodsSequence &getPreProcSetOperators();
 
  /**
   * The sequence of BasicMethod is executed after tangent matrix is calculated.
   * It can be used to setup data structures, e.g. aggregate data from
   * processors or to apply essential boundary conditions.
   *
   * @return reference to BasicMethod for postprocessing
   */
  BasicMethodsSequence &getPostProcSetOperators();
 
  /**
   * @brief Get the finite element pipeline for FunctionFn, that calculate
   * tangent of function load for arc length control
   *
   * @return FEMethodsSequence&
   */
  FEMethodsSequence &getLoadTangent();
 
  /**
   * @brief Get the BasicMethod sequence for preprocessing of FunctionFn
   *
   * @return BasicMethodsSequence&
   */
  BasicMethodsSequence &getPreProcLoadTangent();
 
  /**
   * @brief Get the BasicMethod sequence for postprocessing of FunctionFn
   *
   * @return BasicMethodsSequence&
   */
  BasicMethodsSequence &getPostProcLoadTangent();
 
  /**
   * @brief Get the Load Tangent Hook function
   *
   * Using hook you can debug or post-process while load vector tangent is
   * evaluated
   *
   * @return HookFunction&
   */
  HookFunction &getLoadTangentHook();
 
  /**
   * @brief Get the Right Hand Side Hook function
   *
   * Using hook you can debug or post-process while right hand side vector is
   * evaluated
   *
   * @return HookFunction&
   */
  HookFunction &getRhsHook();
 
  /**
   * \brief Copy sequences from other SNES context
   * @param snes_ctx SNES context from which Sequence is copied from
   * @return         error code
   */
  MoFEMErrorCode copyLoops(const SnesCtx &snes_ctx);
 
  /**
   * @brief Clear loops
   *
   * @return MoFEMErrorCode
   */
  MoFEMErrorCode clearLoops();
 
  friend PetscErrorCode SnesRhs(SNES snes, Vec x, Vec f, void *ctx);
  friend PetscErrorCode SnesMat(SNES snes, Vec x, Mat A, Mat B, void *ctx);
 
  friend MoFEMErrorCode SNESMoFEMSetAssmblyType(SNES snes,
                                                MatAssemblyType type);
  friend MoFEMErrorCode SnesMoFEMSetBehavior(SNES snes, MoFEMTypes bh);
 
  friend MoFEMErrorCode SnesMoFEMSetAssemblyType(SNES snes,
                                                 MatAssemblyType type);
 
  friend MoFEMErrorCode MoFEMSNESMonitorFields(SNES snes, PetscInt its,
                                               PetscReal fgnorm,
                                               SnesCtx *snes_ctx);
 
  friend MoFEMErrorCode MoFEMSNESMonitorEnergy(SNES snes, PetscInt its,
                                               PetscReal fgnorm,
                                               SnesCtx *snes_ctx);
 
  friend PetscErrorCode SnesLoadTangent(SNES snes, Vec u, Vec F, void *ctx);
 
  struct SnesCtxImpl;
 
protected:
  boost::movelib::unique_ptr<SnesCtxImpl> snesCtxImpl;
};
 
/**
 * \brief This is MoFEM implementation for the right hand side (residual vector)
 * evaluation in SNES solver
 *
 * For more information pleas look to PETSc manual, i.e. SNESSetFunction
 * <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/SNES/SNESSetFunction.html>
 *
 * @param  snes SNES solver
 * @param  x    Solution vector at current iteration
 * @param  f    The right hand side vector
 * @param  ctx  Pointer to context i.e. SnesCtx
 * @return      Error code
 */
PetscErrorCode SnesRhs(SNES snes, Vec x, Vec f, void *ctx);
 
/**
 * \brief This is MoFEM implementation for the left hand side (tangent matrix)
 * evaluation in SNES solver
 *
 * For more information pleas look to PETSc manual, i.e. SNESSetJacobian
 * <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/SNES/SNESSetJacobian.html#SNESSetJacobian>
 *
 * @param  snes SNES solver
 * @param  x    Solution vector at current iteration
 * @param  A    Tangent matrix
 * @param  B    Preconditioner tangent matrix
 * @param  ctx  Pointer to context i.e. SnesCtx
 * @return      Error code
 */
PetscErrorCode SnesMat(SNES snes, Vec x, Mat A, Mat B, void *ctx);
 
/**
 * \brief This function calls finite element pipeline to compute tangent of of
 * load vector in arc length control
 *
 * For more information pleas look to PETSc manual, i.e. SNESSetFunction
 * <https://petsc.org/main/manualpages/SNES/SNESSetFunction/>
 *
 * @param  snes SNES solver
 * @param  u    Solution vector at current iteration
 * @param  F    The right hand side vector
 * @param  ctx  Pointer to context i.e. SnesCtx
 * @return      Error code
 */
PetscErrorCode SnesLoadTangent(SNES snes, Vec u, Vec F, void *ctx);
 
/**
 * \brief Set assembly type at the end of SnesMat
 *
 * \note Note that tangent matrix need have to have final assembly, you would
 * use flush assembly in special case that you call SnesMat form other function
 * set to SNESSetJacobian
 *
 * @param  snes
 * @param  type type of assembly, either MAT_FLUSH_ASSEMBLY or
 * MAT_FINAL_ASSEMBLY
 * @return      error code
 */
MoFEMErrorCode SnesMoFEMSetAssemblyType(SNES snes, MatAssemblyType type);
 
/**
 * \brief Set behavior if finite element in sequence does not exist
 * @param  snes
 * @param  bh   If set to MF_EXIST check if element exist, default MF_EXIST.
 * Otherwise set MF_ZERO
 * @return      error code
 */
MoFEMErrorCode SnesMoFEMSetBehavior(SNES snes, MoFEMTypes bh);
 
/**
 * @brief Sens monitor printing residual field by field
 *
 */
MoFEMErrorCode MoFEMSNESMonitorFields(SNES snes, PetscInt its, PetscReal fgnorm,
                                      SnesCtx *snes_ctx);
 
/**
 * @brief Sens monitor printing residual field by field
 *
 */
MoFEMErrorCode MoFEMSNESMonitorEnergy(SNES snes, PetscInt its, PetscReal fgnorm,
                                      SnesCtx *snes_ctx);
 
} // namespace MoFEM
 
#endif // __SNESCTX_HPP__