Interface for nonlinear (SNES) solver. More...

#include <src/petsc/SnesCtx.hpp>

Collaboration diagram for MoFEM::SnesCtx:

Public Types
typedef MoFEM::PairNameFEMethodPtr	PairNameFEMethodPtr

typedef MoFEM::FEMethodsSequence	FEMethodsSequence

typedef MoFEM::BasicMethodsSequence	BasicMethodsSequence

Public Member Functions
	SnesCtx (Interface &m_field, const std::string &problem_name)

virtual	~SnesCtx ()=default

FEMethodsSequence &	getSetOperators ()

FEMethodsSequence &	getComputeRhs ()

BasicMethodsSequence &	getPreProcComputeRhs ()

BasicMethodsSequence &	getPostProcComputeRhs ()

BasicMethodsSequence &	getPreProcSetOperators ()

BasicMethodsSequence &	getPostProcSetOperators ()

MoFEMErrorCode	copyLoops (const SnesCtx &snes_ctx)
	Copy sequences from other SNES contex. More...

MoFEMErrorCode	clearLoops ()
	Clear loops. More...

DEPRECATED FEMethodsSequence &	get_loops_to_do_Mat ()

DEPRECATED FEMethodsSequence &	get_loops_to_do_Rhs ()

DEPRECATED BasicMethodsSequence &	get_preProcess_to_do_Rhs ()

DEPRECATED BasicMethodsSequence &	get_postProcess_to_do_Rhs ()

DEPRECATED BasicMethodsSequence &	get_preProcess_to_do_Mat ()

DEPRECATED BasicMethodsSequence &	get_postProcess_to_do_Mat ()

Public Attributes
MoFEM::Interface &	mField
	database Interface More...

moab::Interface &	moab
	moab Interface More...

std::string	problemName
	problem name More...

MoFEMTypes	bH
	If set to MF_EXIST check if element exist, default MF_EXIST. More...

bool	zeroPreCondMatrixB

MatAssemblyType	typeOfAssembly
	type of assembly at the end More...

bool	vErify
	If true verify vector. More...

FEMethodsSequence	loops_to_do_Mat

FEMethodsSequence	loops_to_do_Rhs

BasicMethodsSequence	preProcess_Mat

BasicMethodsSequence	postProcess_Mat

BasicMethodsSequence	preProcess_Rhs
	Sequence of methods run before residual is assembled. More...

BasicMethodsSequence	postProcess_Rhs
	Sequence of methods run after residual is assembled. More...

Private Attributes
boost::movelib::unique_ptr< bool >	vecAssembleSwitch

boost::movelib::unique_ptr< bool >	matAssembleSwitch

PetscLogEvent	MOFEM_EVENT_SnesRhs
	Log events to assemble residual. More...

PetscLogEvent	MOFEM_EVENT_SnesMat
	Log events to assemble tangent matrix. More...

Friends
PetscErrorCode	SnesRhs (SNES snes, Vec x, Vec f, void *ctx)
	This is MoFEM implementation for the right hand side (residual vector) evaluation in SNES solver. More...

PetscErrorCode	SnesMat (SNES snes, Vec x, Mat A, Mat B, void *ctx)
	This is MoFEM implementation for the left hand side (tangent matrix) evaluation in SNES solver. More...

MoFEMErrorCode	SNESMoFEMSetAssmblyType (SNES snes, MatAssemblyType type)

MoFEMErrorCode	SnesMoFEMSetBehavior (SNES snes, MoFEMTypes bh)
	Set behavior if finite element in sequence does not exist. More...

Detailed Description

Interface for nonlinear (SNES) solver.

Examples: minimal_surface_area.cpp, navier_stokes.cpp, nonlinear_dynamics.cpp, simple_contact.cpp, simple_contact_thermal.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 13 of file SnesCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

typedef MoFEM::BasicMethodsSequence MoFEM::SnesCtx::BasicMethodsSequence

Definition at line 28 of file SnesCtx.hpp.

◆ FEMethodsSequence

typedef MoFEM::FEMethodsSequence MoFEM::SnesCtx::FEMethodsSequence

Definition at line 27 of file SnesCtx.hpp.

◆ PairNameFEMethodPtr

typedef MoFEM::PairNameFEMethodPtr MoFEM::SnesCtx::PairNameFEMethodPtr

Definition at line 26 of file SnesCtx.hpp.

Constructor & Destructor Documentation

◆ SnesCtx()

MoFEM::SnesCtx::SnesCtx	(	Interface &	m_field,
		const std::string &	problem_name
	)

inline

