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.

  : _output_row_index(0),
    _headers_output(false),
    _append(false),
    _output_time(true),
    _csv_delimiter(DEFAULT_CSV_DELIMITER),
    _csv_precision(DEFAULT_CSV_PRECISION)
{
}

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.

  : _column_names(o._column_names),
    _output_file_name(""),
    _output_row_index(o._output_row_index),
    _headers_output(o._headers_output),
    _append(o._append),
    _output_time(o._output_time),
    _csv_delimiter(o._csv_delimiter),
    _csv_precision(o._csv_precision),
    _column_names_unsorted(o._column_names_unsorted)
{
  if (_output_file.is_open())
    mooseError("Copying a FormattedTable with an open stream is not supported");

  for (const auto & it : o._data)
    _data.emplace_back(it.first, it.second);
}

~FormattedTable()

FormattedTable::~FormattedTable

(

)

The destructor is used to close the file handle.

Definition at line 171 of file FormattedTable.C.

{ close(); }

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

{
  if (empty())
    mooseError("No Data stored in the the FormattedTable");

  auto back_it = _data.rbegin();
  back_it->second[name] =
      std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(value));

  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
  {
    _column_names.push_back(name);
    _column_names_unsorted = true;
  }
}

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.

{
  auto back_it = _data.rbegin();

  mooseAssert(back_it == _data.rend() || !MooseUtils::absoluteFuzzyLessThan(time, back_it->first),
              "Attempting to add data to FormattedTable with the dependent variable in a "
              "non-increasing order.\nDid you mean to use addData(std::string &, const "
              "std::vector<Real> &)?");

  // See if the current "row" is already in the table
  if (back_it == _data.rend() || !MooseUtils::absoluteFuzzyEqual(time, back_it->first))
  {
    _data.emplace_back(time, std::map<std::string, std::shared_ptr<TableValueBase>>());
    back_it = _data.rbegin();
  }
  // Insert or update value
  back_it->second[name] =
      std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(value));

  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
  {
    _column_names.push_back(name);
    _column_names_unsorted = true;
  }
}

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.

{
  for (MooseIndex(vector) i = 0; i < vector.size(); ++i)
  {
    if (i == _data.size())
      _data.emplace_back(i, std::map<std::string, std::shared_ptr<TableValueBase>>());

    mooseAssert(MooseUtils::absoluteFuzzyEqual(_data[i].first, i),
                "Inconsistent indexing in VPP vector");

    auto & curr_entry = _data[i];
    curr_entry.second[name] =
        std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(vector[i]));
  }

  if (std::find(_column_names.begin(), _column_names.end(), name) == _column_names.end())
  {
    _column_names.push_back(name);
    _column_names_unsorted = true;
  }
}

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

{
  _data.emplace_back(time, std::map<std::string, std::shared_ptr<TableValueBase>>());
}

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

{
  _append = append_existing_file;
}

clear()

void FormattedTable::clear

(

)

Definition at line 567 of file FormattedTable.C.

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

{
  _data.clear();
  _output_file.close();
  _output_row_index = 0;
}

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

{
  if (!_output_file.is_open())
    return;
  _output_file.flush();
  _output_file.close();
  _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().

{
  return _data.empty();
}

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

{
  auto begin = _data.begin();
  auto end = _data.end();
  if (last_n_entries && (last_n_entries < _data.size()))
    begin = end - last_n_entries;

  for (auto it = begin; it != end; ++it)
  {
    auto & datamap = it->second;
    if (datamap.size() != _column_names.size())
    {
      for (const auto & col_name : _column_names)
        if (!datamap[col_name])
          datamap[col_name] =
              std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<char>>('0'));
    }
    else
    {
      for (auto & [key, val] : datamap)
        if (!val)
          val = std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<char>>('0'));
    }
  }
}

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.

{
  mooseAssert(!empty(), "No Data stored in the FormattedTable");

  auto & last_data_map = _data.rbegin()->second;
  auto it = last_data_map.find(name);
  if (it == last_data_map.end())
    mooseError("No Data found for name: " + name);

  auto value = std::dynamic_pointer_cast<TableValue<T>>(it->second);
  if (!value)
    mooseError("Data for ", name, " is not of the requested type.");
  return value->set();
}

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

{
  mooseAssert(!empty(), "No Data stored in the FormattedTable");
  return _data.rbegin()->first;
}

getWidthModes()

MooseEnum FormattedTable::getWidthModes ( )

static

Definition at line 602 of file FormattedTable.C.

Referenced by Console::validParams().

{
  return MooseEnum("ENVIRONMENT=-1 AUTO=0 80=80 120=120 160=160", "ENVIRONMENT", true);
}

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

