libMesh::UCDIO Class Reference

#include <ucd_io.h>

Inheritance diagram for libMesh::UCDIO:

[legend]

List of all members.

Public Member Functions
	UCDIO (MeshBase &)
	UCDIO (const MeshBase &)
virtual void	read (const std::string &)
virtual void	write (const std::string &)
virtual void	write_nodal_data (const std::string &fname, const std::vector< Number > &soln, const std::vector< std::string > &names)
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=NULL)
unsigned int &	ascii_precision ()
Protected Member Functions
MeshBase &	mesh ()
void	skip_comment_lines (std::istream &in, const char comment_start)
const MeshBase &	mesh () const
Protected Attributes
std::vector< bool >	elems_of_dimension
const bool	_is_parallel_format
Private Member Functions
void	read_implementation (std::istream &in_stream)
void	write_implementation (std::ostream &out_stream)
void	write_header (std::ostream &out, const MeshBase &mesh, dof_id_type n_elems, unsigned int n_vars)
void	write_nodes (std::ostream &out, const MeshBase &mesh)
void	write_interior_elems (std::ostream &out, const MeshBase &mesh)
void	write_soln (std::ostream &out, const MeshBase &mesh, const std::vector< std::string > &names, const std::vector< Number > &soln)

---

Detailed Description

This class implements reading & writing meshes in the AVS's UCD format.

Author:

Benjamin S. Kirk, 2004

Definition at line 47 of file ucd_io.h.

---

Constructor & Destructor Documentation

libMesh::UCDIO::UCDIO

(

MeshBase &

mesh

)

[inline, explicit]

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

Definition at line 133 of file ucd_io.h.

                            :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh)
{
}

libMesh::UCDIO::UCDIO

(

const MeshBase &

mesh

)

[inline, explicit]

Constructor. Takes a reference to a constant mesh object. This constructor will only allow us to write the mesh.

Definition at line 142 of file ucd_io.h.

                                  :
  MeshOutput<MeshBase> (mesh)
{
}

---

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().

const MeshBase & libMesh::MeshOutput< MeshBase >::mesh

(

)

const [protected, inherited]

Returns the object as a read-only reference.

