libMesh::EnsightIO Class Reference

This class implements writing meshes and solutions in Ensight's Gold format. More...

#include <ensight_io.h>

Inheritance diagram for libMesh::EnsightIO:

Classes
struct	Scalars
struct	SystemVars
struct	Vectors

Public Member Functions
	EnsightIO (const std::string &filename, const EquationSystems &eq)
	Constructor.
	~EnsightIO ()=default
	Empty destructor.
void	add_scalar (const std::string &system, std::string_view scalar_description, std::string_view s)
	Tell the EnsightIO interface to output the finite element (not SCALAR) variable named "s".
void	add_vector (const std::string &system, std::string_view vec_description, std::string u, std::string v)
	Tell the EnsightIO interface that the variables (u,v) constitute a vector.
void	add_vector (const std::string &system, std::string_view vec_description, std::string u, std::string v, std::string w)
	Tell the EnsightIO interface that the variables (u, v, w) constitute a vector.
void	write (Real time=0)
	Calls write_ascii() and write_case().
virtual void	write (const std::string &name) override
	Calls this->write(0);.
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
const MeshBase &	mesh () const
virtual bool	get_add_sides ()

Protected Attributes
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.
const bool	_serial_only_needed_on_proc_0
	Flag specifying whether this format can be written by only serializing the mesh to processor zero.

Private Member Functions
void	write_ascii (Real time=0)
void	write_scalar_ascii (std::string_view sys, std::string_view var)
void	write_vector_ascii (std::string_view sys, const std::vector< std::string > &vec, std::string_view var_name)
void	write_solution_ascii ()
void	write_geometry_ascii ()
void	write_case ()

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

Private Attributes
std::string	_ensight_file_name
std::vector< Real >	_time_steps
std::map< std::string, SystemVars >	_system_vars_map
const EquationSystems &	_equation_systems
const MeshBase *const	_obj
	A pointer to a constant object.
unsigned int	_ascii_precision
	Precision to use when writing ASCII files.

Static Private Attributes
static std::map< ElemType, std::string >	_element_map = EnsightIO::build_element_map()

Detailed Description

This class implements writing meshes and solutions in Ensight's Gold format.

Author

Camata

Date

2009

Author

J. W. Peterson (refactoring and iostreams implementation)

Date

2016

Definition at line 47 of file ensight_io.h.

Constructor & Destructor Documentation

EnsightIO()

libMesh::EnsightIO::EnsightIO	(	const std::string &	filename,
		const EquationSystems &	eq
	)

Constructor.

Definition at line 65 of file ensight_io.C.

                                                  :
  MeshOutput<MeshBase> (eq.get_mesh()),
  _equation_systems(eq)
{
  if (_equation_systems.n_processors() == 1)
    _ensight_file_name = filename;
  else
    {
      std::ostringstream tmp_file;
      tmp_file << filename << "_rank" << _equation_systems.processor_id();
      _ensight_file_name = tmp_file.str();
    }
}

References _ensight_file_name, _equation_systems, libMesh::ParallelObject::n_processors(), and libMesh::ParallelObject::processor_id().

~EnsightIO()

libMesh::EnsightIO::~EnsightIO ( )

default

Empty destructor.

Member Function Documentation

add_scalar()

void libMesh::EnsightIO::add_scalar	(	const std::string &	system,
		std::string_view	scalar_description,
		std::string_view	s
	)

Tell the EnsightIO interface to output the finite element (not SCALAR) variable named "s".

Note

You must call add_scalar() or add_vector() (see below) at least once, otherwise only the Mesh will be written out.

Definition at line 122 of file ensight_io.C.

{
  libmesh_assert(_equation_systems.has_system(system_name));
  libmesh_assert(_equation_systems.get_system(system_name).has_variable(s));
 
  Scalars scl;
  scl.description = scl_description;
  scl.scalar_name = s;
 
  _system_vars_map[system_name].EnsightScalars.push_back(std::move(scl));
}

