MortarConsumerInterface Class Reference

An interface for accessing mortar mesh data. More...

#include <MortarConsumerInterface.h>

Inheritance diagram for MortarConsumerInterface:

Public Member Functions
	MortarConsumerInterface (const MooseObject *moose_object)
SubdomainID	primarySubdomain () const
SubdomainID	secondarySubdomain () const
bool	onInterface (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id) const

Static Public Member Functions
static InputParameters	validParams ()
static InputParameters	triangulationParams ()

Protected Member Functions
const std::set< SubdomainID > &	getHigherDimSubdomainIDs () const
const std::set< BoundaryID > &	getBoundaryIDs () const
const AutomaticMortarGeneration &	amg () const
	Retrieve the automatic mortar generation object associated with this constraint.
bool	interpolateNormals () const
	Whether to interpolate the nodal normals (e.g.
void	checkPetrovGalerkinQuadraticFaces (const MooseObject &moose_object, const MooseVariableFieldBase &lm_var) const
	Report an error if Petrov-Galerkin weights the gap of a SECOND order dual Lagrange multiplier with the standard basis on QUAD8 or TRI6 secondary faces.

Static Protected Member Functions
static void	trimDerivative (dof_id_type remove_derivative_index, ADReal &dual_number)
	Get rid of AD derivative entries by dof index.
template<typename Variables , typename DualNumbers >
static void	trimInteriorNodeDerivatives (const std::map< unsigned int, unsigned int > &primary_ip_lowerd_map, const Variables &moose_var, DualNumbers &ad_vars, const bool is_secondary)
	Get rid of interior node variable's derivatives.

Protected Attributes
FEProblemBase &	_mci_fe_problem
SubProblem &	_mci_subproblem
const THREAD_ID	_mci_tid
MooseMesh &	_mci_mesh
	Mesh to query for boundary and subdomain ID information.
Assembly &	_mci_assembly
const MortarInterfaceWarehouse &	_mortar_data
	A reference to the mortar data object that holds all the mortar mesh information.
const BoundaryID	_secondary_id
	Boundary ID for the secondary surface.
const BoundaryID	_primary_id
	Boundary ID for the primary surface.
const SubdomainID	_secondary_subdomain_id
	Subdomain ID for the secondary surface.
const SubdomainID	_primary_subdomain_id
	Subdomain ID for the primary surface.
std::set< BoundaryID >	_secondary_set
	the secondaryid set
std::set< BoundaryID >	_boundary_ids
	the union of the secondary and primary boundary ids
std::set< SubdomainID >	_higher_dim_subdomain_ids
	the higher dimensional subdomain ids corresponding to the interior parents
const bool	_interpolate_normals
	Whether to interpolate the nodal normals.
const MooseArray< Point > &	_phys_points_secondary
	The locations of the quadrature points on the interior secondary elements.
const MooseArray< Point > &	_phys_points_primary
	The locations of the quadrature points on the interior primary elements.
const libMesh::QBase *const &	_qrule_msm
	The quadrature rule on the mortar segment element.
const libMesh::QBase *const &	_qrule_face
	The arbitrary quadrature rule on the lower dimensional secondary face.
Elem const *const &	_lower_secondary_elem
	The secondary face lower dimensional element (not the mortar element!).
Elem const *const &	_lower_primary_elem
	The primary face lower dimensional element (not the mortar element!).
const std::vector< Real > &	_JxW_msm
	The element Jacobian times weights.
const Elem *const &	_msm_elem
	The current mortar segment element.
std::vector< Point >	_normals
	the normals

Private Member Functions
void	setNormals ()
	Set the normals vector.

Private Attributes
const AutomaticMortarGeneration *	_amg

Friends
class	ComputeMortarFunctor
class	FEProblemBase
template<typename >
class	MortarNodalAuxKernelTempl
class	MortarUserObjectThread
void	reinitMortarUserObjects (BoundaryID, BoundaryID, bool)
	Calls the reinitialization of mortar user objects.

Detailed Description

An interface for accessing mortar mesh data.

Note

mci is shorthand for mortar consumer interface, so _mci_problem indicates the mortar consumer interface's problem

Definition at line 36 of file MortarConsumerInterface.h.

Constructor & Destructor Documentation

MortarConsumerInterface()

MortarConsumerInterface::MortarConsumerInterface

(

const MooseObject *

moose_object

)

Definition at line 173 of file MortarConsumerInterface.C.

  : _mci_fe_problem(*moose_object->getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _mci_subproblem(*moose_object->getCheckedPointerParam<SubProblem *>("_subproblem")),
    _mci_tid(moose_object->getParam<THREAD_ID>("_tid")),
    _mci_mesh(_mci_subproblem.mesh()),
    // all geometric assembly information should be correct for nl system number 0
    _mci_assembly(_mci_subproblem.assembly(_mci_tid, 0)),
    _mortar_data(_mci_fe_problem.mortarData()),
    _secondary_id(
        _mci_mesh.getBoundaryID(moose_object->getParam<BoundaryName>("secondary_boundary"))),
    _primary_id(_mci_mesh.getBoundaryID(moose_object->getParam<BoundaryName>("primary_boundary"))),
    _secondary_subdomain_id(
        _mci_mesh.getSubdomainID(moose_object->getParam<SubdomainName>("secondary_subdomain"))),
    _primary_subdomain_id(
        _mci_mesh.getSubdomainID(moose_object->getParam<SubdomainName>("primary_subdomain"))),
    _secondary_set({_secondary_id}),
    _interpolate_normals(moose_object->getParam<bool>("interpolate_normals")),
    _phys_points_secondary(_mci_assembly.qPointsFace()),
    _phys_points_primary(_mci_assembly.qPointsFaceNeighbor()),
    _qrule_msm(_mci_assembly.qRuleMortar()),
    _qrule_face(_mci_assembly.qRuleFace()),
    _lower_secondary_elem(_mci_assembly.lowerDElem()),
    _lower_primary_elem(_mci_assembly.neighborLowerDElem()),
    _JxW_msm(_mci_assembly.jxWMortar()),
    _msm_elem(_mci_assembly.msmElem())
{
  const bool displaced = moose_object->isParamValid("use_displaced_mesh")
                             ? moose_object->getParam<bool>("use_displaced_mesh")
                             : false;
  const auto minimum_projection_angle = moose_object->getParam<Real>("minimum_projection_angle");
  const auto mortar_3d_subpatch_plane =
      moose_object->getParam<MooseEnum>("mortar_3d_subpatch_plane")
          .getEnum<Mortar3DSubpatchPlane>();
 
  // Only geometric 3D mode interprets this value as an angle between subpatch normals. Averaged
  // normal and 2D interfaces continue to use the other projection-angle checks.
  if (_mci_mesh.dimension() == 3 &&
      mortar_3d_subpatch_plane == Mortar3DSubpatchPlane::GEOMETRIC_NORMAL &&
      (minimum_projection_angle < 0.0 || minimum_projection_angle > 90.0))
    moose_object->paramError("minimum_projection_angle",
                             "Must be between 0 and 90 degrees when "
                             "mortar_3d_subpatch_plane = GEOMETRIC_NORMAL.");
 
  // Create the mortar interface if it hasn't already been created
  _mci_fe_problem.createMortarInterface(
      std::make_pair(_primary_id, _secondary_id),
      std::make_pair(_primary_subdomain_id, _secondary_subdomain_id),
      displaced,
      moose_object->getParam<bool>("periodic"),
      moose_object->getParam<bool>("debug_mesh"),
      moose_object->getParam<bool>("correct_edge_dropping"),
      minimum_projection_angle,
      mortar_3d_subpatch_plane,
      moose_object->getParam<MooseEnum>("triangulation"),
      moose_object->getParam<bool>("triangulate_triangles"),
      moose_object->getParam<MooseEnum>("mortar_3d_qp_mapping")
          .getEnum<Mortar3DQuadraturePointMapping>());
 
  _amg = &_mci_fe_problem.getMortarInterface(
      std::make_pair(_primary_id, _secondary_id),
      std::make_pair(_primary_subdomain_id, _secondary_subdomain_id),
      displaced);
 
  const auto & secondary_set = _mortar_data.getHigherDimSubdomainIDs(_secondary_subdomain_id);
  const auto & primary_set = _mortar_data.getHigherDimSubdomainIDs(_primary_subdomain_id);
 
  std::set_union(secondary_set.begin(),
                 secondary_set.end(),
                 primary_set.begin(),
                 primary_set.end(),
                 std::inserter(_higher_dim_subdomain_ids, _higher_dim_subdomain_ids.begin()));
  _boundary_ids = {_secondary_id, _primary_id};
}

Member Function Documentation

amg()

const AutomaticMortarGeneration & MortarConsumerInterface::amg ( ) const

inlineprotected

Retrieve the automatic mortar generation object associated with this constraint.

Definition at line 209 of file MortarConsumerInterface.h.

{
  mooseAssert(_amg, "this should have been set in the constructor");
  return *_amg;
}

Referenced by setNormals().

checkPetrovGalerkinQuadraticFaces()

void MortarConsumerInterface::checkPetrovGalerkinQuadraticFaces ( const MooseObject &  moose_object, const MooseVariableFieldBase &  lm_var  ) const

protected

Report an error if Petrov-Galerkin weights the gap of a SECOND order dual Lagrange multiplier with the standard basis on QUAD8 or TRI6 secondary faces.

libMesh builds the dual basis on these faces against a transformed basis, and the nodal integrals of the standard basis are not positive there, so the combination does not converge.

Parameters

moose_object	The object reporting the error
lm_var	The Lagrange multiplier

Definition at line 257 of file MortarConsumerInterface.C.

{
  if (!lm_var.useDual() || lm_var.feType().family != LAGRANGE || lm_var.feType().order != SECOND)
    return;
 
  for (const auto * const lower_elem :
       _mci_mesh.getMesh().active_local_subdomain_elements_ptr_range(_secondary_subdomain_id))
    if (lower_elem->type() == QUAD8 || lower_elem->type() == TRI6)
      moose_object.paramError(
          "use_petrov_galerkin",
          "The Petrov-Galerkin approach is not supported for a SECOND order dual Lagrange "
          "multiplier on QUAD8 or TRI6 secondary faces. Use a FIRST order multiplier or disable "
          "`use_petrov_galerkin`.");
}

Referenced by MortarConstraintBase::MortarConstraintBase().

getBoundaryIDs()

const std::set< BoundaryID > & MortarConsumerInterface::getBoundaryIDs ( ) const

inlineprotected

Definition at line 71 of file MortarConsumerInterface.h.

{ return _boundary_ids; }

getHigherDimSubdomainIDs()

const std::set< SubdomainID > & MortarConsumerInterface::getHigherDimSubdomainIDs ( ) const

inlineprotected

Definition at line 67 of file MortarConsumerInterface.h.

  {
    return _higher_dim_subdomain_ids;
  }

interpolateNormals()

bool MortarConsumerInterface::interpolateNormals ( ) const

inlineprotected

Whether to interpolate the nodal normals (e.g.

classic idea of evaluating field at quadrature points). If this is set to false, then non-interpolated nodal normals will be used, and then the _normals member should be indexed with _i instead of _qp

Definition at line 83 of file MortarConsumerInterface.h.

{ return _interpolate_normals; }

Referenced by setNormals().

onInterface()

bool MortarConsumerInterface::onInterface ( BoundaryID  primary_boundary_id, BoundaryID  secondary_boundary_id  ) const

inline

Returns

Whether this object lies on the given primary-secondary boundary pair

Definition at line 263 of file MortarConsumerInterface.h.

{
  return (primary_boundary_id == _primary_id) && (secondary_boundary_id == _secondary_id);
}

primarySubdomain()

SubdomainID MortarConsumerInterface::primarySubdomain ( ) const

inline

Returns

The primary lower dimensional subdomain id

Definition at line 54 of file MortarConsumerInterface.h.

{ return _primary_subdomain_id; }

secondarySubdomain()

SubdomainID MortarConsumerInterface::secondarySubdomain ( ) const

inline

Returns

The secondary lower dimensional subdomain id

Definition at line 59 of file MortarConsumerInterface.h.

{ return _secondary_subdomain_id; }

setNormals()

void MortarConsumerInterface::setNormals ( )

private

Set the normals vector.

Definition at line 248 of file MortarConsumerInterface.C.

{
  if (interpolateNormals())
    _normals = amg().getNormals(*_lower_secondary_elem, _qrule_face->get_points());
  else
    _normals = amg().getNodalNormals(*_lower_secondary_elem);
}

triangulationParams()

InputParameters MortarConsumerInterface::triangulationParams ( )

static

Returns

An InputParameters object containing just the parameters that control 3D mortar polygon triangulation (triangulation, triangulate_triangles). Provided so that downstream actions / objects which need to expose the same controls (e.g. ContactAction) can pull these definitions in via params += rather than duplicating them.

Definition at line 131 of file MortarConsumerInterface.C.

{
  InputParameters params = emptyInputParameters();
 
  MooseEnum triangulation(
#if defined(LIBMESH_HAVE_TRIANGLE) || defined(LIBMESH_HAVE_POLY2TRI)
      "vertex centroid ear_clipping delaunay",
#else
      "vertex centroid ear_clipping",
#endif
      "centroid");
  triangulation.addDocumentation(
      "vertex",
      "Triangulate clipped 3D mortar polygons by forming a fan from an existing polygon vertex.");
  triangulation.addDocumentation(
      "centroid",
      "Triangulate clipped 3D mortar polygons by forming a fan from a polygon centroid.");
  triangulation.addDocumentation(
      "ear_clipping", "Triangulate clipped 3D mortar polygons with an ear-clipping algorithm.");
#if defined(LIBMESH_HAVE_TRIANGLE) || defined(LIBMESH_HAVE_POLY2TRI)
  triangulation.addDocumentation(
      "delaunay",
      "Triangulate clipped 3D mortar polygons using libMesh's constrained-Delaunay PSLG "
      "triangulation backend while preserving polygon boundary edges.");
#endif
  params.addParam<MooseEnum>(
      "triangulation",
      triangulation,
      "Strategy used to triangulate clipped 3D mortar polygons into mortar segments. The default "
      "is 'centroid' to preserve the legacy 3D mortar segmentation behavior.");
  params.addParam<bool>(
      "triangulate_triangles",
      false,
      "Whether a clipped 3D mortar polygon that is already a triangle should still be subdivided "
      "during triangulation. When enabled, already-triangular polygons are subdivided with the "
      "centroid-based path because the vertex-fan, ear-clipping, and Delaunay backends cannot "
      "refine a triangle any further on their own.");
 
  return params;
}

Referenced by validParams().

trimDerivative()

void MortarConsumerInterface::trimDerivative ( dof_id_type  remove_derivative_index, ADReal &  dual_number  )

staticprotected

Get rid of AD derivative entries by dof index.

Definition at line 274 of file MortarConsumerInterface.C.

{
  auto md_it = dual_number.derivatives().nude_data().begin();
  auto mi_it = dual_number.derivatives().nude_indices().begin();
 
  auto d_it = dual_number.derivatives().nude_data().begin();
 
  for (auto i_it = dual_number.derivatives().nude_indices().begin();
       i_it != dual_number.derivatives().nude_indices().end();
       ++i_it, ++d_it)
    if (*i_it != remove_derivative_index)
    {
      *mi_it = *i_it;
      *md_it = *d_it;
      ++mi_it;
      ++md_it;
    }
 
  std::size_t n_indices = md_it - dual_number.derivatives().nude_data().begin();
  dual_number.derivatives().nude_indices().resize(n_indices);
  dual_number.derivatives().nude_data().resize(n_indices);
}

Referenced by trimInteriorNodeDerivatives().

trimInteriorNodeDerivatives()

template<typename Variables , typename DualNumbers >

void MortarConsumerInterface::trimInteriorNodeDerivatives ( const std::map< unsigned int, unsigned int > &  primary_ip_lowerd_map, const Variables &  moose_var, DualNumbers &  ad_vars, const bool  is_secondary  )

staticprotected

Get rid of interior node variable's derivatives.

Definition at line 217 of file MortarConsumerInterface.h.

{
  //
  // Remove interior node variable's derivatives from AD objects.
  //
 
  mooseAssert(moose_vars.size(), "Should have passed at least one variable");
  const auto num_indices = is_secondary ? moose_vars[0]->dofIndices().size()
                                        : moose_vars[0]->dofIndicesNeighbor().size();
#ifdef DEBUG
  for (const auto i : make_range(std::size_t(1), moose_vars.size()))
    if (auto * moose_var = moose_vars[i])
      mooseAssert(is_secondary ? moose_var->dofIndices().size()
                               : moose_var->dofIndicesNeighbor().size() == num_indices,
                  "These must be the same for all passed in variables");
#endif
 
  for (const auto dof_index : make_range(num_indices))
    if (!domain_ip_lowerd_map.count(dof_index))
    {
      for (const auto * const moose_var : moose_vars)
      {
        // It's valid for a user to pass a container that represents a LIBMESH_DIM vector of
        // component variables for which one or two of the variables may be null depending on the
        // mesh dimension in the simulation
        if (!moose_var)
          continue;
 
        mooseAssert(moose_var->isNodal(),
                    "Trimming of interior node's derivatives is only supported for Lagrange "
                    "elements in mortar objects");
 
        const auto remove_derivative_index = is_secondary
                                                 ? moose_var->dofIndices()[dof_index]
                                                 : moose_var->dofIndicesNeighbor()[dof_index];
        for (auto & dual_number : dual_numbers)
          trimDerivative(remove_derivative_index, dual_number);
      }
    }
}

validParams()

InputParameters MortarConsumerInterface::validParams ( )

static

Definition at line 26 of file MortarConsumerInterface.C.

{
  // Create InputParameters object that will be appended to the parameters for the inheriting object
  InputParameters params = emptyInputParameters();
  // On a displaced mesh this will geometrically and algebraically ghost the entire interface
  params.addRelationshipManager(
      "AugmentSparsityOnInterface",
      Moose::RelationshipManagerType::GEOMETRIC | Moose::RelationshipManagerType::ALGEBRAIC,
      [](const InputParameters & obj_params, InputParameters & rm_params)
      {
        rm_params.set<bool>("use_displaced_mesh") = obj_params.get<bool>("use_displaced_mesh");
        rm_params.set<BoundaryName>("secondary_boundary") =
            obj_params.get<BoundaryName>("secondary_boundary");
        rm_params.set<BoundaryName>("primary_boundary") =
            obj_params.get<BoundaryName>("primary_boundary");
        rm_params.set<SubdomainName>("secondary_subdomain") =
            obj_params.get<SubdomainName>("secondary_subdomain");
        rm_params.set<SubdomainName>("primary_subdomain") =
            obj_params.get<SubdomainName>("primary_subdomain");
        rm_params.set<bool>("ghost_point_neighbors") =
            obj_params.get<bool>("ghost_point_neighbors");
        rm_params.set<bool>("ghost_higher_d_neighbors") =
            obj_params.get<bool>("ghost_higher_d_neighbors");
      });
 
  params.addRequiredParam<BoundaryName>("primary_boundary",
                                        "The name of the primary boundary sideset.");
  params.addRequiredParam<BoundaryName>("secondary_boundary",
                                        "The name of the secondary boundary sideset.");
  params.addRequiredParam<SubdomainName>("primary_subdomain", "The name of the primary subdomain.");
  params.addRequiredParam<SubdomainName>("secondary_subdomain",
                                         "The name of the secondary subdomain.");
  params.addParam<bool>(
      "periodic",
      false,
      "Whether this constraint is going to be used to enforce a periodic condition. This has the "
      "effect of changing the normals vector for projection from outward to inward facing");
 
  params.addParam<bool>(
      "debug_mesh",
      false,
      "Whether this constraint is going to enable mortar segment mesh debug information. An exodus"
      "file will be generated if the user sets this flag to true");
 
  params.addParam<bool>(
      "correct_edge_dropping",
      false,
      "Whether to enable correct edge dropping treatment for mortar constraints. When disabled "
      "any Lagrange Multiplier degree of freedom on a secondary element without full primary "
      "contributions will be set (strongly) to 0.");
 
  params.addParam<bool>(
      "interpolate_normals",
      true,
      "Whether to interpolate the nodal normals (e.g. classic idea of evaluating field at "
      "quadrature points). If this is set to false, then non-interpolated nodal normals will be "
      "used, and then the _normals member should be indexed with _i instead of _qp");
 
  params.addParam<bool>("ghost_point_neighbors",
                        false,
                        "Whether we should ghost point neighbors of secondary face elements, their "
                        "interior parents, and their mortar interface couples.");
  params.addParam<Real>(
      "minimum_projection_angle",
      40.0,
      "Parameter to control which angle (in degrees) is admissible for the creation of mortar "
      "segments.  If set to a value close to zero, very oblique projections are allowed, which "
      "can result in mortar segments solving physics not meaningfully, and overprojection of "
      "primary nodes onto the mortar segment mesh in extreme cases. In 3D with "
      "mortar_3d_subpatch_plane = GEOMETRIC_NORMAL, this parameter also controls which primary "
      "and secondary subpatch normal pairings are admissible before polygon clipping.");
  params.addParam<MooseEnum>(
      "mortar_3d_subpatch_plane",
      MooseEnum(getMortar3DSubpatchPlaneOptions(), "GEOMETRIC_NORMAL"),
      "Method used to construct the local 3D mortar subpatch planes used for projection and "
      "clipping. GEOMETRIC_NORMAL uses the geometric normal of each linear or bilinear secondary "
      "subpatch. AVERAGED_NODAL_NORMAL uses the averaged nodal normal on each secondary subpatch.");
  params += MortarConsumerInterface::triangulationParams();
 
  MooseEnum mortar_3d_qp_mapping(getMortar3DQuadraturePointMappingOptions(), "normal_projection");
  mortar_3d_qp_mapping.addDocumentation(
      "normal_projection",
      "Project each mortar-segment quadrature point onto the linearized primary and secondary "
      "sub-elements along the mortar-segment normal.");
  mortar_3d_qp_mapping.addDocumentation(
      "reference_interpolation",
      "Interpolate stored primary and secondary parent-face reference coordinates over each "
      "triangular mortar segment.");
  params.addParam<MooseEnum>(
      "mortar_3d_qp_mapping",
      mortar_3d_qp_mapping,
      "Method used to map quadrature points on 3D mortar segments to primary and secondary "
      "parent-face reference coordinates. This parameter has no effect for 2D mortar.");
 
  params.addParam<bool>(
      "ghost_higher_d_neighbors",
      false,
      "Whether we should ghost higher-dimensional neighbors. This is necessary when we are doing "
      "second order mortar with finite volume primal variables, because in order for the method to "
      "be second order we must use cell gradients, which couples in the neighbor cells.");
 
  return params;
}

Referenced by MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), MortarConstraintBase::validParams(), and MortarUserObject::validParams().

Friends And Related Symbol Documentation

ComputeMortarFunctor

friend class ComputeMortarFunctor

friend

Definition at line 194 of file MortarConsumerInterface.h.

FEProblemBase

friend class FEProblemBase

friend

Definition at line 195 of file MortarConsumerInterface.h.

MortarNodalAuxKernelTempl

template<typename >

friend class MortarNodalAuxKernelTempl

friend

Definition at line 198 of file MortarConsumerInterface.h.

MortarUserObjectThread

friend class MortarUserObjectThread

friend

Definition at line 199 of file MortarConsumerInterface.h.

reinitMortarUserObjects

void reinitMortarUserObjects ( BoundaryID  , BoundaryID  , bool    )

friend

Calls the reinitialization of mortar user objects.

See also

FEProblemBase::reinitMortarUserObjects

Member Data Documentation

_amg

const AutomaticMortarGeneration* MortarConsumerInterface::_amg

private

Definition at line 192 of file MortarConsumerInterface.h.

Referenced by amg().

_boundary_ids

std::set<BoundaryID> MortarConsumerInterface::_boundary_ids

protected

the union of the secondary and primary boundary ids

Definition at line 140 of file MortarConsumerInterface.h.

Referenced by getBoundaryIDs().

_higher_dim_subdomain_ids

std::set<SubdomainID> MortarConsumerInterface::_higher_dim_subdomain_ids

protected

the higher dimensional subdomain ids corresponding to the interior parents

Definition at line 143 of file MortarConsumerInterface.h.

Referenced by getHigherDimSubdomainIDs().

_interpolate_normals

const bool MortarConsumerInterface::_interpolate_normals

protected

Whether to interpolate the nodal normals.

Definition at line 146 of file MortarConsumerInterface.h.

Referenced by interpolateNormals().

_JxW_msm

const std::vector<Real>& MortarConsumerInterface::_JxW_msm

protected

The element Jacobian times weights.

Definition at line 177 of file MortarConsumerInterface.h.

Referenced by ADMortarScalarBase::computeJacobian(), ADMortarConstraint::computeJacobian(), MortarConstraint::computeJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), WeightedGapAux::computeQpProperties(), ADMortarScalarBase::computeResidual(), MortarScalarBase::computeResidual(), ADMortarConstraint::computeResidual(), MortarConstraint::computeResidual(), MortarScalarBase::computeScalarJacobian(), MortarScalarBase::computeScalarOffDiagJacobian(), and MortarScalarBase::computeScalarOffDiagJacobianScalar().

