MoFEM::SnesCtx::SnesCtxImpl Struct Reference

Collaboration diagram for MoFEM::SnesCtx::SnesCtxImpl:

Public Types
using	PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr
using	FEMethodsSequence = MoFEM::FEMethodsSequence
using	BasicMethodsSequence = MoFEM::BasicMethodsSequence
using	HookFunction = SnesCtx::HookFunction

Public Member Functions
	SnesCtxImpl (Interface &m_field, std::string problem_name)
virtual	~SnesCtxImpl ()=default
FEMethodsSequence &	getSetOperators ()
FEMethodsSequence &	getComputeRhs ()
BasicMethodsSequence &	getPreProcComputeRhs ()
BasicMethodsSequence &	getPostProcComputeRhs ()
BasicMethodsSequence &	getPreProcSetOperators ()
BasicMethodsSequence &	getPostProcSetOperators ()
FEMethodsSequence &	getLoadTangent ()
BasicMethodsSequence &	getPreProcLoadTangent ()
BasicMethodsSequence &	getPostProcLoadTangent ()
MoFEMErrorCode	copyLoops (const SnesCtxImpl &snes_ctx)
MoFEMErrorCode	clearLoops ()
HookFunction &	getLoadTangentHook ()
HookFunction &	getRhsHook ()

Protected Attributes
PetscLogEvent	MOFEM_EVENT_SnesRhs
	Log events to assemble residual.
PetscLogEvent	MOFEM_EVENT_SnesMat
	Log events to assemble tangent matrix.
PetscLogEvent	MOFEM_EVENT_SnesLoadTangent
MoFEM::Interface &	mField
	database Interface
moab::Interface &	moab
	moab Interface
std::string	problemName
	problem name
FEMethodsSequence	loopsOperator
FEMethodsSequence	loopsRhs
FEMethodsSequence	loopsLoadTangent
BasicMethodsSequence	preProcessOperator
BasicMethodsSequence	postProcessOperator
BasicMethodsSequence	preProcessLoadTangent
BasicMethodsSequence	preProcessRhs
	Sequence of methods run before residual is assembled.
BasicMethodsSequence	postProcessRhs
	Sequence of methods run after residual is assembled.
BasicMethodsSequence	postProcessLoadTangent
MoFEMTypes	bH
	If set to MF_EXIST check if element exist, default MF_EXIST.
bool	zeroPreCondMatrixB = true
bool	vErify = false
	If true verify vector.
MatAssemblyType	typeOfAssembly
	type of assembly at the end
HookFunction	loadTangentHook
HookFunction	rhsHook

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.
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.
MoFEMErrorCode	SNESMoFEMSetAssmblyType (SNES snes, MatAssemblyType type)
MoFEMErrorCode	SnesMoFEMSetBehavior (SNES snes, MoFEMTypes bh)
	Set behavior if finite element in sequence does not exist.
MoFEMErrorCode	SnesMoFEMSetAssemblyType (SNES snes, MatAssemblyType type)
	Set assembly type at the end of SnesMat.
MoFEMErrorCode	SnesMoFEMSetBehavior (SNES snes, MoFEMTypes bh)
	Set behavior if finite element in sequence does not exist.
MoFEMErrorCode	MoFEMSNESMonitorFields (SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx *snes_ctx)
	Sens monitor printing residual field by field.
MoFEMErrorCode	MoFEMSNESMonitorEnergy (SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx *snes_ctx)
	Sens monitor printing residual field by field.
PetscErrorCode	SnesLoadTangent (SNES snes, Vec u, Vec F, void *ctx)
	This function calls finite element pipeline to compute tangent of of load vector in arc length control.

Detailed Description

Definition at line 9 of file SnesCtx.cpp.

Member Typedef Documentation

BasicMethodsSequence

using MoFEM::SnesCtx::SnesCtxImpl::BasicMethodsSequence = MoFEM::BasicMethodsSequence

