MortarInterfaceWarehouse Class Reference

#include <MortarInterfaceWarehouse.h>

Inheritance diagram for MortarInterfaceWarehouse:

Public Member Functions
	MortarInterfaceWarehouse (const libMesh::ParallelObject &other)
void	createMortarInterface (const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &subdomain_key, SubProblem &subproblem, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle, const Mortar3DSubpatchPlane mortar_3d_subpatch_plane, const MooseEnum &triangulation, const bool triangulate_triangles, const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping=Mortar3DQuadraturePointMapping::NORMAL_PROJECTION)
	Create mortar generation object.
const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &, bool on_displaced) const
	Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain keys.
AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &, bool on_displaced)
	Non-const getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain keys.
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > &	getMortarInterfaces (bool on_displaced) const
	Return the per-interface configuration map (AutomaticMortarGeneration object plus the associated user flags) for either the displaced or undisplaced mesh.
const std::set< SubdomainID > &	getMortarSubdomainIDs () const
	Returns the mortar covered subdomains.
const std::set< BoundaryID > &	getMortarBoundaryIDs () const
	Returns the mortar covered boundaries.
bool	update ()
	Builds mortar segment meshes for each mortar interface.
void	meshChanged ()
	Invalidates cached MSM node/element ID offsets on all mortar interfaces so they are recomputed on the next update().
bool	hasDisplacedObjects () const
	Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh.
bool	hasObjects () const
	Returns whether we have any active AutomaticMortarGeneration objects.
const std::set< SubdomainID > &	getHigherDimSubdomainIDs (SubdomainID lower_d_subdomain_id) const
	Returns the higher dimensional subdomain ids of the interior parents of the given lower-d subdomain id.
void	notifyWhenMortarSetup (MortarExecutorInterface *mei)
	Adds mei to the container of objects that will have their mortarSetup method called whenever a mortar mesh's segment coverage is (re)built and has changed, including the first build
void	dontNotifyWhenMortarSetup (MortarExecutorInterface *mei)
	Removes mei from the container of objects that will have their mortarSetup method called whenever a mortar mesh's segment coverage is (re)built and has changed
bool	initialized () const
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Protected Attributes
const Parallel::Communicator &	_communicator

Private Types
typedef std::pair< BoundaryID, BoundaryID >	MortarKey

Private Member Functions
bool	update (AutomaticMortarGeneration &amg)
	Builds mortar segment mesh from specific AutomaticMortarGeneration object.

Private Attributes
std::unordered_map< MortarKey, MortarInterfaceConfig >	_mortar_interfaces
	Map from primary-secondary (in that order) boundary ID pair to the configuration of the undisplaced mortar interface (AMG object + per-interface flags).
std::unordered_map< MortarKey, MortarInterfaceConfig >	_displaced_mortar_interfaces
	Map from primary-secondary (in that order) boundary ID pair to the configuration of the displaced mortar interface (AMG object + per-interface flags).
std::set< SubdomainID >	_mortar_subdomain_coverage
	A set containing the subdomain ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object.
std::set< BoundaryID >	_mortar_boundary_coverage
	A set containing the boundary ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object.
std::unordered_map< SubdomainID, std::set< SubdomainID > >	_lower_d_sub_to_higher_d_subs
	Map from lower dimensional subdomain ids to corresponding higher simensional subdomain ids (e.g.
std::set< MortarExecutorInterface * >	_mei_objs
	A container of objects for whom the mortarSetup method will be called whenever a mortar mesh's segment coverage is (re)built and has changed, including the first build.
bool	_mortar_initd
	Whether we have performed any mortar mesh construction.

Detailed Description

Definition at line 47 of file MortarInterfaceWarehouse.h.

Member Typedef Documentation

MortarKey

typedef std::pair<BoundaryID, BoundaryID> MortarInterfaceWarehouse::MortarKey

private

Definition at line 183 of file MortarInterfaceWarehouse.h.

Constructor & Destructor Documentation

MortarInterfaceWarehouse()

MortarInterfaceWarehouse::MortarInterfaceWarehouse

(

const libMesh::ParallelObject &

other

)

Definition at line 38 of file MortarInterfaceWarehouse.C.

  : libMesh::ParallelObject(other), _mortar_initd(false)
{
}

Member Function Documentation

createMortarInterface()

void MortarInterfaceWarehouse::createMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	boundary_key,
		const std::pair< SubdomainID, SubdomainID > &	subdomain_key,
		SubProblem &	subproblem,
		bool	on_displaced,
		bool	periodic,
		const bool	debug,
		const bool	correct_edge_dropping,
		const Real	minimum_projection_angle,
		const Mortar3DSubpatchPlane	mortar_3d_subpatch_plane,
		const MooseEnum &	triangulation,
		const bool	triangulate_triangles,
		const Mortar3DQuadraturePointMapping	mortar_3d_qp_mapping = Mortar3DQuadraturePointMapping::NORMAL_PROJECTION
	)