_lower_primary_elem

Elem const* const& MortarConsumerInterface::_lower_primary_elem

protected

The primary face lower dimensional element (not the mortar element!).

The mortar element lives on the secondary side of the mortar interface and may correspond to _lower_secondary_elem under the very specific circumstance that the nodes on the primary side of the mortar interface exactly project onto the secondary side of the mortar interface. In general projection of primary nodes will split the face elements on the secondary side of the interface. It is these split elements that are the mortar segment mesh elements

Definition at line 174 of file MortarConsumerInterface.h.

_lower_secondary_elem

Elem const* const& MortarConsumerInterface::_lower_secondary_elem

protected

The secondary face lower dimensional element (not the mortar element!).

The mortar element lives on the secondary side of the mortar interface and may correspond to _lower_secondary_elem under the very specific circumstance that the nodes on the primary side of the mortar interface exactly project onto the secondary side of the mortar interface. In general projection of primary nodes will split the face elements on the secondary side of the interface. It is these split elements that are the mortar segment mesh elements

Definition at line 166 of file MortarConsumerInterface.h.

Referenced by setNormals().

_mci_assembly

Assembly& MortarConsumerInterface::_mci_assembly

protected

Definition at line 118 of file MortarConsumerInterface.h.

_mci_fe_problem

FEProblemBase& MortarConsumerInterface::_mci_fe_problem

