libMesh::VTKIO Class Reference

#include <vtk_io.h>

Inheritance diagram for libMesh::VTKIO:

[legend]

List of all members.

Public Member Functions
	VTKIO (MeshBase &mesh, MeshData *mesh_data=NULL)
	VTKIO (const MeshBase &mesh, MeshData *mesh_data=NULL)
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
virtual void	read (const std::string &)
virtual void	write (const std::string &)
vtkUnstructuredGrid *	get_vtk_grid ()
void	set_compression (bool b)
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
vtkIdType	get_elem_type (ElemType type)
void	nodes_to_vtk ()
void	cells_to_vtk ()
void	system_vectors_to_vtk (const EquationSystems &es, vtkUnstructuredGrid *&grid)
Private Attributes
vtkUnstructuredGrid *	_vtk_grid
MeshData *	_mesh_data
bool	_compress
std::map< dof_id_type, dof_id_type >	_local_node_map

---

Detailed Description

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

This class will not have any functionality unless VTK is detected during configure and hence LIBMESH_HAVE_VTK is defined.

Author:

Wout Ruijter, 2007 (Checked in to LibMesh by J.W. Peterson)

Definition at line 61 of file vtk_io.h.

---

Constructor & Destructor Documentation

libMesh::VTKIO::VTKIO	(	MeshBase &	mesh,
		MeshData *	mesh_data = NULL
	)			[inline, explicit]

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

Definition at line 170 of file vtk_io.h.

References _vtk_grid.

                                                 :
        MeshInput<MeshBase> (mesh),
        MeshOutput<MeshBase>(mesh),
        _mesh_data(mesh_data),
        _compress(false),
        _local_node_map()
{
  _vtk_grid = NULL;
  libmesh_experimental();
}

libMesh::VTKIO::VTKIO	(	const MeshBase &	mesh,
		MeshData *	mesh_data = NULL
	)			[inline, explicit]

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

Definition at line 184 of file vtk_io.h.

References _vtk_grid.

                                                       :
        MeshOutput<MeshBase>(mesh),
        _mesh_data(mesh_data),
        _compress(false),
        _local_node_map()
{
  _vtk_grid = NULL;
  libmesh_experimental();
}

---

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::VTKIO::cells_to_vtk

(

)

[private]

write the cells from the mesh into a vtkUnstructuredGrid

Definition at line 191 of file vtk_io.C.

References _local_node_map, _vtk_grid, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::Elem::connectivity(), end, get_elem_type(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshBase::n_active_local_elem(), libMesh::Elem::n_nodes(), libMesh::MeshBase::node(), libMesh::Elem::node(), libMesh::Elem::type(), and libMeshEnums::VTK.

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

  vtkSmartPointer<vtkCellArray> cells = vtkCellArray::New();
  vtkSmartPointer<vtkIdList> pts = vtkIdList::New();

  std::vector<int> types(mesh.n_active_local_elem());
  int active_element_counter = 0;

  MeshBase::const_element_iterator it = mesh.active_local_elements_begin();
  const MeshBase::const_element_iterator end = mesh.active_local_elements_end();
  for (; it != end; it++, ++active_element_counter)
    {
      Elem *elem = *it;

      pts->SetNumberOfIds(elem->n_nodes());

      // get the connectivity for this element
      std::vector<dof_id_type> conn;
      elem->connectivity(0, VTK, conn);

      for (unsigned int i = 0; i < conn.size(); ++i)
        {
          if (_local_node_map.find(conn[i]) == _local_node_map.end())
            {
              // Ghost node
              float pt[LIBMESH_DIM];
              dof_id_type node = elem->node(i);
              for (unsigned int d = 0; d < LIBMESH_DIM; ++d)
                {
                pt[d] = mesh.node(node)(d);
                }
              vtkIdType local = _vtk_grid->GetPoints()->InsertNextPoint(pt);
              _local_node_map[node] = local;
            }
          pts->InsertId(i, _local_node_map[conn[i]]);
        }

      cells->InsertNextCell(pts);
      types[active_element_counter] = this->get_elem_type(elem->type());
    } // end loop over active elements
  pts->Delete();
  _vtk_grid->SetCells(&types[0], cells);
  cells->Delete();
}

vtkIdType libMesh::VTKIO::get_elem_type

(

ElemType

type

)

[private]

Map libMesh element types to VTK element types

Definition at line 74 of file vtk_io.C.

References libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMeshEnums::EDGE4, libMesh::err, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::INFEDGE2, libMeshEnums::INFHEX16, libMeshEnums::INFHEX18, libMeshEnums::INFHEX8, libMeshEnums::INFPRISM12, libMeshEnums::INFPRISM6, libMeshEnums::INFQUAD4, libMeshEnums::INFQUAD6, libMeshEnums::INVALID_ELEM, libMeshEnums::NODEELEM, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::TRI6.

Referenced by cells_to_vtk().

                                            {
  vtkIdType celltype = VTK_EMPTY_CELL; // initialize to something to avoid compiler warning

  switch(type)
  {
    case EDGE2:
      celltype = VTK_LINE;
      break;
    case EDGE3:
      celltype = VTK_QUADRATIC_EDGE;
      break;// 1
    case TRI3:
      celltype = VTK_TRIANGLE;
      break;// 3
    case TRI6:
      celltype = VTK_QUADRATIC_TRIANGLE;
      break;// 4
    case QUAD4:
      celltype = VTK_QUAD;
      break;// 5
    case QUAD8:
      celltype = VTK_QUADRATIC_QUAD;
      break;// 6
    case TET4:
      celltype = VTK_TETRA;
      break;// 8
    case TET10:
      celltype = VTK_QUADRATIC_TETRA;
      break;// 9
    case HEX8:
      celltype = VTK_HEXAHEDRON;
      break;// 10
    case HEX20:
      celltype = VTK_QUADRATIC_HEXAHEDRON;
      break;// 12
    case HEX27:
      celltype = VTK_TRIQUADRATIC_HEXAHEDRON;
      break;
    case PRISM6:
      celltype = VTK_WEDGE;
      break;// 13
    case PRISM15:
      celltype = VTK_QUADRATIC_WEDGE;
      break;// 14
    case PRISM18:
      celltype = VTK_BIQUADRATIC_QUADRATIC_WEDGE;
      break;// 15
    case PYRAMID5:
      celltype = VTK_PYRAMID;
      break;// 16
#if VTK_MAJOR_VERSION > 5 || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION > 0)
    case QUAD9:
      celltype = VTK_BIQUADRATIC_QUAD;
      break;
#else
    case QUAD9:
#endif
    case EDGE4:
    case INFEDGE2:
    case INFQUAD4:
    case INFQUAD6:
    case INFHEX8:
    case INFHEX16:
    case INFHEX18:
    case INFPRISM6:
    case INFPRISM12:
    case NODEELEM:
    case INVALID_ELEM:
    default:
      {
        libMesh::err<<"element type "<<type<<" not implemented"<<std::endl;
        libmesh_error();
        break;
      }
  }
  return celltype;
}

vtkUnstructuredGrid* libMesh::VTKIO::get_vtk_grid

(

)

[inline]

Get a pointer to the VTK datastructure

Definition at line 112 of file vtk_io.h.

References _vtk_grid.

                                      {
    return _vtk_grid;
  }

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(), 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(), nodes_to_vtk(), libMesh::XdrIO::read(), 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(), libMesh::UCDIO::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(), libMesh::UCDIO::write_implementation(), libMesh::LegacyXdrIO::write_mesh(), libMesh::GmshIO::write_mesh(), libMesh::UCDIO::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::VTKIO::nodes_to_vtk

(

)

[private]

write the nodes from the mesh into a vtkUnstructuredGrid

Definition at line 153 of file vtk_io.C.

References _local_node_map, _vtk_grid, libMesh::DofObject::id(), libMesh::MeshBase::local_nodes_begin(), libMesh::MeshBase::local_nodes_end(), libMesh::MeshInput< MeshBase >::mesh(), and libMesh::MeshBase::n_local_nodes().

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

  // containers for points and coordinates of points
  vtkSmartPointer<vtkPoints> points = vtkPoints::New();
  vtkSmartPointer<vtkDoubleArray> pcoords = vtkDoubleArray::New();
  pcoords->SetNumberOfComponents(LIBMESH_DIM);
  points->SetNumberOfPoints(mesh.n_local_nodes()); // it seems that it needs this to prevent a segfault
 
  unsigned int local_node_counter = 0;

  MeshBase::const_node_iterator nd = mesh.local_nodes_begin();
  MeshBase::const_node_iterator nd_end = mesh.local_nodes_end();
  for (; nd != nd_end; nd++, local_node_counter++)
    {
      Node* node = (*nd);

      float pnt[LIBMESH_DIM];
      for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
        pnt[i] = (*node)(i);

      // Fill mapping between global and local node numbers
      _local_node_map[node->id()] = local_node_counter;

      // add point
      pcoords->InsertNextTuple(pnt); // SetTuple(node->id(),pnt);
    }

  // add coordinates to points
  points->SetData(pcoords);
  pcoords->Delete();
  // add points to grid
  _vtk_grid->SetPoints(points);
  points->Delete();
}

