libMesh::VTKIO Class Reference

This class implements reading and writing meshes in the VTK format. More...

#include <vtk_io.h>

Inheritance diagram for libMesh::VTKIO:

Classes
struct	ElementMaps
	Helper object that holds a map from VTK to libMesh element types and vice-versa. More...

Public Member Functions
	VTKIO (MeshBase &mesh)
	Constructor.
	VTKIO (const MeshBase &mesh)
	Constructor.
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &) override
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.
virtual void	read (const std::string &) override
	This method implements reading a mesh from a specified file in VTK format.
virtual void	write (const std::string &) override
	Output the mesh without solutions to a .pvtu file.
void	set_compression (bool b)
	Setter for compression flag.
vtkUnstructuredGrid *	get_vtk_grid ()
	Get a pointer to the VTK unstructured grid data structure.
bool	is_parallel_format () const
	Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_discontinuous_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with discontinuous data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
	This method may be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data (const std::string &, const EquationSystems &, const std::set< std::string > *)
	This method should be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data_discontinuous (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
	This method implements writing a mesh with discontinuous data to a specified file where the nodal data and variables names are provided.
unsigned int &	ascii_precision ()
	Return/set the precision to use when writing ASCII files.

Protected Member Functions
MeshBase &	mesh ()
void	set_n_partitions (unsigned int n_parts)
	Sets the number of partitions in the mesh.
void	skip_comment_lines (std::istream &in, const char comment_start)
	Reads input from in, skipping all the lines that start with the character comment_start.
const MeshBase &	mesh () const
virtual bool	get_add_sides ()

Protected Attributes
std::vector< bool >	elems_of_dimension
	A vector of bools describing what dimension elements have been encountered when reading a mesh.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
const bool	_serial_only_needed_on_proc_0
	Flag specifying whether this format can be written by only serializing the mesh to processor zero.

Private Member Functions
void	nodes_to_vtk ()
	write the nodes from the mesh into a vtkUnstructuredGrid and update the local_node_map.
void	cells_to_vtk ()
	write the cells from the mesh into a vtkUnstructuredGrid
void	node_values_to_vtk (const std::string &name, const std::vector< Real > &local_values)
	write the nodal values of soln to a vtkUnstructuredGrid
void	get_local_node_values (std::vector< Number > &local_values, std::size_t variable, const std::vector< Number > &soln, const std::vector< std::string > &names)
	Extract the values of soln that correspond to the nodes.

Static Private Member Functions
static std::map< ElemMappingType, ElementMaps >	build_element_maps ()
	Static function used to construct _element_maps.

Private Attributes
vtkSmartPointer< vtkUnstructuredGrid >	_vtk_grid
	Write the system vectors to vtk.
bool	_compress
	Flag to indicate whether the output should be compressed.
std::map< dof_id_type, dof_id_type >	_local_node_map
	maps global node id to node id of partition
MeshBase *	_obj
	A pointer to a non-const object object.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
unsigned int	_ascii_precision
	Precision to use when writing ASCII files.

Static Private Attributes
static std::map< ElemMappingType, ElementMaps >	_element_maps = VTKIO::build_element_maps()
	ElementMaps objects that are built statically and used by all instances of this class.

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

John W. Peterson

Date

2007

Definition at line 60 of file vtk_io.h.

Constructor & Destructor Documentation

VTKIO() [1/2]

libMesh::VTKIO::VTKIO ( MeshBase &  mesh )

explicit

Constructor.

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

Definition at line 89 of file vtk_io.C.

                             :
  MeshInput<MeshBase> (mesh, /*is_parallel_format=*/true),
  MeshOutput<MeshBase>(mesh, /*is_parallel_format=*/true)
#ifdef LIBMESH_HAVE_VTK
  ,_compress(false)
#endif
{
}
 
 
 
// Constructor for writing
VTKIO::VTKIO (const MeshBase & mesh) :
  MeshOutput<MeshBase>(mesh, /*is_parallel_format=*/true)
#ifdef LIBMESH_HAVE_VTK
  ,_compress(false)
#endif
{
}
 
 
 
// Output the mesh without solutions to a .pvtu file
void VTKIO::write (const std::string & name)
{
  std::vector<Number> soln;
  std::vector<std::string> names;
  this->write_nodal_data(name, soln, names);
}

VTKIO() [2/2]

libMesh::VTKIO::VTKIO ( const MeshBase &  mesh )

explicit

Constructor.

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

Member Function Documentation

ascii_precision()

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

inlineinherited

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

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

Definition at line 160 of file mesh_output.h.

{
  return _ascii_precision;
}

build_element_maps()

std::map< ElemMappingType, VTKIO::ElementMaps > libMesh::VTKIO::build_element_maps ( )

staticprivate

Static function used to construct _element_maps.

Definition at line 129 of file vtk_io.C.

{
  // Object to be filled up
  std::map<ElemMappingType, VTKIO::ElementMaps> all_maps;
  ElementMaps em; // Lagrange element maps
 
  em.associate(EDGE2, VTK_LINE);
  em.associate(EDGE3, VTK_QUADRATIC_EDGE);
  em.associate(TRI3, VTK_TRIANGLE);
  em.associate(TRI6, VTK_QUADRATIC_TRIANGLE);
  em.associate(QUAD4, VTK_QUAD);
  em.associate(QUAD8, VTK_QUADRATIC_QUAD);
  em.associate(TET4, VTK_TETRA);
  em.associate(TET10, VTK_QUADRATIC_TETRA);
  em.associate(HEX8, VTK_HEXAHEDRON);
  em.associate(HEX20, VTK_QUADRATIC_HEXAHEDRON);
  em.associate(HEX27, VTK_TRIQUADRATIC_HEXAHEDRON);
  em.associate(PRISM6, VTK_WEDGE);
  em.associate(PRISM15, VTK_QUADRATIC_WEDGE);
  em.associate(PRISM18, VTK_BIQUADRATIC_QUADRATIC_WEDGE);
  em.associate(PYRAMID5, VTK_PYRAMID);
 
  // VTK_BIQUADRATIC_QUAD has been around since VTK 5.0
#if VTK_MAJOR_VERSION > 5 || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION > 0)
  em.associate(QUAD9, VTK_BIQUADRATIC_QUAD);
#endif
 
  // TRI3SUBDIVISION is for writing only
  em.writing_map[TRI3SUBDIVISION] = VTK_TRIANGLE;
  all_maps[ElemMappingType::LAGRANGE_MAP] = em;
 
 
  // VTK_BEZIER_* types were introduced in VTK 9.0
#if VTK_VERSION_LESS_THAN(9,0,0)
  // Revert back to previous behavior when using an older version of VTK
  all_maps[ElemMappingType::RATIONAL_BERNSTEIN_MAP] = em;
#else
  ElementMaps bem; // Rational Bernstein element maps
  bem.associate(EDGE2, VTK_LINE);
  bem.associate(EDGE3, VTK_BEZIER_CURVE);
  bem.associate(TRI3, VTK_TRIANGLE);
  bem.associate(TRI6, VTK_BEZIER_TRIANGLE);
  bem.associate(QUAD4, VTK_QUAD);
  bem.associate(QUAD8, VTK_QUADRATIC_QUAD);
  bem.associate(QUAD9, VTK_BEZIER_QUADRILATERAL);
  bem.associate(TET4, VTK_TETRA);
  bem.associate(TET10, VTK_QUADRATIC_TETRA);
  bem.associate(HEX8, VTK_HEXAHEDRON);
  bem.associate(HEX20, VTK_QUADRATIC_HEXAHEDRON);
  bem.associate(HEX27, VTK_BEZIER_HEXAHEDRON);
  bem.associate(PRISM6, VTK_WEDGE);
  bem.associate(PRISM15, VTK_QUADRATIC_WEDGE);
  bem.associate(PRISM18, VTK_BEZIER_WEDGE);
  bem.associate(PYRAMID5, VTK_PYRAMID);
  bem.writing_map[TRI3SUBDIVISION] = VTK_TRIANGLE;
  all_maps[ElemMappingType::RATIONAL_BERNSTEIN_MAP] = bem;
#endif
 
  return all_maps;
}

References libMesh::VTKIO::ElementMaps::associate(), libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::LAGRANGE_MAP, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, libMesh::TRI6, and libMesh::VTKIO::ElementMaps::writing_map.

cells_to_vtk()

void libMesh::VTKIO::cells_to_vtk ( )

private

write the cells from the mesh into a vtkUnstructuredGrid

Definition at line 685 of file vtk_io.C.

{
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  auto& element_map = libmesh_map_find(_element_maps, mesh.default_mapping_type());
  vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
  vtkSmartPointer<vtkIdList> pts = vtkSmartPointer<vtkIdList>::New();
 
  std::vector<int> types(mesh.n_active_local_elem());
 
  // We already created this but we need to add more if we have any
  // ghost nodes
  vtkAbstractArray * abstract_node_id =
    _vtk_grid->GetPointData()->GetAbstractArray("libmesh_node_id");
  vtkIntArray * node_id = vtkIntArray::SafeDownCast(abstract_node_id);
  libmesh_assert(node_id);
 
  vtkSmartPointer<vtkIntArray> elem_id = vtkSmartPointer<vtkIntArray>::New();
  elem_id->SetName("libmesh_elem_id");
  elem_id->SetNumberOfComponents(1);
 
  vtkSmartPointer<vtkIntArray> subdomain_id = vtkSmartPointer<vtkIntArray>::New();
  subdomain_id->SetName("subdomain_id");
  subdomain_id->SetNumberOfComponents(1);
 
  vtkSmartPointer<vtkIntArray> elem_proc_id = vtkSmartPointer<vtkIntArray>::New();
  elem_proc_id->SetName("processor_id");
  elem_proc_id->SetNumberOfComponents(1);
 
  unsigned active_element_counter = 0;
  for (const auto & elem : mesh.active_local_element_ptr_range())
    {
      // When using rational bernstein these hold the weights
      if ( elem->type() == NODEELEM )
        continue;
 
      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,
           n_conn = cast_int<unsigned int>(conn.size());
           i != n_conn; ++i)
        {
          // If the node ID is not found in the _local_node_map, we'll
          // add it to the _vtk_grid.  NOTE[JWP]: none of the examples
          // I have actually enters this section of code...
          if (!_local_node_map.count(conn[i]))
            {
              dof_id_type global_node_id = elem->node_id(i);
 
              const Point & the_node = mesh.point(global_node_id);
 
              // InsertNextPoint accepts either a double or float array of length 3.
              double pt[3] = {0., 0., 0.};
              for (unsigned int d=0; d<LIBMESH_DIM; ++d)
                pt[d] = double(the_node(d));
 
              // Insert the point into the _vtk_grid
              vtkIdType local = _vtk_grid->GetPoints()->InsertNextPoint(pt);
 
              // Update the _local_node_map with the ID returned by VTK
              _local_node_map[global_node_id] =
                cast_int<dof_id_type>(local);
 
              node_id->InsertTuple1(local, global_node_id);
            }
 
          // Otherwise, the node ID was found in the _local_node_map, so
          // insert it into the vtkIdList.
          pts->InsertId(i, _local_node_map[conn[i]]);
        }
 
      vtkIdType vtkcellid = cells->InsertNextCell(pts);
      types[active_element_counter] = cast_int<int>(element_map.find(elem->type()));
 
      elem_id->InsertTuple1(vtkcellid, elem->id());
      subdomain_id->InsertTuple1(vtkcellid, elem->subdomain_id());
      elem_proc_id->InsertTuple1(vtkcellid, elem->processor_id());
      ++active_element_counter;
    } // end loop over active elements
 
  _vtk_grid->SetCells(types.data(), cells);
  _vtk_grid->GetCellData()->AddArray(elem_id);
  _vtk_grid->GetCellData()->AddArray(subdomain_id);
  _vtk_grid->GetCellData()->AddArray(elem_proc_id);
}