protected

Definition at line 111 of file MortarConsumerInterface.h.

_mci_mesh

MooseMesh& MortarConsumerInterface::_mci_mesh

protected

Mesh to query for boundary and subdomain ID information.

Definition at line 116 of file MortarConsumerInterface.h.

Referenced by checkPetrovGalerkinQuadraticFaces().

_mci_subproblem

SubProblem& MortarConsumerInterface::_mci_subproblem

protected

Definition at line 112 of file MortarConsumerInterface.h.

_mci_tid

const THREAD_ID MortarConsumerInterface::_mci_tid

protected

Definition at line 113 of file MortarConsumerInterface.h.

_mortar_data

const MortarInterfaceWarehouse& MortarConsumerInterface::_mortar_data

protected

A reference to the mortar data object that holds all the mortar mesh information.

Definition at line 122 of file MortarConsumerInterface.h.

_msm_elem

const Elem* const& MortarConsumerInterface::_msm_elem

protected

The current mortar segment element.

Definition at line 180 of file MortarConsumerInterface.h.

_normals

std::vector<Point> MortarConsumerInterface::_normals

protected

the normals

Definition at line 183 of file MortarConsumerInterface.h.

Referenced by WeightedGapAux::computeQpIProperties(), EqualValueConstraint::computeQpResidual(), ADPenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), ADPeriodicSegmentalConstraint::computeScalarQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), PeriodicSegmentalConstraint::computeScalarQpResidual(), and setNormals().