Definition at line 13 of file SnesCtx.cpp.

FEMethodsSequence

using MoFEM::SnesCtx::SnesCtxImpl::FEMethodsSequence = MoFEM::FEMethodsSequence

Definition at line 12 of file SnesCtx.cpp.

HookFunction

using MoFEM::SnesCtx::SnesCtxImpl::HookFunction = SnesCtx::HookFunction

Definition at line 14 of file SnesCtx.cpp.

PairNameFEMethodPtr

using MoFEM::SnesCtx::SnesCtxImpl::PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr

Definition at line 11 of file SnesCtx.cpp.

Constructor & Destructor Documentation

SnesCtxImpl()

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

Definition at line 181 of file SnesCtx.cpp.

    : mField(m_field), moab(m_field.get_moab()), problemName(problem_name) {
  PetscLogEventRegister("LoopSNESRhs", 0, &MOFEM_EVENT_SnesRhs);
  PetscLogEventRegister("LoopSNESMat", 0, &MOFEM_EVENT_SnesMat);
  PetscLogEventRegister("LoopSNESLoadTangent", 0, &MOFEM_EVENT_SnesLoadTangent);
  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");
  }
}

~SnesCtxImpl()

virtual MoFEM::SnesCtx::SnesCtxImpl::~SnesCtxImpl ( )

virtualdefault

Member Function Documentation

clearLoops()

MoFEMErrorCode MoFEM::SnesCtx::SnesCtxImpl::clearLoops

(

)

Definition at line 209 of file SnesCtx.cpp.

                                              {
  MoFEMFunctionBeginHot;
  loopsOperator.clear();
  loopsRhs.clear();
  preProcessOperator.clear();
  postProcessOperator.clear();
  preProcessRhs.clear();
  postProcessRhs.clear();
  loopsLoadTangent.clear();
  preProcessLoadTangent.clear();
  postProcessLoadTangent.clear();
  MoFEMFunctionReturnHot(0);
}

copyLoops()

MoFEMErrorCode MoFEM::SnesCtx::SnesCtxImpl::copyLoops

(

const SnesCtxImpl &

snes_ctx

)

Definition at line 195 of file SnesCtx.cpp.

                                                                        {
  MoFEMFunctionBeginHot;
  loopsOperator = snes_ctx.loopsOperator;
  loopsRhs = snes_ctx.loopsRhs;
  preProcessOperator = snes_ctx.preProcessOperator;
  postProcessOperator = snes_ctx.postProcessOperator;
  preProcessRhs = snes_ctx.preProcessRhs;
  postProcessRhs = snes_ctx.postProcessRhs;
  loopsLoadTangent = snes_ctx.loopsLoadTangent;
  preProcessLoadTangent = snes_ctx.preProcessLoadTangent;
  postProcessLoadTangent = snes_ctx.postProcessLoadTangent;
  MoFEMFunctionReturnHot(0);
}

getComputeRhs()

FEMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getComputeRhs ( )

inline

Definition at line 22 of file SnesCtx.cpp.

{ return loopsRhs; }

getLoadTangent()

FEMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getLoadTangent ( )

inline

Definition at line 34 of file SnesCtx.cpp.

{ return loopsLoadTangent; }

getLoadTangentHook()

HookFunction & MoFEM::SnesCtx::SnesCtxImpl::getLoadTangentHook ( )

inline

Definition at line 48 of file SnesCtx.cpp.

{ return loadTangentHook; }

getPostProcComputeRhs()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPostProcComputeRhs ( )

inline

Definition at line 26 of file SnesCtx.cpp.

{ return postProcessRhs; }

getPostProcLoadTangent()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPostProcLoadTangent ( )

inline

Definition at line 40 of file SnesCtx.cpp.

                                                 {
    return postProcessLoadTangent;
  }

getPostProcSetOperators()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPostProcSetOperators ( )

inline