References _element_maps, _local_node_map, _vtk_grid, libMesh::MeshBase::default_mapping_type(), libMesh::libmesh_assert(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_active_local_elem(), libMesh::NODEELEM, libMesh::MeshBase::point(), and libMesh::VTK.

Referenced by write_nodal_data().

get_add_sides()

virtual bool libMesh::MeshOutput< MeshBase >::get_add_sides ( )

inlineprotectedvirtualinherited

Returns

Whether or not added sides are expected to be output, to plot SIDE_DISCONTINUOUS data. Subclasses should override this if they are capable of plotting such data.

Reimplemented in libMesh::ExodusII_IO.

Definition at line 176 of file mesh_output.h.

{ return false; }

get_local_node_values()

void libMesh::VTKIO::get_local_node_values ( std::vector< Number > &  local_values, std::size_t  variable, const std::vector< Number > &  soln, const std::vector< std::string > &  names  )

private

Extract the values of soln that correspond to the nodes.

This method overwrites all values in local_values

Definition at line 794 of file vtk_io.C.

{
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
  std::size_t num_vars = names.size();
  dof_id_type num_nodes = mesh.n_nodes();
 
  local_values.clear();
  local_values.resize(_local_node_map.size(), 0.0);
 
  // loop over all nodes and get the solution for the current
  // variable, if the node is in the current partition
  for (dof_id_type k=0; k<num_nodes; ++k)
    if (const auto local_node_it = _local_node_map.find(k);
        local_node_it != _local_node_map.end())
      local_values[local_node_it->second] = soln[k*num_vars + variable];
}

References _local_node_map, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), and libMesh::MeshBase::n_nodes().

