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