#include <mesh.h>

Inheritance diagram for oomph::Mesh:

Public Types
typedef void(FiniteElement::*	SteadyExactSolutionFctPt) (const Vector< double > &x, Vector< double > &soln)

typedef void(FiniteElement::*	UnsteadyExactSolutionFctPt) (const double &time, const Vector< double > &x, Vector< double > &soln)

Public Member Functions
	Mesh ()
	Default constructor. More...

	Mesh (const Vector< Mesh * > &sub_mesh_pt)

void	merge_meshes (const Vector< Mesh * > &sub_mesh_pt)

virtual void	setup_boundary_element_info ()

virtual void	setup_boundary_element_info (std::ostream &outfile)

virtual void	reset_boundary_element_info (Vector< unsigned > &ntmp_boundary_elements, Vector< Vector< unsigned >> &ntmp_boundary_elements_in_region, Vector< FiniteElement * > &deleted_elements)
	Virtual function to perform the reset boundary elements info rutines. More...

template<class BULK_ELEMENT >
void	doc_boundary_coordinates (const unsigned &b, std::ofstream &the_file)

virtual void	scale_mesh (const double &factor)

	Mesh (const Mesh &dummy)=delete
	Broken copy constructor. More...

void	operator= (const Mesh &)=delete
	Broken assignment operator. More...

virtual	~Mesh ()
	Virtual Destructor to clean up all memory. More...

void	flush_element_and_node_storage ()

void	flush_element_storage ()

void	flush_node_storage ()

Node *&	node_pt (const unsigned long &n)
	Return pointer to global node n. More...

Node *	node_pt (const unsigned long &n) const
	Return pointer to global node n (const version) More...

GeneralisedElement *&	element_pt (const unsigned long &e)
	Return pointer to element e. More...

GeneralisedElement *	element_pt (const unsigned long &e) const
	Return pointer to element e (const version) More...

const Vector< GeneralisedElement * > &	element_pt () const
	Return reference to the Vector of elements. More...

Vector< GeneralisedElement * > &	element_pt ()
	Return reference to the Vector of elements. More...

FiniteElement *	finite_element_pt (const unsigned &e) const

Node *&	boundary_node_pt (const unsigned &b, const unsigned &n)
	Return pointer to node n on boundary b. More...

Node *	boundary_node_pt (const unsigned &b, const unsigned &n) const
	Return pointer to node n on boundary b. More...

void	set_nboundary (const unsigned &nbound)
	Set the number of boundaries in the mesh. More...

void	remove_boundary_nodes ()
	Clear all pointers to boundary nodes. More...

void	remove_boundary_nodes (const unsigned &b)

void	remove_boundary_node (const unsigned &b, Node *const &node_pt)
	Remove a node from the boundary b. More...

void	add_boundary_node (const unsigned &b, Node *const &node_pt)
	Add a (pointer to) a node to the b-th boundary. More...

void	copy_boundary_node_data_from_nodes ()

bool	boundary_coordinate_exists (const unsigned &i) const
	Indicate whether the i-th boundary has an intrinsic coordinate. More...

unsigned long	nelement () const
	Return number of elements in the mesh. More...

unsigned long	nnode () const
	Return number of nodes in the mesh. More...

unsigned	ndof_types () const
	Return number of dof types in mesh. More...

unsigned	elemental_dimension () const
	Return number of elemental dimension in mesh. More...

unsigned	nodal_dimension () const
	Return number of nodal dimension in mesh. More...

void	add_node_pt (Node *const &node_pt)
	Add a (pointer to a) node to the mesh. More...

void	add_element_pt (GeneralisedElement *const &element_pt)
	Add a (pointer to) an element to the mesh. More...

virtual void	node_update (const bool &update_all_solid_nodes=false)

virtual void	reorder_nodes (const bool &use_old_ordering=true)

virtual void	get_node_reordering (Vector< Node * > &reordering, const bool &use_old_ordering=true) const

template<class BULK_ELEMENT , template< class > class FACE_ELEMENT>
void	build_face_mesh (const unsigned &b, Mesh *const &face_mesh_pt)

unsigned	self_test ()
	Self-test: Check elements and nodes. Return 0 for OK. More...

void	max_and_min_element_size (double &max_size, double &min_size)

double	total_size ()

void	check_inverted_elements (bool &mesh_has_inverted_elements, std::ofstream &inverted_element_file)

void	check_inverted_elements (bool &mesh_has_inverted_elements)

unsigned	check_for_repeated_nodes (const double &epsilon=1.0e-12)

Vector< Node * >	prune_dead_nodes ()

unsigned	nboundary () const
	Return number of boundaries. More...

unsigned long	nboundary_node (const unsigned &ibound) const
	Return number of nodes on a particular boundary. More...

FiniteElement *	boundary_element_pt (const unsigned &b, const unsigned &e) const
	Return pointer to e-th finite element on boundary b. More...

Node *	get_some_non_boundary_node () const

unsigned	nboundary_element (const unsigned &b) const
	Return number of finite elements that are adjacent to boundary b. More...

int	face_index_at_boundary (const unsigned &b, const unsigned &e) const

virtual void	dump (std::ofstream &dump_file, const bool &use_old_ordering=true) const
	Dump the data in the mesh into a file for restart. More...

void	dump (const std::string &dump_file_name, const bool &use_old_ordering=true) const
	Dump the data in the mesh into a file for restart. More...

virtual void	read (std::ifstream &restart_file)
	Read solution from restart file. More...

void	output_paraview (std::ofstream &file_out, const unsigned &nplot) const

void	output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt) const

void	output_fct_paraview (std::ofstream &file_out, const unsigned &nplot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt) const

void	output (std::ostream &outfile)
	Output for all elements. More...

void	output (std::ostream &outfile, const unsigned &n_plot)
	Output at f(n_plot) points in each element. More...

void	output (FILE *file_pt)
	Output for all elements (C-style output) More...

void	output (FILE *file_pt, const unsigned &nplot)
	Output at f(n_plot) points in each element (C-style output) More...

void	output (const std::string &output_filename)
	Output for all elements. More...

void	output (const std::string &output_filename, const unsigned &n_plot)
	Output at f(n_plot) points in each element. More...

void	output_fct (std::ostream &outfile, const unsigned &n_plot, FiniteElement::SteadyExactSolutionFctPt)
	Output a given Vector function at f(n_plot) points in each element. More...

void	output_fct (std::ostream &outfile, const unsigned &n_plot, const double &time, FiniteElement::UnsteadyExactSolutionFctPt)

void	output_boundaries (std::ostream &outfile)
	Output the nodes on the boundaries (into separate tecplot zones) More...

void	output_boundaries (const std::string &output_filename)

void	assign_initial_values_impulsive ()
	Assign initial values for an impulsive start. More...

void	shift_time_values ()

void	calculate_predictions ()

void	set_nodal_and_elemental_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

virtual void	set_mesh_level_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

void	set_consistent_pinned_values_for_continuation (ContinuationStorageScheme *const &continuation_stepper_pt)
	Set consistent values for pinned data in continuation. More...

bool	does_pointer_correspond_to_mesh_data (double *const &parameter_pt)
	Does the double pointer correspond to any mesh data. More...

void	set_nodal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)
	Set the timestepper associated with the nodal data in the mesh. More...

void	set_elemental_internal_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

virtual void	compute_norm (double &norm)

virtual void	compute_norm (Vector< double > &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)

virtual void	compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)

virtual void	compute_error (FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, Vector< double > &error, Vector< double > &norm)

virtual void	compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, double &error, double &norm)
	Returns the norm of the error and that of the exact solution. More...

virtual void	compute_error (FiniteElement::UnsteadyExactSolutionFctPt exact_soln_pt, const double &time, Vector< double > &error, Vector< double > &norm)

bool	is_mesh_distributed () const
	Boolean to indicate if Mesh has been distributed. More...

OomphCommunicator *	communicator_pt () const

void	delete_all_external_storage ()
	Wipe the storage for all externally-based elements. More...

Static Public Attributes
static Steady< 0 >	Default_TimeStepper
	The Steady Timestepper. More...

static bool	Suppress_warning_about_empty_mesh_level_time_stepper_function
	Static boolean flag to control warning about mesh level timesteppers. More...

Protected Member Functions
unsigned long	assign_global_eqn_numbers (Vector< double * > &Dof_pt)
	Assign (global) equation numbers to the nodes. More...

void	describe_dofs (std::ostream &out, const std::string &current_string) const

void	describe_local_dofs (std::ostream &out, const std::string &current_string) const

void	assign_local_eqn_numbers (const bool &store_local_dof_pt)
	Assign local equation numbers in all elements. More...

void	convert_to_boundary_node (Node &node_pt, const Vector< FiniteElement > &finite_element_pt)

void	convert_to_boundary_node (Node *&node_pt)

Protected Attributes
Vector< Vector< Node * > >	Boundary_node_pt

bool	Lookup_for_elements_next_boundary_is_setup

Vector< Vector< FiniteElement * > >	Boundary_element_pt

Vector< Vector< int > >	Face_index_at_boundary

Vector< Node * >	Node_pt
	Vector of pointers to nodes. More...

Vector< GeneralisedElement * >	Element_pt
	Vector of pointers to generalised elements. More...

std::vector< bool >	Boundary_coordinate_exists

Friends
class	Problem
	Problem is a friend. More...

Detailed Description

A general mesh class.

The main components of a Mesh are:

pointers to its Nodes
pointers to its Elements
pointers to its boundary Nodes

Member Typedef Documentation

◆ SteadyExactSolutionFctPt

typedef void(FiniteElement::* oomph::Mesh::SteadyExactSolutionFctPt) (const Vector< double > &x, Vector< double > &soln)

Typedef for function pointer to function that computes steady exact solution

◆ UnsteadyExactSolutionFctPt

typedef void(FiniteElement::* oomph::Mesh::UnsteadyExactSolutionFctPt) (const double &time, const Vector< double > &x, Vector< double > &soln)

Typedef for function pointer to function that computes unsteady exact solution

Constructor & Destructor Documentation

◆ Mesh() [1/3]

oomph::Mesh::Mesh ( )

inline

Default constructor.

     {
       // Lookup scheme hasn't been setup yet
       Lookup_for_elements_next_boundary_is_setup = false;
 #ifdef OOMPH_HAS_MPI
       // Set defaults for distributed meshes
  
       // Mesh hasn't been distributed: Null out pointer to communicator
       Comm_pt = 0;
       // Don't keep all objects as halos
       Keep_all_elements_as_halos = false;
       // Don't output halo elements
       Output_halo_elements = false;
       // Don't suppress automatic resizing of halo nodes
       Resize_halo_nodes_not_required = false;
 #endif
     }

References Lookup_for_elements_next_boundary_is_setup.

◆ Mesh() [2/3]

oomph::Mesh::Mesh ( const Vector< Mesh * > & sub_mesh_pt )

inline

Constructor builds combined mesh from the meshes specified. Note: This simply merges the meshes' elements and nodes (ignoring duplicates; no boundary information etc. is created).

     {
 #ifdef OOMPH_HAS_MPI
       // Mesh hasn't been distributed: Null out pointer to communicator
       Comm_pt = 0;
 #endif
       // Now merge the meshes
       merge_meshes(sub_mesh_pt);
     }

References merge_meshes().

◆ Mesh() [3/3]

oomph::Mesh::Mesh ( const Mesh & dummy )

delete

Broken copy constructor.

◆ ~Mesh()

oomph::Mesh::~Mesh ( )

virtual

Virtual Destructor to clean up all memory.

   {
     // Free the nodes first
     // Loop over the nodes in reverse order
     unsigned long Node_pt_range = Node_pt.size();
     for (unsigned long i = Node_pt_range; i > 0; i--)
     {
       delete Node_pt[i - 1];
       Node_pt[i - 1] = 0;
     }
  
     // Free the elements
     // Loop over the elements in reverse order
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long i = Element_pt_range; i > 0; i--)
     {
       delete Element_pt[i - 1];
       Element_pt[i - 1] = 0;
     }
  
     // Wipe the storage for all externally-based elements and delete halos
     delete_all_external_storage();
   }

References delete_all_external_storage(), Element_pt, i, and Node_pt.

Member Function Documentation

◆ add_boundary_node()

void oomph::Mesh::add_boundary_node	(	const unsigned &	b,
		Node *const &	node_pt
	)

Add a (pointer to) a node to the b-th boundary.

Add the node node_pt to the b-th boundary of the mesh This function also sets the boundary information in the Node itself

   {
     // Tell the node that it's on boundary b.
     // At this point, if the node is not a BoundaryNode, the function
     // should throw an exception.
     node_pt->add_to_boundary(b);
  
     // Get the size of the Boundary_node_pt vector
     unsigned nbound_node = Boundary_node_pt[b].size();
     bool node_already_on_this_boundary = false;
     // Loop over the vector
     for (unsigned n = 0; n < nbound_node; n++)
     {
       // is the current node here already?
       if (node_pt == Boundary_node_pt[b][n])
       {
         node_already_on_this_boundary = true;
       }
     }
  
     // Add the base node pointer to the vector if it's not there already
     if (!node_already_on_this_boundary)
     {
       Boundary_node_pt[b].push_back(node_pt);
     }
   }

References oomph::Node::add_to_boundary(), b, Boundary_node_pt, n, and node_pt().

Referenced by STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::change_boundaries(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 3 >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 2 >::rebuild_from_sons(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), oomph::SimpleCubicScaffoldTetMesh::SimpleCubicScaffoldTetMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), oomph::TetgenScaffoldMesh::TetgenScaffoldMesh(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), and oomph::TubeMesh< ELEMENT >::TubeMesh().

◆ add_element_pt()

void oomph::Mesh::add_element_pt ( GeneralisedElement *const & element_pt )

inline

Add a (pointer to) an element to the mesh.

     {
       Element_pt.push_back(element_pt);
     }

References Element_pt, and element_pt().

◆ add_node_pt()

void oomph::Mesh::add_node_pt ( Node *const & node_pt )

inline

Add a (pointer to a) node to the mesh.

     {
       Node_pt.push_back(node_pt);
     }

References Node_pt, and node_pt().

Referenced by STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 1 >::build(), oomph::RefineableQElement< 2 >::build(), build_face_mesh(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 1, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 3 >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 1 >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 2 >::rebuild_from_sons(), and oomph::TetMeshBase::split_elements_in_corners().

◆ assign_global_eqn_numbers()

unsigned long oomph::Mesh::assign_global_eqn_numbers ( Vector< double * > & Dof_pt )

protected

Assign (global) equation numbers to the nodes.

Assign the global equation numbers in the Data stored at the nodes and also internal element Data. Also, build (via push_back) the Vector of pointers to the dofs (variables).

   {
     // Find out the current number of equations
     unsigned long equation_number = Dof_pt.size();
  
     // Loop over the nodes and call their assigment functions
     unsigned long nnod = Node_pt.size();
  
     for (unsigned long i = 0; i < nnod; i++)
     {
       Node_pt[i]->assign_eqn_numbers(equation_number, Dof_pt);
     }
  
     // Loop over the elements and number their internals
     unsigned long nel = Element_pt.size();
     for (unsigned long i = 0; i < nel; i++)
     {
       Element_pt[i]->assign_internal_eqn_numbers(equation_number, Dof_pt);
     }
  
     // Return the total number of equations
     return (equation_number);
   }

References Element_pt, i, and Node_pt.

Referenced by oomph::Problem::assign_eqn_numbers(), and oomph::PerturbedSpineMesh::assign_global_eqn_numbers().

◆ assign_initial_values_impulsive()

void oomph::Mesh::assign_initial_values_impulsive ( )

Assign initial values for an impulsive start.

Assign the initial values for an impulsive start, which is acheived by looping over all data in the mesh (internal element data and data stored at nodes) and setting the calling the assign_initial_values_impulsive() function for each data's timestepper

   {
     // Loop over the elements
     unsigned long Nelement = nelement();
     for (unsigned long e = 0; e < Nelement; e++)
     {
       // Find the number of internal dofs
       unsigned Ninternal = element_pt(e)->ninternal_data();
       // Loop over internal dofs and shift the time values
       // using the internals data's timestepper
       for (unsigned j = 0; j < Ninternal; j++)
       {
         element_pt(e)
           ->internal_data_pt(j)
           ->time_stepper_pt()
           ->assign_initial_values_impulsive(element_pt(e)->internal_data_pt(j));
       }
     }
  
     // Loop over the nodes
     unsigned long n_node = nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // Assign initial values using the Node's timestepper
       Node_pt[n]->time_stepper_pt()->assign_initial_values_impulsive(
         Node_pt[n]);
       // Assign initial positions using the Node's timestepper
       Node_pt[n]
         ->position_time_stepper_pt()
         ->assign_initial_positions_impulsive(Node_pt[n]);
     }
   }

References e(), element_pt(), j, n, nelement(), nnode(), and Node_pt.

Referenced by oomph::Problem::assign_initial_values_impulsive().

◆ assign_local_eqn_numbers()

void oomph::Mesh::assign_local_eqn_numbers ( const bool & store_local_dof_pt )

protected

Assign local equation numbers in all elements.

Assign the local equation numbers in all elements If the boolean argument is true then also store pointers to dofs

   {
     // Now loop over the elements and assign local equation numbers
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long i = 0; i < Element_pt_range; i++)
     {
       Element_pt[i]->assign_local_eqn_numbers(store_local_dof_pt);
     }
   }

References Element_pt, and i.

Referenced by oomph::Problem::assign_eqn_numbers().

◆ boundary_coordinate_exists()

bool oomph::Mesh::boundary_coordinate_exists ( const unsigned & i ) const

inline