Referenced by write_nodal_data().

get_vtk_grid()

vtkUnstructuredGrid * libMesh::VTKIO::get_vtk_grid

(

)

Get a pointer to the VTK unstructured grid data structure.

Definition at line 591 of file vtk_io.C.

{
  return _vtk_grid;
}

References _vtk_grid.

is_parallel_format()

bool libMesh::MeshInput< MeshBase >::is_parallel_format ( ) const

inlineinherited

Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.

Definition at line 87 of file mesh_input.h.

{ return this->_is_parallel_format; }

mesh() [1/2]

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

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 94 of file mesh_input.h.

{
  libmesh_error_msg_if(_obj == nullptr, "ERROR: _obj should not be nullptr!");
  return *_obj;
}

mesh() [2/2]

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

inlineprotectedinherited

Returns

The object as a read-only reference.

Definition at line 168 of file mesh_output.h.

{
  libmesh_assert(_obj);
  return *_obj;
}

node_values_to_vtk()

void libMesh::VTKIO::node_values_to_vtk ( const std::string &  name, const std::vector< Real > &  local_values  )

private

write the nodal values of soln to a vtkUnstructuredGrid

Definition at line 775 of file vtk_io.C.

{
  vtkSmartPointer<vtkDoubleArray> data = vtkSmartPointer<vtkDoubleArray>::New();
  data->SetName(name.c_str());
 
  libmesh_assert_equal_to(_local_node_map.size(), local_values.size());
 
  // number of local and ghost nodes
  data->SetNumberOfValues(_local_node_map.size());
 
  // copy values into vtk
  for (auto i : index_range(local_values)) {
    data->SetValue(i, double(local_values[i]));
  }
 
  _vtk_grid->GetPointData()->AddArray(data);
}

References _local_node_map, _vtk_grid, and libMesh::index_range().

Referenced by write_nodal_data().

nodes_to_vtk()

void libMesh::VTKIO::nodes_to_vtk ( )

private

write the nodes from the mesh into a vtkUnstructuredGrid and update the local_node_map.

Definition at line 605 of file vtk_io.C.