References _equation_systems, _system_vars_map, libMesh::EnsightIO::Scalars::description, libMesh::EquationSystems::get_system(), libMesh::EquationSystems::has_system(), libMesh::libmesh_assert(), and libMesh::EnsightIO::Scalars::scalar_name.

add_vector() [1/2]

void libMesh::EnsightIO::add_vector	(	const std::string &	system,
		std::string_view	vec_description,
		std::string	u,
		std::string	v
	)

Tell the EnsightIO interface that the variables (u,v) constitute a vector.

Note

u and v must have the same FEType, and be defined in the same system.

Definition at line 82 of file ensight_io.C.

{
  libmesh_assert (_equation_systems.has_system(system_name));
  libmesh_assert (_equation_systems.get_system(system_name).has_variable(u));
  libmesh_assert (_equation_systems.get_system(system_name).has_variable(v));
 
  Vectors vec;
  vec.description = vec_description;
  vec.components.push_back(std::move(u));
  vec.components.push_back(std::move(v));
 
  _system_vars_map[system_name].EnsightVectors.push_back(std::move(vec));
}

References _equation_systems, _system_vars_map, libMesh::EnsightIO::Vectors::components, libMesh::EnsightIO::Vectors::description, libMesh::EquationSystems::get_system(), libMesh::EquationSystems::has_system(), and libMesh::libmesh_assert().

add_vector() [2/2]

void libMesh::EnsightIO::add_vector	(	const std::string &	system,
		std::string_view	vec_description,
		std::string	u,
		std::string	v,
		std::string	w
	)

Tell the EnsightIO interface that the variables (u, v, w) constitute a vector.

Note

Requires a 3D mesh, u, v, and w must have the same FEType, and must be defined in the same system.

Definition at line 101 of file ensight_io.C.

{
  libmesh_assert(_equation_systems.has_system(system_name));
  libmesh_assert(_equation_systems.get_system(system_name).has_variable(u));
  libmesh_assert(_equation_systems.get_system(system_name).has_variable(v));
  libmesh_assert(_equation_systems.get_system(system_name).has_variable(w));
 
  Vectors vec;
  vec.description = vec_name;
  vec.components.push_back(std::move(u));
  vec.components.push_back(std::move(v));
  vec.components.push_back(std::move(w));
  _system_vars_map[system_name].EnsightVectors.push_back(std::move(vec));
}

References _equation_systems, _system_vars_map, libMesh::EnsightIO::Vectors::components, libMesh::EnsightIO::Vectors::description, libMesh::EquationSystems::get_system(), libMesh::EquationSystems::has_system(), and libMesh::libmesh_assert().

ascii_precision()

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

inlineinherited

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

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

Definition at line 160 of file mesh_output.h.

{
  return _ascii_precision;
}

build_element_map()

std::map< ElemType, std::string > libMesh::EnsightIO::build_element_map ( )

staticprivate

Definition at line 45 of file ensight_io.C.

{
  std::map<ElemType, std::string> ret;
  ret[EDGE2] = "bar2";
  ret[EDGE3] = "bar3";
  ret[QUAD4] = "quad4";
  ret[QUAD8] = "quad8";
  // ret[QUAD9] = "quad9"; // not supported
  ret[TRI3] = "tria3";
  ret[TRI6] = "tria6";
  ret[TET4] = "tetra4";
  ret[TET10] = "tetra10";
  ret[HEX8] = "hexa8";
  ret[HEX20] = "hexa20";
  // ret[HEX27] = "HEX27"; // not supported
  ret[PYRAMID5] = "pyramid5";
  return ret;
}

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

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

mesh()

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

write() [1/2]

void libMesh::EnsightIO::write ( const std::string &  name )

overridevirtual

Calls this->write(0);.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 140 of file ensight_io.C.

{
  // We may need to gather a DistributedMesh to output it, making that
  // const qualifier in our constructor a dirty lie
  MeshSerializer serialize(const_cast<MeshBase &>(this->mesh()), !_is_parallel_format);
 
  _ensight_file_name = name;
  this->write();
}

