libMesh::GnuPlotIO Class Reference

#include <gnuplot_io.h>

Inheritance diagram for libMesh::GnuPlotIO:

[legend]

List of all members.

Public Types
enum	PlottingProperties { GRID_ON = 1, PNG_OUTPUT = 2 }
Public Member Functions
	GnuPlotIO (const MeshBase &, const std::string &=std::string("FE 1D Solution"), int properties=0)
virtual void	write (const std::string &)
virtual void	write_nodal_data (const std::string &, const std::vector< Number > &, const std::vector< std::string > &)
void	set_title (const std::string &title)
void	use_grid (bool grid)
void	set_png_output (bool png_output)
virtual void	write_equation_systems (const std::string &, const EquationSystems &, const std::set< std::string > *system_names=NULL)
unsigned int &	ascii_precision ()
Public Attributes
std::string	axes_limits
Protected Member Functions
const MeshBase &	mesh () const
Protected Attributes
const bool	_is_parallel_format
Private Member Functions
void	write_solution (const std::string &, const std::vector< Number > *=NULL, const std::vector< std::string > *=NULL)
Private Attributes
std::string	_title
bool	_grid
bool	_png_output

---

Detailed Description

This class implements writing meshes using GNUplot, designed for use only with 1D meshes.

Author:

David Knezevic, 2005

Definition at line 45 of file gnuplot_io.h.

---

Member Enumeration Documentation

enum libMesh::GnuPlotIO::PlottingProperties

Define enumerations to set plotting properties on construction

Enumerator:

GRID_ON
PNG_OUTPUT

Definition at line 52 of file gnuplot_io.h.

                          { GRID_ON    = 1,
                            PNG_OUTPUT = 2};

---

Constructor & Destructor Documentation

libMesh::GnuPlotIO::GnuPlotIO	(	const MeshBase &	mesh_in,
		const std::string &	title = std::string("FE 1D Solution"),
		int	properties = 0
	)			[explicit]

Constructor. Takes a reference to a constant mesh object. To set the properties, we input a bitwise OR of the GnuPlotIO::PlottingProperties enumerations, e.g. GnuPlotIO::GRID_ON | GnuPlotIO::PNG_OUTPUT

Definition at line 32 of file gnuplot_io.C.

References _grid, _png_output, GRID_ON, and PNG_OUTPUT.

  :
  MeshOutput<MeshBase> (mesh_in),
  _title(title)
{
  _grid       = (mesh_properties & GRID_ON);
  _png_output = (mesh_properties & PNG_OUTPUT);
}

---

Member Function Documentation

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

(

)

[inherited]

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.

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

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

(

)

const [protected, inherited]

Returns the object as a read-only reference.

