AdvancedOutput.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 "AdvancedOutputUtils.h" // OutputDataWarehouse
#include "MooseTypes.h"
#include "UserObject.h"
#include "ExecuteMooseObjectWarehouse.h"
#include "FileOutput.h"

// Forward declarations
class OutputWarehouse;
class FileOutput;
class PetscOutput;
class Console;
class TransientMultiApp;

class AdvancedOutput : public FileOutput
{
public:
  static InputParameters validParams();

  AdvancedOutput(const InputParameters & parameters);

  virtual ~AdvancedOutput();

  virtual bool hasOutput();

  bool hasOutput(const ExecFlagType & type);

  bool hasNodalVariableOutput();

  const std::set<std::string> & getNodalVariableOutput();

  bool hasElementalVariableOutput();

  const std::set<std::string> & getElementalVariableOutput();

  bool hasScalarOutput();

  const std::set<std::string> & getScalarOutput();

  bool hasPostprocessorOutput();

  const std::set<std::string> & getPostprocessorOutput();

  bool hasVectorPostprocessorOutput();

  const std::set<std::string> & getVectorPostprocessorOutput();

  bool hasReporterOutput();

  const std::set<std::string> & getReporterOutput();

  static InputParameters enableOutputTypes(const std::string & names = std::string());

  const OutputOnWarehouse & advancedExecuteOn() const;

protected:
  virtual void initialSetup();

  virtual void init();

  void hideAdditionalVariable(const std::string & category, const std::string & var_name)
  {
    _execute_data[category].hide.insert(var_name);
    _execute_data[category].output.erase(var_name);
  }

  virtual bool shouldOutput();

  virtual void output();

  virtual void outputNodalVariables();

  virtual void outputElementalVariables();

  virtual void outputScalarVariables();

  virtual void outputPostprocessors();

  virtual void outputVectorPostprocessors();

  virtual void outputInput();

  virtual void outputSystemInformation();

  virtual void outputReporters();

  void clearLastExecuteTime();

  bool _elemental_as_nodal, _scalar_as_nodal;

  const ReporterData & _reporter_data;

private:
  void initAvailableLists();

  void initExecutionTypes(const std::string & name, ExecFlagEnum & input);

  void initShowHideLists(const std::vector<VariableName> & show,
                         const std::vector<VariableName> & hide);

  template <typename postprocessor_type>
  void initPostprocessorOrVectorPostprocessorLists(const std::string & execute_data_name);

  void initOutputList(OutputData & data);

  bool wantOutput(const std::string & name, const ExecFlagType & type);

  static void addValidParams(InputParameters & params, const MultiMooseEnum & types);

  bool hasOutputHelper(const std::string & name);

  static MultiMooseEnum getOutputTypes();

  OutputDataWarehouse _execute_data;

  std::map<std::string, Real> & _last_execute_time;

  const bool _postprocessors_as_reporters, _vectorpostprocessors_as_reporters;

  // Allow complete access
  friend class OutputWarehouse;
  friend class Console;
  friend class TransientMultiApp;
};

// Helper function for initAvailableLists, templated on warehouse type and postprocessor_type
template <typename postprocessor_type>
void
AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(const std::string & execute_data_name)
{
  // Convenience reference to the OutputData being operated on (should used "postprocessors" or
  // "vector_postprocessors")
  OutputData & execute_data = _execute_data[execute_data_name];

  // Build the input file parameter name (i.e. "output_postprocessors_on" or
  // "output_vector_postprocessors_on")
  std::ostringstream oss;
  oss << "execute_" << execute_data_name << "_on";
  std::string execute_on_name = oss.str();

  std::vector<postprocessor_type *> objs;
  if constexpr (std::is_same_v<postprocessor_type, Postprocessor>)
    _problem_ptr->theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::Postprocessor)
        .condition<AttribThread>(0)
        .queryIntoUnsorted(objs);
  else if constexpr (std::is_same_v<postprocessor_type, VectorPostprocessor>)
    _problem_ptr->theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::VectorPostprocessor)
        .condition<AttribThread>(0)
        .queryIntoUnsorted(objs);

  for (const auto & obj : objs)
  {
    execute_data.available.insert(obj->PPName());

    // Extract the list of outputs
    const auto & pps_outputs = obj->getOutputs();

    // Check that the outputs lists are valid
    _app.getOutputWarehouse().checkOutputs(pps_outputs);

    // Check that the output object allows postprocessor output,
    // account for "all" keyword (if it is present assume "all" was desired)
    if (pps_outputs.find(name()) != pps_outputs.end() ||
        pps_outputs.find("all") != pps_outputs.end())
    {
      if (!_advanced_execute_on.contains(execute_data_name) ||
          (_advanced_execute_on[execute_data_name].isValid() &&
           _advanced_execute_on[execute_data_name].isValueSet("none")))
      {
        const bool is_pp_type = (execute_data_name == "postprocessors");
        const std::string pp_type_str = is_pp_type ? "post-processor" : "vector post-processor";
        mooseWarning("The ",
                     pp_type_str,
                     " '",
                     obj->PPName(),
                     "' has requested to be output by the '",
                     name(),
                     "' output, but ",
                     pp_type_str,
                     " output is disabled for that output object.");
      }
    }
  }
}