Indicate whether the i-th boundary has an intrinsic coordinate.

     {
       if (Boundary_coordinate_exists.empty())
       {
         return false;
       }
       // ALH: This bounds-checking code needs to remain, because
       // Boundary_coordinate_exists is
       // an stl vector not our overloaded Vector class
 #ifdef RANGE_CHECKING
       if (i >= Boundary_coordinate_exists.size())
       {
         std::ostringstream error_message;
         error_message << "Range Error: " << i << " is not in the range (0,"
                       << Boundary_coordinate_exists.size() - 1 << std::endl;
  
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Boundary_coordinate_exists[i];
     }

References Boundary_coordinate_exists, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::RefineableQElement< 3 >::build(), oomph::RefineableQElement< 2 >::build(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::p_refine(), oomph::PRefineableQElement< 2, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::PRefineableQElement< 3, INITIAL_NNODE_1D >::rebuild_from_sons(), oomph::RefineableQSpectralElement< 3 >::rebuild_from_sons(), and oomph::RefineableQSpectralElement< 2 >::rebuild_from_sons().

◆ boundary_element_pt()

FiniteElement* oomph::Mesh::boundary_element_pt	(	const unsigned &	b,
		const unsigned &	e
	)		const

inline

Return pointer to e-th finite element on boundary b.

     {
 #ifdef PARANOID
       if (!Lookup_for_elements_next_boundary_is_setup)
       {
         throw OomphLibError("Lookup scheme for elements next to boundary "
                             "hasn't been set up yet!\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Boundary_element_pt[b][e];
     }

References b, Boundary_element_pt, e(), Lookup_for_elements_next_boundary_is_setup, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ boundary_node_pt() [1/2]

Node*& oomph::Mesh::boundary_node_pt	(	const unsigned &	b,
		const unsigned &	n
	)

inline

Return pointer to node n on boundary b.

     {
       return Boundary_node_pt[b][n];
     }

References b, Boundary_node_pt, and n.

Referenced by FSICollapsibleChannelProblem< ELEMENT >::actions_after_adapt(), InclinedPlaneProblem< ELEMENT, INTERFACE_ELEMENT >::actions_before_implicit_timestep(), oomph::StreamfunctionProblem::actions_before_solve(), oomph::RefineableTetgenMesh< ELEMENT >::adapt(), oomph::RefineableGmshTetMesh< ELEMENT >::adapt(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), oomph::SolidMesh::boundary_node_pt(), build_face_mesh(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), RectangularWomersleyImpedanceTube< ELEMENT >::build_mesh_and_apply_boundary_conditions(), CombCanSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), CapProblem< ELEMENT >::CapProblem(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::change_boundaries(), InclinedPlaneProblem< ELEMENT, INTERFACE_ELEMENT >::complete_build(), oomph::TwoDimensionalPMLHelper::create_bottom_left_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_bottom_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_bottom_right_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_left_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_right_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_top_left_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_top_pml_mesh(), oomph::TwoDimensionalPMLHelper::create_top_right_pml_mesh(), MeltSpinningProblem< ELEMENT >::deform_free_surface(), AxisymFreeSurfaceNozzleAdvDiffRobinProblem< ELEMENT >::deform_free_surface(), InterfaceProblem< ELEMENT, TIMESTEPPER >::deform_free_surface(), FluxPoissonProblem< ELEMENT >::FluxPoissonProblem(), FSIRingProblem::FSIRingProblem(), merge_meshes(), OneDPoissonProblem< ELEMENT >::OneDPoissonProblem(), OrrSommerfeldProblem< ELEMENT >::OrrSommerfeldProblem(), oomph::PeriodicOrbitTemporalMesh< ELEMENT >::PeriodicOrbitTemporalMesh(), oomph::StreamfunctionProblem::pin_boundaries(), oomph::PMLCornerQuadMesh< ELEMENT >::PMLCornerQuadMesh(), oomph::PMLQuadMesh< ELEMENT >::PMLQuadMesh(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), QuarterCircleDrivenCavityProblem< ELEMENT >::QuarterCircleDrivenCavityProblem(), QuarterCircleDrivenCavityProblem2< ELEMENT >::QuarterCircleDrivenCavityProblem2(), oomph::QuarterPipeMesh< ELEMENT >::QuarterPipeMesh(), oomph::RefineableQuadMeshWithMovingCylinder< ELEMENT >::RefineableQuadMeshWithMovingCylinder(), remove_boundary_nodes(), run_navier_stokes_outflow(), run_prescribed_flux(), run_prescribed_pressure_gradient(), oomph::TetMeshBase::setup_boundary_coordinates(), oomph::RefineableTetgenMesh< ELEMENT >::snap_nodes_onto_boundary(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::UnstructuredTwoDMeshGeometryBase::snap_nodes_onto_geometric_objects(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), and TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem().

◆ boundary_node_pt() [2/2]

Node* oomph::Mesh::boundary_node_pt	(	const unsigned &	b,
		const unsigned &	n
	)		const

inline

Return pointer to node n on boundary b.

     {
       return Boundary_node_pt[b][n];
     }

References b, Boundary_node_pt, and n.

◆ build_face_mesh()

template<class BULK_ELEMENT , template< class > class FACE_ELEMENT>

void oomph::Mesh::build_face_mesh	(	const unsigned &	b,
		Mesh *const &	face_mesh_pt
	)

inline

Constuct a Mesh of FACE_ELEMENTs along the b-th boundary of the mesh (which contains elements of type BULK_ELEMENT)

     {
       // Find the number of nodes on the boundary
       unsigned nbound_node = nboundary_node(b);
       // Loop over the boundary nodes and add them to face mesh node pointer
       for (unsigned n = 0; n < nbound_node; n++)
       {
         face_mesh_pt->add_node_pt(boundary_node_pt(b, n));
       }
  
       // Find the number of elements next to the boundary
       unsigned nbound_element = nboundary_element(b);
       // Loop over the elements adjacent to boundary b
       for (unsigned e = 0; e < nbound_element; e++)
       {
         // Create the FaceElement
         FACE_ELEMENT<BULK_ELEMENT>* face_element_pt =
           new FACE_ELEMENT<BULK_ELEMENT>(boundary_element_pt(b, e),
                                          face_index_at_boundary(b, e));
  
         // Add the face element to the face mesh
         face_mesh_pt->add_element_pt(face_element_pt);
       }
  
 #ifdef OOMPH_HAS_MPI
       // If the bulk mesh has been distributed then the face mesh is too
       if (this->is_mesh_distributed())
       {
         face_mesh_pt->set_communicator_pt(this->communicator_pt());
       }
 #endif
     }

References add_element_pt(), add_node_pt(), b, boundary_element_pt(), boundary_node_pt(), communicator_pt(), e(), face_index_at_boundary(), is_mesh_distributed(), n, nboundary_element(), and nboundary_node().

◆ calculate_predictions()

void oomph::Mesh::calculate_predictions ( )

Calculate predictions for all Data and positions associated with the mesh, usually used in adaptive time-stepping.

Calculate predictions for all Data and positions associated with the mesh. This is usually only used for adaptive time-stepping when the comparison between a predicted value and the actual value is usually used to determine the change in step size. Again the loop is over all data in the mesh and individual timestepper functions for each data value are called.

   {
     // Loop over the elements which shift their internal data
     // via their own timesteppers
     const unsigned long Nelement = nelement();
     for (unsigned long e = 0; e < Nelement; e++)
     {
       // Find the number of internal dofs
       const unsigned Ninternal = element_pt(e)->ninternal_data();
       // Loop over internal dofs and calculate predicted positions
       // using the internals data's timestepper
       for (unsigned j = 0; j < Ninternal; j++)
       {
         element_pt(e)
           ->internal_data_pt(j)
           ->time_stepper_pt()
           ->calculate_predicted_values(element_pt(e)->internal_data_pt(j));
       }
     }
  
     // Loop over the nodes
     const unsigned long n_node = nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // Calculate the predicted values at the nodes
       Node_pt[n]->time_stepper_pt()->calculate_predicted_values(Node_pt[n]);
       // Calculate the predicted positions
       Node_pt[n]->position_time_stepper_pt()->calculate_predicted_positions(
         Node_pt[n]);
     }
   }

References e(), element_pt(), j, n, nelement(), nnode(), and Node_pt.

Referenced by oomph::Problem::calculate_predictions().

◆ check_for_repeated_nodes()

unsigned oomph::Mesh::check_for_repeated_nodes ( const double & epsilon = 1.0e-12 )

inline

Check for repeated nodes within a given spatial tolerance. Return (0/1) for (pass/fail).

     {
       oomph_info << "\n\nStarting check for repeated nodes...";
       bool failed = false;
       unsigned nnod = nnode();
       for (unsigned j = 0; j < nnod; j++)
       {
         Node* nod1_pt = this->node_pt(j);
         unsigned dim = nod1_pt->ndim();
         for (unsigned k = j + 1; k < nnod; k++)
         {
           Node* nod2_pt = this->node_pt(k);
           double dist = 0.0;
           for (unsigned i = 0; i < dim; i++)
           {
             dist += pow((nod1_pt->x(i) - nod2_pt->x(i)), 2);
           }
           dist = sqrt(dist);
           if (dist < epsilon)
           {
             oomph_info << "\n\nRepeated node!" << std::endl;
             oomph_info << "Distance between nodes " << j << " and " << k
                        << std::endl;
             oomph_info << "is " << dist << " which is less than the"
                        << std::endl;
             oomph_info << "permitted distance of " << epsilon << std::endl
                        << std::endl;
             oomph_info << "The offending nodes are located at: " << std::endl;
             for (unsigned i = 0; i < dim; i++)
             {
               oomph_info << nod1_pt->x(i) << " ";
             }
             if (nod1_pt->is_a_copy() || nod2_pt->is_a_copy())
             {
               oomph_info << "\n\n[NOTE: message issued as diagonistic rather "
                             "than an error\n"
                          << " because at least one of the nodes is a copy; you "
                             "may still\n"
                          << " want to check this out. BACKGROUND: Copied nodes "
                             "share the same Data but\n"
                          << " will, in general, have different spatial "
                             "positions (e.g. when used\n"
                          << " as periodic nodes); however there are cases when "
                             "they are located\n"
                          << " at the same spatial position (e.g. in "
                             "oomph-lib's annular mesh which\n"
                          << " is a rolled-around version of the rectangular "
                             "quadmesh). In such cases,\n"
                          << " the nodes could have been deleted and completely "
                             "replaced by \n"
                          << " pointers to existing nodes, but may have been "
                             "left there for convenience\n"
                          << " or out of laziness...]\n";
             }
             else
             {
               failed = true;
             }
             oomph_info << std::endl << std::endl;
           }
         }
       }
       if (failed) return 1;
  
       // If we made it to here, we must have passed the test.
       oomph_info << "...done: Test passed!" << std::endl << std::endl;
       return 0;
     }

References oomph::SarahBL::epsilon, i, oomph::Data::is_a_copy(), j, k, oomph::Node::ndim(), nnode(), node_pt(), oomph::oomph_info, Eigen::bfloat16_impl::pow(), sqrt(), and oomph::Node::x().

Referenced by self_test().

◆ check_inverted_elements() [1/2]

void oomph::Mesh::check_inverted_elements ( bool & mesh_has_inverted_elements )

inline

Check for inverted elements and report outcome in boolean variable. This visits all elements at their integration points and checks if the Jacobian of the mapping between local and global coordinates is positive – using the same test that would be carried out (but only in PARANOID mode) during the assembly of the elements' Jacobian matrices.

     {
       std::ofstream inverted_element_file;
       check_inverted_elements(mesh_has_inverted_elements,
                               inverted_element_file);
     }

References check_inverted_elements().

◆ check_inverted_elements() [2/2]

void oomph::Mesh::check_inverted_elements	(	bool &	mesh_has_inverted_elements,
		std::ofstream &	inverted_element_file
	)

Check for inverted elements and report outcome in boolean variable. This visits all elements at their integration points and checks if the Jacobian of the mapping between local and global coordinates is positive – using the same test that would be carried out (but only in PARANOID mode) during the assembly of the elements' Jacobian matrices. Inverted elements are output in inverted_element_file (if the stream is open).

   {
     // Initialise flag
     mesh_has_inverted_elements = false;
  
     // Suppress output while checking for inverted elements
     bool backup =
       FiniteElement::Suppress_output_while_checking_for_inverted_elements;
     FiniteElement::Suppress_output_while_checking_for_inverted_elements = true;
  
     // Loop over all elements
     unsigned nelem = nelement();
     for (unsigned e = 0; e < nelem; e++)
     {
       FiniteElement* el_pt = finite_element_pt(e);
  
       // Only check for finite elements
       if (el_pt != 0)
       {
         // Find out number of nodes and local coordinates in the element
         unsigned n_node = el_pt->nnode();
         unsigned n_dim = el_pt->dim();
         unsigned ndim_node = el_pt->nodal_dimension();
  
         // Can't check Jacobian for elements in which nodal and elementa
         // dimensions don't match
         if (n_dim == ndim_node)
         {
           // Set up memory for the shape and test function and local coord
           Shape psi(n_node);
           DShape dpsidx(n_node, n_dim);
           Vector<double> s(n_dim);
  
           // Initialise element-level test
           bool is_inverted = false;
  
           unsigned n_intpt = el_pt->integral_pt()->nweight();
           for (unsigned ipt = 0; ipt < n_intpt; ipt++)
           {
             // Local coordinates
             for (unsigned i = 0; i < n_dim; i++)
             {
               s[i] = el_pt->integral_pt()->knot(ipt, i);
             }
  
             double J = 0;
             // Dummy assignment to keep gcc from complaining about
             // "set but unused".
             J += 0.0;
             try
             {
               // Call the derivatives of the shape functions and Jacobian
               J = el_pt->dshape_eulerian(s, psi, dpsidx);
  
               // If code is compiled without PARANOID setting, the
               // above call will simply return the negative Jacobian
               // without failing, so we need to check manually
 #ifndef PARANOID
               try
               {
                 el_pt->check_jacobian(J);
               }
               catch (OomphLibQuietException& error)
               {
                 is_inverted = true;
               }
 #endif
             }
             catch (OomphLibQuietException& error)
             {
               is_inverted = true;
             }
           }
           if (is_inverted)
           {
             mesh_has_inverted_elements = true;
             if (inverted_element_file.is_open())
             {
               el_pt->output(inverted_element_file);
             }
           }
         }
       }
     }
     // Reset
     FiniteElement::Suppress_output_while_checking_for_inverted_elements =
       backup;
   }

References oomph::FiniteElement::check_jacobian(), oomph::FiniteElement::dim(), oomph::FiniteElement::dshape_eulerian(), e(), calibrate::error, finite_element_pt(), i, oomph::FiniteElement::integral_pt(), J, oomph::Integral::knot(), nelement(), oomph::FiniteElement::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::Integral::nweight(), oomph::FiniteElement::output(), s, and oomph::FiniteElement::Suppress_output_while_checking_for_inverted_elements.

Referenced by check_inverted_elements(), demo_smoothing_with_linear_elasticity(), demo_smoothing_with_nonlinear_elasticity(), demo_smoothing_with_poisson(), and oomph::NonLinearElasticitySmoothMesh< ELEMENT >::doc_solution().

◆ communicator_pt()

OomphCommunicator* oomph::Mesh::communicator_pt ( ) const

inline

Read-only access fct to communicator (Null if mesh is not distributed, i.e. if we don't have mpi).

     {
 #ifdef OOMPH_HAS_MPI
       return Comm_pt;
 #else
       return 0;
 #endif
     }

Referenced by build_face_mesh(), oomph::MeshAsGeomObject::build_it(), oomph::Z2ErrorEstimator::doc_flux(), oomph::Z2ErrorEstimator::get_element_errors(), and is_mesh_distributed().

◆ compute_error() [1/8]

virtual void oomph::Mesh::compute_error	(	FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt,
		double &	error,
		double &	norm
	)

inlinevirtual

Plot error when compared against a given time-dependent exact solution. Also returns the norm of the error and that of the exact solution

     {
       // Initialise norm and error
       norm = 0.0;
       error = 0.0;
  
       // Per-element norm and error
       double el_error, el_norm;
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
  
         // Reset elemental errors and norms
         el_norm = 0.0;
         el_error = 0.0;
  
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(exact_soln_pt, el_error, el_norm);
         }
  
         // Add each elemental error to the global error
         norm += el_norm;
         error += el_error;
       }
     } // End of compute_error

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [2/8]

virtual void oomph::Mesh::compute_error	(	FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt,
		Vector< double > &	error,
		Vector< double > &	norm
	)

inlinevirtual

Plot error when compared against a given time-dependent exact solution. Also returns the norm of the error and that of the exact solution

     {
       // Initialise norm vector entries
       norm.initialise(0.0);
  
       // Initialise error vector entries
       error.initialise(0.0);
  
       // Norm vector size
       unsigned n_norm = norm.size();
  
       // Error vector size
       unsigned n_error = error.size();
  
       // Per-element norm and error
       Vector<double> el_norm(n_norm, 0.0);
  
       // Per-element norm and error
       Vector<double> el_error(n_error, 0.0);
  
       // How many elements are there?
       unsigned long element_pt_range = Element_pt.size();
  
       // Loop over the elements
       for (unsigned long e = 0; e < element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
  
         // Re-initialise norm vector entries
         el_norm.initialise(0.0);
  
         // Re-initialise error vector entries
         el_error.initialise(0.0);
  
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(exact_soln_pt, el_error, el_norm);
         }
  
         // Add each elemental norm contribution to the global norm
         for (unsigned i = 0; i < n_norm; i++)
         {
           norm[i] += el_norm[i];
         }
  
         // Add each elemental error contribution to the global error
         for (unsigned i = 0; i < n_error; i++)
         {
           error[i] += el_error[i];
         }
       } // for (unsigned long e=0;e<element_pt_range;e++)
     } // End of compute_error

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, i, oomph::Vector< _Tp >::initialise(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [3/8]

virtual void oomph::Mesh::compute_error	(	FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt,
		const double &	time,
		double &	error,
		double &	norm
	)

inlinevirtual

Returns the norm of the error and that of the exact solution.

     {
       // Initialse the norm and error
       norm = 0.0;
       error = 0.0;
       // Per-element norm and error
       double el_error, el_norm;
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
  
         // Reset elemental errors and norms
         el_norm = 0.0;
         el_error = 0.0;
 #ifdef OOMPH_HAS_MPI
         // Compute error for each non-halo element
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(exact_soln_pt, time, el_error, el_norm);
         }
         // Add each element error to the global errors
         norm += el_norm;
         error += el_error;
       }
     }

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [4/8]

virtual void oomph::Mesh::compute_error	(	FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt,
		const double &	time,
		Vector< double > &	error,
		Vector< double > &	norm
	)

inlinevirtual

Returns the norm of the error and that of the exact solution. Version with vectors of norms and errors so that different variables' norms and errors can be returned individually

     {
       // Initialise norm and error
       unsigned n_error = error.size();
       unsigned n_norm = norm.size();
       for (unsigned i = 0; i < n_error; i++)
       {
         error[i] = 0.0;
       }
       for (unsigned i = 0; i < n_norm; i++)
       {
         norm[i] = 0.0;
       }
       // Per-element norm and error
       Vector<double> el_error(n_error), el_norm(n_norm);
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
         // Reset elemental errors and norms
         for (unsigned i = 0; i < n_error; i++)
         {
           el_error[i] = 0.0;
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           el_norm[i] = 0.0;
         }
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(exact_soln_pt, time, el_error, el_norm);
         }
         // Add each elemental error to the global error
         for (unsigned i = 0; i < n_error; i++)
         {
           error[i] += el_error[i];
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           norm[i] += el_norm[i];
         }
       } // for (unsigned long e=0;e<Element_pt_range;e++)
     } // End of compute_error

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [5/8]

virtual void oomph::Mesh::compute_error	(	std::ostream &	outfile,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt,
		double &	error,
		double &	norm
	)

inlinevirtual

Plot error when compared against a given time-depdendent exact solution. Also returns the norm of the error and that of the exact solution

     {
       // Initialise norm and error
       norm = 0.0;
       error = 0.0;
       // Per-element norm and error
       double el_error, el_norm;
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
         // Reset elemental errors and norms
         el_norm = 0.0;
         el_error = 0.0;
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(outfile, exact_soln_pt, el_error, el_norm);
         }
         // Add each elemental error to the global error
         norm += el_norm;
         error += el_error;
       }
     }

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [6/8]

virtual void oomph::Mesh::compute_error	(	std::ostream &	outfile,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt,
		Vector< double > &	error,
		Vector< double > &	norm
	)

inlinevirtual

Plot error when compared against a given time-depdendent exact solution. Also returns the norm of the error and that of the exact solution. Version with vectors of norms and errors so that different variables' norms and errors can be returned individually

     {
       // Initialise norm and error
       unsigned n_error = error.size();
       unsigned n_norm = norm.size();
       for (unsigned i = 0; i < n_error; i++)
       {
         error[i] = 0.0;
       }
       for (unsigned i = 0; i < n_norm; i++)
       {
         norm[i] = 0.0;
       }
       // Per-element norm and error
       Vector<double> el_error(n_error), el_norm(n_norm);
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
         // Reset elemental errors and norms
         for (unsigned i = 0; i < n_error; i++)
         {
           el_error[i] = 0.0;
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           el_norm[i] = 0.0;
         }
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(outfile, exact_soln_pt, el_error, el_norm);
         }
         // Add each elemental error to the global error
         for (unsigned i = 0; i < n_error; i++)
         {
           error[i] += el_error[i];
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           norm[i] += el_norm[i];
         }
       }
     }

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [7/8]

virtual void oomph::Mesh::compute_error	(	std::ostream &	outfile,
		FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt,
		const double &	time,
		double &	error,
		double &	norm
	)

inlinevirtual

Plot error when compared against a given exact solution. Also returns the norm of the error and that of the exact solution

     {
       // Initialse the norm and error
       norm = 0.0;
       error = 0.0;
       // Per-element norm and error
       double el_error, el_norm;
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
  
         // Reset elemental errors and norms
         el_norm = 0.0;
         el_error = 0.0;
 #ifdef OOMPH_HAS_MPI
         // Compute error for each non-halo element
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(outfile, exact_soln_pt, time, el_error, el_norm);
         }
         // Add each element error to the global errors
         norm += el_norm;
         error += el_error;
       }
     }

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_error() [8/8]

virtual void oomph::Mesh::compute_error	(	std::ostream &	outfile,
		FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt,
		const double &	time,
		Vector< double > &	error,
		Vector< double > &	norm
	)

inlinevirtual