Referenced by libMesh::PostscriptIO::write(), libMesh::FroIO::write(), libMesh::EnsightIO::write(), libMesh::DivaIO::write(), libMesh::TecplotIO::write_ascii(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_binary(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::EnsightIO::write_scalar_ascii(), write_solution(), libMesh::DivaIO::write_stream(), and libMesh::EnsightIO::write_vector_ascii().

void libMesh::GnuPlotIO::set_png_output

(

bool

png_output

)

[inline]

Write output to a .png file using gnuplot

Definition at line 93 of file gnuplot_io.h.

References _png_output.

{ _png_output = png_output; }

void libMesh::GnuPlotIO::set_title

(

const std::string &

title

)

[inline]

Set title of plot

Definition at line 82 of file gnuplot_io.h.

References _title.

{ _title = title; }

void libMesh::GnuPlotIO::use_grid

(

bool

grid

)

[inline]

Turn grid on or off.

Definition at line 87 of file gnuplot_io.h.

References _grid.

{ _grid = grid; }

void libMesh::GnuPlotIO::write

(

const std::string &

fname

)

[virtual]

Write the mesh to the specified file.

Implements libMesh::MeshOutput< MeshBase >.

Definition at line 43 of file gnuplot_io.C.

References write_solution().

{
  this->write_solution(fname);
}

virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems	(	const std::string &	,
		const EquationSystems &	,
		const std::set< std::string > *	system_names = NULL
	)			[virtual, inherited]

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

Referenced by libMesh::Nemesis_IO::write_timestep().

void libMesh::GnuPlotIO::write_nodal_data	(	const std::string &	fname,
		const std::vector< Number > &	soln,
		const std::vector< std::string > &	names
	)			[virtual]

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

Reimplemented from libMesh::MeshOutput< MeshBase >.

Definition at line 48 of file gnuplot_io.C.

References write_solution().

{
  START_LOG("write_nodal_data()", "GnuPlotIO");

  this->write_solution(fname, &soln, &names);

  STOP_LOG("write_nodal_data()", "GnuPlotIO");
}

void libMesh::GnuPlotIO::write_solution	(	const std::string &	fname,
		const std::vector< Number > *	soln = NULL,
		const std::vector< std::string > *	names = NULL
	)			[private]

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

Definition at line 62 of file gnuplot_io.C.

References _grid, _png_output, _title, libMesh::MeshBase::active_elements_begin(), libMesh::MeshBase::active_elements_end(), axes_limits, data, libMesh::err, libMesh::Elem::get_node(), libMesh::MeshOutput< MeshBase >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::Elem::n_nodes(), n_vars, libMesh::Elem::neighbor(), libMesh::Elem::node(), libMesh::MeshBase::point(), libMesh::processor_id(), and libMesh::Real.

Referenced by write(), and write_nodal_data().

{
  // Even when writing on a serialized ParallelMesh, we expect
  // non-proc-0 help with calls like n_active_elem
  // libmesh_assert_equal_to (libMesh::processor_id(), 0);

  const MeshBase& the_mesh = MeshOutput<MeshBase>::mesh();

  dof_id_type n_active_elem = the_mesh.n_active_elem();

  if (libMesh::processor_id() == 0)
  {
  std::stringstream data_stream_name;
  data_stream_name << fname << "_data";
  const std::string data_file_name = data_stream_name.str();

  // This class is designed only for use with 1D meshes
  libmesh_assert_equal_to (the_mesh.mesh_dimension(), 1);

  // Make sure we have a solution to plot
  libmesh_assert ((names != NULL) && (soln != NULL));

  // Create an output stream for script file
  std::ofstream out_stream(fname.c_str());

  // Make sure it opened correctly
  if (!out_stream.good())
    libmesh_file_error(fname.c_str());

  // The number of variables in the equation system
  const unsigned int n_vars =
    libmesh_cast_int<unsigned int>(names->size());

  // Write header to stream
  out_stream << "# This file was generated by gnuplot_io.C\n"
      << "# Stores 1D solution data in GNUplot format\n"
      << "# Execute this by loading gnuplot and typing "
      << "\"call '" << fname << "'\"\n"
      << "reset\n"
      << "set title \"" << _title << "\"\n"
      << "set xlabel \"x\"\n"
      << "set xtics nomirror\n";

  // Loop over the elements to find the minimum and maximum x values,
  // and also to find the element boundaries to write out as xtics
  // if requested.
  Real x_min=0., x_max=0.;

  // construct string for xtic positions at element edges
  std::stringstream xtics_stream;

  MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
  const MeshBase::const_element_iterator end_it =
    the_mesh.active_elements_end();

  unsigned int count = 0;

  for( ; it != end_it; ++it)
  {
    const Elem* el = *it;

    // if el is the left edge of the mesh, print its left node position
    if(el->neighbor(0) == NULL)
    {
      x_min = (*(el->get_node(0)))(0);
      xtics_stream << "\"\" " << x_min << ", \\\n";
    }
    if(el->neighbor(1) == NULL)
    {
      x_max = (*(el->get_node(1)))(0);
    }
    xtics_stream << "\"\" " << (*(el->get_node(1)))(0);

    if(count+1 != n_active_elem)
    {
        xtics_stream << ", \\\n";
    }
    count++;
  }

  out_stream << "set xrange [" << x_min << ":" << x_max << "]\n";

  if(_grid)
    out_stream << "set x2tics (" << xtics_stream.str() << ")\nset grid noxtics noytics x2tics\n";

  if(_png_output)
  {
    out_stream << "set terminal png\n";
    out_stream << "set output \"" << fname << ".png\"\n";
  }

  out_stream << "plot "
      << axes_limits
      << " \"" << data_file_name << "\" using 1:2 title \"" << (*names)[0]
      << "\" with lines";
  if(n_vars > 1)
  {
    for(unsigned int i=1; i<n_vars; i++)
    {
      out_stream << ", \\\n\"" << data_file_name << "\" using 1:" << i+2
          << " title \"" << (*names)[i] << "\" with lines";
    }
  }

  out_stream.close();


  // Create an output stream for data file
  std::ofstream data(data_file_name.c_str());

  if (!data.good())
    {
      libMesh::err << "ERROR: opening output data file " << std::endl;
      libmesh_error();
    }

  // get ordered nodal data using a map
  typedef std::pair<Real, std::vector<Number> > key_value_pair;
  typedef std::map<Real, std::vector<Number> > map_type;
  typedef map_type::iterator map_iterator;

  map_type node_map;


  it  = the_mesh.active_elements_begin();

  for ( ; it != end_it; ++it)
  {
    const Elem* elem = *it;

    for(unsigned int i=0; i<elem->n_nodes(); i++)
    {
      std::vector<Number> values;

      // Get the global id of the node
      dof_id_type global_id = elem->node(i);

      for(unsigned int c=0; c<n_vars; c++)
      {
        values.push_back( (*soln)[global_id*n_vars + c] );
      }

      node_map[ the_mesh.point(global_id)(0) ] = values;
    }
  }


  map_iterator map_it = node_map.begin();
  const map_iterator end_map_it = node_map.end();

  for( ; map_it != end_map_it; ++map_it)
  {
    key_value_pair kvp = *map_it;
    std::vector<Number> values = kvp.second;

    data << kvp.first << "\t";

    for(unsigned int i=0; i<values.size(); i++)
    {
      data << values[i] << "\t";
    }

    data << "\n";
  }

  data.close();
  }
}

---

Member Data Documentation

bool libMesh::GnuPlotIO::_grid [private]

Definition at line 117 of file gnuplot_io.h.

Referenced by GnuPlotIO(), use_grid(), and write_solution().

const bool libMesh::MeshOutput< MeshBase >::_is_parallel_format [protected, inherited]

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

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

bool libMesh::GnuPlotIO::_png_output [private]

Definition at line 118 of file gnuplot_io.h.

Referenced by GnuPlotIO(), set_png_output(), and write_solution().

std::string libMesh::GnuPlotIO::_title [private]

Definition at line 115 of file gnuplot_io.h.

Referenced by set_title(), and write_solution().

std::string libMesh::GnuPlotIO::axes_limits

GNUplot automatically adjusts the x and y-axes of 2D plots to "zoom in" on the data. You can set this string to force GNUplot to maintain a fixed set of axes. Example: axes_limits = "[0:1] [0:1]" would force x and y to be plotted on the range 0<=x<=1 and 0<=y<=1 regardless of where the data lie.

Definition at line 103 of file gnuplot_io.h.

Referenced by write_solution().

---

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

• gnuplot_io.h
• gnuplot_io.C