Definition at line 30 of file SnesCtx.cpp.

                                                  {
    return postProcessOperator;
  }

getPreProcComputeRhs()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPreProcComputeRhs ( )

inline

Definition at line 24 of file SnesCtx.cpp.

{ return preProcessRhs; }

getPreProcLoadTangent()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPreProcLoadTangent ( )

inline

Definition at line 36 of file SnesCtx.cpp.

                                                {
    return preProcessLoadTangent;
  }

getPreProcSetOperators()

BasicMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getPreProcSetOperators ( )

inline

Definition at line 28 of file SnesCtx.cpp.

{ return preProcessOperator; }

getRhsHook()

HookFunction & MoFEM::SnesCtx::SnesCtxImpl::getRhsHook ( )

inline

Definition at line 50 of file SnesCtx.cpp.

{ return rhsHook; }

getSetOperators()

FEMethodsSequence & MoFEM::SnesCtx::SnesCtxImpl::getSetOperators ( )

inline

Definition at line 20 of file SnesCtx.cpp.

{ return loopsOperator; }

Friends And Related Symbol Documentation

MoFEMSNESMonitorEnergy

MoFEMErrorCode MoFEMSNESMonitorEnergy ( SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx * snes_ctx )

friend

Sens monitor printing residual field by field.

Definition at line 648 of file SnesCtx.cpp.

                                                    {
  MoFEMFunctionBegin;
  auto snes_ctx = ctx->snesCtxImpl.get();
  auto &m_field = snes_ctx->mField;
  auto problem_ptr = m_field.get_problem(snes_ctx->problemName);
  auto fields_ptr = m_field.get_fields();
  auto dofs = problem_ptr->numeredRowDofsPtr;
 
  std::vector<double> lnorms(3 * fields_ptr->size(), 0),
      norms(3 * fields_ptr->size(), 0);
 
  Vec x_update, res;
  if (its == 0)
    CHKERR SNESGetSolution(snes, &x_update);
  else
    CHKERR SNESGetSolutionUpdate(snes, &x_update);
  CHKERR SNESGetFunction(snes, &res, PETSC_NULLPTR, PETSC_NULLPTR);
 
  const double *x, *r;
  ;
  CHKERR VecGetArrayRead(res, &r);
  CHKERR VecGetArrayRead(x_update, &x);
 
  {
    int f = 0;
    for (auto fi : *fields_ptr) {
      const auto lo_uid = FieldEntity::getLoBitNumberUId(fi->bitNumber);
      const auto hi_uid = FieldEntity::getHiBitNumberUId(fi->bitNumber);
      const auto hi = dofs->get<Unique_mi_tag>().upper_bound(hi_uid);
      for (auto lo = dofs->get<Unique_mi_tag>().lower_bound(lo_uid); lo != hi;
           ++lo) {
        const DofIdx loc_idx = (*lo)->getPetscLocalDofIdx();
        if (loc_idx >= 0 && loc_idx < problem_ptr->nbLocDofsRow) {
          lnorms[3 * f] += std::abs(x[loc_idx] * r[loc_idx]);
          lnorms[3 * f + 1] += r[loc_idx] * r[loc_idx];
          lnorms[3 * f + 2] += x[loc_idx] * x[loc_idx];
        }
      }
      ++f;
    }
  }
  CHKERR VecRestoreArrayRead(res, &r);
  CHKERR VecRestoreArrayRead(x_update, &x);
 
  MPIU_Allreduce(&*lnorms.begin(), &*norms.begin(), lnorms.size(), MPIU_REAL,
                 MPIU_SUM, PetscObjectComm((PetscObject)snes));
 
  double energy_norm = 0, residual_norm = 0, increment_norm = 0;
  for (int f = 0; f != fields_ptr->size(); ++f) {
    energy_norm += norms[3 * f];
    residual_norm += norms[3 * f + 1];
    increment_norm += norms[3 * f + 2];
  }
  energy_norm = std::sqrt(energy_norm);
  residual_norm = std::sqrt(residual_norm);
  increment_norm = std::sqrt(increment_norm);
 
  {
    MOFEM_LOG("SNES_WORLD", Sev::inform)
        << its << " Function norm Enrgy/Residual/Increment"
        << boost::format(" %14.12e ") % energy_norm
        << boost::format(" %14.12e ") % residual_norm
        << boost::format(" %14.12e ") % increment_norm << "[";
    int f = 0;
    for (auto fi : *fields_ptr) {
      MOFEM_LOG("SNES_WORLD", Sev::inform)
          << its << "\t Energy/Residual/Increment norm "
          << boost::format("%14.12e") % std::sqrt(norms[3 * f]) << "\t"
          << boost::format("%14.12e") % std::sqrt(norms[3 * f + 1]) << " "
          << boost::format("%14.12e") % std::sqrt(norms[3 * f + 2]) << "\t "
          << fi->getName();
      ++f;
    }
    MOFEM_LOG("SNES_WORLD", Sev::inform) << its << " ]";
  }
 
  MoFEMFunctionReturn(0);
}