void libMesh::VTKIO::read

(

const std::string &

name

)

[virtual]

Overloads writing equation systems, this is done because when overloading write_nodal_data there would be no way to export cell centered data This method implements reading a mesh from a specified file in VTK format.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 313 of file vtk_io.C.

References _mesh_data, _vtk_grid, libMesh::MeshBase::add_elem(), libMesh::MeshData::add_foreign_node_id(), libMesh::MeshBase::add_point(), libMesh::MeshBase::clear(), libMesh::Elem::connectivity(), libMesh::Elem::dim(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::err, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::Elem::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::processor_id(), libMesh::DofObject::set_id(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), and libMeshEnums::VTK.

{
  // 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);

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

#ifndef LIBMESH_HAVE_VTK
  libMesh::err << "Cannot read VTK file: " << name
                << "\nYou must have VTK installed and correctly configured to read VTK meshes."
                << std::endl;
  libmesh_error();

#else
//  libMesh::out<<"read "<<name <<std::endl;
  vtkXMLUnstructuredGridReader *reader = vtkXMLUnstructuredGridReader::New();
  reader->SetFileName( name.c_str() );
  //libMesh::out<<"force read"<<std::endl;
  // Force reading
  reader->Update();

  // read in the grid
//  vtkUnstructuredGrid *grid = reader->GetOutput();
  _vtk_grid = reader->GetOutput();
  _vtk_grid->Update();
  reader->Delete();

  // Get a reference to the mesh
  MeshBase& mesh = MeshInput<MeshBase>::mesh();

  // Clear out any pre-existing data from the Mesh
  mesh.clear();

  // always numbered nicely??, so we can loop like this
  // I'm pretty sure it is numbered nicely
  for (unsigned int i=0; i < static_cast<unsigned int>(_vtk_grid->GetNumberOfPoints()); ++i)
    {
      // add to the id map
      // and add the actual point
      double * pnt = _vtk_grid->GetPoint(static_cast<vtkIdType>(i));
      Point xyz(pnt[0],pnt[1],pnt[2]);
      Node* newnode = mesh.add_point(xyz,i);

      // Add node to the nodes vector &
      // tell the MeshData object the foreign node id.
      if (this->_mesh_data != NULL)
        this->_mesh_data->add_foreign_node_id (newnode, i);
    }

  for (unsigned int i=0; i < static_cast<unsigned int>(_vtk_grid->GetNumberOfCells()); ++i)
    {
      vtkCell* cell = _vtk_grid->GetCell(i);
      Elem* elem = NULL;  // Initialize to avoid compiler warning
      switch(cell->GetCellType())
        {
        // FIXME - we're not supporting 2D VTK input yet!? [RHS]
        case VTK_TETRA:
          elem = new Tet4();
          break;
        case VTK_WEDGE:
          elem = new Prism6();
          break;
        case VTK_HEXAHEDRON:
          elem = new Hex8();
          break;
        case VTK_PYRAMID:
          elem = new Pyramid5();
          break;
        case VTK_QUADRATIC_HEXAHEDRON:
          elem = new Hex20();
          break;
        case VTK_QUADRATIC_TETRA:
          elem = new Tet10();
          break;
        default:
          libMesh::err << "element type not implemented in vtkinterface " << cell->GetCellType() << std::endl;
          libmesh_error();
     break;
        }

  // get the straightforward numbering from the VTK cells
  for(unsigned int j=0;j<elem->n_nodes();++j){
          elem->set_node(j) = mesh.node_ptr(cell->GetPointId(j));
  }
  // then get the connectivity
  std::vector<dof_id_type> conn;
  elem->connectivity(0,VTK,conn);
  // then reshuffle the nodes according to the connectivity, this
  // two-time-assign would evade the definition of the vtk_mapping
  for(unsigned int j=0;j<conn.size();++j){
          elem->set_node(j) = mesh.node_ptr(conn[j]);
  }
  elem->set_id(i);

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

  mesh.add_elem(elem);
  } // end loop over VTK cells
  _vtk_grid->Delete();

  // 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

#endif // LIBMESH_HAVE_VTK
}

void libMesh::VTKIO::set_compression

(

bool

b

)

[inline]

Definition at line 116 of file vtk_io.h.

References _compress.

                               {
    this->_compress = b;
  }

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

void libMesh::VTKIO::system_vectors_to_vtk	(	const EquationSystems &	es,
		vtkUnstructuredGrid *&	grid
	)			[private]

write the system vectors to vtk

Definition at line 242 of file vtk_io.C.

References data, libMesh::err, libMesh::EquationSystems::get_mesh(), libMesh::EquationSystems::get_system(), libMesh::MeshBase::n_nodes(), libMesh::EquationSystems::n_systems(), libMesh::processor_id(), libMesh::System::vectors_begin(), and libMesh::System::vectors_end().

                                                                                     {
        if (libMesh::processor_id() == 0){

                std::map<std::string,std::vector<Number> > vecs;
                for(unsigned int i=0;i<es.n_systems();++i){
                        const System& sys = es.get_system(i);
                        System::const_vectors_iterator v_end = sys.vectors_end();
                        System::const_vectors_iterator it = sys.vectors_begin();
                        for(;it!= v_end;++it){ // for all vectors on this system
                                std::vector<Number> values;
//                              libMesh::out<<"it "<<it->first<<std::endl;

                                it->second->localize_to_one(values,0);
//                              libMesh::out<<"finish localize"<<std::endl;
                                vecs[it->first] = values;
                        }
                }


                std::map<std::string,std::vector<Number> >::iterator it = vecs.begin();

                for(;it!=vecs.end();++it){

                        vtkDoubleArray *data = vtkDoubleArray::New();

                        data->SetName(it->first.c_str());

                        libmesh_assert_equal_to (it->second.size(), es.get_mesh().n_nodes());

                        data->SetNumberOfValues(it->second.size());

                        for(unsigned int i=0;i<it->second.size();++i){

#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                                libmesh_do_once (libMesh::err << "Only writing the real part for complex numbers!\n" 
                                                              << "if you need this support contact " << LIBMESH_PACKAGE_BUGREPORT
                                                              << std::endl);
                                data->SetValue(i,it->second[i].real());
#else
                                data->SetValue(i,it->second[i]);
#endif

                        }

                        grid->GetPointData()->AddArray(data);
                        data->Delete();
                }

        }

}