Definition at line 43 of file SnesCtx.hpp.

       : mField(m_field), moab(m_field.get_moab()), problemName(problem_name),
         bH(MF_EXIST), zeroPreCondMatrixB(true),
         typeOfAssembly(MAT_FINAL_ASSEMBLY), vErify(false) {
     PetscLogEventRegister("LoopSNESRhs", 0, &MOFEM_EVENT_SnesRhs);
     PetscLogEventRegister("LoopSNESMat", 0, &MOFEM_EVENT_SnesMat);
     if (!LogManager::checkIfChannelExist("SNES_WORLD")) {
       auto core_log = logging::core::get();
       core_log->add_sink(
           LogManager::createSink(LogManager::getStrmWorld(), "SNES_WORLD"));
       LogManager::setLog("SNES_WORLD");
       MOFEM_LOG_TAG("SNES_WORLD", "SNES");
     }
   }

◆ ~SnesCtx()

virtual MoFEM::SnesCtx::~SnesCtx ( )

virtualdefault

Member Function Documentation

◆ clearLoops()

MoFEMErrorCode SnesCtx::clearLoops ( )

Clear loops.

Returns: MoFEMErrorCode

Definition at line 16 of file SnesCtx.cpp.

                                    {
   MoFEMFunctionBeginHot;
   loops_to_do_Mat.clear();
   loops_to_do_Rhs.clear();
   preProcess_Mat.clear();
   postProcess_Mat.clear();
   preProcess_Rhs.clear();
   postProcess_Rhs.clear();
   MoFEMFunctionReturnHot(0);
 }

◆ copyLoops()

MoFEMErrorCode SnesCtx::copyLoops ( const SnesCtx & snes_ctx )

Copy sequences from other SNES contex.

Parameters

snes_ctx SNES contex from which Sequence is copied from

Returns: error code

Definition at line 5 of file SnesCtx.cpp.

                                                          {
   MoFEMFunctionBeginHot;
   loops_to_do_Mat = snes_ctx.loops_to_do_Mat;
   loops_to_do_Rhs = snes_ctx.loops_to_do_Rhs;
   preProcess_Mat = snes_ctx.preProcess_Mat;
   postProcess_Mat = snes_ctx.postProcess_Mat;
   preProcess_Rhs = snes_ctx.preProcess_Rhs;
   postProcess_Rhs = snes_ctx.postProcess_Rhs;
   MoFEMFunctionReturnHot(0);
 }

◆ get_loops_to_do_Mat()

DEPRECATED FEMethodsSequence& MoFEM::SnesCtx::get_loops_to_do_Mat ( )

inline

Deprecated:: use getSetOperators

Definition at line 125 of file SnesCtx.hpp.

                                                       {
     return getSetOperators();
   }

◆ get_loops_to_do_Rhs()

DEPRECATED FEMethodsSequence& MoFEM::SnesCtx::get_loops_to_do_Rhs ( )

inline

Deprecated:: use getComputeRhs

Definition at line 130 of file SnesCtx.hpp.

                                                       {
     return getComputeRhs();
   }

◆ get_postProcess_to_do_Mat()

DEPRECATED BasicMethodsSequence& MoFEM::SnesCtx::get_postProcess_to_do_Mat ( )

inline

Deprecated:: use getPostProcSetOperators

Definition at line 150 of file SnesCtx.hpp.

                                                                {
     return getPostProcSetOperators();
   }

◆ get_postProcess_to_do_Rhs()

DEPRECATED BasicMethodsSequence& MoFEM::SnesCtx::get_postProcess_to_do_Rhs ( )

inline

Deprecated:: use getPostProcComputeRhs

Definition at line 140 of file SnesCtx.hpp.

                                                                {
     return getPostProcComputeRhs();
   }

◆ get_preProcess_to_do_Mat()

DEPRECATED BasicMethodsSequence& MoFEM::SnesCtx::get_preProcess_to_do_Mat ( )

inline

Deprecated:: use getPreProcSetOperators

Definition at line 145 of file SnesCtx.hpp.

                                                               {
     return getPreProcSetOperators();
   }

◆ get_preProcess_to_do_Rhs()

DEPRECATED BasicMethodsSequence& MoFEM::SnesCtx::get_preProcess_to_do_Rhs ( )

inline

Deprecated:: use getPreProcComputeRhs

Definition at line 135 of file SnesCtx.hpp.

                                                               {
     return getPreProcComputeRhs();
   }

◆ getComputeRhs()

FEMethodsSequence& MoFEM::SnesCtx::getComputeRhs ( )

inline

Returns: return vector to vector with FEMethod to calculate residual

Definition at line 69 of file SnesCtx.hpp.