{
  fillEmptyValues();

  // TODO: run this once at end of simulation, right now it runs every iteration
  // TODO: do I need to be more careful escaping column names?
  // Note: open and close the files each time, having open files may mess with gnuplot

  // supported filetypes: ps, png
  std::string extension, terminal;
  if (format == "png")
  {
    extension = ".png";
    terminal = "png";
  }

  else if (format == "ps")
  {
    extension = ".ps";
    terminal = "postscript";
  }

  else if (format == "gif")
  {
    extension = ".gif";
    terminal = "gif";
  }

  else
    mooseError("gnuplot format \"" + format + "\" is not supported.");

  // Write the data to disk
  std::string dat_name = base_file + ".dat";
  std::ofstream datfile;
  datfile.open(dat_name.c_str(), std::ios::trunc | std::ios::out);
  if (datfile.fail())
    mooseError("Unable to open file ", dat_name);

  datfile << "# time";
  for (const auto & col_name : _column_names)
    datfile << '\t' << col_name;
  datfile << '\n';

  for (auto & data_it : _data)
  {
    datfile << data_it.first;
    for (const auto & col_name : _column_names)
    {
      auto & tmp = data_it.second;
      datfile << '\t' << *tmp[col_name];
    }
    datfile << '\n';
  }
  datfile.flush();
  datfile.close();

  // Write the gnuplot script
  std::string gp_name = base_file + ".gp";
  std::ofstream gpfile;
  gpfile.open(gp_name.c_str(), std::ios::trunc | std::ios::out);
  if (gpfile.fail())
    mooseError("Unable to open file ", gp_name);

  gpfile << gnuplot::before_terminal << terminal << gnuplot::before_ext << extension
         << gnuplot::after_ext;

  // plot all postprocessors in one plot
  int column = 2;
  for (const auto & col_name : _column_names)
  {
    gpfile << " '" << dat_name << "' using 1:" << column << " title '" << col_name
           << "' with linespoints";
    column++;
    if (column - 2 < static_cast<int>(_column_names.size()))
      gpfile << ", \\\n";
  }
  gpfile << "\n\n";

  // plot the postprocessors individually
  column = 2;
  for (const auto & col_name : _column_names)
  {
    gpfile << "set output '" << col_name << extension << "'\n";
    gpfile << "set ylabel '" << col_name << "'\n";
    gpfile << "plot '" << dat_name << "' using 1:" << column << " title '" << col_name
           << "' with linespoints\n\n";
    column++;
  }

  gpfile.flush();
  gpfile.close();
}

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

{
  if (_output_file.is_open() && _output_file_name == file_name)
    return;
  close();
  _output_file_name = file_name;

  std::ios_base::openmode open_flags = std::ios::out;
  if (_append)
    open_flags |= std::ios::app;
  else
  {
    open_flags |= std::ios::trunc;
    _output_row_index = 0;
    _headers_output = false;
  }

  _output_file.open(file_name.c_str(), open_flags);
  if (_output_file.fail())
    mooseError("Unable to open file ", file_name);
}

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

{ _output_time = output_time; }

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

{
  fillEmptyValues();

  open(file_name);

  if (_output_row_index == 0)
  {
    if (align)
    {
      // Set the initial width to the names of the columns
      _align_widths["time"] = 4;

      for (const auto & col_name : _column_names)
        _align_widths[col_name] = col_name.size();

      // Loop through the various times
      for (const auto & it : _data)
      {
        // Update the time _align_width
        {
          std::ostringstream oss;
          oss << std::setprecision(_csv_precision) << it.first;
          unsigned int w = oss.str().size();
          _align_widths["time"] = std::max(_align_widths["time"], w);
        }

        // Loop through the data for the current time and update the _align_widths
        for (const auto & jt : it.second)
        {
          std::ostringstream oss;
          oss << std::setprecision(_csv_precision) << *jt.second;
          unsigned int w = oss.str().size();
          _align_widths[jt.first] = std::max(_align_widths[jt.first], w);
        }
      }
    }

    // Output Header
    if (!_headers_output)
    {
      if (_output_time)
      {
        if (align)
          _output_file << std::setw(_align_widths["time"]) << "time";
        else
          _output_file << "time";
        _headers_output = true;
      }

      for (const auto & col_name : _column_names)
      {
        if (_headers_output)
          _output_file << _csv_delimiter;

        if (align)
          _output_file << std::right << std::setw(_align_widths[col_name]) << col_name;
        else
          _output_file << col_name;
        _headers_output = true;
      }
      _output_file << "\n";
    }
  }

  for (; _output_row_index < _data.size(); ++_output_row_index)
  {
    if (_output_row_index % interval == 0)
      printRow(_data[_output_row_index], align);
  }

  _output_file.flush();
}

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

{
  out.fill(fill_char);
  out << std::right << intersect_char;
  if (_output_time)
    out << std::setw(_column_width + 2) << intersect_char;
  for (auto header_it = col_begin; header_it != col_end; ++header_it)
    out << std::setw(col_widths[*header_it] + 2) << intersect_char;
  out << "\n";

  // Clear the fill character
  out.fill(' ');
}

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

{
  printNoDataRow(':', ' ', out, col_widths, col_begin, col_end);
}

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