Create mortar generation object.

Parameters

boundary_key	The primary-secondary boundary pair on which the AMG objects lives
subdomain_key	The primary-secondary subdomain pair on which the AMG objects lives
subproblem	A reference to the subproblem
on_displaced	Whether the AMG object lives on the displaced mesh
periodic	Whether the AMG object will be used for enforcing periodic constraints. Note that this changes the direction of the projection normals so one AMG object cannot be used to enforce both periodic and non-periodic constraints
debug	whether to output mortar segment mesh exodus file for debugging purposes
correct_edge_dropping	edge dropping treatment selection
minimum_projection_angle	minimum projection angle allowed for building mortar segment mesh
mortar_3d_subpatch_plane	method for constructing 3D mortar subpatch planes
triangulation	triangulation strategy used for clipped 3D mortar polygons
triangulate_triangles	whether a clipped polygon that is already a triangle should still be subdivided
mortar_3d_qp_mapping	method for mapping 3D mortar quadrature points to faces

Definition at line 44 of file MortarInterfaceWarehouse.C.

{
  _mortar_subdomain_coverage.insert(subdomain_key.first);
  _mortar_subdomain_coverage.insert(subdomain_key.second);
 
  _mortar_boundary_coverage.insert(boundary_key.first);
  _mortar_boundary_coverage.insert(boundary_key.second);
 
  MeshBase & mesh = subproblem.mesh().getMesh();
 
  auto & mortar_interfaces = on_displaced ? _displaced_mortar_interfaces : _mortar_interfaces;
  const auto triangulation_mode = toTriangulationMode(triangulation);
 
  auto interface_iterator = mortar_interfaces.find(boundary_key);
  if (interface_iterator != mortar_interfaces.end())
  {
    // Existing entry: every per-interface flag must agree across constraints sharing the same
    // primary-secondary surface pair.
    const auto & existing = interface_iterator->second;
    if (existing.periodic != periodic)
      mooseError("We do not currently support enforcing both periodic and non-periodic constraints "
                 "on the same boundary primary-secondary pair");
    if (existing.debug != debug)
      mooseError(
          "We do not currently support generating and not generating debug output "
          "on the same boundary primary-secondary surface pair. Please set debug_mesh = true for "
          "all constraints sharing the same primary-secondary surface pairs");
    if (!MooseUtils::absoluteFuzzyEqual(existing.minimum_projection_angle,
                                        minimum_projection_angle))
      mooseError("We do not currently support multiple values of 'minimum_projection_angle' on "
                 "the same boundary primary-secondary surface pair.");
    if (existing.mortar_3d_subpatch_plane != mortar_3d_subpatch_plane)
      mooseError("Mortar constraints sharing the same primary/secondary mortar interface must use "
                 "the same 'mortar_3d_subpatch_plane' value.");
    if (existing.triangulation != triangulation_mode)
      mooseError("We do not currently support multiple values of 'triangulation' on the same "
                 "boundary primary-secondary surface pair.");
    if (existing.triangulate_triangles != triangulate_triangles)
      mooseError("We do not currently support multiple values of 'triangulate_triangles' on the "
                 "same boundary primary-secondary surface pair.");
    if (existing.mortar_3d_qp_mapping != mortar_3d_qp_mapping)
      mooseError("We do not currently support multiple values of 'mortar_3d_qp_mapping' on the "
                 "same boundary primary-secondary surface pair.");
  }
  else
  {
    MortarInterfaceConfig config{
        std::make_unique<AutomaticMortarGeneration>(subproblem.getMooseApp(),
                                                    mesh,
                                                    boundary_key,
                                                    subdomain_key,
                                                    on_displaced,
                                                    periodic,
                                                    debug,
                                                    correct_edge_dropping,
                                                    minimum_projection_angle,
                                                    mortar_3d_subpatch_plane,
                                                    triangulation_mode,
                                                    triangulate_triangles,
                                                    mortar_3d_qp_mapping),
        periodic,
        debug,
        minimum_projection_angle,
        mortar_3d_subpatch_plane,
        triangulation_mode,
        triangulate_triangles,
        mortar_3d_qp_mapping};
    config.amg->initOutput();
    mortar_interfaces.emplace(boundary_key, std::move(config));
  }
 
  // See whether to query the mesh
  SubdomainID key1 = subdomain_key.first;
  SubdomainID key2 = subdomain_key.second;
 
  // it(1,2) is a a pair consisting of an iterator to the inserted element (or to the element that
  // prevented the insertion) and a bool denoting whether the insertion took place.
  auto it1 = _lower_d_sub_to_higher_d_subs.insert(std::make_pair(key1, std::set<SubdomainID>{}));
  auto it2 = _lower_d_sub_to_higher_d_subs.insert(std::make_pair(key2, std::set<SubdomainID>{}));
 
  // Each entry in this vector will be a pair. The first member of the pair corresponds to
  // the lower dimensional subomain ID. The second member of the pair corresponds to the higher
  // dimensional subdomain ids of the lower dimeionsal interior parents
  std::vector<std::pair<SubdomainID, std::set<SubdomainID> *>> subdomains_to_probe;
 
  if (it1.second)
    subdomains_to_probe.push_back(std::make_pair(key1, &it1.first->second));
  if (it2.second)
    subdomains_to_probe.push_back(std::make_pair(key2, &it2.first->second));
 
  for (auto & pr : subdomains_to_probe)
  {
    for (const Elem * lower_d_elem : as_range(mesh.active_local_subdomain_elements_begin(pr.first),
                                              mesh.active_local_subdomain_elements_end(pr.first)))
    {
      const Elem * ip = lower_d_elem->interior_parent();
      mooseAssert(
          ip,
          "Lower dimensional elements should always have an interior parent set when using mortar");
      pr.second->insert(ip->subdomain_id());
    }
 
    // Make sure that we get this right in parallel
    _communicator.set_union(*pr.second);
  }
}

