libMesh::TetGenIO Class Reference

#include <tetgen_io.h>

Inheritance diagram for libMesh::TetGenIO:

Public Member Functions

 TetGenIO (MeshBase &mesh, MeshData *mesh_data=NULL)
 
 TetGenIO (const MeshBase &mesh, MeshData *mesh_data=NULL)
 
virtual void read (const std::string &)
 
virtual void write (const std::string &)
 
virtual void write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=NULL)
 
virtual void write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
 
unsigned int & ascii_precision ()
 

Public Attributes

std::vector< std::vector< Real > > node_attributes
 
std::vector< std::vector< Real > > element_attributes
 

Protected Member Functions

MeshBasemesh ()
 
void skip_comment_lines (std::istream &in, const char comment_start)
 
const MeshBasemesh () const
 

Protected Attributes

std::vector< bool > elems_of_dimension
 
const bool _is_parallel_format
 

Private Member Functions

void read_nodes_and_elem (std::istream &node_stream, std::istream &ele_stream)
 
void node_in (std::istream &node_stream)
 
void element_in (std::istream &ele_stream)
 

Private Attributes

std::map< dof_id_type,
dof_id_type
_assign_nodes
 
dof_id_type _num_nodes
 
dof_id_type _num_elements
 
MeshData_mesh_data
 

Detailed Description

This class implements reading and writing meshes in the TetGen format. Format description: cf. TetGen home page.

Author
Benjamin S. Kirk, 2004

Definition at line 50 of file tetgen_io.h.

Constructor & Destructor Documentation

libMesh::TetGenIO::TetGenIO ( MeshBase mesh,
MeshData mesh_data = NULL 
)
inlineexplicit

Constructor. Takes a writeable reference to a mesh object. This is the constructor required to read a mesh.

Definition at line 156 of file tetgen_io.h.

156  :
157  MeshInput<MeshBase> (mesh),
158  MeshOutput<MeshBase>(mesh),
159  _mesh_data(mesh_data)
160 {
161 }
libMesh::TetGenIO::TetGenIO ( const MeshBase mesh,
MeshData mesh_data = NULL 
)
inlineexplicit

Constructor. Takes a read-only reference to a mesh object. This is the constructor required to write a mesh.

Definition at line 166 of file tetgen_io.h.

166  :
167  MeshOutput<MeshBase>(mesh),
168  _mesh_data(mesh_data)
169 {
170 }

Member Function Documentation

unsigned int& libMesh::MeshOutput< MeshBase >::ascii_precision ( )
inherited

Return/set the precision to use when writing ASCII files.

By default we use numeric_limits<Real>::digits10 + 2, which should be enough to write out to ASCII and get the exact same Real back when reading in.

Referenced by libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

void libMesh::TetGenIO::element_in ( std::istream &  ele_stream)
private

Method reads elements and stores them in vector<Elem*> elements in the same order as they come in. Within TetGenMeshInterface, element labels are ignored, but MeshData takes care of such things (if active).

Definition at line 189 of file tetgen_io.C.

References _assign_nodes, _mesh_data, _num_elements, libMesh::MeshData::add_foreign_elem_id(), element_attributes, libMesh::err, libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), n_nodes, and libMesh::resize().

Referenced by read_nodes_and_elem().

