MortarConstraintBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE includes
#include "Constraint.h"
#include "NeighborCoupleableMooseVariableDependencyIntermediateInterface.h"
#include "MooseMesh.h"
#include "MooseVariableInterface.h"
#include "MortarConsumerInterface.h"
#include "TwoMaterialPropertyInterface.h"
 
// Forward Declarations
class FEProblemBase;
namespace libMesh
{
class QBase;
}
 
class MortarConstraintBase : public Constraint,
                             public NeighborCoupleableMooseVariableDependencyIntermediateInterface,
                             public MortarConsumerInterface,
                             public TwoMaterialPropertyInterface,
                             public MooseVariableInterface<Real>
{
public:
  static InputParameters validParams();
 
  MortarConstraintBase(const InputParameters & parameters);
 
  virtual void computeResidual() override;
 
  virtual void computeJacobian() override;
 
  virtual void computeResidual(Moose::MortarType mortar_type) = 0;
 
  virtual void computeJacobian(Moose::MortarType mortar_type) = 0;
 
  const MooseVariable & variable() const override { return *_var; }
 
  const MooseVariable * variablePtr() const { return _var; }
 
  bool useDual() const { return _use_dual; }
 
  virtual void post() {}
 
  virtual void incorrectEdgeDroppingPost(const std::unordered_set<const Node *> &) {}
 
  void zeroInactiveLMDofs(const std::unordered_set<const Node *> & inactive_lm_nodes,
                          const std::unordered_set<const Elem *> & inactive_lm_elems);
 
protected:
  const FEProblemBase & feProblem() const { return _fe_problem; }
 
  FEProblemBase & _fe_problem;
 
  MooseVariable * const _var;
 
  MooseVariableField<Real> & _secondary_var;
 
  MooseVariableField<Real> & _primary_var;
 
  const bool _compute_primal_residuals;
 
  const bool _compute_lm_residuals;
 
  const VariableTestValue _test_dummy;
 
  const bool _use_dual;
 
  const MooseArray<std::vector<Point>> & _tangents;
 
  const MooseArray<Real> & _coord;
 
  const std::vector<Point> & _q_point;
 
  const bool _use_petrov_galerkin;
 
  const MooseVariable * const _aux_lm_var;
 
  const VariableTestValue & _test;
 
  const VariableTestValue & _test_secondary;
 
  const VariableTestValue & _test_primary;
 
  const VariableTestGradient & _grad_test_secondary;
 
  const VariableTestGradient & _grad_test_primary;
 
  const Elem * const & _interior_secondary_elem;
 
  const Elem * const & _interior_primary_elem;
 
  const bool _displaced;
};