References _ensight_file_name, libMesh::MeshOutput< MeshBase >::_is_parallel_format, libMesh::MeshOutput< MeshBase >::mesh(), and write().

write() [2/2]

void libMesh::EnsightIO::write

(

Real

time = 0

)

Calls write_ascii() and write_case().

Writes case, mesh, and solution files named: name.case (contains a description of other files) name.geo000 (mesh) name_{varname}.scl000 (one file per scalar variable) name_{vecname}.vec000 (one file per vector variable)

Definition at line 152 of file ensight_io.C.

{
  this->write_ascii(time);
  this->write_case();
}

References write_ascii(), and write_case().

Referenced by write().

write_ascii()

void libMesh::EnsightIO::write_ascii ( Real  time = 0 )

private

Definition at line 160 of file ensight_io.C.

{
  _time_steps.push_back(time);
 
  this->write_geometry_ascii();
  this->write_solution_ascii();
}

References _time_steps, write_geometry_ascii(), and write_solution_ascii().

Referenced by write().

write_case()

void libMesh::EnsightIO::write_case ( )

private

Definition at line 272 of file ensight_io.C.

{
  std::ostringstream case_file;
  case_file << _ensight_file_name << ".case";
 
  // Open a stream for writing the case file.
  std::ofstream case_stream(case_file.str().c_str());
 
  case_stream << "FORMAT\n";
  case_stream << "type:  ensight gold\n\n";
  case_stream << "GEOMETRY\n";
  case_stream << "model:            1     " << _ensight_file_name << ".geo" << "***\n";
 
  // Write Variable per node section
  if (!_system_vars_map.empty())
    case_stream << "\n\nVARIABLE\n";
 
  for (const auto & pr : _system_vars_map)
    {
      for (const auto & scalar : pr.second.EnsightScalars)
        case_stream << "scalar per node:   1  "
                    << scalar.description << " "
                    << _ensight_file_name << "_" << scalar.scalar_name << ".scl***\n";
 
      for (const auto & vec : pr.second.EnsightVectors)
        case_stream << "vector per node:      1    "
                    << vec.description << " "
                    << _ensight_file_name << "_" << vec.description << ".vec***\n";
 
      // Write time step section
      if (_time_steps.size() != 0)
        {
          case_stream << "\n\nTIME\n";
          case_stream << "time set:             1\n";
          case_stream << "number of steps:   " << std::setw(10) << _time_steps.size() << "\n";
          case_stream << "filename start number:   " << std::setw(10) << 0 << "\n";
          case_stream << "filename increment:  " << std::setw(10) << 1 << "\n";
          case_stream << "time values:\n";
          for (const auto & time : _time_steps)
            case_stream << std::setw(12) << std::setprecision(5) << std::scientific << time << "\n";
        }
    }
}

References _ensight_file_name, _system_vars_map, and _time_steps.

Referenced by 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_geometry_ascii()

void libMesh::EnsightIO::write_geometry_ascii ( )

private

Definition at line 170 of file ensight_io.C.

