libMesh::STLIO Class Reference

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

#include <stl_io.h>

Inheritance diagram for libMesh::STLIO:

Public Member Functions
	STLIO (const MeshBase &)
	Constructor.
	STLIO (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	read_ascii (std::istream &input)
	This method implements reading a mesh from a specified ASCII input stream.
virtual void	read_binary (std::istream &input, std::size_t input_size=0)
	This method implements reading a mesh from a specified binary input stream.
const std::string &	name ()
	This method gets a name after a set or an ASCII read.
virtual void	set_name (const std::string &name)
	This method sets a name to write.
bool	subdivide_second_order ()
	Flag indicating whether or not to subdivide second order elements when writing.
void	set_subdivide_second_order (bool subdivide)
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 std::vector< Number > &, const std::vector< std::string > &)
	This method implements writing a mesh with nodal data to a specified file where the nodal data and variable names are provided.
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
std::unique_ptr< std::istream >	open_file (const std::string &filename)
	Helper to open possibly-zipped files.

Private Attributes
bool	_subdivide_second_order
	Flag to subdivide second order elements.
std::string	_name
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.

Detailed Description

This class implements reading and writing triangle meshes in the STL format.

Author

Roy H. Stogner

Date

2024

Definition at line 45 of file stl_io.h.

Constructor & Destructor Documentation

STLIO() [1/2]