dontNotifyWhenMortarSetup()

void MortarInterfaceWarehouse::dontNotifyWhenMortarSetup

(

MortarExecutorInterface *

mei

)

Removes mei from the container of objects that will have their mortarSetup method called whenever a mortar mesh's segment coverage is (re)built and has changed

Definition at line 291 of file MortarInterfaceWarehouse.C.

{
  _mei_objs.erase(mei_obj);
}

Referenced by MortarExecutorInterface::MortarExecutorInterface(), and MortarUserObjectThread::~MortarUserObjectThread().

getHigherDimSubdomainIDs()

const std::set< SubdomainID > & MortarInterfaceWarehouse::getHigherDimSubdomainIDs

(

SubdomainID

lower_d_subdomain_id

)

const

Returns the higher dimensional subdomain ids of the interior parents of the given lower-d subdomain id.

Definition at line 274 of file MortarInterfaceWarehouse.C.

{
  if (_lower_d_sub_to_higher_d_subs.find(lower_d_subdomain_id) ==
      _lower_d_sub_to_higher_d_subs.end())
    mooseError("The lower dimensional ID ",
               lower_d_subdomain_id,
               " has not been added to MortarInterfaceWarehouse yet");
  return _lower_d_sub_to_higher_d_subs.at(lower_d_subdomain_id);
}

getMortarBoundaryIDs()

const std::set< BoundaryID > & MortarInterfaceWarehouse::getMortarBoundaryIDs ( ) const

inline

Returns the mortar covered boundaries.

Definition at line 125 of file MortarInterfaceWarehouse.h.

{ return _mortar_boundary_coverage; }

getMortarInterface() [1/2]

AutomaticMortarGeneration & MortarInterfaceWarehouse::getMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	boundary_key,
		const std::pair< SubdomainID, SubdomainID > &	subdomain_key,
		bool	on_displaced
	)

Non-const getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain keys.

If the AutomaticMortarGeneration object does not yet exist, then we error

Definition at line 178 of file MortarInterfaceWarehouse.C.

{
  return const_cast<AutomaticMortarGeneration &>(
      const_cast<const MortarInterfaceWarehouse *>(this)->getMortarInterface(
          boundary_key, subdomain_key, on_displaced));
}

getMortarInterface() [2/2]

const AutomaticMortarGeneration & MortarInterfaceWarehouse::getMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	boundary_key,
		const std::pair< SubdomainID, SubdomainID > &	,
		bool	on_displaced
	)		const

Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain keys.

If the AutomaticMortarGeneration object does not yet exist, then we error

Definition at line 164 of file MortarInterfaceWarehouse.C.

{
  auto & mortar_interfaces = on_displaced ? _displaced_mortar_interfaces : _mortar_interfaces;
  auto it = mortar_interfaces.find(boundary_key);
  if (it == mortar_interfaces.end())
    mooseError(
        "The requested mortar interface AutomaticMortarGeneration object does not yet exist!");
  return *it->second.amg;
}

