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);