libMesh::EnsightIO Class Reference

#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)
	~EnsightIO ()
void	add_scalar (const std::string &system, const std::string &scalar_description, const std::string &s)
void	add_vector (const std::string &system, const std::string &vec_description, const std::string &u, const std::string &v)
void	add_vector (const std::string &system, const std::string &vec_description, const std::string &u, const std::string &v, const std::string &w)
void	write (Real time=0)
virtual void	write (const std::string &name) override
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
const MeshBase &	mesh () const

Protected Attributes
const bool	_is_parallel_format
const bool	_serial_only_needed_on_proc_0

Private Member Functions
void	write_ascii (Real time=0)
void	write_scalar_ascii (const std::string &sys, const std::string &var)
void	write_vector_ascii (const std::string &sys, const std::vector< std::string > &vec, const std::string &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

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 55 of file ensight_io.h.

Constructor & Destructor Documentation

EnsightIO()

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

Constructor.

Definition at line 64 of file ensight_io.C.

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

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

~EnsightIO()

libMesh::EnsightIO::~EnsightIO ( )

inline

Empty destructor.

Definition at line 68 of file ensight_io.h.

{}

Member Function Documentation

add_scalar()

void libMesh::EnsightIO::add_scalar	(	const std::string &	system,
		const std::string &	scalar_description,
		const std::string &	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 121 of file ensight_io.C.

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

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

add_vector() [1/2]

void libMesh::EnsightIO::add_vector	(	const std::string &	system,
		const std::string &	vec_description,
		const std::string &	u,
		const 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 81 of file ensight_io.C.

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

{
  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(u);
  vec.components.push_back(v);

  _system_vars_map[system_name].EnsightVectors.push_back(vec);
}

add_vector() [2/2]

void libMesh::EnsightIO::add_vector	(	const std::string &	system,
		const std::string &	vec_description,
		const std::string &	u,
		const std::string &	v,
		const 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 100 of file ensight_io.C.

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

{
  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(u);
  vec.components.push_back(v);
  vec.components.push_back(w);
  _system_vars_map[system_name].EnsightVectors.push_back(vec);
}

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

build_element_map()

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

staticprivate

Definition at line 44 of file ensight_io.C.

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

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

mesh()

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

write() [1/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 151 of file ensight_io.C.

References write_ascii(), and write_case().

Referenced by write().

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

write() [2/2]

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

overridevirtual

Calls this->write(0);

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 139 of file ensight_io.C.

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

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

write_ascii()

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

private

Definition at line 159 of file ensight_io.C.

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

Referenced by write().

{
  _time_steps.push_back(time);

  this->write_geometry_ascii();
  this->write_solution_ascii();
}

write_case()

void libMesh::EnsightIO::write_case ( )

private

Definition at line 275 of file ensight_io.C.

References _ensight_file_name, _system_vars_map, and _time_steps.

Referenced by write().

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

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

void libMesh::EnsightIO::write_geometry_ascii ( )

private

Definition at line 169 of file ensight_io.C.

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

Referenced by write_ascii().

{
  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 (unsigned int i = 0; i < elem->n_nodes(); i++)
        mesh_nodes_map[elem->node_id(i)] = elem->point(i);
    }

  // 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 & pr : mesh_nodes_map)
        {
          mesh_stream << std::setw(12)
                      << std::setprecision(5)
                      << std::scientific
                      << pr.second(direction)
                      << "\n";
          ensight_node_index[pr.first] = i++;
        }
    }

  // Write parts
  for (const auto & pr : ensight_parts_map)
    {
      // Look up this ElemType in the map, error if not present.
      auto name_it = _element_map.find(pr.first);
      if (name_it == _element_map.end())
        libmesh_error_msg("Error: Unsupported ElemType " << pr.first << " for EnsightIO.");

      // Write element type
      mesh_stream << "\n" << name_it->second << "\n";

      const std::vector<const Elem *> & elem_ref = pr.second;

      // 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 (pr.first == QUAD9 && i==4)
                continue;

              // tests!
              if (pr.first == 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";
        }
    }
}

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.

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

  { libmesh_not_implemented(); }

write_scalar_ascii()

void libMesh::EnsightIO::write_scalar_ascii ( const std::string &  sys, const std::string &  var  )

private

Definition at line 337 of file ensight_io.C.

References _ensight_file_name, _equation_systems, _time_steps, libMesh::MeshBase::active_local_element_ptr_range(), libMesh::System::current_solution(), 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().

{
  // 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 (unsigned int n=0; n<elem->n_nodes(); n++)
        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";
}

write_solution_ascii()

void libMesh::EnsightIO::write_solution_ascii ( )

private

Definition at line 321 of file ensight_io.C.

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

Referenced by write_ascii().

{
  for (const auto & pr : _system_vars_map)
    {
      for (const auto & scalar : pr.second.EnsightScalars)
        this->write_scalar_ascii(pr.first,
                                 scalar.scalar_name);

      for (const auto & vec : pr.second.EnsightVectors)
        this->write_vector_ascii(pr.first,
                                 vec.components,
                                 vec.description);
    }
}

write_vector_ascii()

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

private

Definition at line 408 of file ensight_io.C.

References _ensight_file_name, _equation_systems, _time_steps, libMesh::MeshBase::active_local_element_ptr_range(), libMesh::System::current_solution(), 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().

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

Member Data Documentation

_element_map

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

staticprivate

Definition at line 162 of file ensight_io.h.

Referenced by write_geometry_ascii().

_ensight_file_name

std::string libMesh::EnsightIO::_ensight_file_name

private

Definition at line 152 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 159 of file ensight_io.h.

Referenced by add_scalar(), 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 159 of file mesh_output.h.

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

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

_system_vars_map

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

private

Definition at line 156 of file ensight_io.h.

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

_time_steps

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

private

Definition at line 153 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:

• ensight_io.h
• ensight_io.C