libMesh::GMVIO Class Reference

This class implements writing meshes in the GMV format. More...

#include <gmv_io.h>

Inheritance diagram for libMesh::GMVIO:

Public Member Functions
	GMVIO (const MeshBase &)
	Constructor.
	GMVIO (MeshBase &)
	Constructor.
virtual void	write (const std::string &) override
	This method implements writing a mesh to a specified file.
virtual void	read (const std::string &mesh_file) override
	This method implements reading a mesh from a specified file.
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &) override
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.
bool &	binary ()
	Flag indicating whether or not to write a binary file.
bool &	discontinuous ()
	Flag indicating whether or not to write the mesh as discontinuous cell patches.
bool &	partitioning ()
	Flag indicating whether or not to write the partitioning information for the mesh.
bool &	write_subdomain_id_as_material ()
	Flag to write element subdomain_id's as GMV "materials" instead of element processor_id's.
bool &	subdivide_second_order ()
	Flag indicating whether or not to subdivide second order elements.
bool &	p_levels ()
	Flag indicating whether or not to write p level information for p refined meshes.
void	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.
void	write_ascii_new_impl (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are optionally provided.
void	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.
void	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.
bool	is_parallel_format () const
	Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_discontinuous_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)
	This method implements writing a mesh with discontinuous data to a specified file where the data is taken from the EquationSystems object.
virtual void	write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)
	This method may be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data (const std::string &, const EquationSystems &, const std::set< std::string > *)
	This method should be overridden by "parallel" output formats for writing nodal data.
