libMesh::GMVIO Class Reference

#include <gmv_io.h>

Inheritance diagram for libMesh::GMVIO:

Public Member Functions
	GMVIO (const MeshBase &)
	GMVIO (MeshBase &)
virtual void	write (const std::string &) override
virtual void	read (const std::string &mesh_file) override
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &) override
bool &	binary ()
bool &	discontinuous ()
bool &	partitioning ()
bool &	write_subdomain_id_as_material ()
bool &	subdivide_second_order ()
bool &	p_levels ()
void	write_discontinuous_gmv (const std::string &name, const EquationSystems &es, const bool write_partitioning, const std::set< std::string > *system_names=nullptr) const
void	write_ascii_new_impl (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
void	add_cell_centered_data (const std::string &cell_centered_data_name, const std::vector< Real > *cell_centered_data_vals)
void	copy_nodal_solution (EquationSystems &es)
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
virtual void	write_discontinuous_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
virtual void	write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
virtual void	write_nodal_data_discontinuous (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
unsigned int &	ascii_precision ()

Protected Member Functions
MeshBase &	mesh ()
void	set_n_partitions (unsigned int n_parts)
void	skip_comment_lines (std::istream &in, const char comment_start)
const MeshBase &	mesh () const

Protected Attributes
std::vector< bool >	elems_of_dimension
const bool	_is_parallel_format
const bool	_serial_only_needed_on_proc_0

Private Member Functions
void	write_ascii_old_impl (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
void	write_binary (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
void	_read_nodes ()
void	_read_one_cell ()
ElemType	gmv_elem_to_libmesh_elem (std::string elemname)
void	_read_materials ()
void	_read_var ()

Static Private Member Functions
static std::map< std::string, ElemType >	build_reading_element_map ()

Private Attributes
bool	_binary
bool	_discontinuous
bool	_partitioning
bool	_write_subdomain_id_as_material
bool	_subdivide_second_order
bool	_p_levels
std::map< std::string, const std::vector< Real > *>	_cell_centered_data
unsigned int	_next_elem_id
std::map< std::string, std::vector< Number > >	_nodal_data

Static Private Attributes
static std::map< std::string, ElemType >	_reading_element_map = GMVIO::build_reading_element_map()

Detailed Description

This class implements writing meshes in the GMV format. For a full description of the GMV format and to obtain the GMV software see http://www.generalmeshviewer.com

Author

Benjamin S. Kirk

Date

2004

Definition at line 54 of file gmv_io.h.

Constructor & Destructor Documentation

GMVIO() [1/2]

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

explicit

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

Definition at line 240 of file gmv_io.C.

                                   :
  MeshOutput<MeshBase>    (mesh),
  _binary                 (false),
  _discontinuous          (false),
  _partitioning           (true),
  _write_subdomain_id_as_material (false),
  _subdivide_second_order (true),
  _p_levels               (true),
  _next_elem_id           (0)
{
}

GMVIO() [2/2]

libMesh::GMVIO::GMVIO ( MeshBase &  mesh )

explicit

Constructor. Takes a writable reference to a mesh object. This constructor is required to let us read in a mesh.

Definition at line 254 of file gmv_io.C.

                             :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh),
  _binary (false),
  _discontinuous          (false),
  _partitioning           (true),
  _write_subdomain_id_as_material (false),
  _subdivide_second_order (true),
  _p_levels               (true),
  _next_elem_id           (0)
{
}

Member Function Documentation

_read_materials()

void libMesh::GMVIO::_read_materials ( )

private

Definition at line 2044 of file gmv_io.C.

Referenced by read().

{
#ifdef LIBMESH_HAVE_GMV

  // LibMesh assigns materials on a per-cell basis
  libmesh_assert_equal_to (GMVLib::gmv_data.datatype, CELL);

  // Material names: LibMesh has no use for these currently...
  // for (int i = 0; i < GMVLib::gmv_data.num; i++)
  //   {
  //     // Build a 32-char string from the appropriate entries
  //     std::string mat_string(&GMVLib::gmv_data.chardata1[i*33], 32);
  //   }

  for (int i = 0; i < GMVLib::gmv_data.nlongdata1; i++)
    MeshInput<MeshBase>::mesh().elem_ref(i).processor_id() =
      cast_int<processor_id_type>(GMVLib::gmv_data.longdata1[i]-1);

#endif
}

_read_nodes()

void libMesh::GMVIO::_read_nodes ( )

private

Helper functions for reading nodes/cells from a GMV file

Definition at line 2068 of file gmv_io.C.

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

Referenced by read().

{
#ifdef LIBMESH_HAVE_GMV
  // LibMesh writes UNSTRUCT=100 node data
  libmesh_assert_equal_to (GMVLib::gmv_data.datatype, UNSTRUCT);

  // The nodal data is stored in gmv_data.doubledata{1,2,3}
  // and is nnodes long
  for (int i = 0; i < GMVLib::gmv_data.num; i++)
    {
      // Add the point to the Mesh
      MeshInput<MeshBase>::mesh().add_point(Point(GMVLib::gmv_data.doubledata1[i],
                                                  GMVLib::gmv_data.doubledata2[i],
                                                  GMVLib::gmv_data.doubledata3[i]), i);
    }
#endif
}

_read_one_cell()

void libMesh::GMVIO::_read_one_cell ( )

private

Definition at line 2087 of file gmv_io.C.

References _next_elem_id, libMesh::MeshBase::add_elem(), libMesh::Elem::build(), libMesh::Elem::dim(), libMesh::MeshInput< MeshBase >::elems_of_dimension, gmv_elem_to_libmesh_elem(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshBase::node_ptr(), libMesh::DofObject::set_id(), and libMesh::Elem::set_node().

Referenced by read().

{
#ifdef LIBMESH_HAVE_GMV
  // This is either a REGULAR=111 cell or
  // the ENDKEYWORD=207 of the cells
#ifndef NDEBUG
  bool recognized =
    (GMVLib::gmv_data.datatype==REGULAR) ||
    (GMVLib::gmv_data.datatype==ENDKEYWORD);
#endif
  libmesh_assert (recognized);

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

  if (GMVLib::gmv_data.datatype == REGULAR)
    {
      // We need a mapping from GMV element types to LibMesh
      // ElemTypes.  Basically the reverse of the eletypes
      // std::map above.
      //
      // FIXME: Since Quad9's apparently don't exist for GMV, and since
      // In general we write linear sub-elements to GMV files, we need
      // to be careful to read back in exactly what we wrote out...
      //
      // The gmv_data.name1 field is padded with blank characters when
      // it is read in by GMV, so the function that converts it to the
      // libmesh element type needs to take that into account.
      ElemType type = this->gmv_elem_to_libmesh_elem(GMVLib::gmv_data.name1);

      Elem * elem = Elem::build(type).release();
      elem->set_id(_next_elem_id++);

      // Get the ElementDefinition object for this element type
      const ElementDefinition & eledef = eletypes[type];

      // Print out the connectivity information for
      // this cell.
      for (int i=0; i<GMVLib::gmv_data.num2; i++)
        {
          // Map index i to GMV's numbering scheme
          unsigned mapped_i = eledef.node_map[i];

          // Note: Node numbers (as stored in libmesh) are 1-based
          elem->set_node(i) = mesh.node_ptr
            (cast_int<dof_id_type>(GMVLib::gmv_data.longdata1[mapped_i]-1));
        }

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

      // Add the newly-created element to the mesh
      mesh.add_elem(elem);
    }


  if (GMVLib::gmv_data.datatype == ENDKEYWORD)
    {
      // There isn't a cell to read, so we just return
      return;
    }

#endif
}

_read_var()

void libMesh::GMVIO::_read_var ( )

private

Definition at line 2032 of file gmv_io.C.

References _nodal_data.

Referenced by read().

{
#ifdef LIBMESH_HAVE_GMV

  // Copy all the variable's values into a local storage vector.
  _nodal_data.insert ( std::make_pair(std::string(GMVLib::gmv_data.name1),
                                      std::vector<Number>(GMVLib::gmv_data.doubledata1, GMVLib::gmv_data.doubledata1+GMVLib::gmv_data.num) ) );
#endif
}

add_cell_centered_data()

void libMesh::GMVIO::add_cell_centered_data	(	const std::string &	cell_centered_data_name,
		const std::vector< Real > *	cell_centered_data_vals
	)

Takes a vector of cell-centered data to be plotted. You must ensure that for every active element e, v[e->id()] is a valid number. You can add an arbitrary number of different cell-centered data sets by calling this function multiple times.

.) GMV does not like spaces in the cell_centered_data_name .) No matter what order you add cell-centered data, it will be output alphabetically.

Definition at line 1864 of file gmv_io.C.

References _cell_centered_data.

{
  libmesh_assert(cell_centered_data_vals);

  // Make sure there are *at least* enough entries for all the active elements.
  // There can also be entries for inactive elements, they will be ignored.
  // libmesh_assert_greater_equal (cell_centered_data_vals->size(),
  //                           MeshOutput<MeshBase>::mesh().n_active_elem());
  this->_cell_centered_data[cell_centered_data_name] = cell_centered_data_vals;
}

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>::digits10 + 2, which should be enough to write out to ASCII and get the exact same Real back when reading in.

Definition at line 244 of file mesh_output.h.

Referenced by libMesh::TecplotIO::write_ascii(), write_ascii_new_impl(), and write_ascii_old_impl().

{
  return _ascii_precision;
}

binary()

bool& libMesh::GMVIO::binary ( )

inline

Flag indicating whether or not to write a binary file. While binary files may end up being smaller than equivalent ASCII files, they are harder to debug if anything goes wrong, since they are not human-readable.

Definition at line 103 of file gmv_io.h.

References _binary.

Referenced by write(), and write_nodal_data().

{ return _binary; }

build_reading_element_map()

std::map< std::string, ElemType > libMesh::GMVIO::build_reading_element_map ( )

staticprivate

Static function used to build the _reading_element_map.

Definition at line 207 of file gmv_io.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM6, libMesh::QUAD4, libMesh::QUAD8, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.

{
  std::map<std::string, ElemType> ret;

  ret["line"]     = EDGE2;
  ret["tri"]      = TRI3;
  ret["tri3"]     = TRI3;
  ret["quad"]     = QUAD4;
  ret["tet"]      = TET4;
  ret["ptet4"]    = TET4;
  ret["hex"]      = HEX8;
  ret["phex8"]    = HEX8;
  ret["prism"]    = PRISM6;
  ret["pprism6"]  = PRISM6;
  ret["phex20"]   = HEX20;
  ret["phex27"]   = HEX27;
  ret["pprism15"] = PRISM15;
  ret["ptet10"]   = TET10;
  ret["6tri"]     = TRI6;
  ret["8quad"]    = QUAD8;
  ret["3line"]    = EDGE3;

  // Unsupported/Unused types
  // ret["vface2d"]
  // ret["vface3d"]
  // ret["pyramid"]
  // ret["ppyrmd5"]
  // ret["ppyrmd13"]

  return ret;
}

copy_nodal_solution()

void libMesh::GMVIO::copy_nodal_solution

(

EquationSystems &

es

)

If we read in a nodal solution while reading in a mesh, we can attempt to copy that nodal solution into an EquationSystems object.

Definition at line 2168 of file gmv_io.C.

References _nodal_data, libMesh::err, libMesh::FEType::family, libMesh::FIRST, libMesh::OrderWrapper::get_order(), libMesh::EquationSystems::get_system(), libMesh::System::has_variable(), libMesh::LAGRANGE, libMesh::MeshInput< MT >::mesh(), libMesh::EquationSystems::n_systems(), libMesh::FEType::order, libMesh::System::solution, libMesh::System::update(), libMesh::System::variable_number(), and libMesh::System::variable_type().

{
  // Check for easy return if there isn't any nodal data
  if (_nodal_data.empty())
    {
      libMesh::err << "Unable to copy nodal solution: No nodal "
                   << "solution has been read in from file." << std::endl;
      return;
    }

  // Be sure there is at least one system
  libmesh_assert (es.n_systems());

  // Keep track of variable names which have been found and
  // copied already.  This could be used to prevent us from
  // e.g. copying the same var into 2 different systems ...
  // but this seems unlikely.  Also, it is used to tell if
  // any variables which were read in were not successfully
  // copied to the EquationSystems.
  std::set<std::string> vars_copied;

  // For each entry in the nodal data map, try to find a system
  // that has the same variable key name.
  for (unsigned int sys=0; sys<es.n_systems(); ++sys)
    {
      // Get a generic reference to the current System
      System & system = es.get_system(sys);

      // For each var entry in the _nodal_data map, try to find
      // that var in the system
      for (const auto & pr : _nodal_data)
        {
          const std::string & var_name = pr.first;

          if (system.has_variable(var_name))
            {
              // Check if there are as many nodes in the mesh as there are entries
              // in the stored nodal data vector
              libmesh_assert_equal_to (pr.second.size(), MeshInput<MeshBase>::mesh().n_nodes());

              const unsigned int var_num = system.variable_number(var_name);

              // The only type of nodal data we can read in from GMV is for
              // linear LAGRANGE type elements.
              const FEType & fe_type = system.variable_type(var_num);
              if ((fe_type.order.get_order() != FIRST) || (fe_type.family != LAGRANGE))
                {
                  libMesh::err << "Only FIRST-order LAGRANGE variables can be read from GMV files. "
                               << "Skipping variable " << var_name << std::endl;
                  break;
                }


              // Loop over the stored vector's entries, inserting them into
              // the System's solution if appropriate.
              for (dof_id_type i=0,
                   sz = cast_int<dof_id_type>(pr.second.size());
                   i != sz; ++i)
                {
                  // Since this var came from a GMV file, the index i corresponds to
                  // the (single) DOF value of the current variable for node i.
                  const unsigned int dof_index =
                    MeshInput<MeshBase>::mesh().node_ptr(i)->dof_number(sys,      // system #
                                                                        var_num,  // var #
                                                                        0);       // component #, always zero for LAGRANGE

                  // If the dof_index is local to this processor, set the value
                  if ((dof_index >= system.solution->first_local_index()) &&
                      (dof_index <  system.solution->last_local_index()))
                    system.solution->set (dof_index, pr.second [i]);
                } // end loop over my GMVIO's copy of the solution

              // Add the most recently copied var to the set of copied vars
              vars_copied.insert (var_name);
            } // end if (system.has_variable)
        } // end for loop over _nodal_data

      // Communicate parallel values before going to the next system.
      system.solution->close();
      system.update();
    } // end loop over all systems



  // Warn the user if any GMV variables were not successfully copied over to the EquationSystems object
  for (const auto & pr : _nodal_data)
    if (vars_copied.find(pr.first) == vars_copied.end())
      libMesh::err << "Warning: Variable "
                   << pr.first
                   << " was not copied to the EquationSystems object."
                   << std::endl;
}

discontinuous()

bool& libMesh::GMVIO::discontinuous ( )

inline

Flag indicating whether or not to write the mesh as discontinuous cell patches

Definition at line 109 of file gmv_io.h.

References _discontinuous.

{ return _discontinuous; }

gmv_elem_to_libmesh_elem()

ElemType libMesh::GMVIO::gmv_elem_to_libmesh_elem ( std::string  elemname )

private

Definition at line 2151 of file gmv_io.C.

References _reading_element_map.

Referenced by _read_one_cell().

{
  // Erase any whitespace padding in name coming from gmv before performing comparison.
  elemname.erase(std::remove_if(elemname.begin(), elemname.end(), isspace), elemname.end());

  // Look up the string in our string->ElemType name.
  auto it = _reading_element_map.find(elemname);

  if (it == _reading_element_map.end())
    libmesh_error_msg("Unknown/unsupported element: " << elemname << " was read.");

  return it->second;
}

mesh() [1/2]

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

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 169 of file mesh_input.h.

Referenced by _read_one_cell(), libMesh::VTKIO::cells_to_vtk(), libMesh::TetGenIO::element_in(), libMesh::UNVIO::elements_in(), libMesh::UNVIO::elements_out(), libMesh::UNVIO::groups_in(), libMesh::TetGenIO::node_in(), libMesh::UNVIO::nodes_in(), libMesh::UNVIO::nodes_out(), libMesh::VTKIO::nodes_to_vtk(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::VTKIO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::UCDIO::read_implementation(), libMesh::UNVIO::read_implementation(), libMesh::GmshIO::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::OFFIO::read_stream(), libMesh::MatlabIO::read_stream(), libMesh::CheckpointIO::read_subdomain_names(), libMesh::TetGenIO::write(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), write_ascii_new_impl(), write_ascii_old_impl(), write_binary(), write_discontinuous_gmv(), libMesh::Nemesis_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data(), libMesh::UCDIO::write_header(), libMesh::UCDIO::write_implementation(), libMesh::UCDIO::write_interior_elems(), libMesh::GmshIO::write_mesh(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::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::UCDIO::write_soln(), and libMesh::CheckpointIO::write_subdomain_names().

{
  if (_obj == nullptr)
    libmesh_error_msg("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 234 of file mesh_output.h.

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

p_levels()

bool& libMesh::GMVIO::p_levels ( )

inline

Flag indicating whether or not to write p level information for p refined meshes

Definition at line 134 of file gmv_io.h.

References _p_levels.

Referenced by write_ascii_new_impl(), write_ascii_old_impl(), and write_binary().

{ return _p_levels; }

partitioning()

bool& libMesh::GMVIO::partitioning ( )

inline

Flag indicating whether or not to write the partitioning information for the mesh.

Definition at line 115 of file gmv_io.h.

References _partitioning.

Referenced by libMesh::NameBasedIO::write(), write_ascii_new_impl(), write_ascii_old_impl(), write_binary(), and libMesh::NameBasedIO::write_nodal_data().

{ return _partitioning; }

read()

void libMesh::GMVIO::read ( const std::string &  mesh_file )

overridevirtual

This method implements reading a mesh from a specified file.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 1881 of file gmv_io.C.

References _next_elem_id, _read_materials(), _read_nodes(), _read_one_cell(), _read_var(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshBase::clear(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::err, ierr, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::Quality::name(), libMesh::Trees::NODES, libMesh::MeshBase::prepare_for_use(), and libMesh::MeshBase::set_mesh_dimension().

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

  _next_elem_id = 0;

  libmesh_experimental();

#ifndef LIBMESH_HAVE_GMV

  libmesh_error_msg("Cannot read GMV file " << name << " without the GMV API.");

#else
  // We use the file-scope global variable eletypes for mapping nodes
  // from GMV to libmesh indices, so initialize that data now.
  init_eletypes();

  // Clear the mesh so we are sure to start from a pristine state.
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
  mesh.clear();

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

  // It is apparently possible for gmv files to contain
  // a "fromfile" directive (?) But we currently don't make
  // any use of this feature in LibMesh.  Nonzero return val
  // from any function usually means an error has occurred.
  int ierr = GMVLib::gmvread_open_fromfileskip(const_cast<char *>(name.c_str()));
  if (ierr != 0)
    libmesh_error_msg("GMVLib::gmvread_open_fromfileskip failed!");


  // Loop through file until GMVEND.
  int iend = 0;
  while (iend == 0)
    {
      GMVLib::gmvread_data();

      // Check for GMVEND.
      if (GMVLib::gmv_data.keyword == GMVEND)
        {
          iend = 1;
          GMVLib::gmvread_close();
          break;
        }

      // Check for GMVERROR.
      if (GMVLib::gmv_data.keyword == GMVERROR)
        libmesh_error_msg("Encountered GMVERROR while reading!");

      // Process the data.
      switch (GMVLib::gmv_data.keyword)
        {
        case NODES:
          {
            if (GMVLib::gmv_data.num2 == NODES)
              this->_read_nodes();

            else if (GMVLib::gmv_data.num2 == NODE_V)
              libmesh_error_msg("Unsupported GMV data type NODE_V!");

            break;
          }

        case CELLS:
          {
            // Read 1 cell at a time
            this->_read_one_cell();
            break;
          }

        case MATERIAL:
          {
            // keyword == 6
            // These are the materials, which we use to specify the mesh
            // partitioning.
            this->_read_materials();
            break;
          }

        case VARIABLE:
          {
            // keyword == 8
            // This is a field variable.

            // Check to see if we're done reading variables and break out.
            if (GMVLib::gmv_data.datatype == ENDKEYWORD)
              {
                break;
              }

            if (GMVLib::gmv_data.datatype == NODE)
              {
                this->_read_var();
                break;
              }

            else
              {
                libMesh::err << "Warning: Skipping variable: "
                             << GMVLib::gmv_data.name1
                             << " which is of unsupported GMV datatype "
                             << GMVLib::gmv_data.datatype
                             << ".  Nodal field data is currently the only type currently supported."
                             << std::endl;
                break;
              }

          }

        default:
          libmesh_error_msg("Encountered unknown GMV keyword " << GMVLib::gmv_data.keyword);

        } // end switch
    } // end while

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

#if LIBMESH_DIM < 3
  if (mesh.mesh_dimension() > LIBMESH_DIM)
    libmesh_error_msg("Cannot open dimension " \
                      << mesh.mesh_dimension()            \
                      << " mesh file when configured without "        \
                      << mesh.mesh_dimension()                        \
                      << "D support.");
#endif

  // Done reading in the mesh, now call find_neighbors, etc.
  // mesh.find_neighbors();

  // Don't allow renumbering of nodes and elements when calling
  // prepare_for_use().  It is usually confusing for users when the
  // Mesh gets renumbered automatically, since sometimes there are
  // other parts of the simulation which rely on the original
  // ordering.
  mesh.allow_renumbering(false);
  mesh.prepare_for_use();
#endif
}

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 91 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 179 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);
}

subdivide_second_order()

bool& libMesh::GMVIO::subdivide_second_order ( )

inline

Flag indicating whether or not to subdivide second order elements

Definition at line 128 of file gmv_io.h.

References _subdivide_second_order.

Referenced by write_ascii_new_impl(), and write_ascii_old_impl().

{ return _subdivide_second_order; }

write()

void libMesh::GMVIO::write ( const std::string &  fname )

overridevirtual

This method implements writing a mesh to a specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 269 of file gmv_io.C.

References binary(), write_ascii_old_impl(), and write_binary().

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

{
  if (this->binary())
    this->write_binary (fname);
  else
    this->write_ascii_old_impl  (fname);
}

write_ascii_new_impl()

void libMesh::GMVIO::write_ascii_new_impl	(	const std::string &	fname,
		const std::vector< Number > *	v = nullptr,
		const std::vector< std::string > *	solution_names = nullptr
	)

This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are optionally provided. This will write an ASCII file. This is the new implementation (without subcells).

Definition at line 293 of file gmv_io.C.

References _cell_centered_data, std::abs(), libMesh::MeshBase::active_element_ptr_range(), libMesh::MeshOutput< MeshBase >::ascii_precision(), libMesh::err, std::max(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), n_vars, p_levels(), partitioning(), libMesh::MeshBase::point(), libMesh::Real, subdivide_second_order(), write_ascii_old_impl(), and write_subdomain_id_as_material().

{
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS

  libMesh::err << "WARNING:  GMVIO::write_ascii_new_impl() not infinite-element aware!"
               << std::endl;
  libmesh_here();

  // Set it to our current precision
  this->write_ascii_old_impl (fname, v, solution_names);

#else

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

  // This is a parallel_only function
  const unsigned int n_active_elem = mesh.n_active_elem();

  if (MeshOutput<MeshBase>::mesh().processor_id() != 0)
    return;

  // Open the output file stream
  std::ofstream out_stream (fname.c_str());

  out_stream << std::setprecision(this->ascii_precision());

  // Make sure it opened correctly
  if (!out_stream.good())
    libmesh_file_error(fname.c_str());

  unsigned int mesh_max_p_level = 0;

  // Begin interfacing with the GMV data file
  {
    out_stream << "gmvinput ascii\n\n";

    // write the nodes
    out_stream << "nodes " << mesh.n_nodes() << "\n";
    for (unsigned int n=0; n<mesh.n_nodes(); n++)
      out_stream << mesh.point(n)(0) << " ";
    out_stream << "\n";

    for (unsigned int n=0; n<mesh.n_nodes(); n++)
#if LIBMESH_DIM > 1
      out_stream << mesh.point(n)(1) << " ";
#else
    out_stream << 0. << " ";
#endif
    out_stream << "\n";

    for (unsigned int n=0; n<mesh.n_nodes(); n++)
#if LIBMESH_DIM > 2
      out_stream << mesh.point(n)(2) << " ";
#else
    out_stream << 0. << " ";
#endif
    out_stream << "\n\n";
  }

  {
    // write the connectivity
    out_stream << "cells " << n_active_elem << "\n";

    // initialize the eletypes map (eletypes is a file-global variable)
    init_eletypes();

    for (const auto & elem : mesh.active_element_ptr_range())
      {
        mesh_max_p_level = std::max(mesh_max_p_level,
                                    elem->p_level());

        // Make sure we have a valid entry for
        // the current element type.
        libmesh_assert (eletypes.count(elem->type()));

        const ElementDefinition & ele = eletypes[elem->type()];

        // The element mapper better not require any more nodes
        // than are present in the current element!
        libmesh_assert_less_equal (ele.node_map.size(), elem->n_nodes());

        out_stream << ele.label << "\n";
        for (std::size_t i=0; i < ele.node_map.size(); i++)
          out_stream << elem->node_id(ele.node_map[i])+1 << " ";
        out_stream << "\n";
      }
    out_stream << "\n";
  }

  // optionally write the partition information
  if (this->partitioning())
    {
      if (this->write_subdomain_id_as_material())
        libmesh_error_msg("Not yet supported in GMVIO::write_ascii_new_impl");

      else // write processor IDs as materials.  This is the default
        {
          out_stream << "material "
                     << mesh.n_partitions()
            // Note: GMV may give you errors like
            // Error, material for cell 1 is greater than 1
            // Error, material for cell 2 is greater than 1
            // Error, material for cell 3 is greater than 1
            // ... because you put the wrong number of partitions here.
            // To ensure you write the correct number of materials, call
            // mesh.recalculate_n_partitions() before writing out the
            // mesh.
            // Note: we can't call it now because the Mesh is const here and
            // it is a non-const function.
                     << " 0\n";

          for (unsigned int proc=0; proc<mesh.n_partitions(); proc++)
            out_stream << "proc_" << proc << "\n";

          // FIXME - don't we need to use an ElementDefinition here? - RHS
          for (const auto & elem : mesh.active_element_ptr_range())
            out_stream << elem->processor_id()+1 << "\n";
          out_stream << "\n";
        }
    }

  // If there are *any* variables at all in the system (including
  // p level, or arbitrary cell-based data)
  // to write, the gmv file needs to contain the word "variable"
  // on a line by itself.
  bool write_variable = false;

  // 1.) p-levels
  if (this->p_levels() && mesh_max_p_level)
    write_variable = true;

  // 2.) solution data
  if ((solution_names != nullptr) && (v != nullptr))
    write_variable = true;

  // 3.) cell-centered data
  if (!(this->_cell_centered_data.empty()))
    write_variable = true;

  if (write_variable)
    out_stream << "variable\n";

  //   if ((this->p_levels() && mesh_max_p_level) ||
  //     ((solution_names != nullptr) && (v != nullptr)))
  //     out_stream << "variable\n";

  // optionally write the polynomial degree information
  if (this->p_levels() && mesh_max_p_level)
    {
      out_stream << "p_level 0\n";

      for (const auto & elem : mesh.active_element_ptr_range())
        {
          const ElementDefinition & ele = eletypes[elem->type()];

          // The element mapper better not require any more nodes
          // than are present in the current element!
          libmesh_assert_less_equal (ele.node_map.size(), elem->n_nodes());

          for (std::size_t i=0; i < ele.node_map.size(); i++)
            out_stream << elem->p_level() << " ";
        }
      out_stream << "\n\n";
    }


  // optionally write cell-centered data
  if (!(this->_cell_centered_data.empty()))
    {
      for (auto & pr : this->_cell_centered_data)
        {
          // write out the variable name, followed by a zero.
          out_stream << pr.first << " 0\n";

          const std::vector<Real> * the_array = pr.second;

          // Loop over active elements, write out cell data.  If second-order cells
          // are split into sub-elements, the sub-elements inherit their parent's
          // cell-centered data.
          for (const auto & elem : mesh.active_element_ptr_range())
            {
              // Use the element's ID to find the value.
              libmesh_assert_less (elem->id(), the_array->size());
              const Real the_value = the_array->operator[](elem->id());

              if (this->subdivide_second_order())
                for (unsigned int se=0; se < elem->n_sub_elem(); se++)
                  out_stream << the_value << " ";
              else
                out_stream << the_value << " ";
            }

          out_stream << "\n\n";
        }
    }


  // optionally write the data
  if ((solution_names != nullptr) && (v != nullptr))
    {
      const unsigned int n_vars = solution_names->size();

      if (!(v->size() == mesh.n_nodes()*n_vars))
        libMesh::err << "ERROR: v->size()=" << v->size()
                     << ", mesh.n_nodes()=" << mesh.n_nodes()
                     << ", n_vars=" << n_vars
                     << ", mesh.n_nodes()*n_vars=" << mesh.n_nodes()*n_vars
                     << "\n";

      libmesh_assert_equal_to (v->size(), mesh.n_nodes()*n_vars);

      for (unsigned int c=0; c<n_vars; c++)
        {

#ifdef LIBMESH_USE_COMPLEX_NUMBERS

          // in case of complex data, write _three_ data sets
          // for each component

          // this is the real part
          out_stream << "r_" << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c].real() << " ";

          out_stream << "\n\n";

          // this is the imaginary part
          out_stream << "i_" << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c].imag() << " ";

          out_stream << "\n\n";

          // this is the magnitude
          out_stream << "a_" << (*solution_names)[c] << " 1\n";
          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << std::abs((*v)[n*n_vars + c]) << " ";

          out_stream << "\n\n";

#else

          out_stream << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c] << " ";

          out_stream << "\n\n";

#endif
        }

    }

  // If we wrote any variables, we have to close the variable section now
  if (write_variable)
    out_stream << "endvars\n";


  // end of the file
  out_stream << "\nendgmv\n";

#endif
}

write_ascii_old_impl()

void libMesh::GMVIO::write_ascii_old_impl ( const std::string &  fname, const std::vector< Number > *  v = nullptr, const std::vector< std::string > *  solution_names = nullptr  )

private

This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are optionally provided. This will write an ASCII file. This is the old implementation (using subcells) which was the default in libMesh-0.4.3-rc2.

Definition at line 568 of file gmv_io.C.

References _cell_centered_data, std::abs(), libMesh::MeshBase::active_element_ptr_range(), libMesh::MeshOutput< MeshBase >::ascii_precision(), libMesh::Elem::build(), libMesh::Utility::enum_to_string(), libMesh::err, libMesh::FIRST, libMesh::Elem::first_order_equivalent_type(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, std::max(), libMesh::MeshBase::max_node_id(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_active_sub_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::n_partitions(), n_vars, p_levels(), partitioning(), libMesh::MeshBase::point(), libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::Real, subdivide_second_order(), libMesh::TECPLOT, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and write_subdomain_id_as_material().

Referenced by write(), write_ascii_new_impl(), and write_nodal_data().

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

  // Use a MeshSerializer object to gather a parallel mesh before outputting it.
  // Note that we cast away constness here (which is bad), but the destructor of
  // the MeshSerializer object reparallelizes the Mesh, hopefully keeping it
  // "logically const" outside the context of this function...
  MeshSerializer serialize(const_cast<MeshBase &>(mesh),
                           !MeshOutput<MeshBase>::_is_parallel_format);

  // These are parallel_only functions
  const dof_id_type n_active_elem = mesh.n_active_elem(),
    n_active_sub_elem = mesh.n_active_sub_elem();

  if (MeshOutput<MeshBase>::mesh().processor_id() != 0)
    return;

  // Open the output file stream
  std::ofstream out_stream (fname.c_str());

  // Set it to our current precision
  out_stream << std::setprecision(this->ascii_precision());

  // Make sure it opened correctly
  if (!out_stream.good())
    libmesh_file_error(fname.c_str());

  // Make sure our nodes are contiguous and serialized
  libmesh_assert_equal_to (mesh.n_nodes(), mesh.max_node_id());

  // libmesh_assert (mesh.is_serial());
  // if (!mesh.is_serial())
  //   {
  //     if (MeshOutput<MeshBase>::mesh().processor_id() == 0)
  //       libMesh::err << "Error: GMVIO cannot yet write a DistributedMesh solution"
  //                     << std::endl;
  //     return;
  //   }

  unsigned int mesh_max_p_level = 0;

  // Begin interfacing with the GMV data file

  // FIXME - if subdivide_second_order() is off,
  // we probably should only be writing the
  // vertex nodes - RHS
  {
    // write the nodes

    out_stream << "gmvinput ascii\n\n";
    out_stream << "nodes " << mesh.n_nodes() << '\n';
    for (unsigned int n=0; n<mesh.n_nodes(); n++)
      out_stream << mesh.point(n)(0) << " ";

    out_stream << '\n';

    for (unsigned int n=0; n<mesh.n_nodes(); n++)
#if LIBMESH_DIM > 1
      out_stream << mesh.point(n)(1) << " ";
#else
    out_stream << 0. << " ";
#endif

    out_stream << '\n';

    for (unsigned int n=0; n<mesh.n_nodes(); n++)
#if LIBMESH_DIM > 2
      out_stream << mesh.point(n)(2) << " ";
#else
    out_stream << 0. << " ";
#endif

    out_stream << '\n' << '\n';
  }



  {
    // write the connectivity

    out_stream << "cells ";
    if (this->subdivide_second_order())
      out_stream << n_active_sub_elem;
    else
      out_stream << n_active_elem;
    out_stream << '\n';

    // The same temporary storage will be used for each element
    std::vector<dof_id_type> conn;

    for (const auto & elem : mesh.active_element_ptr_range())
      {
        mesh_max_p_level = std::max(mesh_max_p_level,
                                    elem->p_level());

        switch (elem->dim())
          {
          case 1:
            {
              if (this->subdivide_second_order())
                for (unsigned int se=0; se<elem->n_sub_elem(); se++)
                  {
                    out_stream << "line 2\n";
                    elem->connectivity(se, TECPLOT, conn);
                    for (std::size_t i=0; i<conn.size(); i++)
                      out_stream << conn[i] << " ";

                    out_stream << '\n';
                  }
              else
                {
                  out_stream << "line 2\n";
                  if (elem->default_order() == FIRST)
                    elem->connectivity(0, TECPLOT, conn);
                  else
                    {
                      std::unique_ptr<Elem> lo_elem = Elem::build(Elem::first_order_equivalent_type(elem->type()));
                      for (unsigned int i = 0; i != lo_elem->n_nodes(); ++i)
                        lo_elem->set_node(i) = elem->node_ptr(i);
                      lo_elem->connectivity(0, TECPLOT, conn);
                    }
                  for (std::size_t i=0; i<conn.size(); i++)
                    out_stream << conn[i] << " ";

                  out_stream << '\n';
                }

              break;
            }

          case 2:
            {
              if (this->subdivide_second_order())
                for (unsigned int se=0; se<elem->n_sub_elem(); se++)
                  {
                    // Quad elements
                    if ((elem->type() == QUAD4) ||
                        (elem->type() == QUAD8) || // Note: QUAD8 will be output as one central quad and
                        // four surrounding triangles (though they will be written
                        // to GMV as QUAD4s).
                        (elem->type() == QUAD9)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                        || (elem->type() == INFQUAD4)
                        || (elem->type() == INFQUAD6)
#endif
                        )
                      {
                        out_stream << "quad 4\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (std::size_t i=0; i<conn.size(); i++)
                          out_stream << conn[i] << " ";
                      }

                    // Triangle elements
                    else if ((elem->type() == TRI3) ||
                             (elem->type() == TRI6))
                      {
                        out_stream << "tri 3\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (unsigned int i=0; i<3; i++)
                          out_stream << conn[i] << " ";
                      }
                    else
                      libmesh_error_msg("Unsupported element type: " << Utility::enum_to_string(elem->type()));
                  }
              else // !this->subdivide_second_order()
                {
                  // Quad elements
                  if ((elem->type() == QUAD4)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                      || (elem->type() == INFQUAD4)
#endif
                      )
                    {
                      elem->connectivity(0, TECPLOT, conn);
                      out_stream << "quad 4\n";
                      for (std::size_t i=0; i<conn.size(); i++)
                        out_stream << conn[i] << " ";
                    }
                  else if ((elem->type() == QUAD8) ||
                           (elem->type() == QUAD9)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                           || (elem->type() == INFQUAD6)
#endif
                           )
                    {
                      std::unique_ptr<Elem> lo_elem = Elem::build(Elem::first_order_equivalent_type(elem->type()));
                      for (unsigned int i = 0; i != lo_elem->n_nodes(); ++i)
                        lo_elem->set_node(i) = elem->node_ptr(i);
                      lo_elem->connectivity(0, TECPLOT, conn);
                      out_stream << "quad 4\n";
                      for (std::size_t i=0; i<conn.size(); i++)
                        out_stream << conn[i] << " ";
                    }
                  else if (elem->type() == TRI3)
                    {
                      elem->connectivity(0, TECPLOT, conn);
                      out_stream << "tri 3\n";
                      for (unsigned int i=0; i<3; i++)
                        out_stream << conn[i] << " ";
                    }
                  else if (elem->type() == TRI6)
                    {
                      std::unique_ptr<Elem> lo_elem = Elem::build(Elem::first_order_equivalent_type(elem->type()));
                      for (unsigned int i = 0; i != lo_elem->n_nodes(); ++i)
                        lo_elem->set_node(i) = elem->node_ptr(i);
                      lo_elem->connectivity(0, TECPLOT, conn);
                      out_stream << "tri 3\n";
                      for (unsigned int i=0; i<3; i++)
                        out_stream << conn[i] << " ";
                    }

                  out_stream << '\n';
                }

              break;
            }

          case 3:
            {
              if (this->subdivide_second_order())
                for (unsigned int se=0; se<elem->n_sub_elem(); se++)
                  {

#ifndef  LIBMESH_ENABLE_INFINITE_ELEMENTS
                    if ((elem->type() == HEX8)   ||
                        (elem->type() == HEX27))
                      {
                        out_stream << "phex8 8\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (std::size_t i=0; i<conn.size(); i++)
                          out_stream << conn[i] << " ";
                      }

                    else if (elem->type() == HEX20)
                      {
                        out_stream << "phex20 20\n";
                        out_stream << elem->node_id(0)+1  << " "
                                   << elem->node_id(1)+1  << " "
                                   << elem->node_id(2)+1  << " "
                                   << elem->node_id(3)+1  << " "
                                   << elem->node_id(4)+1  << " "
                                   << elem->node_id(5)+1  << " "
                                   << elem->node_id(6)+1  << " "
                                   << elem->node_id(7)+1  << " "
                                   << elem->node_id(8)+1  << " "
                                   << elem->node_id(9)+1  << " "
                                   << elem->node_id(10)+1 << " "
                                   << elem->node_id(11)+1 << " "
                                   << elem->node_id(16)+1 << " "
                                   << elem->node_id(17)+1 << " "
                                   << elem->node_id(18)+1 << " "
                                   << elem->node_id(19)+1 << " "
                                   << elem->node_id(12)+1 << " "
                                   << elem->node_id(13)+1 << " "
                                   << elem->node_id(14)+1 << " "
                                   << elem->node_id(15)+1 << " ";
                      }

                    // According to our copy of gmvread.c, this is the
                    // mapping for the Hex27 element.  Unfortunately,
                    // I tried it and Paraview does not seem to be
                    // able to read Hex27 elements.  Since this is
                    // unlikely to change any time soon, we'll
                    // continue to write out Hex27 elements as 8 Hex8
                    // sub-elements.
                    //
                    // TODO:
                    // 1.) If we really wanted to use this code for
                    // something, we'd want to avoid repeating the
                    // hard-coded node ordering from the HEX20 case.
                    // These should both be able to use
                    // ElementDefinitions.
                    // 2.) You would also need to change
                    // Hex27::n_sub_elem() to return 1, not sure how
                    // much other code that would affect...

                    // else if (elem->type() == HEX27)
                    //   {
                    //     out_stream << "phex27 27\n";
                    //     out_stream << elem->node_id(0)+1  << " "
                    //                << elem->node_id(1)+1  << " "
                    //                << elem->node_id(2)+1  << " "
                    //                << elem->node_id(3)+1  << " "
                    //                << elem->node_id(4)+1  << " "
                    //                << elem->node_id(5)+1  << " "
                    //                << elem->node_id(6)+1  << " "
                    //                << elem->node_id(7)+1  << " "
                    //                << elem->node_id(8)+1  << " "
                    //                << elem->node_id(9)+1  << " "
                    //                << elem->node_id(10)+1 << " "
                    //                << elem->node_id(11)+1 << " "
                    //                << elem->node_id(16)+1 << " "
                    //                << elem->node_id(17)+1 << " "
                    //                << elem->node_id(18)+1 << " "
                    //                << elem->node_id(19)+1 << " "
                    //                << elem->node_id(12)+1 << " "
                    //                << elem->node_id(13)+1 << " "
                    //                << elem->node_id(14)+1 << " "
                    //                << elem->node_id(15)+1 << " "
                    //       // mid-face nodes
                    //                << elem->node_id(21)+1 << " " // GMV front
                    //                << elem->node_id(22)+1 << " " // GMV right
                    //                << elem->node_id(23)+1 << " " // GMV back
                    //                << elem->node_id(24)+1 << " " // GMV left
                    //                << elem->node_id(20)+1 << " " // GMV bottom
                    //                << elem->node_id(25)+1 << " " // GMV top
                    //       // center node
                    //                << elem->node_id(26)+1 << " ";
                    //   }

#else // LIBMESH_ENABLE_INFINITE_ELEMENTS

                    // In case of infinite elements, HEX20
                    // should be handled just like the
                    // INFHEX16, since these connect to each other
                    if ((elem->type() == HEX8)     ||
                        (elem->type() == HEX27)    ||
                        (elem->type() == INFHEX8)  ||
                        (elem->type() == INFHEX16) ||
                        (elem->type() == INFHEX18) ||
                        (elem->type() == HEX20))
                      {
                        out_stream << "phex8 8\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (std::size_t i=0; i<conn.size(); i++)
                          out_stream << conn[i] << " ";
                      }
#endif

                    else if ((elem->type() == TET4)  ||
                             (elem->type() == TET10))
                      {
                        out_stream << "tet 4\n";
                        // Tecplot connectivity returns 8 entries for
                        // the Tet, enough to store it as a degenerate Hex.
                        // For GMV we only pick out the four relevant node
                        // indices.
                        elem->connectivity(se, TECPLOT, conn);
                        out_stream << conn[0] << " "  // libmesh tet node 0
                                   << conn[2] << " "  // libmesh tet node 2
                                   << conn[1] << " "  // libmesh tet node 1
                                   << conn[4] << " "; // libmesh tet node 3
                      }
#ifndef  LIBMESH_ENABLE_INFINITE_ELEMENTS
                    else if ((elem->type() == PRISM6)  ||
                             (elem->type() == PRISM15) ||
                             (elem->type() == PRISM18) ||
                             (elem->type() == PYRAMID5))
#else
                    else if ((elem->type() == PRISM6)     ||
                             (elem->type() == PRISM15)    ||
                             (elem->type() == PRISM18)    ||
                             (elem->type() == PYRAMID5)   ||
                             (elem->type() == INFPRISM6)  ||
                             (elem->type() == INFPRISM12))
#endif
                      {
                        // Note that the prisms are treated as
                        // degenerated phex8's.
                        out_stream << "phex8 8\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (std::size_t i=0; i<conn.size(); i++)
                          out_stream << conn[i] << " ";
                      }

                    else
                      libmesh_error_msg("Encountered an unrecognized element " \
                                        << "type: " << elem->type()  \
                                        << "\nPossibly a dim-1 dimensional " \
                                        << "element?  Aborting...");

                    out_stream << '\n';
                  }
              else // !this->subdivide_second_order()
                {
                  std::unique_ptr<Elem> lo_elem = Elem::build(Elem::first_order_equivalent_type(elem->type()));
                  for (unsigned int i = 0; i != lo_elem->n_nodes(); ++i)
                    lo_elem->set_node(i) = elem->node_ptr(i);
                  if ((lo_elem->type() == HEX8)
#ifdef  LIBMESH_ENABLE_INFINITE_ELEMENTS
                      || (lo_elem->type() == HEX27)
#endif
                      )
                    {
                      out_stream << "phex8 8\n";
                      lo_elem->connectivity(0, TECPLOT, conn);
                      for (std::size_t i=0; i<conn.size(); i++)
                        out_stream << conn[i] << " ";
                    }

                  else if (lo_elem->type() == TET4)
                    {
                      out_stream << "tet 4\n";
                      lo_elem->connectivity(0, TECPLOT, conn);
                      out_stream << conn[0] << " "
                                 << conn[2] << " "
                                 << conn[1] << " "
                                 << conn[4] << " ";
                    }
                  else if ((lo_elem->type() == PRISM6)
#ifdef  LIBMESH_ENABLE_INFINITE_ELEMENTS
                           || (lo_elem->type() == INFPRISM6)
#endif
                           )
                    {
                      // Note that the prisms are treated as
                      // degenerated phex8's.
                      out_stream << "phex8 8\n";
                      lo_elem->connectivity(0, TECPLOT, conn);
                      for (std::size_t i=0; i<conn.size(); i++)
                        out_stream << conn[i] << " ";
                    }

                  else
                    libmesh_error_msg("Encountered an unrecognized element " \
                                      << "type.  Possibly a dim-1 dimensional " \
                                      << "element?  Aborting...");

                  out_stream << '\n';
                }

              break;
            }

          default:
            libmesh_error_msg("Unsupported element dimension: " <<
                              elem->dim());
          }
      }

    out_stream << '\n';
  }



  // optionally write the partition information
  if (this->partitioning())
    {
      if (this->write_subdomain_id_as_material())
        {
          // Subdomain IDs can be non-contiguous and need not
          // necessarily start at 0.  Furthermore, since the user is
          // free to define subdomain_id_type to be a signed type, we
          // can't even assume max(subdomain_id) >= # unique subdomain ids.

          // We build a map<subdomain_id, unsigned> to associate to each
          // user-selected subdomain ID a unique, contiguous unsigned value
          // which we can write to file.
          std::map<subdomain_id_type, unsigned> sbdid_map;

          // Try to insert with dummy value
          for (const auto & elem : mesh.active_element_ptr_range())
            sbdid_map.insert(std::make_pair(elem->subdomain_id(), 0));

          // Map is created, iterate through it to set indices.  They will be
          // used repeatedly below.
          {
            unsigned ctr=0;
            for (auto & pr : sbdid_map)
              pr.second = ctr++;
          }

          out_stream << "material "
                     << sbdid_map.size()
                     << " 0\n";

          for (std::size_t sbdid=0; sbdid<sbdid_map.size(); sbdid++)
            out_stream << "proc_" << sbdid << "\n";

          for (const auto & elem : mesh.active_element_ptr_range())
            {
              // Find the unique index for elem->subdomain_id(), print that to file
              auto map_iter = sbdid_map.find(elem->subdomain_id());

              libmesh_assert_msg(map_iter != sbdid_map.end(), "Entry for subdomain " << elem->subdomain_id() << " not found.");

              unsigned gmv_mat_number = (*map_iter).second;

              if (this->subdivide_second_order())
                for (unsigned int se=0; se<elem->n_sub_elem(); se++)
                  out_stream << gmv_mat_number+1 << '\n';
              else
                out_stream << gmv_mat_number+1 << "\n";
            }
          out_stream << '\n';

        }
      else // write processor IDs as materials.  This is the default
        {
          out_stream << "material "
                     << mesh.n_partitions()
                     << " 0"<< '\n';

          for (unsigned int proc=0; proc<mesh.n_partitions(); proc++)
            out_stream << "proc_" << proc << '\n';

          for (const auto & elem : mesh.active_element_ptr_range())
            if (this->subdivide_second_order())
              for (unsigned int se=0; se<elem->n_sub_elem(); se++)
                out_stream << elem->processor_id()+1 << '\n';
            else
              out_stream << elem->processor_id()+1 << '\n';

          out_stream << '\n';
        }
    }


  // If there are *any* variables at all in the system (including
  // p level, or arbitrary cell-based data)
  // to write, the gmv file needs to contain the word "variable"
  // on a line by itself.
  bool write_variable = false;

  // 1.) p-levels
  if (this->p_levels() && mesh_max_p_level)
    write_variable = true;

  // 2.) solution data
  if ((solution_names != nullptr) && (v != nullptr))
    write_variable = true;

  // 3.) cell-centered data
  if (!(this->_cell_centered_data.empty()))
    write_variable = true;

  if (write_variable)
    out_stream << "variable\n";


  // optionally write the p-level information
  if (this->p_levels() && mesh_max_p_level)
    {
      out_stream << "p_level 0\n";

      for (const auto & elem : mesh.active_element_ptr_range())
        if (this->subdivide_second_order())
          for (unsigned int se=0; se<elem->n_sub_elem(); se++)
            out_stream << elem->p_level() << " ";
        else
          out_stream << elem->p_level() << " ";
      out_stream << "\n\n";
    }




  // optionally write cell-centered data
  if (!(this->_cell_centered_data.empty()))
    {
      for (const auto & pr : this->_cell_centered_data)
        {
          // write out the variable name, followed by a zero.
          out_stream << pr.first << " 0\n";

          const std::vector<Real> * the_array = pr.second;

          // Loop over active elements, write out cell data.  If second-order cells
          // are split into sub-elements, the sub-elements inherit their parent's
          // cell-centered data.
          for (const auto & elem : mesh.active_element_ptr_range())
            {
              // Use the element's ID to find the value...
              libmesh_assert_less (elem->id(), the_array->size());
              const Real the_value = (*the_array)[elem->id()];

              if (this->subdivide_second_order())
                for (unsigned int se=0; se < elem->n_sub_elem(); se++)
                  out_stream << the_value << " ";
              else
                out_stream << the_value << " ";
            }

          out_stream << "\n\n";
        }
    }




  // optionally write the data
  if ((solution_names != nullptr) &&
      (v != nullptr))
    {
      const unsigned int n_vars =
        cast_int<unsigned int>(solution_names->size());

      if (!(v->size() == mesh.n_nodes()*n_vars))
        libMesh::err << "ERROR: v->size()=" << v->size()
                     << ", mesh.n_nodes()=" << mesh.n_nodes()
                     << ", n_vars=" << n_vars
                     << ", mesh.n_nodes()*n_vars=" << mesh.n_nodes()*n_vars
                     << std::endl;

      libmesh_assert_equal_to (v->size(), mesh.n_nodes()*n_vars);

      for (unsigned int c=0; c<n_vars; c++)
        {

#ifdef LIBMESH_USE_COMPLEX_NUMBERS

          // in case of complex data, write _tree_ data sets
          // for each component

          // this is the real part
          out_stream << "r_" << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c].real() << " ";

          out_stream << '\n' << '\n';


          // this is the imaginary part
          out_stream << "i_" << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c].imag() << " ";

          out_stream << '\n' << '\n';

          // this is the magnitude
          out_stream << "a_" << (*solution_names)[c] << " 1\n";
          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << std::abs((*v)[n*n_vars + c]) << " ";

          out_stream << '\n' << '\n';

#else

          out_stream << (*solution_names)[c] << " 1\n";

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            out_stream << (*v)[n*n_vars + c] << " ";

          out_stream << '\n' << '\n';

#endif
        }

    }

  // If we wrote any variables, we have to close the variable section now
  if (write_variable)
    out_stream << "endvars\n";


  // end of the file
  out_stream << "\nendgmv\n";
}

write_binary()

void libMesh::GMVIO::write_binary ( const std::string &  fname, const std::vector< Number > *  vec = nullptr, const std::vector< std::string > *  solution_names = nullptr  )

private

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

Definition at line 1230 of file gmv_io.C.

References _cell_centered_data, std::abs(), libMesh::MeshBase::active_element_ptr_range(), libMesh::err, std::max(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::MeshBase::n_nodes(), libMesh::ParallelObject::n_processors(), n_vars, p_levels(), partitioning(), libMesh::MeshBase::point(), and write_subdomain_id_as_material().

Referenced by write(), and write_nodal_data().

{
  // We use the file-scope global variable eletypes for mapping nodes
  // from GMV to libmesh indices, so initialize that data now.
  init_eletypes();

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

  // This is a parallel_only function
  const dof_id_type n_active_elem = mesh.n_active_elem();

  if (MeshOutput<MeshBase>::mesh().processor_id() != 0)
    return;

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

  libmesh_assert (out_stream.good());

  unsigned int mesh_max_p_level = 0;

  std::string buffer;

  // Begin interfacing with the GMV data file
  {
    // write the nodes
    buffer = "gmvinput";
    out_stream.write(buffer.c_str(), buffer.size());

    buffer = "ieeei4r4";
    out_stream.write(buffer.c_str(), buffer.size());
  }



  // write the nodes
  {
    buffer = "nodes   ";
    out_stream.write(buffer.c_str(), buffer.size());

    unsigned int tempint = mesh.n_nodes();
    out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

    // write the x coordinate
    std::vector<float> temp(mesh.n_nodes());
    for (unsigned int v=0; v<mesh.n_nodes(); v++)
      temp[v] = static_cast<float>(mesh.point(v)(0));
    out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());

    // write the y coordinate
    for (unsigned int v=0; v<mesh.n_nodes(); v++)
      {
#if LIBMESH_DIM > 1
        temp[v] = static_cast<float>(mesh.point(v)(1));
#else
        temp[v] = 0.;
#endif
      }
    out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());

    // write the z coordinate
    for (unsigned int v=0; v<mesh.n_nodes(); v++)
      {
#if LIBMESH_DIM > 2
        temp[v] = static_cast<float>(mesh.point(v)(2));
#else
        temp[v] = 0.;
#endif
      }
    out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());
  }


  // write the connectivity
  {
    buffer = "cells   ";
    out_stream.write(buffer.c_str(), buffer.size());

    unsigned int tempint = n_active_elem;
    out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

    for (const auto & elem : mesh.active_element_ptr_range())
      {
        mesh_max_p_level = std::max(mesh_max_p_level,
                                    elem->p_level());

        // The ElementDefinition label contains the GMV name
        // and the number of nodes for the respective
        // element.
        const ElementDefinition & ed = eletypes[elem->type()];

        // The ElementDefinition labels all have a name followed by a
        // whitespace and then the number of nodes.  To write the
        // string in binary, we want to drop everything after that
        // space, and then pad the string out to 8 characters.
        buffer = ed.label;

        // Erase everything from the first whitespace character to the end of the string.
        buffer.erase(buffer.find_first_of(' '), std::string::npos);

        // Append whitespaces until the string is exactly 8 characters long.
        while (buffer.size() < 8)
          buffer.insert(buffer.end(), ' ');

        // Finally, write the 8 character stream to file.
        out_stream.write(buffer.c_str(), buffer.size());

        // Write the number of nodes that this type of element has.
        // Note: don't want to use the number of nodes of the element,
        // because certain elements, like QUAD9 and HEX27 only support
        // being written out as lower-order elements (QUAD8 and HEX20,
        // respectively).
        tempint = cast_int<unsigned int>(ed.node_map.size());
        out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

        // Write the element connectivity
        for (std::size_t i=0; i<ed.node_map.size(); i++)
          {
            dof_id_type id = elem->node_id(ed.node_map[i]) + 1;
            out_stream.write(reinterpret_cast<char *>(&id), sizeof(dof_id_type));
          }
      }
  }



  // optionally write the partition information
  if (this->partitioning())
    {
      if (this->write_subdomain_id_as_material())
        libmesh_error_msg("Not yet supported in GMVIO::write_binary");

      else
        {
          buffer = "material";
          out_stream.write(buffer.c_str(), buffer.size());

          unsigned int tmpint = mesh.n_processors();
          out_stream.write(reinterpret_cast<char *>(&tmpint), sizeof(unsigned int));

          tmpint = 0; // IDs are cell based
          out_stream.write(reinterpret_cast<char *>(&tmpint), sizeof(unsigned int));

          for (unsigned int proc=0; proc<mesh.n_processors(); proc++)
            {
              // We have to write exactly 8 bytes.  This means that
              // the processor id can be up to 3 characters long, and
              // we pad it with blank characters on the end.
              std::ostringstream oss;
              oss << "proc_" << std::setw(3) << std::left << proc;
              out_stream.write(oss.str().c_str(), oss.str().size());
            }

          std::vector<unsigned int> proc_id (n_active_elem);

          unsigned int n=0;

          // We no longer write sub-elems in GMV, so just assign a
          // processor id value to each element.
          for (const auto & elem : mesh.active_element_ptr_range())
            proc_id[n++] = elem->processor_id() + 1;

          out_stream.write(reinterpret_cast<char *>(proc_id.data()),
                           sizeof(unsigned int)*proc_id.size());
        }
    }

  // If there are *any* variables at all in the system (including
  // p level, or arbitrary cell-based data)
  // to write, the gmv file needs to contain the word "variable"
  // on a line by itself.
  bool write_variable = false;

  // 1.) p-levels
  if (this->p_levels() && mesh_max_p_level)
    write_variable = true;

  // 2.) solution data
  if ((solution_names != nullptr) && (vec != nullptr))
    write_variable = true;

  //   // 3.) cell-centered data - unsupported
  //   if (!(this->_cell_centered_data.empty()))
  //     write_variable = true;

  if (write_variable)
    {
      buffer = "variable";
      out_stream.write(buffer.c_str(), buffer.size());
    }

  // optionally write the partition information
  if (this->p_levels() && mesh_max_p_level)
    {
      unsigned int n_floats = n_active_elem;
      for (unsigned int i=0; i != mesh.mesh_dimension(); ++i)
        n_floats *= 2;

      std::vector<float> temp(n_floats);

      buffer = "p_level";
      out_stream.write(buffer.c_str(), buffer.size());

      unsigned int tempint = 0; // p levels are cell data
      out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

      unsigned int n=0;
      for (const auto & elem : mesh.active_element_ptr_range())
        for (unsigned int se=0; se<elem->n_sub_elem(); se++)
          temp[n++] = static_cast<float>( elem->p_level() );

      out_stream.write(reinterpret_cast<char *>(temp.data()),
                       sizeof(float)*n_floats);
    }


  // optionally write cell-centered data
  if (!(this->_cell_centered_data.empty()))
    libMesh::err << "Cell-centered data not (yet) supported in binary I/O mode!" << std::endl;




  // optionally write the data
  if ((solution_names != nullptr) &&
      (vec != nullptr))
    {
      std::vector<float> temp(mesh.n_nodes());

      const unsigned int n_vars =
        cast_int<unsigned int>(solution_names->size());

      for (unsigned int c=0; c<n_vars; c++)
        {

#ifdef LIBMESH_USE_COMPLEX_NUMBERS
          // for complex data, write three datasets


          // Real part
          buffer = "r_";
          out_stream.write(buffer.c_str(), buffer.size());

          buffer = (*solution_names)[c];
          out_stream.write(buffer.c_str(), buffer.size());

          unsigned int tempint = 1; // always do nodal data
          out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            temp[n] = static_cast<float>( (*vec)[n*n_vars + c].real() );

          out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());


          // imaginary part
          buffer = "i_";
          out_stream.write(buffer.c_str(), buffer.size());

          buffer = (*solution_names)[c];
          out_stream.write(buffer.c_str(), buffer.size());

          out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            temp[n] = static_cast<float>( (*vec)[n*n_vars + c].imag() );

          out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());

          // magnitude
          buffer = "a_";
          out_stream.write(buffer.c_str(), buffer.size());
          buffer = (*solution_names)[c];
          out_stream.write(buffer.c_str(), buffer.size());

          out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            temp[n] = static_cast<float>(std::abs((*vec)[n*n_vars + c]));

          out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());