Referenced by getMortarInterface().

getMortarInterfaces()

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > & MortarInterfaceWarehouse::getMortarInterfaces ( bool  on_displaced ) const

inline

Return the per-interface configuration map (AutomaticMortarGeneration object plus the associated user flags) for either the displaced or undisplaced mesh.

Iterating callers should reach the AMG via the value's amg member.

Definition at line 109 of file MortarInterfaceWarehouse.h.

  {
    if (on_displaced)
      return _displaced_mortar_interfaces;
    else
      return _mortar_interfaces;
  }

getMortarSubdomainIDs()

const std::set< SubdomainID > & MortarInterfaceWarehouse::getMortarSubdomainIDs ( ) const

inline

Returns the mortar covered subdomains.

Definition at line 120 of file MortarInterfaceWarehouse.h.

{ return _mortar_subdomain_coverage; }

hasDisplacedObjects()

bool MortarInterfaceWarehouse::hasDisplacedObjects ( ) const

inline

Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh.

Definition at line 144 of file MortarInterfaceWarehouse.h.

{ return _displaced_mortar_interfaces.size(); }

hasObjects()

bool MortarInterfaceWarehouse::hasObjects ( ) const

inline

Returns whether we have any active AutomaticMortarGeneration objects.

Definition at line 149 of file MortarInterfaceWarehouse.h.

{ return _mortar_interfaces.size(); }

initialized()

bool MortarInterfaceWarehouse::initialized ( ) const

inline

Returns

whether we have performed an initial mortar mesh construction

Definition at line 173 of file MortarInterfaceWarehouse.h.

{ return _mortar_initd; }

meshChanged()

void MortarInterfaceWarehouse::meshChanged

(

)

Invalidates cached MSM node/element ID offsets on all mortar interfaces so they are recomputed on the next update().

Call when mesh topology changes.

Definition at line 204 of file MortarInterfaceWarehouse.C.

{
  for (auto & mortar_pair : _mortar_interfaces)
    mortar_pair.second.amg->meshChanged();
  for (auto & mortar_pair : _displaced_mortar_interfaces)
    mortar_pair.second.amg->meshChanged();
  update();
}

notifyWhenMortarSetup()

void MortarInterfaceWarehouse::notifyWhenMortarSetup

(

MortarExecutorInterface *

mei

)

Adds mei to the container of objects that will have their mortarSetup method called whenever a mortar mesh's segment coverage is (re)built and has changed, including the first build

Definition at line 285 of file MortarInterfaceWarehouse.C.

{
  _mei_objs.insert(mei_obj);
}

Referenced by MortarExecutorInterface::MortarExecutorInterface(), and MortarExecutorInterface::MortarExecutorInterface().

update() [1/2]

bool MortarInterfaceWarehouse::update

(

)

Builds mortar segment meshes for each mortar interface.

Returns

Whether any interface's mortar segment coverage (interior-parent subdomains) changed as a result of this rebuild. Callers that also need to refresh mortar-dependent DoF ghosting (see FEProblemBase::updateMortarMesh()) can key off this instead of re-deriving it.

Definition at line 189 of file MortarInterfaceWarehouse.C.

{
  bool coverage_changed = false;
 
  for (auto & mortar_pair : _mortar_interfaces)
    coverage_changed |= update(*mortar_pair.second.amg);
  for (auto & mortar_pair : _displaced_mortar_interfaces)
    coverage_changed |= update(*mortar_pair.second.amg);
 
  _mortar_initd = true;
 
  return coverage_changed;
}

Referenced by meshChanged(), and update().

update() [2/2]

bool MortarInterfaceWarehouse::update ( AutomaticMortarGeneration &  amg )

private

Builds mortar segment mesh from specific AutomaticMortarGeneration object.

Returns

Whether amg's interior-parent subdomain coverage changed (or this is the first build)

Definition at line 214 of file MortarInterfaceWarehouse.C.

