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

#include "src/petsc/SnesCtx.hpp"

Collaboration diagram for MoFEM::SnesCtx:

Classes
struct	SnesCtxImpl

Public Types
using	PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr

using	FEMethodsSequence = MoFEM::FEMethodsSequence

using	BasicMethodsSequence = MoFEM::BasicMethodsSequence

using	HookFunction

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

virtual	~SnesCtx ()

FEMethodsSequence &	getSetOperators ()

FEMethodsSequence &	getComputeRhs ()

BasicMethodsSequence &	getPreProcComputeRhs ()

BasicMethodsSequence &	getPostProcComputeRhs ()

BasicMethodsSequence &	getPreProcSetOperators ()

BasicMethodsSequence &	getPostProcSetOperators ()

FEMethodsSequence &	getLoadTangent ()
	Get the finite element pipeline for FunctionFn, that calculate tangent of function load for arc length control.

BasicMethodsSequence &	getPreProcLoadTangent ()
	Get the BasicMethod sequence for preprocessing of FunctionFn.

BasicMethodsSequence &	getPostProcLoadTangent ()
	Get the BasicMethod sequence for postprocessing of FunctionFn.

HookFunction &	getLoadTangentHook ()
	Get the Load Tangent Hook function.

HookFunction &	getRhsHook ()
	Get the Right Hand Side Hook function.

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

MoFEMErrorCode	clearLoops ()
	Clear loops.

Protected Attributes
boost::movelib::unique_ptr< SnesCtxImpl >	snesCtxImpl

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	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

Interface for nonlinear (SNES) solver.

Examples: minimal_surface_area.cpp, navier_stokes.cpp, nonlinear_dynamics.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 15 of file SnesCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

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

Definition at line 19 of file SnesCtx.hpp.

◆ FEMethodsSequence

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

Definition at line 18 of file SnesCtx.hpp.

◆ HookFunction

using MoFEM::SnesCtx::HookFunction

Initial value:

 boost::function<MoFEMErrorCode(
      SNES snes, Vec x, Vec F, boost::shared_ptr<CacheTuple> cache_ptr,
      void *ctx)>

Definition at line 20 of file SnesCtx.hpp.

◆ PairNameFEMethodPtr

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

Definition at line 17 of file SnesCtx.hpp.

Constructor & Destructor Documentation

◆ SnesCtx()

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

Definition at line 125 of file SnesCtx.cpp.

126 : snesCtxImpl(boost::movelib::make_unique<SnesCtx::SnesCtxImpl>(

127 m_field, problem_name)) {}

MoFEM::SnesCtx::snesCtxImpl

boost::movelib::unique_ptr< SnesCtxImpl > snesCtxImpl

Definition SnesCtx.hpp:150

◆ ~SnesCtx()

MoFEM::SnesCtx::~SnesCtx ( )

virtualdefault

Member Function Documentation

◆ clearLoops()

MoFEMErrorCode MoFEM::SnesCtx::clearLoops ( )

Clear loops.

Returns: MoFEMErrorCode

Definition at line 171 of file SnesCtx.cpp.

171{ return snesCtxImpl->clearLoops(); }

◆ copyLoops()

MoFEMErrorCode MoFEM::SnesCtx::copyLoops ( const SnesCtx & snes_ctx )

Copy sequences from other SNES context.

Parameters

snes_ctx SNES context from which Sequence is copied from

Returns: error code

Definition at line 167 of file SnesCtx.cpp.

                                                         {
  return snesCtxImpl->copyLoops(*snes_ctx.snesCtxImpl);
}

◆ getComputeRhs()

FEMethodsSequence & MoFEM::SnesCtx::getComputeRhs ( )

Returns: return vector to vector with FEMethod to calculate residual

Definition at line 135 of file SnesCtx.cpp.

                                          {
  return snesCtxImpl->getComputeRhs();
}

◆ getLoadTangent()

FEMethodsSequence & MoFEM::SnesCtx::getLoadTangent ( )

Get the finite element pipeline for FunctionFn, that calculate tangent of function load for arc length control.