MoFEMSNESMonitorFields

MoFEMErrorCode MoFEMSNESMonitorFields ( SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx * snes_ctx )

friend

Sens monitor printing residual field by field.

Definition at line 592 of file SnesCtx.cpp.

                                                    {
  MoFEMFunctionBegin;
  auto snes_ctx = ctx->snesCtxImpl.get();
  auto &m_field = snes_ctx->mField;
  auto problem_ptr = m_field.get_problem(snes_ctx->problemName);
  auto fields_ptr = m_field.get_fields();
  auto dofs = problem_ptr->numeredRowDofsPtr;
 
  std::vector<double> lnorms(fields_ptr->size(), 0),
      norms(fields_ptr->size(), 0);
 
  Vec res;
  CHKERR SNESGetFunction(snes, &res, NULL, NULL);
 
  const double *r;
  CHKERR VecGetArrayRead(res, &r);
  {
    int f = 0;
    for (auto fi : *fields_ptr) {
      const auto lo_uid = FieldEntity::getLoBitNumberUId(fi->bitNumber);
      const auto hi_uid = FieldEntity::getHiBitNumberUId(fi->bitNumber);
      const auto hi = dofs->get<Unique_mi_tag>().upper_bound(hi_uid);
      for (auto lo = dofs->get<Unique_mi_tag>().lower_bound(lo_uid); lo != hi;
           ++lo) {
        const DofIdx loc_idx = (*lo)->getPetscLocalDofIdx();
        if (loc_idx >= 0 && loc_idx < problem_ptr->nbLocDofsRow) {
          lnorms[f] += PetscRealPart(PetscSqr(r[loc_idx]));
        }
      }
      ++f;
    }
  }
  CHKERR VecRestoreArrayRead(res, &r);
 
  MPIU_Allreduce(&*lnorms.begin(), &*norms.begin(), lnorms.size(), MPIU_REAL,
                 MPIU_SUM, PetscObjectComm((PetscObject)snes));
 
  {
    MOFEM_LOG("SNES_WORLD", Sev::inform)
        << its << " Function norm " << boost::format("%14.12e") % (double)fgnorm
        << " [";
    int f = 0;
    for (auto fi : *fields_ptr) {
      MOFEM_LOG("SNES_WORLD", Sev::inform)
          << its << "\t Field norm "
          << boost::format("%14.12e") % (double)PetscSqrtReal(norms[f]) << " "
          << fi->getName();
      ++f;
    }
    MOFEM_LOG("SNES_WORLD", Sev::inform) << its << "]";
  }
 
  MoFEMFunctionReturn(0);
}

SnesLoadTangent

PetscErrorCode SnesLoadTangent ( SNES snes, Vec u, Vec F, void * ctx )