{
  std::ostringstream file;
  file << _ensight_file_name
       << ".geo"
       << std::setw(3)
       << std::setprecision(0)
       << std::setfill('0')
       << std::right
       << _time_steps.size()-1;
 
  // Open a stream to write the mesh
  std::ofstream mesh_stream(file.str().c_str());
 
  mesh_stream << "EnSight Gold Geometry File Format\n";
  mesh_stream << "Generated by \n";
  mesh_stream << "node id off\n";
  mesh_stream << "element id given\n";
  mesh_stream << "part\n";
  mesh_stream << std::setw(10) << 1 << "\n";
  mesh_stream << "uns-elements\n";
  mesh_stream << "coordinates\n";
 
  // mapping between nodal index and your coordinates
  std::map<int, Point> mesh_nodes_map;
 
  // Map for grouping elements of the same type
  std::map<ElemType, std::vector<const Elem *>> ensight_parts_map;
 
  const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
 
  // Construct the various required maps
  for (const auto & elem : the_mesh.active_local_element_ptr_range())
    {
      ensight_parts_map[elem->type()].push_back(elem);
 
      for (const Node & node : elem->node_ref_range())
        mesh_nodes_map[node.id()] = node;
    }
 
  // Write number of local points
  mesh_stream << std::setw(10) << mesh_nodes_map.size() << "\n";
 
  // write x, y, and z node positions, build mapping between
  // ensight and libmesh node numbers.
  std::map <int, int> ensight_node_index;
  for (unsigned direction=0; direction<3; ++direction)
    {
      int i = 1;
      for (const auto & [idx, pt] : mesh_nodes_map)
        {
          mesh_stream << std::setw(12)
                      << std::setprecision(5)
                      << std::scientific
                      << pt(direction)
                      << "\n";
          ensight_node_index[idx] = i++;
        }
    }
 
  // Write parts
  for (const auto & [elem_type, elem_ref] : ensight_parts_map)
    {
      // Look up this ElemType in the map, error if not present.
      std::string name = libmesh_map_find(_element_map, elem_type);
 
      // Write element type
      mesh_stream << "\n" << name << "\n";
 
      // Write number of element
      mesh_stream << std::setw(10) << elem_ref.size() << "\n";
 
      // Write element id
      for (const auto & elem : elem_ref)
        mesh_stream << std::setw(10) << elem->id() << "\n";
 
      // Write connectivity
      for (auto i : index_range(elem_ref))
        {
          for (const auto & node : elem_ref[i]->node_ref_range())
            {
              // tests!
              if (elem_type == QUAD9 && i==4)
                continue;
 
              // tests!
              if (elem_type == HEX27 &&
                  (i==4    || i ==10 || i == 12 ||
                   i == 13 || i ==14 || i == 16 || i == 22))
                continue;
 
              mesh_stream << std::setw(10) << ensight_node_index[node.id()];
            }
          mesh_stream << "\n";
        }
    }
}

References _element_map, _ensight_file_name, _time_steps, libMesh::HEX27, libMesh::index_range(), libMesh::MeshOutput< MT >::mesh(), and libMesh::QUAD9.

Referenced by write_ascii().

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

write_scalar_ascii()

void libMesh::EnsightIO::write_scalar_ascii ( std::string_view  sys, std::string_view  var  )

private

Definition at line 334 of file ensight_io.C.

{
  // Construct scalar variable filename
  std::ostringstream scl_file;
  scl_file << _ensight_file_name
           << "_"
           << var_name
           << ".scl"
           << std::setw(3)
           << std::setprecision(0)
           << std::setfill('0')
           << std::right
           << _time_steps.size()-1;
 
  // Open a stream and start writing scalar variable info.
  std::ofstream scl_stream(scl_file.str().c_str());
  scl_stream << "Per node scalar value\n";
  scl_stream << "part\n";
  scl_stream << std::setw(10) << 1 << "\n";
  scl_stream << "coordinates\n";
 
  const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
  const unsigned int dim = the_mesh.mesh_dimension();
  const System & system = _equation_systems.get_system(sys);
  const DofMap & dof_map = system.get_dof_map();
  int var = system.variable_number(var_name);
 
  std::vector<dof_id_type> dof_indices_scl;
 
  // Map from node id -> solution value.  We end up just writing this
  // map out in order, not sure what would happen if there were holes
  // in the numbering...
  std::map<int, Real> local_soln;
 
  std::vector<Number> elem_soln;
  std::vector<Number> nodal_soln;
 
  // Loop over active local elements, construct the nodal solution, and write it to file.
  for (const auto & elem : the_mesh.active_local_element_ptr_range())
    {
      const FEType & fe_type = system.variable_type(var);
 
      dof_map.dof_indices (elem, dof_indices_scl, var);
 
      elem_soln.resize(dof_indices_scl.size());
 
      for (auto i : index_range(dof_indices_scl))
        elem_soln[i] = system.current_solution(dof_indices_scl[i]);
 
      FEInterface::nodal_soln (dim, fe_type, elem, elem_soln, nodal_soln);
 
      libmesh_assert_equal_to (nodal_soln.size(), elem->n_nodes());
 
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
      libmesh_error_msg("Complex-valued Ensight output not yet supported");
#endif
 
      for (auto n : elem->node_index_range())
        local_soln[elem->node_id(n)] = libmesh_real(nodal_soln[n]);
    }
 
  for (const auto & pr : local_soln)
    scl_stream << std::setw(12)
               << std::setprecision(5)
               << std::scientific
               << pr.second
               << "\n";
}

