FormattedTable.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE includes
#include "Moose.h"
#include "MooseEnum.h"
#include "DataIO.h"
#include "MooseUtils.h"
 
// C++ includes
#include <fstream>
 
// Forward declarations
class FormattedTable;
class TableValueBase;
namespace libMesh
{
class ExodusII_IO;
}
 
template <>
void dataStore(std::ostream & stream, FormattedTable & table, void * context);
template <>
void dataLoad(std::istream & stream, FormattedTable & v, void * context);
template <>
void dataStore(std::ostream & stream, TableValueBase *& value, void * context);
template <>
void dataLoad(std::istream & stream, TableValueBase *& value, void * context);
 
class TableValueBase
{
public:
  virtual ~TableValueBase() = default;
 
  template <typename T>
  static constexpr bool isSupportedType()
  {
    return std::is_fundamental<T>::value || std::is_same<T, std::string>::value;
  }
 
  virtual void print(std::ostream & os) const = 0;
 
  virtual void store(std::ostream & stream, void * context) = 0;
};
 
std::ostream & operator<<(std::ostream & os, const TableValueBase & value);
 
template <typename T>
class TableValue : public TableValueBase
{
public:
  TableValue(const T & value) : _value(value)
  {
    if (!this->isSupportedType<T>())
      mooseError("Unsupported type ", MooseUtils::prettyCppType<T>(), " for FormattedTable.");
  }
 
  const T & get() const { return _value; }
  T & set() { return _value; }
 
  virtual void print(std::ostream & os) const override { os << this->_value; };
 
  virtual void store(std::ostream & stream, void * context) override;
  static void
  load(std::istream & stream, std::shared_ptr<TableValueBase> & value_base, void * context);
 
private:
  T _value;
};
 
template <>
inline void
TableValue<bool>::print(std::ostream & os) const
{
  os << (this->_value ? "True" : "False");
}
 
template <typename T>
void
TableValue<T>::store(std::ostream & stream, void * context)
{
  std::string type = typeid(T).name();
  ::dataStore(stream, type, context);
  ::dataStore(stream, _value, context);
}
 
template <typename T>
void
TableValue<T>::load(std::istream & stream,
                    std::shared_ptr<TableValueBase> & value_base,
                    void * context)
{
  T value;
  ::dataLoad(stream, value, context);
  value_base = std::dynamic_pointer_cast<TableValueBase>(std::make_shared<TableValue<T>>(value));
}
 
class FormattedTable
{
public:
  FormattedTable();
 
  FormattedTable(const FormattedTable & o);
 
  ~FormattedTable();
 
  bool empty() const;
 
  void append(bool append_existing_file);
 
  void addRow(Real time);
 
  template <typename T = Real>
  void addData(const std::string & name, const T & value);
 
  template <typename T = Real>
  void addData(const std::string & name, const T & value, Real time);
 
  template <typename T = Real>
  void addData(const std::string & name, const std::vector<T> & vector);
 
  Real getLastTime() const;
 
  template <typename T = Real>
  T & getLastData(const std::string & name) const;
 
  void clear();
 
  void outputTimeColumn(bool output_time) { _output_time = output_time; }
 
  //  const std::map<Real, std::map<std::string, Real>> & getData() const { return _data; }
 
  void printTable(std::ostream & out, unsigned int last_n_entries = 0);
  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);
 
  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);
 
  static MooseEnum getWidthModes();
 
  void setDelimiter(std::string delimiter) { _csv_delimiter = delimiter; }
 
  void setPrecision(unsigned int precision) { _csv_precision = precision; }
 
  void setUseScientificNotation(bool use_scientific_notation)
  {
    _csv_use_scientific_notation = use_scientific_notation;
  }
 
  void sortColumns();
 
protected:
  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;
 
  std::vector<std::pair<Real, std::map<std::string, std::shared_ptr<TableValueBase>>>> _data;
 
  std::map<std::string, unsigned int> _align_widths;
 
  std::vector<std::string> _column_names;
 
  static const unsigned short _column_width;
 
  static const unsigned short _min_pps_width;
 
private:
  void close();
 
  void open(const std::string & file_name);
 
  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);
 
  std::string _output_file_name;
 
  std::ofstream _output_file;
 
  std::size_t _output_row_index;
 
  bool _headers_output;
 
  bool _append;
 
  bool _output_time;
 
  std::string _csv_delimiter;
 
  unsigned int _csv_precision;
 
  bool _csv_use_scientific_notation;
 
  bool _column_names_unsorted = true;
 
  friend void
  dataStore<FormattedTable>(std::ostream & stream, FormattedTable & table, void * context);
  friend void dataLoad<FormattedTable>(std::istream & stream, FormattedTable & v, void * context);
};
 
template <typename T>
void
FormattedTable::addData(const std::string & name, const T & value)
{
  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;
  }
}
 
template <typename T>
void
FormattedTable::addData(const std::string & name, const T & value, Real time)
{
  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;
  }
}
 
template <typename T>
void
FormattedTable::addData(const std::string & name, const std::vector<T> & vector)
{
  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;
  }
}
 
template <typename T>
T &
FormattedTable::getLastData(const std::string & name) const
{
  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();
}
 
template <>
void dataStore(std::ostream & stream, FormattedTable & table, void * context);
template <>
void dataLoad(std::istream & stream, FormattedTable & v, void * context);
template <>
void dataStore(std::ostream & stream, TableValueBase *& value, void * context);
template <>
void dataLoad(std::istream & stream, TableValueBase *& value, void * context);