Plot error when compared against a given time-depdendent exact solution. Also returns the norm of the error and that of the exact solution. Version with vectors of norms and errors so that different variables' norms and errors can be returned individually

     {
       // Initialise norm and error
       unsigned n_error = error.size();
       unsigned n_norm = norm.size();
       for (unsigned i = 0; i < n_error; i++)
       {
         error[i] = 0.0;
       }
       for (unsigned i = 0; i < n_norm; i++)
       {
         norm[i] = 0.0;
       }
       // Per-element norm and error
       Vector<double> el_error(n_error), el_norm(n_norm);
  
       // Loop over the elements
       unsigned long Element_pt_range = Element_pt.size();
       for (unsigned long e = 0; e < Element_pt_range; e++)
       {
         // Try to cast to FiniteElement
         FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
         if (el_pt == 0)
         {
           throw OomphLibError(
             "Can't execute compute_error(...) for non FiniteElements",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
         // Reset elemental errors and norms
         for (unsigned i = 0; i < n_error; i++)
         {
           el_error[i] = 0.0;
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           el_norm[i] = 0.0;
         }
         // Calculate the elemental errors for each non-halo element
 #ifdef OOMPH_HAS_MPI
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_error(outfile, exact_soln_pt, time, el_error, el_norm);
         }
         // Add each elemental error to the global error
         for (unsigned i = 0; i < n_error; i++)
         {
           error[i] += el_error[i];
         }
         for (unsigned i = 0; i < n_norm; i++)
         {
           norm[i] += el_norm[i];
         }
       }
     }

References oomph::FiniteElement::compute_error(), e(), Element_pt, calibrate::error, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ compute_norm() [1/2]

virtual void oomph::Mesh::compute_norm ( double & norm )

inlinevirtual

Compute norm of solution by summing contributions of compute_norm(...) for all constituent elements in the mesh. What that norm means depends on what's defined in the element's function; may need to take the square root afterwards if the elements compute the square of the L2 norm, say.

Reimplemented in ElasticQuadFromTriangleMesh< ELEMENT >.

     {
       // Initialse the norm
       norm = 0.0;
  
       // Per-element norm
       double el_norm = 0;
  
       // Loop over the elements
       unsigned long n_element = Element_pt.size();
       for (unsigned long e = 0; e < n_element; e++)
       {
         GeneralisedElement* el_pt = Element_pt[e];
  
 #ifdef OOMPH_HAS_MPI
         // Compute error for each non-halo element
         if (!(el_pt->is_halo()))
 #endif
         {
           el_pt->compute_norm(el_norm);
         }
         norm += el_norm;
       }
     }

References oomph::GeneralisedElement::compute_norm(), e(), and Element_pt.

◆ compute_norm() [2/2]

virtual void oomph::Mesh::compute_norm ( Vector< double > & norm )

inlinevirtual

Compute norm of solution by summing contributions of compute_norm(...) for all constituent elements in the mesh. What that norm means depends on what's defined in the element's function; may need to take the square root afterwards if the elements compute the square of the L2 norm, say.

     {
       // How many unknowns are there?
       unsigned n_entry = norm.size();
  
       // Initialse the norm
       norm.initialise(0.0);
  
       // Per-element norm
       Vector<double> el_norm(n_entry, 0.0);
  
       // How many elements are there?
       unsigned long n_element = Element_pt.size();
  
       // Loop over the elements
       for (unsigned long e = 0; e < n_element; e++)
       {
         // Get a pointer to the e-th generalised element
         GeneralisedElement* el_pt = Element_pt[e];
  
 #ifdef OOMPH_HAS_MPI
         // Compute error for each non-halo element
         if (!(el_pt->is_halo()))
 #endif
         {
           // Compute the elemental norm
           el_pt->compute_norm(el_norm);
         }
  
         // Loop over the norm vector entries
         for (unsigned i = 0; i < n_entry; i++)
         {
           // Update the norm of the i-th component
           norm[i] += el_norm[i];
         }
       } // for (unsigned long e=0;e<n_element;e++)
     } // End of compute_norm

References oomph::GeneralisedElement::compute_norm(), e(), Element_pt, i, and oomph::Vector< _Tp >::initialise().

◆ convert_to_boundary_node() [1/2]

void oomph::Mesh::convert_to_boundary_node ( Node *& node_pt )

protected

A function that upgrades an ordinary node to a boundary node. All pointers to the node from the mesh's elements are found. and replaced by pointers to the new boundary node. If the node is present in the mesh's list of nodes, that pointer is also replaced. Finally, the pointer argument node_pt addresses the new node on return from the function. We shouldn't ever really use this, but it does make life that bit easier for the lazy mesh writer.

   {
     // Cache a list of FiniteElement pointers for use in this function.
     Vector<FiniteElement*> fe_pt(nelement(), 0);
     for (unsigned e = 0, ne = nelement(); e < ne; e++)
     {
       // Some elements may not have been build yet, just store a null pointer
       // for these cases.
       if (Element_pt[e] == 0) fe_pt[e] = 0;
       else
         fe_pt[e] = finite_element_pt(e);
     }
  
     // Now call the real function
     convert_to_boundary_node(node_pt, fe_pt);
   }

References convert_to_boundary_node(), e(), Element_pt, finite_element_pt(), nelement(), and node_pt().

◆ convert_to_boundary_node() [2/2]

void oomph::Mesh::convert_to_boundary_node	(	Node *&	node_pt,
		const Vector< FiniteElement * > &	finite_element_pt
	)

protected

A function that upgrades an ordinary node to a boundary node We shouldn't ever really use this, but it does make life that bit easier for the lazy mesh writer. The pointer to the node is replaced by a pointer to the new boundary node in all element look-up schemes and in the mesh's Node_pt vector. The new node is also addressed by node_pt on return from the function.

As convert_to_boundary_node but with a vector of pre-"dynamic cast"ed pointers passed in. If this function is being called often then creating this vector and passing it in explicitly each time can give a large speed up.

   {
     // If the node is already a boundary node, then return straight away,
     // we don't need to do anything
     if (dynamic_cast<BoundaryNodeBase*>(node_pt) != 0)
     {
       return;
     }
  
     // Loop over all the elements in the mesh and find all those in which
     // the present node is referenced and the corresponding local node number
     // in those elements.
  
     // Storage for elements and local node number
     std::list<std::pair<unsigned long, int>>
       list_of_elements_and_local_node_numbers;
  
     // Loop over all elements
     unsigned long n_element = this->nelement();
     for (unsigned long e = 0; e < n_element; e++)
     {
       // Buffer the case when we have not yet filled up the element array
       // Unfortunately, we should not assume that the array has been filled
       // in a linear order, so we can't break out early.
       if (Element_pt[e] != 0)
       {
         // Find the local node number of the passed node
         int node_number = finite_element_pt[e]->get_node_number(node_pt);
         // If the node is present in the element, add it to our list and
         // NULL out the local element entries
         if (node_number != -1)
         {
           list_of_elements_and_local_node_numbers.insert(
             list_of_elements_and_local_node_numbers.end(),
             std::make_pair(e, node_number));
           // Null it out
           finite_element_pt[e]->node_pt(node_number) = 0;
         }
       }
     } // End of loop over elements
  
     // If there are no entries in the list we are in real trouble
     if (list_of_elements_and_local_node_numbers.empty())
     {
       std::ostringstream error_stream;
       error_stream << "Node " << node_pt
                    << " is not contained in any elements in the Mesh."
                    << std::endl
                    << "How was it created then?" << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
  
     // Create temporary storage for a pointer to the old node.
     // This is required because if we have passed a reference to the
     // first element that we find, constructing the new node
     // will over-write our pointer and we'll get segmentation faults.
     Node* old_node_pt = node_pt;
  
     // We now create the new node by using the first element in the list
     std::list<std::pair<unsigned long, int>>::iterator list_it =
       list_of_elements_and_local_node_numbers.begin();
  
     // Create a new boundary node, using the timestepper from the
     // original node
     Node* new_node_pt =
       finite_element_pt[list_it->first]->construct_boundary_node(
         list_it->second, node_pt->time_stepper_pt());
  
     // Now copy all the information accross from the old node
  
     // Can we cast the node to a solid node
     SolidNode* solid_node_pt = dynamic_cast<SolidNode*>(new_node_pt);
     // If it's a solid node, do the casting
     if (solid_node_pt != 0)
     {
       solid_node_pt->copy(dynamic_cast<SolidNode*>(old_node_pt));
     }
     else
     {
       new_node_pt->copy(old_node_pt);
     }
  
     // Loop over all other elements in the list and set their pointers
     // to the new node
     for (++list_it; // Increment the iterator
          list_it != list_of_elements_and_local_node_numbers.end();
          ++list_it)
     {
       finite_element_pt[list_it->first]->node_pt(list_it->second) = new_node_pt;
     }
  
     // Finally, find the position of the node in the global mesh
     Vector<Node*>::iterator it =
       std::find(Node_pt.begin(), Node_pt.end(), old_node_pt);
  
     // If it is in the mesh, update the pointer
     if (it != Node_pt.end())
     {
       *it = new_node_pt;
     }
  
     // Can now delete the old node
     delete old_node_pt;
  
     // Replace the passed pointer by a pointer to the new node
     // Note that in most cases, this will be wasted work because the node
     // pointer will either the pointer in the mesh's or an element's
     // node_pt vector. Still assignment is quicker than an if to check this.
     node_pt = new_node_pt;
   }

References oomph::FiniteElement::construct_boundary_node(), oomph::Node::copy(), oomph::SolidNode::copy(), e(), Element_pt, finite_element_pt(), oomph::FiniteElement::get_node_number(), nelement(), oomph::FiniteElement::node_pt(), Node_pt, node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Data::time_stepper_pt().

Referenced by oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), convert_to_boundary_node(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), and oomph::TubeMesh< ELEMENT >::TubeMesh().

◆ copy_boundary_node_data_from_nodes()

void oomph::Mesh::copy_boundary_node_data_from_nodes ( )

inline

Replace existing boundary node lookup schemes with new schemes created using the boundary data stored in the nodes.

     {
       // Clear existing boundary data
       Boundary_node_pt.clear();
  
       // Loop over nodes adding them to the appropriate boundary lookup schemes
       // in the mesh.
       const unsigned n_node = nnode();
       for (unsigned nd = 0; nd < n_node; nd++)
       {
         Node* nd_pt = node_pt(nd);
  
         if (nd_pt->is_on_boundary())
         {
           // Get set of boundaries that the node is on
           std::set<unsigned>* boundaries_pt;
           nd_pt->get_boundaries_pt(boundaries_pt);
  
           // If needed then add more boundaries to this mesh
           unsigned max_boundary_n =
             1 + *std::max_element(boundaries_pt->begin(), boundaries_pt->end());
           if (max_boundary_n > nboundary())
           {
             set_nboundary(max_boundary_n);
           }
  
           // Add node pointer to the appropriate Boundary_node_pt vectors
           std::set<unsigned>::const_iterator it;
           for (it = boundaries_pt->begin(); it != boundaries_pt->end(); it++)
           {
             Boundary_node_pt[*it].push_back(nd_pt);
           }
         }
       }
     }

References Boundary_node_pt, oomph::Node::get_boundaries_pt(), oomph::Node::is_on_boundary(), nboundary(), nnode(), node_pt(), and set_nboundary().

◆ delete_all_external_storage()

void oomph::Mesh::delete_all_external_storage ( )

Wipe the storage for all externally-based elements.

Wipe the storage for all externally-based elements and delete halos.

   {
 #ifdef OOMPH_HAS_MPI
  
     // Only do for distributed meshes
     if (is_mesh_distributed())
     {
       // Some of the external halo/haloed nodes are masters of nodes
       // in this mesh. We must set to be non-hanging any nodes whose
       // masters we are about to delete, to remove any dependencies.
  
       // Loop over all the mesh nodes and check their masters
       for (unsigned i = 0; i < nnode(); i++)
       {
         // Get pointer to the node
         Node* nod_pt = node_pt(i);
  
         // Check if the node exists
         if (nod_pt != 0)
         {
           // Check if the node is hanging
           if (nod_pt->is_hanging())
           {
             // Get pointer to the hang info
             HangInfo* hang_pt = nod_pt->hanging_pt();
  
             // Check if any master is in the external halo storage
             // External haloed nodes don't get deleted, so we don't need to
             //(and shouldn't) un-hang their dependents
             bool found_a_master_in_external_halo_storage = false;
             for (unsigned m = 0; m < hang_pt->nmaster(); m++)
             {
               // Iterator for vector of nodes
               Vector<Node*>::iterator it;
  
               // Loop over external halo storage with all processors
               bool found_this_master_in_external_halo_storage = false;
               for (int d = 0; d < Comm_pt->nproc(); d++)
               {
                 // Find master in map of external halo nodes
                 it = std::find(External_halo_node_pt[d].begin(),
                                External_halo_node_pt[d].end(),
                                hang_pt->master_node_pt(m));
  
                 // Check if it was found
                 if (it != External_halo_node_pt[d].end())
                 {
                   // Mark as found
                   found_this_master_in_external_halo_storage = true;
                   // Don't need to search remaining processors
                   break;
                 }
               }
  
               // Check if any have been found
               if (found_this_master_in_external_halo_storage)
               {
                 // Mark as found
                 found_a_master_in_external_halo_storage = true;
                 // Don't need to search remaining masters
                 break;
               }
             }
  
             // If it was found...
             if (found_a_master_in_external_halo_storage)
             {
               // Master is in external halo storage and is about to be deleted,
               // so we'd better make this node non-hanging. In case the node
               // does not become hanging again, we must get all the required
               // information from its masters to make it a 'proper' node again.
  
               // Reconstruct the nodal values/position from the node's
               // hanging node representation
               unsigned nt = nod_pt->ntstorage();
               unsigned n_value = nod_pt->nvalue();
               Vector<double> values(n_value);
               unsigned n_dim = nod_pt->ndim();
               Vector<double> position(n_dim);
               // Loop over all history values
               for (unsigned t = 0; t < nt; t++)
               {
                 nod_pt->value(t, values);
                 for (unsigned i = 0; i < n_value; i++)
                 {
                   nod_pt->set_value(t, i, values[i]);
                 }
                 nod_pt->position(t, position);
                 for (unsigned i = 0; i < n_dim; i++)
                 {
                   nod_pt->x(t, i) = position[i];
                 }
               }
  
               // If it's an algebraic node: Update its previous nodal positions
               // too
               AlgebraicNode* alg_node_pt = dynamic_cast<AlgebraicNode*>(nod_pt);
               if (alg_node_pt != 0)
               {
                 bool update_all_time_levels = true;
                 alg_node_pt->node_update(update_all_time_levels);
               }
  
  
               // If it's a Solid node, update Lagrangian coordinates
               // from its hanging node representation
               SolidNode* solid_node_pt = dynamic_cast<SolidNode*>(nod_pt);
               if (solid_node_pt != 0)
               {
                 unsigned n_lagrangian = solid_node_pt->nlagrangian();
                 for (unsigned i = 0; i < n_lagrangian; i++)
                 {
                   solid_node_pt->xi(i) = solid_node_pt->lagrangian_position(i);
                 }
               }
  
               // No need to worry about geometrically hanging nodes
               // on boundaries (as in (p_)adapt_mesh())
               // if((mesh_dim > 2) && (nod_pt->is_hanging()))
               // {
               //  //If the node is on a boundary then add a pointer to the node
               //  //to our lookup scheme
               //  if(nod_pt->is_on_boundary())
               //   {
               //    //Storage for the boundaries on which the Node is located
               //    std::set<unsigned>* boundaries_pt;
               //    nod_pt->get_boundaries_pt(boundaries_pt);
               //    if(boundaries_pt!=0)
               //     {
               //      //Loop over the boundaries and add a pointer to the node
               //      //to the appropriate storage scheme
               //      for(std::set<unsigned>::iterator
               //      it=boundaries_pt->begin();
               //          it!=boundaries_pt->end();++it)
               //       {
               //        hanging_nodes_on_boundary_pt[*it].insert(nod_pt);
               //       }
               //     }
               //   }
               // }
  
               // Finally set nonhanging
               nod_pt->set_nonhanging();
             }
           }
         }
         else
         {
           // Node doesn't exist!
         }
       }
     }
  
     // Careful: some of the external halo nodes are also in boundary
     //          node storage and should be removed from this first
     for (std::map<unsigned, Vector<Node*>>::iterator it =
            External_halo_node_pt.begin();
          it != External_halo_node_pt.end();
          it++)
     {
       // Processor ID
       int d = (*it).first;
  
       // How many external haloes with this process?
       unsigned n_ext_halo_nod = nexternal_halo_node(d);
       for (unsigned j = 0; j < n_ext_halo_nod; j++)
       {
         Node* ext_halo_nod_pt = external_halo_node_pt(d, j);
         unsigned n_bnd = nboundary();
         for (unsigned i_bnd = 0; i_bnd < n_bnd; i_bnd++)
         {
           // Call this for all boundaries; it will do nothing
           // if the node is not on the current boundary
           remove_boundary_node(i_bnd, ext_halo_nod_pt);
         }
       }
     }
  
     // A loop to delete external halo nodes
     for (std::map<unsigned, Vector<Node*>>::iterator it =
            External_halo_node_pt.begin();
          it != External_halo_node_pt.end();
          it++)
     {
       // Processor ID
       int d = (*it).first;
  
       unsigned n_ext_halo_nod = nexternal_halo_node(d);
       for (unsigned j = 0; j < n_ext_halo_nod; j++)
       {
         // Only delete if it's not a node stored in the current mesh
         bool is_a_mesh_node = false;
         unsigned n_node = nnode();
         for (unsigned jj = 0; jj < n_node; jj++)
         {
           if (Node_pt[jj] == External_halo_node_pt[d][j])
           {
             is_a_mesh_node = true;
           }
         }
  
         // There will also be duplications between multiple processors,
         // so make sure that we don't try to delete these twice
         if (!is_a_mesh_node)
         {
           // Loop over all other higher-numbered processors and check
           // for duplicated external halo nodes
           // (The highest numbered processor should delete all its ext halos)
           for (std::map<unsigned, Vector<Node*>>::iterator itt =
                  External_halo_node_pt.begin();
                itt != External_halo_node_pt.end();
                itt++)
           {
             // Processor ID
             int dd = (*itt).first;
  
             if (dd > d)
             {
               unsigned n_ext_halo = nexternal_halo_node(dd);
               for (unsigned jjj = 0; jjj < n_ext_halo; jjj++)
               {
                 if (External_halo_node_pt[dd][jjj] ==
                     External_halo_node_pt[d][j])
                 {
                   is_a_mesh_node = true;
                 }
               }
             }
           }
         }
  
         // Only now if no duplicates exist can the node be safely deleted
         if (!is_a_mesh_node)
         {
           delete External_halo_node_pt[d][j];
         }
       }
     }
  
     // Another loop to delete external halo elements (which are distinct)
     for (std::map<unsigned, Vector<GeneralisedElement*>>::iterator it =
            External_halo_element_pt.begin();
          it != External_halo_element_pt.end();
          it++)
     {
       // Processor ID
       int d = (*it).first;
  
       unsigned n_ext_halo_el = nexternal_halo_element(d);
       for (unsigned e = 0; e < n_ext_halo_el; e++)
       {
         delete External_halo_element_pt[d][e];
       }
     }
  
     // Now we are okay to clear the external halo node storage
     External_halo_node_pt.clear();
     External_halo_element_pt.clear();
  
     // External haloed nodes and elements are actual members
     // of the external mesh and should not be deleted
     External_haloed_node_pt.clear();
     External_haloed_element_pt.clear();
 #endif
   }

References e(), Eigen::placeholders::end, oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), is_mesh_distributed(), j, oomph::SolidNode::lagrangian_position(), m, oomph::HangInfo::master_node_pt(), nboundary(), oomph::Node::ndim(), oomph::SolidNode::nlagrangian(), oomph::HangInfo::nmaster(), nnode(), Node_pt, node_pt(), oomph::AlgebraicNode::node_update(), oomph::Data::ntstorage(), oomph::Data::nvalue(), oomph::Node::position(), remove_boundary_node(), oomph::Node::set_nonhanging(), oomph::Data::set_value(), plotPSD::t, oomph::Node::value(), oomph::Node::x(), and oomph::SolidNode::xi().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::Problem::delete_all_external_storage(), oomph::TreeBasedRefineableMeshBase::p_adapt(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::Multi_domain_functions::setup_multi_domain_interactions(), and ~Mesh().

◆ describe_dofs()

void oomph::Mesh::describe_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

protected

Function to describe the dofs of the Mesh. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

   {
     // Loop over the nodes and call their classification functions
     unsigned long nnod = Node_pt.size();
     for (unsigned long i = 0; i < nnod; i++)
     {
       std::stringstream conversion;
       conversion << " of Node " << i << current_string;
       std::string in(conversion.str());
       Node_pt[i]->describe_dofs(out, in);
     }
  
     // Loop over the elements and classify.
     unsigned long nel = Element_pt.size();
     for (unsigned long i = 0; i < nel; i++)
     {
       std::stringstream conversion;
       conversion << " in Element " << i << " [" << typeid(*Element_pt[i]).name()
                  << "] " << current_string;
       std::string in(conversion.str());
       Element_pt[i]->describe_dofs(out, in);
     }
   }

References Element_pt, i, plotDoE::name, Node_pt, out(), and oomph::Global_string_for_annotation::string().

Referenced by oomph::Problem::describe_dofs().

◆ describe_local_dofs()

void oomph::Mesh::describe_local_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

protected

Function to describe the local dofs of the elements. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

   {
     // Now loop over the elements and describe local dofs
     unsigned long nel = Element_pt.size();
     for (unsigned long i = 0; i < nel; i++)
     {
       std::stringstream conversion;
       conversion << " in Element" << i << " [" << typeid(*Element_pt[i]).name()
                  << "] " << current_string;
       std::string in(conversion.str());
       Element_pt[i]->describe_local_dofs(out, in);
     }
   }

References Element_pt, i, plotDoE::name, out(), and oomph::Global_string_for_annotation::string().

Referenced by oomph::Problem::describe_dofs().

◆ doc_boundary_coordinates()

template<class BULK_ELEMENT >

void oomph::Mesh::doc_boundary_coordinates	(	const unsigned &	b,
		std::ofstream &	the_file
	)

inline

Output boundary coordinates on boundary b – template argument specifies the bulk element type (needed to create FaceElement of appropriate type on mesh boundary).

     {
       if (nelement() == 0) return;
       if (!Boundary_coordinate_exists[b])
       {
         oomph_info << "No boundary coordinates were set up for boundary " << b
                    << std::endl;
         return;
       }
  
       // Get spatial dimension
       unsigned dim = finite_element_pt(0)->node_pt(0)->ndim();
  
       // Loop over all elements on boundaries
       unsigned nel = this->nboundary_element(b);
  
       // Loop over the bulk elements adjacent to boundary b
       for (unsigned e = 0; e < nel; e++)
       {
         // Get pointer to the bulk element that is adjacent to boundary b
         FiniteElement* bulk_elem_pt = this->boundary_element_pt(b, e);
  
         // Find the index of the face of element e along boundary b
         int face_index = this->face_index_at_boundary(b, e);
  
         // Create new face element
         DummyFaceElement<BULK_ELEMENT>* el_pt =
           new DummyFaceElement<BULK_ELEMENT>(bulk_elem_pt, face_index);
  
         // Specify boundary id in bulk mesh (needed to extract
         // boundary coordinate)
         el_pt->set_boundary_number_in_bulk_mesh(b);
  
         // Doc boundary coordinate
         Vector<double> s(dim - 1);
         Vector<double> zeta(dim - 1);
         Vector<double> x(dim);
         unsigned n_plot = 5;
         the_file << el_pt->tecplot_zone_string(n_plot);
  
         // Loop over plot points
         unsigned num_plot_points = el_pt->nplot_points(n_plot);
         for (unsigned iplot = 0; iplot < num_plot_points; iplot++)
         {
           // Get local coordinates of plot point
           el_pt->get_s_plot(iplot, n_plot, s);
           el_pt->interpolated_zeta(s, zeta);
           el_pt->interpolated_x(s, x);
           for (unsigned i = 0; i < dim; i++)
           {
             the_file << x[i] << " ";
           }
           for (unsigned i = 0; i < (dim - 1); i++)
           {
             the_file << zeta[i] << " ";
           }
  
           the_file << std::endl;
         }
         el_pt->write_tecplot_zone_footer(the_file, n_plot);
  
         // Cleanup
         delete el_pt;
       }
     }

References b, Boundary_coordinate_exists, boundary_element_pt(), e(), face_index_at_boundary(), finite_element_pt(), oomph::FiniteElement::get_s_plot(), i, oomph::FaceElement::interpolated_x(), oomph::FiniteElement::interpolated_zeta(), nboundary_element(), oomph::Node::ndim(), nelement(), oomph::FiniteElement::node_pt(), oomph::FiniteElement::nplot_points(), oomph::oomph_info, s, oomph::FaceElement::set_boundary_number_in_bulk_mesh(), oomph::FiniteElement::tecplot_zone_string(), oomph::FiniteElement::write_tecplot_zone_footer(), plotDoE::x, and Eigen::zeta().

◆ does_pointer_correspond_to_mesh_data()

bool oomph::Mesh::does_pointer_correspond_to_mesh_data ( double *const & parameter_pt )

Does the double pointer correspond to any mesh data.

Return true if the pointer corresponds to any data stored in the mesh and false if not

   {
     // Loop over the nodes
     const unsigned long n_node = this->nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // Check the values and positional data associated with each node
       if ((this->Node_pt[n]->does_pointer_correspond_to_value(parameter_pt)) ||
           (this->Node_pt[n]->does_pointer_correspond_to_position_data(
             parameter_pt)))
       {
         return true;
       }
     }
  
     // Loop over the elements
     const unsigned long n_element = this->nelement();
     for (unsigned long e = 0; e < n_element; e++)
     {
       // Cache pointer to the elemnet
       GeneralisedElement* const elem_pt = this->element_pt(e);
  
       // Find the number of internal dofs
       const unsigned n_internal = elem_pt->ninternal_data();
  
       // Loop over internal dofs and test the data
       for (unsigned j = 0; j < n_internal; j++)
       {
         if (elem_pt->internal_data_pt(j)->does_pointer_correspond_to_value(
               parameter_pt))
         {
           return true;
         }
       }
     }
  
     // If we get here we haven't found the data, so return false
     return false;
   }