69 { return loops_to_do_Rhs; }

◆ getPostProcComputeRhs()

BasicMethodsSequence& MoFEM::SnesCtx::getPostProcComputeRhs ( )

inline

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.

Returns: reference to BasicMethod for postprocessing

Definition at line 87 of file SnesCtx.hpp.

87 { return postProcess_Rhs; }

◆ getPostProcSetOperators()

BasicMethodsSequence& MoFEM::SnesCtx::getPostProcSetOperators ( )

inline

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.

Returns: reference to BasicMethod for postprocessing

Definition at line 101 of file SnesCtx.hpp.

101 { return postProcess_Mat; }

◆ getPreProcComputeRhs()

BasicMethodsSequence& MoFEM::SnesCtx::getPreProcComputeRhs ( )

inline

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.

Returns: reference to BasicMethod for preprocessing

Definition at line 78 of file SnesCtx.hpp.

78 { return preProcess_Rhs; }

◆ getPreProcSetOperators()

BasicMethodsSequence& MoFEM::SnesCtx::getPreProcSetOperators ( )

inline

Returns: reference to BasicMethod for preprocessing

Definition at line 92 of file SnesCtx.hpp.

92 { return preProcess_Mat; }

◆ getSetOperators()

FEMethodsSequence& MoFEM::SnesCtx::getSetOperators ( )

inline

Returns: return reference to vector with FEMethod to calculate tangent matrix

Definition at line 64 of file SnesCtx.hpp.

64 { return loops_to_do_Mat; }

Friends And Related Function Documentation

◆ SnesMat

PetscErrorCode SnesMat	(	SNES	snes,
		Vec	x,
		Mat	A,
		Mat	B,
		void *	ctx
	)

friend

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

Parameters

snes	SNES solver
x	Solution vector at current iteration
A	Tangent matrix
B	Preconditioner tangent matrix
ctx	Pointer to context i.e. SnesCtx

Returns: Error code