{
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // containers for points and coordinates of points
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  vtkSmartPointer<vtkDoubleArray> pcoords = vtkSmartPointer<vtkDoubleArray>::New();
  // if this grid is to be used in VTK then the dimension of the points should be 3
  pcoords->SetNumberOfComponents(LIBMESH_DIM);
  pcoords->Allocate(3*mesh.n_local_nodes());
  points->SetNumberOfPoints(mesh.n_local_nodes()); // it seems that it needs this to prevent a segfault
 
  // SetRationalWeights() was introduced in VTK 9.0
#if !VTK_VERSION_LESS_THAN(9,0,0)
  bool have_weights = false;
  int weight_index = 0;
  vtkSmartPointer<vtkDoubleArray> rational_weights;
 
  if (mesh.default_mapping_type() == ElemMappingType::RATIONAL_BERNSTEIN_MAP)
  {
    rational_weights = vtkSmartPointer<vtkDoubleArray>::New();
    rational_weights->SetName("RationalWeights");
    rational_weights->SetNumberOfComponents(1);
    weight_index = static_cast<int>(mesh.default_mapping_data());
    have_weights = true;
  }
#endif
 
  vtkSmartPointer<vtkIntArray> node_id = vtkSmartPointer<vtkIntArray>::New();
  node_id->SetName("libmesh_node_id");
  node_id->SetNumberOfComponents(1);
 
  unsigned int local_node_counter = 0;
 
  for (const auto & node_ptr : mesh.local_node_ptr_range())
    {
      const Node & node = *node_ptr;
 
      double pnt[3] = {0, 0, 0};
      for (unsigned int i=0; i<LIBMESH_DIM; ++i)
        pnt[i] = double(node(i));
 
      // Fill mapping between global and local node numbers
      _local_node_map[node.id()] = local_node_counter;
 
      // add point
#if VTK_VERSION_LESS_THAN(7,1,0)
      pcoords->InsertNextTupleValue(pnt);
#else
      pcoords->InsertNextTuple(pnt);
#endif
#if !VTK_VERSION_LESS_THAN(9,0,0)
      if (have_weights)
      {
        Real weight = node.get_extra_datum<Real>(weight_index);
        rational_weights->InsertTuple1(local_node_counter, double(weight));
      }
#endif
 
      node_id->InsertTuple1(local_node_counter, node.id());
 
      ++local_node_counter;
    }
 
  // add coordinates to points
  points->SetData(pcoords);
 
  // add points to grid
  _vtk_grid->SetPoints(points);
  _vtk_grid->GetPointData()->AddArray(node_id);
 
#if !VTK_VERSION_LESS_THAN(9,0,0)
  if (have_weights)
    _vtk_grid->GetPointData()->SetRationalWeights(rational_weights);
 
#endif
}

