MortaringHelpers Namespace Reference

Classes
class	MergedSolidMesh
class	PointIntegralScheme
class	PointElementWithExternalElement

Enumerations
enum	Colour { WHITE , GREY , BLACK }

Functions
template<class NodeNodeConstraintClass , class NodeElementConstraintClass , class ELEMENTTYPE >
Vector< ConstraintElement * >	setup_constraint_elements_at_nodes (Problem *problem_pt, Vector< Vector< Node * >> node_pt, Vector< SolidMesh * > mesh_pt, const bool &accept_failure=false)
template<class NodeNodeConstraintElementType >
void	dfs (Node *node_pt, Node *parent_node_pt, std::map< Node *, Vector< std::pair< NodeNodeConstraintElementType *, Node * >>> &tree, std::map< Node *, Colour > &colours, Vector< NodeNodeConstraintElementType * > &pruned_branches)
template<class NodeNodeConstraintElementType >
Vector< NodeNodeConstraintElementType * >	find_redundant_constraint_elements (Vector< NodeNodeConstraintElementType * > element_pt)

Variables
static double	Mortaring_Constraints_Distance_Tolerance = 1e-10

Enumeration Type Documentation

Colour

enum MortaringHelpers::Colour

Enumerator
WHITE
GREY
BLACK

{ WHITE, GREY, BLACK };

Function Documentation

dfs()

template<class NodeNodeConstraintElementType >

void MortaringHelpers::dfs	(	Node *	node_pt,
		Node *	parent_node_pt,
		std::map< Node *, Vector< std::pair< NodeNodeConstraintElementType *, Node * >>> &	tree,
		std::map< Node *, Colour > &	colours,
		Vector< NodeNodeConstraintElementType * > &	pruned_branches
	)

{
 // Mark the current node as being visited (GREY)
 colours[node_pt] = GREY;
 
 // Get all branches (edges) from the current node
 Vector<std::pair<NodeNodeConstraintElementType*, Node*>> branches = tree[node_pt];
 for (auto& branch : branches)
 {
  Node* next_node = branch.second;
  NodeNodeConstraintElementType* element = branch.first;
 
  // If the branch has already been pruned, skip it
  if (std::find(pruned_branches.begin(), pruned_branches.end(), element) != pruned_branches.end())
  {
   continue;
  }
 
  // If we encounter a GREY node that is not the parent, a cycle is detected
  if (colours[next_node] == GREY && next_node != parent_node_pt)
  {
   pruned_branches.push_back(element);
  }
  // If the next node is unvisited (WHITE), continue DFS
  else if (colours[next_node] == WHITE)
  {
   dfs(next_node, node_pt, tree, colours, pruned_branches);
  }
 }
 
 // Mark the current node as fully processed (BLACK)
 colours[node_pt] = BLACK;
}

References BLACK, GREY, and WHITE.

Referenced by Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_post(), and find_redundant_constraint_elements().

find_redundant_constraint_elements()

template<class NodeNodeConstraintElementType >

Vector<NodeNodeConstraintElementType*> MortaringHelpers::find_redundant_constraint_elements

(

Vector< NodeNodeConstraintElementType * >

element_pt

)

{
 // Create a tree representation from the constraint elements
 std::map<Node*, Vector<std::pair<NodeNodeConstraintElementType*, Node*>>> tree;
 for (auto& element : element_pt)
 {
  Node* node1 = element->solid_node_pt(0);
  Node* node2 = element->solid_node_pt(1);
  tree[node1].push_back(std::make_pair(element, node2));
  tree[node2].push_back(std::make_pair(element, node1));
 }
 
 // Vector to store the pruned branches
 Vector<NodeNodeConstraintElementType*> pruned_branches;
 // Map to store the colours of the nodes
 std::map<Node*, Colour> colours;
 
 // Initialize all nodes as unvisited (WHITE)
 for (auto& node_branches : tree)
 {
  Node* root_node = node_branches.first;
  if (colours[root_node] == WHITE)
  {
   // // Perform DFS to detect cycles starting from the root node
   dfs(root_node, nullptr, tree, colours, pruned_branches);
  }
 }
 
 return pruned_branches;
}

References dfs(), and WHITE.

setup_constraint_elements_at_nodes()

template<class NodeNodeConstraintClass , class NodeElementConstraintClass , class ELEMENTTYPE >

Vector<ConstraintElement*> MortaringHelpers::setup_constraint_elements_at_nodes	(	Problem *	problem_pt,
		Vector< Vector< Node * >>	node_pt,
		Vector< SolidMesh * >	mesh_pt,
		const bool &	accept_failure = false
	)