Returns: FEMethodsSequence&

Definition at line 155 of file SnesCtx.cpp.

                                           {
  return snesCtxImpl->getLoadTangent();
}

◆ getLoadTangentHook()

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

Get the Load Tangent Hook function.

Using hook you can debug or post-process while load vector tangent is evaluated

Returns: HookFunction&

Definition at line 173 of file SnesCtx.cpp.

                                                 {
  return snesCtxImpl->getLoadTangentHook();
}

◆ getPostProcComputeRhs()

BasicMethodsSequence & MoFEM::SnesCtx::getPostProcComputeRhs ( )

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

                                                     {
  return snesCtxImpl->getPostProcComputeRhs();
}

◆ getPostProcLoadTangent()

BasicMethodsSequence & MoFEM::SnesCtx::getPostProcLoadTangent ( )

Get the BasicMethod sequence for postprocessing of FunctionFn.

Returns: BasicMethodsSequence&

Definition at line 163 of file SnesCtx.cpp.

                                                      {
  return snesCtxImpl->getPostProcLoadTangent();
}

◆ getPostProcSetOperators()

BasicMethodsSequence & MoFEM::SnesCtx::getPostProcSetOperators ( )

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

                                                       {
  return snesCtxImpl->getPostProcSetOperators();
}

◆ getPreProcComputeRhs()

BasicMethodsSequence & MoFEM::SnesCtx::getPreProcComputeRhs ( )

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

                                                    {
  return snesCtxImpl->getPreProcComputeRhs();
}

◆ getPreProcLoadTangent()

BasicMethodsSequence & MoFEM::SnesCtx::getPreProcLoadTangent ( )

Get the BasicMethod sequence for preprocessing of FunctionFn.

Returns: BasicMethodsSequence&

Definition at line 159 of file SnesCtx.cpp.

                                                     {
  return snesCtxImpl->getPreProcLoadTangent();
}

◆ getPreProcSetOperators()

BasicMethodsSequence & MoFEM::SnesCtx::getPreProcSetOperators ( )

Returns: reference to BasicMethod for preprocessing

Definition at line 147 of file SnesCtx.cpp.

                                                      {
  return snesCtxImpl->getPreProcSetOperators();
}

◆ getRhsHook()

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

Get the Right Hand Side Hook function.

Using hook you can debug or post-process while right hand side vector is evaluated

Returns: HookFunction&

Definition at line 177 of file SnesCtx.cpp.

                                         {
  return snesCtxImpl->getRhsHook();
}

◆ getSetOperators()

FEMethodsSequence & MoFEM::SnesCtx::getSetOperators ( )

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

Definition at line 131 of file SnesCtx.cpp.

                                            {
  return snesCtxImpl->getSetOperators();
}

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

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

◆ snesCtxImpl

boost::movelib::unique_ptr<SnesCtxImpl> MoFEM::SnesCtx::snesCtxImpl

protected

Definition at line 150 of file SnesCtx.hpp.

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

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

Classes

Public Types

Public Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BasicMethodsSequence

◆ FEMethodsSequence

◆ HookFunction

◆ PairNameFEMethodPtr

Constructor & Destructor Documentation

◆ SnesCtx()

◆ ~SnesCtx()

Member Function Documentation

◆ clearLoops()

◆ copyLoops()

◆ getComputeRhs()

◆ getLoadTangent()

◆ getLoadTangentHook()

◆ getPostProcComputeRhs()

◆ getPostProcLoadTangent()

◆ getPostProcSetOperators()

◆ getPreProcComputeRhs()

◆ getPreProcLoadTangent()

◆ getPreProcSetOperators()

◆ getRhsHook()

◆ getSetOperators()

Friends And Related Symbol Documentation

◆ MoFEMSNESMonitorEnergy

◆ MoFEMSNESMonitorFields

◆ SnesLoadTangent

◆ SnesMat

◆ SnesMoFEMSetAssemblyType

◆ SNESMoFEMSetAssmblyType

◆ SnesMoFEMSetBehavior

◆ SnesRhs

Member Data Documentation

◆ snesCtxImpl