References oomph::Data::does_pointer_correspond_to_value(), e(), element_pt(), oomph::GeneralisedElement::internal_data_pt(), j, n, nelement(), oomph::GeneralisedElement::ninternal_data(), nnode(), and Node_pt.

Referenced by oomph::Problem::does_pointer_correspond_to_problem_data().

◆ dump() [1/2]

void oomph::Mesh::dump	(	const std::string &	dump_file_name,
		const bool &	use_old_ordering = `true`
	)		const

inline

Dump the data in the mesh into a file for restart.

     {
       std::ofstream dump_stream(dump_file_name.c_str());
 #ifdef PARANOID
       if (!dump_stream.is_open())
       {
         std::string err = "Couldn't open file " + dump_file_name;
         throw OomphLibError(
           err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
       }
 #endif
       dump(dump_stream, use_old_ordering);
     }

References dump(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

◆ dump() [2/2]

void oomph::Mesh::dump	(	std::ofstream &	dump_file,
		const bool &	use_old_ordering = `true`
	)		const

virtual

Dump the data in the mesh into a file for restart.

Dump function for the mesh class. Loop over all nodes and elements and dump them

Reimplemented in oomph::PerturbedSpineMesh.

   {
     // Get a reordering of the nodes so that the dump file is in a standard
     // ordering regardless of the sequence of mesh refinements etc.
     Vector<Node*> reordering;
     this->get_node_reordering(reordering, use_old_ordering);
  
     // Find number of nodes
     unsigned long Node_pt_range = this->nnode();
  
     // Doc # of nodes
     dump_file << Node_pt_range << " # number of nodes " << std::endl;
  
     // Loop over all the nodes and dump their data
     for (unsigned nd = 0; nd < Node_pt_range; nd++)
     {
       reordering[nd]->dump(dump_file);
     }
  
     // Loop over elements and deal with internal data
     unsigned n_element = this->nelement();
     for (unsigned e = 0; e < n_element; e++)
     {
       GeneralisedElement* el_pt = this->element_pt(e);
       unsigned n_internal = el_pt->ninternal_data();
       if (n_internal > 0)
       {
         dump_file << n_internal
                   << " # number of internal Data items in element " << e
                   << std::endl;
         for (unsigned i = 0; i < n_internal; i++)
         {
           el_pt->internal_data_pt(i)->dump(dump_file);
         }
       }
     }
   }

References oomph::Data::dump(), e(), element_pt(), get_node_reordering(), i, oomph::GeneralisedElement::internal_data_pt(), nelement(), oomph::GeneralisedElement::ninternal_data(), and nnode().

Referenced by dump(), oomph::Problem::dump(), oomph::SpineMesh::dump(), and oomph::PerturbedSpineMesh::dump().

◆ element_pt() [1/4]

Vector<GeneralisedElement*>& oomph::Mesh::element_pt ( )

inline

Return reference to the Vector of elements.

     {
       return Element_pt;
     }

References Element_pt.

◆ element_pt() [2/4]

const Vector<GeneralisedElement*>& oomph::Mesh::element_pt ( ) const

inline

Return reference to the Vector of elements.

     {
       return Element_pt;
     }

References Element_pt.

◆ element_pt() [3/4]

GeneralisedElement*& oomph::Mesh::element_pt ( const unsigned long & e )

inline

Return pointer to element e.

     {
       return Element_pt[e];
     }

References e(), and Element_pt.

◆ element_pt() [4/4]

GeneralisedElement* oomph::Mesh::element_pt ( const unsigned long & e ) const

inline

Return pointer to element e (const version)

     {
       return Element_pt[e];
     }

References e(), and Element_pt.

◆ elemental_dimension()

unsigned oomph::Mesh::elemental_dimension ( ) const

Return number of elemental dimension in mesh.

Get the number of elemental dimension in the mesh from the first element of the mesh. If MPI is on then also do some consistency checks between processors. Careful: Involves MPI Broadcasts and must therefore be called on all processors!

   {
     // Remains -1 if we don't have any elements on this processor.
     int int_dim = -1;
     if (nelement() > 0)
     {
       int_dim = finite_element_pt(0)->dim();
 #ifdef PARANOID
       // Check that every element in this mesh has the same number of
       // types of elemental dimension.
       for (unsigned i = 1; i < nelement(); i++)
       {
         if (int_dim != int(finite_element_pt(i)->dim()))
         {
           std::ostringstream error_message;
           error_message
             << "Every element in the mesh must have the same number of "
             << "elemental dimension for elemental_dimension() to work.\n"
             << "Element 0 has elemental dimension " << int_dim << "\n"
             << "Element " << i << " has elemental dimension "
             << finite_element_pt(i)->dim() << ".";
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
 #endif
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // If mesh is distributed
     if (Comm_pt != 0)
     {
       // if more than one processor then
       // + ensure dimension number is consistent on each processor (PARANOID)
       // + ensure processors with no elements in this mesh have the
       //   correct dimension number.
       if (Comm_pt->nproc() > 1)
       {
         unsigned nproc = Comm_pt->nproc();
         unsigned my_rank = Comm_pt->my_rank();
  
         // Collect on root the dimension number determined independently
         // on all processors (-1 indicates that the processor didn't have
         // any elements and therefore doesn't know!)
         int* dim_recv = 0;
         if (my_rank == 0)
         {
           dim_recv = new int[nproc];
         }
  
         MPI_Gather(
           &int_dim, 1, MPI_INT, dim_recv, 1, MPI_INT, 0, Comm_pt->mpi_comm());
  
         // Root: Update own dimension, check consistency amongst
         // all processors (in paranoid mode) and send out the actual
         // dimension number to those processors who couldn't figure this
         // out themselves
         if (my_rank == 0)
         {
           // Check number of types of all non-root processors
           for (unsigned p = 1; p < nproc; p++)
           {
             if (dim_recv[p] != -1)
             {
               // Processor p was able to figure out the elemental
               // dimension, so I root can update
               // its own (if required)
               if (int_dim == -1)
               {
                 int_dim = dim_recv[p];
               }
 #ifdef PARANOID
               // Check consistency
               else if (int_dim != dim_recv[p])
               {
                 std::ostringstream error_message;
                 error_message
                   << "The elements in this mesh must have the same elemental "
                   << "dimension number on each processor";
                 for (unsigned p = 0; p < nproc; p++)
                 {
                   if (dim_recv[p] != -1)
                   {
                     error_message << "Processor " << p << " : " << dim_recv[p]
                                   << "\n";
                   }
                   else
                   {
                     error_message << "Processor " << p << " : (no elements)\n";
                   }
                 }
                 throw OomphLibError(error_message.str(),
                                     OOMPH_CURRENT_FUNCTION,
                                     OOMPH_EXCEPTION_LOCATION);
               }
 #endif
             }
           }
  
           // Now send the elemental dimension to non-root processors that
           // don't have it
           for (unsigned p = 1; p < nproc; p++)
           {
             if (dim_recv[p] == -1)
             {
               MPI_Send(&int_dim, 1, MPI_INT, p, 0, Comm_pt->mpi_comm());
             }
           }
           // clean up
           delete[] dim_recv;
         }
         // "else if": "else" for non-root; "if" for checking if current
         // (non-root) processor does not know elemental dimension and is
         // therefore about to receive it from root.
         else if (int_dim == -1)
         {
           MPI_Recv(
             &int_dim, 1, MPI_INT, 0, 0, Comm_pt->mpi_comm(), MPI_STATUS_IGNORE);
         }
       }
     }
 #endif
  
     // If int_dim if still -1 then no elements were found for this mesh, so it
     // has no elemental dimension.
     if (int_dim == -1) int_dim = 0;
  
     return unsigned(int_dim);
   }

References oomph::FiniteElement::dim(), finite_element_pt(), i, nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

Referenced by oomph::LagrangeEnforcedFlowPreconditioner::set_meshes().

◆ face_index_at_boundary()

int oomph::Mesh::face_index_at_boundary	(	const unsigned &	b,
		const unsigned &	e
	)		const

inline

For the e-th finite element on boundary b, return int to indicate the face_index of the face adjacent to the boundary. This is consistent with input required during the generation of FaceElements.

     {
 #ifdef PARANOID
       if (!Lookup_for_elements_next_boundary_is_setup)
       {
         throw OomphLibError("Lookup scheme for elements next to boundary "
                             "hasn't been set up yet!\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Face_index_at_boundary[b][e];
     }

References b, e(), Face_index_at_boundary, Lookup_for_elements_next_boundary_is_setup, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ finite_element_pt()

FiniteElement* oomph::Mesh::finite_element_pt ( const unsigned & e ) const

inline

Upcast (downcast?) to FiniteElement (needed to access FiniteElement member functions).

     {
 #ifdef PARANOID
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         // Error
         throw OomphLibError("Failed cast to FiniteElement* ",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
         // Dummy return to keep intel compiler happy
         return el_pt;
       }
       return el_pt;
 #else
       return dynamic_cast<FiniteElement*>(Element_pt[e]);
 #endif
     }

References e(), Element_pt, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::RefineableTetgenMesh< ELEMENT >::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TetMeshBase::assess_mesh_quality(), oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), oomph::QuadFromTriangleMesh< ELEMENT >::build_from_scaffold(), oomph::MeshAsGeomObject::build_it(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), check_inverted_elements(), oomph::TriangleScaffoldMesh::check_mesh_integrity(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), oomph::RefineableTetMeshBase::compute_volume_target(), convert_to_boundary_node(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), doc_boundary_coordinates(), oomph::Z2ErrorEstimator::doc_flux(), oomph::FSI_functions::doc_fsi(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution(), oomph::DummyErrorEstimator::DummyErrorEstimator(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), oomph::ElasticRefineableQuarterPipeMesh< ELEMENT >::ElasticRefineableQuarterPipeMesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), elemental_dimension(), GlobalParameters::find_node_on_centerline(), FlatPlateMesh< ELEMENT >::FlatPlateMesh(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::FpPressureAdvectionDiffusionProblem(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), FSIRingProblem::FSIRingProblem(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), oomph::DummyErrorEstimator::get_element_errors(), NodeReordering::get_node_reordering(), oomph::NavierStokesSchurComplementPreconditioner::get_pressure_advection_diffusion_matrix(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::interface_min_max(), max_and_min_element_size(), oomph::MyProblem::min_element_size(), oomph::MyProblem::my_set_initial_condition(), oomph::NetFluxControlElement< ELEMENT >::NetFluxControlElement(), oomph::BrethertonSpineMesh< ELEMENT, INTERFACE_ELEMENT >::nfree_surface_spines(), nodal_dimension(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), oomph::MyProblem::output_exact_solution(), oomph::MyProblem::output_solution(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::pin_all_non_pressure_dofs(), oomph::MGSolver< DIM >::plot(), oomph::PMLQuadMeshBase< ELEMENT >::pml_locate_zeta(), oomph::PMLCornerQuadMesh< ELEMENT >::PMLCornerQuadMesh(), oomph::PMLQuadMesh< ELEMENT >::PMLQuadMesh(), print_connectivity_matrix(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), oomph::RefineableEighthSphereMesh< ELEMENT >::RefineableEighthSphereMesh(), oomph::RefineableFullCircleMesh< ELEMENT >::RefineableFullCircleMesh(), oomph::RefineableQuarterPipeMesh< ELEMENT >::RefineableQuarterPipeMesh(), oomph::RefineableQuarterTubeMesh< ELEMENT >::RefineableQuarterTubeMesh(), oomph::RefineableTubeMesh< ELEMENT >::RefineableTubeMesh(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::reset_pin_status(), HeatedCircularPenetratorElement::set_contact_element_mesh_pt(), oomph::NavierStokesImpedanceTractionElement< BULK_NAVIER_STOKES_ELEMENT, WOMERSLEY_ELEMENT, DIM >::set_external_data_from_navier_stokes_outflow_mesh(), oomph::MGSolver< DIM >::set_self_test_vector(), oomph::MyProblem::set_up_impulsive_initial_condition(), oomph::AlgebraicFishMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >::setup_algebraic_node_update(), oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >::setup_algebraic_node_update(), oomph::BrickMeshBase::setup_boundary_element_info(), oomph::LineMeshBase::setup_boundary_element_info(), oomph::QuadMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::setup_boundary_element_info(), oomph::TriangleMeshBase::setup_boundary_element_info(), oomph::MGSolver< DIM >::setup_interpolation_matrices(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices(), ShellMesh< ELEMENT >::ShellMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), SimpleSpineMesh< ELEMENT >::SimpleSpineMesh(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::TetMeshBase::split_elements_in_corners(), SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::SurfactantProblem(), oomph::TetgenScaffoldMesh::TetgenScaffoldMesh(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), total_size(), TriangleFaceTestProblem< ELEMENT >::TriangleFaceTestProblem(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), oomph::TubeMesh< ELEMENT >::TubeMesh(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), oomph::RefineableTetgenMesh< ELEMENT >::update_faceted_surface_using_face_mesh(), and oomph::WomersleyMesh< WOMERSLEY_ELEMENT >::WomersleyMesh().

◆ flush_element_and_node_storage()

void oomph::Mesh::flush_element_and_node_storage ( )

inline

Flush storage for elements and nodes by emptying the vectors that store the pointers to them. This is useful if a particular mesh is only built to generate a small part of a bigger mesh. Once the elements and nodes have been created, they are typically copied into the new mesh and the auxiliary mesh can be deleted. However, if we simply call the destructor of the auxiliary mesh, it will also wipe out the nodes and elements, because it still "thinks" it's in charge of these...

     {
       flush_element_storage();
       flush_node_storage();
     }

References flush_element_storage(), and flush_node_storage().

◆ flush_element_storage()

void oomph::Mesh::flush_element_storage ( )

inline

Flush storage for elements (only) by emptying the vectors that store the pointers to them. This is useful if a particular mesh is only built to generate a small part of a bigger mesh. Once the elements and nodes have been created, they are typically copied into the new mesh and the auxiliary mesh can be deleted. However, if we simply call the destructor of the auxiliary mesh, it will also wipe out the nodes and elements, because it still "thinks" it's in charge of these...

     {
       Element_pt.clear();
     }

References Element_pt.

Referenced by flush_element_and_node_storage().

◆ flush_node_storage()

void oomph::Mesh::flush_node_storage ( )

inline

Flush storage for nodes (only) by emptying the vectors that store the pointers to them.

     {
       Node_pt.clear();
     }

References Node_pt.

Referenced by flush_element_and_node_storage(), and InclinedPlaneProblem< ELEMENT, INTERFACE_ELEMENT >::~InclinedPlaneProblem().

◆ get_node_reordering()

void oomph::Mesh::get_node_reordering	(	Vector< Node * > &	reordering,
		const bool &	use_old_ordering = `true`
	)		const

virtual

Get a reordering of the nodes in the order in which they appear in elements – can be overloaded for more efficient re-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 order
     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 = 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[node_pt(j)] = false;
       }
  
       // Initialise counter for number of nodes
       unsigned long count = 0;
  
       // Get the number of elements in the mesh
       unsigned nel = nelement();
  
       // Loop over all elements
       for (unsigned e = 0; e < nel; e++)
       {
         // Make sure the e-th element is a FiniteElement (or derived) class
         // object
         FiniteElement* el_pt =
           checked_dynamic_cast<FiniteElement*>(element_pt(e));
  
         // 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++)
       } // 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 = 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] = node_pt(i);
       }
  
       // Now sort the nodes lexicographically
       std::sort(reordering.begin(),
                 reordering.end(),
                 &NodeOrdering::node_global_position_comparison);
     } // if (use_old_ordering)
   } // End of get_node_reordering

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

Referenced by dump(), and reorder_nodes().

◆ get_some_non_boundary_node()

Node* oomph::Mesh::get_some_non_boundary_node ( ) const

inline

Find a node not on any boundary in mesh_pt (useful for pinning a single node in a purely Neumann problem so that it is fully determined).

     {
       for (unsigned nd = 0, nnd = nnode(); nd < nnd; nd++)
       {
         if (!(node_pt(nd)->is_on_boundary()))
         {
           return node_pt(nd);
         }
       }
  
       std::ostringstream error_msg;
       error_msg << "No non-boundary nodes in the mesh.";
       throw OomphLibError(
         error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       // Never get here!
       return 0;
     }

References nnode(), node_pt(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ is_mesh_distributed()

bool oomph::Mesh::is_mesh_distributed ( ) const

inline

Boolean to indicate if Mesh has been distributed.

     {
 #ifdef OOMPH_HAS_MPI
       return communicator_pt() != 0;
 #else
       // Can't be distributed without mpi
       return false;
 #endif
     }

References communicator_pt().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), build_face_mesh(), oomph::MeshAsGeomObject::build_it(), delete_all_external_storage(), oomph::DummyErrorEstimator::DummyErrorEstimator(), oomph::Problem::dump(), oomph::Z2ErrorEstimator::get_element_errors(), ndof_types(), oomph::TreeBasedRefineableMeshBase::p_adapt(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_refine_selected_elements(), oomph::Problem::read(), oomph::TreeBasedRefineableMeshBase::refine_base_mesh(), oomph::TreeBasedRefineableMeshBase::refine_selected_elements(), and oomph::UnstructuredTwoDMeshGeometryBase::setup_boundary_coordinates().

◆ max_and_min_element_size()

void oomph::Mesh::max_and_min_element_size	(	double &	max_size,
		double &	min_size
	)

inline

Determine max and min area for all FiniteElements in the mesh (non-FiniteElements are ignored)

     {
       max_size = 0.0;
       min_size = DBL_MAX;
       unsigned nel = nelement();
       for (unsigned e = 0; e < nel; e++)
       {
         max_size = std::max(max_size, finite_element_pt(e)->size());
         min_size = std::min(min_size, finite_element_pt(e)->size());
       }
     }

References e(), finite_element_pt(), max, min, nelement(), and size.

◆ merge_meshes()

void oomph::Mesh::merge_meshes ( const Vector< Mesh * > & sub_mesh_pt )

Merge meshes. Note: This simply merges the meshes' elements and nodes (ignoring duplicates; no boundary information etc. is created).

   {
     // No boundary lookup scheme is set up for the combined mesh
     Lookup_for_elements_next_boundary_is_setup = false;
  
     // Number of submeshes
     unsigned nsub_mesh = sub_mesh_pt.size();
  
     // Initialise element, node and boundary counters for global mesh
     unsigned long n_element = 0;
     unsigned long n_node = 0;
     unsigned n_bound = 0;
  
     // Loop over submeshes and get total number of elements, nodes and
     // boundaries
     for (unsigned imesh = 0; imesh < nsub_mesh; imesh++)
     {
       n_element += sub_mesh_pt[imesh]->nelement();
       n_node += sub_mesh_pt[imesh]->nnode();
       n_bound += sub_mesh_pt[imesh]->nboundary();
     }
  
     // Reserve storage for element and node pointers
     Element_pt.clear();
     Element_pt.reserve(n_element);
     Node_pt.clear();
     Node_pt.reserve(n_node);
  
     // Resize vector of vectors of nodes
     Boundary_node_pt.clear();
     Boundary_node_pt.resize(n_bound);
  
     // Sets of pointers to elements and nodes (to exlude duplicates -- they
     // shouldn't occur anyway but if they do, they must only be added
     // once in the global mesh to avoid trouble in the timestepping)
     std::set<GeneralisedElement*> element_set_pt;
     std::set<Node*> node_set_pt;
  
     // Counter for total number of boundaries in all the submeshes
     unsigned ibound_global = 0;
     // Loop over the number of submeshes
     for (unsigned imesh = 0; imesh < nsub_mesh; imesh++)
     {
       // Loop over the elements of the submesh and add to vector
       // duplicates are ignored
       unsigned nel_before = 0;
       unsigned long n_element = sub_mesh_pt[imesh]->nelement();
       for (unsigned long e = 0; e < n_element; e++)
       {
         GeneralisedElement* el_pt = sub_mesh_pt[imesh]->element_pt(e);
         element_set_pt.insert(el_pt);
         // Was it a duplicate?
         unsigned nel_now = element_set_pt.size();
         if (nel_now == nel_before)
         {
           std::ostringstream warning_stream;
           warning_stream << "WARNING: " << std::endl
                          << "Element " << e << " in submesh " << imesh
                          << " is a duplicate \n and was ignored when assembling"
                          << " combined mesh." << std::endl;
           OomphLibWarning(warning_stream.str(),
                           "Mesh::Mesh(const Vector<Mesh*>&)",
                           OOMPH_EXCEPTION_LOCATION);
         }
         else
         {
           Element_pt.push_back(el_pt);
         }
         nel_before = nel_now;
       }
  
       // Loop over the nodes of the submesh and add to vector
       // duplicates are ignored
       unsigned nnod_before = 0;
       unsigned long n_node = sub_mesh_pt[imesh]->nnode();
       for (unsigned long n = 0; n < n_node; n++)
       {
         Node* nod_pt = sub_mesh_pt[imesh]->node_pt(n);
         node_set_pt.insert(nod_pt);
         // Was it a duplicate?
         unsigned nnod_now = node_set_pt.size();
         if (nnod_now == nnod_before)
         {
           std::ostringstream warning_stream;
           warning_stream
             << "WARNING: " << std::endl
             << "Node " << n << " in submesh " << imesh
             << " is a duplicate \n and was ignored when assembling "
             << "combined mesh." << std::endl;
           OomphLibWarning(warning_stream.str(),
                           "Mesh::Mesh(const Vector<Mesh*>&)",
                           OOMPH_EXCEPTION_LOCATION);
         }
         else
         {
           Node_pt.push_back(nod_pt);
         }
         nnod_before = nnod_now;
       }
  
       // Loop over the boundaries of the submesh
       unsigned n_bound = sub_mesh_pt[imesh]->nboundary();
       for (unsigned ibound = 0; ibound < n_bound; ibound++)
       {
         // Loop over the number of nodes on the boundary and add to the
         // global vector
         unsigned long n_bound_node = sub_mesh_pt[imesh]->nboundary_node(ibound);
         for (unsigned long n = 0; n < n_bound_node; n++)
         {
           Boundary_node_pt[ibound_global].push_back(
             sub_mesh_pt[imesh]->boundary_node_pt(ibound, n));
         }
         // Increase the number of the global boundary counter
         ibound_global++;
       }
     } // End of loop over submeshes
   }

References Boundary_node_pt, boundary_node_pt(), e(), Element_pt, Lookup_for_elements_next_boundary_is_setup, n, Node_pt, and OOMPH_EXCEPTION_LOCATION.

Referenced by Mesh(), oomph::Problem::rebuild_global_mesh(), and oomph::SolidMesh::SolidMesh().

◆ nboundary()

unsigned oomph::Mesh::nboundary ( ) const

inline

Return number of boundaries.

     {
       return Boundary_node_pt.size();
     }

References Boundary_node_pt.

◆ nboundary_element()

unsigned oomph::Mesh::nboundary_element ( const unsigned & b ) const

inline

Return number of finite elements that are adjacent to boundary b.

     {
 #ifdef PARANOID
       if (!Lookup_for_elements_next_boundary_is_setup)
       {
         throw OomphLibError("Lookup scheme for elements next to boundary "
                             "hasn't been set up yet!\n",
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       return Boundary_element_pt[b].size();
     }

References b, Boundary_element_pt, Lookup_for_elements_next_boundary_is_setup, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

◆ nboundary_node()

unsigned long oomph::Mesh::nboundary_node ( const unsigned & ibound ) const

inline

Return number of nodes on a particular boundary.

     {
       return Boundary_node_pt[ibound].size();
     }

References Boundary_node_pt.

◆ ndof_types()

unsigned oomph::Mesh::ndof_types ( ) const

Return number of dof types in mesh.

Get the number of dof types in the mesh from the first element of the mesh. If MPI is on then also do some consistency checks between processors. Careful: Involves MPI Broadcasts and must therefore be called on all processors!

   {
     // Remains -1 if we don't have any elements on this processor.
     int int_ndof_types = -1;
     unsigned nel = nelement();
     if (nel > 0)
     {
       int_ndof_types = element_pt(0)->ndof_types();
 #ifdef PARANOID
       // Check that every element in this mesh has the same number of
       // types of DOF.
       for (unsigned i = 1; i < nel; i++)
       {
         if (int_ndof_types != int(element_pt(i)->ndof_types()))
         {
           std::ostringstream error_message;
           error_message
             << "Every element in the mesh must have the same number of "
             << "types of DOF for ndof_types() to work\n"
             << "Element 0 has " << int_ndof_types << " DOF types\n"
             << "Element " << i << " [out of a total of " << nel << " ] has "
             << element_pt(i)->ndof_types() << " DOF types"
             << "Element types are: Element 0:" << typeid(*element_pt(0)).name()
             << "\n"
             << "           Current Element  :" << typeid(*element_pt(i)).name()
             << "\n";
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
 #endif
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // If mesh is distributed
     if (is_mesh_distributed())
     {
       // if more than one processor then
       // + ensure number of DOFs is consistent on each processor (PARANOID)
       // + ensure processors with no elements in this mesh have the
       //   correct number of DOF types
       if (Comm_pt->nproc() > 1)
       {
         unsigned nproc = Comm_pt->nproc();
         unsigned my_rank = Comm_pt->my_rank();
  
         // Collect on root the number of dofs types determined independently
         // on all processors (-1 indicates that the processor didn't have
         // any elements and therefore doesn't know!)
         int* ndof_types_recv = 0;
         if (my_rank == 0)
         {
           ndof_types_recv = new int[nproc];
         }
  
         MPI_Gather(&int_ndof_types,
                    1,
                    MPI_INT,
                    ndof_types_recv,
                    1,
                    MPI_INT,
                    0,
                    Comm_pt->mpi_comm());
  
         // Root: Update own number of dof types, check consistency amongst
         // all processors (in paranoid mode) and send out the actual
         // number of dof types to those processors who couldn't figure this
         // out themselves
         if (my_rank == 0)
         {
           // Check number of types of all non-root processors
           for (unsigned p = 1; p < nproc; p++)
           {
             if (ndof_types_recv[p] != -1)
             {
               // Processor p was able to figure out how many
               // dof types there are, so I root can update
               // its own (if required)
               if (int_ndof_types == -1)
               {
                 int_ndof_types = ndof_types_recv[p];
               }
 #ifdef PARANOID
               // Check consistency
               else if (int_ndof_types != ndof_types_recv[p])
               {
                 std::ostringstream error_message;
                 error_message
                   << "The elements in this mesh must have the same number "
                   << "of types of DOF on each processor";
                 for (unsigned p = 0; p < nproc; p++)
                 {
                   if (ndof_types_recv[p] != -1)
                   {
                     error_message << "Processor " << p << " : "
                                   << ndof_types_recv[p] << "\n";
                   }
                   else
                   {
                     error_message << "Processor " << p << " : (no elements)\n";
                   }
                 }
                 throw OomphLibError(error_message.str(),
                                     OOMPH_CURRENT_FUNCTION,
                                     OOMPH_EXCEPTION_LOCATION);
               }
 #endif
             }
           }
  
           // Now send ndof types to non-root processors that don't have it
           for (unsigned p = 1; p < nproc; p++)
           {
             if (ndof_types_recv[p] == -1)
             {
               MPI_Send(&int_ndof_types, 1, MPI_INT, p, 0, Comm_pt->mpi_comm());
             }
           }
           // clean up
           delete[] ndof_types_recv;
         }
         // "else if": "else" for non-root; "if" for checking if current
         // (non-root) processor does not know ndof type and is therefore
         // about to receive it from root.
         else if (int_ndof_types == -1)
         {
           MPI_Recv(&int_ndof_types,
                    1,
                    MPI_INT,
                    0,
                    0,
                    Comm_pt->mpi_comm(),
                    MPI_STATUS_IGNORE);
         }
       }
     }
 #endif
  
     // If int_ndof_types if still -1 then no elements were found for this mesh,
     // so it has no dofs.
     if (int_ndof_types == -1) int_ndof_types = 0;
  
     return unsigned(int_ndof_types);
   }

References element_pt(), i, is_mesh_distributed(), plotDoE::name, nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

Referenced by oomph::BlockPreconditioner< MATRIX >::ndof_types_in_mesh().

◆ nelement()

unsigned long oomph::Mesh::nelement ( ) const

inline

Return number of elements in the mesh.

     {
       return Element_pt.size();
     }

References Element_pt.

◆ nnode()

unsigned long oomph::Mesh::nnode ( ) const

inline

Return number of nodes in the mesh.

     {
       return Node_pt.size();
     }

References Node_pt.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::actions_before_newton_solve(), SolidBag::actionsBeforeOomphTimeStep(), oomph::RefineableTetgenMesh< ELEMENT >::adapt(), oomph::RefineableGmshTetMesh< ELEMENT >::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), assign_initial_values_impulsive(), oomph::StreamfunctionProblem::assign_velocities(), oomph::Multi_domain_functions::aux_setup_multi_domain_interaction(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::backup(), oomph::SolidICProblem::backup_original_state(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), SolidBag::bendBag(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), oomph::MeshAsGeomObject::build_it(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), CombCanSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::build_single_layer_mesh(), calculate_predictions(), check_for_repeated_nodes(), oomph::TriangleScaffoldMesh::check_mesh_integrity(), oomph::MyProblem::check_not_segregated(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), oomph::TreeBasedRefineableMeshBase::complete_hanging_nodes(), oomph::AddedMainNumberingLookup::construct_added_to_main_mapping(), oomph::Problem::copy(), copy_boundary_node_data_from_nodes(), MovingBlockProblem< ELEMENT >::create_extruded_mesh(), InterfaceProblem< ELEMENT, TIMESTEPPER >::deform_free_surface(), MeshDeformation::deform_mesh(), delete_all_external_storage(), demo_smoothing_with_nonlinear_elasticity(), oomph::FSI_functions::doc_fsi(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution(), doc_sparse_node_update(), does_pointer_correspond_to_mesh_data(), dump(), FlatPlateMesh< ELEMENT >::FlatPlateMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::Z2ErrorEstimator::get_element_errors(), NodeReordering::get_node_reordering(), get_node_reordering(), get_some_non_boundary_node(), main(), oomph::MyProblem::my_set_initial_condition(), oomph::AlgebraicMesh::node_update(), oomph::MacroElementNodeUpdateMesh::node_update(), node_update(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::operator()(), oomph::LinearElasticitySmoothMesh< LINEAR_ELASTICITY_ELEMENT >::operator()(), oomph::PoissonSmoothMesh< POISSON_ELEMENT >::operator()(), PolarNSProblem< ELEMENT >::output_streamfunction(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::PerturbedStateProblem(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_dofs_of_coordinate(), oomph::StreamfunctionProblem::pin_velocities(), oomph::PMLQuadMeshBase< ELEMENT >::pml_locate_zeta(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), prune_dead_nodes(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), read(), oomph::VorticitySmoother< ELEMENT >::recover_vorticity(), reorder_nodes(), NodeReordering::reorder_nodes(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::reset(), oomph::SolidICProblem::reset_original_state(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::reset_pin_status(), oomph::NavierStokesSchurComplementPreconditioner::reset_pin_status(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::restore_positions(), CombCanSpineMesh< ELEMENT, INTERFACE_ELEMENT >::rotate_90(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::rotate_90_zeq1_xeq0(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::rotate_90_zeq1_yeq0(), run_navier_stokes_outflow(), scale_mesh(), oomph::MyProblem::segregated_pin_indices(), oomph::AlgebraicMesh::self_test(), set_consistent_pinned_values_for_continuation(), oomph::SolidMesh::set_lagrangian_nodal_coordinates(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::SolidICProblem::set_newmark_initial_condition_directly(), set_nodal_time_stepper(), oomph::Problem::set_pinned_values_to_zero(), oomph::MyProblem::set_up_impulsive_initial_condition(), oomph::MGSolver< DIM >::setup_interpolation_matrices_unstructured(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices_unstructured(), oomph::SolidICProblem::setup_problem(), ShellMesh< ELEMENT >::ShellMesh(), shift_time_values(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), ABCProblem< ELEMENT, TIMESTEPPERT >::solve(), oomph::TetMeshBase::split_elements_in_corners(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::store_positions(), oomph::Refineable_r_mesh< ELEMENT >::stretch_mesh(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), oomph::MyProblem::undo_segregated_pinning(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_all(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_dofs_of_coordinate(), and oomph::WomersleyMesh< WOMERSLEY_ELEMENT >::WomersleyMesh().

◆ nodal_dimension()

unsigned oomph::Mesh::nodal_dimension ( ) const

Return number of nodal dimension in mesh.

Get the number of nodal dimension in the mesh from the first element of the mesh. If MPI is on then also do some consistency checks between processors. Careful: Involves MPI Broadcasts and must therefore be called on all processors!

   {
     // Remains -1 if we don't have any elements on this processor.
     int int_dim = -1;
     if (nelement() > 0)
     {
       int_dim = finite_element_pt(0)->nodal_dimension();
 #ifdef PARANOID
       // Check that every element in this mesh has the same number of
       // types of nodal dimension.
       for (unsigned i = 1; i < nelement(); i++)
       {
         if (int_dim != int(finite_element_pt(i)->nodal_dimension()))
         {
           std::ostringstream error_message;
           error_message
             << "Every element in the mesh must have the same number of "
             << "nodal dimension for nodal_dimension() to work.\n"
             << "Element 0 has nodal dimension " << int_dim << "\n"
             << "Element " << i << " has nodal dimension "
             << finite_element_pt(i)->nodal_dimension() << ".";
           throw OomphLibError(error_message.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
 #endif
     }
  
 #ifdef OOMPH_HAS_MPI
  
     // If mesh is distributed
     if (Comm_pt != 0)
     {
       // if more than one processor then
       // + ensure dimension number is consistent on each processor (PARANOID)
       // + ensure processors with no elements in this mesh have the
       //   correct dimension number.
       if (Comm_pt->nproc() > 1)
       {
         unsigned nproc = Comm_pt->nproc();
         unsigned my_rank = Comm_pt->my_rank();
  
         // Collect on root the dimension number determined independently
         // on all processors (-1 indicates that the processor didn't have
         // any elements and therefore doesn't know!)
         int* dim_recv = 0;
         if (my_rank == 0)
         {
           dim_recv = new int[nproc];
         }
  
         MPI_Gather(
           &int_dim, 1, MPI_INT, dim_recv, 1, MPI_INT, 0, Comm_pt->mpi_comm());
  
         // Root: Update own dimension, check consistency amongst
         // all processors (in paranoid mode) and send out the actual
         // dimension number to those processors who couldn't figure this
         // out themselves
         if (my_rank == 0)
         {
           // Check number of types of all non-root processors
           for (unsigned p = 1; p < nproc; p++)
           {
             if (dim_recv[p] != -1)
             {
               // Processor p was able to figure out the nodal
               // dimension, so I root can update
               // its own (if required)
               if (int_dim == -1)
               {
                 int_dim = dim_recv[p];
               }
 #ifdef PARANOID
               // Check consistency
               else if (int_dim != dim_recv[p])
               {
                 std::ostringstream error_message;
                 error_message
                   << "The elements in this mesh must have the same nodal "
                   << "dimension number on each processor";
                 for (unsigned p = 0; p < nproc; p++)
                 {
                   if (dim_recv[p] != -1)
                   {
                     error_message << "Processor " << p << " : " << dim_recv[p]
                                   << "\n";
                   }
                   else
                   {
                     error_message << "Processor " << p << " : (no elements)\n";
                   }
                 }
                 throw OomphLibError(error_message.str(),
                                     OOMPH_CURRENT_FUNCTION,
                                     OOMPH_EXCEPTION_LOCATION);
               }
 #endif
             }
           }
  
           // Now send the nodal dimension to non-root processors that
           // don't have it
           for (unsigned p = 1; p < nproc; p++)
           {
             if (dim_recv[p] == -1)
             {
               MPI_Send(&int_dim, 1, MPI_INT, p, 0, Comm_pt->mpi_comm());
             }
           }
           // clean up
           delete[] dim_recv;
         }
         // "else if": "else" for non-root; "if" for checking if current
         // (non-root) processor does not know nodal dimension and is therefore
         // about to receive it from root.
         else if (int_dim == -1)
         {
           MPI_Recv(
             &int_dim, 1, MPI_INT, 0, 0, Comm_pt->mpi_comm(), MPI_STATUS_IGNORE);
         }
       }
     }
 #endif
  
     // If int_dim if still -1 then no elements were found for this mesh, so it
     // has no nodal dimension.
     if (int_dim == -1) int_dim = 0;
  
     return unsigned(int_dim);
   }

References finite_element_pt(), i, nelement(), oomph::FiniteElement::nodal_dimension(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

Referenced by oomph::LagrangeEnforcedFlowPreconditioner::set_meshes().

◆ node_pt() [1/2]

Node*& oomph::Mesh::node_pt ( const unsigned long & n )

inline

Return pointer to global node n.

     {
       return Node_pt[n];
     }

References n, and Node_pt.

Referenced by oomph::IMRByBDF::actions_after_timestep(), oomph::RefineableTetgenMesh< ELEMENT >::adapt(), oomph::RefineableGmshTetMesh< ELEMENT >::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), add_boundary_node(), STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), add_node_pt(), oomph::StreamfunctionProblem::assign_velocities(), oomph::SolidICProblem::backup_original_state(), oomph::MeshAsGeomObject::build_it(), oomph::ExtrudedCubeMeshFromQuadMesh< ELEMENT >::build_mesh(), check_for_repeated_nodes(), oomph::TriangleScaffoldMesh::check_mesh_integrity(), oomph::MyProblem::check_not_segregated(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), InclinedPlaneProblem< ELEMENT, INTERFACE_ELEMENT >::complete_build(), oomph::TreeBasedRefineableMeshBase::complete_hanging_nodes(), oomph::AddedMainNumberingLookup::construct_added_to_main_mapping(), convert_to_boundary_node(), oomph::Problem::copy(), copy_boundary_node_data_from_nodes(), MeshDeformation::deform_mesh(), delete_all_external_storage(), oomph::FSI_functions::doc_fsi(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::Problem::get_dofs(), oomph::Z2ErrorEstimator::get_element_errors(), NodeReordering::get_node_reordering(), get_node_reordering(), get_some_non_boundary_node(), main(), oomph::MyProblem::my_set_initial_condition(), oomph::MacroElementNodeUpdateMesh::node_update(), node_update(), PolarNSProblem< ELEMENT >::output_streamfunction(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_all(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::pin_dofs_of_coordinate(), oomph::StreamfunctionProblem::pin_velocities(), oomph::MGSolver< DIM >::plot(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::project(), PseudoSolidCapProblem< ELEMENT >::PseudoSolidCapProblem(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), read(), oomph::VorticitySmoother< ELEMENT >::recover_vorticity(), oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh(), remove_boundary_node(), reorder_nodes(), NodeReordering::reorder_nodes(), oomph::SolidICProblem::reset_original_state(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::reset_pin_status(), oomph::NavierStokesSchurComplementPreconditioner::reset_pin_status(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::restore_positions(), run_navier_stokes_outflow(), scale_mesh(), oomph::MyProblem::segregated_pin_indices(), oomph::Problem::set_dofs(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::Problem::set_pinned_values_to_zero(), oomph::MGSolver< DIM >::set_self_test_vector(), oomph::MyProblem::set_up_impulsive_initial_condition(), oomph::MGSolver< DIM >::setup_interpolation_matrices_unstructured(), oomph::HelmholtzMGPreconditioner< DIM >::setup_interpolation_matrices_unstructured(), oomph::SolidICProblem::setup_problem(), oomph::SimpleCubicScaffoldTetMesh::SimpleCubicScaffoldTetMesh(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), ABCProblem< ELEMENT, TIMESTEPPERT >::solve(), oomph::MGSolver< DIM >::solve(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::store_positions(), oomph::TubeMesh< ELEMENT >::TubeMesh(), oomph::MyProblem::undo_segregated_pinning(), oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_all(), and oomph::ProjectionProblem< PROJECTABLE_ELEMENT >::unpin_dofs_of_coordinate().

◆ node_pt() [2/2]

Node* oomph::Mesh::node_pt ( const unsigned long & n ) const

inline

Return pointer to global node n (const version)

     {
       return Node_pt[n];
     }

References n, and Node_pt.

◆ node_update()

void oomph::Mesh::node_update ( const bool & update_all_solid_nodes = false )

virtual

Update nodal positions in response to changes in the domain shape. Uses the FiniteElement::get_x(...) function for FiniteElements and doesn't do anything for other element types. If a MacroElement pointer has been set for a FiniteElement, the MacroElement representation is used to update the nodal positions; if not get_x(...) uses the FE interpolation and thus leaves the nodal positions unchanged. Virtual, so it can be overloaded by specific meshes, such as AlgebraicMeshes or SpineMeshes. Generally, this function updates the position of all nodes in response to changes in the boundary position. However, we ignore all SolidNodes since their position is computed as part of the solution – unless the bool flag is set to true. Such calls are typically made when the initial mesh is created and/or after a mesh has been refined repeatedly before the start of the computation.

Update nodal positions in response to changes in the domain shape. Uses the FiniteElement::get_x(...) function for FiniteElements and doesn't do anything for other element types. If a MacroElement pointer has been set for a FiniteElement, the MacroElement representation is used to update the nodal positions; if not get_x(...) uses the FE interpolation and thus leaves the nodal positions unchanged. Virtual, so it can be overloaded by specific meshes, such as AlgebraicMeshes or SpineMeshes. Generally, this function updates the position of all nodes in response to changes in the boundary position. For SolidNodes it only applies the update to those SolidNodes whose position is determined by the boundary position, unless the bool flag is set to true.

Local and global (Eulerian) coordinate

Reimplemented in oomph::AlgebraicRefineableQuarterTubeMesh< ELEMENT >, oomph::MacroElementNodeUpdateRefineableQuarterTubeMesh< ELEMENT >, oomph::AlgebraicRefineableQuarterCircleSectorMesh< ELEMENT >, oomph::AlgebraicRefineableQuarterCircleSectorMesh< FLUID_ELEMENT >, oomph::MacroElementNodeUpdateRefineableQuarterCircleSectorMesh< ELEMENT >, oomph::AlgebraicRefineableFishMesh< ELEMENT >, oomph::AlgebraicFishMesh< ELEMENT >, oomph::MacroElementNodeUpdateRefineableFishMesh< ELEMENT >, oomph::SpineMesh, oomph::MacroElementNodeUpdateMesh, oomph::AlgebraicMesh, and oomph::PerturbedSpineMesh.

   {
     // Get the current time
     double t_start = TimingHelpers::timer();
  
 #ifdef PARANOID
 #ifdef OOMPH_HAS_MPI
     // Paranoid check to throw an error if node update is called for elements
     // with nonuniformly spaced nodes for which some masters are 'external'
     for (unsigned long n = 0; n < nnode(); n++)
     {
       Node* nod_pt = Node_pt[n];
       if (nod_pt->is_hanging())
       {
         // Loop over master nodes
         unsigned nmaster = nod_pt->hanging_pt()->nmaster();
         for (unsigned imaster = 0; imaster < nmaster; imaster++)
         {
           // Get pointer to master node
           Node* master_nod_pt = nod_pt->hanging_pt()->master_node_pt(imaster);
  
           // Get vector of all external halo nodes
           Vector<Node*> external_halo_node_pt;
           get_external_halo_node_pt(external_halo_node_pt);
  
           // Search the external halo storage for this node
           Vector<Node*>::iterator it = std::find(external_halo_node_pt.begin(),
                                                  external_halo_node_pt.end(),
                                                  master_nod_pt);
  
           // Check if the node was found
           if (it != external_halo_node_pt.end())
           {
             // Throw error becase node update won't work
             // It's ok to throw an error here because this function is
             // overloaded for Algebraic and MacroElementNodeUpdate
             // Meshes. This is only a problem for meshes of ordinary
             // nodes.
             std::ostringstream err_stream;
  
             err_stream << "Calling node_update() for a mesh which contains"
                        << std::endl
                        << "master nodes which live in the external storage."
                        << std::endl
                        << "These nodes do not belong to elements on this"
                        << std::endl
                        << "processor and therefore cannot be updated locally."
                        << std::endl;
  
             throw OomphLibError(err_stream.str(),
                                 OOMPH_CURRENT_FUNCTION,
                                 OOMPH_EXCEPTION_LOCATION);
           }
         }
       }
     }
     // If we get to here then none of the masters of any of the nodes in the
     // mesh live in the external storage, so we'll be fine if we carry on.
 #endif
 #endif
  
     Vector<double> s;
     Vector<double> r;
  
     // NB: This repeats nodes a lot - surely it would be
     // quicker to modify it so that it only does each node once,
     // particularly in the update_all_solid_nodes=true case?
     // Create a map to indicate whether or not we've updated a node already
     std::map<Node*, bool> has_node_been_updated;
  
     // How many nodes are there?
     unsigned n_node = nnode();
  
     // Loop over all Nodes
     for (unsigned n = 0; n < n_node; n++)
     {
       // Get pointer to node
       Node* nod_pt = node_pt(n);
  
       // Initialise the boolean value associated with this node
       has_node_been_updated[nod_pt] = false;
     }
  
     // Loop over all elements
     unsigned nel = nelement();
     for (unsigned e = 0; e < nel; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(element_pt(e));
  
       // If it's a finite element we can proceed: FiniteElements have
       // nodes and a get_x() function
       if (el_pt != 0)
       {
         // Find out dimension of element = number of local coordinates
         unsigned ndim_el = el_pt->dim();
         s.resize(ndim_el);
  
         // Loop over nodal points
         unsigned n_node = el_pt->nnode();
         for (unsigned j = 0; j < n_node; j++)
         {
           // Get pointer to node
           Node* nod_pt = el_pt->node_pt(j);
  
           // Get spatial dimension of node
           unsigned ndim_node = nod_pt->ndim();
           r.resize(ndim_node);
  
           // For non-hanging nodes
           if (!(nod_pt->is_hanging()))
           {
             // If we've not dealt with this Node yet
             if (!has_node_been_updated[nod_pt])
             {
               // Get the position of the node
               el_pt->local_coordinate_of_node(j, s);
  
               // Get new position
               el_pt->get_x(s, r);
  
               // Try to cast to SolidNode
               SolidNode* solid_node_pt = dynamic_cast<SolidNode*>(nod_pt);
  
               // Loop over coordinate directions
               for (unsigned i = 0; i < ndim_node; i++)
               {
                 // It's a SolidNode:
                 if (solid_node_pt != 0)
                 {
                   // only do it if explicitly requested!
                   if (update_all_solid_nodes)
                   {
                     solid_node_pt->x(i) = r[i];
                   }
                 }
                 // Not a SolidNode: Definitely update
                 else
                 {
                   nod_pt->x(i) = r[i];
                 }
               }
  
               // Indicate that we're done with this node, regardless of whether
               // or not it even needed updating
               has_node_been_updated[nod_pt] = true;
             } // if (!has_node_been_updated[nod_pt])
           } // if (!(nod_pt->is_hanging()))
         } // for (unsigned j=0;j<n_node;j++)
       } // if (el_pt!=0)
     } // for (unsigned e=0;e<nel;e++)
  
     // Now update the external halo nodes before we adjust the positions of the
     // hanging nodes incase any are masters of local nodes
 #ifdef OOMPH_HAS_MPI
     // Loop over all external halo nodes with other processors
     // and update them
     for (std::map<unsigned, Vector<Node*>>::iterator it =
            External_halo_node_pt.begin();
          it != External_halo_node_pt.end();
          it++)
     {
       // Get vector of external halo nodes
       Vector<Node*> ext_halo_node_pt = (*it).second;
       unsigned nnod = ext_halo_node_pt.size();
       for (unsigned j = 0; j < nnod; j++)
       {
         ext_halo_node_pt[j]->node_update();
       }
     }
 #endif
  
     // Now loop over hanging nodes and adjust their position
     // in line with their hanging node constraints
     for (unsigned long n = 0; n < n_node; n++)
     {
       Node* nod_pt = Node_pt[n];
       if (nod_pt->is_hanging())
       {
         // Get spatial dimension of node
         unsigned ndim_node = nod_pt->ndim();
  
         // Initialise
         for (unsigned i = 0; i < ndim_node; i++)
         {
           nod_pt->x(i) = 0.0;
         }
  
         // Loop over master nodes
         unsigned nmaster = nod_pt->hanging_pt()->nmaster();
         for (unsigned imaster = 0; imaster < nmaster; imaster++)
         {
           // Loop over directions
           for (unsigned i = 0; i < ndim_node; i++)
           {
             nod_pt->x(i) +=
               nod_pt->hanging_pt()->master_node_pt(imaster)->x(i) *
               nod_pt->hanging_pt()->master_weight(imaster);
           }
         }
       }
     }
  
     // Loop over all nodes again and execute auxiliary node update
     // function
     for (unsigned long n = 0; n < n_node; n++)
     {
       Node_pt[n]->perform_auxiliary_node_update_fct();
     }
  
     // Tell the user how long it's taken
     oomph_info << "Time taken to update nodal positions [sec]: "
                << TimingHelpers::timer() - t_start << std::endl;
   }

References oomph::FiniteElement::dim(), e(), element_pt(), oomph::FiniteElement::get_x(), oomph::Node::hanging_pt(), i, oomph::Node::is_hanging(), j, oomph::FiniteElement::local_coordinate_of_node(), oomph::HangInfo::master_node_pt(), oomph::HangInfo::master_weight(), n, oomph::Node::ndim(), nelement(), oomph::HangInfo::nmaster(), oomph::FiniteElement::nnode(), nnode(), oomph::FiniteElement::node_pt(), Node_pt, node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, UniformPSDSelfTest::r, s, oomph::TimingHelpers::timer(), and oomph::Node::x().

Referenced by oomph::AlgebraicCollapsibleChannelMesh< ELEMENT >::AlgebraicCollapsibleChannelMesh(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), oomph::SegregatableFSIProblem::extrapolate_solid_data(), oomph::MyAlgebraicCollapsibleChannelMesh< ELEMENT >::MyAlgebraicCollapsibleChannelMesh(), oomph::PseudoElasticChannelWithLeafletMesh< ELEMENT >::PseudoElasticChannelWithLeafletMesh(), oomph::QuarterPipeMesh< ELEMENT >::QuarterPipeMesh(), and oomph::RefineableTwoDAnnularMesh< ELEMENT >::RefineableTwoDAnnularMesh().

◆ operator=()

void oomph::Mesh::operator= ( const Mesh & )

delete

Broken assignment operator.

◆ output() [1/6]

void oomph::Mesh::output ( const std::string & output_filename )

inline

Output for all elements.

     {
       std::ofstream outfile;
       outfile.open(output_filename.c_str());
       output(outfile);
       outfile.close();
     }

References output().

◆ output() [2/6]

void oomph::Mesh::output	(	const std::string &	output_filename,
		const unsigned &	n_plot
	)

inline

Output at f(n_plot) points in each element.

     {
       std::ofstream outfile;
       outfile.open(output_filename.c_str());
       output(outfile, n_plot);
       outfile.close();
     }

References output().

◆ output() [3/6]

void oomph::Mesh::output ( FILE * file_pt )

Output for all elements (C-style output)

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function) (C style output)

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output(file_pt);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output(file_pt);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output().

◆ output() [4/6]

void oomph::Mesh::output	(	FILE *	file_pt,
		const unsigned &	n_plot
	)

Output at f(n_plot) points in each element (C-style output)

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function). Use n_plot plot points in each coordinate direction. (C style output)

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output(file_pt, n_plot);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output(file_pt, n_plot);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output().

◆ output() [5/6]

void oomph::Mesh::output ( std::ostream & outfile )

Output for all elements.

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function)

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output(outfile);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output(outfile);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output().

Referenced by ContactProblem< ELEMENT >::actions_after_adapt(), ContactProblem< ELEMENT >::actions_before_adapt(), oomph::RefineableTetgenMesh< ELEMENT >::adapt(), demo_smoothing_with_linear_elasticity(), demo_smoothing_with_nonlinear_elasticity(), demo_smoothing_with_poisson(), oomph::FSI_functions::doc_fsi(), oomph::StreamfunctionProblem::doc_solution(), oomph::NonLinearElasticitySmoothMesh< ELEMENT >::doc_solution(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution(), doc_sparse_node_update(), main(), output(), output_both_versions(), oomph::MeshAsGeomObject::position(), and oomph::TreeBasedRefineableMeshBase::refine_as_in_reference_mesh().

◆ output() [6/6]

void oomph::Mesh::output	(	std::ostream &	outfile,
		const unsigned &	n_plot
	)

Output at f(n_plot) points in each element.

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function). Use n_plot plot points in each coordinate direction.

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
  
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output(outfile, n_plot);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output(outfile, n_plot);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output().

◆ output_boundaries() [1/2]

void oomph::Mesh::output_boundaries ( const std::string & output_filename )

inline

Output the nodes on the boundaries (into separate tecplot zones). Specify filename

     {
       std::ofstream outfile;
       outfile.open(output_filename.c_str());
       output_boundaries(outfile);
       outfile.close();
     }

References output_boundaries().

◆ output_boundaries() [2/2]

void oomph::Mesh::output_boundaries ( std::ostream & outfile )

Output the nodes on the boundaries (into separate tecplot zones)

Output function for the mesh boundaries

Loop over all boundaries and dump out the coordinates of the points on the boundary (in individual tecplot zones)

   {
     // Loop over the boundaries
     unsigned num_bound = nboundary();
     for (unsigned long ibound = 0; ibound < num_bound; ibound++)
     {
       unsigned nnod = Boundary_node_pt[ibound].size();
       if (nnod > 0)
       {
         outfile << "ZONE T=\"boundary" << ibound << "\"\n";
  
         for (unsigned inod = 0; inod < nnod; inod++)
         {
           Boundary_node_pt[ibound][inod]->output(outfile);
         }
       }
     }
   }

References Boundary_node_pt, and nboundary().

Referenced by output_boundaries().

◆ output_fct() [1/2]

void oomph::Mesh::output_fct	(	std::ostream &	outfile,
		const unsigned &	n_plot,
		const double &	time,
		FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt
	)

Output a given time-dep. Vector function at f(n_plot) points in each element

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function) at time t. Use n_plot plot points in each coordinate direction.

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output_fct(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output_fct(outfile, n_plot, time, exact_soln_pt);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output_fct(outfile, n_plot, time, exact_soln_pt);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output_fct().

◆ output_fct() [2/2]

void oomph::Mesh::output_fct	(	std::ostream &	outfile,
		const unsigned &	n_plot,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt
	)

Output a given Vector function at f(n_plot) points in each element.

Output function for the mesh class

Loop over all elements and plot (i.e. execute the element's own output() function). Use n_plot plot points in each coordinate direction.

   {
     // Loop over the elements and call their output functions
     // Assign Element_pt_range
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long e = 0; e < Element_pt_range; e++)
     {
       // Try to cast to FiniteElement
       FiniteElement* el_pt = dynamic_cast<FiniteElement*>(Element_pt[e]);
       if (el_pt == 0)
       {
         oomph_info << "Can't execute output_fct(...) for non FiniteElements"
                    << std::endl;
       }
       else
       {
 #ifdef OOMPH_HAS_MPI
         if (Output_halo_elements)
 #endif
         {
           el_pt->output_fct(outfile, n_plot, exact_soln_pt);
         }
 #ifdef OOMPH_HAS_MPI
         else
         {
           if (!el_pt->is_halo())
           {
             el_pt->output_fct(outfile, n_plot, exact_soln_pt);
           }
         }
 #endif
       }
     }
   }

References e(), Element_pt, oomph::oomph_info, and oomph::FiniteElement::output_fct().

Referenced by oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution().

◆ output_fct_paraview() [1/2]

void oomph::Mesh::output_fct_paraview	(	std::ofstream &	file_out,
		const unsigned &	nplot,
		const double &	time,
		FiniteElement::UnsteadyExactSolutionFctPt	exact_soln_pt
	)		const

Output in paraview format into specified file. Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

Output in paraview format into specified file.

Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

   {
     // Change the scientific format so that E is used rather than e
     file_out.setf(std::ios_base::uppercase);
  
     // Decide how many elements there are to be plotted
     unsigned long number_of_elements = this->Element_pt.size();
  
     // Cast to finite element and return if cast fails.
     FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(0));
  
 #ifdef PARANOID
     if (fe_pt == 0)
     {
       throw OomphLibError("Recast for FiniteElement failed for element 0!\n",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
 #ifdef PARANOID
     // Check if all elements have the same number of degrees of freedom,
     // if they don't, paraview will break
     unsigned el_zero_ndof = fe_pt->nscalar_paraview();
     for (unsigned i = 1; i < number_of_elements; i++)
     {
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
       unsigned el_i_ndof = fe_pt->nscalar_paraview();
       if (el_zero_ndof != el_i_ndof)
       {
         std::stringstream error_stream;
         error_stream
           << "Element " << i << " has different number of degrees of freedom\n"
           << "than from previous elements, Paraview cannot handle this.\n"
           << "We suggest that the problem is broken up into submeshes instead."
           << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // Make variables to hold the number of nodes and elements
     unsigned long number_of_nodes = 0;
     unsigned long total_number_of_elements = 0;
  
     // Loop over all the elements to find total number of plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       number_of_nodes += fe_pt->nplot_points_paraview(nplot);
       total_number_of_elements += fe_pt->nsub_elements_paraview(nplot);
     }
  
  
     // File Declaration
     //------------------
  
     // Insert the necessary lines plus header of file, and
     // number of nodes and elements
     file_out << "<?xml version=\"1.0\"?>\n"
              << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" "
              << "byte_order=\"LittleEndian\">\n"
              << "<UnstructuredGrid>\n"
              << "<Piece NumberOfPoints=\"" << number_of_nodes
              << "\" NumberOfCells=\"" << total_number_of_elements << "\">\n";
  
  
     // Point Data
     //-----------
  
     // Check the number of degrees of freedom
     unsigned ndof = fe_pt->nscalar_paraview();
  
     // Point data is going in here
     file_out << "<PointData ";
  
     // Insert just the first scalar name, since paraview reads everything
     // else after that as being of the same type. Get information from
     // first element.
     file_out << "Scalars=\"" << fe_pt->scalar_name_paraview(0) << "\">\n";
  
     // Loop over i scalar fields and j number of elements
     for (unsigned i = 0; i < ndof; i++)
     {
       file_out << "<DataArray type=\"Float32\" "
                << "Name=\"" << fe_pt->scalar_name_paraview(i) << "\" "
                << "format=\"ascii\""
                << ">\n";
  
       for (unsigned j = 0; j < number_of_elements; j++)
       {
         // Cast to FiniteElement and (in paranoid mode) check
         // if cast has failed.
         FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(j));
  
 #ifdef PARANOID
         if (fe_pt == 0)
         {
           std::stringstream error_stream;
           error_stream << "Recast for element " << j << " failed" << std::endl;
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         fe_pt->scalar_value_fct_paraview(
           file_out, i, nplot, time, exact_soln_pt);
       }
  
       // Close of the DataArray
       file_out << "</DataArray>\n";
     }
  
     // Close off the PointData set
     file_out << "</PointData>\n";
  
  
     // Geometric Points
     //------------------
  
     file_out << "<Points>\n"
              << "<DataArray type=\"Float32\""
              << " NumberOfComponents=\""
              // This always has to be 3 for an unstructured grid
              << 3 << "\" "
              << "format=\"ascii\">\n";
  
     // Loop over all the elements to print their plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->output_paraview(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Points>\n";
  
  
     // Cells
     //-------
  
     file_out
       << "<Cells>\n"
       << "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
  
     // Make counter for keeping track of all the local elements,
     // because Paraview requires global coordinates
     unsigned counter = 0;
  
     // Write connectivity with the local elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_output_offset_information(file_out, nplot, counter);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"Int32\" "
              << "Name=\"offsets\" format=\"ascii\">\n";
  
     // Make variable that holds the current offset number
     unsigned offset_sum = 0;
  
     // Write the offset for the specific elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_offsets(file_out, nplot, offset_sum);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"UInt8\" Name=\"types\">\n";
  
     // Loop over all elements to get the type that they have
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->write_paraview_type(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Cells>\n";
  
  
     // File Closure
     //-------------
     file_out << "</Piece>\n"
              << "</UnstructuredGrid>\n"
              << "</VTKFile>";
   }

◆ output_fct_paraview() [2/2]

void oomph::Mesh::output_fct_paraview	(	std::ofstream &	file_out,
		const unsigned &	nplot,
		FiniteElement::SteadyExactSolutionFctPt	exact_soln_pt
	)		const

Output in paraview format into specified file. Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

Output in paraview format into specified file.

Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

   {
     // Change the scientific format so that E is used rather than e
     file_out.setf(std::ios_base::uppercase);
  
     // Decide how many elements there are to be plotted
     unsigned long number_of_elements = this->Element_pt.size();
  
     // Cast to finite element and return if cast fails.
     FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(0));
  
 #ifdef PARANOID
     if (fe_pt == 0)
     {
       throw OomphLibError("Recast for FiniteElement failed for element 0!\n",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
 #ifdef PARANOID
     // Check if all elements have the same number of degrees of freedom,
     // if they don't, paraview will break
     unsigned el_zero_ndof = fe_pt->nscalar_paraview();
     for (unsigned i = 1; i < number_of_elements; i++)
     {
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
       unsigned el_i_ndof = fe_pt->nscalar_paraview();
       if (el_zero_ndof != el_i_ndof)
       {
         std::stringstream error_stream;
         error_stream
           << "Element " << i << " has different number of degrees of freedom\n"
           << "than from previous elements, Paraview cannot handle this.\n"
           << "We suggest that the problem is broken up into submeshes instead."
           << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // Make variables to hold the number of nodes and elements
     unsigned long number_of_nodes = 0;
     unsigned long total_number_of_elements = 0;
  
     // Loop over all the elements to find total number of plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       number_of_nodes += fe_pt->nplot_points_paraview(nplot);
       total_number_of_elements += fe_pt->nsub_elements_paraview(nplot);
     }
  
  
     // File Declaration
     //------------------
  
     // Insert the necessary lines plus header of file, and
     // number of nodes and elements
     file_out << "<?xml version=\"1.0\"?>\n"
              << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" "
              << "byte_order=\"LittleEndian\">\n"
              << "<UnstructuredGrid>\n"
              << "<Piece NumberOfPoints=\"" << number_of_nodes
              << "\" NumberOfCells=\"" << total_number_of_elements << "\">\n";
  
  
     // Point Data
     //-----------
  
     // Check the number of degrees of freedom
     unsigned ndof = fe_pt->nscalar_paraview();
  
     // Point data is going in here
     file_out << "<PointData ";
  
     // Insert just the first scalar name, since paraview reads everything
     // else after that as being of the same type. Get information from
     // first element.
     file_out << "Scalars=\"" << fe_pt->scalar_name_paraview(0) << "\">\n";
  
     // Loop over i scalar fields and j number of elements
     for (unsigned i = 0; i < ndof; i++)
     {
       file_out << "<DataArray type=\"Float32\" "
                << "Name=\"" << fe_pt->scalar_name_paraview(i) << "\" "
                << "format=\"ascii\""
                << ">\n";
  
       for (unsigned j = 0; j < number_of_elements; j++)
       {
         // Cast to FiniteElement and (in paranoid mode) check
         // if cast has failed.
         FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(j));
  
 #ifdef PARANOID
         if (fe_pt == 0)
         {
           std::stringstream error_stream;
           error_stream << "Recast for element " << j << " failed" << std::endl;
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         fe_pt->scalar_value_fct_paraview(file_out, i, nplot, exact_soln_pt);
       }
  
       // Close of the DataArray
       file_out << "</DataArray>\n";
     }
  
     // Close off the PointData set
     file_out << "</PointData>\n";
  
  
     // Geometric Points
     //------------------
  
     file_out << "<Points>\n"
              << "<DataArray type=\"Float32\""
              << " NumberOfComponents=\""
              // This always has to be 3 for an unstructured grid
              << 3 << "\" "
              << "format=\"ascii\">\n";
  
     // Loop over all the elements to print their plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->output_paraview(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Points>\n";
  
  
     // Cells
     //-------
  
     file_out
       << "<Cells>\n"
       << "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
  
     // Make counter for keeping track of all the local elements,
     // because Paraview requires global coordinates
     unsigned counter = 0;
  
     // Write connectivity with the local elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_output_offset_information(file_out, nplot, counter);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"Int32\" "
              << "Name=\"offsets\" format=\"ascii\">\n";
  
     // Make variable that holds the current offset number
     unsigned offset_sum = 0;
  
     // Write the offset for the specific elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_offsets(file_out, nplot, offset_sum);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"UInt8\" Name=\"types\">\n";
  
     // Loop over all elements to get the type that they have
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->write_paraview_type(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Cells>\n";
  
  
     // File Closure
     //-------------
     file_out << "</Piece>\n"
              << "</UnstructuredGrid>\n"
              << "</VTKFile>";
   }

◆ output_paraview()

void oomph::Mesh::output_paraview	(	std::ofstream &	file_out,
		const unsigned &	nplot
	)		const

Output in paraview format into specified file. Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

Output in paraview format into specified file.

Breaks up each element into sub-elements for plotting purposes. We assume that all elements are of the same type (fct will break (in paranoid mode) if paraview output fcts of the elements are inconsistent).

   {
     // Change the scientific format so that E is used rather than e
     file_out.setf(std::ios_base::uppercase);
  
     // Decide how many elements there are to be plotted
     unsigned long number_of_elements = this->Element_pt.size();
  
     // Cast to finite element and return if cast fails.
     FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(0));
  
 #ifdef PARANOID
     if (fe_pt == 0)
     {
       throw OomphLibError("Recast for FiniteElement failed for element 0!\n",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
  
 #ifdef PARANOID
     // Check if all elements have the same number of degrees of freedom,
     // if they don't, paraview will break
     unsigned el_zero_ndof = fe_pt->nscalar_paraview();
     for (unsigned i = 1; i < number_of_elements; i++)
     {
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
       unsigned el_i_ndof = fe_pt->nscalar_paraview();
       if (el_zero_ndof != el_i_ndof)
       {
         std::stringstream error_stream;
         error_stream
           << "Element " << i << " has different number of degrees of freedom\n"
           << "than from previous elements, Paraview cannot handle this.\n"
           << "We suggest that the problem is broken up into submeshes instead."
           << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
  
     // Make variables to hold the number of nodes and elements
     unsigned long number_of_nodes = 0;
     unsigned long total_number_of_elements = 0;
  
     // Loop over all the elements to find total number of plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       number_of_nodes += fe_pt->nplot_points_paraview(nplot);
       total_number_of_elements += fe_pt->nsub_elements_paraview(nplot);
     }
  
  
     // File Declaration
     //------------------
  
     // Insert the necessary lines plus header of file, and
     // number of nodes and elements
     file_out << "<?xml version=\"1.0\"?>\n"
              << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" "
              << "byte_order=\"LittleEndian\">\n"
              << "<UnstructuredGrid>\n"
              << "<Piece NumberOfPoints=\"" << number_of_nodes
              << "\" NumberOfCells=\"" << total_number_of_elements << "\">\n";
  
  
     // Point Data
     //-----------
  
     // Check the number of degrees of freedom
     unsigned ndof = fe_pt->nscalar_paraview();
  
     // Point data is going in here
     file_out << "<PointData ";
  
     // Insert just the first scalar name, since paraview reads everything
     // else after that as being of the same type. Get information from
     // first element.
     file_out << "Scalars=\"" << fe_pt->scalar_name_paraview(0) << "\">\n";
  
     // Loop over i scalar fields and j number of elements
     for (unsigned i = 0; i < ndof; i++)
     {
       file_out << "<DataArray type=\"Float32\" "
                << "Name=\"" << fe_pt->scalar_name_paraview(i) << "\" "
                << "format=\"ascii\""
                << ">\n";
  
       for (unsigned j = 0; j < number_of_elements; j++)
       {
         // Cast to FiniteElement and (in paranoid mode) check
         // if cast has failed.
         FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(j));
  
 #ifdef PARANOID
         if (fe_pt == 0)
         {
           std::stringstream error_stream;
           error_stream << "Recast for element " << j << " failed" << std::endl;
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         fe_pt->scalar_value_paraview(file_out, i, nplot);
       }
  
       // Close of the DataArray
       file_out << "</DataArray>\n";
     }
  
     // Close off the PointData set
     file_out << "</PointData>\n";
  
  
     // Geometric Points
     //------------------
  
     file_out << "<Points>\n"
              << "<DataArray type=\"Float32\""
              << " NumberOfComponents=\""
              // This always has to be 3 for an unstructured grid
              << 3 << "\" "
              << "format=\"ascii\">\n";
  
     // Loop over all the elements to print their plot points
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->output_paraview(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Points>\n";
  
  
     // Cells
     //-------
  
     file_out
       << "<Cells>\n"
       << "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
  
     // Make counter for keeping track of all the local elements,
     // because Paraview requires global coordinates
     unsigned counter = 0;
  
     // Write connectivity with the local elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " faild" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_output_offset_information(file_out, nplot, counter);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"Int32\" "
              << "Name=\"offsets\" format=\"ascii\">\n";
  
     // Make variable that holds the current offset number
     unsigned offset_sum = 0;
  
     // Write the offset for the specific elements
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       fe_pt->write_paraview_offsets(file_out, nplot, offset_sum);
     }
  
     file_out << "</DataArray>\n"
              << "<DataArray type=\"UInt8\" Name=\"types\">\n";
  
     // Loop over all elements to get the type that they have
     for (unsigned i = 0; i < number_of_elements; i++)
     {
       // Cast to FiniteElement and (in paranoid mode) check
       // if cast has failed.
       FiniteElement* fe_pt = dynamic_cast<FiniteElement*>(element_pt(i));
  
 #ifdef PARANOID
       if (fe_pt == 0)
       {
         std::stringstream error_stream;
         error_stream << "Recast for element " << i << " failed" << std::endl;
         throw OomphLibError(
           error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       fe_pt->write_paraview_type(file_out, nplot);
     }
  
     file_out << "</DataArray>\n"
              << "</Cells>\n";
  
  
     // File Closure
     //-------------
     file_out << "</Piece>\n"
              << "</UnstructuredGrid>\n"
              << "</VTKFile>";
   }

◆ prune_dead_nodes()

Vector< Node * > oomph::Mesh::prune_dead_nodes ( )

Prune nodes. Nodes that have been marked as obsolete are removed from the mesh (and its boundary-node scheme). Returns vector of pointers to deleted nodes.

Nodes that have been marked as obsolete are removed from the mesh and the its boundaries. Returns vector of pointers to deleted nodes.

   {
     // Only copy the 'live' nodes across to new mesh
     //----------------------------------------------
  
     // New Vector of pointers to nodes
     Vector<Node*> new_node_pt;
     Vector<Node*> deleted_node_pt;
  
     // Loop over all nodes in mesh
     unsigned long n_node = nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // If the node still exists: Copy across
       if (!(Node_pt[n]->is_obsolete()))
       {
         new_node_pt.push_back(Node_pt[n]);
       }
       // Otherwise the Node is gone:
       // Delete it for good if it does not lie on a boundary
       // (if it lives on a boundary we have to remove it from
       // the boundary lookup schemes below)
       else
       {
         if (!(Node_pt[n]->is_on_boundary()))
         {
           deleted_node_pt.push_back(Node_pt[n]);
           delete Node_pt[n];
           Node_pt[n] = 0;
         }
       }
     }
  
     // Now update old vector by setting it equal to the new vector
     Node_pt = new_node_pt;
  
  
     // Boundaries
     //-----------
  
     // Only copy the 'live' nodes into new boundary node arrays
     //---------------------------------------------------------
     // Loop over the boundaries
     unsigned num_bound = nboundary();
     for (unsigned ibound = 0; ibound < num_bound; ibound++)
     {
       // New Vector of pointers to existent boundary nodes
       Vector<Node*> new_boundary_node_pt;
  
       // Loop over the boundary nodes
       unsigned long Nboundary_node = Boundary_node_pt[ibound].size();
  
       // Reserve contiguous memory for new vector of pointers
       // Must be equal in size to the number of nodes or less
       new_boundary_node_pt.reserve(Nboundary_node);
  
       for (unsigned long n = 0; n < Nboundary_node; n++)
       {
         // If node still exists: Copy across
         if (!(Boundary_node_pt[ibound][n]->is_obsolete()))
         {
           new_boundary_node_pt.push_back(Boundary_node_pt[ibound][n]);
         }
         // Otherwise Node is gone: Delete it for good
         else
         {
           // The node may lie on multiple boundaries, so remove the node
           // from the current boundary
           Boundary_node_pt[ibound][n]->remove_from_boundary(ibound);
  
           // Now if the node is no longer on any boundaries, delete it
           if (!Boundary_node_pt[ibound][n]->is_on_boundary())
           {
             deleted_node_pt.push_back(
               dynamic_cast<Node*>(Boundary_node_pt[ibound][n]));
  
             delete Boundary_node_pt[ibound][n];
           }
         }
       }
  
       // Update the old vector by setting it equal to the new vector
       Boundary_node_pt[ibound] = new_boundary_node_pt;
  
     } // End of loop over boundaries
  
     // Tell us who you deleted
     return deleted_node_pt;
   }

References Boundary_node_pt, n, nboundary(), nnode(), and Node_pt.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::PMLCornerQuadMesh< ELEMENT >::PMLCornerQuadMesh(), and oomph::PMLQuadMesh< ELEMENT >::PMLQuadMesh().

◆ read()

void oomph::Mesh::read ( std::ifstream & restart_file )

virtual

Read solution from restart file.

Try to cast to elastic node

Reimplemented in oomph::SpineMesh, and oomph::PerturbedSpineMesh.

   {
     std::string input_string;
  
     // Reorder the nodes within the mesh's node vector
     // to establish a standard ordering regardless of the sequence
     // of mesh refinements etc
     this->reorder_nodes();
  
     // Read nodes
  
     // Find number of nodes
     unsigned long n_node = this->nnode();
  
     // Read line up to termination sign
     getline(restart_file, input_string, '#');
  
     // Ignore rest of line
     restart_file.ignore(80, '\n');
  
     // Check # of nodes:
     unsigned long check_n_node = atoi(input_string.c_str());
     if (check_n_node != n_node)
     {
       std::ostringstream error_stream;
       error_stream << "The number of nodes allocated " << n_node
                    << " is not the same as specified in the restart file "
                    << check_n_node << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Loop over the nodes
     for (unsigned long n = 0; n < n_node; n++)
     {
       SolidNode* el_node_pt = dynamic_cast<SolidNode*>(this->node_pt(n));
       if (el_node_pt != 0)
       {
         el_node_pt->read(restart_file);
       }
       else
       {
         this->node_pt(n)->read(restart_file);
       }
     }
  
     // Read internal data of elements:
     //--------------------------------
     // Loop over elements and deal with internal data
     unsigned n_element = this->nelement();
     for (unsigned e = 0; e < n_element; e++)
     {
       GeneralisedElement* el_pt = this->element_pt(e);
       unsigned n_internal = el_pt->ninternal_data();
       if (n_internal > 0)
       {
         // Read line up to termination sign
         getline(restart_file, input_string, '#');
  
         // Ignore rest of line
         restart_file.ignore(80, '\n');
  
         // Check # of internals :
         unsigned long check_n_internal = atoi(input_string.c_str());
         if (check_n_internal != n_internal)
         {
           std::ostringstream error_stream;
           error_stream << "The number of internal data  " << n_internal
                        << " is not the same as specified in the restart file "
                        << check_n_internal << std::endl;
  
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
  
         for (unsigned i = 0; i < n_internal; i++)
         {
           el_pt->internal_data_pt(i)->read(restart_file);
         }
       }
     }
   }

References e(), element_pt(), i, oomph::GeneralisedElement::internal_data_pt(), n, nelement(), oomph::GeneralisedElement::ninternal_data(), nnode(), node_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::read(), oomph::Node::read(), oomph::SolidNode::read(), reorder_nodes(), and oomph::Global_string_for_annotation::string().

Referenced by oomph::PerturbedSpineMesh::read(), oomph::SpineMesh::read(), and oomph::Problem::read().

◆ remove_boundary_node()

void oomph::Mesh::remove_boundary_node	(	const unsigned &	b,
		Node *const &	node_pt
	)

Remove a node from the boundary b.

Remove the node node_pt from the b-th boundary of the mesh This function also removes the information from the Node itself

   {
     // Find the location of the node in the boundary
     Vector<Node*>::iterator it = std::find(
       Boundary_node_pt[b].begin(), Boundary_node_pt[b].end(), node_pt);
     // If the node is on this boundary
     if (it != Boundary_node_pt[b].end())
     {
       // Remove the node from the mesh's list of boundary nodes
       Boundary_node_pt[b].erase(it);
       // Now remove the node's boundary information
       node_pt->remove_from_boundary(b);
     }
     // If not do nothing
   }

References b, Boundary_node_pt, Eigen::placeholders::end, node_pt(), and oomph::Node::remove_from_boundary().

Referenced by delete_all_external_storage(), and ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh().

◆ remove_boundary_nodes() [1/2]

void oomph::Mesh::remove_boundary_nodes ( )

Clear all pointers to boundary nodes.

Remove all information about mesh boundaries.

   {
     // Loop over each boundary call remove_boundary_nodes
     unsigned n_bound = Boundary_node_pt.size();
     for (unsigned b = 0; b < n_bound; b++)
     {
       remove_boundary_nodes(b);
     }
     // Clear the storage
     Boundary_node_pt.clear();
   }

References b, and Boundary_node_pt.

Referenced by STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::change_boundaries(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), and oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh().

◆ remove_boundary_nodes() [2/2]

void oomph::Mesh::remove_boundary_nodes ( const unsigned & b )

Remove all information about nodes stored on the b-th boundary of the mesh

Remove the information about nodes stored on the b-th boundary of the mesh

   {
     // Loop over all the nodes on the boundary and call
     // their remove_from_boundary function
     unsigned n_boundary_node = Boundary_node_pt[b].size();
     for (unsigned n = 0; n < n_boundary_node; n++)
     {
       boundary_node_pt(b, n)->remove_from_boundary(b);
     }
     // Clear the storage
     Boundary_node_pt[b].clear();
   }

References b, Boundary_node_pt, boundary_node_pt(), n, and oomph::Node::remove_from_boundary().

◆ reorder_nodes()

void oomph::Mesh::reorder_nodes ( const bool & use_old_ordering = true )

virtual

Re-order nodes in the order in which they appear in elements – can be overloaded for more efficient re-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(reordering, use_old_ordering);
  
     // Get the number of nodes in the mesh
     unsigned n_node = 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
       node_pt(i) = reordering[i];
     }
   } // End of reorder_nodes

References get_node_reordering(), i, nnode(), and node_pt().

Referenced by oomph::TreeBasedRefineableMeshBase::adapt(), oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::TreeBasedRefineableMeshBase::p_adapt(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), and read().

◆ reset_boundary_element_info()

virtual void oomph::Mesh::reset_boundary_element_info	(	Vector< unsigned > &	ntmp_boundary_elements,
		Vector< Vector< unsigned >> &	ntmp_boundary_elements_in_region,
		Vector< FiniteElement * > &	deleted_elements
	)

inlinevirtual

Virtual function to perform the reset boundary elements info rutines.

Reimplemented in oomph::TriangleMeshBase.

     {
       std::ostringstream error_stream;
       error_stream << "Empty default reset boundary element info function"
                    << "called.\n";
       error_stream << "This should be overloaded in a specific "
                    << "TriangleMeshBase\n";
       throw OomphLibError(error_stream.str(),
                           "Mesh::reset_boundary_element_info()",
                           OOMPH_EXCEPTION_LOCATION);
     }

References OOMPH_EXCEPTION_LOCATION.

◆ scale_mesh()

virtual void oomph::Mesh::scale_mesh ( const double & factor )

inlinevirtual

Scale all nodal coordinates by given factor. Virtual so it can be overloaded in SolidMesh class where it also re-assigns the Lagrangian coordinates.

Reimplemented in oomph::SolidMesh.

     {
       unsigned nnod = this->nnode();
       unsigned dim = this->node_pt(0)->ndim();
       for (unsigned j = 0; j < nnod; j++)
       {
         Node* nod_pt = this->node_pt(j);
         for (unsigned i = 0; i < dim; i++)
         {
           nod_pt->x(i) *= factor;
         }
       }
     }

References i, j, oomph::Node::ndim(), nnode(), node_pt(), and oomph::Node::x().

Referenced by oomph::SolidMesh::scale_mesh().

◆ self_test()

unsigned oomph::Mesh::self_test ( )

Self-test: Check elements and nodes. Return 0 for OK.

   {
     // Initialise
     bool passed = true;
  
     // Check the mesh for repeated nodes (issues its own error message)
     if (0 != check_for_repeated_nodes()) passed = false;
  
     // hierher -- re-enable once problem with Hermite elements has been
     // resolved.
     //  // Check if there are any inverted elements
     //  bool mesh_has_inverted_elements=false;
     //  check_inverted_elements(mesh_has_inverted_elements);
     //  if (mesh_has_inverted_elements)
     //   {
     //    passed=false;
     //    oomph_info << "\n ERROR: Mesh has inverted elements\n"
     //               << "     Run Mesh::check_inverted_elements(...) with"
     //               << "     with output stream to find out which elements are"
     //               << "     inverted.\n";
     //   }
  
     // Loop over the elements, check for duplicates and do self test
     std::set<GeneralisedElement*> element_set_pt;
     unsigned long Element_pt_range = Element_pt.size();
     for (unsigned long i = 0; i < Element_pt_range; i++)
     {
       if (Element_pt[i]->self_test() != 0)
       {
         passed = false;
         oomph_info << "\n ERROR: Failed Element::self_test() for element i="
                    << i << std::endl;
       }
       // Add to set (which ignores duplicates):
       element_set_pt.insert(Element_pt[i]);
     }
  
     // Check for duplicates:
     if (element_set_pt.size() != Element_pt_range)
     {
       oomph_info << "ERROR:  " << Element_pt_range - element_set_pt.size()
                  << " duplicate elements were encountered in mesh!"
                  << std::endl;
       passed = false;
     }
  
  
     // Loop over the nodes, check for duplicates and do self test
     std::set<Node*> node_set_pt;
     unsigned long Node_pt_range = Node_pt.size();
     for (unsigned long i = 0; i < Node_pt_range; i++)
     {
       if (Node_pt[i]->self_test() != 0)
       {
         passed = false;
         oomph_info << "\n ERROR: Failed Node::self_test() for node i=" << i
                    << std::endl;
       }
       // Add to set (which ignores duplicates):
       node_set_pt.insert(Node_pt[i]);
     }
  
     // Check for duplicates:
     if (node_set_pt.size() != Node_pt_range)
     {
       oomph_info << "ERROR:  " << Node_pt_range - node_set_pt.size()
                  << " duplicate nodes were encountered in mesh!" << std::endl;
       passed = false;
     }
  
     // Return verdict
     if (passed)
     {
       return 0;
     }
     else
     {
       return 1;
     }
   }

References check_for_repeated_nodes(), Element_pt, i, Node_pt, and oomph::oomph_info.

Referenced by oomph::RefineableEighthSphereMesh< ELEMENT >::RefineableEighthSphereMesh(), oomph::RefineableFullCircleMesh< ELEMENT >::RefineableFullCircleMesh(), oomph::RefineableQuarterTubeMesh< ELEMENT >::RefineableQuarterTubeMesh(), oomph::RefineableTubeMesh< ELEMENT >::RefineableTubeMesh(), and oomph::AlgebraicMesh::self_test().

◆ set_consistent_pinned_values_for_continuation()

void oomph::Mesh::set_consistent_pinned_values_for_continuation ( ContinuationStorageScheme *const & continuation_storage_pt )

Set consistent values for pinned data in continuation.

Set the values of auxilliary data used in continuation problems when the data is pinned.

   {
     // Loop over the nodes
     const unsigned long n_node = this->nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       continuation_storage_pt->set_consistent_pinned_values(this->Node_pt[n]);
       continuation_storage_pt->set_consistent_pinned_positions(
         this->Node_pt[n]);
     }
  
     // Loop over the elements
     const unsigned long n_element = this->nelement();
     for (unsigned long e = 0; e < n_element; e++)
     {
       // Cache pointer to the elemnet
       GeneralisedElement* const elem_pt = this->element_pt(e);
       // Find the number of internal dofs
       const unsigned n_internal = elem_pt->ninternal_data();
  
       // Loop over internal dofs and test the data
       for (unsigned j = 0; j < n_internal; j++)
       {
         continuation_storage_pt->set_consistent_pinned_values(
           elem_pt->internal_data_pt(j));
       }
     }
   }

References e(), element_pt(), oomph::GeneralisedElement::internal_data_pt(), j, n, nelement(), oomph::GeneralisedElement::ninternal_data(), nnode(), Node_pt, oomph::ContinuationStorageScheme::set_consistent_pinned_positions(), and oomph::ContinuationStorageScheme::set_consistent_pinned_values().

Referenced by oomph::Problem::set_consistent_pinned_values_for_continuation().

◆ set_elemental_internal_time_stepper()

void oomph::Mesh::set_elemental_internal_time_stepper	(	TimeStepper *const &	time_stepper_pt,
		const bool &	preserve_existing_data
	)

Set the timestepper associated with the internal data stored within elements in the meah

Set the time stepper associated with all internal data stored in the elements in the mesh

   {
     // Loop over the elements
     const unsigned long n_element = this->nelement();
     for (unsigned long e = 0; e < n_element; e++)
     {
       // Find the number of internal dofs
       const unsigned n_internal = this->element_pt(e)->ninternal_data();
  
       // Loop over internal dofs and set the timestepper
       for (unsigned j = 0; j < n_internal; j++)
       {
         this->element_pt(e)->internal_data_pt(j)->set_time_stepper(
           time_stepper_pt, preserve_existing_data);
       }
     }
   }

References e(), element_pt(), j, and nelement().

Referenced by set_nodal_and_elemental_time_stepper().

◆ set_mesh_level_time_stepper()

void oomph::Mesh::set_mesh_level_time_stepper	(	TimeStepper *const &	time_stepper_pt,
		const bool &	preserve_existing_data
	)

virtual

Function that can be used to set any additional timestepper data stored at the Mesh (as opposed to nodal and elemental) levels. This is virtual so that it can be overloaded in the appropriate Meshes. Examples include the SpineMeshes and adaptive triangle and tet meshes

Virtual function that should be overloaded if the mesh has any mesh level storage of the timestepper

Reimplemented in oomph::TriangleMesh< ELEMENT >, oomph::TriangleMesh< FLUID_ELEMENT >, oomph::TriangleMesh< SOLID_ELEMENT >, oomph::TriangleMesh< HELMHOLTZ_ELEMENT >, oomph::TriangleMesh< POROELASTICITY_ELEMENT >, oomph::TriangleMesh< ELASTICITY_ELEMENT >, oomph::TriangleMesh< oomph::TPoissonElement< 2, 2 > >, oomph::TetgenMesh< ELEMENT >, and oomph::SpineMesh.

   {
 #ifdef PARANOID
     if (!Suppress_warning_about_empty_mesh_level_time_stepper_function)
     {
       std::ostringstream warning_stream;
       warning_stream
         << "Empty set_mesh_level_time_stepper() has been called.\n"
         << "This function needs to be overloaded to reset any (pointers to) \n"
         << "timesteppers for meshes that store timesteppers in locations "
            "other\n"
         << "than the Nodes or Elements;\n"
         << "e.g. SpineMeshes have SpineData with timesteppers,\n"
         << "Triangle and TetMeshes store the timestepper for use in "
            "adaptivity.\n\n\n";
       warning_stream
         << "If you are solving a continuation or bifurcation detecion\n"
         << "problem and strange things are happening, then check that\n"
         << "you don't need to overload this function for your mesh."
         << "\n This warning can be suppressed by setting:\n"
         << "Mesh::Suppress_warning_about_empty_mesh_level_time_stepper_"
            "function=true"
         << std::endl;
       OomphLibWarning(
         warning_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
   }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Suppress_warning_about_empty_mesh_level_time_stepper_function.

Referenced by oomph::Problem::set_timestepper_for_all_data().

◆ set_nboundary()

void oomph::Mesh::set_nboundary ( const unsigned & nbound )

inline

Set the number of boundaries in the mesh.

     {
       Boundary_node_pt.resize(nbound);
       Boundary_coordinate_exists.resize(nbound, false);
     }

References Boundary_coordinate_exists, and Boundary_node_pt.

Referenced by STSpineMesh< ELEMENT, INTERFACE_ELEMENT >::add_mesh(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), CombTipSpineMesh< ELEMENT, INTERFACE_ELEMENT >::change_boundaries(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), copy_boundary_node_data_from_nodes(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), oomph::SimpleCubicScaffoldTetMesh::SimpleCubicScaffoldTetMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), oomph::TetgenScaffoldMesh::TetgenScaffoldMesh(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), and oomph::TubeMesh< ELEMENT >::TubeMesh().

◆ set_nodal_and_elemental_time_stepper()

void oomph::Mesh::set_nodal_and_elemental_time_stepper	(	TimeStepper *const &	time_stepper_pt,
		const bool &	preserve_existing_data
	)

inline

Set the timestepper associated with all nodal and elemental data stored in the mesh.

     {
       this->set_nodal_time_stepper(time_stepper_pt, preserve_existing_data);
       this->set_elemental_internal_time_stepper(time_stepper_pt,
                                                 preserve_existing_data);
     }

References set_elemental_internal_time_stepper(), and set_nodal_time_stepper().

Referenced by oomph::Problem::set_timestepper_for_all_data().

◆ set_nodal_time_stepper()

void oomph::Mesh::set_nodal_time_stepper	(	TimeStepper *const &	time_stepper_pt,
		const bool &	preserve_existing_data
	)

Set the timestepper associated with the nodal data in the mesh.

Set the time stepper associated with all the nodal data in the problem

   {
     // Loop over the nodes
     const unsigned long n_node = this->nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // Set the timestepper associated with each node
       this->Node_pt[n]->set_time_stepper(time_stepper_pt,
                                          preserve_existing_data);
       this->Node_pt[n]->set_position_time_stepper(time_stepper_pt,
                                                   preserve_existing_data);
     }
   }

References n, nnode(), and Node_pt.

Referenced by set_nodal_and_elemental_time_stepper().

◆ setup_boundary_element_info() [1/2]

virtual void oomph::Mesh::setup_boundary_element_info ( )

inlinevirtual

Interface for function that is used to setup the boundary information (Empty virtual function – implement this for specific Mesh classes)

Reimplemented in oomph::HermiteQuadMesh< ELEMENT >, oomph::TriangleMeshBase, oomph::TetMeshBase, oomph::QuadMeshBase, oomph::LineMeshBase, oomph::BrickMeshBase, and oomph::RefineableSolidCubicMesh< ELEMENT >.

275 {}

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::RefineableRectangleWithHoleAndAnnularRegionMesh< ELEMENT >::RefineableRectangleWithHoleAndAnnularRegionMesh(), oomph::RefineableRectangleWithHoleMesh< ELEMENT >::RefineableRectangleWithHoleMesh(), TFaceTestProblem< ELEMENT >::TFaceTestProblem(), and TriangleFaceTestProblem< ELEMENT >::TriangleFaceTestProblem().

◆ setup_boundary_element_info() [2/2]

virtual void oomph::Mesh::setup_boundary_element_info ( std::ostream & outfile )

inlinevirtual

Setup lookup schemes which establish whic elements are located next to mesh's boundaries. Doc in outfile (if it's open). (Empty virtual function – implement this for specific Mesh classes)

Reimplemented in oomph::HermiteQuadMesh< ELEMENT >, oomph::TriangleMeshBase, oomph::TetMeshBase, oomph::QuadMeshBase, oomph::LineMeshBase, oomph::BrickMeshBase, and oomph::RefineableSolidCubicMesh< ELEMENT >.

281 {}

◆ shift_time_values()

void oomph::Mesh::shift_time_values ( )

Shift time-dependent data along for next timestep: Deal with nodal Data/positions and the element's internal Data

Shift time-dependent data along for next timestep: Again this is achieved by looping over all data and calling the functions defined in each data object's timestepper.

   {
     // Loop over the elements which shift their internal data
     // via their own timesteppers
     const unsigned long Nelement = nelement();
     for (unsigned long e = 0; e < Nelement; e++)
     {
       // Find the number of internal dofs
       const unsigned Ninternal = element_pt(e)->ninternal_data();
       // Loop over internal dofs and shift the time values
       // using the internals data's timestepper
       for (unsigned j = 0; j < Ninternal; j++)
       {
         element_pt(e)
           ->internal_data_pt(j)
           ->time_stepper_pt()
           ->shift_time_values(element_pt(e)->internal_data_pt(j));
       }
     }
  
     // Loop over the nodes
     const unsigned long n_node = nnode();
     for (unsigned long n = 0; n < n_node; n++)
     {
       // Shift the Data associated with the nodes with the Node's own
       // timestepper
       Node_pt[n]->time_stepper_pt()->shift_time_values(Node_pt[n]);
       // Push history of nodal positions back
       Node_pt[n]->position_time_stepper_pt()->shift_time_positions(Node_pt[n]);
     }
   }

References e(), element_pt(), j, n, nelement(), nnode(), and Node_pt.

Referenced by oomph::Problem::shift_time_values().

◆ total_size()

double oomph::Mesh::total_size ( )

inline

Determine the sum of all "sizes" of the FiniteElements in the mesh (non-FiniteElements are ignored). This gives the length/area/volume occupied by the mesh

     {
       double size = 0.0;
       unsigned nel = nelement();
       for (unsigned e = 0; e < nel; e++)
       {
         FiniteElement* fe_pt = finite_element_pt(e);
         if (fe_pt != 0)
         {
           size += fe_pt->size();
         }
       }
       return size;
     }

References e(), finite_element_pt(), nelement(), size, and oomph::FiniteElement::size().

Friends And Related Function Documentation

◆ Problem

friend class Problem

friend

Problem is a friend.

Member Data Documentation

◆ Boundary_coordinate_exists

std::vector<bool> oomph::Mesh::Boundary_coordinate_exists

protected

Vector of boolean data that indicates whether the boundary coordinates have been set for the boundary

Referenced by boundary_coordinate_exists(), oomph::ChannelWithLeafletMesh< ELEMENT >::ChannelWithLeafletMesh(), oomph::CollapsibleChannelMesh< ELEMENT >::CollapsibleChannelMesh(), doc_boundary_coordinates(), oomph::ElasticRefineableRectangularQuadMesh< ELEMENT >::ElasticRefineableRectangularQuadMesh(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), oomph::FSIDrivenCavityMesh< ELEMENT >::FSIDrivenCavityMesh(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterPipeMesh< ELEMENT >::QuarterPipeMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RefineableSolidCubicMesh< ELEMENT >::RefineableSolidCubicMesh(), set_nboundary(), oomph::TetMeshBase::setup_boundary_coordinates(), oomph::UnstructuredTwoDMeshGeometryBase::setup_boundary_coordinates(), oomph::TetMeshBase::snap_nodes_onto_geometric_objects(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), and oomph::TubeMesh< ELEMENT >::TubeMesh().

◆ Boundary_element_pt

Vector<Vector<FiniteElement*> > oomph::Mesh::Boundary_element_pt

protected

Vector of Vector of pointers to elements on the boundaries: Boundary_element_pt(b,e)

Referenced by boundary_element_pt(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), nboundary_element(), oomph::BrickMeshBase::setup_boundary_element_info(), oomph::LineMeshBase::setup_boundary_element_info(), oomph::QuadMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::setup_boundary_element_info(), oomph::TriangleMeshBase::setup_boundary_element_info(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ Boundary_node_pt

Vector<Vector<Node*> > oomph::Mesh::Boundary_node_pt

protected

Vector of Vector of pointers to nodes on the boundaries: Boundary_node_pt(b,n). Note that this is private to force the use of the add_boundary_node() function, which ensures that the reverse look-up schemes for the nodes are set up.

Referenced by add_boundary_node(), boundary_node_pt(), copy_boundary_node_data_from_nodes(), ElasticTwoLayerMesh< ELEMENT >::ElasticTwoLayerMesh(), merge_meshes(), nboundary(), nboundary_node(), output_boundaries(), prune_dead_nodes(), remove_boundary_node(), remove_boundary_nodes(), and set_nboundary().

◆ Default_TimeStepper

Steady< 0 > oomph::Mesh::Default_TimeStepper

static

The Steady Timestepper.

Default Steady Timestepper, to be used in default arguments to Mesh constructors

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), MortaringHelpers::PointElementWithExternalElement::PointElementWithExternalElement(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup().

◆ Element_pt

Vector<GeneralisedElement*> oomph::Mesh::Element_pt

protected

Vector of pointers to generalised elements.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), add_element_pt(), oomph::jh_mesh< ELEMENT >::assign_fluid_element_vector(), oomph::streamfunction_mesh::assign_fluid_element_vector(), assign_global_eqn_numbers(), assign_local_eqn_numbers(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), compute_error(), compute_norm(), convert_to_boundary_node(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), describe_dofs(), describe_local_dofs(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), oomph::PerturbedSpineMesh::element_node_pt(), oomph::SolidMesh::element_node_pt(), oomph::SpineMesh::element_node_pt(), element_pt(), finite_element_pt(), flush_element_storage(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), oomph::jh_mesh< ELEMENT >::make_flux_element(), oomph::jh_mesh< ELEMENT >::make_traction_elements(), oomph::streamfunction_mesh::make_traction_elements(), merge_meshes(), nelement(), output(), output_fct(), output_fct_paraview(), output_paraview(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), oomph::jh_mesh< ELEMENT >::remove_traction_elements(), oomph::streamfunction_mesh::remove_traction_elements(), self_test(), oomph::SimpleCubicScaffoldTetMesh::SimpleCubicScaffoldTetMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), oomph::TetMeshBase::split_elements_in_corners(), oomph::TetgenScaffoldMesh::TetgenScaffoldMesh(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), oomph::TubeMesh< ELEMENT >::TubeMesh(), and ~Mesh().

◆ Face_index_at_boundary

Vector<Vector<int> > oomph::Mesh::Face_index_at_boundary

protected

For the e-th finite element on boundary b, this is the index of the face that lies along that boundary

Referenced by oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), face_index_at_boundary(), oomph::BrickMeshBase::setup_boundary_element_info(), oomph::LineMeshBase::setup_boundary_element_info(), oomph::QuadMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::setup_boundary_element_info(), oomph::TriangleMeshBase::setup_boundary_element_info(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ Lookup_for_elements_next_boundary_is_setup

bool oomph::Mesh::Lookup_for_elements_next_boundary_is_setup

protected

Flag to indicate that the lookup schemes for elements that are adjacent to the boundaries has been set up.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), boundary_element_pt(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), face_index_at_boundary(), merge_meshes(), Mesh(), nboundary_element(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::BrickMeshBase::setup_boundary_element_info(), oomph::LineMeshBase::setup_boundary_element_info(), oomph::QuadMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::setup_boundary_element_info(), oomph::TriangleMeshBase::setup_boundary_element_info(), oomph::TetMeshBase::split_elements_in_corners(), and oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh().

◆ Node_pt

Vector<Node*> oomph::Mesh::Node_pt

protected

Vector of pointers to nodes.

Referenced by add_node_pt(), assign_global_eqn_numbers(), assign_initial_values_impulsive(), oomph::BackupMeshForProjection< GEOMETRIC_ELEMENT >::BackupMeshForProjection(), oomph::GmshTetMesh< ELEMENT >::build_from_scaffold(), calculate_predictions(), oomph::TriangleScaffoldMesh::check_mesh_integrity(), convert_to_boundary_node(), oomph::GmshTetScaffoldMesh::create_mesh_from_msh_file(), delete_all_external_storage(), describe_dofs(), does_pointer_correspond_to_mesh_data(), oomph::EighthSphereMesh< ELEMENT >::EighthSphereMesh(), flush_node_storage(), oomph::FullCircleMesh< ELEMENT >::FullCircleMesh(), oomph::GeompackQuadScaffoldMesh::GeompackQuadScaffoldMesh(), merge_meshes(), nnode(), oomph::PerturbedSpineMesh::node_pt(), oomph::AlgebraicMesh::node_pt(), node_pt(), oomph::SolidMesh::node_pt(), oomph::SpineMesh::node_pt(), oomph::PerturbedSpineMesh::node_update(), node_update(), oomph::SpineMesh::node_update(), prune_dead_nodes(), oomph::QuarterCircleSectorMesh< ELEMENT >::QuarterCircleSectorMesh(), oomph::QuarterTubeMesh< ELEMENT >::QuarterTubeMesh(), oomph::RectangleWithHoleMesh< ELEMENT >::RectangleWithHoleMesh(), self_test(), set_consistent_pinned_values_for_continuation(), oomph::SolidMesh::set_lagrangian_nodal_coordinates(), set_nodal_time_stepper(), shift_time_values(), oomph::SimpleCubicScaffoldTetMesh::SimpleCubicScaffoldTetMesh(), oomph::SimpleRectangularTriMesh< ELEMENT >::SimpleRectangularTriMesh(), oomph::Refineable_r_mesh< ELEMENT >::stretch_mesh(), oomph::TetgenScaffoldMesh::TetgenScaffoldMesh(), oomph::ThinLayerBrickOnTetMesh< ELEMENT >::ThinLayerBrickOnTetMesh(), oomph::TriangleScaffoldMesh::TriangleScaffoldMesh(), oomph::TubeMesh< ELEMENT >::TubeMesh(), oomph::WomersleyMesh< WOMERSLEY_ELEMENT >::WomersleyMesh(), and ~Mesh().

◆ Suppress_warning_about_empty_mesh_level_time_stepper_function

bool oomph::Mesh::Suppress_warning_about_empty_mesh_level_time_stepper_function

static

Initial value:

=

false

Static boolean flag to control warning about mesh level timesteppers.

Boolean used to control warning about empty mesh level timestepper function

Referenced by set_mesh_level_time_stepper().

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

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ SteadyExactSolutionFctPt

◆ UnsteadyExactSolutionFctPt

Constructor & Destructor Documentation

◆ Mesh() [1/3]

◆ Mesh() [2/3]

◆ Mesh() [3/3]

◆ ~Mesh()

Member Function Documentation

◆ add_boundary_node()

◆ add_element_pt()

◆ add_node_pt()

◆ assign_global_eqn_numbers()

◆ assign_initial_values_impulsive()

◆ assign_local_eqn_numbers()

◆ boundary_coordinate_exists()

◆ boundary_element_pt()

◆ boundary_node_pt() [1/2]

◆ boundary_node_pt() [2/2]

◆ build_face_mesh()

◆ calculate_predictions()

◆ check_for_repeated_nodes()

◆ check_inverted_elements() [1/2]

◆ check_inverted_elements() [2/2]

◆ communicator_pt()

◆ compute_error() [1/8]

◆ compute_error() [2/8]

◆ compute_error() [3/8]

◆ compute_error() [4/8]

◆ compute_error() [5/8]

◆ compute_error() [6/8]

◆ compute_error() [7/8]

◆ compute_error() [8/8]

◆ compute_norm() [1/2]

◆ compute_norm() [2/2]

◆ convert_to_boundary_node() [1/2]

◆ convert_to_boundary_node() [2/2]

◆ copy_boundary_node_data_from_nodes()

◆ delete_all_external_storage()

◆ describe_dofs()

◆ describe_local_dofs()

◆ doc_boundary_coordinates()

◆ does_pointer_correspond_to_mesh_data()

◆ dump() [1/2]

◆ dump() [2/2]

◆ element_pt() [1/4]

◆ element_pt() [2/4]

◆ element_pt() [3/4]

◆ element_pt() [4/4]

◆ elemental_dimension()

◆ face_index_at_boundary()

◆ finite_element_pt()

◆ flush_element_and_node_storage()

◆ flush_element_storage()

◆ flush_node_storage()

◆ get_node_reordering()

◆ get_some_non_boundary_node()

◆ is_mesh_distributed()

◆ max_and_min_element_size()

◆ merge_meshes()

◆ nboundary()

◆ nboundary_element()

◆ nboundary_node()

◆ ndof_types()

◆ nelement()

◆ nnode()

◆ nodal_dimension()

◆ node_pt() [1/2]

◆ node_pt() [2/2]

◆ node_update()

◆ operator=()

◆ output() [1/6]

◆ output() [2/6]