#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)
	Create mortar generation object. More...

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

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

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, std::unique_ptr< AutomaticMortarGeneration > > &	getMortarInterfaces (bool on_displaced) const
	Return all automatic mortar generation objects on either the displaced or undisplaced mesh. More...

const std::set< SubdomainID > &	getMortarSubdomainIDs () const
	Returns the mortar covered subdomains. More...

const std::set< BoundaryID > &	getMortarBoundaryIDs () const
	Returns the mortar covered boundaries. More...

void	update ()
	Builds mortar segment meshes for each mortar interface. More...

bool	hasDisplacedObjects () const
	Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh. More...

bool	hasObjects () const
	Returns whether we have any active AutomaticMortarGeneration objects. More...

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

void	notifyWhenMortarSetup (MortarExecutorInterface *mei)
	Adds `mei` to the container of objects that will have their `mortarSetup` method called as soon as the mortar mesh has been generated for the first time More...

void	dontNotifyWhenMortarSetup (MortarExecutorInterface *mei)
	Removes `mei` from the container of objects that will have their `mortarSetup` method called as soon as the mortar mesh has been generated for the first time More...

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
void	update (AutomaticMortarGeneration &amg)
	Builds mortar segment mesh from specific AutomaticMortarGeneration object. More...

Private Attributes
std::unordered_map< MortarKey, std::unique_ptr< AutomaticMortarGeneration > >	_mortar_interfaces
	Map from primary-secondary (in that order) boundary ID pair to the corresponding undisplaced AutomaticMortarGeneration object. More...

std::unordered_map< MortarKey, std::unique_ptr< AutomaticMortarGeneration > >	_displaced_mortar_interfaces
	Map from primary-secondary (in that order) boundary ID pair to the corresponding displaced AutomaticMortarGeneration object. More...

std::set< SubdomainID >	_mortar_subdomain_coverage
	A set containing the subdomain ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object. More...

std::set< BoundaryID >	_mortar_boundary_coverage
	A set containing the boundary ids covered by all the mortar interfaces in this MortarInterfaceWarehouse object. More...

std::unordered_map< MortarKey, bool >	_periodic_map
	Map from undisplaced AMG key to whether the undisplaced AMG object is enforcing periodic constraints. More...

std::unordered_map< MortarKey, bool >	_displaced_periodic_map
	Map from displaced AMG key to whether the displaced AMG object is enforcing periodic constraints. More...

std::unordered_map< MortarKey, bool >	_debug_flag_map
	Map from undisplaced AMG key to whether the undisplaced AMG object is to output mortar segment mesh. More...

std::unordered_map< MortarKey, bool >	_displaced_debug_flag_map
	Map from displaced AMG key to whether the displaced AMG object is to output mortar segment mesh. More...

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

std::set< MortarExecutorInterface * >	_mei_objs
	A container of objects for whom the `mortarSetup` method will be called after the mortar mesh has been setup for the first time. More...

bool	_mortar_initd
	Whether we have performed any mortar mesh construction. More...

Detailed Description

Definition at line 24 of file MortarInterfaceWarehouse.h.

Member Typedef Documentation

◆ MortarKey

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

private

Definition at line 137 of file MortarInterfaceWarehouse.h.

Constructor & Destructor Documentation

◆ MortarInterfaceWarehouse()

MortarInterfaceWarehouse::MortarInterfaceWarehouse ( const libMesh::ParallelObject & other )

Definition at line 17 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
	)

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