References _local_node_map, _vtk_grid, libMesh::MeshBase::default_mapping_data(), libMesh::MeshBase::default_mapping_type(), libMesh::DofObject::get_extra_datum(), libMesh::DofObject::id(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_local_nodes(), libMesh::RATIONAL_BERNSTEIN_MAP, and libMesh::Real.

Referenced by write_nodal_data().

read()

void libMesh::VTKIO::read ( const std::string &  name )

overridevirtual

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

FIXME: This is known to write nonsense on AMR meshes and it strips the imaginary parts of complex Numbers.

As with other Mesh IO classes, this interface is still still "available" when !LIBMESH_HAVE_VTK, however, it will throw a runtime error.

This function is not currently used by anything, so it is commented out, and may eventually be removed entirely.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 258 of file vtk_io.C.

{
  // 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);
 
  // Keep track of what kinds of elements this file contains
  elems_of_dimension.clear();
  elems_of_dimension.resize(4, false);
 
  // VTK XML unstructured grid files come in two root-element forms: a
  // plain serial "UnstructuredGrid" file (conventionally .vtu), and a
  // "PUnstructuredGrid" descriptor (conventionally .pvtu) referencing one
  // or more serial piece files for parallel use.  Each needs a different
  // reader class.  Sniff the file's actual root <VTKFile type="..."/>
  // attribute rather than assuming one from the extension (or, worse,
  // always assuming one -- vtkXMLPUnstructuredGridReader silently yields
  // an empty grid, rather than any diagnostic, when handed the other
  // format).
  std::string file_type;
  {
    vtkSmartPointer<vtkXMLFileReadTester> tester =
      vtkSmartPointer<vtkXMLFileReadTester>::New();
    tester->SetFileName(name.c_str());
 
    libmesh_error_msg_if
      (!tester->TestReadFile(),
       "Error: " << name << " does not appear to be a VTK XML file.");
 
    const char * file_type_cstr = tester->GetFileDataType();
    libmesh_error_msg_if
      (!file_type_cstr,
       "Error: " << name << " does not specify a VTK XML data type.");
    file_type = file_type_cstr;
  }
 
  if (file_type == "PUnstructuredGrid")
    {
      vtkSmartPointer<vtkXMLPUnstructuredGridReader> reader =
        vtkSmartPointer<vtkXMLPUnstructuredGridReader>::New();
      reader->SetFileName(name.c_str());
      reader->Update();
      _vtk_grid = reader->GetOutput();
    }
  else if (file_type == "UnstructuredGrid")
    {
      vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
        vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
      reader->SetFileName(name.c_str());
      reader->Update();
      _vtk_grid = reader->GetOutput();
    }
  else
    libmesh_error_msg
      ("Error: " << name << " is a VTK XML file of type \"" << file_type
       << "\", but libMesh's VTKIO reader only supports \"UnstructuredGrid\" "
       "(.vtu) and \"PUnstructuredGrid\" (.pvtu) files.");
 
  // Get a reference to the mesh
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // Clear out any pre-existing data from the Mesh
  mesh.clear();
 
  // Try to preserve any libMesh ids and subdomain ids we find in the
  // file.  This will be null if there are none, e.g. if a non-libMesh
  // program wrote this file.
 
  vtkAbstractArray * abstract_elem_id =
    _vtk_grid->GetCellData()->GetAbstractArray("libmesh_elem_id");
  vtkAbstractArray * abstract_node_id =
    _vtk_grid->GetPointData()->GetAbstractArray("libmesh_node_id");
  vtkAbstractArray * abstract_subdomain_id =
    _vtk_grid->GetCellData()->GetAbstractArray("subdomain_id");
 
  // Get ids as integers.  This will be null if they are another data
  // type, e.g. if a non-libMesh program used the names we thought
  // were unique for different data.
  vtkIntArray * elem_id = vtkIntArray::SafeDownCast(abstract_elem_id);
  vtkIntArray * node_id = vtkIntArray::SafeDownCast(abstract_node_id);
  vtkIntArray * subdomain_id = vtkIntArray::SafeDownCast(abstract_subdomain_id);
 
  if (abstract_elem_id && !elem_id)
    libmesh_warning("Found non-integral libmesh_elem_id array; forced to ignore it.\n"
                    "This is technically valid but probably broken.");
 
  if (abstract_node_id && !node_id)
    libmesh_warning("Found non-integral libmesh_node_id array; forced to ignore it.\n"
                    "This is technically valid but probably broken.");
 
  if (abstract_subdomain_id && !subdomain_id)
    libmesh_warning("Found non-integral subdomain_id array; forced to ignore it.\n"
                    "This is technically valid but probably broken.");
 
  // Get the number of points from the _vtk_grid object
  const unsigned int vtk_num_points = static_cast<unsigned int>(_vtk_grid->GetNumberOfPoints());
 
  // Map from VTK indexing to libMesh id if necessary
  std::vector<dof_id_type> vtk_node_to_libmesh;
  if (node_id)
    vtk_node_to_libmesh.resize(vtk_num_points);
 
  // always numbered nicely so we can loop like this
  for (unsigned int i=0; i<vtk_num_points; ++i)
    {
      // add to the id map
      // and add the actual point
      double pnt[3];
      _vtk_grid->GetPoint(static_cast<vtkIdType>(i), pnt);
      Point xyz(pnt[0], pnt[1], pnt[2]);
 
      if (node_id)
        {
          auto id = node_id->GetValue(i);
 
          // It would nice to distinguish between "duplicate nodes
          // because one was ghosted in a parallel file segment" and
          // "duplicate nodes because there was a bug", but I'm not
          // sure how to do that with vtkXMLPUnstructuredGridReader
          if (!mesh.query_node_ptr(id))
            mesh.add_point(xyz, id);
          vtk_node_to_libmesh[i] = id;
        }
      else
        mesh.add_point(xyz, i);
    }
 
  // Get the number of cells from the _vtk_grid object
  const unsigned int vtk_num_cells = static_cast<unsigned int>(_vtk_grid->GetNumberOfCells());
 
  auto& element_map = libmesh_map_find(_element_maps, mesh.default_mapping_type());
 
  vtkSmartPointer<vtkGenericCell> cell = vtkSmartPointer<vtkGenericCell>::New();
  for (unsigned int i=0; i<vtk_num_cells; ++i)
    {
      _vtk_grid->GetCell(i, cell);
 
      std::unique_ptr<Elem> elem;
 
      // VTK polyhedra are described by a stream of polygonal faces
      // rather than by an ordered node list, so they are built
      // separately as C0Polyhedron elements with their nodes already
      // assigned via their sides.
      if (cell->GetCellType() == VTK_POLYHEDRON)
        elem = add_vtk_polyhedron(*_vtk_grid, mesh,
                                  static_cast<vtkIdType>(i),
                                  node_id, vtk_node_to_libmesh);
      else
        {
          // Get the libMesh element type corresponding to this VTK element type.
          ElemType libmesh_elem_type = element_map.find(cell->GetCellType());
          elem = Elem::build(libmesh_elem_type);
 
          // get the straightforward numbering from the VTK cells
          for (auto j : elem->node_index_range())
            {
              const auto vtk_point_id = cell->GetPointId(j);
              const dof_id_type libmesh_node_id = node_id ?
                vtk_node_to_libmesh[vtk_point_id] : vtk_point_id;
 
              elem->set_node(j, mesh.node_ptr(libmesh_node_id));
            }
 
          // 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,
               n_conn = cast_int<unsigned int>(conn.size());
               j != n_conn; ++j)
            elem->set_node(j, mesh.node_ptr(conn[j]));
        }
 
      if (elem_id)
        {
          auto id = elem_id->GetValue(i);
          libmesh_error_msg_if
            (mesh.query_elem_ptr(id), "Duplicate element id " << id <<
             " found in libmesh_elem_ids");
          elem->set_id(id);
        }
      else
        elem->set_id(i);
 
      if (subdomain_id)
        {
          auto sbdid = subdomain_id->GetValue(i);
          elem->subdomain_id() = sbdid;
        }
 
      elems_of_dimension[elem->dim()] = true;
 
      mesh.add_elem(std::move(elem));
    } // end loop over VTK cells
 
  // 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
  libmesh_error_msg_if(mesh.mesh_dimension() > LIBMESH_DIM,
                       "Cannot open dimension "
                       << mesh.mesh_dimension()
                       << " mesh file when configured without "
                       << mesh.mesh_dimension()
                       << "D support.");
#endif // LIBMESH_DIM < 3
}

