#include <triangle_scaffold_mesh.h>

Inheritance diagram for oomph::TriangleScaffoldMesh:

Public Member Functions
	TriangleScaffoldMesh ()
	Empty constructor. More...

	TriangleScaffoldMesh (const std::string &node_file_name, const std::string &element_file_name, const std::string &poly_file_name)
	Constructor: Pass the filenames of the triangle files. More...

	TriangleScaffoldMesh (const TriangleScaffoldMesh &)=delete
	Broken copy constructor. More...

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

	~TriangleScaffoldMesh ()
	Empty destructor. More...

unsigned	global_node_number (const unsigned &i)

unsigned	edge_boundary (const unsigned &e, const unsigned &i) const

unsigned	nglobal_edge ()
	Return the number of internal edges. More...

unsigned	edge_index (const unsigned &e, const unsigned &i) const

double	element_attribute (const unsigned &e) const
	Return the attribute of the element e. More...

Vector< Vector< double > > &	internal_point ()
	Vectors of hole centre coordinates. More...

Public Member Functions inherited from oomph::Mesh
	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...

Protected Member Functions
void	check_mesh_integrity ()

Protected Member Functions inherited from oomph::Mesh
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
unsigned	Nglobal_edge
	Number of internal edges. More...

Vector< unsigned >	Global_node
	Storage for global node numbers listed element-by-element. More...

Vector< Vector< unsigned > >	Edge_boundary

Vector< Vector< unsigned > >	Edge_index
	Vector of vectors containing the global edge index of. More...

Vector< double >	Element_attribute
	Vector of double attributes for each element. More...

Vector< Vector< double > >	Hole_centre
	Vectors of hole centre coordinates. More...

Protected Attributes inherited from oomph::Mesh
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

Additional Inherited Members
Public Types inherited from oomph::Mesh
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)

Static Public Attributes inherited from oomph::Mesh
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...

Detailed Description

Triangle Mesh that is based on input files generated by the triangle mesh generator Triangle.

Constructor & Destructor Documentation

◆ TriangleScaffoldMesh() [1/3]

oomph::TriangleScaffoldMesh::TriangleScaffoldMesh ( )

inline

Empty constructor.

54 {}

◆ TriangleScaffoldMesh() [2/3]

oomph::TriangleScaffoldMesh::TriangleScaffoldMesh	(	const std::string &	node_file_name,
		const std::string &	ele_file_name,
		const std::string &	poly_file_name
	)

Constructor: Pass the filenames of the triangle files.

