TableOutput.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 "AdvancedOutput.h"
#include "FileOutput.h"
#include "FormattedTable.h"
 
class TableOutput : public AdvancedOutput
{
public:
  static InputParameters validParams();
  static void addMultiAppFixedPointIterationEndExecFlag(InputParameters & params,
                                                        const std::string & param);
 
  TableOutput(const InputParameters & parameters);
 
  void clear();
 
protected:
  virtual void outputScalarVariables() override;
 
  virtual void outputPostprocessors() override;
 
  bool shouldOutputPostprocessorsRow(const FormattedTable & table);
 
  void outputPostprocessorsRow(FormattedTable & table);
 
  virtual void outputReporters() override;
  template <typename T>
  void outputReporter(const ReporterName & name);
 
  virtual void outputVectorPostprocessors() override;
 
  bool _tables_restartable;
 
  FormattedTable & _postprocessor_table;
 
  std::map<std::string, FormattedTable> _vector_postprocessor_tables;
 
  std::map<std::string, FormattedTable> & _vector_postprocessor_time_tables;
 
  FormattedTable & _scalar_table;
 
  FormattedTable & _reporter_table;
 
  FormattedTable & _all_data_table;
 
  const bool _check_all_columns_for_new_row;
 
  const Real _new_row_tol;
 
  const bool _time_data;
 
  const bool _time_column;
};
 
template <typename T>
void
TableOutput::outputReporter(const ReporterName & name)
{
  static_assert(TableValueBase::isSupportedType<T>(), "Unsupported table value type.");
 
  if (_reporter_data.hasReporterValue<T>(name))
  {
    if (_reporter_table.empty() || !MooseUtils::absoluteFuzzyEqual(_reporter_table.getLastTime(),
                                                                   getOutputTime(),
                                                                   _new_row_tol))
      _reporter_table.addRow(getOutputTime());
 
    if (_all_data_table.empty() || !MooseUtils::absoluteFuzzyEqual(_all_data_table.getLastTime(),
                                                                   getOutputTime(),
                                                                   _new_row_tol))
      _all_data_table.addRow(getOutputTime());
 
    const T & value = _reporter_data.getReporterValue<T>(name);
    _reporter_table.addData<T>(name.getCombinedName(), value);
    _all_data_table.addData<T>(name.getCombinedName(), value);
  }
  else if (_reporter_data.hasReporterValue<std::vector<T>>(name))
  {
    const std::string & obj_name = name.getObjectName();
    const std::string & val_name = name.getValueName();
    auto insert_pair = moose_try_emplace(_vector_postprocessor_tables, obj_name, FormattedTable());
 
    FormattedTable & table = insert_pair.first->second;
    table.outputTimeColumn(false);
 
    const std::vector<T> & vector = _reporter_data.getReporterValue<std::vector<T>>(name);
    table.addData<T>(val_name, vector);
 
    if (_time_data)
    {
      FormattedTable & t_table = _vector_postprocessor_time_tables[obj_name];
      t_table.addData("timestep", _t_step, _time);
    }
  }
}