References _element_maps, _vtk_grid, libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::Elem::build(), libMesh::MeshBase::clear(), libMesh::MeshBase::default_mapping_type(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::query_elem_ptr(), libMesh::MeshBase::query_node_ptr(), libMesh::MeshBase::set_mesh_dimension(), tester(), and libMesh::VTK.

Referenced by libMesh::NameBasedIO::read(), and MeshInputTest::testVTKReadNotAnXMLFile().

set_compression()

void libMesh::VTKIO::set_compression

(

bool

b

)

Setter for compression flag.

Definition at line 598 of file vtk_io.C.

{
  this->_compress = b;
}

References _compress, and b.

set_n_partitions()

void libMesh::MeshInput< MeshBase >::set_n_partitions ( unsigned int  n_parts )

inlineprotectedinherited

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 101 of file mesh_input.h.

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

skip_comment_lines()

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.

Definition at line 113 of file mesh_input.h.

{
  char c, line[256];
 
  while (in.get(c), c==comment_start)
    in.getline (line, 255);
 
  // put back first character of
  // first non-comment line
  in.putback (c);
}

write()

virtual void libMesh::VTKIO::write ( const std::string &  )

overridevirtual

Output the mesh without solutions to a .pvtu file.

As with other Mesh IO classes, this interface is still still "available" when !LIBMESH_HAVE_VTK, however, it will throw a runtime error.

Implements libMesh::MeshOutput< MeshBase >.

Referenced by main(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testVTKPreserveElemIds(), MeshInputTest::testVTKPreserveSubdomainIds(), and libMesh::NameBasedIO::write().

write_discontinuous_equation_systems()

void libMesh::MeshOutput< MeshBase >::write_discontinuous_equation_systems ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names = nullptr  )

virtualinherited

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

Definition at line 101 of file mesh_output.C.

{
  LOG_SCOPE("write_discontinuous_equation_systems()", "MeshOutput");
 
  // We may need to gather and/or renumber a DistributedMesh to output
  // it, making that const qualifier in our constructor a dirty lie
  MT & my_mesh = const_cast<MT &>(*_obj);
 
  // If we're asked to write data that's associated with a different
  // mesh, output files full of garbage are the result.
  libmesh_assert_equal_to(&es.get_mesh(), _obj);
 
  // A non-renumbered mesh may not have a contiguous numbering, and
  // that needs to be fixed before we can build a solution vector.
  if (my_mesh.max_elem_id() != my_mesh.n_elem() ||
      my_mesh.max_node_id() != my_mesh.n_nodes())
    {
      // If we were allowed to renumber then we should have already
      // been properly renumbered...
      libmesh_assert(!my_mesh.allow_renumbering());
 
      libmesh_do_once(libMesh::out <<
                      "Warning:  This MeshOutput subclass only supports meshes which are contiguously renumbered!"
                      << std::endl;);
 
      my_mesh.allow_renumbering(true);
 
      my_mesh.renumber_nodes_and_elements();
 
      // Not sure what good going back to false will do here, the
      // renumbering horses have already left the barn...
      my_mesh.allow_renumbering(false);
    }
 
  MeshSerializer serialize(const_cast<MT &>(*_obj), !_is_parallel_format, _serial_only_needed_on_proc_0);
 
  // Build the list of variable names that will be written.
  std::vector<std::string> names;
  es.build_variable_names  (names, nullptr, system_names);
 
  if (!_is_parallel_format)
    {
      // Build the nodal solution values & get the variable
      // names from the EquationSystems object
      std::vector<Number> soln;
      es.build_discontinuous_solution_vector (soln, system_names,
                                              nullptr, false, /* defaults */
                                              this->get_add_sides());
 
      this->write_nodal_data_discontinuous (fname, soln, names);
    }
  else // _is_parallel_format
    {
      libmesh_not_implemented();
    }
}

write_equation_systems()

void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names = nullptr  )

virtualinherited

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, and libMesh::ExodusII_IO.

Definition at line 92 of file mesh_output.C.