#else

          buffer = (*solution_names)[c];
          out_stream.write(buffer.c_str(), buffer.size());

          unsigned int tempint = 1; // always do nodal data
          out_stream.write(reinterpret_cast<char *>(&tempint), sizeof(unsigned int));

          for (unsigned int n=0; n<mesh.n_nodes(); n++)
            temp[n] = static_cast<float>((*vec)[n*n_vars + c]);

          out_stream.write(reinterpret_cast<char *>(temp.data()), sizeof(float)*mesh.n_nodes());

#endif
        }
    }

  // If we wrote any variables, we have to close the variable section now
  if (write_variable)
    {
      buffer = "endvars ";
      out_stream.write(buffer.c_str(), buffer.size());
    }

  // end the file
  buffer = "endgmv  ";
  out_stream.write(buffer.c_str(), buffer.size());
}

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

References libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EquationSystems::get_mesh(), 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);

      this->write_nodal_data_discontinuous (fname, soln, names);
    }
  else // _is_parallel_format
    {
      libmesh_not_implemented();
    }
}

write_discontinuous_gmv()

void libMesh::GMVIO::write_discontinuous_gmv	(	const std::string &	name,
		const EquationSystems &	es,
		const bool	write_partitioning,
		const std::set< std::string > *	system_names = nullptr
	)		const

