libMesh::UNVIO Class Reference

The UNVIO class implements the Ideas UNV universal file format. More...

#include <unv_io.h>

Inheritance diagram for libMesh::UNVIO:

Public Member Functions
	UNVIO (MeshBase &mesh)
	Constructor.
	UNVIO (const MeshBase &mesh)
	Constructor.
virtual	~UNVIO ()
	Destructor.
virtual void	read (const std::string &) override
	This method implements reading a mesh from a specified file.
virtual void	write (const std::string &) override
	This method implements writing a mesh to a specified file.
bool &	verbose ()
	Set the flag indicating if we should be verbose.
void	read_dataset (std::string file_name)
	Read a UNV data file containing a dataset of type "2414".
const std::vector< Number > *	get_data (Node *node) const
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
void	read_implementation (std::istream &in_stream)
	The actual implementation of the read function.
void	write_implementation (std::ostream &out_stream)
	The actual implementation of the write function.
void	nodes_in (std::istream &in_file)
	Read nodes from file.
void	elements_in (std::istream &in_file)
	Method reads elements and stores them in std::vector<Elem *> _elements in the same order as they come in.
void	groups_in (std::istream &in_file)
	Reads the "groups" section of the file.
void	nodes_out (std::ostream &out_file)
	Outputs nodes to the file out_file.
void	elements_out (std::ostream &out_file)
	Outputs the element data to the file out_file.
unsigned char	max_elem_dimension_seen ()
bool	need_D_to_e (std::string &number)
	Replaces "1.1111D+00" with "1.1111e+00" if necessary.

Private Attributes
bool	_verbose
	should be be verbose?
std::map< dof_id_type, Node * >	_unv_node_id_to_libmesh_node_ptr
	Maps UNV node IDs to libMesh Node*s.
std::map< unsigned, unsigned >	_unv_elem_id_to_libmesh_elem_id
	Map UNV element IDs to libmesh element IDs.
std::map< Node *, std::vector< Number > >	_node_data
	Map from libMesh Node* to data at that node, as read in by the read_dataset() function.
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 const std::string	_nodes_dataset_label = "2411"
	label for the node dataset
static const std::string	_elements_dataset_label = "2412"
	label for the element dataset
static const std::string	_groups_dataset_label = "2467"
	label for the groups dataset

Detailed Description

The UNVIO class implements the Ideas UNV universal file format.

This class enables both reading and writing UNV files.

Author history

Author

Tammo Kaschner

Daniel Dreyer

Benjamin S. Kirk

John W. Peterson

Date

2003, 2004, 2014

Definition at line 52 of file unv_io.h.

Constructor & Destructor Documentation

UNVIO() [1/2]

libMesh::UNVIO::UNVIO

(

MeshBase &

mesh

)

Constructor.

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

Definition at line 68 of file unv_io.C.

                             :
  MeshInput<MeshBase> (mesh),
  MeshOutput<MeshBase>(mesh),
  _verbose (false)
{
}

UNVIO() [2/2]

libMesh::UNVIO::UNVIO

(

const MeshBase &

mesh

)

Constructor.

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

Definition at line 77 of file unv_io.C.

                                   :
  MeshOutput<MeshBase> (mesh),
  _verbose (false)
{
}

~UNVIO()

libMesh::UNVIO::~UNVIO ( )

virtualdefault

Destructor.

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

elements_in()

void libMesh::UNVIO::elements_in ( std::istream &  in_file )

private

Method reads elements and stores them in std::vector<Elem *> _elements in the same order as they come in.

Within UNVIO, element labels are ignored.

Definition at line 583 of file unv_io.C.

{
  LOG_SCOPE("elements_in()","UNVIO");
 
  if (this->verbose())
    libMesh::out << "  Reading elements" << std::endl;
 
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // node label, we use an int here so we can read in a -1
  int element_label;
 
  unsigned
    n_nodes,           // number of nodes on element
    fe_descriptor_id,  // FE descriptor id
    phys_prop_tab_num, // physical property table number (not supported yet)
    mat_prop_tab_num,  // material property table number (not supported yet)
    color;             // color (not supported yet)
 
  // vector that temporarily holds the node labels defining element
  std::vector<unsigned int> node_labels (21);
 
  // vector that assigns element nodes to their correct position
  // for example:
  // 44:plane stress      | QUAD4
  // linear quadrilateral |
  // position in UNV-file | position in libmesh
  // assign_elem_node[1]   = 0
  // assign_elem_node[2]   = 3
  // assign_elem_node[3]   = 2
  // assign_elem_node[4]   = 1
  //
  // UNV is 1-based, we leave the 0th element of the vectors unused in order
  // to prevent confusion, this way we can store elements with up to 20 nodes
  unsigned int assign_elem_nodes[21];
 
  // Read elements until there are none left
  unsigned ctr = 0;
  while (true)
    {
      // read element label, break out when we read -1
      in_file >> element_label;
 
      if (element_label == -1)
        break;
 
      in_file >> fe_descriptor_id        // read FE descriptor id
              >> phys_prop_tab_num       // (not supported yet)
              >> mat_prop_tab_num        // (not supported yet)
              >> color                   // (not supported yet)
              >> n_nodes;                // read number of nodes on element
 
      // For "beam" type elements, the next three numbers are:
      // .) beam orientation node number
      // .) beam fore-end cross section number
      // .) beam aft-end cross section number
      // which we discard in libmesh.  The "beam" type elements:
      // 11  Rod
      // 21  Linear beam
      // 22  Tapered beam
      // 23  Curved beam
      // 24  Parabolic beam
      // all have fe_descriptor_id < 25.
      // http://www.sdrl.uc.edu/universal-file-formats-for-modal-analysis-testing-1/file-format-storehouse/unv_2412.htm
      if (fe_descriptor_id < 25)
        {
          unsigned dummy;
          in_file >> dummy >> dummy >> dummy;
        }
 
      // read node labels (1-based)
      for (unsigned int j=1; j<=n_nodes; j++)
        in_file >> node_labels[j];
 
      // element pointer, to be allocated
      std::unique_ptr<Elem> elem;
 
      switch (fe_descriptor_id)
        {
        case 11: // Rod
          {
            elem = Elem::build(EDGE2);
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=1;
            break;
          }
 
        case 41: // Plane Stress Linear Triangle
        case 91: // Thin Shell   Linear Triangle
          {
            elem = Elem::build(TRI3);  // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=2;
            assign_elem_nodes[3]=1;
            break;
          }
 
        case 42: // Plane Stress Quadratic Triangle
        case 92: // Thin Shell   Quadratic Triangle
          {
            elem = Elem::build(TRI6);  // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=5;
            assign_elem_nodes[3]=2;
            assign_elem_nodes[4]=4;
            assign_elem_nodes[5]=1;
            assign_elem_nodes[6]=3;
            break;
          }
 
        case 43: // Plane Stress Cubic Triangle
          libmesh_error_msg("ERROR: UNV-element type 43: Plane Stress Cubic Triangle not supported.");
 
        case 44: // Plane Stress Linear Quadrilateral
        case 94: // Thin Shell   Linear Quadrilateral
          {
            elem = Elem::build(QUAD4); // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=3;
            assign_elem_nodes[3]=2;
            assign_elem_nodes[4]=1;
            break;
          }
 
        case 45: // Plane Stress Quadratic Quadrilateral
        case 95: // Thin Shell   Quadratic Quadrilateral
          {
            elem = Elem::build(QUAD8); // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=7;
            assign_elem_nodes[3]=3;
            assign_elem_nodes[4]=6;
            assign_elem_nodes[5]=2;
            assign_elem_nodes[6]=5;
            assign_elem_nodes[7]=1;
            assign_elem_nodes[8]=4;
            break;
          }
 
        case 300: // Thin Shell   Quadratic Quadrilateral (nine nodes)
          {
            elem = Elem::build(QUAD9); // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=7;
            assign_elem_nodes[3]=3;
            assign_elem_nodes[4]=6;
            assign_elem_nodes[5]=2;
            assign_elem_nodes[6]=5;
            assign_elem_nodes[7]=1;
            assign_elem_nodes[8]=4;
            assign_elem_nodes[9]=8;
            break;
          }
 
        case 46: // Plane Stress Cubic Quadrilateral
          libmesh_error_msg("ERROR: UNV-element type 46: Plane Stress Cubic Quadrilateral not supported.");
 
        case 111: // Solid Linear Tetrahedron
          {
            elem = Elem::build(TET4);  // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=1;
            assign_elem_nodes[3]=2;
            assign_elem_nodes[4]=3;
            break;
          }
 
        case 112: // Solid Linear Prism
          {
            elem = Elem::build(PRISM6);  // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=1;
            assign_elem_nodes[3]=2;
            assign_elem_nodes[4]=3;
            assign_elem_nodes[5]=4;
            assign_elem_nodes[6]=5;
            break;
          }
 
        case 115: // Solid Linear Brick
          {
            elem = Elem::build(HEX8);  // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=4;
            assign_elem_nodes[3]=5;
            assign_elem_nodes[4]=1;
            assign_elem_nodes[5]=3;
            assign_elem_nodes[6]=7;
            assign_elem_nodes[7]=6;
            assign_elem_nodes[8]=2;
            break;
          }
 
        case 116: // Solid Quadratic Brick
          {
            elem = Elem::build(HEX20); // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=12;
            assign_elem_nodes[3]=4;
            assign_elem_nodes[4]=16;
            assign_elem_nodes[5]=5;
            assign_elem_nodes[6]=13;
            assign_elem_nodes[7]=1;
            assign_elem_nodes[8]=8;
 
            assign_elem_nodes[9]=11;
            assign_elem_nodes[10]=19;
            assign_elem_nodes[11]=17;
            assign_elem_nodes[12]=9;
 
            assign_elem_nodes[13]=3;
            assign_elem_nodes[14]=15;
            assign_elem_nodes[15]=7;
            assign_elem_nodes[16]=18;
            assign_elem_nodes[17]=6;
            assign_elem_nodes[18]=14;
            assign_elem_nodes[19]=2;
            assign_elem_nodes[20]=10;
            break;
          }
 
        case 117: // Solid Cubic Brick
          libmesh_error_msg("Error: UNV-element type 117: Solid Cubic Brick not supported.");
 
        case 118: // Solid Quadratic Tetrahedron
          {
            elem = Elem::build(TET10); // create new element
 
            assign_elem_nodes[1]=0;
            assign_elem_nodes[2]=4;
            assign_elem_nodes[3]=1;
            assign_elem_nodes[4]=5;
            assign_elem_nodes[5]=2;
            assign_elem_nodes[6]=6;
            assign_elem_nodes[7]=7;
            assign_elem_nodes[8]=8;
            assign_elem_nodes[9]=9;
            assign_elem_nodes[10]=3;
            break;
          }
 
        default: // Unrecognized element type
          libmesh_error_msg("ERROR: UNV-element type " << fe_descriptor_id << " not supported.");
        }
 
      // nodes are being stored in element
      for (dof_id_type j=1; j<=n_nodes; j++)
        {
          // Map the UNV node ID to the libmesh node ID
          auto & node_ptr =
            libmesh_map_find(_unv_node_id_to_libmesh_node_ptr, node_labels[j]);
 
          elem->set_node(assign_elem_nodes[j], node_ptr);
        }
 
      elems_of_dimension[elem->dim()] = true;
 
      // Set the element's ID
      elem->set_id(ctr);
 
      // Maintain a map from the libmesh (0-based) numbering to the
      // UNV numbering.
      _unv_elem_id_to_libmesh_elem_id[element_label] = ctr;
 
      // Add the element to the Mesh
      mesh.add_elem(std::move(elem));
 
      // Increment the counter for the next iteration
      ctr++;
    } // end while (true)
}

References _unv_elem_id_to_libmesh_elem_id, _unv_node_id_to_libmesh_node_ptr, libMesh::MeshBase::add_elem(), libMesh::Elem::build(), libMesh::EDGE2, libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::HEX20, libMesh::HEX8, libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), n_nodes, libMesh::out, libMesh::PRISM6, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and verbose().

Referenced by read_implementation().

elements_out()

void libMesh::UNVIO::elements_out ( std::ostream &  out_file )

private

Outputs the element data to the file out_file.

Do not use this directly, but through the proper write method.

Definition at line 932 of file unv_io.C.

{
  if (this->verbose())
    libMesh::out << "  Writing elements" << std::endl;
 
  // Write beginning of dataset
  out_file << "    -1\n"
           << "  "
           << _elements_dataset_label
           << "\n";
 
  unsigned
    fe_descriptor_id = 0,    // FE descriptor id
    phys_prop_tab_dummy = 2, // physical property (not supported yet)
    mat_prop_tab_dummy = 1,  // material property (not supported yet)
    color_dummy = 7;         // color (not supported yet)
 
  // vector that assigns element nodes to their correct position
  // currently only elements with up to 20 nodes
  //
  // Example:
  // QUAD4               | 44:plane stress
  //                     | linear quad
  // position in libMesh | UNV numbering
  // (note: 0-based)     | (note: 1-based)
  //
  // assign_elem_node[0]  = 0
  // assign_elem_node[1]  = 3
  // assign_elem_node[2]  = 2
  // assign_elem_node[3]  = 1
  unsigned int assign_elem_nodes[20];
 
  unsigned int n_elem_written=0;
 
  // A reference to the parent class's mesh
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  for (const auto & elem : mesh.element_ptr_range())
    {
      switch (elem->type())
        {
 
        case TRI3:
          {
            fe_descriptor_id = 41; // Plane Stress Linear Triangle
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 2;
            assign_elem_nodes[2] = 1;
            break;
          }
 
        case TRI6:
          {
            fe_descriptor_id = 42; // Plane Stress Quadratic Triangle
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 5;
            assign_elem_nodes[2] = 2;
            assign_elem_nodes[3] = 4;
            assign_elem_nodes[4] = 1;
            assign_elem_nodes[5] = 3;
            break;
          }
 
        case QUAD4:
          {
            fe_descriptor_id = 44; // Plane Stress Linear Quadrilateral
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 3;
            assign_elem_nodes[2] = 2;
            assign_elem_nodes[3] = 1;
            break;
          }
 
        case QUAD8:
          {
            fe_descriptor_id = 45; // Plane Stress Quadratic Quadrilateral
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 7;
            assign_elem_nodes[2] = 3;
            assign_elem_nodes[3] = 6;
            assign_elem_nodes[4] = 2;
            assign_elem_nodes[5] = 5;
            assign_elem_nodes[6] = 1;
            assign_elem_nodes[7] = 4;
            break;
          }
 
        case QUAD9:
          {
            fe_descriptor_id = 300; // Plane Stress Quadratic Quadrilateral
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 7;
            assign_elem_nodes[2] = 3;
            assign_elem_nodes[3] = 6;
            assign_elem_nodes[4] = 2;
            assign_elem_nodes[5] = 5;
            assign_elem_nodes[6] = 1;
            assign_elem_nodes[7] = 4;
            assign_elem_nodes[8] = 8;
            break;
          }
 
        case TET4:
          {
            fe_descriptor_id = 111; // Solid Linear Tetrahedron
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 1;
            assign_elem_nodes[2] = 2;
            assign_elem_nodes[3] = 3;
            break;
          }
 
        case PRISM6:
          {
            fe_descriptor_id = 112; // Solid Linear Prism
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 1;
            assign_elem_nodes[2] = 2;
            assign_elem_nodes[3] = 3;
            assign_elem_nodes[4] = 4;
            assign_elem_nodes[5] = 5;
            break;
          }
 
        case HEX8:
          {
            fe_descriptor_id = 115; // Solid Linear Brick
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 4;
            assign_elem_nodes[2] = 5;
            assign_elem_nodes[3] = 1;
            assign_elem_nodes[4] = 3;
            assign_elem_nodes[5] = 7;
            assign_elem_nodes[6] = 6;
            assign_elem_nodes[7] = 2;
            break;
          }
 
        case HEX20:
          {
            fe_descriptor_id = 116; // Solid Quadratic Brick
            assign_elem_nodes[ 0] = 0;
            assign_elem_nodes[ 1] = 12;
            assign_elem_nodes[ 2] = 4;
            assign_elem_nodes[ 3] = 16;
            assign_elem_nodes[ 4] = 5;
            assign_elem_nodes[ 5] = 13;
            assign_elem_nodes[ 6] = 1;
            assign_elem_nodes[ 7] = 8;
 
            assign_elem_nodes[ 8] = 11;
            assign_elem_nodes[ 9] = 19;
            assign_elem_nodes[10] = 17;
            assign_elem_nodes[11] = 9;
 
            assign_elem_nodes[12] = 3;
            assign_elem_nodes[13] = 15;
            assign_elem_nodes[14] = 7;
            assign_elem_nodes[15] = 18;
            assign_elem_nodes[16] = 6;
            assign_elem_nodes[17] = 14;
            assign_elem_nodes[18] = 2;
            assign_elem_nodes[19] = 10;
 
 
            break;
          }
 
        case TET10:
          {
            fe_descriptor_id = 118; // Solid Quadratic Tetrahedron
            assign_elem_nodes[0] = 0;
            assign_elem_nodes[1] = 4;
            assign_elem_nodes[2] = 1;
            assign_elem_nodes[3] = 5;
            assign_elem_nodes[4] = 2;
            assign_elem_nodes[5] = 6;
            assign_elem_nodes[6] = 7;
            assign_elem_nodes[7] = 8;
            assign_elem_nodes[8] = 9;
            assign_elem_nodes[9] = 3;
            break;
          }
 
        default:
          libmesh_error_msg("ERROR: Element type = " << Utility::enum_to_string(elem->type()) << " not supported in " << "UNVIO!");
        }
 
      dof_id_type elem_id = elem->id();
 
      out_file << std::setw(10) << elem_id             // element ID
               << std::setw(10) << fe_descriptor_id    // type of element
               << std::setw(10) << phys_prop_tab_dummy // not supported
               << std::setw(10) << mat_prop_tab_dummy  // not supported
               << std::setw(10) << color_dummy         // not supported
               << std::setw(10) << elem->n_nodes()     // No. of nodes per element
               << '\n';
 
      for (auto j : elem->node_index_range())
        {
          // assign_elem_nodes[j]-th node: i.e., j loops over the
          // libMesh numbering, and assign_elem_nodes[j] over the
          // UNV numbering.
          const Node * node_in_unv_order = elem->node_ptr(assign_elem_nodes[j]);
 
          // new record after 8 id entries
          if (j==8 || j==16)
            out_file << '\n';
 
          // Write foreign label for this node
          dof_id_type node_id = node_in_unv_order->id();
 
          out_file << std::setw(10) << node_id;
        }
 
      out_file << '\n';
 
      n_elem_written++;
    }
 
  if (this->verbose())
    libMesh::out << "  Finished writing " << n_elem_written << " elements" << std::endl;
 
  // Write end of dataset
  out_file << "    -1\n";
}