virtual void	write_nodal_data_discontinuous (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
	This method implements writing a mesh with discontinuous data to a specified file where the nodal data and variables names are provided.
unsigned int &	ascii_precision ()
	Return/set the precision to use when writing ASCII files.

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

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

Private Member Functions
void	write_ascii_old_impl (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are optionally provided.
void	write_binary (const std::string &, const std::vector< Number > *=nullptr, const std::vector< std::string > *=nullptr)
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are optionally provided.
void	_read_nodes ()
	Helper functions for reading nodes/cells from a GMV file.
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 ()
	Static function used to build the _reading_element_map.

Private Attributes
bool	_binary
	Flag to write binary data.
bool	_discontinuous
	Flag to write the mesh as discontinuous patches.
bool	_partitioning
	Flag to write the mesh partitioning.
bool	_write_subdomain_id_as_material
	Flag to write element subdomain_id's as GMV "materials" instead of element processor_id's.
bool	_subdivide_second_order
	Flag to subdivide second order elements.
bool	_p_levels
	Flag to write the mesh p refinement levels.
std::map< std::string, const std::vector< Real > * >	_cell_centered_data
	Storage for arbitrary cell-centered data.
unsigned int	_next_elem_id
std::map< std::string, std::vector< Number > >	_nodal_data
MeshBase *	_obj
	A pointer to a non-const object object.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
unsigned int	_ascii_precision
	Precision to use when writing ASCII files.

Static Private Attributes
static std::map< std::string, ElemType >	_reading_element_map = GMVIO::build_reading_element_map()
	Static map from string -> ElementType for use during reading.

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 46 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 242 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 256 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 2028 of file gmv_io.C.

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

Referenced by read().

_read_nodes()

void libMesh::GMVIO::_read_nodes ( )

private

Helper functions for reading nodes/cells from a GMV file.

Definition at line 2052 of file gmv_io.C.

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

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

Referenced by read().

_read_one_cell()

void libMesh::GMVIO::_read_one_cell ( )

private

Definition at line 2071 of file gmv_io.C.

{
#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);
 
      auto elem = Elem::build(type);
      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(std::move(elem));
    }
 
 
  if (GMVLib::gmv_data.datatype == ENDKEYWORD)
    {
      // There isn't a cell to read, so we just return
      return;
    }
 
#endif
}

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

Referenced by read().

_read_var()

void libMesh::GMVIO::_read_var ( )

private

Definition at line 2016 of file gmv_io.C.

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

References _nodal_data.

Referenced by read().

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 1849 of file gmv_io.C.

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

References _cell_centered_data, and libMesh::libmesh_assert().

ascii_precision()

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

inlineinherited

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

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

Definition at line 160 of file mesh_output.h.

{
  return _ascii_precision;
}

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 95 of file gmv_io.h.

{ return _binary; }

References _binary.

Referenced by write(), and write_nodal_data().

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 209 of file gmv_io.C.

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

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.

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 2148 of file gmv_io.C.

{
  // 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 (auto sys : make_range(es.n_systems()))
    {
      // 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 & [var_name, vec] : _nodal_data)
        {
          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 (vec.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>(vec.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, vec[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;
}

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::libmesh_assert(), libMesh::make_range(), 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().

discontinuous()

bool & libMesh::GMVIO::discontinuous ( )

inline

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

Definition at line 101 of file gmv_io.h.

{ return _discontinuous; }

References _discontinuous.

get_add_sides()

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

inlineprotectedvirtualinherited

Returns

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 176 of file mesh_output.h.

{ return false; }

gmv_elem_to_libmesh_elem()

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

private

Definition at line 2136 of file gmv_io.C.

{
  // Erase any whitespace padding in name coming from gmv before performing comparison.
  elemname.erase(std::remove_if(elemname.begin(), elemname.end(),
                                [](unsigned char const c){return std::isspace(c);}),
                 elemname.end());
  return libmesh_map_find(_reading_element_map, elemname);
}

References _reading_element_map.

Referenced by _read_one_cell().

is_parallel_format()

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

inlineinherited

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

Definition at line 87 of file mesh_input.h.

{ return this->_is_parallel_format; }

mesh() [1/2]

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

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 94 of file mesh_input.h.

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

mesh() [2/2]

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

inlineprotectedinherited

Returns

The object as a read-only reference.

Definition at line 168 of file mesh_output.h.

{
  libmesh_assert(_obj);
  return *_obj;
}

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 126 of file gmv_io.h.

{ return _p_levels; }

References _p_levels.

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

partitioning()

bool & libMesh::GMVIO::partitioning ( )

inline

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

Definition at line 107 of file gmv_io.h.

{ return _partitioning; }

References _partitioning.

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

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 1866 of file gmv_io.C.

{
  // This is a serial-only process for now;
  // the Mesh should be read on processor 0 and
  // broadcast later
  libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().processor_id(), 0);
 
  _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()));
  libmesh_error_msg_if(ierr != 0, "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.
      libmesh_error_msg_if(GMVLib::gmv_data.keyword == GMVERROR,
                           "Encountered GMVERROR while reading!");
 
      // Process the data.
      switch (GMVLib::gmv_data.keyword)
        {
        case NODES:
          {
            if (GMVLib::gmv_data.num2 == NODES)
              this->_read_nodes();
 
            else
              libmesh_error_msg_if(GMVLib::gmv_data.num2 == NODE_V,
                                   "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
  libmesh_error_msg_if(mesh.mesh_dimension() > LIBMESH_DIM,
                       "Cannot open dimension "
                       << mesh.mesh_dimension()
                       << " mesh file when configured without "
                       << mesh.mesh_dimension()
                       << "D support.");
#endif
 
  // 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
}

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, libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::prepare_for_use(), and libMesh::MeshBase::set_mesh_dimension().

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

set_n_partitions()

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

inlineprotectedinherited

Sets the number of partitions in the mesh.

Typically this gets done by the partitioner, but some parallel file formats begin "pre-partitioned".

Definition at line 101 of file mesh_input.h.

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

skip_comment_lines()

void libMesh::MeshInput< MeshBase >::skip_comment_lines ( std::istream &  in, const char  comment_start  )

protectedinherited

Reads input from in, skipping all the lines that start with the character comment_start.

Definition at line 113 of file mesh_input.h.

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

subdivide_second_order()

bool & libMesh::GMVIO::subdivide_second_order ( )

inline

Flag indicating whether or not to subdivide second order elements.

Definition at line 120 of file gmv_io.h.

{ return _subdivide_second_order; }

References _subdivide_second_order.

Referenced by write_ascii_new_impl(), and write_ascii_old_impl().

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 271 of file gmv_io.C.

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

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

Referenced by main(), and libMesh::NameBasedIO::write().

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 295 of file gmv_io.C.

{
#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 (auto n : make_range(mesh.n_nodes()))
      out_stream << mesh.point(n)(0) << " ";
    out_stream << "\n";
 
    for (auto n : make_range(mesh.n_nodes()))
#if LIBMESH_DIM > 1
      out_stream << mesh.point(n)(1) << " ";
#else
    out_stream << 0. << " ";
#endif
    out_stream << "\n";
 
    for (auto n : make_range(mesh.n_nodes()))
#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 (auto i : index_range(ele.node_map))
          out_stream << elem->node_id(ele.node_map[i])+1 << " ";
        out_stream << "\n";
      }
    out_stream << "\n";
  }
 
  // optionally write the partition information
  if (this->partitioning())
    {
      libmesh_error_msg_if(this->write_subdomain_id_as_material(),
                           "Not yet supported in GMVIO::write_ascii_new_impl");
 
      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 (auto proc : make_range(mesh.n_partitions()))
        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, enms=ele.node_map.size(); i < enms; i++)
            out_stream << elem->p_level() << " ";
        }
      out_stream << "\n\n";
    }
 
 
  // optionally write cell-centered data
  if (!(this->_cell_centered_data.empty()))
    {
      for (const auto & [var_name, the_array] : this->_cell_centered_data)
        {
          // write out the variable name, followed by a zero.
          out_stream << var_name << " 0\n";
 
          // 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, nse=elem->n_sub_elem(); se<nse; 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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            out_stream << std::abs((*v)[n*n_vars + c]) << " ";
 
          out_stream << "\n\n";
 
#else
 
          out_stream << (*solution_names)[c] << " 1\n";
 
          for (auto n : make_range(mesh.n_nodes()))
            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
}

References _cell_centered_data, libMesh::MeshOutput< MeshBase >::ascii_precision(), libMesh::err, libMesh::index_range(), libMesh::libmesh_assert(), libMesh::make_range(), 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().

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 565 of file gmv_io.C.

{
  // 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 (auto n : make_range(mesh.n_nodes()))
      out_stream << mesh.point(n)(0) << " ";
 
    out_stream << '\n';
 
    for (auto n : make_range(mesh.n_nodes()))
#if LIBMESH_DIM > 1
      out_stream << mesh.point(n)(1) << " ";
#else
    out_stream << 0. << " ";
#endif
 
    out_stream << '\n';
 
    for (auto n : make_range(mesh.n_nodes()))
#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 (auto se : make_range(elem->n_sub_elem()))
                  {
                    out_stream << "line 2\n";
                    elem->connectivity(se, TECPLOT, conn);
                    for (const auto & idx : conn)
                      out_stream << idx << " ";
 
                    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 (auto i : lo_elem->node_index_range())
                        lo_elem->set_node(i, const_cast<Node*>(elem->node_ptr(i)));
                      lo_elem->connectivity(0, TECPLOT, conn);
                    }
                  for (const auto & idx : conn)
                    out_stream << idx << " ";
 
                  out_stream << '\n';
                }
 
              break;
            }
 
          case 2:
            {
              if (this->subdivide_second_order())
                for (auto se : make_range(elem->n_sub_elem()))
                  {
                    // 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 (const auto & idx : conn)
                          out_stream << idx << " ";
                      }
 
                    // 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 (const auto & idx : conn)
                        out_stream << idx << " ";
                    }
                  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 (auto i : lo_elem->node_index_range())
                        lo_elem->set_node(i, const_cast<Node*>(elem->node_ptr(i)));
                      lo_elem->connectivity(0, TECPLOT, conn);
                      out_stream << "quad 4\n";
                      for (const auto & idx : conn)
                        out_stream << idx << " ";
                    }
                  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 (auto i : lo_elem->node_index_range())
                        lo_elem->set_node(i, const_cast<Node*>(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 (auto se : make_range(elem->n_sub_elem()))
                  {
 
#ifndef  LIBMESH_ENABLE_INFINITE_ELEMENTS
                    if ((elem->type() == HEX8)   ||
                        (elem->type() == HEX27))
                      {
                        out_stream << "phex8 8\n";
                        elem->connectivity(se, TECPLOT, conn);
                        for (const auto & idx : conn)
                          out_stream << idx << " ";
                      }
 
                    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 (const auto & idx : conn)
                          out_stream << idx << " ";
                      }
#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 (const auto & idx : conn)
                          out_stream << idx << " ";
                      }
 
                    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 (auto i : lo_elem->node_index_range())
                    lo_elem->set_node(i, const_cast<Node*>(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 (const auto & idx : conn)
                        out_stream << idx << " ";
                    }
 
                  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 (const auto & idx : conn)
                        out_stream << idx << " ";
                    }
 
                  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.emplace(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 (auto sbdid : make_range(sbdid_map.size()))
            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
              unsigned gmv_mat_number = libmesh_map_find(sbdid_map, elem->subdomain_id());
 
              if (this->subdivide_second_order())
                for (unsigned int se=0, nse=elem->n_sub_elem(); se<nse; 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 (auto proc : make_range(mesh.n_partitions()))
            out_stream << "proc_" << proc << '\n';
 
          for (const auto & elem : mesh.active_element_ptr_range())
            if (this->subdivide_second_order())
              for (unsigned int se=0, nse=elem->n_sub_elem(); se<nse; 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, nse=elem->n_sub_elem(); se<nse; 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 & [var_name, the_array] : this->_cell_centered_data)
        {
          // write out the variable name, followed by a zero.
          out_stream << var_name << " 0\n";
 
          // 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, nse=elem->n_sub_elem(); se<nse; 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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            out_stream << std::abs((*v)[n*n_vars + c]) << " ";
 
          out_stream << '\n' << '\n';
 
#else
 
          out_stream << (*solution_names)[c] << " 1\n";
 
          for (auto n : make_range(mesh.n_nodes()))
            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";
}

References _cell_centered_data, 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, libMesh::make_range(), 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().

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 1221 of file gmv_io.C.

{
  // 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 (auto v : make_range(mesh.n_nodes()))
      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 (auto v : make_range(mesh.n_nodes()))
      {
#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 (auto v : make_range(mesh.n_nodes()))
      {
#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 (const auto & ed_id : ed.node_map)
          {
            dof_id_type id = elem->node_id(ed_id) + 1;
            out_stream.write(reinterpret_cast<char *>(&id), sizeof(dof_id_type));
          }
      }
  }
 
 
 
  // optionally write the partition information
  if (this->partitioning())
    {
      libmesh_error_msg_if(this->write_subdomain_id_as_material(),
                           "Not yet supported in GMVIO::write_binary");
 
      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 (auto proc : make_range(mesh.n_processors()))
        {
          // 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, d=mesh.mesh_dimension(); i != d; ++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, nse=elem->n_sub_elem(); se<nse; 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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            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 (auto n : make_range(mesh.n_nodes()))
            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());
}

References _cell_centered_data, libMesh::err, int, libMesh::libmesh_assert(), libMesh::make_range(), 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().

write_discontinuous_equation_systems()

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

virtualinherited

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

Definition at line 101 of file mesh_output.C.

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

write_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 1539 of file gmv_io.C.

{
  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 (const Node & node : elem->node_ref_range())
          out_stream << node(0) << " ";
 
      out_stream << std::endl;
    }
 
 
    // Write all the y values
    {
      for (const auto & elem : mesh.active_element_ptr_range())
        for (const Node & node : elem->node_ref_range())
#if LIBMESH_DIM > 1
          out_stream << node(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 (const Node & node : elem->node_ref_range())
#if LIBMESH_DIM > 2
          out_stream << node(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, nse=elem->n_sub_elem(); se<nse; 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, enn=elem->n_nodes(); i<enn; 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, nse=elem->n_sub_elem(); se<nse; 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, enn=elem->n_nodes(); i<enn; i++)
                      out_stream << nn++ << " ";
 
                  }
                else if ((elem->type() == TRI3) ||
                         (elem->type() == TRI6))
                  {
                    out_stream << "tri 3" << std::endl;
                    for (unsigned int i=0, enn=elem->n_nodes(); i<enn; 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, nse=elem->n_sub_elem(); se<nse; 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, enn=elem->n_nodes(); i<enn; 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, enn=elem->n_nodes(); i<enn; i++)
                      out_stream << nn++ << " ";
                  }
                else if ((elem->type() == TET4) ||
                         (elem->type() == TET10))
                  {
                    out_stream << "tet 4" << std::endl;
                    for (unsigned int i=0, enn=elem->n_nodes(); i<enn; 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)
    {
      libmesh_error_msg_if(_write_subdomain_id_as_material,
                           "Not yet supported in GMVIO::write_discontinuous_gmv");
 
      out_stream << "material "
                 << mesh.n_processors()
                 << " 0"<< std::endl;
 
      for (auto proc : make_range(mesh.n_processors()))
        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 (auto n : elem->node_index_range())
            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 (auto n : elem->node_index_range())
            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 (auto n : elem->node_index_range())
            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 i=0, enn=elem->n_nodes(); i<enn; i++)
              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;
}

References _cell_centered_data, _write_subdomain_id_as_material, 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::libmesh_assert(), libMesh::make_range(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::ParallelObject::n_processors(), n_vars, 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().

write_equation_systems()

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

virtualinherited

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

Reimplemented in libMesh::NameBasedIO, and libMesh::ExodusII_IO.

Definition at line 92 of file mesh_output.C.

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

write_nodal_data() [1/3]

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

virtualinherited

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

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

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

Reimplemented in libMesh::Nemesis_IO.

Definition at line 149 of file mesh_output.C.

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

write_nodal_data() [2/3]

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

virtualinherited

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

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

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

Reimplemented in libMesh::Nemesis_IO.

Definition at line 136 of file mesh_output.C.

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

write_nodal_data() [3/3]

void libMesh::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 281 of file gmv_io.C.

{
  LOG_SCOPE("write_nodal_data()", "GMVIO");
 
  if (this->binary())
    this->write_binary (fname, &soln, &names);
  else
    this->write_ascii_old_impl  (fname, &soln, &names);
}

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

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

write_nodal_data_discontinuous()

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

inlinevirtualinherited

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 118 of file mesh_output.h.

  { libmesh_not_implemented(); }

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 114 of file gmv_io.h.

{ return _write_subdomain_id_as_material; }

References _write_subdomain_id_as_material.

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

Member Data Documentation

_ascii_precision

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

privateinherited

Precision to use when writing ASCII files.

Definition at line 207 of file mesh_output.h.

_binary

bool libMesh::GMVIO::_binary

private

Flag to write binary data.

Definition at line 191 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 225 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 196 of file gmv_io.h.

Referenced by discontinuous().

_is_parallel_format [1/2]

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

privateinherited

Flag specifying whether this format is parallel-capable.

If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 130 of file mesh_input.h.

_is_parallel_format [2/2]

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

protectedinherited

Flag specifying whether this format is parallel-capable.

If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 184 of file mesh_output.h.

_next_elem_id

unsigned int libMesh::GMVIO::_next_elem_id

private

Definition at line 231 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 236 of file gmv_io.h.

Referenced by _read_var(), and copy_nodal_solution().

_obj

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

privateinherited

A pointer to a non-const object object.

This allows us to read the object from file.

Definition at line 123 of file mesh_input.h.

_p_levels

bool libMesh::GMVIO::_p_levels

private

Flag to write the mesh p refinement levels.

Definition at line 217 of file gmv_io.h.

Referenced by p_levels().

_partitioning

bool libMesh::GMVIO::_partitioning

private

Flag to write the mesh partitioning.

Definition at line 201 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 242 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 193 of file mesh_output.h.

_subdivide_second_order

bool libMesh::GMVIO::_subdivide_second_order

private

Flag to subdivide second order elements.

Definition at line 212 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 207 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 107 of file mesh_input.h.

---

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

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