Referenced by libMesh::PostscriptIO::write(), libMesh::FroIO::write(), libMesh::EnsightIO::write(), libMesh::DivaIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_binary(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::EnsightIO::write_scalar_ascii(), libMesh::GnuPlotIO::write_solution(), libMesh::DivaIO::write_stream(), and libMesh::EnsightIO::write_vector_ascii().

MeshBase & libMesh::MeshInput< MeshBase >::mesh

(

)

[protected, inherited]

Returns the object as a writeable reference.

Referenced by libMesh::GMVIO::_read_materials(), libMesh::GMVIO::_read_nodes(), libMesh::GMVIO::_read_one_cell(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::AbaqusIO::assign_subdomain_ids(), libMesh::VTKIO::cells_to_vtk(), libMesh::GMVIO::copy_nodal_solution(), libMesh::UNVIO::element_in(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::element_out(), libMesh::UNVIO::node_in(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::node_out(), libMesh::VTKIO::nodes_to_vtk(), libMesh::XdrIO::read(), libMesh::VTKIO::read(), libMesh::TetGenIO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::AbaqusIO::read(), libMesh::LegacyXdrIO::read_ascii(), libMesh::AbaqusIO::read_elements(), libMesh::UNVIO::read_implementation(), read_implementation(), libMesh::LegacyXdrIO::read_mesh(), libMesh::GmshIO::read_mesh(), libMesh::AbaqusIO::read_nodes(), libMesh::XdrIO::read_serialized_bcs(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::XdrIO::write(), libMesh::TetGenIO::write(), libMesh::Nemesis_IO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::UNVIO::write_implementation(), write_implementation(), libMesh::LegacyXdrIO::write_mesh(), libMesh::GmshIO::write_mesh(), write_nodal_data(), libMesh::Nemesis_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::XdrIO::write_parallel(), libMesh::GmshIO::write_post(), libMesh::XdrIO::write_serialized_bcs(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::LegacyXdrIO::write_soln().

void libMesh::UCDIO::read

(

const std::string &

file_name

)

[virtual]

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

Implements libMesh::MeshInput< MeshBase >.

Definition at line 46 of file ucd_io.C.

References libMesh::err, and read_implementation().

{
  if (file_name.rfind(".gz") < file_name.size())
    {
#ifdef LIBMESH_HAVE_GZSTREAM

      igzstream in_stream (file_name.c_str());
      this->read_implementation (in_stream);

#else

      libMesh::err << "ERROR:  You must have the zlib.h header "
                    << "files and libraries to read and write "
                    << "compressed streams."
                    << std::endl;
      libmesh_error();

#endif
      return;
    }

  else
    {
      std::ifstream in_stream (file_name.c_str());
      this->read_implementation (in_stream);
      return;
    }
}

void libMesh::UCDIO::read_implementation

(

std::istream &

in_stream

)

[private]

The actual implementation of the read function. The public read interface simply decides which type of stream to pass the implementation.

Definition at line 108 of file ucd_io.C.

References libMesh::Elem::dim(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::err, libMesh::MeshInput< MeshBase >::mesh(), libMesh::Elem::n_nodes(), libMesh::processor_id(), libMesh::DofObject::set_id(), libMesh::Elem::set_node(), and libMesh::MeshInput< MeshBase >::skip_comment_lines().

Referenced by read().

{
  // This is a serial-only process for now;
  // the Mesh should be read on processor 0 and
  // broadcast later
  libmesh_assert_equal_to (libMesh::processor_id(), 0);

  // Check input buffer
  libmesh_assert (in.good());

  MeshBase& mesh = MeshInput<MeshBase>::mesh();

  // Keep track of what kinds of elements this file contains
  elems_of_dimension.clear();
  elems_of_dimension.resize(4, false);

  this->skip_comment_lines (in, '#');

  unsigned int nNodes=0, nElem=0, dummy=0;

  in >> nNodes   // Read the number of nodes from the stream
     >> nElem    // Read the number of elements from the stream
     >> dummy
     >> dummy
     >> dummy;


  // Read the nodal coordinates. Note that UCD format always
  // stores (x,y,z), and in 2D z=0. We don't need to store this,
  // however.  So, we read in x,y,z for each node and make a point
  // in the proper way based on what dimension we're in
  {
    Point xyz;

    for (unsigned int i=0; i<nNodes; i++)
      {
        libmesh_assert (in.good());

        in >> dummy   // Point number
           >> xyz(0)  // x-coordinate value
           >> xyz(1)  // y-coordinate value
           >> xyz(2); // z-coordinate value

        // Build the node
        mesh.add_point (xyz, i);
      }
  }



  // Read the elements from the stream. Notice that the UCD node-numbering
  // scheme is 1-based, and we just created a 0-based scheme above
  // (which is of course what we want). So, when we read in the nodal
  // connectivity for each element we need to take 1 off the value of
  // each node so that we get the right thing.
  {
    unsigned int material_id=0, node=0;
    std::string type;

    for (unsigned int i=0; i<nElem; i++)
      {
        Elem* elem = NULL;

        libmesh_assert (in.good());

        in >> dummy        // Cell number, means nothing to us
           >> material_id  // doesn't mean anything at present, might later
           >> type;        // string describing cell type:
                           // either tri, quad, tet, hex, or prism for the
                           // obvious cases


                           // Now read the connectivity.
        if (type == "quad")
          elem = new Quad4;
        else if (type == "tri")
          elem = new Tri3;
        else if (type == "hex")
          elem = new Hex8;
        else if (type == "tet")
          elem = new Tet4;
        else if (type == "prism")
          elem = new Prism6;
        else
          libmesh_error();

        for (unsigned int n=0; n<elem->n_nodes(); n++)
          {
            libmesh_assert (in.good());

            in >> node; // read the current node
            node -= 1;  // UCD is 1-based, so subtract

            libmesh_assert_less (node, mesh.n_nodes());

            elem->set_node(n) =
              mesh.node_ptr(node); // assign the node
          }

        elems_of_dimension[elem->dim()] = true;

        // Add the element to the mesh
        elem->set_id(i);
        mesh.add_elem (elem);
      }

    // Set the mesh dimension to the largest encountered for an element
    for (unsigned int i=0; i!=4; ++i)
      if (elems_of_dimension[i])
        mesh.set_mesh_dimension(i);

#if LIBMESH_DIM < 3
    if (mesh.mesh_dimension() > LIBMESH_DIM)
      {
        libMesh::err << "Cannot open dimension " <<
                        mesh.mesh_dimension() <<
                        " mesh file when configured without " <<
                        mesh.mesh_dimension() << "D support." <<
                        std::endl;
        libmesh_error();
      }
#endif
  }
}

void libMesh::MeshInput< MeshBase >::skip_comment_lines	(	std::istream &	in,
		const char	comment_start
	)			[protected, inherited]

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

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

void libMesh::UCDIO::write

(

const std::string &

file_name

)

[virtual]

This method implements writing a mesh to a specified file in UCD format.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 77 of file ucd_io.C.

References libMesh::err, and write_implementation().

{
  if (file_name.rfind(".gz") < file_name.size())
    {
#ifdef LIBMESH_HAVE_GZSTREAM

      ogzstream out_stream (file_name.c_str());
      this->write_implementation (out_stream);

#else

      libMesh::err << "ERROR:  You must have the zlib.h header "
                    << "files and libraries to read and write "
                    << "compressed streams."
                    << std::endl;
      libmesh_error();

#endif
      return;
    }

  else
    {
      std::ofstream out_stream (file_name.c_str());
      this->write_implementation (out_stream);
      return;
    }
}

virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems	(	const std::string &	,
		const EquationSystems &	,
		const std::set< std::string > *	system_names = NULL
	)			[virtual, inherited]

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().

void libMesh::UCDIO::write_header	(	std::ostream &	out,
		const MeshBase &	mesh,
		dof_id_type	n_elems,
		unsigned int	n_vars
	)			[private]

Write UCD format header

Definition at line 263 of file ucd_io.C.

References libMesh::MeshBase::n_nodes().

Referenced by write_implementation(), and write_nodal_data().

{
  libmesh_assert (out_stream.good());
  // TODO: We used to print out the SVN revision here when we did keyword expansions...
  out_stream << "# For a description of the UCD format see the AVS Developer's guide.\n"
      << "#\n";

  // Write the mesh info
  out_stream << mesh.n_nodes() << " "
      << n_elems  << " "
      << n_vars << " "
      << " 0 0\n";
  return;
}

void libMesh::UCDIO::write_implementation

(

std::ostream &

out_stream

)

[private]

The actual implementation of the write function. The public write interface simply decides which type of stream to pass the implementation.

Definition at line 235 of file ucd_io.C.

References libMesh::err, libMesh::MeshInput< MeshBase >::mesh(), write_header(), write_interior_elems(), and write_nodes().

Referenced by write().

{
  libmesh_assert (out_stream.good());

  const MeshBase& mesh = MeshOutput<MeshBase>::mesh();

  // UCD doesn't work in 1D
  libmesh_assert_not_equal_to (mesh.mesh_dimension(), 1);
  if(mesh.mesh_dimension() != 3)
    {
      libMesh::err << "Error: Can't write boundary elements for meshes of dimension less than 3"
                   << "Mesh dimension = " << mesh.mesh_dimension()
                   << std::endl;
      libmesh_error();
    }

  // Write header
  this->write_header(out_stream,mesh,mesh.n_elem(),0);

  // Write the node coordinates
  this->write_nodes(out_stream,mesh);

  // Write the elements
  this->write_interior_elems(out_stream,mesh);

  return;
}

void libMesh::UCDIO::write_interior_elems	(	std::ostream &	out,
		const MeshBase &	mesh
	)			[private]

Write element information

Definition at line 298 of file ucd_io.C.

References libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::err, libMeshEnums::HEX8, libMeshEnums::PRISM6, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::UCD.

Referenced by write_implementation(), and write_nodal_data().

{
  std::string type[] =
    { "edge",  "edge",  "edge",
      "tri",   "tri",
      "quad",  "quad",  "quad",
      "tet",   "tet",
      "hex",   "hex",   "hex",
      "prism", "prism", "prism",
      "pyramid" };

  MeshBase::const_element_iterator it  = mesh.elements_begin();
  const MeshBase::const_element_iterator end = mesh.elements_end();
  
  unsigned int e=1; // 1-based element number for UCD
  
  // Write element information
  for (; it != end; ++it)
    {
      libmesh_assert (out_stream.good());
      
      // PB: I believe these are the only supported ElemTypes.
      const ElemType etype = (*it)->type();
      if( (etype != TRI3) && (etype != QUAD4) &&
          (etype != TET4) && (etype != HEX8) &&
          (etype != PRISM6) && (etype != PYRAMID5) )
        {
          libMesh::err << "Error: Unsupported ElemType for UCDIO."
                       << std::endl;
          libmesh_error();
        }

      out_stream << e++ << " 0 " << type[etype] << "\t";
      // (*it)->write_ucd_connectivity(out_stream);
      (*it)->write_connectivity(out_stream, UCD);
    }

  return;
}

void libMesh::UCDIO::write_nodal_data	(	const std::string &	fname,
		const std::vector< Number > &	soln,
		const std::vector< std::string > &	names
	)			[virtual]

This method implements writing a mesh and solution to a specified file in UCD format. This is internally called by MeshOutput::write_equation_systems

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 338 of file ucd_io.C.

References libMesh::MeshInput< MeshBase >::mesh(), write_header(), write_interior_elems(), write_nodes(), and write_soln().

{
  std::ofstream out_stream(fname.c_str());
  
  const MeshBase& mesh = MeshOutput<MeshBase>::mesh();

  // UCD doesn't work in 1D
  libmesh_assert (mesh.mesh_dimension() != 1);

  // Write header
  this->write_header(out_stream,mesh,mesh.n_elem(),names.size());

  // Write the node coordinates
  this->write_nodes(out_stream,mesh);

  // Write the elements
  this->write_interior_elems(out_stream,mesh);

  // Write the solution
  this->write_soln(out_stream,mesh,names,soln);

  return;
}

void libMesh::UCDIO::write_nodes	(	std::ostream &	out,
		const MeshBase &	mesh
	)			[private]

Write node information

Definition at line 279 of file ucd_io.C.

References end, libMesh::MeshBase::nodes_begin(), and libMesh::MeshBase::nodes_end().

Referenced by write_implementation(), and write_nodal_data().

{
  MeshBase::const_node_iterator       it  = mesh.nodes_begin();
  const MeshBase::const_node_iterator end = mesh.nodes_end();
  
  unsigned int n=1; // 1-based node number for UCD
  
  // Write the node coordinates
  for (; it != end; ++it)
    {
      libmesh_assert (out_stream.good());
      
      out_stream << n++ << "\t";
      (*it)->write_unformatted(out_stream);
    }

  return;
}

void libMesh::UCDIO::write_soln	(	std::ostream &	out,
		const MeshBase &	mesh,
		const std::vector< std::string > &	names,
		const std::vector< Number > &	soln
	)			[private]

Writes all nodal solution variables

Definition at line 364 of file ucd_io.C.

References libMesh::MeshTools::Generation::Private::idx(), and libMesh::MeshBase::n_nodes().

Referenced by write_nodal_data().

{
  libmesh_assert (out_stream.good());

  // First write out how many variables and how many components per variable
  out_stream << names.size();
  for( unsigned int i = 0; i < names.size(); i++ )
    {
      libmesh_assert (out_stream.good());
      // Each named variable has only 1 component
      out_stream << " 1";
    }
  out_stream << std::endl;

  // Now write out variable names and units. Since we don't store units
  // We just write out dummy.
  for( std::vector<std::string>::const_iterator var = names.begin();
       var != names.end();
       var++)
    {
      libmesh_assert (out_stream.good());
      out_stream << (*var) << ", dummy" << std::endl;
    }

  // Now, for each node, write out the solution variables
  std::size_t nv = names.size();
  for( std::size_t n = 1; // 1-based node number for UCD
       n <= mesh.n_nodes(); n++)
    {
      libmesh_assert (out_stream.good());
      out_stream << n;

      for( std::size_t var = 0; var != nv; var++ )
        {
          std::size_t idx = nv*(n-1) + var;
          
          out_stream << " " << soln[idx];
        }
      out_stream << std::endl;
    }

  return;
}

---

Member Data Documentation

const bool libMesh::MeshOutput< MeshBase >::_is_parallel_format [protected, inherited]

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::PostscriptIO::write(), libMesh::FroIO::write(), libMesh::EnsightIO::write(), and libMesh::DivaIO::write().

std::vector<bool> libMesh::MeshInput< MeshBase >::elems_of_dimension [protected, inherited]

A vector of bools describing what dimension elements have been encountered when reading a mesh.

Definition at line 93 of file mesh_input.h.

Referenced by libMesh::GMVIO::_read_one_cell(), libMesh::UNVIO::element_in(), libMesh::VTKIO::read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::UNVIO::read_implementation(), read_implementation(), libMesh::LegacyXdrIO::read_mesh(), and libMesh::XdrIO::read_serialized_connectivity().

---

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

• ucd_io.h
• ucd_io.C