This class implements a damper that limits the change in the Jacobian of elements. More...

#include <ElementJacobianDamper.h>

Inheritance diagram for ElementJacobianDamper:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ElementJacobianDamper (const InputParameters &parameters)

virtual void	initialSetup () override

virtual Real	computeDamping (const NumericVector< Number > &, const NumericVector< Number > &update) override
	Computes this Damper's damping. More...

bool	probeDamping (const NumericVector< Number > &update, Real damping, Real &max_difference, std::string &error_message)
	Probe a damped update on the displaced mesh and report the maximum relative change in JxW. More...

void	checkMinDamping (const Real cur_damping) const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	haveParameter (const std::string &name) const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	subdomainSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

virtual void	meshChanged ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

Protected Attributes
THREAD_ID	_tid
	Thread ID. More...

Assembly &	_assembly

const QBase *const &	_qrule
	Quadrature rule. More...

const MooseArray< Real > &	_JxW
	Transformed Jacobian weights. More...

FEProblemBase &	_fe_problem
	The FE problem. More...

MooseSharedPointer< DisplacedProblem >	_displaced_problem
	The displaced problem. More...

MooseMesh *	_mesh
	The displaced mesh. More...

std::vector< MooseVariable * >	_disp_var
	The displacement variables. More...

unsigned int	_ndisp
	The number of displacement variables. More...

std::vector< VariableValue >	_disp_incr
	The current Newton increment in the displacement variables. More...

const Real	_max_jacobian_diff
	Maximum allowed relative increment in Jacobian. More...

const bool	_use_backtracking
	Whether to backtrack the trial update when probing would otherwise create a degenerate map. More...

const Real	_backtrack_factor
	Multiplicative cutback applied during backtracking. More...

const unsigned int	_max_backtrack_steps
	Maximum number of backtracking attempts. More...

SubProblem &	_subproblem

SystemBase &	_sys

const Real &	_min_damping

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

const Parallel::Communicator &	_communicator

Detailed Description

This class implements a damper that limits the change in the Jacobian of elements.

Definition at line 24 of file ElementJacobianDamper.h.

Constructor & Destructor Documentation

◆ ElementJacobianDamper()

ElementJacobianDamper::ElementJacobianDamper ( const InputParameters & parameters )