{
 // Vector of constraint elements built
 Vector<ConstraintElement*> constraint_element_pt;
 
 // Assume all the nodes/elements are the same dimension
 const unsigned dim = node_pt[0][0]->ndim();
 
 // The number of nodes from each mesh
 const Vector<long unsigned> n_node = {node_pt[0].size(), node_pt[1].size()};
 
 // Allocate for nodes which were not matched to other nodes
 Vector<Vector<unsigned>> node_was_matched(2);
 node_was_matched[0].resize(n_node[0], 0);
 node_was_matched[1].resize(n_node[1], 0);
 
 // First attempt to match each node to another in the other mesh
 unsigned n_matched_nodes = 0;
 for(unsigned i=0; i<n_node[0]; i++)
 {
  SolidNode* node_0_pt = dynamic_cast<SolidNode*>(node_pt[0][i]);
  for(unsigned j=0; j<n_node[1]; j++)
  {
   // If the node has already been matched to another node
   if(node_was_matched[1][j]) continue;
 
   SolidNode* node_1_pt = dynamic_cast<SolidNode*>(node_pt[1][j]);
 
   // get the distance between the nodes TODO is it faster to just check absolute distance in each spatial direction?
   double distance = 0.0;
   for(unsigned d=0; d<dim; d++)
   {
    distance += (node_0_pt->xi(d) - node_1_pt->xi(d))*
                (node_0_pt->xi(d) - node_1_pt->xi(d));
   }
   // if co-located build constraint element
   if(sqrt(distance) < Mortaring_Constraints_Distance_Tolerance)
   {
    // If the nodes are the same then skip this, we can't mortar a node to itself
    // This check is useful because it will allow a mesh to be mortared to itself
    if(node_0_pt == node_1_pt) continue;
    // Record that these nodes were matched
    node_was_matched[0][i] = 1;
    node_was_matched[1][j] = 1;
    n_matched_nodes++;
    // Build the node-node constraint element
    constraint_element_pt.push_back(new NodeNodeConstraintClass(node_0_pt, node_1_pt));
 
    // stop checking for this node in the first mesh
    break;
   }
  }
 }
 
 // If we have matched all nodes then return
 if((n_node[0] - n_matched_nodes) == 0 && (n_node[1] - n_matched_nodes) == 0 ) return constraint_element_pt;
 
 // If we get to here then we know that some nodes have not been mortared.
 // If the mesh pointers are the same then we know we have failed. We can't perform the following procedure
 // if the meshes are the same.
 if(mesh_pt[0] == mesh_pt[1])
 {
  throw OomphLibError("Mortaring failed - meshes are the same and node-node mortaring has not captured all nodes",
                   OOMPH_CURRENT_FUNCTION,
                   OOMPH_EXCEPTION_LOCATION);
 }
 
 const bool Previous_Accept_failed_locate_zeta_in_setup_multi_domain_interaction
  = Multi_domain_functions::Accept_failed_locate_zeta_in_setup_multi_domain_interaction;
 Multi_domain_functions::Accept_failed_locate_zeta_in_setup_multi_domain_interaction = accept_failure;
 
                                                                       
 // Figure out how many nodes are left to be matched from each mesh
 Vector<long unsigned> n_unmatched_nodes{n_node[0] - n_matched_nodes,
                                         n_node[1] - n_matched_nodes};
 
 for(unsigned m : {0,1})
 {
  if(n_unmatched_nodes[m] == 0) continue;
  
  // Get the nodes which were not matched
  Vector<Node*> unmatched_node_pt(n_unmatched_nodes[m]);
  unsigned count = 0;
  for(unsigned i=0; i<n_node[m]; i++)
  {
   if(!node_was_matched[m][i])
   {
    unmatched_node_pt[count++] = node_pt[m][i];
   }
  }
 
  // Create a mesh for locating the zetas in the other mesh
  Mesh* Locating_mesh_pt = new Mesh;
 
  Vector<PointElementWithExternalElement*> locating_elements_pt(n_unmatched_nodes[m]);
  for(unsigned i=0; i<n_unmatched_nodes[m]; i++)
  {
   Vector<double> x(dim);
   for(unsigned d=0; d<dim; d++)
   {
    x[d] = dynamic_cast<SolidNode*>(unmatched_node_pt[i])->xi(d);
   }
 
   locating_elements_pt[i] = new PointElementWithExternalElement(x);
   Locating_mesh_pt->add_element_pt(locating_elements_pt[i]);
  }
 
  // Setup multi domain interactions with the second mesh
  Multi_domain_functions::setup_multi_domain_interaction<ELEMENTTYPE>(problem_pt,
                                                                      Locating_mesh_pt,
                                                                      mesh_pt[unsigned(1-m)],
                                                                      0);
 
  // Loop over the locating elements
  for(unsigned i=0; i<n_unmatched_nodes[m]; i++)
  {
   // If the external element was not found skip this element - no need to crash out, that would have happened
   // earlier if this was an issue (if accept_failure == false)
   if(locating_elements_pt[i]->external_element_pt(0,0) == nullptr) continue;
   constraint_element_pt.push_back(new NodeElementConstraintClass(dynamic_cast<SolidNode*>(unmatched_node_pt[i]),
                                                                  locating_elements_pt[i]->external_element_pt(0,0),
                                                                  locating_elements_pt[i]->external_element_local_coord(0,0)));
  }
 }
 Multi_domain_functions::Accept_failed_locate_zeta_in_setup_multi_domain_interaction = Previous_Accept_failed_locate_zeta_in_setup_multi_domain_interaction;
 
 return constraint_element_pt;
}

References oomph::Multi_domain_functions::Accept_failed_locate_zeta_in_setup_multi_domain_interaction, oomph::Mesh::add_element_pt(), i, j, m, Mortaring_Constraints_Distance_Tolerance, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, sqrt(), plotDoE::x, and oomph::SolidNode::xi().

Referenced by MortaringValidationProblem< ELEMENT, NON_MORTAR_ELEMENT >::build_constraint_elements(), and MortaringValidationProblem< ELEMENT, NON_MORTAR_ELEMENT >::build_mortaring_elements().

Variable Documentation

Mortaring_Constraints_Distance_Tolerance

double MortaringHelpers::Mortaring_Constraints_Distance_Tolerance = 1e-10

static

Referenced by setup_constraint_elements_at_nodes().