libMesh::STLIO::STLIO ( 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 64 of file stl_io.C.

                                   :
  MeshOutput<MeshBase>    (mesh),
  _subdivide_second_order (true)
{
}

STLIO() [2/2]

libMesh::STLIO::STLIO ( 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 72 of file stl_io.C.

                             :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh),
  _subdivide_second_order (true)
{
}

Member Function Documentation

ascii_precision()

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

inlineinherited

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

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

Definition at line 160 of file mesh_output.h.

{
  return _ascii_precision;
}

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

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

name()

const std::string & libMesh::STLIO::name ( )

inline

This method gets a name after a set or an ASCII read.

Definition at line 94 of file stl_io.h.

{ return _name; }

References _name.

Referenced by set_name().

open_file()

std::unique_ptr< std::istream > libMesh::STLIO::open_file ( const std::string &  filename )

private

Helper to open possibly-zipped files.

Definition at line 223 of file stl_io.C.

{
  const bool gzipped_file = Utility::ends_with(filename, ".gz");
 
  std::unique_ptr<std::istream> file;
 
  if (gzipped_file)
    {
#ifdef LIBMESH_HAVE_GZSTREAM
      auto inf = std::make_unique<igzstream>();
      libmesh_assert(inf);
      inf->open(filename.c_str(), std::ios::in);
      file = std::move(inf);
#else
      libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
#endif
    }
  else
    {
      auto inf = std::make_unique<std::ifstream>();
      libmesh_assert(inf);
 
      std::string new_name = Utility::unzip_file(filename);
 
      inf->open(new_name.c_str(), std::ios::in);
      file = std::move(inf);
    }
 
  return file;
}

References libMesh::Utility::ends_with(), libMesh::libmesh_assert(), and libMesh::Utility::unzip_file().

Referenced by read().

read()

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

overridevirtual

This method implements reading a mesh from a specified file.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 165 of file stl_io.C.

{
  LOG_SCOPE("read()", "STLIO");
 
  // 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);
 
  // Clear the mesh so we are sure to start from a pristine state.
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
  mesh.clear();
  mesh.set_mesh_dimension(2);
 
  std::unique_ptr<std::istream> fstream =
    this->open_file(filename);
 
  char c;
  const char * expected_header = "solid!";
  bool is_ascii_stl = false,
       is_binary_stl = false;
  while (fstream->get(c))
    {
      if (c == ' ')
        continue;
      if (c == *expected_header)
        {
          ++expected_header;
          if (*expected_header == '!')
          {
            is_ascii_stl = true;
            break;
          }
        }
      else
        {
          is_binary_stl = true; // probably
          break;
        }
    }
 
  if (is_ascii_stl)
    {
      fstream->seekg(0);
      this->read_ascii(*fstream);
    }
  else if (is_binary_stl)
    {
      fstream->seekg(0, std::ios_base::end);
      std::size_t length = fstream->tellg();
      fstream->seekg(0);
      this->read_binary(*fstream, length);
    }
  else
    libmesh_error_msg("Failed to read an STL header in " << filename);
}

References libMesh::MeshBase::clear(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), open_file(), read_ascii(), read_binary(), and libMesh::MeshBase::set_mesh_dimension().

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

read_ascii()

void libMesh::STLIO::read_ascii ( std::istream &  input )

virtual

This method implements reading a mesh from a specified ASCII input stream.

Definition at line 256 of file stl_io.C.

{
  LOG_SCOPE("read_ascii()", "STLIO");
 
#ifndef LIBMESH_HAVE_CXX11_REGEX
  libmesh_not_implemented();  // What is your compiler?!?  Email us!
  libmesh_ignore(file);
#else
 
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  const std::regex all_expected_chars
    ("^[\\w\\d\\-\\.\\^\\$]*$");
 
  const std::regex start_regex
    ("^\\s*solid");
  const std::regex start_with_name_regex
    ("^\\s*solid\\s+(\\w+)");
 
  const std::regex start_facet_regex
    ("^\\s*facet");
 
  // We'll ignore facets' normals for now
  /*
  const std::regex facet_with_normal_regex
    ("^\\s*facet\\s+normal"
     "\\s+([+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?)"
     "\\s+[+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?)"
     "\\s+[+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?))");
  */
 
  const std::regex start_loop_regex
    ("^\\s*outer\\s+loop");
 
  const std::regex vertex_regex
    ("^\\s*vertex"
     "\\s+([+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?)"
     "\\s+[+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?)"
     "\\s+[+-]?(\\d+([.]\\d*)?([eE][+-]?\\d+)?|[.]\\d+([eE][+-]?\\d+)?))");
 
  const std::regex end_facet_regex
    ("^\\s*end\\s*facet");
 
  const std::regex end_loop_regex
    ("^\\s*end\\s*loop");
 
  bool have_started = false;
  bool in_facet = false;
  bool in_vertex_loop = false;
  std::unique_ptr<Tri3> triangle;
  int next_vertex = 0;
  int line_num = 0;
 
  std::unordered_map<Point, Node *> mesh_points;
 
  for (std::string line; std::getline(file, line);)
    {
      ++line_num;
      std::smatch sm;
 
      for (char & c : line)
        {
          libmesh_error_msg_if
            (c != '\n' && c != '\r' &&
             (c < ' ' || c > '~'),
             "Found non-ASCII character " << int(c) << " on line " <<
             line_num << "\nSTLIO does not yet support binary files.");
        }
 
      if (std::regex_search(line, sm, start_regex))
        {
          if (std::regex_search(line, sm, start_with_name_regex))
            this->_name = sm[1];
          libmesh_error_msg_if
            (have_started,
             "Found two 'solid' lines starting the same STL file?");
          have_started = true;
        }
 
      else if (std::regex_search(line, sm, start_facet_regex))
        {
          libmesh_error_msg_if
            (in_facet,
             "Found a repeated 'facet' line with no 'endfacet' between them.");
          in_facet = true;
 
          /*
          if (std::regex_search(line, sm, facet_with_normal_regex))
            {
              const std::string normalvec = sm[1];
 
              // Try to be compatible with higher-than-double T; maybe
              // *someone* out there is doing STL in 128 bits? ...
              std::stringstream ss(normalvec);
              ss >> normal(0);
              ss >> normal(1);
              ss >> normal(2);
              }
          */
        }
 
      else if (std::regex_search(line, end_facet_regex))
        {
          libmesh_error_msg_if
            (!in_facet,
             "Found an 'endfacet' line with no matching 'facet'.");
          in_facet = false;
        }
 
      else if (std::regex_search(line, start_loop_regex))
        {
          libmesh_error_msg_if
            (!in_facet,
             "Found an 'outer loop' line with no matching 'facet'.");
          libmesh_error_msg_if
            (in_vertex_loop,
             "Found a repeated 'outer loop' line with no 'endloop' between them.");
          in_vertex_loop = true;
          triangle = std::make_unique<Tri3>();
          next_vertex = 0;
        }
 
      else if (std::regex_search(line, sm, vertex_regex))
        {
          const std::string normalvec = sm[1];
 
          // Try to be compatible with higher-than-double-precision T;
          // maybe *someone* out there is doing STL in 128 bits? ...
          std::stringstream ss(normalvec);
          Point p;
          ss >> p(0);
          ss >> p(1);
          ss >> p(2);
 
          Node * node;
          if (auto it = mesh_points.find(p); it != mesh_points.end())
            {
              node = it->second;
            }
          else
            {
              node = mesh.add_point(p);
              mesh_points[p] = node;
            }
 
          libmesh_error_msg_if
            (next_vertex > 2,
             "Found more than 3 vertices in a loop; STLIO only supports Tri3.");
          triangle->set_node(next_vertex++, node);
        }
 
      else if (std::regex_search(line, end_loop_regex))
        {
          libmesh_error_msg_if
            (next_vertex != 3,
             "Found an 'endloop' line after only seeing " << next_vertex << " vertices in 'loop'.");
          libmesh_error_msg_if
            (!in_vertex_loop,
             "Found an 'endloop' line with no matching 'loop'.");
          in_vertex_loop = false;
 
          test_and_add(std::move(triangle), mesh);
        }
    }
 
  libmesh_error_msg_if
    (in_facet,
     "File ended without ending a facet first.");
 
  libmesh_error_msg_if
    (in_vertex_loop,
     "File ended without ending an outer loop first.");
#endif // LIBMESH_HAVE_CXX11_REGEX
}

References _name, libMesh::MeshBase::add_point(), libMesh::libmesh_ignore(), libMesh::MeshInput< MT >::mesh(), and libMesh::MeshInput< MeshBase >::mesh().

Referenced by read().

read_binary()

void libMesh::STLIO::read_binary ( std::istream &  input, std::size_t  input_size = 0  )

virtual

This method implements reading a mesh from a specified binary input stream.

If the size in bytes is known a priori then it can be passed in to allow for additional error checking.

Definition at line 433 of file stl_io.C.

{
  LOG_SCOPE("read_binary()", "STLIO");
 
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  char header_buffer[80];
 
  // 80-character header which is generally ignored - Wikipedia
  file.read(header_buffer, 80);
 
  // What's our endianness here?  Input binary files are specified to
  // be little endian, and we might need to do conversions.
 
  uint32_t test_int = 0x87654321;
  const bool big_endian = ((*reinterpret_cast<char *>(&test_int)) != 0x21);
  const Utility::ReverseBytes endian_fix{big_endian};
 
  // C++ doesn't specify a size for float, but we really need 4-byte
  // floats here.  Fortunately basically every implementation ever
  // uses exactly 4 bytes for float.
  if constexpr (sizeof(float) != 4)
    libmesh_error_msg("Trying to read 4 byte floats without 4-byte float?");
 
  uint32_t n_elem = 0;
 
  file.read(reinterpret_cast<char*>(&n_elem), 4);
  endian_fix(n_elem);
 
  libmesh_error_msg_if
    (input_size &&
     (input_size < 84+n_elem*50),
     "Not enough data for " << n_elem << " STL triangles in " <<
     input_size << " uncompressed bytes.");
 
  std::unique_ptr<Tri3> triangle;
  std::unordered_map<Point, Node *> mesh_points;
 
  for (unsigned int e : make_range(n_elem))
  {
    libmesh_ignore(e);
 
    triangle = std::make_unique<Tri3>();
 
    // We'll ignore facets' normals for now
    char ignored_buffer[12];
    file.read(ignored_buffer, 12);
 
    // Read vertex locations
    for (int i : make_range(3))
      {
        float point_buffer[3];
        file.read(reinterpret_cast<char*>(point_buffer), 12);
        endian_fix(point_buffer[0]);
        endian_fix(point_buffer[1]);
        endian_fix(point_buffer[2]);
        const Point p {point_buffer[0],
                       point_buffer[1],
                       point_buffer[2]};
 
        Node * node;
        if (auto it = mesh_points.find(p); it != mesh_points.end())
          {
            node = it->second;
          }
        else
          {
            node = mesh.add_point(p);
            mesh_points[p] = node;
          }
 
        triangle->set_node(i, node);
      }
 
    // The 2-byte "attribute byte count" is unstandardized; typically
    // 0, or sometimes triangle color.  Ignore it.
    file.read(ignored_buffer, 2);
 
    test_and_add(std::move(triangle), mesh);
  }
}

References libMesh::MeshBase::add_point(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::MeshInput< MT >::mesh(), and libMesh::MeshInput< MeshBase >::mesh().

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

set_name()

virtual void libMesh::STLIO::set_name ( const std::string &  name )

inlinevirtual

This method sets a name to write.

Definition at line 99 of file stl_io.h.

{ _name = name; }

References _name, and name().

set_subdivide_second_order()

void libMesh::STLIO::set_subdivide_second_order ( bool  subdivide )

inline

Definition at line 107 of file stl_io.h.

  { _subdivide_second_order = subdivide; }

References _subdivide_second_order.

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::STLIO::subdivide_second_order ( )

inline

Flag indicating whether or not to subdivide second order elements when writing.

This option is not yet supported.

Definition at line 105 of file stl_io.h.

{ return _subdivide_second_order; }

References _subdivide_second_order.

write()

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

overridevirtual

This method implements writing a mesh to a specified file.

We currently only support ASCII writes.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 81 of file stl_io.C.

{
  LOG_SCOPE("write()", "STLIO");
 
  // Get a reference to the mesh
  const MeshBase * mesh_ptr = &MeshOutput<MeshBase>::mesh();
 
  libmesh_parallel_only(mesh_ptr->comm());
 
  // If necessary, serialize to proc 0, which will do all the writing
  std::unique_ptr<DistributedMesh> mesh_copy;
  std::unique_ptr<MeshSerializer> serializer;
  if (!mesh_ptr->is_serial())
    {
      mesh_copy = std::make_unique<DistributedMesh>(*mesh_ptr);
      mesh_ptr = mesh_copy.get();
      serializer = std::make_unique<MeshSerializer>(*mesh_copy, true, true);
    }
 
  const MeshBase & mesh = *mesh_ptr;
 
  if (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());
 
  // Write the header
  out_stream << "solid " << this->_name << '\n';
 
  // Write all our triangles
  // scream if we see a non-triangle
  for (auto elem : mesh.element_ptr_range())
    {
      // Get to this later
      if (elem->type() == TRI6 || elem->type() == TRI7)
        {
          if (this->_subdivide_second_order)
            libmesh_not_implemented();
 
          libmesh_error_msg("Tried to write a non-linear triangle to an STL file");
        }
 
      libmesh_error_msg_if(elem->type() != TRI3,
                           "Tried to write a non-triangle to an STL file");
 
      auto n = (elem->point(1)-elem->point(0)).cross(elem->point(2)-elem->point(0));
 
      // Other STL files have slivers, I guess ours can too
      if (auto length = n.norm())
        n /= length;
 
      out_stream << "facet normal " <<
        n(0) << ' ' <<
        n(1) << ' ' <<
        n(2) << "\n"
        "    outer loop\n"
        "        vertex " <<
        elem->point(0)(0) << ' ' <<
        elem->point(0)(1) << ' ' <<
        elem->point(0)(2) << "\n"
        "        vertex " <<
        elem->point(1)(0) << ' ' <<
        elem->point(1)(1) << ' ' <<
        elem->point(1)(2) << "\n"
        "        vertex " <<
        elem->point(2)(0) << ' ' <<
        elem->point(2)(1) << ' ' <<
        elem->point(2)(2) << "\n"
        "    endloop\n"
        "endfacet\n";
    }
 
  out_stream << "endsolid" << std::endl;
}

References _name, _subdivide_second_order, libMesh::MeshOutput< MeshBase >::ascii_precision(), libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::ParallelObject::processor_id(), libMesh::TRI3, libMesh::TRI6, and libMesh::TRI7.

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

write_discontinuous_equation_systems()

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

virtualinherited

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

Definition at line 101 of file mesh_output.C.

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

write_equation_systems()

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

virtualinherited

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

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

Definition at line 92 of file mesh_output.C.

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

write_nodal_data() [1/3]

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

virtualinherited

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

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

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

Reimplemented in libMesh::Nemesis_IO.

Definition at line 149 of file mesh_output.C.

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

write_nodal_data() [2/3]

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

virtualinherited

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

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

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

Reimplemented in libMesh::Nemesis_IO.

Definition at line 136 of file mesh_output.C.

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

write_nodal_data() [3/3]

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

inlinevirtualinherited

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

Reimplemented in libMesh::ExodusII_IO, libMesh::GmshIO, libMesh::GMVIO, libMesh::GnuPlotIO, libMesh::MEDITIO, libMesh::NameBasedIO, libMesh::TecplotIO, libMesh::VTKIO, libMesh::Nemesis_IO, and libMesh::UCDIO.

Definition at line 109 of file mesh_output.h.

  { libmesh_not_implemented(); }

write_nodal_data_discontinuous()

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

inlinevirtualinherited

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 118 of file mesh_output.h.

  { libmesh_not_implemented(); }

Member Data Documentation

_ascii_precision

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

privateinherited

Precision to use when writing ASCII files.

Definition at line 207 of file mesh_output.h.

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

_name

std::string libMesh::STLIO::_name

private

Definition at line 122 of file stl_io.h.

Referenced by name(), read_ascii(), set_name(), and write().

_obj

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

privateinherited

A pointer to a non-const object object.

This allows us to read the object from file.

Definition at line 123 of file mesh_input.h.

_serial_only_needed_on_proc_0

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

protectedinherited

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

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

Definition at line 193 of file mesh_output.h.

_subdivide_second_order

bool libMesh::STLIO::_subdivide_second_order

private

Flag to subdivide second order elements.

Definition at line 120 of file stl_io.h.

Referenced by set_subdivide_second_order(), subdivide_second_order(), and write().

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/stl_io.h
• src/mesh/stl_io.C