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