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. More...
bool	interpolateNormals () const
	Whether to interpolate the nodal normals (e.g. More...

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

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

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

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

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 35 of file MortarConsumerInterface.h.

Constructor & Destructor Documentation

MortarConsumerInterface()

MortarConsumerInterface::MortarConsumerInterface

(

const MooseObject *

moose_object

)

Definition at line 172 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 197 of file MortarConsumerInterface.h.

Referenced by setNormals().

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

getBoundaryIDs()

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

inlineprotected

Definition at line 70 of file MortarConsumerInterface.h.

{ return _boundary_ids; }

getHigherDimSubdomainIDs()

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

inlineprotected

Definition at line 66 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 82 of file MortarConsumerInterface.h.

Referenced by setNormals().

{ return _interpolate_normals; }

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 251 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 53 of file MortarConsumerInterface.h.

{ return _primary_subdomain_id; }

secondarySubdomain()

SubdomainID MortarConsumerInterface::secondarySubdomain ( ) const

inline

Returns

The secondary lower dimensional subdomain id

Definition at line 58 of file MortarConsumerInterface.h.

{ return _secondary_subdomain_id; }

setNormals()

void MortarConsumerInterface::setNormals ( )

private

Set the normals vector.

Definition at line 247 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 130 of file MortarConsumerInterface.C.

Referenced by validParams().

{
  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;
}

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 256 of file MortarConsumerInterface.C.

Referenced by trimInteriorNodeDerivatives().

{
  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);
}

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 205 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 25 of file MortarConsumerInterface.C.

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

{
  // 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, and "
                        "consequently also 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;
}

Friends And Related Function Documentation

ComputeMortarFunctor

friend class ComputeMortarFunctor

friend

Definition at line 182 of file MortarConsumerInterface.h.

FEProblemBase

friend class FEProblemBase

friend

Definition at line 183 of file MortarConsumerInterface.h.

MortarNodalAuxKernelTempl

template<typename >

friend class MortarNodalAuxKernelTempl

friend

Definition at line 186 of file MortarConsumerInterface.h.

MortarUserObjectThread

friend class MortarUserObjectThread

friend

Definition at line 187 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 180 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 128 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 131 of file MortarConsumerInterface.h.

Referenced by getHigherDimSubdomainIDs().

_interpolate_normals

const bool MortarConsumerInterface::_interpolate_normals

protected

Whether to interpolate the nodal normals.

Definition at line 134 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 165 of file MortarConsumerInterface.h.

Referenced by ADMortarConstraint::computeJacobian(), MortarConstraint::computeJacobian(), ADMortarScalarBase::computeJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), WeightedGapAux::computeQpProperties(), ADMortarConstraint::computeResidual(), MortarConstraint::computeResidual(), ADMortarScalarBase::computeResidual(), MortarScalarBase::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 162 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 154 of file MortarConsumerInterface.h.

Referenced by setNormals().

_mci_assembly

Assembly& MortarConsumerInterface::_mci_assembly

protected

Definition at line 106 of file MortarConsumerInterface.h.

_mci_fe_problem

FEProblemBase& MortarConsumerInterface::_mci_fe_problem

protected

Definition at line 99 of file MortarConsumerInterface.h.

_mci_mesh

MooseMesh& MortarConsumerInterface::_mci_mesh

protected

Mesh to query for boundary and subdomain ID information.

Definition at line 104 of file MortarConsumerInterface.h.

_mci_subproblem

SubProblem& MortarConsumerInterface::_mci_subproblem

protected

Definition at line 100 of file MortarConsumerInterface.h.

_mci_tid

const THREAD_ID MortarConsumerInterface::_mci_tid

protected

Definition at line 101 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 110 of file MortarConsumerInterface.h.

_msm_elem

const Elem* const& MortarConsumerInterface::_msm_elem

protected

The current mortar segment element.

Definition at line 168 of file MortarConsumerInterface.h.

_normals

std::vector<Point> MortarConsumerInterface::_normals

protected

the normals

Definition at line 171 of file MortarConsumerInterface.h.

Referenced by WeightedGapAux::computeQpIProperties(), EqualValueConstraint::computeQpResidual(), ADPeriodicSegmentalConstraint::computeScalarQpResidual(), ADPenaltyPeriodicSegmentalConstraint::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 140 of file MortarConsumerInterface.h.

Referenced by PeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), PenaltyPeriodicSegmentalConstraint::computeQpOffDiagJacobianScalar(), WeightedGapAux::computeQpProperties(), ADPeriodicSegmentalConstraint::computeQpResidual(), PeriodicSegmentalConstraint::computeQpResidual(), ADPenaltyPeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeQpResidual(), PenaltyPeriodicSegmentalConstraint::computeScalarQpJacobian(), PeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), PenaltyPeriodicSegmentalConstraint::computeScalarQpOffDiagJacobian(), ADPeriodicSegmentalConstraint::computeScalarQpResidual(), ADPenaltyPeriodicSegmentalConstraint::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 137 of file MortarConsumerInterface.h.

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

_primary_id

const BoundaryID MortarConsumerInterface::_primary_id

protected

Boundary ID for the primary surface.

Definition at line 116 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 122 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 146 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 143 of file MortarConsumerInterface.h.

Referenced by ADMortarConstraint::computeJacobian(), MortarConstraint::computeJacobian(), ADMortarScalarBase::computeJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), ADMortarConstraint::computeResidual(), MortarConstraint::computeResidual(), ADMortarScalarBase::computeResidual(), MortarScalarBase::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 113 of file MortarConsumerInterface.h.

Referenced by MortarConsumerInterface(), and onInterface().

_secondary_set

std::set<BoundaryID> MortarConsumerInterface::_secondary_set

protected

the secondaryid set

Definition at line 125 of file MortarConsumerInterface.h.

_secondary_subdomain_id

const SubdomainID MortarConsumerInterface::_secondary_subdomain_id

protected

Subdomain ID for the secondary surface.

Definition at line 119 of file MortarConsumerInterface.h.

Referenced by secondarySubdomain().

---

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

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