Definition at line 139 of file SnesCtx.cpp.

                                                                   {
   SnesCtx *snes_ctx = (SnesCtx *)ctx;
   // PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
   MoFEMFunctionBegin;
   PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
   if (snes_ctx->zeroPreCondMatrixB)
     CHKERR MatZeroEntries(B);
  
   snes_ctx->matAssembleSwitch = boost::movelib::make_unique<bool>(true);
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR snes_ctx->mField.cache_problem_entities(snes_ctx->problemName,
                                                  cache_ptr);
  
   auto set = [&](auto &fe) {
     fe.snes = snes;
     fe.snes_x = x;
     fe.snes_A = A;
     fe.snes_B = B;
     fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
     fe.ksp_ctx = KspMethod::CTX_OPERATORS;
     fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
  
     CHKERR SNESGetKSP(snes, &fe.ksp);
     
     fe.cacheWeakPtr = cache_ptr;
   };
  
   auto unset = [&](auto &fe) {
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
  
   CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR snes_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       snes_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
   for (auto &bit : snes_ctx->preProcess_Mat) {
     bit->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR snes_ctx->mField.problem_basic_method_preProcess(
         snes_ctx->problemName, *bit);
     unset(*bit);
     snes_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
  
  
   for (auto &lit : snes_ctx->loops_to_do_Mat) {
     lit.second->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
     set(*lit.second);
     CHKERR snes_ctx->mField.loop_finite_elements(
         snes_ctx->problemName, lit.first, *(lit.second), nullptr, snes_ctx->bH,
         cache_ptr);
     unset(*lit.second);
     snes_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
   }
  
   for (auto &bit : snes_ctx->postProcess_Mat) {
     bit->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR snes_ctx->mField.problem_basic_method_postProcess(
         snes_ctx->problemName, *bit);
     unset(*bit);
     snes_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   if (*snes_ctx->matAssembleSwitch) {
     CHKERR MatAssemblyBegin(B, snes_ctx->typeOfAssembly);
     CHKERR MatAssemblyEnd(B, snes_ctx->typeOfAssembly);
   }
   PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ SNESMoFEMSetAssmblyType

MoFEMErrorCode SNESMoFEMSetAssmblyType	(	SNES	snes,
		MatAssemblyType	type
	)

friend

◆ SnesMoFEMSetBehavior

MoFEMErrorCode SnesMoFEMSetBehavior	(	SNES	snes,
		MoFEMTypes	bh
	)

friend

Set behavior if finite element in sequence does not exist.

Parameters

snes
bh	If set to MF_EXIST check if element exist, default MF_EXIST. Otherwise set MF_ZERO

Returns: error code

Definition at line 224 of file SnesCtx.cpp.

                                                               {
   SnesCtx *snes_ctx;
   MoFEMFunctionBegin;
   CHKERR SNESGetApplicationContext(snes, &snes_ctx);
   snes_ctx->bH = bh;
   MoFEMFunctionReturn(0);
 }

◆ SnesRhs

PetscErrorCode SnesRhs	(	SNES	snes,
		Vec	x,
		Vec	f,
		void *	ctx
	)

friend

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

Parameters

snes	SNES solver
x	Solution vector at current iteration
f	The right hand side vector
ctx	Pointer to context i.e. SnesCtx

Returns: Error code

Definition at line 27 of file SnesCtx.cpp.

                                                            {
   SnesCtx *snes_ctx = (SnesCtx *)ctx;
   // PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
   MoFEMFunctionBegin;
   PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
   if (snes_ctx->vErify) {
     // Verify finite elements, check for not a number
     CHKERR VecAssemblyBegin(f);
     CHKERR VecAssemblyEnd(f);
     MPI_Comm comm = PetscObjectComm((PetscObject)f);
     PetscSynchronizedPrintf(comm, "SNES Verify x\n");
     const Problem *prb_ptr;
     CHKERR snes_ctx->mField.get_problem(snes_ctx->problemName, &prb_ptr);
     CHKERR snes_ctx->mField.getInterface<Tools>()->checkVectorForNotANumber(
         prb_ptr, COL, x);
   }
   CHKERR snes_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       snes_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
  
   auto zero_ghost_vec = [](Vec g) {
     MoFEMFunctionBegin;
     Vec l;
     CHKERR VecGhostGetLocalForm(g, &l);
     double *a;
     CHKERR VecGetArray(l, &a);
     int s;
     CHKERR VecGetLocalSize(l, &s);
     for (int i = 0; i != s; ++i)
       a[i] = 0;
     CHKERR VecRestoreArray(l, &a);
     CHKERR VecGhostRestoreLocalForm(g, &l);
     MoFEMFunctionReturn(0);
   };
   CHKERR zero_ghost_vec(f);
  
   snes_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR snes_ctx->mField.cache_problem_entities(snes_ctx->problemName,
                                                  cache_ptr);
  
   auto set = [&](auto &fe) {
     fe.snes = snes;
     fe.snes_x = x;
     fe.snes_f = f;
     fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
     fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
     fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
  
     CHKERR SNESGetKSP(snes, &fe.ksp);
  
     fe.cacheWeakPtr = cache_ptr;
   };
  
   auto unset = [&](auto &fe) {
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   for (auto &bit : snes_ctx->preProcess_Rhs) {
     bit->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR snes_ctx->mField.problem_basic_method_preProcess(
         snes_ctx->problemName, *bit);
     unset(*bit);
     snes_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   for (auto &lit : snes_ctx->loops_to_do_Rhs) {
     lit.second->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
     set(*lit.second);
     CHKERR snes_ctx->mField.loop_finite_elements(
         snes_ctx->problemName, lit.first, *lit.second, nullptr, snes_ctx->bH,
         cache_ptr);
     unset(*lit.second);
     if (snes_ctx->vErify) {
       // Verify finite elements, check for not a number
       CHKERR VecAssemblyBegin(f);
       CHKERR VecAssemblyEnd(f);
       MPI_Comm comm = PetscObjectComm((PetscObject)f);
       PetscSynchronizedPrintf(comm, "SNES Verify f FE < %s >\n",
                               lit.first.c_str());
       const Problem *prb_ptr;
       CHKERR snes_ctx->mField.get_problem(snes_ctx->problemName, &prb_ptr);
       CHKERR snes_ctx->mField.getInterface<Tools>()->checkVectorForNotANumber(
           prb_ptr, ROW, f);
     }
  
     snes_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
   }
  
   for (auto &bit : snes_ctx->postProcess_Rhs) {
     bit->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR snes_ctx->mField.problem_basic_method_postProcess(
         snes_ctx->problemName, *bit);
     unset(*bit);
     snes_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   if (*(snes_ctx->vecAssembleSwitch)) {
     CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecAssemblyBegin(f);
     CHKERR VecAssemblyEnd(f);
   }
   PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

Member Data Documentation

◆ bH

MoFEMTypes MoFEM::SnesCtx::bH

If set to MF_EXIST check if element exist, default MF_EXIST.

Definition at line 20 of file SnesCtx.hpp.

◆ loops_to_do_Mat

FEMethodsSequence MoFEM::SnesCtx::loops_to_do_Mat

Sequence of finite elements instances assembling tangent matrix

Definition at line 30 of file SnesCtx.hpp.

◆ loops_to_do_Rhs

FEMethodsSequence MoFEM::SnesCtx::loops_to_do_Rhs

Sequence of finite elements instances assembling residual vector

Definition at line 32 of file SnesCtx.hpp.

◆ matAssembleSwitch

boost::movelib::unique_ptr<bool> MoFEM::SnesCtx::matAssembleSwitch

private

Definition at line 156 of file SnesCtx.hpp.

◆ mField

MoFEM::Interface& MoFEM::SnesCtx::mField

database Interface

Definition at line 15 of file SnesCtx.hpp.

◆ moab

moab::Interface& MoFEM::SnesCtx::moab

moab Interface

Definition at line 16 of file SnesCtx.hpp.

◆ MOFEM_EVENT_SnesMat

PetscLogEvent MoFEM::SnesCtx::MOFEM_EVENT_SnesMat

private

Log events to assemble tangent matrix.

Definition at line 158 of file SnesCtx.hpp.

◆ MOFEM_EVENT_SnesRhs

PetscLogEvent MoFEM::SnesCtx::MOFEM_EVENT_SnesRhs

private

Log events to assemble residual.

Definition at line 157 of file SnesCtx.hpp.

◆ postProcess_Mat

BasicMethodsSequence MoFEM::SnesCtx::postProcess_Mat

Sequence of methods run after tangent matrix is assembled

Definition at line 36 of file SnesCtx.hpp.

◆ postProcess_Rhs

BasicMethodsSequence MoFEM::SnesCtx::postProcess_Rhs

Sequence of methods run after residual is assembled.

Definition at line 41 of file SnesCtx.hpp.

◆ preProcess_Mat

BasicMethodsSequence MoFEM::SnesCtx::preProcess_Mat

Sequence of methods run before tangent matrix is assembled

Definition at line 34 of file SnesCtx.hpp.

◆ preProcess_Rhs

BasicMethodsSequence MoFEM::SnesCtx::preProcess_Rhs

Sequence of methods run before residual is assembled.

Definition at line 39 of file SnesCtx.hpp.

◆ problemName

std::string MoFEM::SnesCtx::problemName

problem name

Definition at line 18 of file SnesCtx.hpp.

◆ typeOfAssembly

MatAssemblyType MoFEM::SnesCtx::typeOfAssembly

type of assembly at the end

Definition at line 23 of file SnesCtx.hpp.

◆ vecAssembleSwitch

boost::movelib::unique_ptr<bool> MoFEM::SnesCtx::vecAssembleSwitch

private

Definition at line 155 of file SnesCtx.hpp.

◆ vErify

bool MoFEM::SnesCtx::vErify

If true verify vector.

Definition at line 24 of file SnesCtx.hpp.

◆ zeroPreCondMatrixB

bool MoFEM::SnesCtx::zeroPreCondMatrixB

If true zero matrix, otherwise user need to do it, default true

Definition at line 21 of file SnesCtx.hpp.

The documentation for this struct was generated from the following files:

src/petsc/SnesCtx.hpp
src/petsc/impl/SnesCtx.cpp

Public Types

Public Member Functions

Public Attributes

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BasicMethodsSequence

◆ FEMethodsSequence

◆ PairNameFEMethodPtr

Constructor & Destructor Documentation

◆ SnesCtx()

◆ ~SnesCtx()

Member Function Documentation

◆ clearLoops()

◆ copyLoops()

◆ get_loops_to_do_Mat()

◆ get_loops_to_do_Rhs()

◆ get_postProcess_to_do_Mat()

◆ get_postProcess_to_do_Rhs()

◆ get_preProcess_to_do_Mat()

◆ get_preProcess_to_do_Rhs()

◆ getComputeRhs()

◆ getPostProcComputeRhs()

◆ getPostProcSetOperators()

◆ getPreProcComputeRhs()

◆ getPreProcSetOperators()

◆ getSetOperators()

Friends And Related Function Documentation

◆ SnesMat

◆ SNESMoFEMSetAssmblyType

◆ SnesMoFEMSetBehavior

◆ SnesRhs

Member Data Documentation

◆ bH

◆ loops_to_do_Mat

◆ loops_to_do_Rhs

◆ matAssembleSwitch

◆ mField

◆ moab

◆ MOFEM_EVENT_SnesMat

◆ MOFEM_EVENT_SnesRhs

◆ postProcess_Mat

◆ postProcess_Rhs

◆ preProcess_Mat

◆ preProcess_Rhs

◆ problemName

◆ typeOfAssembly

◆ vecAssembleSwitch

◆ vErify

◆ zeroPreCondMatrixB