_phys_points_primary

const MooseArray<Point>& MortarConsumerInterface::_phys_points_primary

protected

The locations of the quadrature points on the interior primary elements.

Definition at line 152 of file MortarConsumerInterface.h.

Referenced by PenaltyPeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), PeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), WeightedGapAux::computeQpProperties(), ADPenaltyPeriodicSegmentalConstraint::computeQpResidual(), ADPeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeQpResidual(), PeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpJacobian(), PenaltyPeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), PeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), ADPenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), ADPeriodicSegmentalConstraint::computeScalarQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), and PeriodicSegmentalConstraint::computeScalarQpResidual().

_phys_points_secondary

const MooseArray<Point>& MortarConsumerInterface::_phys_points_secondary

protected

The locations of the quadrature points on the interior secondary elements.

Definition at line 149 of file MortarConsumerInterface.h.

Referenced by PenaltyPeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), PeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), WeightedGapAux::computeQpProperties(), ADPenaltyPeriodicSegmentalConstraint::computeQpResidual(), ADPeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeQpResidual(), PeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpJacobian(), PenaltyPeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), PeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), ADPenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), ADPeriodicSegmentalConstraint::computeScalarQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), and PeriodicSegmentalConstraint::computeScalarQpResidual().

_primary_id

