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.

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.

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

Assembly &	_assembly

const QBase *const &	_qrule
	Quadrature rule.

const MooseArray< Real > &	_JxW
	Transformed Jacobian weights.

FEProblemBase &	_fe_problem
	The FE problem.

MooseSharedPointer< DisplacedProblem >	_displaced_problem
	The displaced problem.

MooseMesh *	_mesh
	The displaced mesh.

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

unsigned int	_ndisp
	The number of displacement variables.

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

const Real	_max_jacobian_diff
	Maximum allowed relative increment in Jacobian.

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

const Real	_backtrack_factor
	Multiplicative cutback applied during backtracking.

const unsigned int	_max_backtrack_steps
	Maximum number of backtracking attempts.

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

Private Member Functions
RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const RestartableDataMapName	_metaname

std::string	_restartable_name

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.

{
  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;
}

Referenced by computeDamping().

◆ 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

Private Member Functions

Static Private Member Functions

Private 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