{
  LOG_SCOPE("write_equation_systems()", "MeshOutput");
 
  // We may need to gather and/or renumber a DistributedMesh to output
  // it, making that const qualifier in our constructor a dirty lie
  MT & my_mesh = const_cast<MT &>(*_obj);
 
  // If we're asked to write data that's associated with a different
  // mesh, output files full of garbage are the result.
  libmesh_assert_equal_to(&es.get_mesh(), _obj);
 
  // A non-parallel format, non-renumbered mesh may not have a contiguous
  // numbering, and that needs to be fixed before we can build a solution vector.
  if (!_is_parallel_format &&
      (my_mesh.max_elem_id() != my_mesh.n_elem() ||
       my_mesh.max_node_id() != my_mesh.n_nodes()))
    {
      // If we were allowed to renumber then we should have already
      // been properly renumbered...
      libmesh_assert(!my_mesh.allow_renumbering());
 
      libmesh_do_once(libMesh::out <<
                      "Warning:  This MeshOutput subclass only supports meshes which are contiguously renumbered!"
                      << std::endl;);
 
      my_mesh.allow_renumbering(true);
 
      my_mesh.renumber_nodes_and_elements();
 
      // Not sure what good going back to false will do here, the
      // renumbering horses have already left the barn...
      my_mesh.allow_renumbering(false);
    }
 
  if (!_is_parallel_format)
    {
      MeshSerializer serialize(const_cast<MT &>(*_obj), !_is_parallel_format, _serial_only_needed_on_proc_0);
 
      // Build the list of variable names that will be written.
      std::vector<std::string> names;
      es.build_variable_names  (names, nullptr, system_names);
 
      // Build the nodal solution values & get the variable
      // names from the EquationSystems object
      std::vector<Number> soln;
      es.build_solution_vector (soln, system_names,
                                this->get_add_sides());
 
      this->write_nodal_data (fname, soln, names);
    }
  else // _is_parallel_format
    this->write_nodal_data (fname, es, system_names);
}

write_nodal_data() [1/3]

void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  fname, const EquationSystems &  es, const std::set< std::string > *  system_names  )

virtualinherited

This method should be overridden by "parallel" output formats for writing nodal data.

Instead of getting a localized copy of the nodal solution vector, it directly uses EquationSystems current_local_solution vectors to look up nodal values.

If not implemented, reorders the solutions into a nodal-only NumericVector and calls the above version of this function.

Reimplemented in libMesh::Nemesis_IO.

Definition at line 149 of file mesh_output.C.

{
  std::vector<std::string> names;
  es.build_variable_names  (names, nullptr, system_names);
 
  std::unique_ptr<NumericVector<Number>> parallel_soln =
    es.build_parallel_solution_vector(system_names);
 
  this->write_nodal_data (fname, *parallel_soln, names);
}

write_nodal_data() [2/3]

void libMesh::MeshOutput< MeshBase >::write_nodal_data ( const std::string &  fname, const NumericVector< Number > &  parallel_soln, const std::vector< std::string > &  names  )

virtualinherited

This method may be overridden by "parallel" output formats for writing nodal data.

Instead of getting a localized copy of the nodal solution vector, it is passed a NumericVector of type=PARALLEL which is in node-major order i.e. (u0,v0,w0, u1,v1,w1, u2,v2,w2, u3,v3,w3, ...) and contains n_nodes*n_vars total entries. Then, it is up to the individual I/O class to extract the required solution values from this vector and write them in parallel.

If not implemented, localizes the parallel vector into a std::vector and calls the other version of this function.

Reimplemented in libMesh::Nemesis_IO.

Definition at line 136 of file mesh_output.C.

{
  // This is the fallback implementation for parallel I/O formats that
  // do not yet implement proper writing in parallel, and instead rely
  // on the full solution vector being available on all processors.
  std::vector<Number> soln;
  parallel_soln.localize(soln);
  this->write_nodal_data(fname, soln, names);
}

write_nodal_data() [3/3]

void libMesh::VTKIO::write_nodal_data ( const std::string &  fname, const std::vector< Number > &  soln, const std::vector< std::string > &  names  )

overridevirtual

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

As with other Mesh IO classes, this interface is still still "available" when !LIBMESH_HAVE_VTK, however, it will throw a runtime error.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 473 of file vtk_io.C.

