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

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 (IsKokkosObjectKey &&) 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	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	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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)

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

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 35 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(parameters.get<Real>("max_increment"))
 {
   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 66 of file ElementJacobianDamper.C.

 {
   // Maximum difference in the Jacobian for this Newton iteration
   Real max_difference = 0.0;
   MooseArray<Real> JxW_displaced;
 
   // Vector for storing the original node coordinates
   std::vector<Point> point_copies;
 
   PARALLEL_TRY
   {
     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 current 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)
           {
             dof_id_type disp_dof_num =
                 displaced_node.dof_number(_sys.number(), _disp_var[j]->number(), 0);
             displaced_node(j) += update(disp_dof_num);
           }
         }
 
         // Reinit element to compute Jacobian of displaced element
         _assembly.reinit(current_elem);
         JxW_displaced = _JxW;
 
         // Un-displace nodes
         for (unsigned int i = 0; i < current_elem->n_nodes(); ++i)
         {
           Node & displaced_node = current_elem->node_ref(i);
 
           for (unsigned int j = 0; j < _ndisp; ++j)
             displaced_node(j) = point_copies[i](j);
         }
 
         // Reinit element to compute Jacobian before displacement
         _assembly.reinit(current_elem);
 
         for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
         {
           Real diff = std::abs(JxW_displaced[qp] - _JxW[qp]) / _JxW[qp];
           if (diff > max_difference)
             max_difference = diff;
         }
 
         JxW_displaced.release();
       }
     }
     catch (MooseException & e)
     {
       _fe_problem.setException(e.what());
     }
     catch (std::exception & e)
     {
       // Allow the libmesh error/exception on negative jacobian
       const std::string & message = e.what();
       if (message.find("Jacobian") == std::string::npos)
         throw e;
       else
         _fe_problem.setException(message);
     }
   }
   PARALLEL_CATCH;
 
   _communicator.max(max_difference);
 
   if (max_difference > _max_jacobian_diff)
     return _max_jacobian_diff / max_difference;
 
   return 1.0;
 }

◆ initialSetup()

void ElementJacobianDamper::initialSetup ( )

overridevirtual

Reimplemented from GeneralDamper.

Definition at line 61 of file ElementJacobianDamper.C.

62 {

63 }

◆ validParams()

InputParameters ElementJacobianDamper::validParams ( )

static

Definition at line 21 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.set<bool>("use_displaced_mesh") = true;
   return params;
 }

Member Data Documentation

◆ _assembly

Assembly& ElementJacobianDamper::_assembly

protected

Definition at line 42 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 66 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

◆ _disp_var

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

protected

The displacement variables.

Definition at line 60 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

◆ _displaced_problem

MooseSharedPointer<DisplacedProblem> ElementJacobianDamper::_displaced_problem

protected

The displaced problem.

Definition at line 54 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

◆ _fe_problem

FEProblemBase& ElementJacobianDamper::_fe_problem

protected

The FE problem.

Definition at line 51 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _JxW

const MooseArray<Real>& ElementJacobianDamper::_JxW

protected

Transformed Jacobian weights.

Definition at line 48 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 69 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _mesh

MooseMesh* ElementJacobianDamper::_mesh

protected

The displaced mesh.

Definition at line 57 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

◆ _ndisp

unsigned int ElementJacobianDamper::_ndisp

protected

The number of displacement variables.

Definition at line 63 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

◆ _qrule

const QBase* const& ElementJacobianDamper::_qrule

protected

Quadrature rule.

Definition at line 45 of file ElementJacobianDamper.h.

Referenced by computeDamping().

◆ _tid

THREAD_ID ElementJacobianDamper::_tid

protected

Thread ID.

Definition at line 41 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

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

◆ validParams()

Member Data Documentation

◆ _assembly

◆ _disp_incr

◆ _disp_var

◆ _displaced_problem

◆ _fe_problem

◆ _JxW

◆ _max_jacobian_diff

◆ _mesh

◆ _ndisp

◆ _qrule

◆ _tid