Definition at line 23 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 & periodic_map = on_displaced ? _displaced_periodic_map : _periodic_map;
   auto & debug_flag_map = on_displaced ? _displaced_debug_flag_map : _debug_flag_map;
   auto & mortar_interfaces = on_displaced ? _displaced_mortar_interfaces : _mortar_interfaces;
 
   // Periodic flag
   auto periodic_map_iterator = periodic_map.find(boundary_key);
   if (periodic_map_iterator != periodic_map.end() && periodic_map_iterator->second != periodic)
     mooseError("We do not currently support enforcing both periodic and non-periodic constraints "
                "on the same boundary primary-secondary pair");
   else
     periodic_map.insert(periodic_map_iterator, std::make_pair(boundary_key, periodic));
 
   // Debug mesh flag displaced
   auto debug_flag_map_iterator = debug_flag_map.find(boundary_key);
   if (debug_flag_map_iterator != debug_flag_map.end() && debug_flag_map_iterator->second != 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");
   else
     debug_flag_map.insert(debug_flag_map_iterator, std::make_pair(boundary_key, debug));
 
   // Generate lower-d mesh
   if (mortar_interfaces.find(boundary_key) == mortar_interfaces.end())
   {
     auto [it, inserted] = mortar_interfaces.emplace(
         boundary_key,
         std::make_unique<AutomaticMortarGeneration>(subproblem.getMooseApp(),
                                                     mesh,
                                                     boundary_key,
                                                     subdomain_key,
                                                     on_displaced,
                                                     periodic,
                                                     debug,
                                                     correct_edge_dropping,
                                                     minimum_projection_angle));
     if (inserted)
       it->second->initOutput();
   }
 
   // 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 as soon as the mortar mesh has been generated for the first time

Definition at line 205 of file MortarInterfaceWarehouse.C.

 {
   _mei_objs.erase(mei_obj);
 }

◆ 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 188 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 91 of file MortarInterfaceWarehouse.h.

91 { return _mortar_boundary_coverage; }

MortarInterfaceWarehouse::_mortar_boundary_coverage

std::set< BoundaryID > _mortar_boundary_coverage

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

Definition: MortarInterfaceWarehouse.h:154

◆ getMortarInterface() [1/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 118 of file MortarInterfaceWarehouse.C.

Referenced by getMortarInterface().

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

◆ getMortarInterface() [2/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 132 of file MortarInterfaceWarehouse.C.

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

◆ getMortarInterfaces()

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

inline

Return all automatic mortar generation objects on either the displaced or undisplaced mesh.

Definition at line 75 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 86 of file MortarInterfaceWarehouse.h.

86 { return _mortar_subdomain_coverage; }

MortarInterfaceWarehouse::_mortar_subdomain_coverage

std::set< SubdomainID > _mortar_subdomain_coverage

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

Definition: MortarInterfaceWarehouse.h:150

◆ hasDisplacedObjects()

bool MortarInterfaceWarehouse::hasDisplacedObjects ( ) const

inline

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

Definition at line 101 of file MortarInterfaceWarehouse.h.

101 { return _displaced_mortar_interfaces.size(); }

MortarInterfaceWarehouse::_displaced_mortar_interfaces

std::unordered_map< MortarKey, std::unique_ptr< AutomaticMortarGeneration > > _displaced_mortar_interfaces

Map from primary-secondary (in that order) boundary ID pair to the corresponding displaced AutomaticM...

Definition: MortarInterfaceWarehouse.h:146

◆ hasObjects()

bool MortarInterfaceWarehouse::hasObjects ( ) const

inline

Returns whether we have any active AutomaticMortarGeneration objects.

Definition at line 106 of file MortarInterfaceWarehouse.h.

106 { return _mortar_interfaces.size(); }

MortarInterfaceWarehouse::_mortar_interfaces

std::unordered_map< MortarKey, std::unique_ptr< AutomaticMortarGeneration > > _mortar_interfaces

Map from primary-secondary (in that order) boundary ID pair to the corresponding undisplaced Automati...

Definition: MortarInterfaceWarehouse.h:141

◆ initialized()

bool MortarInterfaceWarehouse::initialized ( ) const

inline

Returns: whether we have performed an initial mortar mesh construction

Definition at line 129 of file MortarInterfaceWarehouse.h.

129 { return _mortar_initd; }

MortarInterfaceWarehouse::_mortar_initd

bool _mortar_initd

Whether we have performed any mortar mesh construction.

Definition: MortarInterfaceWarehouse.h:177

◆ notifyWhenMortarSetup()

void MortarInterfaceWarehouse::notifyWhenMortarSetup ( MortarExecutorInterface * mei )

Adds mei to the container of objects that will have their mortarSetup method called as soon as the mortar mesh has been generated for the first time

Definition at line 199 of file MortarInterfaceWarehouse.C.

 {
   _mei_objs.insert(mei_obj);
 }

◆ update() [1/2]

void MortarInterfaceWarehouse::update ( )

Builds mortar segment meshes for each mortar interface.

Definition at line 143 of file MortarInterfaceWarehouse.C.

 {
   for (auto & mortar_pair : _mortar_interfaces)
     update(*mortar_pair.second);
   for (auto & mortar_pair : _displaced_mortar_interfaces)
     update(*mortar_pair.second);
 
   _mortar_initd = true;
 }

◆ update() [2/2]

void MortarInterfaceWarehouse::update ( AutomaticMortarGeneration & amg )

private

Builds mortar segment mesh from specific AutomaticMortarGeneration object.

Definition at line 154 of file MortarInterfaceWarehouse.C.

 {
   // Clear exiting data
   amg.clear();
 
   // Construct maps from nodes -> lower dimensional elements on the primary and secondary
   // boundaries.
   amg.buildNodeToElemMaps();
 
   // Compute nodal geometry (normals and tangents).
   amg.computeNodalGeometry();
 
   const auto dim = amg.dim();
   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 if (dim == 3)
     amg.buildMortarSegmentMesh3d();
   else
     mooseError("Invalid mesh dimension for mortar constraint");
 
   amg.computeInactiveLMNodes();
   amg.computeInactiveLMElems();
 }