friend

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/

Parameters

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

Returns

Error code

Definition at line 353 of file SnesCtx.cpp.

                                                                   {
  auto *snes_ctx = static_cast<SnesCtx *>(ctx)->snesCtxImpl.get();
  MoFEMFunctionBegin;
  PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesLoadTangent, 0, 0, 0, 0);
  Vec dx;
  CHKERR SNESGetSolutionUpdate(snes, &dx);
  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);
 
  auto vec_assemble_switch = 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) {
    MoFEMFunctionBeginHot;
    fe.snes = snes;
    fe.snes_x = x;
    fe.snes_dx = dx;
    fe.snes_f = f;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX | PetscData::CtxSetDX;
 
    CHKERR SNESGetKSP(snes, &fe.ksp);
 
    // If SNES is of type SNESNEWTONAL then get load parameter, will act as a
    // psued time
    PetscBool same;
    CHKERR PetscObjectTypeCompare((PetscObject)snes, SNESNEWTONAL, &same);
    if (same) {
      CHKERR SNESNewtonALGetLoadParameter(snes, &fe.ts_t);
      fe.data_ctx |= PetscData::CtxSetTime;
    }
 
    fe.cacheWeakPtr = cache_ptr;
    MoFEMFunctionReturnHot(0);
  };
 
  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->preProcessLoadTangent) {
    bit->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_preProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    vec_assemble_switch = boost::move(bit->vecAssembleSwitch);
  }
 
  for (auto &lit : snes_ctx->loopsLoadTangent) {
    lit.second->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR 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);
    }
 
    vec_assemble_switch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  for (auto &bit : snes_ctx->postProcessLoadTangent) {
    bit->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_postProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    vec_assemble_switch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*(vec_assemble_switch)) {
    CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
  }
 
  if (snes_ctx->loadTangentHook) {
    CHKERR snes_ctx->loadTangentHook(snes, x, f, cache_ptr, ctx);
  }
 
  PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesLoadTangent, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

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 483 of file SnesCtx.cpp.

                                                                  {
  auto *snes_ctx = static_cast<SnesCtx *>(ctx)->snesCtxImpl.get();
  MoFEMFunctionBegin;
  PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
 
  auto mat_assemble_switch = 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);
  Vec dx;
  CHKERR SNESGetSolutionUpdate(snes, &dx);
 
  auto set = [&](auto &fe) {
    MoFEMFunctionBeginHot;
    fe.snes = snes;
    fe.snes_x = x;
    fe.snes_dx = dx;
    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 |
                  PetscData::CtxSetDX;
 
    CHKERR SNESGetKSP(snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    MoFEMFunctionReturnHot(0);
  };
 
  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);
 
  if (*mat_assemble_switch) {
    if (snes_ctx->zeroPreCondMatrixB)
      CHKERR MatZeroEntries(B);
  }
  for (auto &bit : snes_ctx->preProcessOperator) {
    bit->matAssembleSwitch = boost::move(mat_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_preProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    mat_assemble_switch = boost::move(bit->matAssembleSwitch);
  }
 
  for (auto &lit : snes_ctx->loopsOperator) {
    lit.second->matAssembleSwitch = boost::move(mat_assemble_switch);
    CHKERR 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);
    mat_assemble_switch = boost::move(lit.second->matAssembleSwitch);
  }
 
  for (auto &bit : snes_ctx->postProcessOperator) {
    bit->matAssembleSwitch = boost::move(mat_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_postProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    mat_assemble_switch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*mat_assemble_switch) {
    CHKERR MatAssemblyBegin(B, snes_ctx->typeOfAssembly);
    CHKERR MatAssemblyEnd(B, snes_ctx->typeOfAssembly);
  }
  PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

SnesMoFEMSetAssemblyType

MoFEMErrorCode SnesMoFEMSetAssemblyType ( SNES snes, MatAssemblyType type )

friend

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

Parameters

snes
type	type of assembly, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY

Returns

error code

Definition at line 564 of file SnesCtx.cpp.

                                                                         {
 
  auto get_snes_ctx = [](SNES snes) {
    SnesCtx *snes_ctx;
    CHK_THROW_MESSAGE(SNESGetApplicationContext(snes, &snes_ctx),
                      "Cannot get SNES context");
    return snes_ctx->snesCtxImpl.get();
  };
 
  MoFEMFunctionBegin;
  get_snes_ctx(snes)->typeOfAssembly = type;
  MoFEMFunctionReturn(0);
}

SNESMoFEMSetAssmblyType

MoFEMErrorCode SNESMoFEMSetAssmblyType ( SNES snes, MatAssemblyType type )

friend

SnesMoFEMSetBehavior [1/2]

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 578 of file SnesCtx.cpp.

                                                              {
 
  auto get_snes_ctx = [](SNES snes) {
    SnesCtx *snes_ctx;
    CHK_THROW_MESSAGE(SNESGetApplicationContext(snes, &snes_ctx),
                      "Cannot get SNES context");
    return snes_ctx->snesCtxImpl.get();
  };
 
  MoFEMFunctionBegin;
  get_snes_ctx(snes)->bH = bh;
  MoFEMFunctionReturn(0);
}

SnesMoFEMSetBehavior [2/2]

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 578 of file SnesCtx.cpp.

                                                              {
 
  auto get_snes_ctx = [](SNES snes) {
    SnesCtx *snes_ctx;
    CHK_THROW_MESSAGE(SNESGetApplicationContext(snes, &snes_ctx),
                      "Cannot get SNES context");
    return snes_ctx->snesCtxImpl.get();
  };
 
  MoFEMFunctionBegin;
  get_snes_ctx(snes)->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 223 of file SnesCtx.cpp.

                                                           {
  auto *snes_ctx = static_cast<SnesCtx *>(ctx)->snesCtxImpl.get();
  MoFEMFunctionBegin;
  PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
  Vec dx;
  CHKERR SNESGetSolutionUpdate(snes, &dx);
  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);
 
  auto vec_assemble_switch = 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) {
    MoFEMFunctionBeginHot;
    fe.snes = snes;
    fe.snes_x = x;
    fe.snes_dx = dx;
    fe.snes_f = f;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX | PetscData::CtxSetDX;
 
    CHKERR SNESGetKSP(snes, &fe.ksp);
 
    // If SNES is of type SNESNEWTONAL then get load parameter, will act as a
    // psued time
    PetscBool same;
    CHKERR PetscObjectTypeCompare((PetscObject)snes, SNESNEWTONAL, &same);
    if (same) {
      CHKERR SNESNewtonALGetLoadParameter(snes, &fe.ts_t);
      fe.data_ctx |= PetscData::CtxSetTime;
    }
 
    fe.cacheWeakPtr = cache_ptr;
    MoFEMFunctionReturnHot(0);
  };
 
  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->preProcessRhs) {
    bit->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_preProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    vec_assemble_switch = boost::move(bit->vecAssembleSwitch);
  }
 
  for (auto &lit : snes_ctx->loopsRhs) {
    lit.second->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR 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);
    }
 
    vec_assemble_switch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  for (auto &bit : snes_ctx->postProcessRhs) {
    bit->vecAssembleSwitch = boost::move(vec_assemble_switch);
    CHKERR set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_postProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    vec_assemble_switch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*(vec_assemble_switch)) {
    CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
  }
 
  if (snes_ctx->rhsHook) {
    CHKERR snes_ctx->rhsHook(snes, x, f, cache_ptr, ctx);
  }
 
  PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