190 {
191  // Check input buffer
192  libmesh_assert (ele_stream.good());
193 
194  // Get a reference to the mesh
195  MeshBase& mesh = MeshInput<MeshBase>::mesh();
196 
197  // Read the elements from the ele_stream (*.ele file).
198  unsigned int element_lab=0, n_nodes=0, nAttri=0;
199 
200  ele_stream >> _num_elements // Read the number of tetrahedrons from the stream.
201  >> n_nodes // Read the number of nodes per tetrahedron from the stream (defaults to 4).
202  >> nAttri; // Read the number of attributes from stream.
203 
204  // Vector that assigns element nodes to their correct position.
205  // TetGen is normaly 0-based
206  // (right now this is strictly not necessary since it is the identity map,
207  // but in the future TetGen could change their numbering scheme.)
208  static const unsigned int assign_elm_nodes[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
209 
210  // If present, make room for element attributes to be stored.
211  this->element_attributes.resize(nAttri);
212  for (unsigned i=0; i<nAttri; ++i)
214 
215  for (dof_id_type i=0; i<_num_elements; i++)
216  {
217  libmesh_assert (ele_stream.good());
218 
219  // TetGen only supports Tet4 and Tet10 elements.
220  Elem* elem;
221 
222  if (n_nodes==4)
223  elem = new Tet4;
224 
225  else if (n_nodes==10)
226  elem = new Tet10;
227 
228  else
229  {
230  libMesh::err << "Elements with " << n_nodes
231  << " nodes are not supported in the LibMesh tetgen module\n";
232  libmesh_error();
233  }
234  elem->set_id(i);
235 
236  mesh.add_elem (elem);
237 
238  libmesh_assert(elem);
239  libmesh_assert_equal_to (elem->n_nodes(), n_nodes);
240 
241  // Read the element label
242  ele_stream >> element_lab;
243 
244  // Add the element to the mesh &
245  // tell the MeshData object the foreign element id
246  if (this->_mesh_data != NULL)
247  this->_mesh_data->add_foreign_elem_id (elem, element_lab);
248 
249  // Read node labels
250  for (dof_id_type j=0; j<n_nodes; j++)
251  {
252  dof_id_type node_label;
253  ele_stream >> node_label;
254 
255  // Assign node to element
256  elem->set_node(assign_elm_nodes[j]) =
257  mesh.node_ptr(_assign_nodes[node_label]);
258  }
259 
260  // Read and store attributes from the stream.
261  for (unsigned int j=0; j<nAttri; j++)
262  ele_stream >> this->element_attributes[j][i];
263  }
264 }
MeshBase & libMesh::MeshInput< MeshBase >::mesh ( )
protectedinherited

Returns the object as a writeable reference.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::VTKIO::cells_to_vtk(), element_in(), libMesh::UNVIO::element_in(), libMesh::UNVIO::element_out(), node_in(), libMesh::UNVIO::node_in(), libMesh::UNVIO::node_out(), libMesh::VTKIO::nodes_to_vtk(), libMesh::ExodusII_IO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::VTKIO::read(), libMesh::LegacyXdrIO::read_ascii(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_connectivity(), libMesh::UCDIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodes(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_bcs(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::CheckpointIO::read_subdomain_names(), write(), libMesh::ExodusII_IO::write(), libMesh::Nemesis_IO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::CheckpointIO::write_bcs(), libMesh::GMVIO::write_binary(), libMesh::CheckpointIO::write_connectivity(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::UCDIO::write_implementation(), libMesh::UNVIO::write_implementation(), libMesh::GmshIO::write_mesh(), libMesh::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::Nemesis_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::CheckpointIO::write_nodes(), libMesh::CheckpointIO::write_nodesets(), libMesh::XdrIO::write_parallel(), libMesh::GmshIO::write_post(), libMesh::XdrIO::write_serialized_bcs(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), and libMesh::CheckpointIO::write_subdomain_names().

void libMesh::TetGenIO::node_in ( std::istream &  node_stream)
private

Method reads nodes from node_stream and stores them in vector<Node*> nodes in the order they come in. The original node labels are being stored in the map _assign_nodes in order to assign the elements to the right nodes later. In addition, provided it is active, the MeshData gets to know the node id from the file, too.

Definition at line 126 of file tetgen_io.C.

References _assign_nodes, _mesh_data, _num_nodes, libMesh::MeshData::add_foreign_node_id(), libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), node_attributes, libMesh::Real, and libMesh::resize().

Referenced by read_nodes_and_elem().

127 {
128  // Check input buffer
129  libmesh_assert (node_stream.good());
130 
131  // Get a reference to the mesh
132  MeshBase& mesh = MeshInput<MeshBase>::mesh();
133 
134  unsigned int dimension=0, nAttributes=0, BoundaryMarkers=0;
135 
136  node_stream >> _num_nodes // Read the number of nodes from the stream
137  >> dimension // Read the dimension from the stream
138  >> nAttributes // Read the number of attributes from stream
139  >> BoundaryMarkers; // Read if or not boundary markers are included in *.node (0 or 1)
140 
141  // Read the nodal coordinates from the node_stream (*.node file).
142  unsigned int node_lab=0;
143  Point xyz;
144  Real dummy;
145 
146  // If present, make room for node attributes to be stored.
147  this->node_attributes.resize(nAttributes);
148  for (unsigned i=0; i<nAttributes; ++i)
150 
151 
152  for (unsigned int i=0; i<_num_nodes; i++)
153  {
154  // Check input buffer
155  libmesh_assert (node_stream.good());
156 
157  node_stream >> node_lab // node number
158  >> xyz(0) // x-coordinate value
159  >> xyz(1) // y-coordinate value
160  >> xyz(2); // z-coordinate value
161 
162  // Read and store attributes from the stream.
163  for (unsigned int j=0; j<nAttributes; j++)
164  node_stream >> node_attributes[j][i];
165 
166  // Read (and discard) boundary marker if BoundaryMarker=1.
167  // TODO: should we store this somehow?
168  if (BoundaryMarkers == 1)
169  node_stream >> dummy;
170 
171  // Store the new position of the node under its label.
172  //_assign_nodes.insert (std::make_pair(node_lab,i));
173  _assign_nodes[node_lab] = i;
174 
175  // do this irrespective whether MeshData exists
176  Node* newnode = mesh.add_point(xyz, i);
177 
178  // Add node to the nodes vector &
179  // tell the MeshData object the foreign node id.
180  if (this->_mesh_data != NULL)
181  this->_mesh_data->add_foreign_node_id (newnode, node_lab);
182  }
183 }
void libMesh::TetGenIO::read ( const std::string &  name)
virtual

This method implements reading a mesh from a specified file in TetGen format.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 34 of file tetgen_io.C.

References libMesh::err, libMesh::MeshInput< MT >::mesh(), libMesh::Quality::name(), libMesh::out, libMesh::processor_id(), read_nodes_and_elem(), and libMesh::MeshInput< MeshBase >::skip_comment_lines().

Referenced by libMesh::UnstructuredMesh::read().

35 {
36  // This is a serial-only process for now;
37  // the Mesh should be read on processor 0 and
38  // broadcast later
39  libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().processor_id(), 0);
40 
41  std::string name_node, name_ele, dummy;
42 
43  // tetgen only works in 3D
44  MeshInput<MeshBase>::mesh().set_mesh_dimension(3);
45 
46 #if LIBMESH_DIM < 3
47  libMesh::err << "Cannot open dimension 3 mesh file when configured without 3D support." <<
48  std::endl;
49  libmesh_error();
50 #endif
51 
52  // Check name for *.node or *.ele extension.
53  // Set std::istream for node_stream and ele_stream.
54  //
55  if (name.rfind(".node") < name.size())
56  {
57  name_node = name;
58  dummy = name;
59  std::size_t position = dummy.rfind(".node");
60  name_ele = dummy.replace(position, 5, ".ele");
61  }
62  else if (name.rfind(".ele") < name.size())
63  {
64  name_ele = name;
65  dummy = name;
66  std::size_t position = dummy.rfind(".ele");
67  name_node = dummy.replace(position, 4, ".node");
68  }
69  else
70  {
71  libMesh::err << "ERROR: Unrecognized file name: "
72  << name << std::endl;
73  libmesh_error();
74  }
75 
76 
77 
78  // Set the streams from which to read in
79  std::ifstream node_stream (name_node.c_str());
80  std::ifstream ele_stream (name_ele.c_str());
81 
82  if ( !node_stream.good() || !ele_stream.good() )
83  {
84  libMesh::err << "ERROR: One or both Input file(s) not good." << std::endl
85  << "Error checking files "
86  << name_node << " and "
87  << name_ele << std::endl;
88  libmesh_error();
89  }
90  libMesh::out<< "TetGenIO found the tetgen files to read " <<std::endl;
91 
92  // Skip the comment lines at the beginning
93  this->skip_comment_lines (node_stream, '#');
94  this->skip_comment_lines (ele_stream, '#');
95 
96  // Read the nodes and elements from the streams
97  this->read_nodes_and_elem (node_stream, ele_stream);
98  libMesh::out<< "TetGenIO read in nodes and elements " <<std::endl;
99 }
void libMesh::TetGenIO::read_nodes_and_elem ( std::istream &  node_stream,
std::istream &  ele_stream 
)
private

Reads a mesh (nodes & elements) from the file provided through node_stream and ele_stream.

Definition at line 103 of file tetgen_io.C.

References _assign_nodes, _mesh_data, _num_elements, _num_nodes, libMesh::MeshData::close_foreign_id_maps(), element_in(), and node_in().

Referenced by read().

105 {
106  _num_nodes = 0;
107  _num_elements = 0;
108 
109  // Read all the datasets.
110  this->node_in (node_stream);
111  this->element_in (ele_stream);
112 
113  // Tell the MeshData object that we are finished
114  // reading data.
115  if (this->_mesh_data != NULL)
117 
118  // some more clean-up
119  _assign_nodes.clear();
120 }
void libMesh::MeshInput< MeshBase >::skip_comment_lines ( std::istream &  in,
const char  comment_start 
)
protectedinherited

Reads input from in, skipping all the lines that start with the character comment_start.

Referenced by read(), and libMesh::UCDIO::read_implementation().

void libMesh::TetGenIO::write ( const std::string &  fname)
virtual

This method implements writing a mesh to a specified ".poly" file. ".poly" files defines so called Piecewise Linear Complex (PLC).

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 271 of file tetgen_io.C.

References libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), end, libMesh::err, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), and libMesh::MeshBase::point().

Referenced by libMesh::UnstructuredMesh::write().

272 {
273  // libmesh_assert three dimensions (should be extended later)
274  libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().mesh_dimension(), 3);
275 
276  if (!(fname.rfind(".poly") < fname.size()))
277  {
278  libMesh::err << "ERROR: Unrecognized file name: "
279  << fname << std::endl;
280  libmesh_error();
281  }
282 
283  // Open the output file stream
284  std::ofstream out_stream (fname.c_str());
285 
286  // Make sure it opened correctly
287  if (!out_stream.good())
288  libmesh_file_error(fname.c_str());
289 
290  // Get a reference to the mesh
291  const MeshBase& mesh = MeshOutput<MeshBase>::mesh();
292 
293  // Begin interfacing with the .poly file
294  {
295  // header:
296  out_stream << "# poly file output generated by libmesh\n"
297  << mesh.n_nodes() << " 3 0 0\n";
298 
299  // write the nodes:
300  for (dof_id_type v=0; v<mesh.n_nodes(); v++)
301  out_stream << v << " "
302  << mesh.point(v)(0) << " "
303  << mesh.point(v)(1) << " "
304  << mesh.point(v)(2) << "\n";
305  }
306 
307  {
308  // write the connectivity:
309  out_stream << "# Facets:\n"
310  << mesh.n_elem() << " 0\n";
311 
312 // const_active_elem_iterator it (mesh.elements_begin());
313 // const const_active_elem_iterator end(mesh.elements_end());
314 
315  MeshBase::const_element_iterator it = mesh.active_elements_begin();
316  const MeshBase::const_element_iterator end = mesh.active_elements_end();
317 
318  for ( ; it != end; ++it)
319  out_stream << "1\n3 " // no. of facet polygons
320  // << (*it)->n_nodes() << " "
321  << (*it)->node(0) << " "
322  << (*it)->node(1) << " "
323  << (*it)->node(2) << "\n";
324  }
325 
326  // end of the file
327  out_stream << "0\n"; // no holes output!
328  out_stream << "\n\n# end of file\n";
329 }
virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  ,
const EquationSystems ,
const std::set< std::string > *  system_names = NULL 
)
virtualinherited

