AugmentedLagrangianContactConvergence< T > Class Template Reference

Class to check convergence for the augmented Lagrangian contact problem. More...

#include <AugmentedLagrangianContactConvergence.h>

Inheritance diagram for AugmentedLagrangianContactConvergence< T >:

Public Member Functions
	AugmentedLagrangianContactConvergence (const InputParameters &params)
virtual Convergence::MooseConvergenceStatus	checkConvergence (unsigned int iter) override
virtual const unsigned int &	getLagrangianIterationNumber () const
virtual void	setLagrangianIterationNumber (unsigned int iter)

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
unsigned int	_lagrangian_iteration_number
	current augmented lagrange iteration number
const unsigned int	_maximum_number_lagrangian_iterations
	maximum mumber of augmented lagrange iterations

Detailed Description

template<class T>
class AugmentedLagrangianContactConvergence< T >

Class to check convergence for the augmented Lagrangian contact problem.

Template Parameters

T	a convergence class type to use for such problems

Definition at line 21 of file AugmentedLagrangianContactConvergence.h.

Constructor & Destructor Documentation

AugmentedLagrangianContactConvergence()

template<class T >

AugmentedLagrangianContactConvergence< T >::AugmentedLagrangianContactConvergence

(

const InputParameters &

params

)

Definition at line 47 of file AugmentedLagrangianContactConvergence.C.

  : T(params), AugmentedLagrangianContactProblemInterface(params)
{
}

Member Function Documentation

checkConvergence()

template<class T >

Convergence::MooseConvergenceStatus AugmentedLagrangianContactConvergence< T >::checkConvergence ( unsigned int  iter )

overridevirtual

Definition at line 55 of file AugmentedLagrangianContactConvergence.C.

{
  // Check convergence of the nonlinear problem
  auto reason = T::checkConvergence(iter);
 
  auto & fe_problem_base = this->getMooseApp().feProblem();
 
  auto aug_contact = dynamic_cast<AugmentedLagrangianContactProblemInterface *>(&fe_problem_base);
  _lagrangian_iteration_number = aug_contact->getLagrangianIterationNumber();
 
  bool repeat_augmented_lagrange_step = false;
 
  // Nonlinear solve is converged, now check that the constraints are met
  if (reason == Convergence::MooseConvergenceStatus::CONVERGED)
  {
    if (_lagrangian_iteration_number < _maximum_number_lagrangian_iterations)
    {
 
      auto & nonlinear_sys = fe_problem_base.currentNonlinearSystem();
      nonlinear_sys.update();
 
      // Get the penetration locator from the displaced mesh if it exist, otherwise get
      // it from the undisplaced mesh.
      const auto displaced_problem = fe_problem_base.getDisplacedProblem();
      const auto & penetration_locators = (displaced_problem ? displaced_problem->geomSearchData()
                                                             : fe_problem_base.geomSearchData())
                                              ._penetration_locators;
 
      // loop over contact pairs (penetration locators)
      const ConstraintWarehouse & constraints = nonlinear_sys.getConstraintWarehouse();
      std::list<std::shared_ptr<MechanicalContactConstraint>> mccs;
      for (const auto & pair : penetration_locators)
      {
        const auto & boundaries = pair.first;
 
        if (!constraints.hasActiveNodeFaceConstraints(boundaries.second, bool(displaced_problem)))
          continue;
        const auto & ncs =
            constraints.getActiveNodeFaceConstraints(boundaries.second, bool(displaced_problem));
 
        mccs.emplace_back(nullptr);
        for (const auto & nc : ncs)
          if (const auto mcc = std::dynamic_pointer_cast<MechanicalContactConstraint>(nc); !mcc)
            mooseError("AugmentedLagrangianContactProblem: dynamic cast of "
                       "MechanicalContactConstraint object failed.");
          else
          {
            // Return if this constraint does not correspond to the primary-secondary pair
            // prepared by the outer loops.
            // This continue statement is required when, e.g. one secondary surface constrains
            // more than one primary surface.
            if (mcc->secondaryBoundary() != boundaries.second ||
                mcc->primaryBoundary() != boundaries.first)
              continue;
 
            // save one constraint pointer for each contact pair
            if (!mccs.back())
              mccs.back() = mcc;
 
            // check if any of the constraints is not yet converged
            if (repeat_augmented_lagrange_step || !mcc->AugmentedLagrangianContactConverged())
            {
              repeat_augmented_lagrange_step = true;
              break;
            }
          }
      }
 
      // next loop over penalty mortar user objects
      const auto & pmuos = this->_app.template getInterfaceObjects<AugmentedLagrangeInterface>();
      for (auto * pmuo : pmuos)
      {
        // check if any of the constraints is not yet converged
        if (!repeat_augmented_lagrange_step && !pmuo->isAugmentedLagrangianConverged())
          repeat_augmented_lagrange_step = true;
      }
 
      // Communicate the repeat_augmented_lagrange_step in parallel.
      // If one proc needs to do another loop, all do.
      this->_communicator.max(repeat_augmented_lagrange_step);
 
      // repeat update step if necessary
      if (repeat_augmented_lagrange_step)
      {
        _lagrangian_iteration_number++;
        Moose::out << "Augmented Lagrangian contact repeat " << _lagrangian_iteration_number
                   << '\n';
 
        // Each contact pair will have constraints for all displacements, but those share the
        // Lagrange multipliers, which are stored on the penetration locator. We call update
        // only for the first constraint for each contact pair.
        for (const auto & mcc : mccs)
          mcc->updateAugmentedLagrangianMultiplier(/* beginning_of_step = */ false);
 
        // Update all penalty mortar user objects
        for (const auto & pmuo : pmuos)
          pmuo->updateAugmentedLagrangianMultipliers();
 
        // call AM setup again (e.g. to update active sets)
        for (const auto & pmuo : pmuos)
          pmuo->augmentedLagrangianSetup();
 
        // force it to keep iterating
        reason = Convergence::MooseConvergenceStatus::ITERATING;
        Moose::out << "Augmented Lagrangian Multiplier needs updating.";
      }
      else
        Moose::out << "Augmented Lagrangian contact constraint enforcement is satisfied.";
    }
    else
    {
      // maxed out
      Moose::out << "Maximum Augmented Lagrangian contact iterations have been reached.";
      reason = Convergence::MooseConvergenceStatus::DIVERGED;
    }
  }
 
  return reason;
}