void libMesh::VTKIO::write

(

const std::string &

name

)

[virtual]

Output the mesh without solutions to a .pvtu file

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 544 of file vtk_io.C.

References write_nodal_data().

                                        {
  std::vector<Number> soln;
  std::vector<std::string> names;
  this->write_nodal_data(name, soln, names);
}

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

virtual void libMesh::VTKIO::write_nodal_data	(	const std::string &	,
		const std::vector< Number > &	,
		const std::vector< std::string > &
	)			[virtual]

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

Reimplemented from libMesh::MeshOutput< MeshBase >.

Referenced by write().

---

Member Data Documentation

bool libMesh::VTKIO::_compress [private]

Flag to indicate whether the output should be compressed

Definition at line 157 of file vtk_io.h.

Referenced by set_compression().

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::map<dof_id_type, dof_id_type> libMesh::VTKIO::_local_node_map [private]

maps global node id to node id of partition

Definition at line 162 of file vtk_io.h.

Referenced by cells_to_vtk(), and nodes_to_vtk().

MeshData* libMesh::VTKIO::_mesh_data [private]

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

Definition at line 152 of file vtk_io.h.

Referenced by read().

vtkUnstructuredGrid* libMesh::VTKIO::_vtk_grid [private]

pointer to the VTK grid

Definition at line 146 of file vtk_io.h.

Referenced by cells_to_vtk(), get_vtk_grid(), nodes_to_vtk(), read(), and VTKIO().

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(), read(), libMesh::Nemesis_IO::read(), libMesh::GMVIO::read(), libMesh::ExodusII_IO::read(), libMesh::UNVIO::read_implementation(), libMesh::UCDIO::read_implementation(), libMesh::LegacyXdrIO::read_mesh(), and libMesh::XdrIO::read_serialized_connectivity().

---

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

• vtk_io.h
• vtk_io.C