bH

MoFEMTypes MoFEM::SnesCtx::SnesCtxImpl::bH

protected

Initial value:

=
      MF_EXIST

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

Definition at line 110 of file SnesCtx.cpp.

loadTangentHook

HookFunction MoFEM::SnesCtx::SnesCtxImpl::loadTangentHook

protected

Hook function called at the end of load tangent evaluation

Definition at line 118 of file SnesCtx.cpp.

loopsLoadTangent

FEMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::loopsLoadTangent

protected

Sequence of finite elements instances assembling tangent of load vector in arc length control

Definition at line 91 of file SnesCtx.cpp.

loopsOperator

FEMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::loopsOperator

protected

Sequence of finite elements instances assembling tangent matrix

Definition at line 86 of file SnesCtx.cpp.

loopsRhs

FEMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::loopsRhs

protected

Sequence of finite elements instances assembling residual vector

Definition at line 88 of file SnesCtx.cpp.

mField

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

protected

database Interface

Definition at line 81 of file SnesCtx.cpp.

moab

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

protected

moab Interface

Definition at line 82 of file SnesCtx.cpp.

MOFEM_EVENT_SnesLoadTangent

PetscLogEvent MoFEM::SnesCtx::SnesCtxImpl::MOFEM_EVENT_SnesLoadTangent