getLagrangianIterationNumber()

virtual const unsigned int & AugmentedLagrangianContactProblemInterface::getLagrangianIterationNumber ( ) const

inlinevirtualinherited

Definition at line 23 of file AugmentedLagrangianContactProblemInterface.h.

  {
    return _lagrangian_iteration_number;
  }

Referenced by AugmentedLagrangianContactConvergence< T >::checkConvergence(), and NumAugmentedLagrangeIterations::getValue().

setLagrangianIterationNumber()

virtual void AugmentedLagrangianContactProblemInterface::setLagrangianIterationNumber ( unsigned int  iter )

inlinevirtualinherited

Definition at line 27 of file AugmentedLagrangianContactProblemInterface.h.

  {
    _lagrangian_iteration_number = iter;
  }

validParams()

template<class T >

InputParameters AugmentedLagrangianContactConvergence< T >::validParams ( )

static

Definition at line 38 of file AugmentedLagrangianContactConvergence.C.

{
  InputParameters params = T::validParams();
  params += AugmentedLagrangianContactProblemInterface::validParams();
  params.addClassDescription("Convergence for augmented Lagrangian contact");
  return params;
}

Member Data Documentation

_lagrangian_iteration_number

template<class T >

unsigned int AugmentedLagrangianContactProblemInterface::_lagrangian_iteration_number

protected

current augmented lagrange iteration number

Definition at line 37 of file AugmentedLagrangianContactProblemInterface.h.

_maximum_number_lagrangian_iterations

template<class T >

const unsigned int AugmentedLagrangianContactProblemInterface::_maximum_number_lagrangian_iterations

protected

maximum mumber of augmented lagrange iterations

Definition at line 34 of file AugmentedLagrangianContactProblemInterface.h.

---

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

• contact/include/convergence/AugmentedLagrangianContactConvergence.h
• contact/src/convergence/AugmentedLagrangianContactConvergence.C