#include <ucd_io.h>

Inheritance diagram for libMesh::UCDIO:

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	set_n_partitions (unsigned int n_parts)
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().

MeshBase & libMesh::MeshInput< MeshBase >::mesh ( ) [protected, inherited]

Returns the object as a writeable reference.

const MeshBase & libMesh::MeshOutput< MeshBase >::mesh ( ) const [protected, inherited]

Returns the object as a read-only reference.

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

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

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

{
  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_error_msg("ERROR:  You must have the zlib.h header files and libraries to read and write compressed streams.");

#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 100 of file ucd_io.C.

References libMesh::Elem::dim(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::libmesh_assert(), 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 (MeshOutput<MeshBase>::mesh().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_msg("Unsupported element type = " << type);

        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 char 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_error_msg("Cannot open dimension " \
                        << mesh.mesh_dimension() \
                        << " mesh file when configured without " \
                        << mesh.mesh_dimension() \
                        << "D support.");
#endif
  }
}

void libMesh::MeshInput< MeshBase >::set_n_partitions ( unsigned int n_parts ) [inline, protected, inherited]

Sets the number of partitions in the mesh. Typically this gets done by the partitioner, but some parallel file formats begin "pre-partitioned".

Definition at line 94 of file mesh_input.h.

References libMesh::MeshInput< MT >::mesh().

Referenced by libMesh::Nemesis_IO::read(), and libMesh::XdrIO::read().

{ this->mesh().set_n_partitions() = n_parts; }

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 73 of file ucd_io.C.

References write_implementation().

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

{
  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_error_msg("ERROR:  You must have the zlib.h header files and libraries to read and write compressed streams.");

#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.

Reimplemented in libMesh::NameBasedIO.

Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_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 248 of file ucd_io.C.

References libMesh::libmesh_assert(), and 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 224 of file ucd_io.C.

References libMesh::libmesh_assert(), 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_error_msg("Error: Can't write boundary elements for meshes of dimension less than 3. " \
                      << "Mesh dimension = " << mesh.mesh_dimension());

  // 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 283 of file ucd_io.C.

References libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), end, libMesh::HEX8, libMesh::libmesh_assert(), libMesh::PRISM6, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::TET4, libMesh::TRI3, and libMesh::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_error_msg("Error: Unsupported ElemType for UCDIO.");

      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 319 of file ucd_io.C.

References libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_elem(), libMesh::MeshTools::n_elem(), libMesh::ParallelObject::processor_id(), write_header(), write_interior_elems(), write_nodes(), and write_soln().

Referenced by libMesh::NameBasedIO::write_nodal_data().

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

  const dof_id_type n_elem = mesh.n_elem();

  // Only processor 0 does the writing
  if (mesh.processor_id())
    return;

  std::ofstream out_stream(fname.c_str());

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

  // Write header
  this->write_header(out_stream,mesh,n_elem,
                     cast_int<unsigned int>(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 264 of file ucd_io.C.

References end, libMesh::libmesh_assert(), 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 352 of file ucd_io.C.

References libMesh::MeshTools::Generation::Private::idx(), libMesh::libmesh_assert(), 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::FroIO::write(), libMesh::DivaIO::write(), libMesh::PostscriptIO::write(), and libMesh::EnsightIO::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 100 of file mesh_input.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation