#include <unv_io.h>

Inheritance diagram for libMesh::UNVIO:

Public Member Functions
	UNVIO (MeshBase &mesh)

	UNVIO (const MeshBase &mesh)

virtual	~UNVIO ()

virtual void	read (const std::string &) override

virtual void	write (const std::string &) override

bool &	verbose ()

void	read_dataset (std::string file_name)

const std::vector< Number > *	get_data (Node *node) const

virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)

virtual void	write_discontinuous_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=nullptr)

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

virtual void	write_nodal_data (const std::string &, const NumericVector< Number > &, const std::vector< std::string > &)

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

unsigned int &	ascii_precision ()

Protected Member Functions
MeshBase &	mesh ()

void	set_n_partitions (unsigned int n_parts)

void	skip_comment_lines (std::istream &in, const char comment_start)

const MeshBase &	mesh () const

Protected Attributes
std::vector< bool >	elems_of_dimension

const bool	_is_parallel_format

const bool	_serial_only_needed_on_proc_0

Private Member Functions
void	read_implementation (std::istream &in_stream)

void	write_implementation (std::ostream &out_stream)

void	nodes_in (std::istream &in_file)

void	elements_in (std::istream &in_file)

void	groups_in (std::istream &in_file)

void	nodes_out (std::ostream &out_file)

void	elements_out (std::ostream &out_file)

unsigned char	max_elem_dimension_seen ()

bool	need_D_to_e (std::string &number)

Private Attributes
bool	_verbose

std::map< dof_id_type, Node * >	_unv_node_id_to_libmesh_node_ptr

std::map< unsigned, unsigned >	_unv_elem_id_to_libmesh_elem_id

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

Static Private Attributes
static const std::string	_nodes_dataset_label = "2411"

static const std::string	_elements_dataset_label = "2412"

static const std::string	_groups_dataset_label = "2467"

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 66 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 75 of file unv_io.C.

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

◆ ~UNVIO()

libMesh::UNVIO::~UNVIO ( )

virtual

Destructor.

Definition at line 83 of file unv_io.C.

84 {

85 }

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

Definition at line 244 of file mesh_output.h.

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

 {
   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 574 of file unv_io.C.

References _unv_elem_id_to_libmesh_elem_id, _unv_node_id_to_libmesh_node_ptr, libMesh::MeshBase::add_elem(), libMesh::Elem::dim(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::MeshInput< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), n_nodes, libMesh::out, libMesh::DofObject::set_id(), libMesh::Elem::set_node(), and verbose().

Referenced by read_implementation().

 {
   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
       Elem * elem = nullptr;
 
       switch (fe_descriptor_id)
         {
         case 11: // Rod
           {
             elem = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 = new 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 it = _unv_node_id_to_libmesh_node_ptr.find(node_labels[j]);
           if (it != _unv_node_id_to_libmesh_node_ptr.end())
             elem->set_node(assign_elem_nodes[j]) = it->second;
           else
             libmesh_error_msg("ERROR: UNV node " << node_labels[j] << " not found!");
         }
 
       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(elem);
 
       // Increment the counter for the next iteration
       ctr++;
     } // end while (true)
 }

◆ 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 924 of file unv_io.C.

References _elements_dataset_label, libMesh::MeshBase::element_ptr_range(), 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().

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

◆ 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 1314 of file unv_io.C.

References _node_data.

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

◆ 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 408 of file unv_io.C.

References _unv_elem_id_to_libmesh_elem_id, libMesh::MeshBase::active_element_ptr_range(), 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< MT >::mesh(), libMesh::MeshInput< MeshBase >::mesh(), side, libMesh::BoundaryInfo::sideset_name(), libMesh::Elem::subdomain_id(), and libMesh::MeshBase::subdomain_name().

Referenced by read_implementation().

 {
   // 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.
             auto it = _unv_elem_id_to_libmesh_elem_id.find(entity_tag);
             if (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...
                     if (group_elem->dim()+1 != max_dim)
                       libmesh_error_msg("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() =
                       cast_int<subdomain_id_type>(group_number);
 
                     // Store the lower-dimensional element in the provide_bcs container.
                     provide_bcs.insert(std::make_pair(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() =
                       cast_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.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());
           }
 }

◆ 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 375 of file unv_io.C.

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

Referenced by groups_in(), and read_implementation().

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

◆ mesh() [1/2]

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

inlineprotectedinherited

Returns: The object as a writable reference.

Definition at line 169 of file mesh_input.h.

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

◆ mesh() [2/2]

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

inlineprotectedinherited

Returns: The object as a read-only reference.

Definition at line 234 of file mesh_output.h.

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

 {
   libmesh_assert(_obj);
   return *_obj;
 }

◆ 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 391 of file unv_io.C.

Referenced by read_dataset().

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

◆ nodes_in()

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

private

Read nodes from file.

Definition at line 302 of file unv_io.C.

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

 {
   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;
 
   // always 3 coordinates in the UNV file, no matter
   // what LIBMESH_DIM is.
   Point xyz;
 
   // 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!
       coords_stream >> xyz(0) >> xyz(1) >> xyz(2);
 
       // Add node to the Mesh, bump the counter.
       Node * added_node = mesh.add_point(xyz, ctr++);
 
       // Maintain the mapping between UNV node ids and libmesh Node
       // pointers.
       _unv_node_id_to_libmesh_node_ptr[node_label] = added_node;
     }
 }

◆ 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 862 of file unv_io.C.

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

Referenced by write_implementation().

 {
   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 16 digits for printing out the coordinates
   out_file << std::scientific << std::setprecision(16) << 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";
 }

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

References read_implementation().

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

 {
   if (file_name.rfind(".gz") < file_name.size())
     {
 #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;
     }
 }

◆ 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 1153 of file unv_io.C.

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

 {
   std::ifstream in_stream(file_name.c_str());
 
   if (!in_stream.good())
     libmesh_error_msg("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.
           if (dataset_location != 1)
             libmesh_error_msg("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 it = _unv_node_id_to_libmesh_node_ptr.find(f_n_id);
 
               if (it == _unv_node_id_to_libmesh_node_ptr.end())
                 libmesh_error_msg("UNV node id " << f_n_id << " was not found.");
 
               // 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[it->second] = values;
             } // end while (true)
         } // end if (news == "2414")
     } // end while (true)
 }

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

References _elements_dataset_label, _groups_dataset_label, _nodes_dataset_label, libMesh::MeshBase::delete_elem(), libMesh::MeshBase::element_ptr_range(), 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().

 {
   // Keep track of what kinds of elements this file contains
   elems_of_dimension.clear();
   elems_of_dimension.resize(4, false);
 
   {
     if (!in_stream.good())
       libmesh_error_msg("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(), isspace),
                                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.
                 if (!found_node)
                   libmesh_error_msg("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.
                 if (!found_node || !found_elem)
                   libmesh_error_msg("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!
     if (!found_node)
       libmesh_error_msg("ERROR: Could not find nodes!");
 
     if (!found_elem)
       libmesh_error_msg("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
     if (MeshInput<MeshBase>::mesh().mesh_dimension() > LIBMESH_DIM)
       libmesh_error_msg("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;
   }
 }

◆ set_n_partitions()

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

inlineprotectedinherited

Sets the number of partitions in the mesh. Typically this gets done by the partitioner, but some parallel file formats begin "pre-partitioned".

Definition at line 91 of file mesh_input.h.

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

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

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

libMesh::MeshInput< MeshBase >::mesh

MeshBase & mesh()

Definition: mesh_input.h:169

libMesh::MeshBase::set_n_partitions

unsigned int & set_n_partitions()

Definition: mesh_base.h:1371

◆ skip_comment_lines()

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

protectedinherited

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

Definition at line 179 of file mesh_input.h.

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

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

◆ verbose()

bool & libMesh::UNVIO::verbose ( )

Set the flag indicating if we should be verbose.

Definition at line 89 of file unv_io.C.

References _verbose.

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

 {
   return _verbose;
 }

◆ 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 260 of file unv_io.C.

References write_implementation().

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

 {
   if (file_name.rfind(".gz") < file_name.size())
     {
 #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;
     }
 }

◆ write_discontinuous_equation_systems()

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

virtualinherited

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

Definition at line 92 of file mesh_output.C.

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

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

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

◆ write_equation_systems()

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

virtualinherited

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

Reimplemented in libMesh::NameBasedIO.

Definition at line 31 of file mesh_output.C.

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

Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_IO::write_timestep().

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

◆ write_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 289 of file unv_io.C.

References elements_out(), and nodes_out().

Referenced by write().

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

◆ write_nodal_data() [1/2]

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::Nemesis_IO, libMesh::UCDIO, libMesh::NameBasedIO, libMesh::GmshIO, libMesh::GMVIO, libMesh::VTKIO, libMesh::MEDITIO, libMesh::GnuPlotIO, and libMesh::TecplotIO.

Definition at line 105 of file mesh_output.h.

108 { libmesh_not_implemented(); }

◆ write_nodal_data() [2/2]

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

virtualinherited

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

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

Reimplemented in libMesh::Nemesis_IO.

Definition at line 150 of file mesh_output.C.

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

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

◆ write_nodal_data_discontinuous()

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

inlinevirtualinherited

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

Reimplemented in libMesh::ExodusII_IO.

Definition at line 114 of file mesh_output.h.

117 { libmesh_not_implemented(); }

Member Data Documentation

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

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

protectedinherited

Flag specifying whether this format is parallel-capable. If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 159 of file mesh_output.h.

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

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

◆ _serial_only_needed_on_proc_0

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

protectedinherited

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

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

Definition at line 168 of file mesh_output.h.

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

Referenced by libMesh::GMVIO::_read_one_cell(), elements_in(), max_elem_dimension_seen(), libMesh::AbaqusIO::max_elem_dimension_seen(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GMVIO::read(), libMesh::VTKIO::read(), libMesh::AbaqusIO::read_elements(), libMesh::UCDIO::read_implementation(), read_implementation(), and libMesh::XdrIO::read_serialized_connectivity().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ UNVIO() [1/2]

◆ UNVIO() [2/2]

◆ ~UNVIO()

Member Function Documentation

◆ ascii_precision()

◆ elements_in()

◆ elements_out()

◆ get_data()

◆ groups_in()

◆ max_elem_dimension_seen()

◆ mesh() [1/2]

◆ mesh() [2/2]

◆ need_D_to_e()

◆ nodes_in()

◆ nodes_out()

◆ read()

◆ read_dataset()

◆ read_implementation()

◆ set_n_partitions()

◆ skip_comment_lines()

◆ verbose()

◆ write()

◆ write_discontinuous_equation_systems()

◆ write_equation_systems()

◆ write_implementation()

◆ write_nodal_data() [1/2]

◆ write_nodal_data() [2/2]

◆ write_nodal_data_discontinuous()

Member Data Documentation

◆ _elements_dataset_label

◆ _groups_dataset_label

◆ _is_parallel_format

◆ _node_data

◆ _nodes_dataset_label

◆ _serial_only_needed_on_proc_0

◆ _unv_elem_id_to_libmesh_elem_id

◆ _unv_node_id_to_libmesh_node_ptr

◆ _verbose

◆ elems_of_dimension