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. More...
	VTKIO (const MeshBase &mesh)
	Constructor. More...
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. More...
virtual void	read (const std::string &) override
	This method implements reading a mesh from a specified file in VTK format. More...
virtual void	write (const std::string &) override
	Output the mesh without solutions to a .pvtu file. More...
void	set_compression (bool b)
	Setter for compression flag. More...
vtkUnstructuredGrid *	get_vtk_grid ()
	Get a pointer to the VTK unstructured grid data structure. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
unsigned int &	ascii_precision ()
	Return/set the precision to use when writing ASCII files. More...

Protected Member Functions
MeshBase &	mesh ()
void	set_n_partitions (unsigned int n_parts)
	Sets the number of partitions in the mesh. More...
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. More...
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. More...
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable. More...
const bool	_serial_only_needed_on_proc_0
	Flag specifying whether this format can be written by only serializing the mesh to processor zero. More...

Private Member Functions
void	nodes_to_vtk ()
	write the nodes from the mesh into a vtkUnstructuredGrid and update the local_node_map. More...
void	cells_to_vtk ()
	write the cells from the mesh into a vtkUnstructuredGrid More...
void	node_values_to_vtk (const std::string &name, const std::vector< Real > &local_values)
	write the nodal values of soln to a vtkUnstructuredGrid More...
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. More...

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

Private Attributes
vtkSmartPointer< vtkUnstructuredGrid >	_vtk_grid
	Write the system vectors to vtk. More...
bool	_compress
	Flag to indicate whether the output should be compressed. More...
std::map< dof_id_type, dof_id_type >	_local_node_map
	maps global node id to node id of partition More...

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

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

Referenced by libMesh::UNVIO::nodes_out(), libMesh::FroIO::write(), libMesh::STLIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::GMVIO::write_ascii_new_impl(), and libMesh::GMVIO::write_ascii_old_impl().

{
  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 122 of file vtk_io.C.

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.

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

cells_to_vtk()

void libMesh::VTKIO::cells_to_vtk ( )

private

write the cells from the mesh into a vtkUnstructuredGrid

Definition at line 564 of file vtk_io.C.

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

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

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 673 of file vtk_io.C.

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

Referenced by write_nodal_data().

{
  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];
}

get_vtk_grid()

vtkUnstructuredGrid * libMesh::VTKIO::get_vtk_grid

(

)

Get a pointer to the VTK unstructured grid data structure.

Definition at line 470 of file vtk_io.C.

References _vtk_grid.

{
  return _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.

References libMesh::MeshInput< MT >::_is_parallel_format.

{ return this->_is_parallel_format; }

mesh() [1/2]

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

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 178 of file mesh_input.h.

Referenced by libMesh::GMVIO::_read_one_cell(), cells_to_vtk(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::Nemesis_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::elements_in(), libMesh::UNVIO::elements_out(), get_local_node_values(), libMesh::ExodusII_IO::get_sideset_data_indices(), libMesh::UNVIO::groups_in(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::nodes_in(), libMesh::UNVIO::nodes_out(), nodes_to_vtk(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::GMVIO::read(), libMesh::STLIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read(), read(), libMesh::STLIO::read_ascii(), libMesh::CheckpointIO::read_bcs(), libMesh::STLIO::read_binary(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::UNVIO::read_implementation(), libMesh::GmshIO::read_mesh(), libMesh::DynaIO::read_mesh(), libMesh::CheckpointIO::read_nodes(), libMesh::CheckpointIO::read_nodesets(), libMesh::CheckpointIO::read_remote_elem(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::ExodusII_IO::read_sideset_data(), libMesh::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::CheckpointIO::read_subdomain_names(), libMesh::STLIO::write(), libMesh::TetGenIO::write(), libMesh::Nemesis_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::ExodusII_IO::write(), libMesh::GMVIO::write_ascii_new_impl(), libMesh::GMVIO::write_ascii_old_impl(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::Nemesis_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_elemsets(), libMesh::UCDIO::write_header(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_interior_elems(), libMesh::GmshIO::write_mesh(), libMesh::UCDIO::write_nodal_data(), write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::UCDIO::write_nodes(), libMesh::CheckpointIO::write_nodesets(), libMesh::XdrIO::write_parallel(), libMesh::GmshIO::write_post(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::ExodusII_IO::write_sideset_data(), libMesh::UCDIO::write_soln(), and libMesh::CheckpointIO::write_subdomain_names().

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

References libMesh::libmesh_assert().

Referenced by libMesh::FroIO::write(), libMesh::TecplotIO::write(), libMesh::MEDITIO::write(), libMesh::PostscriptIO::write(), libMesh::EnsightIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::TecplotIO::write_binary(), libMesh::TecplotIO::write_nodal_data(), libMesh::MEDITIO::write_nodal_data(), and libMesh::GnuPlotIO::write_solution().

{
  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 654 of file vtk_io.C.

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

Referenced by write_nodal_data().

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

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 484 of file vtk_io.C.

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, libMesh::Real, and libMesh::MeshTools::weight().

Referenced by write_nodal_data().

{
  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
}

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 185 of file vtk_io.C.

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::Quality::name(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::query_elem_ptr(), libMesh::MeshBase::query_node_ptr(), libMesh::MeshBase::set_mesh_dimension(), and libMesh::VTK.

Referenced by libMesh::NameBasedIO::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);

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

  // Use a typedef, because these names are just crazy
  typedef vtkSmartPointer<vtkXMLPUnstructuredGridReader> MyReader;
  MyReader reader = MyReader::New();

  // Pass the filename along to the reader
  reader->SetFileName(name.c_str());

  // Force reading
  reader->Update();

  // read in the grid
  _vtk_grid = reader->GetOutput();

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

      // Get the libMesh element type corresponding to this VTK element type.
      ElemType libmesh_elem_type = element_map.find(cell->GetCellType());
      auto 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
}

set_compression()

void libMesh::VTKIO::set_compression

(

bool

b

)

Setter for compression flag.

Definition at line 477 of file vtk_io.C.

References _compress.

{
  this->_compress = 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.

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

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

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

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

{
  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 89 of file mesh_output.C.

References libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::get_mesh(), libMesh::libmesh_assert(), and libMesh::out.

Referenced by libMesh::ExodusII_IO::write_timestep_discontinuous().

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

Definition at line 31 of file mesh_output.C.

References libMesh::EquationSystems::build_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::get_mesh(), libMesh::libmesh_assert(), and libMesh::out.

Referenced by libMesh::Nemesis_IO::write_timestep().

{
  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::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 352 of file vtk_io.C.

References _compress, _local_node_map, _vtk_grid, cells_to_vtk(), libMesh::ParallelObject::comm(), libMesh::err, TIMPI::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().

{
  // 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 (fname.substr(fname.rfind("."), fname.size()) != ".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();

}

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 149 of file mesh_output.C.

References libMesh::NumericVector< T >::localize().

{
  // 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::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 162 of file mesh_output.C.

References libMesh::EquationSystems::build_parallel_solution_vector(), and libMesh::EquationSystems::build_variable_names().

{
  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_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

_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

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.

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

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

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

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

---

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

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