libMesh::GnuPlotIO Class Reference

#include <gnuplot_io.h>

Inheritance diagram for libMesh::GnuPlotIO:

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

Define enumerations to set plotting properties on construction

Enumerator
GRID_ON 
PNG_OUTPUT 

Definition at line 52 of file gnuplot_io.h.

52  { GRID_ON = 1,
53  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.

35  :
36  MeshOutput<MeshBase> (mesh_in),
37  _title(title)
38 {
39  _grid = (mesh_properties & GRID_ON);
40  _png_output = (mesh_properties & PNG_OUTPUT);
41 }

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

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.

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

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

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

44 {
45  this->write_solution(fname);
46 }
virtual void libMesh::MeshOutput< MeshBase >::write_equation_systems ( const std::string &  ,
const EquationSystems ,
const std::set< std::string > *  system_names = NULL 
)
virtualinherited

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(), 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(), libMesh::STOP_LOG(), and write_solution().

51 {
52  START_LOG("write_nodal_data()", "GnuPlotIO");
53 
54  this->write_solution(fname, &soln, &names);
55 
56  STOP_LOG("write_nodal_data()", "GnuPlotIO");
57 }
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::libmesh_assert(), libMesh::MeshOutput< MT >::mesh(), libMesh::MeshOutput< MeshBase >::mesh(), libMesh::MeshBase::mesh_dimension(), libMesh::MeshBase::n_active_elem(), libMesh::Elem::n_nodes(), libMesh::n_vars, libMesh::Elem::neighbor(), libMesh::Elem::node(), libMesh::MeshBase::point(), libMesh::processor_id(), and libMesh::Real.

Referenced by write(), and write_nodal_data().

65 {
66  // Even when writing on a serialized ParallelMesh, we expect
67  // non-proc-0 help with calls like n_active_elem
68  // libmesh_assert_equal_to (this->mesh().processor_id(), 0);
69 
70  const MeshBase& the_mesh = MeshOutput<MeshBase>::mesh();
71 
72  dof_id_type n_active_elem = the_mesh.n_active_elem();
73 
74  if (this->mesh().processor_id() == 0)
75  {
76  std::stringstream data_stream_name;
77  data_stream_name << fname << "_data";
78  const std::string data_file_name = data_stream_name.str();
79 
80  // This class is designed only for use with 1D meshes
81  libmesh_assert_equal_to (the_mesh.mesh_dimension(), 1);
82 
83  // Make sure we have a solution to plot
84  libmesh_assert ((names != NULL) && (soln != NULL));
85 
86  // Create an output stream for script file
87  std::ofstream out_stream(fname.c_str());
88 
89  // Make sure it opened correctly
90  if (!out_stream.good())
91  libmesh_file_error(fname.c_str());
92 
93  // The number of variables in the equation system
94  const unsigned int n_vars =
95  libmesh_cast_int<unsigned int>(names->size());
96 
97  // Write header to stream
98  out_stream << "# This file was generated by gnuplot_io.C\n"
99  << "# Stores 1D solution data in GNUplot format\n"
100  << "# Execute this by loading gnuplot and typing "
101  << "\"call '" << fname << "'\"\n"
102  << "reset\n"
103  << "set title \"" << _title << "\"\n"
104  << "set xlabel \"x\"\n"
105  << "set xtics nomirror\n";
106 
107  // Loop over the elements to find the minimum and maximum x values,
108  // and also to find the element boundaries to write out as xtics
109  // if requested.
110  Real x_min=0., x_max=0.;
111 
112  // construct string for xtic positions at element edges
113  std::stringstream xtics_stream;
114 
115  MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
116  const MeshBase::const_element_iterator end_it =
117  the_mesh.active_elements_end();
118 
119  unsigned int count = 0;
120 
121  for( ; it != end_it; ++it)
122  {
123  const Elem* el = *it;
124 
125  // if el is the left edge of the mesh, print its left node position
126  if(el->neighbor(0) == NULL)
127  {
128  x_min = (*(el->get_node(0)))(0);
129  xtics_stream << "\"\" " << x_min << ", \\\n";
130  }
131  if(el->neighbor(1) == NULL)
132  {
133  x_max = (*(el->get_node(1)))(0);
134  }
135  xtics_stream << "\"\" " << (*(el->get_node(1)))(0);
136 
137  if(count+1 != n_active_elem)
138  {
139  xtics_stream << ", \\\n";
140  }
141  count++;
142  }
143 
144  out_stream << "set xrange [" << x_min << ":" << x_max << "]\n";
145 
146  if(_grid)
147  out_stream << "set x2tics (" << xtics_stream.str() << ")\nset grid noxtics noytics x2tics\n";
148 
149  if(_png_output)
150  {
151  out_stream << "set terminal png\n";
152  out_stream << "set output \"" << fname << ".png\"\n";
153  }
154 
155  out_stream << "plot "
156  << axes_limits
157  << " \"" << data_file_name << "\" using 1:2 title \"" << (*names)[0]
158  << "\" with lines";
159  if(n_vars > 1)
160  {
161  for(unsigned int i=1; i<n_vars; i++)
162  {
163  out_stream << ", \\\n\"" << data_file_name << "\" using 1:" << i+2
164  << " title \"" << (*names)[i] << "\" with lines";
165  }
166  }
167 
168  out_stream.close();
169 
170 
171  // Create an output stream for data file
172  std::ofstream data(data_file_name.c_str());
173 
174  if (!data.good())
175  {
176  libMesh::err << "ERROR: opening output data file " << std::endl;
177  libmesh_error();
178  }
179 
180  // get ordered nodal data using a map
181  typedef std::pair<Real, std::vector<Number> > key_value_pair;
182  typedef std::map<Real, std::vector<Number> > map_type;
183  typedef map_type::iterator map_iterator;
184 
185  map_type node_map;
186 
187 
188  it = the_mesh.active_elements_begin();
189 
190  for ( ; it != end_it; ++it)
191  {
192  const Elem* elem = *it;
193 
194  for(unsigned int i=0; i<elem->n_nodes(); i++)
195  {
196  std::vector<Number> values;
197 
198  // Get the global id of the node
199  dof_id_type global_id = elem->node(i);
200 
201  for(unsigned int c=0; c<n_vars; c++)
202  {
203  values.push_back( (*soln)[global_id*n_vars + c] );
204  }
205 
206  node_map[ the_mesh.point(global_id)(0) ] = values;
207  }
208  }
209 
210 
211  map_iterator map_it = node_map.begin();
212  const map_iterator end_map_it = node_map.end();
213 
214  for( ; map_it != end_map_it; ++map_it)
215  {
216  key_value_pair kvp = *map_it;
217  std::vector<Number> values = kvp.second;
218 
219  data << kvp.first << "\t";
220 
221  for(unsigned int i=0; i<values.size(); i++)
222  {
223  data << values[i] << "\t";
224  }
225 
226  data << "\n";
227  }
228 
229  data.close();
230  }
231 }

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
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 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:

Site Created By: libMesh Developers
Last modified: February 07 2014 16:58:01 UTC

Hosted By:
SourceForge.net Logo