{
  // Warn that the .pvtu file extension should be used.  Paraview
  // recognizes this, and it works in both serial and parallel.  Only
  // warn about this once.
  if (!Utility::ends_with(fname, ".pvtu"))
    libmesh_do_once(libMesh::err << "The .pvtu extension should be used when writing VTK files in libMesh.");
 
  // If there are variable names being written, the solution vector
  // should not be empty, it should have been broadcast to all
  // processors by the MeshOutput base class, since VTK is a parallel
  // format.  Verify this before going further.
  libmesh_error_msg_if(!names.empty() && soln.empty(),
                       "Empty soln vector in VTKIO::write_nodal_data().");
 
  // Get a reference to the mesh
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // we only use Unstructured grids
  _vtk_grid = vtkSmartPointer<vtkUnstructuredGrid>::New();
  vtkSmartPointer<vtkXMLPUnstructuredGridWriter> writer = vtkSmartPointer<vtkXMLPUnstructuredGridWriter>::New();
#ifdef LIBMESH_HAVE_MPI
  // Set VTK to the same communicator as libMesh
  vtkSmartPointer<vtkMPICommunicator> vtk_comm = vtkSmartPointer<vtkMPICommunicator>::New();
  MPI_Comm mpi_comm = mesh.comm().get();
  vtkMPICommunicatorOpaqueComm vtk_opaque_comm(&mpi_comm);
  vtk_comm->InitializeExternal(&vtk_opaque_comm);
 
  vtkSmartPointer<vtkMPIController> vtk_mpi_ctrl = vtkSmartPointer<vtkMPIController>::New();
  vtk_mpi_ctrl->SetCommunicator(vtk_comm);
 
  writer->SetController(vtk_mpi_ctrl);
#endif
 
  // add nodes to the grid and update _local_node_map
  _local_node_map.clear();
  this->nodes_to_vtk();
 
  // add cells to the grid
  this->cells_to_vtk();
 
  // add nodal solutions to the grid, if solutions are given
  if (names.size() > 0)
    {
      std::size_t num_vars = names.size();
      std::vector<Number> local_values;
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      std::vector<Real> local_real_values;
#endif
 
      for (std::size_t variable=0; variable<num_vars; ++variable)
        {
          get_local_node_values(local_values, variable, soln, names);
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
          // write real part
          local_real_values.resize(local_values.size());
          std::transform(local_values.begin(), local_values.end(),
                         local_real_values.begin(),
                         [](Number x) { return x.real(); });
          node_values_to_vtk(names[variable] + "_real", local_real_values);
 
          // write imaginary part
          local_real_values.resize(local_values.size());
          std::transform(local_values.begin(), local_values.end(),
                         local_real_values.begin(),
                         [](Number x) { return x.imag(); });
          node_values_to_vtk(names[variable] + "_imag", local_real_values);
#else
          node_values_to_vtk(names[variable], local_values);
#endif
        }
    }
 
  // Tell the writer how many partitions exist and on which processor
  // we are currently
  writer->SetNumberOfPieces(mesh.n_processors());
  writer->SetStartPiece(mesh.processor_id());
  writer->SetEndPiece(mesh.processor_id());
 
  // partitions overlap by one node
  // FIXME: According to this document
  // http://paraview.org/Wiki/images/5/51/SC07_tut107_ParaView_Handouts.pdf
  // the ghosts are cells rather than nodes.
  writer->SetGhostLevel(1);
 
  // VTK 6 replaces SetInput() with SetInputData(). See
  // http://www.vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput
  // for the full explanation.
#if VTK_VERSION_LESS_THAN(6,0,0)
  writer->SetInput(_vtk_grid);
#else
  writer->SetInputData(_vtk_grid);
#endif
 
  writer->SetFileName(fname.c_str());
  writer->SetDataModeToAscii();
 
  // compress the output, if desired (switches also to binary)
  if (this->_compress)
    {
#if !VTK_VERSION_LESS_THAN(5,6,0)
      writer->SetCompressorTypeToZLib();
      writer->SetDataModeToBinary();
#else
      libmesh_do_once(libMesh::err << "Compression not implemented with old VTK libs!" << std::endl;);
#endif
    }
 
  writer->Write();
 
}

References _compress, _local_node_map, _vtk_grid, cells_to_vtk(), libMesh::ParallelObject::comm(), libMesh::Utility::ends_with(), libMesh::err, libMesh::Parallel::Communicator::get(), get_local_node_values(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::ParallelObject::n_processors(), node_values_to_vtk(), nodes_to_vtk(), and libMesh::ParallelObject::processor_id().

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

write_nodal_data_discontinuous()

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

inlinevirtualinherited

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 118 of file mesh_output.h.

  { libmesh_not_implemented(); }

Member Data Documentation

_ascii_precision

unsigned int libMesh::MeshOutput< MeshBase >::_ascii_precision

privateinherited

Precision to use when writing ASCII files.

Definition at line 207 of file mesh_output.h.

_compress

bool libMesh::VTKIO::_compress

private

Flag to indicate whether the output should be compressed.

Definition at line 174 of file vtk_io.h.

Referenced by set_compression(), and write_nodal_data().

_element_maps

std::map< ElemMappingType, VTKIO::ElementMaps > libMesh::VTKIO::_element_maps = VTKIO::build_element_maps()

staticprivate

ElementMaps objects that are built statically and used by all instances of this class.

Definition at line 215 of file vtk_io.h.

Referenced by cells_to_vtk(), and read().

_is_parallel_format [1/2]

const bool libMesh::MeshInput< MeshBase >::_is_parallel_format

privateinherited

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 130 of file mesh_input.h.

_is_parallel_format [2/2]

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 184 of file mesh_output.h.

_local_node_map

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 179 of file vtk_io.h.

Referenced by cells_to_vtk(), get_local_node_values(), node_values_to_vtk(), nodes_to_vtk(), and write_nodal_data().

_obj

MeshBase * libMesh::MeshInput< MeshBase >::_obj

privateinherited

A pointer to a non-const object object.

This allows us to read the object from file.

Definition at line 123 of file mesh_input.h.

_serial_only_needed_on_proc_0

const bool libMesh::MeshOutput< MeshBase >::_serial_only_needed_on_proc_0

protectedinherited

Flag specifying whether this format can be written by only serializing the mesh to processor zero.

If this is false (default) the mesh will be serialized to all processors

Definition at line 193 of file mesh_output.h.

_vtk_grid

vtkSmartPointer<vtkUnstructuredGrid> libMesh::VTKIO::_vtk_grid

private

Write the system vectors to vtk.

This function is not currently used by anything, so it is commented out, and may eventually be removed entirely. pointer to the VTK grid. the vtkSmartPointer will automatically initialize the value to null and keep track of reference counting.

Definition at line 169 of file vtk_io.h.

Referenced by cells_to_vtk(), get_vtk_grid(), node_values_to_vtk(), nodes_to_vtk(), read(), and write_nodal_data().

elems_of_dimension

std::vector<bool> libMesh::MeshInput< MeshBase >::elems_of_dimension

protectedinherited

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

Definition at line 107 of file mesh_input.h.

---

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

• include/mesh/vtk_io.h
• src/mesh/vtk_io.C