Writes a GMV file with discontinuous data

Definition at line 1551 of file gmv_io.C.

References _cell_centered_data, _write_subdomain_id_as_material, std::abs(), libMesh::MeshBase::active_element_ptr_range(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::EquationSystems::build_variable_names(), libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::Utility::enum_to_string(), libMesh::err, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFEDGE2, libMesh::INFHEX16, libMesh::INFHEX18, libMesh::INFHEX8, libMesh::INFPRISM12, libMesh::INFPRISM6, libMesh::INFQUAD4, libMesh::INFQUAD6, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::ParallelObject::n_processors(), n_vars, libMesh::Quality::name(), libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::ParallelObject::processor_id(), libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.

Referenced by libMesh::ErrorVector::plot_error().

{
  std::vector<std::string> solution_names;
  std::vector<Number>      v;

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

  es.build_variable_names  (solution_names, nullptr, system_names);
  es.build_discontinuous_solution_vector (v, system_names);

  // These are parallel_only functions
  const unsigned int n_active_elem = mesh.n_active_elem();

  if (mesh.processor_id() != 0)
    return;

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

  libmesh_assert (out_stream.good());

  // Begin interfacing with the GMV data file
  {

    // write the nodes
    out_stream << "gmvinput ascii" << std::endl << std::endl;

    // Compute the total weight
    {
      unsigned int tw=0;

      for (const auto & elem : mesh.active_element_ptr_range())
        tw += elem->n_nodes();

      out_stream << "nodes " << tw << std::endl;
    }



    // Write all the x values
    {
      for (const auto & elem : mesh.active_element_ptr_range())
        for (unsigned int n=0; n<elem->n_nodes(); n++)
          out_stream << elem->point(n)(0) << " ";

      out_stream << std::endl;
    }


    // Write all the y values
    {
      for (const auto & elem : mesh.active_element_ptr_range())
        for (unsigned int n=0; n<elem->n_nodes(); n++)
#if LIBMESH_DIM > 1
          out_stream << elem->point(n)(1) << " ";
#else
      out_stream << 0. << " ";
#endif

      out_stream << std::endl;
    }


    // Write all the z values
    {
      for (const auto & elem : mesh.active_element_ptr_range())
        for (unsigned int n=0; n<elem->n_nodes(); n++)
#if LIBMESH_DIM > 2
          out_stream << elem->point(n)(2) << " ";
#else
      out_stream << 0. << " ";
#endif

      out_stream << std::endl << std::endl;
    }
  }



  {
    // write the connectivity

    out_stream << "cells " << n_active_elem << std::endl;

    unsigned int nn=1;

    switch (mesh.mesh_dimension())
      {
      case 1:
        {
          for (const auto & elem : mesh.active_element_ptr_range())
            for (unsigned int se=0; se<elem->n_sub_elem(); se++)
              {
                if ((elem->type() == EDGE2) ||
                    (elem->type() == EDGE3) ||
                    (elem->type() == EDGE4)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                    || (elem->type() == INFEDGE2)
#endif
                    )
                  {
                    out_stream << "line 2" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";

                  }
                else
                  libmesh_error_msg("Unsupported 1D element type: " << Utility::enum_to_string(elem->type()));

                out_stream << std::endl;
              }

          break;
        }

      case 2:
        {
          for (const auto & elem : mesh.active_element_ptr_range())
            for (unsigned int se=0; se<elem->n_sub_elem(); se++)
              {
                if ((elem->type() == QUAD4) ||
                    (elem->type() == QUAD8) || // Note: QUAD8 will be output as one central quad and
                    // four surrounding triangles (though they will be written
                    // to GMV as QUAD4s).
                    (elem->type() == QUAD9)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                    || (elem->type() == INFQUAD4)
                    || (elem->type() == INFQUAD6)
#endif
                    )
                  {
                    out_stream << "quad 4" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";

                  }
                else if ((elem->type() == TRI3) ||
                         (elem->type() == TRI6))
                  {
                    out_stream << "tri 3" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";

                  }
                else
                  libmesh_error_msg("Unsupported 2D element type: " << Utility::enum_to_string(elem->type()));

                out_stream << std::endl;
              }

          break;
        }


      case 3:
        {
          for (const auto & elem : mesh.active_element_ptr_range())
            for (unsigned int se=0; se<elem->n_sub_elem(); se++)
              {
                if ((elem->type() == HEX8) ||
                    (elem->type() == HEX20) ||
                    (elem->type() == HEX27)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                    || (elem->type() == INFHEX8)
                    || (elem->type() == INFHEX16)
                    || (elem->type() == INFHEX18)
#endif
                    )
                  {
                    out_stream << "phex8 8" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";
                  }
                else if ((elem->type() == PRISM6) ||
                         (elem->type() == PRISM15) ||
                         (elem->type() == PRISM18)
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
                         || (elem->type() == INFPRISM6)
                         || (elem->type() == INFPRISM12)
#endif
                         )
                  {
                    out_stream << "pprism6 6" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";
                  }
                else if ((elem->type() == TET4) ||
                         (elem->type() == TET10))
                  {
                    out_stream << "tet 4" << std::endl;
                    for (unsigned int i=0; i<elem->n_nodes(); i++)
                      out_stream << nn++ << " ";
                  }
                else
                  libmesh_error_msg("Unsupported 3D element type: " << Utility::enum_to_string(elem->type()));

                out_stream << std::endl;
              }

          break;
        }

      default:
        libmesh_error_msg("Unsupported mesh dimension: " << mesh.mesh_dimension());
      }

    out_stream << std::endl;
  }



  // optionally write the partition information
  if (write_partitioning)
    {
      if (_write_subdomain_id_as_material)
        libmesh_error_msg("Not yet supported in GMVIO::write_discontinuous_gmv");

      else
        {
          out_stream << "material "
                     << mesh.n_processors()
                     << " 0"<< std::endl;

          for (unsigned int proc=0; proc<mesh.n_processors(); proc++)
            out_stream << "proc_" << proc << std::endl;

          for (const auto & elem : mesh.active_element_ptr_range())
            out_stream << elem->processor_id()+1 << std::endl;

          out_stream << std::endl;
        }
    }


  // Writing cell-centered data is not yet supported in discontinuous GMV files.
  if (!(this->_cell_centered_data.empty()))
    {
      libMesh::err << "Cell-centered data not (yet) supported for discontinuous GMV files!" << std::endl;
    }



  // write the data
  {
    const unsigned int n_vars =
      cast_int<unsigned int>(solution_names.size());

    //    libmesh_assert_equal_to (v.size(), tw*n_vars);

    out_stream << "variable" << std::endl;


    for (unsigned int c=0; c<n_vars; c++)
      {

#ifdef LIBMESH_USE_COMPLEX_NUMBERS

        // in case of complex data, write _tree_ data sets
        // for each component

        // this is the real part
        out_stream << "r_" << solution_names[c] << " 1" << std::endl;
        for (const auto & elem : mesh.active_element_ptr_range())
          for (unsigned int n=0; n<elem->n_nodes(); n++)
            out_stream << v[(n++)*n_vars + c].real() << " ";
        out_stream << std::endl << std::endl;


        // this is the imaginary part
        out_stream << "i_" << solution_names[c] << " 1" << std::endl;
        for (const auto & elem : mesh.active_element_ptr_range())
          for (unsigned int n=0; n<elem->n_nodes(); n++)
            out_stream << v[(n++)*n_vars + c].imag() << " ";
        out_stream << std::endl << std::endl;

        // this is the magnitude
        out_stream << "a_" << solution_names[c] << " 1" << std::endl;
        for (const auto & elem : mesh.active_element_ptr_range())
          for (unsigned int n=0; n<elem->n_nodes(); n++)
            out_stream << std::abs(v[(n++)*n_vars + c]) << " ";
        out_stream << std::endl << std::endl;

#else

        out_stream << solution_names[c] << " 1" << std::endl;
        {
          unsigned int nn=0;

          for (const auto & elem : mesh.active_element_ptr_range())
            for (unsigned int n=0; n<elem->n_nodes(); n++)
              out_stream << v[(nn++)*n_vars + c] << " ";
        }
        out_stream << std::endl << std::endl;

#endif

      }

    out_stream << "endvars" << std::endl;
  }


  // end of the file
  out_stream << std::endl << "endgmv" << std::endl;
}

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.

Definition at line 31 of file mesh_output.C.

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

Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_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-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_solution_vector (soln, system_names);

      this->write_nodal_data (fname, soln, names);
    }
  else // _is_parallel_format
    {
      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() [1/2]

void libMesh::GMVIO::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.

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 279 of file gmv_io.C.

References binary(), write_ascii_old_impl(), and write_binary().

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

{
  LOG_SCOPE("write_nodal_data()", "GMVIO");

  if (this->binary())
    this->write_binary (fname, &soln, &names);
  else
    this->write_ascii_old_impl  (fname, &soln, &names);
}

write_nodal_data() [2/2]

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 should 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 150 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_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 114 of file mesh_output.h.

  { libmesh_not_implemented(); }

write_subdomain_id_as_material()

bool& libMesh::GMVIO::write_subdomain_id_as_material ( )

inline

Flag to write element subdomain_id's as GMV "materials" instead of element processor_id's. Allows you to generate exploded views on user-defined subdomains, potentially creating a pretty picture.

Definition at line 122 of file gmv_io.h.

References _write_subdomain_id_as_material.

Referenced by write_ascii_new_impl(), write_ascii_old_impl(), and write_binary().

{ return _write_subdomain_id_as_material; }

Member Data Documentation

_binary

bool libMesh::GMVIO::_binary

private

Flag to write binary data.

Definition at line 199 of file gmv_io.h.

Referenced by binary().

_cell_centered_data

std::map<std::string, const std::vector<Real> * > libMesh::GMVIO::_cell_centered_data

private

Storage for arbitrary cell-centered data. Ex: You can use this to plot the effectivity index for a given cell. The map is between the string representing the variable name and a pointer to a vector containing the data.

Definition at line 233 of file gmv_io.h.

Referenced by add_cell_centered_data(), write_ascii_new_impl(), write_ascii_old_impl(), write_binary(), and write_discontinuous_gmv().

_discontinuous

bool libMesh::GMVIO::_discontinuous

private

Flag to write the mesh as discontinuous patches.

Definition at line 204 of file gmv_io.h.

Referenced by discontinuous().

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

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

_next_elem_id

unsigned int libMesh::GMVIO::_next_elem_id

private

Definition at line 239 of file gmv_io.h.

Referenced by _read_one_cell(), and read().

_nodal_data

std::map<std::string, std::vector<Number> > libMesh::GMVIO::_nodal_data

private

Definition at line 244 of file gmv_io.h.

Referenced by _read_var(), and copy_nodal_solution().

_p_levels

bool libMesh::GMVIO::_p_levels

private

Flag to write the mesh p refinement levels.

Definition at line 225 of file gmv_io.h.

Referenced by p_levels().

_partitioning

bool libMesh::GMVIO::_partitioning

private

Flag to write the mesh partitioning.

Definition at line 209 of file gmv_io.h.

Referenced by partitioning().

_reading_element_map

std::map< std::string, ElemType > libMesh::GMVIO::_reading_element_map = GMVIO::build_reading_element_map()

staticprivate

Static map from string -> ElementType for use during reading.

Definition at line 250 of file gmv_io.h.

Referenced by gmv_elem_to_libmesh_elem().

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

_subdivide_second_order

bool libMesh::GMVIO::_subdivide_second_order

private

Flag to subdivide second order elements

Definition at line 220 of file gmv_io.h.

Referenced by subdivide_second_order().

_write_subdomain_id_as_material

bool libMesh::GMVIO::_write_subdomain_id_as_material

private

Flag to write element subdomain_id's as GMV "materials" instead of element processor_id's.

Definition at line 215 of file gmv_io.h.

Referenced by write_discontinuous_gmv(), and write_subdomain_id_as_material().

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

Referenced by _read_one_cell(), libMesh::UNVIO::elements_in(), libMesh::UNVIO::max_elem_dimension_seen(), libMesh::AbaqusIO::max_elem_dimension_seen(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), read(), libMesh::VTKIO::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:

• gmv_io.h
• gmv_io.C