https://mooseframework.inl.gov
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...
 
template<typename T = Real>
void addData (const std::string &name, const T &value)
 Method for adding data to the output table. More...
 
template<typename T = Real>
void addData (const std::string &name, const T &value, Real time)
 Method for adding data to the output table. More...
 
template<typename T = Real>
void addData (const std::string &name, const std::vector< T > &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...
 
template<typename T = Real>
T & 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 (libMesh::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
 

Protected Attributes

std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _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, std::shared_ptr< TableValueBase >>> &row_data, bool align)
 
void fillEmptyValues (unsigned int last_n_entries=0)
 Fill any values that are not defined (usually when there are mismatched column lengths) More...
 

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 109 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 143 of file FormattedTable.C.

144  : _output_row_index(0),
145  _headers_output(false),
146  _append(false),
147  _output_time(true),
150 {
151 }
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 153 of file FormattedTable.C.

155  _output_file_name(""),
158  _append(o._append),
163 {
164  if (_output_file.is_open())
165  mooseError("Copying a FormattedTable with an open stream is not supported");
166 
167  for (const auto & it : o._data)
168  _data.emplace_back(it.first, it.second);
169 }
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:302
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)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
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 171 of file FormattedTable.C.

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

Member Function Documentation

◆ addData() [1/3]

template<typename T >
void FormattedTable::addData ( const std::string &  name,
const T &  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 332 of file FormattedTable.h.

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

333 {
334  if (empty())
335  mooseError("No Data stored in the the FormattedTable");
336 
337  auto back_it = _data.rbegin();
338  back_it->second[name] =
339  std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(value));
340 
341  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
342  {
343  _column_names.push_back(name);
344  _column_names_unsorted = true;
345  }
346 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
bool empty() const
Returns a boolean value based on whether the FormattedTable contains data or not. ...
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ addData() [2/3]

template<typename T >
void FormattedTable::addData ( const std::string &  name,
const T &  value,
Real  time 
)

Method for adding data to the output table.

The dependent variable is named "time"

Definition at line 350 of file FormattedTable.h.

351 {
352  auto back_it = _data.rbegin();
353 
354  mooseAssert(back_it == _data.rend() || !MooseUtils::absoluteFuzzyLessThan(time, back_it->first),
355  "Attempting to add data to FormattedTable with the dependent variable in a "
356  "non-increasing order.\nDid you mean to use addData(std::string &, const "
357  "std::vector<Real> &)?");
358 
359  // See if the current "row" is already in the table
360  if (back_it == _data.rend() || !MooseUtils::absoluteFuzzyEqual(time, back_it->first))
361  {
362  _data.emplace_back(time, std::map<std::string, std::shared_ptr<TableValueBase>>());
363  back_it = _data.rbegin();
364  }
365  // Insert or update value
366  back_it->second[name] =
367  std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(value));
368 
369  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
370  {
371  _column_names.push_back(name);
372  _column_names_unsorted = true;
373  }
374 }
std::string name(const ElemQuality q)
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:380
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
bool absoluteFuzzyLessThan(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether a variable is less than another variable within an absolute tolerance...
Definition: MooseUtils.h:475
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ addData() [3/3]

template<typename T >
void FormattedTable::addData ( const std::string &  name,
const std::vector< T > &  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 378 of file FormattedTable.h.

379 {
380  for (MooseIndex(vector) i = 0; i < vector.size(); ++i)
381  {
382  if (i == _data.size())
383  _data.emplace_back(i, std::map<std::string, std::shared_ptr<TableValueBase>>());
384 
385  mooseAssert(MooseUtils::absoluteFuzzyEqual(_data[i].first, i),
386  "Inconsistent indexing in VPP vector");
387 
388  auto & curr_entry = _data[i];
389  curr_entry.second[name] =
390  std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(vector[i]));
391  }
392 
393  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
394  {
395  _column_names.push_back(name);
396  _column_names_unsorted = true;
397  }
398 }
std::string name(const ElemQuality q)
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:380
bool _column_names_unsorted
Flag indicating that sorting is necessary (used by sortColumns method).
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
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 186 of file FormattedTable.C.

Referenced by AutomaticMortarGeneration::msmStatistics(), TableOutput::outputPostprocessors(), and TableOutput::outputReporter().

187 {
188  _data.emplace_back(time, std::map<std::string, std::shared_ptr<TableValueBase>>());
189 }
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _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 180 of file FormattedTable.C.

Referenced by CSV::initialSetup().

181 {
182  _append = append_existing_file;
183 }
bool _append
Keeps track of whether we want to open an existing file for appending or overwriting.

◆ clear()

void FormattedTable::clear ( )

Definition at line 567 of file FormattedTable.C.

Referenced by TableOutput::clear(), and AutomaticMortarGeneration::msmStatistics().

568 {
569  _data.clear();
570  _output_file.close();
571  _output_row_index = 0;
572 }
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _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 111 of file FormattedTable.C.

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

112 {
113  if (!_output_file.is_open())
114  return;
115  _output_file.flush();
116  _output_file.close();
117  _output_file_name = "";
118 }
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 174 of file FormattedTable.C.

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

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

◆ fillEmptyValues()

void FormattedTable::fillEmptyValues ( unsigned int  last_n_entries = 0)
private

Fill any values that are not defined (usually when there are mismatched column lengths)

If last_n_entries is non-zero, only values in that many final rows will be examined and filled.

Definition at line 575 of file FormattedTable.C.

Referenced by dataStore(), makeGnuplot(), printCSV(), and printTablePiece().

576 {
577  auto begin = _data.begin();
578  auto end = _data.end();
579  if (last_n_entries && (last_n_entries < _data.size()))
580  begin = end - last_n_entries;
581 
582  for (auto it = begin; it != end; ++it)
583  {
584  auto & datamap = it->second;
585  if (datamap.size() != _column_names.size())
586  {
587  for (const auto & col_name : _column_names)
588  if (!datamap[col_name])
589  datamap[col_name] =
590  std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<char>>('0'));
591  }
592  else
593  {
594  for (auto & [key, val] : datamap)
595  if (!val)
596  val = std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<char>>('0'));
597  }
598  }
599 }
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
std::vector< std::string > _column_names
The set of column names updated when data is inserted through the setter methods. ...