This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.

Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_IO::write_timestep().

virtual void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  ,
const std::vector< Number > &  ,
const std::vector< std::string > &   
)
inlinevirtualinherited

This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.

Reimplemented in libMesh::ExodusII_IO, libMesh::GMVIO, libMesh::Nemesis_IO, libMesh::GmshIO, libMesh::VTKIO, libMesh::UCDIO, libMesh::MEDITIO, libMesh::GnuPlotIO, and libMesh::TecplotIO.

Definition at line 98 of file mesh_output.h.

101  { libmesh_error(); }

Member Data Documentation

std::map<dof_id_type,dof_id_type> libMesh::TetGenIO::_assign_nodes
private

stores new positions of nodes. Used when reading.

Definition at line 132 of file tetgen_io.h.

Referenced by element_in(), node_in(), and read_nodes_and_elem().

const bool libMesh::MeshOutput< MeshBase >::_is_parallel_format
protectedinherited

Flag specifying whether this format is parallel-capable. If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 126 of file mesh_output.h.

Referenced by libMesh::FroIO::write(), libMesh::DivaIO::write(), libMesh::PostscriptIO::write(), and libMesh::EnsightIO::write().

MeshData* libMesh::TetGenIO::_mesh_data
private

A pointer to the MeshData object you would like to use. with this TetGenIO object. Can be NULL.

Definition at line 148 of file tetgen_io.h.

Referenced by element_in(), node_in(), and read_nodes_and_elem().

dof_id_type libMesh::TetGenIO::_num_elements
private

total number of elements. Primarily used when reading.

Definition at line 142 of file tetgen_io.h.

Referenced by element_in(), and read_nodes_and_elem().

dof_id_type libMesh::TetGenIO::_num_nodes
private

total number of nodes. Primarily used when reading.

Definition at line 137 of file tetgen_io.h.

Referenced by node_in(), and read_nodes_and_elem().

std::vector<std::vector<Real> > libMesh::TetGenIO::element_attributes

Data structure to hold element attributes read in from file. What you do with these is up to you!

Definition at line 91 of file tetgen_io.h.

Referenced by element_in().

std::vector<std::vector<Real> > libMesh::TetGenIO::node_attributes

Data structure to hold node attributes read in from file. What you do with these is up to you!

Definition at line 85 of file tetgen_io.h.

Referenced by node_in().


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

Site Created By: libMesh Developers
Last modified: February 07 2014 16:58:02 UTC

Hosted By:
SourceForge.net Logo