const BoundaryID MortarConsumerInterface::_primary_id

protected

Boundary ID for the primary surface.

Definition at line 128 of file MortarConsumerInterface.h.

Referenced by onInterface().

_primary_subdomain_id

const SubdomainID MortarConsumerInterface::_primary_subdomain_id

protected

Subdomain ID for the primary surface.

Definition at line 134 of file MortarConsumerInterface.h.

Referenced by primarySubdomain().

_qrule_face

const libMesh::QBase* const& MortarConsumerInterface::_qrule_face

protected

The arbitrary quadrature rule on the lower dimensional secondary face.

Definition at line 158 of file MortarConsumerInterface.h.

Referenced by setNormals().

_qrule_msm

const libMesh::QBase* const& MortarConsumerInterface::_qrule_msm

protected

The quadrature rule on the mortar segment element.

Definition at line 155 of file MortarConsumerInterface.h.

Referenced by ADMortarScalarBase::computeJacobian(), ADMortarConstraint::computeJacobian(), MortarConstraint::computeJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), ADMortarScalarBase::computeResidual(), MortarScalarBase::computeResidual(), ADMortarConstraint::computeResidual(), MortarConstraint::computeResidual(), MortarScalarBase::computeScalarJacobian(), MortarScalarBase::computeScalarOffDiagJacobian(), MortarScalarBase::computeScalarOffDiagJacobianScalar(), and WeightedGapAux::computeValue().

_secondary_id

const BoundaryID MortarConsumerInterface::_secondary_id

protected

Boundary ID for the secondary surface.

Definition at line 125 of file MortarConsumerInterface.h.

Referenced by MortarConsumerInterface(), and onInterface().

_secondary_set

std::set<BoundaryID> MortarConsumerInterface::_secondary_set

protected

the secondaryid set

Definition at line 137 of file MortarConsumerInterface.h.

_secondary_subdomain_id

const SubdomainID MortarConsumerInterface::_secondary_subdomain_id

protected

Subdomain ID for the secondary surface.

Definition at line 131 of file MortarConsumerInterface.h.

Referenced by checkPetrovGalerkinQuadraticFaces(), and secondarySubdomain().

---

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

• include/interfaces/MortarConsumerInterface.h
• src/interfaces/MortarConsumerInterface.C