www.mooseframework.org
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | Private Attributes | Friends | List of all members
FormattedTable Class Reference

This class is used for building, formatting, and outputting tables of numbers. More...

#include <FormattedTable.h>

Public Member Functions

 FormattedTable ()
 Default constructor - The default constructor takes an optional parameter to turn off stateful printing. More...
 
 FormattedTable (const FormattedTable &o)
 Copy constructor - The copy constructor will duplicate the data structures but is not designed to work with FormattedTables with open streams (e.g. More...
 
 ~FormattedTable ()
 The destructor is used to close the file handle. More...
 
bool empty () const
 Returns a boolean value based on whether the FormattedTable contains data or not. More...
 
void append (bool append_existing_file)
 Sets append mode which means an existing file is not truncated on opening. More...
 
void addRow (Real time)
 Force a new row in the table with the passed in time. More...
 
void addData (const std::string &name, Real value)
 Method for adding data to the output table. More...
 
void addData (const std::string &name, Real value, Real time)
 Method for adding data to the output table. More...
 
void addData (const std::string &name, const std::vector< Real > &vector)
 Method for adding an entire vector to a table at a time. More...
 
Real getLastTime ()
 Retrieve the last time (or independent variable) value. More...
 
Real & getLastData (const std::string &name)
 Retrieve Data for last value of given name. More...
 
void clear ()
 
void outputTimeColumn (bool output_time)
 Set whether or not to output time column. More...
 
void printTable (std::ostream &out, unsigned int last_n_entries=0)
 Methods for dumping the table to the stream - either by filename or by stream handle. More...
 
void printTable (std::ostream &out, unsigned int last_n_entries, const MooseEnum &suggested_term_width)
 
void printTable (const std::string &file_name)
 
void printCSV (const std::string &file_name, int interval=1, bool align=false)
 Method for dumping the table to a csv file - opening and closing the file handle is handled. More...
 
void printEnsight (const std::string &file_name)
 
void writeExodus (ExodusII_IO *ex_out, Real time)
 
void makeGnuplot (const std::string &base_file, const std::string &format)
 
void setDelimiter (std::string delimiter)
 By default printCSV places "," between each entry, this allows this to be changed. More...
 
void setPrecision (unsigned int precision)
 By default printCSV prints output to a precision of 14, this allows this to be changed. More...
 
void sortColumns ()
 Sorts columns alphabetically. More...
 

Static Public Member Functions

static MooseEnum getWidthModes ()
 

Protected Member Functions

void printTablePiece (std::ostream &out, unsigned int last_n_entries, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end)
 
void printOmittedRow (std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const
 
void printRowDivider (std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const
 
void printNoDataRow (char intersect_char, char fill_char, std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const
 
unsigned short getTermWidth (bool use_environment) const
 Returns the width of the terminal using sys/ioctl. More...
 

Protected Attributes

std::vector< std::pair< Real, std::map< std::string, Real > > > _data
 Data structure for the console table: The first part of the pair tracks the independent variable (normally time) and is associated with the second part of the table which is the map of dependent variables and their associated values. More...
 
std::map< std::string, unsigned int > _align_widths
 Alignment widths (only used if asked to print aligned to CSV output) More...
 
std::vector< std::string > _column_names
 The set of column names updated when data is inserted through the setter methods. More...
 

Static Protected Attributes

static const unsigned short _column_width = 15
 The single cell width used for all columns in the table. More...
 
static const unsigned short _min_pps_width = 40
 The absolute minimum PPS table width. More...
 

Private Member Functions

void close ()
 Close the underlying output file stream if any. This is idempotent. More...
 
void open (const std::string &file_name)
 Open or switch the underlying file stream to point to file_name. This is idempotent. More...
 
void printRow (std::pair< Real, std::map< std::string, Real >> &row_data, bool align)
 

Private Attributes

std::string _output_file_name
 The optional output file stream. More...
 
std::ofstream _output_file
 The stream handle (corresponds to _output_file_name) More...
 
std::size_t _output_row_index
 Keeps track of the index indicating which vector elements have been output. More...
 
bool _headers_output
 Keeps track of whether the header has been output. More...
 
bool _append
 Keeps track of whether we want to open an existing file for appending or overwriting. More...
 
bool _output_time
 Whether or not to output the Time column. More...
 
std::string _csv_delimiter
 *.csv file delimiter, defaults to "," More...
 
unsigned int _csv_precision
 *.csv file precision, defaults to 14 More...
 
bool _column_names_unsorted = true
 Flag indicating that sorting is necessary (used by sortColumns method). More...
 

Friends

void dataStore (std::ostream &stream, FormattedTable &table, void *context)
 
void dataLoad (std::istream &stream, FormattedTable &v, void *context)
 

Detailed Description

This class is used for building, formatting, and outputting tables of numbers.

Definition at line 36 of file FormattedTable.h.

Constructor & Destructor Documentation

◆ FormattedTable() [1/2]

FormattedTable::FormattedTable ( )

Default constructor - The default constructor takes an optional parameter to turn off stateful printing.

This means that each time you ask the FormattedTable to print to a file, it'll, print the entire table. The default is to only print the part of the table that hasn't already been printed.

Definition at line 84 of file FormattedTable.C.

85  : _output_row_index(0),
86  _headers_output(false),
87  _append(false),
88  _output_time(true),
91 {
92 }
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
bool _output_time
Whether or not to output the Time column.
std::string _csv_delimiter
*.csv file delimiter, defaults to ","
const unsigned short DEFAULT_CSV_PRECISION
unsigned int _csv_precision
*.csv file precision, defaults to 14
bool _headers_output
Keeps track of whether the header has been output.
bool _append
Keeps track of whether we want to open an existing file for appending or overwriting.
const std::string DEFAULT_CSV_DELIMITER

◆ FormattedTable() [2/2]

FormattedTable::FormattedTable ( const FormattedTable o)

Copy constructor - The copy constructor will duplicate the data structures but is not designed to work with FormattedTables with open streams (e.g.

CSV Output mode).

Definition at line 94 of file FormattedTable.C.

99  _append(o._append),
104 {
105  if (_output_file.is_open())
106  mooseError("Copying a FormattedTable with an open stream is not supported");
107 
108  for (const auto & it : o._data)
109  _data.emplace_back(it.first, it.second);
110 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
std::string _output_file_name
The optional output file stream.
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
bool _output_time
Whether or not to output the Time column.
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::string _csv_delimiter
*.csv file delimiter, defaults to ","
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
unsigned int _csv_precision
*.csv file precision, defaults to 14
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...
bool _headers_output
Keeps track of whether the header has been output.
bool _append
Keeps track of whether we want to open an existing file for appending or overwriting.

◆ ~FormattedTable()

FormattedTable::~FormattedTable ( )

The destructor is used to close the file handle.

Definition at line 112 of file FormattedTable.C.

112 { close(); }
void close()
Close the underlying output file stream if any. This is idempotent.

Member Function Documentation

◆ addData() [1/3]

void FormattedTable::addData ( const std::string &  name,
Real  value 
)

Method for adding data to the output table.

Data is added to the last row. Method will error if called on an empty table.

Definition at line 133 of file FormattedTable.C.

Referenced by TableOutput::outputPostprocessors(), TableOutput::outputScalarVariables(), and TableOutput::outputVectorPostprocessors().

134 {
135  if (empty())
136  mooseError("No Data stored in the the FormattedTable");
137 
138  auto back_it = _data.rbegin();
139  back_it->second[name] = value;
140 
141  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
142  {
143  _column_names.push_back(name);
144  _column_names_unsorted = true;
145  }
146 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
bool empty() const
Returns a boolean value based on whether the FormattedTable contains data or not. ...
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ addData() [2/3]

void FormattedTable::addData ( const std::string &  name,
Real  value,
Real  time 
)

Method for adding data to the output table.

The dependent variable is named "time"

Definition at line 149 of file FormattedTable.C.

150 {
151  auto back_it = _data.rbegin();
152 
153  mooseAssert(back_it == _data.rend() || !MooseUtils::absoluteFuzzyLessThan(time, back_it->first),
154  "Attempting to add data to FormattedTable with the dependent variable in a "
155  "non-increasing order.\nDid you mean to use addData(std::string &, const "
156  "std::vector<Real> &)?");
157 
158  // See if the current "row" is already in the table
159  if (back_it == _data.rend() || !MooseUtils::absoluteFuzzyEqual(time, back_it->first))
160  {
161  _data.emplace_back(time, std::map<std::string, Real>());
162  back_it = _data.rbegin();
163  }
164  // Insert or update value
165  back_it->second[name] = value;
166 
167  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
168  {
169  _column_names.push_back(name);
170  _column_names_unsorted = true;
171  }
172 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:231
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
bool absoluteFuzzyLessThan(const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether a variable is less than another variable within an absolute tolerance...
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ addData() [3/3]

void FormattedTable::addData ( const std::string &  name,
const std::vector< Real > &  vector 
)

Method for adding an entire vector to a table at a time.

Checks are made to ensure that the dependent variable index lines up with the vector indices.

Definition at line 175 of file FormattedTable.C.

176 {
177  for (MooseIndex(vector) i = 0; i < vector.size(); ++i)
178  {
179  if (i == _data.size())
180  _data.emplace_back(i, std::map<std::string, Real>());
181 
182  mooseAssert(MooseUtils::absoluteFuzzyEqual(_data[i].first, i),
183  "Inconsistent indexing in VPP vector");
184 
185  auto & curr_entry = _data[i];
186  curr_entry.second[name] = vector[i];
187  }
188 
189  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
190  {
191  _column_names.push_back(name);
192  _column_names_unsorted = true;
193  }
194 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:231
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ addRow()

void FormattedTable::addRow ( Real  time)

Force a new row in the table with the passed in time.

Definition at line 127 of file FormattedTable.C.

Referenced by TableOutput::outputPostprocessors().

128 {
129  _data.emplace_back(time, std::map<std::string, Real>());
130 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...

◆ append()

void FormattedTable::append ( bool  append_existing_file)

Sets append mode which means an existing file is not truncated on opening.

This mode is typically used for recovery.

Definition at line 121 of file FormattedTable.C.

Referenced by CSV::initialSetup().

122 {
123  _append = append_existing_file;
124 }
bool _append
Keeps track of whether we want to open an existing file for appending or overwriting.

◆ clear()

void FormattedTable::clear ( )

Definition at line 575 of file FormattedTable.C.

Referenced by TableOutput::clear(), and TableOutput::outputVectorPostprocessors().

576 {
577  _data.clear();
578 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...

◆ close()

void FormattedTable::close ( )
private

Close the underlying output file stream if any. This is idempotent.

Definition at line 52 of file FormattedTable.C.

Referenced by open(), and ~FormattedTable().

53 {
54  if (!_output_file.is_open())
55  return;
56  _output_file.flush();
57  _output_file.close();
58  _output_file_name = "";
59 }
std::string _output_file_name
The optional output file stream.
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)

◆ empty()

bool FormattedTable::empty ( ) const

Returns a boolean value based on whether the FormattedTable contains data or not.

Definition at line 115 of file FormattedTable.C.

Referenced by addData(), getLastData(), getLastTime(), Gnuplot::output(), CSV::output(), TableOutput::outputPostprocessors(), Console::outputPostprocessors(), and Console::outputScalarVariables().

116 {
117  return _data.empty();
118 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...

◆ getLastData()

Real & FormattedTable::getLastData ( const std::string &  name)

Retrieve Data for last value of given name.

Definition at line 204 of file FormattedTable.C.

205 {
206  mooseAssert(!empty(), "No Data stored in the FormattedTable");
207 
208  auto & last_data_map = _data.rbegin()->second;
209  auto it = last_data_map.find(name);
210  if (it == last_data_map.end())
211  mooseError("No Data found for name: " + name);
212 
213  return it->second;
214 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
bool empty() const
Returns a boolean value based on whether the FormattedTable contains data or not. ...

◆ getLastTime()

Real FormattedTable::getLastTime ( )

Retrieve the last time (or independent variable) value.

Definition at line 197 of file FormattedTable.C.

Referenced by TableOutput::outputPostprocessors().

198 {
199  mooseAssert(!empty(), "No Data stored in the FormattedTable");
200  return _data.rbegin()->first;
201 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
bool empty() const
Returns a boolean value based on whether the FormattedTable contains data or not. ...

◆ getTermWidth()

unsigned short FormattedTable::getTermWidth ( bool  use_environment) const
protected

Returns the width of the terminal using sys/ioctl.

Initialize the value we intend to populate just in case the system call fails

Definition at line 581 of file FormattedTable.C.

Referenced by printTable().

582 {
583  struct winsize w;
588  w.ws_col = std::numeric_limits<unsigned short>::max();
589 
590  if (use_environment)
591  {
592  char * pps_width = std::getenv("MOOSE_PPS_WIDTH");
593  if (pps_width != NULL)
594  {
595  std::stringstream ss(pps_width);
596  ss >> w.ws_col;
597  }
598  }
599  else
600  {
601  try
602  {
603  ioctl(0, TIOCGWINSZ, &w);
604  }
605  catch (...)
606  {
607  // Something bad happened, make sure we have a sane value
608  w.ws_col = std::numeric_limits<unsigned short>::max();
609  }
610  }
611 
612  return w.ws_col;
613 }

◆ getWidthModes()

MooseEnum FormattedTable::getWidthModes ( )
static

Definition at line 616 of file FormattedTable.C.

Referenced by validParams< Console >(), and validParams< TableOutput >().

617 {
618  return MooseEnum("ENVIRONMENT=-1 AUTO=0 80=80 120=120 160=160", "ENVIRONMENT", true);
619 }
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:32

◆ makeGnuplot()

void FormattedTable::makeGnuplot ( const std::string &  base_file,
const std::string &  format 
)

Definition at line 483 of file FormattedTable.C.

Referenced by Gnuplot::output().

484 {
485  // TODO: run this once at end of simulation, right now it runs every iteration
486  // TODO: do I need to be more careful escaping column names?
487  // Note: open and close the files each time, having open files may mess with gnuplot
488 
489  // supported filetypes: ps, png
490  std::string extension, terminal;
491  if (format == "png")
492  {
493  extension = ".png";
494  terminal = "png";
495  }
496 
497  else if (format == "ps")
498  {
499  extension = ".ps";
500  terminal = "postscript";
501  }
502 
503  else if (format == "gif")
504  {
505  extension = ".gif";
506  terminal = "gif";
507  }
508 
509  else
510  mooseError("gnuplot format \"" + format + "\" is not supported.");
511 
512  // Write the data to disk
513  std::string dat_name = base_file + ".dat";
514  std::ofstream datfile;
515  datfile.open(dat_name.c_str(), std::ios::trunc | std::ios::out);
516  if (datfile.fail())
517  mooseError("Unable to open file ", dat_name);
518 
519  datfile << "# time";
520  for (const auto & col_name : _column_names)
521  datfile << '\t' << col_name;
522  datfile << '\n';
523 
524  for (auto & data_it : _data)
525  {
526  datfile << data_it.first;
527  for (const auto & col_name : _column_names)
528  {
529  auto & tmp = data_it.second;
530  datfile << '\t' << tmp[col_name];
531  }
532  datfile << '\n';
533  }
534  datfile.flush();
535  datfile.close();
536 
537  // Write the gnuplot script
538  std::string gp_name = base_file + ".gp";
539  std::ofstream gpfile;
540  gpfile.open(gp_name.c_str(), std::ios::trunc | std::ios::out);
541  if (gpfile.fail())
542  mooseError("Unable to open file ", gp_name);
543 
544  gpfile << gnuplot::before_terminal << terminal << gnuplot::before_ext << extension
546 
547  // plot all postprocessors in one plot
548  int column = 2;
549  for (const auto & col_name : _column_names)
550  {
551  gpfile << " '" << dat_name << "' using 1:" << column << " title '" << col_name
552  << "' with linespoints";
553  column++;
554  if (column - 2 < static_cast<int>(_column_names.size()))
555  gpfile << ", \\\n";
556  }
557  gpfile << "\n\n";
558 
559  // plot the postprocessors individually
560  column = 2;
561  for (const auto & col_name : _column_names)
562  {
563  gpfile << "set output '" << col_name << extension << "'\n";
564  gpfile << "set ylabel '" << col_name << "'\n";
565  gpfile << "plot '" << dat_name << "' using 1:" << column << " title '" << col_name
566  << "' with linespoints\n\n";
567  column++;
568  }
569 
570  gpfile.flush();
571  gpfile.close();
572 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
const std::string after_ext
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...
const std::string before_ext
const std::string before_terminal

◆ open()

void FormattedTable::open ( const std::string &  file_name)
private

Open or switch the underlying file stream to point to file_name. This is idempotent.

Definition at line 62 of file FormattedTable.C.

Referenced by printCSV(), and printTable().

63 {
64  if (_output_file.is_open() && _output_file_name == file_name)
65  return;
66  close();
67  _output_file_name = file_name;
68 
69  std::ios_base::openmode open_flags = std::ios::out;
70  if (_append)
71  open_flags |= std::ios::app;
72  else
73  {
74  open_flags |= std::ios::trunc;
76  _headers_output = false;
77  }
78 
79  _output_file.open(file_name.c_str(), open_flags);
80  if (_output_file.fail())
81  mooseError("Unable to open file ", file_name);
82 }
std::string _output_file_name
The optional output file stream.
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:208
void close()
Close the underlying output file stream if any. This is idempotent.
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
bool _headers_output
Keeps track of whether the header has been output.
bool _append
Keeps track of whether we want to open an existing file for appending or overwriting.

◆ outputTimeColumn()

void FormattedTable::outputTimeColumn ( bool  output_time)
inline

Set whether or not to output time column.

Definition at line 106 of file FormattedTable.h.

Referenced by TableOutput::outputVectorPostprocessors(), and TableOutput::TableOutput().

106 { _output_time = output_time; }
bool _output_time
Whether or not to output the Time column.

◆ printCSV()

void FormattedTable::printCSV ( const std::string &  file_name,
int  interval = 1,
bool  align = false 
)

Method for dumping the table to a csv file - opening and closing the file handle is handled.

Note: Only call this on processor 0!

When the alignment option is set to true, the widths of the columns needs to be computed based on longest of the column name of the data supplied. This is done here by creating a map of the widths for each of the columns, including time

Definition at line 362 of file FormattedTable.C.

Referenced by CSV::output().

363 {
364  open(file_name);
365 
366  if (_output_row_index == 0)
367  {
374  if (align)
375  {
376  // Set the initial width to the names of the columns
377  _align_widths["time"] = 4;
378 
379  for (const auto & col_name : _column_names)
380  _align_widths[col_name] = col_name.size();
381 
382  // Loop through the various times
383  for (const auto & it : _data)
384  {
385  // Update the time _align_width
386  {
387  std::ostringstream oss;
388  oss << std::setprecision(_csv_precision) << it.first;
389  unsigned int w = oss.str().size();
390  _align_widths["time"] = std::max(_align_widths["time"], w);
391  }
392 
393  // Loop through the data for the current time and update the _align_widths
394  for (const auto & jt : it.second)
395  {
396  std::ostringstream oss;
397  oss << std::setprecision(_csv_precision) << jt.second;
398  unsigned int w = oss.str().size();
399  _align_widths[jt.first] = std::max(_align_widths[jt.first], w);
400  }
401  }
402  }
403 
404  // Output Header
405  if (!_headers_output)
406  {
407  if (_output_time)
408  {
409  if (align)
410  _output_file << std::setw(_align_widths["time"]) << "time";
411  else
412  _output_file << "time";
413  _headers_output = true;
414  }
415 
416  for (const auto & col_name : _column_names)
417  {
418  if (_headers_output)
420 
421  if (align)
422  _output_file << std::right << std::setw(_align_widths[col_name]) << col_name;
423  else
424  _output_file << col_name;
425  _headers_output = true;
426  }
427  _output_file << "\n";
428  }
429  }
430 
431  for (; _output_row_index < _data.size(); ++_output_row_index)
432  {
433  if (_output_row_index % interval == 0)
435  }
436 
437  _output_file.flush();
438 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
void open(const std::string &file_name)
Open or switch the underlying file stream to point to file_name. This is idempotent.
bool _output_time
Whether or not to output the Time column.
std::string _csv_delimiter
*.csv file delimiter, defaults to ","
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
void printRow(std::pair< Real, std::map< std::string, Real >> &row_data, bool align)
std::map< std::string, unsigned int > _align_widths
Alignment widths (only used if asked to print aligned to CSV output)
unsigned int _csv_precision
*.csv file precision, defaults to 14
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...
bool _headers_output
Keeps track of whether the header has been output.

◆ printEnsight()

void FormattedTable::printEnsight ( const std::string &  file_name)

◆ printNoDataRow()

void FormattedTable::printNoDataRow ( char  intersect_char,
char  fill_char,
std::ostream &  out,
std::map< std::string, unsigned short > &  col_widths,
std::vector< std::string >::iterator &  col_begin,
std::vector< std::string >::iterator &  col_end 
) const
protected

Definition at line 235 of file FormattedTable.C.

Referenced by printOmittedRow(), and printRowDivider().

241 {
242  out.fill(fill_char);
243  out << std::right << intersect_char << std::setw(_column_width + 2) << intersect_char;
244  for (auto header_it = col_begin; header_it != col_end; ++header_it)
245  out << std::setw(col_widths[*header_it] + 2) << intersect_char;
246  out << "\n";
247 
248  // Clear the fill character
249  out.fill(' ');
250 }
static const unsigned short _column_width
The single cell width used for all columns in the table.

◆ printOmittedRow()

void FormattedTable::printOmittedRow ( std::ostream &  out,
std::map< std::string, unsigned short > &  col_widths,
std::vector< std::string >::iterator &  col_begin,
std::vector< std::string >::iterator &  col_end 
) const
protected

Definition at line 217 of file FormattedTable.C.

Referenced by printTablePiece().

221 {
222  printNoDataRow(':', ' ', out, col_widths, col_begin, col_end);
223 }
void printNoDataRow(char intersect_char, char fill_char, std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const

◆ printRow()

void FormattedTable::printRow ( std::pair< Real, std::map< std::string, Real >> &  row_data,
bool  align 
)
private

Definition at line 441 of file FormattedTable.C.

Referenced by printCSV().

442 {
443  bool first = true;
444 
445  if (_output_time)
446  {
447  if (align)
448  _output_file << std::setprecision(_csv_precision) << std::right
449  << std::setw(_align_widths["time"]) << row_data.first;
450  else
451  _output_file << std::setprecision(_csv_precision) << row_data.first;
452  first = false;
453  }
454 
455  for (const auto & col_name : _column_names)
456  {
457  std::map<std::string, Real> & tmp = row_data.second;
458 
459  if (!first)
461  else
462  first = false;
463 
464  if (align)
465  _output_file << std::setprecision(_csv_precision) << std::right
466  << std::setw(_align_widths[col_name]) << tmp[col_name];
467  else
468  _output_file << std::setprecision(_csv_precision) << tmp[col_name];
469  }
470  _output_file << "\n";
471 }
bool _output_time
Whether or not to output the Time column.
std::string _csv_delimiter
*.csv file delimiter, defaults to ","
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
std::map< std::string, unsigned int > _align_widths
Alignment widths (only used if asked to print aligned to CSV output)
unsigned int _csv_precision
*.csv file precision, defaults to 14
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ printRowDivider()

void FormattedTable::printRowDivider ( std::ostream &  out,
std::map< std::string, unsigned short > &  col_widths,
std::vector< std::string >::iterator &  col_begin,
std::vector< std::string >::iterator &  col_end 
) const
protected

Definition at line 226 of file FormattedTable.C.

Referenced by printTablePiece().

230 {
231  printNoDataRow('+', '-', out, col_widths, col_begin, col_end);
232 }
void printNoDataRow(char intersect_char, char fill_char, std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const

◆ printTable() [1/3]

void FormattedTable::printTable ( std::ostream &  out,
unsigned int  last_n_entries = 0 
)

Methods for dumping the table to the stream - either by filename or by stream handle.

If a filename is supplied opening and closing of the file is properly handled. In the screen version of the method, an optional parameters can be passed to print only the last "n" entries. A value of zero means don't skip any rows

Note: Only call these from processor 0!

Definition at line 260 of file FormattedTable.C.

Referenced by Console::outputPostprocessors(), Console::outputScalarVariables(), and printTable().

261 {
262  printTable(out, last_n_entries, MooseEnum("ENVIRONMENT=-1", "ENVIRONMENT"));
263 }
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:32
void printTable(std::ostream &out, unsigned int last_n_entries=0)
Methods for dumping the table to the stream - either by filename or by stream handle.

◆ printTable() [2/3]

void FormattedTable::printTable ( std::ostream &  out,
unsigned int  last_n_entries,
const MooseEnum suggested_term_width 
)

Definition at line 266 of file FormattedTable.C.

269 {
270  unsigned short term_width;
271 
272  if (suggested_term_width == "ENVIRONMENT")
273  term_width = getTermWidth(true);
274  else if (suggested_term_width == "AUTO")
275  term_width = getTermWidth(false);
276  else
277  term_width = MooseUtils::stringToInteger(suggested_term_width);
278 
279  if (term_width < _min_pps_width)
280  term_width = _min_pps_width;
281 
282  std::vector<std::string>::iterator col_it = _column_names.begin();
283  std::vector<std::string>::iterator col_end = _column_names.end();
284 
285  std::vector<std::string>::iterator curr_begin = col_it;
286  std::vector<std::string>::iterator curr_end;
287  while (col_it != col_end)
288  {
289  std::map<std::string, unsigned short> col_widths;
290  unsigned int curr_width = _column_width + 4;
291  unsigned int cols_in_group = 0;
292  while (curr_width < term_width && col_it != col_end)
293  {
294  curr_end = col_it;
295  col_widths[*col_it] = col_it->length() > _column_width ? col_it->length() + 1 : _column_width;
296 
297  curr_width += col_widths[*col_it] + 3;
298  ++col_it;
299  ++cols_in_group;
300  }
301  if (col_it != col_end && cols_in_group >= 2)
302  {
303  // curr_width -= col_widths[*curr_end];
304  col_widths.erase(*curr_end);
305  col_it = curr_end;
306  }
307  else
308  curr_end = col_it;
309 
310  printTablePiece(out, last_n_entries, col_widths, curr_begin, curr_end);
311  curr_begin = curr_end;
312  }
313 }
void printTablePiece(std::ostream &out, unsigned int last_n_entries, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end)
int stringToInteger(const std::string &input, bool throw_on_failure=false)
Robust string to integer conversion that fails for cases such at "1foo".
Definition: MooseUtils.C:730
static const unsigned short _min_pps_width
The absolute minimum PPS table width.
unsigned short getTermWidth(bool use_environment) const
Returns the width of the terminal using sys/ioctl.
static const unsigned short _column_width
The single cell width used for all columns in the table.
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ printTable() [3/3]

void FormattedTable::printTable ( const std::string &  file_name)

Definition at line 253 of file FormattedTable.C.

254 {
255  open(file_name);
257 }
void open(const std::string &file_name)
Open or switch the underlying file stream to point to file_name. This is idempotent.
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
void printTable(std::ostream &out, unsigned int last_n_entries=0)
Methods for dumping the table to the stream - either by filename or by stream handle.

◆ printTablePiece()

void FormattedTable::printTablePiece ( std::ostream &  out,
unsigned int  last_n_entries,
std::map< std::string, unsigned short > &  col_widths,
std::vector< std::string >::iterator &  col_begin,
std::vector< std::string >::iterator &  col_end 
)
protected

Print out the header row

Definition at line 316 of file FormattedTable.C.

Referenced by printTable().

321 {
325  printRowDivider(out, col_widths, col_begin, col_end);
326  out << "|" << std::setw(_column_width) << std::left << " time"
327  << " |";
328  for (auto header_it = col_begin; header_it != col_end; ++header_it)
329  out << " " << std::setw(col_widths[*header_it]) << *header_it << "|";
330  out << "\n";
331  printRowDivider(out, col_widths, col_begin, col_end);
332 
333  auto data_it = _data.begin();
334  if (last_n_entries)
335  {
336  if (_data.size() > last_n_entries)
337  {
338  // Print a blank row to indicate that values have been ommited
339  printOmittedRow(out, col_widths, col_begin, col_end);
340 
341  // Jump to the right place in the vector
342  data_it += _data.size() - last_n_entries;
343  }
344  }
345  // Now print the remaining data rows
346  for (; data_it != _data.end(); ++data_it)
347  {
348  out << "|" << std::right << std::setw(_column_width) << std::scientific << data_it->first
349  << " |";
350  for (auto header_it = col_begin; header_it != col_end; ++header_it)
351  {
352  auto & tmp = data_it->second;
353  out << std::setw(col_widths[*header_it]) << tmp[*header_it] << " |";
354  }
355  out << "\n";
356  }
357 
358  printRowDivider(out, col_widths, col_begin, col_end);
359 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
void printOmittedRow(std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const
void printRowDivider(std::ostream &out, std::map< std::string, unsigned short > &col_widths, std::vector< std::string >::iterator &col_begin, std::vector< std::string >::iterator &col_end) const
static const unsigned short _column_width
The single cell width used for all columns in the table.

◆ setDelimiter()

void FormattedTable::setDelimiter ( std::string  delimiter)
inline

By default printCSV places "," between each entry, this allows this to be changed.

Definition at line 140 of file FormattedTable.h.

Referenced by CSV::initialSetup().

140 { _csv_delimiter = delimiter; }
std::string _csv_delimiter
*.csv file delimiter, defaults to ","

◆ setPrecision()

void FormattedTable::setPrecision ( unsigned int  precision)
inline

By default printCSV prints output to a precision of 14, this allows this to be changed.

Definition at line 145 of file FormattedTable.h.

Referenced by CSV::initialSetup().

145 { _csv_precision = precision; }
unsigned int _csv_precision
*.csv file precision, defaults to 14

◆ sortColumns()

void FormattedTable::sortColumns ( )

Sorts columns alphabetically.

Definition at line 622 of file FormattedTable.C.

Referenced by CSV::output(), Console::outputPostprocessors(), and Console::outputScalarVariables().

623 {
625  {
626  std::sort(_column_names.begin(), _column_names.end());
627  _column_names_unsorted = false;
628  }
629 }
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ writeExodus()

void FormattedTable::writeExodus ( ExodusII_IO *  ex_out,
Real  time 
)

Friends And Related Function Documentation

◆ dataLoad

void dataLoad ( std::istream &  stream,
FormattedTable v,
void *  context 
)
friend

Definition at line 42 of file FormattedTable.C.

43 {
44  loadHelper(stream, table._data, context);
45  loadHelper(stream, table._align_widths, context);
46  loadHelper(stream, table._column_names, context);
47  loadHelper(stream, table._output_row_index, context);
48  loadHelper(stream, table._headers_output, context);
49 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:742

◆ dataStore

void dataStore ( std::ostream &  stream,
FormattedTable table,
void *  context 
)
friend

Definition at line 31 of file FormattedTable.C.

32 {
33  storeHelper(stream, table._data, context);
34  storeHelper(stream, table._align_widths, context);
35  storeHelper(stream, table._column_names, context);
36  storeHelper(stream, table._output_row_index, context);
37  storeHelper(stream, table._headers_output, context);
38 }
std::vector< std::pair< Real, std::map< std::string, Real > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:678
std::map< std::string, unsigned int > _align_widths
Alignment widths (only used if asked to print aligned to CSV output)
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...
bool _headers_output
Keeps track of whether the header has been output.

Member Data Documentation

◆ _align_widths

std::map<std::string, unsigned int> FormattedTable::_align_widths
protected

Alignment widths (only used if asked to print aligned to CSV output)

Definition at line 189 of file FormattedTable.h.

Referenced by dataLoad(), dataStore(), printCSV(), and printRow().

◆ _append

bool FormattedTable::_append
private

Keeps track of whether we want to open an existing file for appending or overwriting.

Definition at line 230 of file FormattedTable.h.

Referenced by append(), and open().

◆ _column_names

std::vector<std::string> FormattedTable::_column_names
protected

The set of column names updated when data is inserted through the setter methods.

Definition at line 192 of file FormattedTable.h.

Referenced by addData(), dataLoad(), dataStore(), makeGnuplot(), printCSV(), printRow(), printTable(), and sortColumns().

◆ _column_names_unsorted

bool FormattedTable::_column_names_unsorted = true
private

Flag indicating that sorting is necessary (used by sortColumns method).

Definition at line 242 of file FormattedTable.h.

Referenced by addData(), and sortColumns().

◆ _column_width

const unsigned short FormattedTable::_column_width = 15
staticprotected

The single cell width used for all columns in the table.

Definition at line 195 of file FormattedTable.h.

Referenced by printNoDataRow(), printTable(), and printTablePiece().

◆ _csv_delimiter

std::string FormattedTable::_csv_delimiter
private

*.csv file delimiter, defaults to ","

Definition at line 236 of file FormattedTable.h.

Referenced by printCSV(), printRow(), and setDelimiter().

◆ _csv_precision

unsigned int FormattedTable::_csv_precision
private

*.csv file precision, defaults to 14

Definition at line 239 of file FormattedTable.h.

Referenced by printCSV(), printRow(), and setPrecision().

◆ _data

std::vector<std::pair<Real, std::map<std::string, Real> > > FormattedTable::_data
protected

Data structure for the console table: The first part of the pair tracks the independent variable (normally time) and is associated with the second part of the table which is the map of dependent variables and their associated values.

Definition at line 186 of file FormattedTable.h.

Referenced by addData(), addRow(), clear(), dataLoad(), dataStore(), empty(), FormattedTable(), getLastData(), getLastTime(), makeGnuplot(), printCSV(), and printTablePiece().

◆ _headers_output

bool FormattedTable::_headers_output
private

Keeps track of whether the header has been output.

This is separate from _output_row_index because it's possible to output the header with zero rows. We don't consider this a bug, it helps users understand that they have declared vectors properly but maybe haven't populated them correctly.

Definition at line 227 of file FormattedTable.h.

Referenced by dataLoad(), dataStore(), open(), and printCSV().

◆ _min_pps_width

const unsigned short FormattedTable::_min_pps_width = 40
staticprotected

The absolute minimum PPS table width.

Definition at line 198 of file FormattedTable.h.

Referenced by printTable().

◆ _output_file

std::ofstream FormattedTable::_output_file
private

The stream handle (corresponds to _output_file_name)

Definition at line 213 of file FormattedTable.h.

Referenced by close(), FormattedTable(), open(), printCSV(), printRow(), and printTable().

◆ _output_file_name

std::string FormattedTable::_output_file_name
private

The optional output file stream.

Definition at line 210 of file FormattedTable.h.

Referenced by close(), and open().

◆ _output_row_index

std::size_t FormattedTable::_output_row_index
private

Keeps track of the index indicating which vector elements have been output.

All items with an index less than this index have been output. Higher values have not.

Definition at line 219 of file FormattedTable.h.

Referenced by dataLoad(), dataStore(), open(), and printCSV().

◆ _output_time

bool FormattedTable::_output_time
private

Whether or not to output the Time column.

Definition at line 233 of file FormattedTable.h.

Referenced by outputTimeColumn(), printCSV(), and printRow().


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