Definition at line 66 of file ElementJacobianDamper.C.

   : GeneralDamper(parameters),
     _tid(parameters.get<THREAD_ID>("_tid")),
     _assembly(_subproblem.assembly(_tid, _sys.number())),
     _qrule(_assembly.qRule()),
     _JxW(_assembly.JxW()),
     _fe_problem(*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
     _displaced_problem(_fe_problem.getDisplacedProblem()),
     _max_jacobian_diff(getParam<Real>("max_increment")),
     _use_backtracking(getParam<bool>("use_backtracking")),
     _backtrack_factor(getParam<Real>("backtrack_factor")),
     _max_backtrack_steps(getParam<unsigned int>("max_backtrack_steps"))
 {
   if (_displaced_problem == NULL)
     mooseError("ElementJacobianDamper: Must use displaced problem");
 
   _mesh = &_displaced_problem->mesh();
 
   const std::vector<VariableName> & nl_vnames(getParam<std::vector<VariableName>>("displacements"));
   _ndisp = nl_vnames.size();
 
   for (unsigned int i = 0; i < _ndisp; ++i)
   {
     _disp_var.push_back(&_sys.getFieldVariable<Real>(_tid, nl_vnames[i]));
     _disp_incr.push_back(_disp_var.back()->increment());
   }
 }

Member Function Documentation

◆ computeDamping()

Real ElementJacobianDamper::computeDamping	(	const NumericVector< Number > &	,
		const NumericVector< Number > &	update
	)

overridevirtual

Computes this Damper's damping.

Implements GeneralDamper.

Definition at line 100 of file ElementJacobianDamper.C.

 {
   auto probe_trial =
       [&](const Real trial_damping, Real & max_difference, std::string & error_message)
   {
     const bool trial_nondegenerate_local =
         probeDamping(update, trial_damping, max_difference, error_message);
 
     _communicator.max(max_difference);
 
     const unsigned int invalid_local = trial_nondegenerate_local ? 0 : 1;
     unsigned int invalid = invalid_local;
     _communicator.max(invalid);
 
     if (invalid)
     {
       processor_id_type first_invalid_processor =
           invalid_local ? _communicator.rank() : std::numeric_limits<processor_id_type>::max();
       _communicator.min(first_invalid_processor);
       _communicator.broadcast(error_message, first_invalid_processor);
     }
 
     return !invalid;
   };
 
   if (!_use_backtracking)
   {
     Real max_difference = 0.0;
     std::string error_message;
 
     PARALLEL_TRY
     {
       if (!probe_trial(/*trial_damping=*/1.0, max_difference, error_message))
         _fe_problem.setException(error_message);
     }
     PARALLEL_CATCH;
 
     if (max_difference > _max_jacobian_diff)
       return _max_jacobian_diff / max_difference;
 
     return 1.0;
   }
 
   const Real minimum_trial_damping = std::max(_min_damping, std::numeric_limits<Real>::epsilon());
   Real damping = 1.0;
   std::string error_message;
 
   // Try 1 step, then at most max_backtrack_steps extra steps
   for (unsigned int step = 0; step <= _max_backtrack_steps; ++step)
   {
     Real max_difference = 0.0;
     bool trial_nondegenerate = false;
 
     PARALLEL_TRY { trial_nondegenerate = probe_trial(damping, max_difference, error_message); }
     PARALLEL_CATCH;
 
     if (trial_nondegenerate && max_difference <= _max_jacobian_diff)
       return damping;
 
     if (damping <= minimum_trial_damping || step == _max_backtrack_steps)
     {
       if (!trial_nondegenerate)
         _fe_problem.setException(error_message.empty()
                                      ? "ElementJacobianDamper could not find a nondegenerate "
                                        "trial update."
                                      : error_message);
       else
         _fe_problem.setException("ElementJacobianDamper could not reduce the relative Jacobian "
                                  "increment below max_increment without driving the damping "
                                  "factor below a usable threshold.");
 
       // The exception flag will abort the nonlinear step after the damper returns, so return the
       // last trial damping only to satisfy the interface.
       return damping;
     }
 
     if (!trial_nondegenerate)
       damping *= _backtrack_factor;
     else
       damping =
           std::min(damping * _backtrack_factor, damping * _max_jacobian_diff / max_difference);
   }
 
   return damping;
 }

◆ initialSetup()

void ElementJacobianDamper::initialSetup ( )

overridevirtual

Reimplemented from GeneralDamper.

Definition at line 95 of file ElementJacobianDamper.C.

96 {

97 }

◆ probeDamping()

bool ElementJacobianDamper::probeDamping	(	const NumericVector< Number > &	update,
		Real	damping,
		Real &	max_difference,
		std::string &	error_message
	)

Probe a damped update on the displaced mesh and report the maximum relative change in JxW.

Returns false if the trial update produces a degenerate map.

Definition at line 188 of file ElementJacobianDamper.C.

Referenced by computeDamping().

 {
   MooseArray<Real> JxW_displaced;
 
   // Vector for storing the original node coordinates
   std::vector<Point> point_copies;
 
   max_difference = 0.0;
   error_message.clear();
 
   try
   {
     // Loop over elements in the mesh
     for (auto & current_elem : _mesh->getMesh().active_local_element_ptr_range())
     {
       point_copies.clear();
       point_copies.reserve(current_elem->n_nodes());
 
       // Displace nodes with the trial Newton increment
       for (unsigned int i = 0; i < current_elem->n_nodes(); ++i)
       {
         Node & displaced_node = current_elem->node_ref(i);
 
         point_copies.push_back(displaced_node);
 
         for (unsigned int j = 0; j < _ndisp; ++j)
         {
           const dof_id_type disp_dof_num =
               displaced_node.dof_number(_sys.number(), _disp_var[j]->number(), 0);
           displaced_node(j) += damping * update(disp_dof_num);
         }
       }
 
       try
       {
         // Reinit element to compute Jacobian of the trial displaced element
         _assembly.reinit(current_elem);
         JxW_displaced = _JxW;
       }
       catch (const std::exception & e)
       {
         restoreNodes(*current_elem, point_copies);
 
         // Degenerate-map failures mean this trial damping is too aggressive
         if (strstr(e.what(), "Jacobian") || strstr(e.what(), "singular") ||
             strstr(e.what(), "det != 0"))
         {
           error_message = e.what();
           return false;
         }
 
         throw;
       }
 
       restoreNodes(*current_elem, point_copies);
 
       // Reinit element to compute Jacobian before displacement
       try
       {
         _assembly.reinit(current_elem);
       }
       catch (const std::exception & e)
       {
         if (strstr(e.what(), "Jacobian") || strstr(e.what(), "singular") ||
             strstr(e.what(), "det != 0"))
         {
           error_message = e.what();
           return false;
         }
 
         throw;
       }
 
       for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
       {
         const Real denominator = std::max(std::abs(_JxW[qp]), libMesh::TOLERANCE);
         const Real diff = std::abs(JxW_displaced[qp] - _JxW[qp]) / denominator;
         if (diff > max_difference)
           max_difference = diff;
       }
 
       JxW_displaced.release();
     }
   }
   catch (const MooseException & e)
   {
     error_message = e.what();
     _fe_problem.setException(e.what());
     return false;
   }
 
   return true;
 }

◆ validParams()

InputParameters ElementJacobianDamper::validParams ( )

static

Definition at line 38 of file ElementJacobianDamper.C.

 {
   InputParameters params = GeneralDamper::validParams();
   params.addClassDescription("Damper that limits the change in element Jacobians");
   params.addParam<std::vector<VariableName>>(
       "displacements", {}, "The nonlinear displacement variables");
   params.addParam<Real>(
       "max_increment",
       0.1,
       "The maximum permissible relative increment in the Jacobian per Newton iteration");
   params.addParam<bool>(
       "use_backtracking",
       false,
       "If true, iteratively cut back the probed Newton update when a full trial update would "
       "create a degenerate displaced element map. The accepted trial must also satisfy "
       "max_increment.");
   params.addRangeCheckedParam<Real>(
       "backtrack_factor",
       0.5,
       "backtrack_factor > 0 & backtrack_factor < 1",
       "Multiplicative cutback applied to the trial damping during ElementJacobianDamper "
       "backtracking.");
   params.addParam<unsigned int>(
       "max_backtrack_steps", 12, "Maximum number of ElementJacobianDamper backtracking attempts.");
   params.set<bool>("use_displaced_mesh") = true;
   return params;
 }

Member Data Documentation

◆ _assembly

Assembly& ElementJacobianDamper::_assembly

protected

Definition at line 51 of file ElementJacobianDamper.h.

Referenced by probeDamping().

◆ _backtrack_factor

const Real ElementJacobianDamper::_backtrack_factor

protected

Multiplicative cutback applied during backtracking.

Definition at line 84 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _disp_incr

std::vector<VariableValue> ElementJacobianDamper::_disp_incr

protected

The current Newton increment in the displacement variables.

Definition at line 75 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

◆ _disp_var

std::vector<MooseVariable *> ElementJacobianDamper::_disp_var

protected

The displacement variables.

Definition at line 69 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper(), and probeDamping().

◆ _displaced_problem

MooseSharedPointer<DisplacedProblem> ElementJacobianDamper::_displaced_problem

protected

The displaced problem.

Definition at line 63 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

◆ _fe_problem

FEProblemBase& ElementJacobianDamper::_fe_problem

protected

The FE problem.

Definition at line 60 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and probeDamping().

◆ _JxW

const MooseArray<Real>& ElementJacobianDamper::_JxW

protected

Transformed Jacobian weights.

Definition at line 57 of file ElementJacobianDamper.h.

Referenced by probeDamping().

◆ _max_backtrack_steps

const unsigned int ElementJacobianDamper::_max_backtrack_steps

protected

Maximum number of backtracking attempts.

Definition at line 87 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _max_jacobian_diff

const Real ElementJacobianDamper::_max_jacobian_diff

protected

Maximum allowed relative increment in Jacobian.

Definition at line 78 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _mesh

MooseMesh* ElementJacobianDamper::_mesh

protected

The displaced mesh.

Definition at line 66 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper(), and probeDamping().

◆ _ndisp

unsigned int ElementJacobianDamper::_ndisp

protected

The number of displacement variables.

Definition at line 72 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper(), and probeDamping().

◆ _qrule

const QBase* const& ElementJacobianDamper::_qrule

protected

Quadrature rule.

Definition at line 54 of file ElementJacobianDamper.h.

Referenced by probeDamping().

◆ _tid

THREAD_ID ElementJacobianDamper::_tid

protected

Thread ID.

Definition at line 50 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

◆ _use_backtracking

const bool ElementJacobianDamper::_use_backtracking

protected

Whether to backtrack the trial update when probing would otherwise create a degenerate map.

Definition at line 81 of file ElementJacobianDamper.h.

Referenced by computeDamping().

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

solid_mechanics/include/dampers/ElementJacobianDamper.h
solid_mechanics/src/dampers/ElementJacobianDamper.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ElementJacobianDamper()

Member Function Documentation

◆ computeDamping()

◆ initialSetup()

◆ probeDamping()

◆ validParams()

Member Data Documentation

◆ _assembly

◆ _backtrack_factor

◆ _disp_incr

◆ _disp_var

◆ _displaced_problem

◆ _fe_problem

◆ _JxW

◆ _max_backtrack_steps

◆ _max_jacobian_diff

◆ _mesh

◆ _ndisp

◆ _qrule

◆ _tid

◆ _use_backtracking