References _ensight_file_name, _equation_systems, _time_steps, libMesh::System::current_solution(), dim, libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_system(), libMesh::index_range(), libMesh::libmesh_real(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::FEInterface::nodal_soln(), libMesh::System::variable_number(), and libMesh::System::variable_type().

Referenced by write_solution_ascii().

write_solution_ascii()

void libMesh::EnsightIO::write_solution_ascii ( )

private

Definition at line 318 of file ensight_io.C.

{
  for (const auto & [sys_name, sys_vars] : _system_vars_map)
    {
      for (const auto & scalar : sys_vars.EnsightScalars)
        this->write_scalar_ascii(sys_name,
                                 scalar.scalar_name);
 
      for (const auto & vec : sys_vars.EnsightVectors)
        this->write_vector_ascii(sys_name,
                                 vec.components,
                                 vec.description);
    }
}

References _system_vars_map, write_scalar_ascii(), and write_vector_ascii().

Referenced by write_ascii().

write_vector_ascii()

void libMesh::EnsightIO::write_vector_ascii ( std::string_view  sys, const std::vector< std::string > &  vec, std::string_view  var_name  )

private

Definition at line 405 of file ensight_io.C.

{
  // Construct vector variable filename
  std::ostringstream vec_file;
  vec_file << _ensight_file_name
           << "_"
           << var_name
           << ".vec"
           << std::setw(3)
           << std::setprecision(0)
           << std::setfill('0')
           << std::right
           << _time_steps.size()-1;
 
  // Open a stream and start writing vector variable info.
  std::ofstream vec_stream(vec_file.str().c_str());
  vec_stream << "Per vector per value\n";
  vec_stream << "part\n";
  vec_stream << std::setw(10) << 1 << "\n";
  vec_stream << "coordinates\n";
 
  // Get a constant reference to the mesh object.
  const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
 
  // The dimension that we are running
  const unsigned int dim = the_mesh.mesh_dimension();
 
  const System & system = _equation_systems.get_system(sys);
 
  const DofMap & dof_map = system.get_dof_map();
 
  const unsigned int u_var = system.variable_number(vec[0]);
  const unsigned int v_var = system.variable_number(vec[1]);
  const unsigned int w_var = (dim==3) ? system.variable_number(vec[2]) : 0;
 
  std::vector<dof_id_type> dof_indices_u;
  std::vector<dof_id_type> dof_indices_v;
  std::vector<dof_id_type> dof_indices_w;
 
  // Map from node id -> solution value.  We end up just writing this
  // map out in order, not sure what would happen if there were holes
  // in the numbering...
  std::map<int,std::vector<Real>> local_soln;
 
  // Now we will loop over all the elements in the mesh.
  for (const auto & elem : the_mesh.active_local_element_ptr_range())
    {
      const FEType & fe_type = system.variable_type(u_var);
 
      dof_map.dof_indices (elem, dof_indices_u, u_var);
      dof_map.dof_indices (elem, dof_indices_v, v_var);
      if (dim==3)
        dof_map.dof_indices (elem, dof_indices_w, w_var);
 
      std::vector<Number> elem_soln_u;
      std::vector<Number> elem_soln_v;
      std::vector<Number> elem_soln_w;
 
      std::vector<Number> nodal_soln_u;
      std::vector<Number> nodal_soln_v;
      std::vector<Number> nodal_soln_w;
 
      elem_soln_u.resize(dof_indices_u.size());
      elem_soln_v.resize(dof_indices_v.size());
      if (dim == 3)
        elem_soln_w.resize(dof_indices_w.size());
 
      for (auto i : index_range(dof_indices_u))
        {
          elem_soln_u[i] = system.current_solution(dof_indices_u[i]);
          elem_soln_v[i] = system.current_solution(dof_indices_v[i]);
          if (dim==3)
            elem_soln_w[i] = system.current_solution(dof_indices_w[i]);
        }
 
      FEInterface::nodal_soln (dim, fe_type, elem, elem_soln_u, nodal_soln_u);
      FEInterface::nodal_soln (dim, fe_type, elem, elem_soln_v, nodal_soln_v);
      if (dim == 3)
        FEInterface::nodal_soln (dim, fe_type, elem, elem_soln_w, nodal_soln_w);
 
      libmesh_assert_equal_to (nodal_soln_u.size(), elem->n_nodes());
      libmesh_assert_equal_to (nodal_soln_v.size(), elem->n_nodes());
 
#ifdef LIBMESH_ENABLE_COMPLEX
      libmesh_error_msg("Complex-valued Ensight output not yet supported");
#endif
 
      for (const auto & n : elem->node_index_range())
        {
          std::vector<Real> node_vec(3);
          node_vec[0] = libmesh_real(nodal_soln_u[n]);
          node_vec[1] = libmesh_real(nodal_soln_v[n]);
          node_vec[2] = 0.0;
          if (dim==3)
            node_vec[2] = libmesh_real(nodal_soln_w[n]);
          local_soln[elem->node_id(n)] = node_vec;
        }
    }
 
  for (unsigned dir=0; dir<3; ++dir)
    {
      for (const auto & pr : local_soln)
        vec_stream << std::setw(12)
                   << std::scientific
                   << std::setprecision(5)
                   << pr.second[dir]
                   << "\n";
    }
}

References _ensight_file_name, _equation_systems, _time_steps, libMesh::System::current_solution(), dim, libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::EquationSystems::get_system(), libMesh::index_range(), libMesh::libmesh_real(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::FEInterface::nodal_soln(), libMesh::System::variable_number(), and libMesh::System::variable_type().

Referenced by write_solution_ascii().

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.

_element_map

std::map< ElemType, std::string > libMesh::EnsightIO::_element_map = EnsightIO::build_element_map()

staticprivate

Definition at line 154 of file ensight_io.h.

Referenced by write_geometry_ascii().

_ensight_file_name

std::string libMesh::EnsightIO::_ensight_file_name

private

Definition at line 144 of file ensight_io.h.

Referenced by EnsightIO(), write(), write_case(), write_geometry_ascii(), write_scalar_ascii(), and write_vector_ascii().

_equation_systems

const EquationSystems& libMesh::EnsightIO::_equation_systems

private

Definition at line 151 of file ensight_io.h.

Referenced by add_scalar(), add_vector(), add_vector(), EnsightIO(), write_scalar_ascii(), and write_vector_ascii().

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

_obj

const MeshBase * const libMesh::MeshOutput< MeshBase >::_obj

privateinherited

A pointer to a constant object.

This allows us to write the object to file.

Definition at line 202 of file mesh_output.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.

_system_vars_map

std::map<std::string, SystemVars> libMesh::EnsightIO::_system_vars_map

private

Definition at line 148 of file ensight_io.h.

Referenced by add_scalar(), add_vector(), add_vector(), write_case(), and write_solution_ascii().

_time_steps

std::vector<Real> libMesh::EnsightIO::_time_steps

private

Definition at line 145 of file ensight_io.h.

Referenced by write_ascii(), write_case(), write_geometry_ascii(), write_scalar_ascii(), and write_vector_ascii().

---

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

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