{
  // Snapshot the interior-parent subdomain coverage before clearing so we can tell afterward
  // whether this rebuild changed which subdomains the mortar segment mesh touches. Consumers
  // registered via notifyWhenMortarSetup() rebuild material dependency lists keyed off exactly
  // these sets (see Moose::Mortar::setupMortarMaterials), so a change here is what they need to
  // be notified of.
  const auto secondary_ip_sub_ids_before = amg.secondaryIPSubIDs();
  const auto primary_ip_sub_ids_before = amg.primaryIPSubIDs();
 
  // Clear exiting data
  amg.clear();
 
  const auto dim = amg.dim();
 
  if (dim == 1)
    mooseError("Mortar constraints are not currently supported for 1D meshes");
  else if (dim != 2 && dim != 3)
    mooseError("Invalid mesh dimension for mortar constraint");
 
  // Construct maps from nodes -> lower dimensional elements on the primary and secondary
  // boundaries.
  amg.buildNodeToElemMaps();
 
  // Compute nodal geometry (normals and tangents).
  amg.computeNodalGeometry();
 
  if (dim == 2)
  {
    // Project secondary nodes (find xi^(2) values).
    amg.projectSecondaryNodes();
 
    // Project primary nodes (find xi^(1) values).
    amg.projectPrimaryNodes();
 
    // Build the mortar segment mesh on the secondary boundary.
    amg.buildMortarSegmentMesh();
  }
  else // dim == 3
    amg.buildMortarSegmentMesh3d();
 
  amg.computeInactiveLMNodes();
  amg.computeInactiveLMElems();
 
  // Fire on the first build unconditionally (nothing to compare against yet), and otherwise only
  // when coverage actually changed: setupMortarMaterials() rebuilds three containers via
  // MaterialBase::buildRequiredMaterials dependency resolution, which we do not want to redo on
  // every residual/Jacobian evaluation.
  const bool coverage_changed = !_mortar_initd ||
                                secondary_ip_sub_ids_before != amg.secondaryIPSubIDs() ||
                                primary_ip_sub_ids_before != amg.primaryIPSubIDs();
 
  if (coverage_changed)
    for (const auto mei : _mei_objs)
      mei->mortarSetup(amg);
 
  return coverage_changed;
}

Member Data Documentation

_displaced_mortar_interfaces

std::unordered_map<MortarKey, MortarInterfaceConfig> MortarInterfaceWarehouse::_displaced_mortar_interfaces

private

Map from primary-secondary (in that order) boundary ID pair to the configuration of the displaced mortar interface (AMG object + per-interface flags).

Definition at line 191 of file MortarInterfaceWarehouse.h.

Referenced by createMortarInterface(), getMortarInterface(), getMortarInterfaces(), hasDisplacedObjects(), meshChanged(), and update().

_lower_d_sub_to_higher_d_subs

std::unordered_map<SubdomainID, std::set<SubdomainID> > MortarInterfaceWarehouse::_lower_d_sub_to_higher_d_subs

private

Map from lower dimensional subdomain ids to corresponding higher simensional subdomain ids (e.g.

the ids of the interior parents)

Definition at line 203 of file MortarInterfaceWarehouse.h.

Referenced by createMortarInterface(), and getHigherDimSubdomainIDs().

_mei_objs

std::set<MortarExecutorInterface *> MortarInterfaceWarehouse::_mei_objs

private

A container of objects for whom the mortarSetup method will be called whenever a mortar mesh's segment coverage is (re)built and has changed, including the first build.

Definition at line 207 of file MortarInterfaceWarehouse.h.

Referenced by dontNotifyWhenMortarSetup(), notifyWhenMortarSetup(), and update().

_mortar_boundary_coverage

std::set<BoundaryID> MortarInterfaceWarehouse::_mortar_boundary_coverage

private

A set containing the boundary ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object.

Definition at line 199 of file MortarInterfaceWarehouse.h.

Referenced by createMortarInterface(), and getMortarBoundaryIDs().

_mortar_initd

bool MortarInterfaceWarehouse::_mortar_initd

private

Whether we have performed any mortar mesh construction.

Definition at line 210 of file MortarInterfaceWarehouse.h.

Referenced by initialized(), update(), and update().

_mortar_interfaces

std::unordered_map<MortarKey, MortarInterfaceConfig> MortarInterfaceWarehouse::_mortar_interfaces

private

Map from primary-secondary (in that order) boundary ID pair to the configuration of the undisplaced mortar interface (AMG object + per-interface flags).

Definition at line 187 of file MortarInterfaceWarehouse.h.

Referenced by createMortarInterface(), getMortarInterface(), getMortarInterfaces(), hasObjects(), meshChanged(), and update().

_mortar_subdomain_coverage

std::set<SubdomainID> MortarInterfaceWarehouse::_mortar_subdomain_coverage

private

A set containing the subdomain ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object.

Definition at line 195 of file MortarInterfaceWarehouse.h.

Referenced by createMortarInterface(), and getMortarSubdomainIDs().

---

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

• include/constraints/MortarInterfaceWarehouse.h
• src/constraints/MortarInterfaceWarehouse.C