NodeReordering Namespace Reference

Contains helper function to reorganise nodes. More...

Functions
bool	node_global_position_comparison (Node *nd1_pt, Node *nd2_pt)
void	get_node_reordering (Mesh *mesh_pt, Vector< Node * > &reordering, const bool &use_old_ordering)
void	reorder_nodes (Mesh *mesh_pt, const bool &use_old_ordering)

Detailed Description

Contains helper function to reorganise nodes.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

Function Documentation

get_node_reordering()

void NodeReordering::get_node_reordering	(	Mesh *	mesh_pt,
		Vector< Node * > &	reordering,
		const bool &	use_old_ordering
	)

Get a vector of the nodes in the order in which they are encountered when stepping through the elements (similar to reorder_nodes() but without changing the mesh's node vector).

  {
    // If the user wants to use the original ordering
    if (use_old_ordering)
    {
      // Setup map to check if nodes have been done yet
      std::map<Node*,bool> done;
 
      // Loop over all nodes
      unsigned nnod=mesh_pt->nnode();
 
      // Initialise the vector
      reordering.assign(nnod,0);
 
      // Return immediately if there are no nodes: Note assumption:
      // Either all the elements' nodes stored here or none. If only a subset
      // is stored in the Node_pt vector we'll get a range checking error below
      // (only if run with range checking, of course).
      if (nnod==0)
      {
        // Return immediately
        return;
      }
 
      // Loop over the nodes in the mesh
      for (unsigned j=0; j<nnod; j++)
      {
        // Indicate whether or not the node has been swapped
        done[mesh_pt->node_pt(j)]=false;
      }
 
      // Initialise counter for number of nodes
      unsigned long count=0;
 
      // Get the number of elements in the mesh
      unsigned nel=mesh_pt->nelement();
 
      // Loop over all elements
      for (unsigned e=0; e<nel; e++)
      {
        // Upcase FiniteElement (or derived) class object
        FiniteElement* el_pt=mesh_pt->finite_element_pt(e);
 
        // If the upcast was successful
        if (el_pt!=0)
        {
          // Get the number of nodes in this element
          unsigned nnod=el_pt->nnode();
 
          // Loop over nodes in element
          for (unsigned j=0; j<nnod; j++)
          {
            // Get a pointer to the j-th node in the element
            Node* nod_pt=el_pt->node_pt(j);
 
            // Has node been done yet?
            if (!done[nod_pt])
            {
              // Insert into node vector. NOTE: If you get a seg fault/range
              // checking error here then you probably haven't added all the
              // elements' nodes to the Node_pt vector -- this is most likely
              // to arise in the case of meshes of face elements (though they
              // usually don't store the nodes at all so if you have any
              // problems here there's something unusual/not quite right in
              // any case... For this reason we don't range check here by
              // default (not even under paranoia) but force you turn on proper
              // (costly) range checking to track this down...
              reordering[count]=nod_pt;
 
              // Indicate that the node has been done
              done[nod_pt]=true;
 
              // Increase counter
              count++;
            }
          } // for (unsigned j=0;j<nnod;j++)
        } // if (el_pt!=0)
      } // for (unsigned e=0;e<nel;e++)
 
      // Sanity check
      if (count!=nnod)
      {
        // Create an error message
        std::string error_message="Trouble: Number of nodes hasn't stayed ";
 
        // Finish off the message
        error_message+="constant during reordering!\n";
 
        // Throw an error
        throw OomphLibError(error_message,
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
    else
    {
      // Copy node vector out
      unsigned n_node=mesh_pt->nnode();
 
      // Resize the node ordering vector
      reordering.resize(n_node);
 
      // Loop over the nodes
      for (unsigned i=0; i<n_node; i++)
      {
        // Assign the i-th node pointer entry
        reordering[i]=mesh_pt->node_pt(i);
      }
 
      // Now sort the nodes lexicographically
      std::sort(reordering.begin(),reordering.end(),
                &node_global_position_comparison);
    } // if (use_old_ordering)
  } // End of get_node_reordering

References e(), oomph::Mesh::finite_element_pt(), i, j, oomph::Mesh::nelement(), oomph::FiniteElement::nnode(), oomph::Mesh::nnode(), node_global_position_comparison(), oomph::FiniteElement::node_pt(), oomph::Mesh::node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

Referenced by reorder_nodes().

node_global_position_comparison()

bool NodeReordering::node_global_position_comparison ( Node *  nd1_pt, Node *  nd2_pt  )

inline

Function for ordering nodes. Return true if first node's position is "before" second nodes. Dimension 0 checked first, then... until they are different (by more than tol=1e-10). If they are both in exactly the same place an error is thrown.

  {
    // If we're comparing a node with itself
    if (nd1_pt==nd2_pt)
    {
      // Don't do anything (passing true makes std::sort break...)
      return false;
    }
 
    // Get the number of dimensions stored by the node
    unsigned n_dim=nd1_pt->ndim();
 
    // A vector containing the indices in the order to check them. Order by
    // time slices first, then order the nodes in each time-slice by their x
    // position and finally order the nodes by their y-position (3D version)
    unsigned chosen_index[]= {2,0,1};
 
    // The coordinate indices in the order to check them (2D version)
    unsigned chosen_index_2d[]= {0,1};
 
    // Allocate space for the index we're going to order by
    unsigned j=0;
 
    // Loop over the spatial coordinates
    for (unsigned i=0; i<n_dim; i++)
    {
      // If we're in 3D (space-time)
      if (n_dim==3)
      {
        // The index we're going to order by
        j=chosen_index[i];
      }
      else
      {
        // The index we're going to order by
        j=chosen_index_2d[i];
      }
 
      // Check to see if the points occupy the same position (in index j)
      if (std::abs(nd1_pt->x(j)-nd2_pt->x(j))>1e-10)
      {
        // Check to see if node 1 is before node 2
        if (nd1_pt->x(j)<nd2_pt->x(j))
        {
          // Node 1 is before node 2 so return true
          return true;
        }
        // If node 2 is after node 1
        else
        {
          // Node 1 isn't before node 2 so return false
          return false;
        }
      } // if (std::abs(nd1_pt->x(j)-nd2_pt->x(j))>1e-10)
    } // for (unsigned i=0;i<n_dim;i++)
 
    // Create an output stream
    std::ostringstream error_message_stream;
 
    // Construct the error message
    error_message_stream << "Nodes are at the same point to ~1e-10! "
                         << "The difference is "
                         << std::abs(nd1_pt->x(j)-nd2_pt->x(j)) << std::endl;
 
    // Throw the error message
    throw OomphLibError(error_message_stream.str(),
                        OOMPH_EXCEPTION_LOCATION,
                        OOMPH_CURRENT_FUNCTION);
  } // End of node_global_position_comparison

References abs(), e(), i, j, oomph::Node::ndim(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Node::x().

Referenced by get_node_reordering().

reorder_nodes()

void NodeReordering::reorder_nodes	(	Mesh *	mesh_pt,
		const bool &	use_old_ordering
	)

Reorder nodes in the order in which they are encountered when stepping through the elements

  {
    // Create storage for the reordered nodes
    Vector<Node*> reordering;
 
    // Get the reordered nodes (without altering the mesh's node vector)
    get_node_reordering(mesh_pt,reordering,use_old_ordering);
 
    // Get the number of nodes in the mesh
    unsigned n_node=mesh_pt->nnode();
 
    // Loop over all of the nodes
    for (unsigned i=0; i<n_node; i++)
    {
      // Replace the Mesh's i-th node pointer with the reordered node pointer
      mesh_pt->node_pt(i)=reordering[i];
    }
  } // End of reorder_nodes

References get_node_reordering(), i, oomph::Mesh::nnode(), and oomph::Mesh::node_pt().

Referenced by NavierStokesProblem< ELEMENT >::create_spacetime_mesh().