Constructor: Pass the filenames of the triangle files The assumptions are that the nodes have been assigned boundary information which is used in the nodal construction to ensure that BoundaryNodes are indeed constructed when necessary. Additional boundary information is added from the segment boundaries.

   {
     // Process element file
     //---------------------
     std::ifstream element_file(ele_file_name.c_str(), std::ios_base::in);
  
     // Check that the file actually opened correctly
     if (!element_file.is_open())
     {
       std::string error_msg("Failed to open element file: ");
       error_msg += "\"" + ele_file_name + "\".";
       throw OomphLibError(
         error_msg, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Number of elements
     unsigned n_element;
     element_file >> n_element;
  
     // Number of nodes per element
     unsigned n_local_node;
     element_file >> n_local_node;
     if (n_local_node != 3)
     {
       std::ostringstream error_stream;
       error_stream
         << "Triangle should only be used to generate 3-noded triangles!\n"
         << "Your triangle input file, contains data for " << n_local_node
         << "-noded triangles" << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Dummy nodal attributes
     unsigned dummy_attribute;
  
     // Element attributes may be used if we have internal boundaries
     Element_attribute.resize(n_element, 0.0);
  
     // Dummy storage for element numbers
     unsigned dummy_element_number;
  
     // Resize stoorage for global node numbers listed element-by-element
     Global_node.resize(n_element * n_local_node);
  
 #ifdef PARANOID
     std::map<unsigned, bool> global_node_done;
 #endif
  
     // Initialise counter
     unsigned k = 0;
  
     // Are attributes specified?
     unsigned attribute_flag;
     element_file >> attribute_flag;
  
     // Read global node numbers for all elements
     if (attribute_flag == 0)
     {
       for (unsigned i = 0; i < n_element; i++)
       {
         element_file >> dummy_element_number;
         for (unsigned j = 0; j < n_local_node; j++)
         {
           element_file >> Global_node[k];
 #ifdef PARANOID
           global_node_done[Global_node[k] - 1] = true;
 #endif
           k++;
         }
       }
     }
     else
     {
       for (unsigned i = 0; i < n_element; i++)
       {
         element_file >> dummy_element_number;
         for (unsigned j = 0; j < n_local_node; j++)
         {
           element_file >> Global_node[k];
 #ifdef PARANOID
           global_node_done[Global_node[k] - 1] = true;
 #endif
           k++;
         }
         element_file >> Element_attribute[i];
       }
     }
     element_file.close();
  
 #ifdef PARANOID
     // Determine if the node numbering starts at 0 or 1 (triangle can do
     // either depending on input arguments). We can't (currently) handle
     // 0-based indexing so throw an error if it is being used.
     if (*std::min_element(Global_node.begin(), Global_node.end()) != 1)
     {
       std::string err("Triangle is using 0-based indexing, ");
       err += "however the oomph-lib interface can only handle 1-based indexing "
              "in Triangle.\n";
       err +=
         "This is likely to be due to the input file using 0-based indexing.";
       err += "Alternatively you may have specified the -z flag when running "
              "Triangle.";
       throw OomphLibError(
         err, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Resize the Element vector
     Element_pt.resize(n_element);
  
     // Process node file
     // -----------------
     std::ifstream node_file(node_file_name.c_str(), std::ios_base::in);
  
     // Check that the file actually opened correctly
     if (!node_file.is_open())
     {
       std::string error_msg("Failed to open node file: ");
       error_msg += "\"" + node_file_name + "\".";
       throw OomphLibError(
         error_msg, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Read number of nodes
     unsigned n_node;
     node_file >> n_node;
  
     // Create a vector of boolean so as not to create the same node twice
     std::vector<bool> done(n_node, false);
  
     // Resize the Node vector
     Node_pt.resize(n_node);
  
     // Spatial dimension of nodes
     unsigned dimension;
     node_file >> dimension;
  
 #ifdef PARANOID
     if (dimension != 2)
     {
       throw OomphLibError("The dimension must be 2\n",
                           OOMPH_CURRENT_FUNCTION,
                           OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Flag for attributes
     node_file >> attribute_flag;
  
     // Flag for boundary markers
     unsigned boundary_markers_flag;
     node_file >> boundary_markers_flag;
  
     // Dummy for node number
     unsigned dummy_node_number;
  
     // Create storage for nodal posititions and boundary markers
     Vector<double> x_node(n_node);
     Vector<double> y_node(n_node);
     Vector<unsigned> bound(n_node);
  
     // Check if there are attributes
     if (attribute_flag == 0)
     {
       if (boundary_markers_flag == 1)
       {
         for (unsigned i = 0; i < n_node; i++)
         {
           node_file >> dummy_node_number;
           node_file >> x_node[i];
           node_file >> y_node[i];
           node_file >> bound[i];
         }
         node_file.close();
       }
       else
       {
         for (unsigned i = 0; i < n_node; i++)
         {
           node_file >> dummy_node_number;
           node_file >> x_node[i];
           node_file >> y_node[i];
           bound[i] = 0;
         }
         node_file.close();
       }
     }
     else
     {
       if (boundary_markers_flag == 1)
       {
         for (unsigned i = 0; i < n_node; i++)
         {
           node_file >> dummy_node_number;
           node_file >> x_node[i];
           node_file >> y_node[i];
           node_file >> dummy_attribute;
           node_file >> bound[i];
         }
         node_file.close();
       }
       else
       {
         for (unsigned i = 0; i < n_node; i++)
         {
           node_file >> dummy_node_number;
           node_file >> x_node[i];
           node_file >> y_node[i];
           node_file >> dummy_attribute;
           bound[i] = 0;
         }
         node_file.close();
       }
     } // end
  
  
     // Determine highest boundary index
     // --------------------------------
     unsigned n_bound = 0;
     if (boundary_markers_flag == 1)
     {
       n_bound = bound[0];
       for (unsigned i = 1; i < n_node; i++)
       {
         if (bound[i] > n_bound)
         {
           n_bound = bound[i];
         }
       }
     }
  
     // Process poly file to extract edges
     //-----------------------------------
  
     // Open poly file
     std::ifstream poly_file(poly_file_name.c_str(), std::ios_base::in);
  
     // Check that the file actually opened correctly
     if (!poly_file.is_open())
     {
       std::string error_msg("Failed to open poly file: ");
       error_msg += "\"" + poly_file_name + "\".";
       throw OomphLibError(
         error_msg, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Number of nodes in poly file
     unsigned n_node_poly;
     poly_file >> n_node_poly;
  
     // Dimension
     poly_file >> dimension;
  
     // Attribute flag
     poly_file >> attribute_flag;
  
     // Boundary markers flag
     poly_file >> boundary_markers_flag;
  
  
     // Ignore node information: Note: No, we can't extract the
     // actual nodes themselves from here!
     unsigned dummy;
     if (n_node_poly > 0)
     {
       if (attribute_flag == 0)
       {
         if (boundary_markers_flag == 1)
         {
           for (unsigned i = 0; i < n_node_poly; i++)
           {
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
           }
         }
         else
         {
           for (unsigned i = 0; i < n_node_poly; i++)
           {
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
           }
         }
       }
       else
       {
         if (boundary_markers_flag == 1)
         {
           for (unsigned i = 0; i < n_node_poly; i++)
           {
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
           }
         }
         else
         {
           for (unsigned i = 0; i < n_node_poly; i++)
           {
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
             poly_file >> dummy;
           }
         }
       }
     }
  
     // Now extract the segment information
     // Segements are lines that lie on boundaries of the domain
     //----------------------------------------------------------
  
     // Number of segments
     unsigned n_segment;
     poly_file >> n_segment;
  
     // Boundary marker flag
     poly_file >> boundary_markers_flag;
  
     // Storage for the global node numbers (in the triangle 1-based
     // numbering scheme!) of the first and second node in each segment
     Vector<unsigned> first_node(n_segment);
     Vector<unsigned> second_node(n_segment);
  
     // Storage for the boundary marker for each segment
     Vector<unsigned> segment_boundary(n_segment);
  
     // Dummy for global segment number
     unsigned dummy_segment_number;
  
     // Storage for the edges associated with each node. Nodes are indexed
     // using the Triangle 1-based index which is why there is a +1 here.
     Vector<std::set<unsigned>> node_on_edges(n_node + 1);
  
     // Extract information for each segment
     for (unsigned i = 0; i < n_segment; i++)
     {
       poly_file >> dummy_segment_number;
       poly_file >> first_node[i];
       poly_file >> second_node[i];
       poly_file >> segment_boundary[i];
       // Check that we don't have a higher segment boundary number
       if (segment_boundary[i] > n_bound)
       {
         n_bound = segment_boundary[i];
       }
       // Add the segment index to each node
       node_on_edges[first_node[i]].insert(i);
       node_on_edges[second_node[i]].insert(i);
     }
  
     // Extract hole center information
     unsigned nhole = 0;
     poly_file >> nhole;
     if (nhole != 0)
     {
       Hole_centre.resize(nhole);
  
       // Dummy for hole number
       unsigned dummy_hole;
       // Loop over the holes to get centre coords
       for (unsigned ihole = 0; ihole < nhole; ihole++)
       {
         Hole_centre[ihole].resize(2);
  
         // Read the centre value
         poly_file >> dummy_hole;
         poly_file >> Hole_centre[ihole][0];
         poly_file >> Hole_centre[ihole][1];
       }
     }
     else
     {
       Hole_centre.resize(0);
     }
     poly_file.close();
  
     // Set the number of boundaries
     if (n_bound > 0)
     {
       this->set_nboundary(n_bound);
     }
  
  
     // Create the elements
     //--------------------
  
     // Counter for nodes in the vector that lists
     // the global node numbers of the elements' local nodes
     unsigned counter = 0;
     for (unsigned e = 0; e < n_element; e++)
     {
       Element_pt[e] = new TElement<2, 2>;
       for (unsigned j = 0; j < n_local_node; j++)
       {
         unsigned global_node_number = Global_node[counter];
         if (done[global_node_number - 1] == false) //... -1 because node number
         // begins at 1 in triangle
         {
           // If we are on the boundary
           if ((boundary_markers_flag == 1) &&
               (bound[global_node_number - 1] > 0))
           {
             // Construct a boundary node
             Node_pt[global_node_number - 1] =
               finite_element_pt(e)->construct_boundary_node(j);
             // Add to the boundary node look-up scheme
             add_boundary_node(bound[global_node_number - 1] - 1,
                               Node_pt[global_node_number - 1]);
           }
           // Otherwise make an ordinary node
           else
           {
             Node_pt[global_node_number - 1] =
               finite_element_pt(e)->construct_node(j);
           }
           done[global_node_number - 1] = true;
           Node_pt[global_node_number - 1]->x(0) =
             x_node[global_node_number - 1];
           Node_pt[global_node_number - 1]->x(1) =
             y_node[global_node_number - 1];
         }
         else
         {
           finite_element_pt(e)->node_pt(j) = Node_pt[global_node_number - 1];
         }
         counter++;
       }
     }
  
     // Resize the "matrix" that stores the boundary id for each
     // edge in each element.
     Edge_boundary.resize(n_element);
     Edge_index.resize(n_element);
  
     // Storage for the global node numbers (in triangle's 1-based
     // numbering scheme) for the zero-th, 1st, and 2nd node in each
     // triangle.
     unsigned glob_num[3] = {0, 0, 0};
  
     // 0-based index used to construct a global index-based lookup scheme
     // for each edge that will be used to uniquely construct mid-side
     // nodes.
     // The segments (edges that lie on boundaries) have already
     // been added to the scheme, so we start with the number of segments.
     Nglobal_edge = n_segment;
  
     // Loop over the elements
     for (unsigned e = 0; e < n_element; e++)
     {
       // Each element has three edges
       Edge_boundary[e].resize(3);
       Edge_index[e].resize(3);
       // By default each edge is NOT on a boundary
       for (unsigned i = 0; i < 3; i++)
       {
         Edge_boundary[e][i] = 0;
       }
  
       // Read out the global node numbers from the triangle data structure
       const unsigned element_offset = e * n_local_node;
       for (unsigned i = 0; i < 3; i++)
       {
         glob_num[i] = Global_node[element_offset + i];
       }
  
       // Now we know the global node numbers of the elements' three nodes
       // in triangle's 1-based numbering.
  
       // Determine whether any of the elements edges have already been
       // allocated an index. This may be because they are on boundaries
       // (segments) or because they have already occured.
       // The global index for the i-th edge will be stored in edge_index[i]
       for (unsigned i = 0; i < 3; i++)
       {
         std::vector<unsigned> local_edge_index;
  
         // Find the common global edge index for the nodes on
         // the i-th element edge (note the use of moular arithmetic here)
         std::set_intersection(node_on_edges[glob_num[i]].begin(),
                               node_on_edges[glob_num[i]].end(),
                               node_on_edges[glob_num[(i + 1) % 3]].begin(),
                               node_on_edges[glob_num[(i + 1) % 3]].end(),
                               std::insert_iterator<std::vector<unsigned>>(
                                 local_edge_index, local_edge_index.begin()));
  
         // If the nodes share more than one global edge index, then
         // we have a problem
         if (local_edge_index.size() > 1)
         {
           throw OomphLibError(
             "Nodes in scaffold mesh share more than one global edge",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
  
         // If the element's edge is not already allocated, the intersection
         // will be empty
         if (local_edge_index.size() == 0)
         {
           // Allocate the next global index
           Edge_index[e][i] = Nglobal_edge;
           // Associate the new edge index with the nodes
           node_on_edges[glob_num[i]].insert(Nglobal_edge);
           node_on_edges[glob_num[(i + 1) % 3]].insert(Nglobal_edge);
           // Increment the global edge index
           ++Nglobal_edge;
         }
         // Otherwise we already have an edge
         else if (local_edge_index.size() == 1)
         {
           // Set the edge index
           Edge_index[e][i] = local_edge_index[0];
           // Allocate the boundary index, if it is a segment
           if (local_edge_index[0] < n_segment)
           {
             Edge_boundary[e][i] = segment_boundary[local_edge_index[0]];
             // Add the nodes to the boundary look-up scheme in
             // oomph-lib (0-based) index
             add_boundary_node(segment_boundary[local_edge_index[0]] - 1,
                               Node_pt[glob_num[i] - 1]);
             add_boundary_node(segment_boundary[local_edge_index[0]] - 1,
                               Node_pt[glob_num[(i + 1) % 3] - 1]);
           }
         }
       }
     }
  
 #ifdef PARANOID
  
     std::ostringstream error_stream;
     bool broken = false;
     unsigned nnod = nnode();
     error_stream << "Checking presence of " << nnod << " global nodes\n";
     for (unsigned j = 0; j < nnod; j++)
     {
       if (!global_node_done[j])
       {
         error_stream << "Global node " << j
                      << " was not listed in *.ele file\n";
         broken = true;
       }
     }
     if (broken)
     {
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Check things and throw if mesh is broken...
     check_mesh_integrity();
 #endif
   }

References oomph::Mesh::add_boundary_node(), check_mesh_integrity(), oomph::FiniteElement::construct_boundary_node(), oomph::FiniteElement::construct_node(), e(), Edge_boundary, Edge_index, Element_attribute, oomph::Mesh::Element_pt, Eigen::placeholders::end, oomph::Mesh::finite_element_pt(), Global_node, global_node_number(), Hole_centre, i, insert(), j, k, Nglobal_edge, oomph::Mesh::nnode(), oomph::FiniteElement::node_pt(), oomph::Mesh::Node_pt, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Mesh::set_nboundary(), and oomph::Global_string_for_annotation::string().

◆ TriangleScaffoldMesh() [3/3]

oomph::TriangleScaffoldMesh::TriangleScaffoldMesh ( const TriangleScaffoldMesh & )

delete

Broken copy constructor.

◆ ~TriangleScaffoldMesh()

oomph::TriangleScaffoldMesh::~TriangleScaffoldMesh ( )

inline

Empty destructor.

75 {}

Member Function Documentation

◆ check_mesh_integrity()

void oomph::TriangleScaffoldMesh::check_mesh_integrity ( )

protected

Check mesh integrity – performs some internal consistency checks and throws error if violated.

   {
     // Check that all nodes are attached to elements
     std::map<Node*, bool> done;
  
     // Number of nodes per element
     unsigned nnod_el = finite_element_pt(0)->nnode();
  
     // Loop over elements to visit their nodes
     unsigned nelem = nelement();
     for (unsigned e = 0; e < nelem; e++)
     {
       // Loop over all nodes in element
       for (unsigned j = 0; j < nnod_el; j++)
       {
         // Pointer to node in the scaffold mesh
         Node* node_pt = finite_element_pt(e)->node_pt(j);
  
         done[node_pt] = true;
       }
     }
  
     // Now check if all nodes have been visited
     std::ostringstream error_stream;
     bool broken = false;
     unsigned nnod = nnode();
     for (unsigned j = 0; j < nnod; j++)
     {
       if (!done[Node_pt[j]])
       {
         error_stream << "Scaffold node " << j
                      << " does not seem to be attached to any element";
         broken = true;
       }
     }
     if (broken)
     {
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References e(), oomph::Mesh::finite_element_pt(), j, oomph::Mesh::nelement(), oomph::FiniteElement::nnode(), oomph::Mesh::nnode(), oomph::FiniteElement::node_pt(), oomph::Mesh::Node_pt, oomph::Mesh::node_pt(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by TriangleScaffoldMesh().

◆ edge_boundary()

unsigned oomph::TriangleScaffoldMesh::edge_boundary	(	const unsigned &	e,
		const unsigned &	i
	)		const

inline

Return the boundary id of the i-th edge in the e-th element: This is zero-based as in triangle. Zero means the edge is not on a boundary. Postive numbers identify the boundary. Will be reduced by one to identify the oomph-lib boundary.

     {
       return Edge_boundary[e][i];
     }

References e(), Edge_boundary, and i.

Referenced by oomph::QuadFromTriangleMesh< ELEMENT >::build_from_scaffold().

◆ edge_index()

unsigned oomph::TriangleScaffoldMesh::edge_index	(	const unsigned &	e,
		const unsigned &	i
	)		const

inline

Return the global index of the i-th edge in the e-th element: The global index starts from zero

     {
       return Edge_index[e][i];
     }

References e(), Edge_index, and i.

◆ element_attribute()

double oomph::TriangleScaffoldMesh::element_attribute ( const unsigned & e ) const

inline

Return the attribute of the element e.

     {
       return Element_attribute[e];
     }

References e(), and Element_attribute.

◆ global_node_number()

unsigned oomph::TriangleScaffoldMesh::global_node_number ( const unsigned & i )

inline

Return the global node of each local node listed element-by-element e*n_local_node + n_local Note that the node numbers are indexed from 1

     {
       return Global_node[i];
     }

References Global_node, and i.

Referenced by TriangleScaffoldMesh().

◆ internal_point()

Vector<Vector<double> >& oomph::TriangleScaffoldMesh::internal_point ( )

inline

Vectors of hole centre coordinates.

     {
       return Hole_centre;
     }

References Hole_centre.

◆ nglobal_edge()

unsigned oomph::TriangleScaffoldMesh::nglobal_edge ( )

inline

Return the number of internal edges.

     {
       return Nglobal_edge;
     }

References Nglobal_edge.

◆ operator=()

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

delete

Broken assignment operator.

Member Data Documentation

◆ Edge_boundary

Vector<Vector<unsigned> > oomph::TriangleScaffoldMesh::Edge_boundary

protected

Vector of vectors containing the boundary ids of the elements' edges

Referenced by edge_boundary(), and TriangleScaffoldMesh().

◆ Edge_index

Vector<Vector<unsigned> > oomph::TriangleScaffoldMesh::Edge_index

protected

Vector of vectors containing the global edge index of.

Referenced by edge_index(), and TriangleScaffoldMesh().

◆ Element_attribute

Vector<double> oomph::TriangleScaffoldMesh::Element_attribute

protected

Vector of double attributes for each element.

Referenced by element_attribute(), and TriangleScaffoldMesh().

◆ Global_node

Vector<unsigned> oomph::TriangleScaffoldMesh::Global_node

protected

Storage for global node numbers listed element-by-element.

Referenced by global_node_number(), and TriangleScaffoldMesh().

◆ Hole_centre

Vector<Vector<double> > oomph::TriangleScaffoldMesh::Hole_centre

protected

Vectors of hole centre coordinates.

Referenced by internal_point(), and TriangleScaffoldMesh().

◆ Nglobal_edge

unsigned oomph::TriangleScaffoldMesh::Nglobal_edge

protected

Number of internal edges.

Referenced by nglobal_edge(), and TriangleScaffoldMesh().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TriangleScaffoldMesh() [1/3]

◆ TriangleScaffoldMesh() [2/3]

◆ TriangleScaffoldMesh() [3/3]

◆ ~TriangleScaffoldMesh()

Member Function Documentation

◆ check_mesh_integrity()

◆ edge_boundary()

◆ edge_index()

◆ element_attribute()

◆ global_node_number()

◆ internal_point()

◆ nglobal_edge()

◆ operator=()

Member Data Documentation

◆ Edge_boundary

◆ Edge_index

◆ Element_attribute

◆ Global_node

◆ Hole_centre

◆ Nglobal_edge