ElementJacobianDamper Class Reference

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

#include <ElementJacobianDamper.h>

Inheritance diagram for ElementJacobianDamper:

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

Static Public Member Functions
static InputParameters	validParams ()

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

Detailed Description

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

Definition at line 28 of file ElementJacobianDamper.h.

Constructor & Destructor Documentation

ElementJacobianDamper()

ElementJacobianDamper::ElementJacobianDamper

(

const InputParameters &

parameters

)

Definition at line 37 of file ElementJacobianDamper.C.

  : GeneralDamper(parameters),
    _tid(parameters.get<THREAD_ID>("_tid")),
    _assembly(_subproblem.assembly(_tid)),
    _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.

Definition at line 68 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;
 
  // 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();
  }
 
  _communicator.max(max_difference);
 
  if (max_difference > _max_jacobian_diff)
    return _max_jacobian_diff / max_difference;
 
  return 1.0;
}

initialSetup()

void ElementJacobianDamper::initialSetup ( )

overridevirtual

Definition at line 63 of file ElementJacobianDamper.C.

{
}

validParams()

InputParameters ElementJacobianDamper::validParams ( )

static

Definition at line 23 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 46 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 70 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

_disp_var

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

protected

The displacement variables.

Definition at line 64 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

_displaced_problem

MooseSharedPointer<DisplacedProblem> ElementJacobianDamper::_displaced_problem

protected

The displaced problem.

Definition at line 58 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

_fe_problem

FEProblemBase& ElementJacobianDamper::_fe_problem

protected

The FE problem.

Definition at line 55 of file ElementJacobianDamper.h.

_JxW

const MooseArray<Real>& ElementJacobianDamper::_JxW

protected

Transformed Jacobian weights.

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

Referenced by computeDamping().

_mesh

MooseMesh* ElementJacobianDamper::_mesh

protected

The displaced mesh.

Definition at line 61 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

_ndisp

unsigned int ElementJacobianDamper::_ndisp

protected

The number of displacement variables.

Definition at line 67 of file ElementJacobianDamper.h.

Referenced by computeDamping(), and ElementJacobianDamper().

_qrule

const QBase* const & ElementJacobianDamper::_qrule

protected

Quadrature rule.

Definition at line 49 of file ElementJacobianDamper.h.

Referenced by computeDamping().

_tid

THREAD_ID ElementJacobianDamper::_tid

protected

Thread ID.

Definition at line 45 of file ElementJacobianDamper.h.

Referenced by ElementJacobianDamper().

---

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

• tensor_mechanics/include/dampers/ElementJacobianDamper.h
• tensor_mechanics/src/dampers/ElementJacobianDamper.C