MortarConstraintBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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;
};