protected

Log events to assemble tangent of load vector

Definition at line 78 of file SnesCtx.cpp.

MOFEM_EVENT_SnesMat

PetscLogEvent MoFEM::SnesCtx::SnesCtxImpl::MOFEM_EVENT_SnesMat

protected

Log events to assemble tangent matrix.

Definition at line 77 of file SnesCtx.cpp.

MOFEM_EVENT_SnesRhs

PetscLogEvent MoFEM::SnesCtx::SnesCtxImpl::MOFEM_EVENT_SnesRhs

protected

Log events to assemble residual.

Definition at line 76 of file SnesCtx.cpp.

postProcessLoadTangent

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::postProcessLoadTangent

protected

Sequence of methods run after tangent of load vector in arc length control is assembled

Definition at line 107 of file SnesCtx.cpp.

postProcessOperator

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::postProcessOperator

protected

Sequence of methods run after tangent matrix is assembled

Definition at line 96 of file SnesCtx.cpp.

postProcessRhs

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::postProcessRhs

protected

Sequence of methods run after residual is assembled.

Definition at line 105 of file SnesCtx.cpp.

preProcessLoadTangent

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::preProcessLoadTangent

protected

Sequence of methods run before tangent of load vector in arc length control is assembled

Definition at line 99 of file SnesCtx.cpp.

preProcessOperator

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::preProcessOperator

protected

Sequence of methods run before tangent matrix is assembled

Definition at line 94 of file SnesCtx.cpp.

preProcessRhs

BasicMethodsSequence MoFEM::SnesCtx::SnesCtxImpl::preProcessRhs

protected

Sequence of methods run before residual is assembled.

Definition at line 103 of file SnesCtx.cpp.

problemName

std::string MoFEM::SnesCtx::SnesCtxImpl::problemName

protected

problem name

Definition at line 84 of file SnesCtx.cpp.

rhsHook

HookFunction MoFEM::SnesCtx::SnesCtxImpl::rhsHook

protected

Hook function called at the end of residual evaluation

Definition at line 121 of file SnesCtx.cpp.

typeOfAssembly

MatAssemblyType MoFEM::SnesCtx::SnesCtxImpl::typeOfAssembly

protected

Initial value:

=
      MAT_FINAL_ASSEMBLY

type of assembly at the end

Definition at line 115 of file SnesCtx.cpp.

vErify

bool MoFEM::SnesCtx::SnesCtxImpl::vErify = false

protected

If true verify vector.

Definition at line 114 of file SnesCtx.cpp.

zeroPreCondMatrixB

bool MoFEM::SnesCtx::SnesCtxImpl::zeroPreCondMatrixB = true

protected

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

Definition at line 112 of file SnesCtx.cpp.

---

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

• src/petsc/impl/SnesCtx.cpp