References _elements_dataset_label, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX8, libMesh::DofObject::id(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::out, libMesh::PRISM6, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and verbose().

Referenced by write_implementation().

get_add_sides()

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

inlineprotectedvirtualinherited

Returns

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 176 of file mesh_output.h.

{ return false; }

get_data()

const std::vector< Number > * libMesh::UNVIO::get_data

(

Node *

node

)

const

Returns

A pointer the values associated with the node node, as read in by the read_dataset() method.

If no values exist for the node in question, a nullptr is returned instead. It is up to the user to check the return value before using it.

Definition at line 1317 of file unv_io.C.

{
  if (const auto it = _node_data.find(node);
      it == _node_data.end())
    return nullptr;
  else
    return &(it->second);
}

References _node_data.

Referenced by main().

groups_in()

void libMesh::UNVIO::groups_in ( std::istream &  in_file )

private

Reads the "groups" section of the file.

The format of the groups section is described here: http://www.sdrl.uc.edu/universal-file-formats-for-modal-analysis-testing-1/file-format-storehouse/unv_2467.htm

Definition at line 417 of file unv_io.C.

{
  // Grab reference to the Mesh, so we can add boundary info data to it
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // Record the max and min element dimension seen while reading the file.
  unsigned char max_dim = this->max_elem_dimension_seen();
 
  // Container which stores lower-dimensional elements (based on
  // Elem::key()) for later assignment of boundary conditions.  We
  // could use e.g. an unordered_set with Elems as keys for this, but
  // this turns out to be much slower on the search side, since we
  // have to build an entire side in order to search, rather than just
  // calling elem->key(side) to compute a key.
  typedef std::unordered_multimap<dof_id_type, Elem *> map_type;
  map_type provide_bcs;
 
  // Read groups until there aren't any more to read...
  while (true)
    {
      // If we read a -1, it means there is nothing else to read in this section.
      int group_number;
      in_file >> group_number;
 
      if (group_number == -1)
        break;
 
      // The first record consists of 8 entries:
      // Field 1 -- group number (that we just read)
      // Field 2 -- active constraint set no. for group
      // Field 3 -- active restraint set no. for group
      // Field 4 -- active load set no. for group
      // Field 5 -- active dof set no. for group
      // Field 6 -- active temperature set no. for group
      // Field 7 -- active contact set no. for group
      // Field 8 -- number of entities in group
      // Only the first and last of these are relevant to us...
      unsigned num_entities;
      std::string group_name;
      {
        unsigned dummy;
        in_file >> dummy >> dummy >> dummy >> dummy >> dummy >> dummy
                >> num_entities;
 
        // The second record has 1 field, the group name
        in_file >> group_name;
      }
 
      // The dimension of the elements in the group will determine
      // whether this is a sideset group or a subdomain group.
      bool
        is_subdomain_group = false,
        is_sideset_group = false;
 
      // Each subsequent line has 8 entries, there are two entity type
      // codes and two tags per line that we need to read.  In all my
      // examples, the entity type code was always "8", which stands for
      // "finite elements" but it's possible that we could eventually
      // support other entity type codes...
      // Field 1 -- entity type code
      // Field 2 -- entity tag
      // Field 3 -- entity node leaf id.
      // Field 4 -- entity component/ ham id.
      // Field 5 -- entity type code
      // Field 6 -- entity tag
      // Field 7 -- entity node leaf id.
      // Field 8 -- entity component/ ham id.
      {
        unsigned entity_type_code, entity_tag, dummy;
        for (unsigned entity=0; entity<num_entities; ++entity)
          {
            in_file >> entity_type_code >> entity_tag >> dummy >> dummy;
 
            if (entity_type_code != 8)
              libMesh::err << "Warning, unrecognized entity type code = "
                           << entity_type_code
                           << " in group "
                           << group_name
                           << std::endl;
 
            // Try to find this ID in the map from UNV element ids to libmesh ids.
            if (const auto it = _unv_elem_id_to_libmesh_elem_id.find(entity_tag);
                it != _unv_elem_id_to_libmesh_elem_id.end())
              {
                unsigned libmesh_elem_id = it->second;
 
                // Attempt to get a pointer to the elem listed in the group
                Elem * group_elem = mesh.elem_ptr(libmesh_elem_id);
 
                // dim < max_dim means the Elem defines a boundary condition
                if (group_elem->dim() < max_dim)
                  {
                    is_sideset_group = true;
 
                    // We can only handle elements that are *exactly*
                    // one dimension lower than the max element
                    // dimension.  Not sure if "edge" BCs in 3D
                    // actually make sense/are required...
                    libmesh_error_msg_if(group_elem->dim()+1 != max_dim,
                                         "ERROR: Expected boundary element of dimension "
                                         << max_dim-1 << " but got " << group_elem->dim());
 
                    // Set the current group number as the lower-dimensional element's subdomain ID.
                    // We will use this later to set a boundary ID.
                    group_elem->subdomain_id() =
                      restrict_int<subdomain_id_type>(group_number);
 
                    // Store the lower-dimensional element in the provide_bcs container.
                    provide_bcs.emplace(group_elem->key(), group_elem);
                  }
 
                // dim == max_dim means this group defines a subdomain ID
                else if (group_elem->dim() == max_dim)
                  {
                    is_subdomain_group = true;
                    group_elem->subdomain_id() =
                      restrict_int<subdomain_id_type>(group_number);
                  }
 
                else
                  libmesh_error_msg("ERROR: Found an elem with dim=" \
                                    << group_elem->dim() << " > " << "max_dim=" << +max_dim);
              }
            else
              libMesh::err << "WARNING: UNV Element " << entity_tag << " not found while parsing groups." << std::endl;
          } // end for (entity)
      } // end scope
 
      // Associate this group_number with the group_name in the BoundaryInfo object.
      if (is_sideset_group)
        mesh.get_boundary_info().sideset_name
          (cast_int<boundary_id_type>(group_number)) = group_name;
 
      if (is_subdomain_group)
        mesh.set_subdomain_name
          (cast_int<subdomain_id_type>(group_number), group_name);
 
    } // end while (true)
 
  // Loop over elements and try to assign boundary information
  for (auto & elem : mesh.active_element_ptr_range())
    if (elem->dim() == max_dim)
      for (auto sn : elem->side_index_range())
        for (const auto & pr : as_range(provide_bcs.equal_range (elem->key(sn))))
          {
            // This is a max-dimension element that may require BCs.
            // For each of its sides, including internal sides, we'll
            // see if a lower-dimensional element provides boundary
            // information for it.  Note that we have not yet called
            // find_neighbors(), so we can't use elem->neighbor(sn) in
            // this algorithm...
 
            // Build a side to confirm the hash mapped to the correct side.
            std::unique_ptr<Elem> side (elem->build_side_ptr(sn));
 
            // Get a pointer to the lower-dimensional element
            Elem * lower_dim_elem = pr.second;
 
            // This was a hash, so it might not be perfect.  Let's verify...
            if (*lower_dim_elem == *side)
              mesh.get_boundary_info().add_side(elem, sn, lower_dim_elem->subdomain_id());
          }
}

References _unv_elem_id_to_libmesh_elem_id, libMesh::BoundaryInfo::add_side(), libMesh::as_range(), libMesh::Elem::dim(), libMesh::MeshBase::elem_ptr(), libMesh::err, libMesh::MeshBase::get_boundary_info(), libMesh::Elem::key(), max_elem_dimension_seen(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::set_subdomain_name(), libMesh::BoundaryInfo::sideset_name(), and libMesh::Elem::subdomain_id().

Referenced by read_implementation().

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

max_elem_dimension_seen()

unsigned char libMesh::UNVIO::max_elem_dimension_seen ( )

private

Returns

The maximum geometric element dimension encountered while reading the Mesh. Only valid after the elements have been read in and the elems_of_dimension array has been populated.

Definition at line 384 of file unv_io.C.

{
  unsigned char max_dim = 0;
 
  unsigned char elem_dimensions_size = cast_int<unsigned char>
    (elems_of_dimension.size());
  // The elems_of_dimension array is 1-based in the UNV reader
  for (unsigned char i=1; i<elem_dimensions_size; ++i)
    if (elems_of_dimension[i])
      max_dim = i;
 
  return max_dim;
}

References libMesh::MeshInput< MeshBase >::elems_of_dimension.

Referenced by groups_in(), and read_implementation().

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

need_D_to_e()

bool libMesh::UNVIO::need_D_to_e ( std::string &  number )

private

Replaces "1.1111D+00" with "1.1111e+00" if necessary.

This function only needs to be called once per stream, one can assume that if one number needs rewriting, they all do.

Returns

true if the replacement occurs, false otherwise.

Definition at line 400 of file unv_io.C.

{
  // find "D" in string, start looking at 6th element since dont expect a "D" earlier.
  std::string::size_type position = number.find("D", 6);
 
  if (position != std::string::npos)
    {
      // replace "D" in string
      number.replace(position, 1, "e");
      return true;
    }
  else
    return false;
}

Referenced by read_dataset().

nodes_in()

void libMesh::UNVIO::nodes_in ( std::istream &  in_file )

private

Read nodes from file.

Definition at line 298 of file unv_io.C.

{
  LOG_SCOPE("nodes_in()","UNVIO");
 
  if (this->verbose())
    libMesh::out << "  Reading nodes" << std::endl;
 
  MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
  // node label, we use an int here so we can read in a -1
  int node_label;
 
  // We'll just read the floating point values as strings even when
  // there are no "D" characters in the file.  This will make parsing
  // the file a bit slower but the logic to do so will all be
  // simplified and in one place...
  std::string line;
  std::istringstream coords_stream;
 
  // Continue reading nodes until there are none left
  unsigned ctr = 0;
  while (true)
    {
      // Read the node label
      in_file >> node_label;
 
      // Break out of the while loop when we hit -1
      if (node_label == -1)
        break;
 
      // Read and discard the the rest of the node data on this line
      // which we do not currently use:
      // .) exp_coord_sys_num
      // .) disp_coord_sys_num
      // .) color
      std::getline(in_file, line);
 
      // read the floating-point data
      std::getline(in_file, line);
 
      // Replace any "D" characters used for exponents with "E"
      size_t last_pos = 0;
      while (true)
        {
          last_pos = line.find("D", last_pos);
 
          if (last_pos != std::string::npos)
            line.replace(last_pos, 1, "E");
          else
            break;
        }
 
      // Construct a stream object from the current line and then
      // stream in the xyz values.
      coords_stream.str(line);
      coords_stream.clear(); // clear iostate bits!  Important!
 
      // always 3 coordinates in the UNV file, no matter
      // what LIBMESH_DIM is.
      std::array<Real, 3> xyz;
 
      coords_stream >> xyz[0] >> xyz[1] >> xyz[2];
 
      Point p(xyz[0]);
#if LIBMESH_DIM > 1
      p(1) = xyz[1];
#else
      libmesh_assert_equal_to(xyz[1], 0);
#endif
#if LIBMESH_DIM > 2
      p(2) = xyz[2];
#else
      libmesh_assert_equal_to(xyz[2], 0);
#endif
 
      // Add node to the Mesh, bump the counter.
      Node * added_node = mesh.add_point(p, ctr++);
 
      // Maintain the mapping between UNV node ids and libmesh Node
      // pointers.
      _unv_node_id_to_libmesh_node_ptr[node_label] = added_node;
    }
}

References _unv_node_id_to_libmesh_node_ptr, libMesh::MeshBase::add_point(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::out, and verbose().

Referenced by read_implementation().

nodes_out()

void libMesh::UNVIO::nodes_out ( std::ostream &  out_file )

private

Outputs nodes to the file out_file.

Do not use this directly, but through the proper write method.

Definition at line 870 of file unv_io.C.

{
  if (this->verbose())
    libMesh::out << "  Writing " << MeshOutput<MeshBase>::mesh().n_nodes() << " nodes" << std::endl;
 
  // Write beginning of dataset
  out_file << "    -1\n"
           << "  "
           << _nodes_dataset_label
           << '\n';
 
  unsigned int
    exp_coord_sys_dummy  = 0, // export coordinate sys. (not supported yet)
    disp_coord_sys_dummy = 0, // displacement coordinate sys. (not supp. yet)
    color_dummy          = 0; // color(not supported yet)
 
  // A reference to the parent class's mesh
  const MeshBase & mesh = MeshOutput<MeshBase>::mesh();
 
  // Use scientific notation with capital E and default 17 digits for printing out the coordinates
  out_file << std::scientific << std::setprecision(this->ascii_precision()) << std::uppercase;
 
  for (const auto & current_node : mesh.node_ptr_range())
    {
      dof_id_type node_id = current_node->id();
 
      out_file << std::setw(10) << node_id
               << std::setw(10) << exp_coord_sys_dummy
               << std::setw(10) << disp_coord_sys_dummy
               << std::setw(10) << color_dummy
               << '\n';
 
      // The coordinates - always write out three coords regardless of LIBMESH_DIM
      Real x = (*current_node)(0);
 
#if LIBMESH_DIM > 1
      Real y = (*current_node)(1);
#else
      Real y = 0.;
#endif
 
#if LIBMESH_DIM > 2
      Real z = (*current_node)(2);
#else
      Real z = 0.;
#endif
 
      out_file << std::setw(25) << x
               << std::setw(25) << y
               << std::setw(25) << z
               << '\n';
    }
 
  // Write end of dataset
  out_file << "    -1\n";
}

References _nodes_dataset_label, libMesh::MeshOutput< MeshBase >::ascii_precision(), libMesh::MeshInput< MeshBase >::mesh(), libMesh::MeshOutput< MT >::mesh(), libMesh::out, libMesh::Real, and verbose().

Referenced by write_implementation().

read()

void libMesh::UNVIO::read ( const std::string &  file_name )

overridevirtual

This method implements reading a mesh from a specified file.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 96 of file unv_io.C.

{
  if (Utility::contains(file_name, ".gz"))
    {
#ifdef LIBMESH_HAVE_GZSTREAM
 
      igzstream in_stream (file_name.c_str());
      this->read_implementation (in_stream);
 
#else
 
      libmesh_error_msg("ERROR:  You must have the zlib.h header files and libraries to read and write compressed streams.");
 
#endif
      return;
    }
 
  else
    {
      std::ifstream in_stream (file_name.c_str());
      this->read_implementation (in_stream);
      return;
    }
}

References libMesh::Utility::contains(), and read_implementation().

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

read_dataset()

void libMesh::UNVIO::read_dataset

(

std::string

file_name

)

Read a UNV data file containing a dataset of type "2414".

For more info, see http://tinyurl.com/htcf6zm

Definition at line 1161 of file unv_io.C.

{
  std::ifstream in_stream(file_name.c_str());
 
  libmesh_error_msg_if(!in_stream.good(), "Error opening UNV data file.");
 
  std::string olds, news, dummy;
 
  while (true)
    {
      in_stream >> olds >> news;
 
      // A "-1" followed by a number means the beginning of a dataset.
      while (((olds != "-1") || (news == "-1")) && !in_stream.eof())
        {
          olds = news;
          in_stream >> news;
        }
 
      if (in_stream.eof())
        break;
 
      // We only support reading datasets in the "2414" format.
      if (news == "2414")
        {
          // Ignore the rest of the current line and the next two
          // lines that contain analysis dataset label and name.
          for (unsigned int i=0; i<3; i++)
            std::getline(in_stream, dummy);
 
          // Read the dataset location, where
          // 1: Data at nodes
          // 2: Data on elements
          // Currently only data on nodes is supported.
          unsigned int dataset_location;
          in_stream >> dataset_location;
 
          // Currently only nodal datasets are supported.
          libmesh_error_msg_if(dataset_location != 1, "ERROR: Currently only Data at nodes is supported.");
 
          // Ignore the rest of this line and the next five records.
          for (unsigned int i=0; i<6; i++)
            std::getline(in_stream, dummy);
 
          // These data are all of no interest to us...
          unsigned int
            model_type,
            analysis_type,
            data_characteristic,
            result_type;
 
          // The type of data (complex, real, float, double etc, see
          // below).
          unsigned int data_type;
 
          // The number of floating-point values per entity.
          unsigned int num_vals_per_node;
 
          in_stream >> model_type           // not used here
                    >> analysis_type        // not used here
                    >> data_characteristic  // not used here
                    >> result_type          // not used here
                    >> data_type
                    >> num_vals_per_node;
 
          // Ignore the rest of record 9, and records 10-13.
          for (unsigned int i=0; i<5; i++)
            std::getline(in_stream, dummy);
 
          // Now get the foreign (aka UNV node) node number and
          // the respective nodal data.
          int f_n_id;
          std::vector<Number> values;
 
          while (true)
            {
              in_stream >> f_n_id;
 
              // If -1 then we have reached the end of the dataset.
              if (f_n_id == -1)
                break;
 
              // Resize the values vector (usually data in three
              // principle directions, i.e. num_vals_per_node = 3).
              values.resize(num_vals_per_node);
 
              // Read the values for the respective node.
              for (unsigned int data_cnt=0; data_cnt<num_vals_per_node; data_cnt++)
                {
                  // Check what data type we are reading.
                  // 2,4: Real
                  // 5,6: Complex
                  // other data types are not supported yet.
                  // As again, these floats may also be written
                  // using a 'D' instead of an 'e'.
                  if (data_type == 2 || data_type == 4)
                    {
                      std::string buf;
                      in_stream >> buf;
                      this->need_D_to_e(buf);
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                      values[data_cnt] = Complex(std::atof(buf.c_str()), 0.);
#else
                      values[data_cnt] = std::atof(buf.c_str());
#endif
                    }
 
                  else if (data_type == 5 || data_type == 6)
                    {
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                      Real re_val, im_val;
 
                      std::string buf;
                      in_stream >> buf;
 
                      if (this->need_D_to_e(buf))
                        {
                          re_val = std::atof(buf.c_str());
                          in_stream >> buf;
                          this->need_D_to_e(buf);
                          im_val = std::atof(buf.c_str());
                        }
                      else
                        {
                          re_val = std::atof(buf.c_str());
                          in_stream >> im_val;
                        }
 
                      values[data_cnt] = Complex(re_val,im_val);
#else
 
                      libmesh_error_msg("ERROR: Complex data only supported when libMesh is configured with --enable-complex!");
#endif
                    }
 
                  else
                    libmesh_error_msg("ERROR: Data type not supported.");
 
                } // end loop data_cnt
 
              // Get a pointer to the Node associated with the UNV node id.
              auto & node_ptr = libmesh_map_find(_unv_node_id_to_libmesh_node_ptr, f_n_id);
 
              // Store the nodal values in our map which uses the
              // libMesh Node* as the key.  We use operator[] here
              // because we want to create an empty vector if the
              // entry does not already exist.
              _node_data[node_ptr] = values;
            } // end while (true)
        } // end if (news == "2414")
    } // end while (true)
}

References _node_data, _unv_node_id_to_libmesh_node_ptr, need_D_to_e(), and libMesh::Real.

Referenced by main().

read_implementation()

void libMesh::UNVIO::read_implementation ( std::istream &  in_stream )

private

The actual implementation of the read function.

The public read interface simply decides which type of stream to pass the implementation.

Definition at line 122 of file unv_io.C.

{
  // Keep track of what kinds of elements this file contains
  elems_of_dimension.clear();
  elems_of_dimension.resize(4, false);
 
  {
    libmesh_error_msg_if(!in_stream.good(), "ERROR: Input file not good.");
 
    // Flags to be set when certain sections are encountered
    bool
      found_node  = false,
      found_elem  = false,
      found_group = false;
 
    // strings for reading the file line by line
    std::string
      old_line,
      current_line;
 
    while (true)
      {
        // Save off the old_line.  This will provide extra reliability
        // for detecting the beginnings of the different sections.
        old_line = current_line;
 
        // Try to read something.  This may set EOF!
        std::getline(in_stream, current_line);
 
        // If the stream is still "valid", parse the line
        if (in_stream)
          {
            // UNV files always have some amount of leading
            // whitespace, let's not rely on exactly how much...  This
            // command deletes it.
            current_line.erase(std::remove_if(current_line.begin(), current_line.end(),
                                              [](unsigned char const c){return std::isspace(c);}),
                               current_line.end());
 
            // Parse the nodes section
            if (current_line == _nodes_dataset_label &&
                old_line == "-1")
              {
                found_node = true;
                this->nodes_in(in_stream);
              }
 
            // Parse the elements section
            else if (current_line == _elements_dataset_label &&
                     old_line == "-1")
              {
                // The current implementation requires the nodes to
                // have been read before reaching the elements
                // section.
                libmesh_error_msg_if(!found_node,
                                     "ERROR: The Nodes section must come before the Elements section of the UNV file!");
 
                found_elem = true;
                this->elements_in(in_stream);
              }
 
            // Parse the groups section
            else if (current_line == _groups_dataset_label &&
                     old_line == "-1")
              {
                // The current implementation requires the nodes and
                // elements to have already been read before reaching
                // the groups section.
                libmesh_error_msg_if(!found_node || !found_elem,
                                     "ERROR: The Nodes and Elements sections must come before the Groups section of the UNV file!");
 
                found_group = true;
                this->groups_in(in_stream);
              }
 
            // We can stop reading once we've found the nodes, elements,
            // and group sections.
            if (found_node && found_elem && found_group)
              break;
 
            // If we made it here, we're not done yet, so keep reading
            continue;
          }
 
        // if (!in_stream) check to see if EOF was set.  If so, break out of while loop.
        if (in_stream.eof())
          break;
 
        // If !in_stream and !in_stream.eof(), stream is in a bad state!
        libmesh_error_msg("Stream is bad! Perhaps the file does not exist?");
      } // end while (true)
 
    // By now we better have found the datasets for nodes and elements,
    // otherwise the unv file is bad!
    libmesh_error_msg_if(!found_node, "ERROR: Could not find nodes!");
    libmesh_error_msg_if(!found_elem, "ERROR: Could not find elements!");
  }
 
 
 
  {
    // Set the mesh dimension to the largest element dimension encountered
    MeshInput<MeshBase>::mesh().set_mesh_dimension(max_elem_dimension_seen());
 
#if LIBMESH_DIM < 3
    libmesh_error_msg_if(MeshInput<MeshBase>::mesh().mesh_dimension() > LIBMESH_DIM,
                         "Cannot open dimension "
                         << MeshInput<MeshBase>::mesh().mesh_dimension()
                         << " mesh file when configured without "
                         << MeshInput<MeshBase>::mesh().mesh_dimension()
                         << "D support." );
#endif
 
    // Delete any lower-dimensional elements that might have been
    // added to the mesh strictly for setting BCs.
    {
      // Grab reference to the Mesh
      MeshBase & mesh = MeshInput<MeshBase>::mesh();
 
      unsigned char max_dim = this->max_elem_dimension_seen();
 
      for (const auto & elem : mesh.element_ptr_range())
        if (elem->dim() < max_dim)
          mesh.delete_elem(elem);
    }
 
    if (this->verbose())
      libMesh::out << "  Finished." << std::endl << std::endl;
  }
}

References _elements_dataset_label, _groups_dataset_label, _nodes_dataset_label, libMesh::MeshBase::delete_elem(), elements_in(), libMesh::MeshInput< MeshBase >::elems_of_dimension, groups_in(), max_elem_dimension_seen(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), nodes_in(), libMesh::out, and verbose().

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

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

verbose()

bool & libMesh::UNVIO::verbose

(

)

Set the flag indicating if we should be verbose.

Definition at line 89 of file unv_io.C.

{
  return _verbose;
}

References _verbose.

Referenced by elements_in(), elements_out(), nodes_in(), nodes_out(), and read_implementation().

write()

void libMesh::UNVIO::write ( const std::string &  file_name )

overridevirtual

This method implements writing a mesh to a specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 257 of file unv_io.C.

{
  if (Utility::contains(file_name, ".gz"))
    {
#ifdef LIBMESH_HAVE_GZSTREAM
 
      ogzstream out_stream(file_name.c_str());
      this->write_implementation (out_stream);
 
#else
 
      libmesh_error_msg("ERROR:  You must have the zlib.h header files and libraries to read and write compressed streams.");
 
#endif
 
      return;
    }
 
  else
    {
      std::ofstream out_stream (file_name.c_str());
      this->write_implementation (out_stream);
      return;
    }
}

References libMesh::Utility::contains(), and write_implementation().

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

void libMesh::UNVIO::write_implementation ( std::ostream &  out_stream )

private

The actual implementation of the write function.

The public write interface simply decides which type of stream to pass the implementation.

Definition at line 286 of file unv_io.C.

{
  libmesh_error_msg_if(!out_file.good(), "ERROR: Output file not good.");
 
  // write the nodes, then the elements
  this->nodes_out    (out_file);
  this->elements_out (out_file);
}

References elements_out(), and nodes_out().

Referenced by write().

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.

_elements_dataset_label

const std::string libMesh::UNVIO::_elements_dataset_label = "2412"

staticprivate

label for the element dataset

Definition at line 198 of file unv_io.h.

Referenced by elements_out(), and read_implementation().

_groups_dataset_label

const std::string libMesh::UNVIO::_groups_dataset_label = "2467"

staticprivate

label for the groups dataset

Definition at line 203 of file unv_io.h.

Referenced by read_implementation().

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

_node_data

std::map<Node *, std::vector<Number> > libMesh::UNVIO::_node_data

private

Map from libMesh Node* to data at that node, as read in by the read_dataset() function.

Definition at line 214 of file unv_io.h.

Referenced by get_data(), and read_dataset().

_nodes_dataset_label

const std::string libMesh::UNVIO::_nodes_dataset_label = "2411"

staticprivate

label for the node dataset

Definition at line 193 of file unv_io.h.

Referenced by nodes_out(), and read_implementation().

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

_unv_elem_id_to_libmesh_elem_id

std::map<unsigned, unsigned> libMesh::UNVIO::_unv_elem_id_to_libmesh_elem_id

private

Map UNV element IDs to libmesh element IDs.

Definition at line 208 of file unv_io.h.

Referenced by elements_in(), and groups_in().

_unv_node_id_to_libmesh_node_ptr

std::map<dof_id_type, Node *> libMesh::UNVIO::_unv_node_id_to_libmesh_node_ptr

private

Maps UNV node IDs to libMesh Node*s.

Used when reading. Even if the libMesh Mesh is renumbered, this map should continue to be valid.

Definition at line 188 of file unv_io.h.

Referenced by elements_in(), nodes_in(), and read_dataset().

_verbose

bool libMesh::UNVIO::_verbose

private

should be be verbose?

Definition at line 182 of file unv_io.h.

Referenced by verbose().

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