◆ getLastData()

template<typename T >
T & FormattedTable::getLastData ( const std::string &  name)

Retrieve Data for last value of given name.

Definition at line 402 of file FormattedTable.h.

403 {
404  mooseAssert(!empty(), "No Data stored in the FormattedTable");
405 
406  auto & last_data_map = _data.rbegin()->second;
407  auto it = last_data_map.find(name);
408  if (it == last_data_map.end())
409  mooseError("No Data found for name: " + name);
410 
411  auto value = std::dynamic_pointer_cast<TableValue<T>>(it->second);
412  if (!value)
413  mooseError("Data for ", name, " is not of the requested type.");
414  return value->set();
415 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
bool empty() const
Returns a boolean value based on whether the FormattedTable contains data or not. ...
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...

◆ getLastTime()

Real FormattedTable::getLastTime ( )

Retrieve the last time (or independent variable) value.

Definition at line 192 of file FormattedTable.C.

Referenced by TableOutput::outputPostprocessors(), and TableOutput::outputReporter().

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

◆ getWidthModes()

MooseEnum FormattedTable::getWidthModes ( )
static

Definition at line 602 of file FormattedTable.C.

Referenced by Console::validParams().

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

◆ makeGnuplot()

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

Definition at line 473 of file FormattedTable.C.

Referenced by Gnuplot::output().

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

Referenced by printCSV(), and printTable().

122 {
123  if (_output_file.is_open() && _output_file_name == file_name)
124  return;
125  close();
126  _output_file_name = file_name;
127 
128  std::ios_base::openmode open_flags = std::ios::out;
129  if (_append)
130  open_flags |= std::ios::app;
131  else
132  {
133  open_flags |= std::ios::trunc;
134  _output_row_index = 0;
135  _headers_output = false;
136  }
137 
138  _output_file.open(file_name.c_str(), open_flags);
139  if (_output_file.fail())
140  mooseError("Unable to open file ", file_name);
141 }
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:302
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 183 of file FormattedTable.h.

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

183 { _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 349 of file FormattedTable.C.

Referenced by CSV::output().

350 {
351  fillEmptyValues();
352 
353  open(file_name);
354 
355  if (_output_row_index == 0)
356  {
363  if (align)
364  {
365  // Set the initial width to the names of the columns
366  _align_widths["time"] = 4;
367 
368  for (const auto & col_name : _column_names)
369  _align_widths[col_name] = col_name.size();
370 
371  // Loop through the various times
372  for (const auto & it : _data)
373  {
374  // Update the time _align_width
375  {
376  std::ostringstream oss;
377  oss << std::setprecision(_csv_precision) << it.first;
378  unsigned int w = oss.str().size();
379  _align_widths["time"] = std::max(_align_widths["time"], w);
380  }
381 
382  // Loop through the data for the current time and update the _align_widths
383  for (const auto & jt : it.second)
384  {
385  std::ostringstream oss;
386  oss << std::setprecision(_csv_precision) << *jt.second;
387  unsigned int w = oss.str().size();
388  _align_widths[jt.first] = std::max(_align_widths[jt.first], w);
389  }
390  }
391  }
392 
393  // Output Header
394  if (!_headers_output)
395  {
396  if (_output_time)
397  {
398  if (align)
399  _output_file << std::setw(_align_widths["time"]) << "time";
400  else
401  _output_file << "time";
402  _headers_output = true;
403  }
404 
405  for (const auto & col_name : _column_names)
406  {
407  if (_headers_output)
409 
410  if (align)
411  _output_file << std::right << std::setw(_align_widths[col_name]) << col_name;
412  else
413  _output_file << col_name;
414  _headers_output = true;
415  }
416  _output_file << "\n";
417  }
418  }
419 
420  for (; _output_row_index < _data.size(); ++_output_row_index)
421  {
422  if (_output_row_index % interval == 0)
424  }
425 
426  _output_file.flush();
427 }
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.
void printRow(std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase >>> &row_data, bool align)
std::string _csv_delimiter
*.csv file delimiter, defaults to ","
void fillEmptyValues(unsigned int last_n_entries=0)
Fill any values that are not defined (usually when there are mismatched column lengths) ...
auto max(const L &left, const R &right)
std::ofstream _output_file
The stream handle (corresponds to _output_file_name)
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
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 217 of file FormattedTable.C.

Referenced by printOmittedRow(), and printRowDivider().

223 {
224  out.fill(fill_char);
225  out << std::right << intersect_char;
226  if (_output_time)
227  out << std::setw(_column_width + 2) << intersect_char;
228  for (auto header_it = col_begin; header_it != col_end; ++header_it)
229  out << std::setw(col_widths[*header_it] + 2) << intersect_char;
230  out << "\n";
231 
232  // Clear the fill character
233  out.fill(' ');
234 }
bool _output_time
Whether or not to output the Time column.
static const unsigned short _column_width
The single cell width used for all columns in the table.
OStreamProxy out

◆ 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 199 of file FormattedTable.C.

Referenced by printTablePiece().

203 {
204  printNoDataRow(':', ' ', out, col_widths, col_begin, col_end);
205 }
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, std::shared_ptr< TableValueBase >>> &  row_data,
bool  align 
)
private

Definition at line 430 of file FormattedTable.C.

Referenced by printCSV().

432 {
433  bool first = true;
434 
435  if (_output_time)
436  {
437  if (align)
438  _output_file << std::setprecision(_csv_precision) << std::right
439  << std::setw(_align_widths["time"]) << row_data.first;
440  else
441  _output_file << std::setprecision(_csv_precision) << row_data.first;
442  first = false;
443  }
444 
445  for (const auto & col_name : _column_names)
446  {
447  std::map<std::string, std::shared_ptr<TableValueBase>> & tmp = row_data.second;
448 
449  if (!first)
451  else
452  first = false;
453 
454  if (align)
455  _output_file << std::setprecision(_csv_precision) << std::right
456  << std::setw(_align_widths[col_name]) << *tmp[col_name];
457  else
458  _output_file << std::setprecision(_csv_precision) << *tmp[col_name];
459  }
460  _output_file << "\n";
461 }
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 208 of file FormattedTable.C.

Referenced by printTablePiece().

212 {
213  printNoDataRow('+', '-', out, col_widths, col_begin, col_end);
214 }
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 244 of file FormattedTable.C.

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

245 {
246  printTable(out, last_n_entries, MooseEnum("ENVIRONMENT=-1", "ENVIRONMENT"));
247 }
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
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 250 of file FormattedTable.C.

253 {
254  unsigned short term_width;
255 
256  if (suggested_term_width == "ENVIRONMENT")
257  term_width = MooseUtils::getTermWidth(true);
258  else if (suggested_term_width == "AUTO")
259  term_width = MooseUtils::getTermWidth(false);
260  else
261  term_width = MooseUtils::stringToInteger(suggested_term_width);
262 
263  if (term_width < _min_pps_width)
264  term_width = _min_pps_width;
265 
266  std::vector<std::string>::iterator col_it = _column_names.begin();
267  std::vector<std::string>::iterator col_end = _column_names.end();
268 
269  std::vector<std::string>::iterator curr_begin = col_it;
270  std::vector<std::string>::iterator curr_end;
271  while (col_it != col_end)
272  {
273  std::map<std::string, unsigned short> col_widths;
274  unsigned int curr_width = _column_width + 4;
275  unsigned int cols_in_group = 0;
276  while (curr_width < term_width && col_it != col_end)
277  {
278  curr_end = col_it;
279  col_widths[*col_it] = col_it->length() > _column_width ? col_it->length() + 1 : _column_width;
280 
281  curr_width += col_widths[*col_it] + 3;
282  ++col_it;
283  ++cols_in_group;
284  }
285  if (col_it != col_end && cols_in_group >= 2)
286  {
287  // curr_width -= col_widths[*curr_end];
288  col_widths.erase(*curr_end);
289  col_it = curr_end;
290  }
291  else
292  curr_end = col_it;
293 
294  printTablePiece(out, last_n_entries, col_widths, curr_begin, curr_end);
295  curr_begin = curr_end;
296  }
297 }
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:1073
static const unsigned short _min_pps_width
The absolute minimum PPS table width.
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. ...
unsigned short getTermWidth(bool use_environment)
Returns the width of the terminal using sys/ioctl.
Definition: MooseUtils.C:636

◆ printTable() [3/3]

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

Definition at line 237 of file FormattedTable.C.

238 {
239  open(file_name);
241 }
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 300 of file FormattedTable.C.

Referenced by printTable().

305 {
306  fillEmptyValues(last_n_entries);
310  printRowDivider(out, col_widths, col_begin, col_end);
311  out << "|";
312  if (_output_time)
313  out << std::setw(_column_width) << std::left << " time" << " |";
314  for (auto header_it = col_begin; header_it != col_end; ++header_it)
315  out << " " << std::setw(col_widths[*header_it]) << *header_it << "|";
316  out << "\n";
317  printRowDivider(out, col_widths, col_begin, col_end);
318 
319  auto data_it = _data.begin();
320  if (last_n_entries)
321  {
322  if (_data.size() > last_n_entries)
323  {
324  // Print a blank row to indicate that values have been ommited
325  printOmittedRow(out, col_widths, col_begin, col_end);
326 
327  // Jump to the right place in the vector
328  data_it += _data.size() - last_n_entries;
329  }
330  }
331  // Now print the remaining data rows
332  for (; data_it != _data.end(); ++data_it)
333  {
334  out << "|";
335  if (_output_time)
336  out << std::right << std::setw(_column_width) << std::scientific << data_it->first << " |";
337  for (auto header_it = col_begin; header_it != col_end; ++header_it)
338  {
339  auto & tmp = data_it->second;
340  out << std::setw(col_widths[*header_it]) << *tmp[*header_it] << " |";
341  }
342  out << "\n";
343  }
344 
345  printRowDivider(out, col_widths, col_begin, col_end);
346 }
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
bool _output_time
Whether or not to output the Time column.
void fillEmptyValues(unsigned int last_n_entries=0)
Fill any values that are not defined (usually when there are mismatched column lengths) ...
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
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
static const unsigned short _column_width
The single cell width used for all columns in the table.
OStreamProxy out

◆ setDelimiter()

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

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

Definition at line 217 of file FormattedTable.h.

Referenced by CSV::initialSetup().

std::string _csv_delimiter
*.csv file delimiter, defaults to ","
charT const * delimiter
Definition: InfixIterator.h:34

◆ 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 222 of file FormattedTable.h.

Referenced by CSV::initialSetup().

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

◆ sortColumns()

void FormattedTable::sortColumns ( )

Sorts columns alphabetically.

Definition at line 608 of file FormattedTable.C.

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

609 {
611  {
612  std::sort(_column_names.begin(), _column_names.end());
613  _column_names_unsorted = false;
614  }
615 }
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 ( libMesh::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 39 of file FormattedTable.C.

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

◆ dataStore

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

Definition at line 27 of file FormattedTable.C.

28 {
29  table.fillEmptyValues();
30  storeHelper(stream, table._data, context);
31  storeHelper(stream, table._align_widths, context);
32  storeHelper(stream, table._column_names, context);
33  storeHelper(stream, table._output_row_index, context);
34  storeHelper(stream, table._headers_output, context);
35 }
std::size_t _output_row_index
Keeps track of the index indicating which vector elements have been output.
void fillEmptyValues(unsigned int last_n_entries=0)
Fill any values that are not defined (usually when there are mismatched column lengths) ...
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:893
std::vector< std::pair< Real, std::map< std::string, std::shared_ptr< TableValueBase > > > > _data
Data structure for the console table: The first part of the pair tracks the independent variable (nor...
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 261 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 311 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 264 of file FormattedTable.h.

Referenced by addData(), dataLoad(), dataStore(), fillEmptyValues(), 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 323 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 267 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 317 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 320 of file FormattedTable.h.

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

◆ _data

std::vector<std::pair<Real, std::map<std::string, std::shared_ptr<TableValueBase> > > > 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 258 of file FormattedTable.h.

Referenced by addData(), addRow(), clear(), dataLoad(), dataStore(), empty(), fillEmptyValues(), 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 308 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 270 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 294 of file FormattedTable.h.

Referenced by clear(), 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 291 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 300 of file FormattedTable.h.

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

◆ _output_time

bool FormattedTable::_output_time
private

Whether or not to output the Time column.

Definition at line 314 of file FormattedTable.h.

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


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