{
  bool first = true;

  if (_output_time)
  {
    if (align)
      _output_file << std::setprecision(_csv_precision) << std::right
                   << std::setw(_align_widths["time"]) << row_data.first;
    else
      _output_file << std::setprecision(_csv_precision) << row_data.first;
    first = false;
  }

  for (const auto & col_name : _column_names)
  {
    std::map<std::string, std::shared_ptr<TableValueBase>> & tmp = row_data.second;

    if (!first)
      _output_file << _csv_delimiter;
    else
      first = false;

    if (align)
      _output_file << std::setprecision(_csv_precision) << std::right
                   << std::setw(_align_widths[col_name]) << *tmp[col_name];
    else
      _output_file << std::setprecision(_csv_precision) << *tmp[col_name];
  }
  _output_file << "\n";
}

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

{
  printNoDataRow('+', '-', out, col_widths, col_begin, col_end);
}

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

{
  printTable(out, last_n_entries, MooseEnum("ENVIRONMENT=-1", "ENVIRONMENT"));
}

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.

{
  unsigned short term_width;

  if (suggested_term_width == "ENVIRONMENT")
    term_width = MooseUtils::getTermWidth(true);
  else if (suggested_term_width == "AUTO")
    term_width = MooseUtils::getTermWidth(false);
  else
    term_width = MooseUtils::stringToInteger(suggested_term_width);

  if (term_width < _min_pps_width)
    term_width = _min_pps_width;

  std::vector<std::string>::iterator col_it = _column_names.begin();
  std::vector<std::string>::iterator col_end = _column_names.end();

  std::vector<std::string>::iterator curr_begin = col_it;
  std::vector<std::string>::iterator curr_end;
  while (col_it != col_end)
  {
    std::map<std::string, unsigned short> col_widths;
    unsigned int curr_width = _column_width + 4;
    unsigned int cols_in_group = 0;
    while (curr_width < term_width && col_it != col_end)
    {
      curr_end = col_it;
      col_widths[*col_it] = col_it->length() > _column_width ? col_it->length() + 1 : _column_width;

      curr_width += col_widths[*col_it] + 3;
      ++col_it;
      ++cols_in_group;
    }
    if (col_it != col_end && cols_in_group >= 2)
    {
      // curr_width -= col_widths[*curr_end];
      col_widths.erase(*curr_end);
      col_it = curr_end;
    }
    else
      curr_end = col_it;

    printTablePiece(out, last_n_entries, col_widths, curr_begin, curr_end);
    curr_begin = curr_end;
  }
}

printTable() [3/3]

void FormattedTable::printTable

(

const std::string &

file_name

)

Definition at line 237 of file FormattedTable.C.

{
  open(file_name);
  printTable(_output_file);
}

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

{
  fillEmptyValues(last_n_entries);
  printRowDivider(out, col_widths, col_begin, col_end);
  out << "|";
  if (_output_time)
    out << std::setw(_column_width) << std::left << " time" << " |";
  for (auto header_it = col_begin; header_it != col_end; ++header_it)
    out << " " << std::setw(col_widths[*header_it]) << *header_it << "|";
  out << "\n";
  printRowDivider(out, col_widths, col_begin, col_end);

  auto data_it = _data.begin();
  if (last_n_entries)
  {
    if (_data.size() > last_n_entries)
    {
      // Print a blank row to indicate that values have been ommited
      printOmittedRow(out, col_widths, col_begin, col_end);

      // Jump to the right place in the vector
      data_it += _data.size() - last_n_entries;
    }
  }
  // Now print the remaining data rows
  for (; data_it != _data.end(); ++data_it)
  {
    out << "|";
    if (_output_time)
      out << std::right << std::setw(_column_width) << std::scientific << data_it->first << " |";
    for (auto header_it = col_begin; header_it != col_end; ++header_it)
    {
      auto & tmp = data_it->second;
      out << std::setw(col_widths[*header_it]) << *tmp[*header_it] << " |";
    }
    out << "\n";
  }

  printRowDivider(out, col_widths, col_begin, col_end);
}

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

{ _csv_delimiter = delimiter; }

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

{ _csv_precision = precision; }

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

{
  if (_column_names_unsorted)
  {
    std::sort(_column_names.begin(), _column_names.end());
    _column_names_unsorted = false;
  }
}

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.

{
  loadHelper(stream, table._data, context);
  loadHelper(stream, table._align_widths, context);
  loadHelper(stream, table._column_names, context);
  loadHelper(stream, table._output_row_index, context);
  loadHelper(stream, table._headers_output, context);
}

dataStore

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

friend

Definition at line 27 of file FormattedTable.C.

{
  table.fillEmptyValues();
  storeHelper(stream, table._data, context);
  storeHelper(stream, table._align_widths, context);
  storeHelper(stream, table._column_names, context);
  storeHelper(stream, table._output_row_index, context);
  storeHelper(stream, table._headers_output, context);
}

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:

• include/utils/FormattedTable.h
• src/utils/FormattedTable.C