#include <gnuplot_io.h>
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.
Definition at line 45 of file gnuplot_io.h.
Member Enumeration Documentation
Define enumerations to set plotting properties on construction
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::TecplotIO::elem_dimension(), libMesh::FroIO::write(), libMesh::DivaIO::write(), libMesh::TecplotIO::write(), libMesh::PostscriptIO::write(), libMesh::MEDITIO::write(), libMesh::EnsightIO::write(), libMesh::MEDITIO::write_ascii(), libMesh::TecplotIO::write_ascii(), libMesh::TecplotIO::write_binary(), libMesh::EnsightIO::write_geometry_ascii(), libMesh::TecplotIO::write_nodal_data(), libMesh::MEDITIO::write_nodal_data(), 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.
Reimplemented in libMesh::NameBasedIO.
Referenced by libMesh::Nemesis_IO::write_timestep(), and libMesh::ExodusII_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 libMesh::START_LOG(), and 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::Elem::get_node(), libMesh::libmesh_assert(), 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 (this->mesh().processor_id(), 0);
const MeshBase& the_mesh = MeshOutput<MeshBase>::mesh();
dof_id_type n_active_elem = the_mesh.n_active_elem();
if (this->mesh().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 =
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_error_msg("ERROR: opening output data file " << data_file_name);
// 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::FroIO::write(), libMesh::DivaIO::write(), libMesh::PostscriptIO::write(), and libMesh::EnsightIO::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:
generated by
