PostprocessorInterface.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
 
// Standard includes
#include <string>
 
// MOOSE includes
#include "MooseTypes.h"
 
// Forward Declarations
class FEProblemBase;
class InputParameters;
class PostprocessorName;
class MooseObject;
 
#define usingPostprocessorInterfaceMembers                                                         \
  using PostprocessorInterface::getPostprocessorValue;                                             \
  using PostprocessorInterface::getPostprocessorValueOld;                                          \
  using PostprocessorInterface::getPostprocessorValueOlder;                                        \
  using PostprocessorInterface::coupledPostprocessors
 
class PostprocessorInterface
{
public:
  PostprocessorInterface(const MooseObject * moose_object);
 
  PostprocessorInterface(const FEProblemBase * problem);
 
#ifdef MOOSE_KOKKOS_ENABLED
  PostprocessorInterface(const PostprocessorInterface & object,
                         const Moose::Kokkos::FunctorCopy & key);
#endif
 
  static InputParameters validParams();
 
 
  const PostprocessorValue & getPostprocessorValue(const std::string & param_name,
                                                   const unsigned int index = 0) const;
  const PostprocessorValue & getPostprocessorValueOld(const std::string & param_name,
                                                      const unsigned int index = 0) const;
  const PostprocessorValue & getPostprocessorValueOlder(const std::string & param_name,
                                                        const unsigned int index = 0) const;
  // doco-normal-methods-end
 
 
 
  virtual const PostprocessorValue &
  getPostprocessorValueByName(const PostprocessorName & name) const;
  const PostprocessorValue & getPostprocessorValueOldByName(const PostprocessorName & name) const;
  const PostprocessorValue & getPostprocessorValueOlderByName(const PostprocessorName & name) const;
 
  bool isDefaultPostprocessorValue(const std::string & param_name,
                                   const unsigned int index = 0) const;
 
  bool hasPostprocessor(const std::string & param_name, const unsigned int index = 0) const;
 
  bool hasPostprocessorByName(const PostprocessorName & name) const;
 
  std::size_t coupledPostprocessors(const std::string & param_name) const;
 
  const PostprocessorName & getPostprocessorName(const std::string & param_name,
                                                 const unsigned int index = 0) const;
 
protected:
  virtual void addPostprocessorDependencyHelper(const PostprocessorName & /* name */) const {}
 
private:
  const MooseObject & _ppi_moose_object;
 
  const InputParameters & _ppi_params;
 
  const FEProblemBase & _ppi_feproblem;
 
  mutable std::map<PostprocessorName, std::unique_ptr<PostprocessorValue>> _default_values;
 
  const PostprocessorName &
  getPostprocessorNameInternal(const std::string & param_name,
                               const unsigned int index,
                               const bool allow_default_value = true) const;
 
  const PostprocessorValue & getPostprocessorValueInternal(const std::string & param_name,
                                                           unsigned int index,
                                                           std::size_t t_index) const;
  const PostprocessorValue & getPostprocessorValueByNameInternal(const PostprocessorName & name,
                                                                 std::size_t t_index) const;
 
  bool isDefaultPostprocessorValueByName(const PostprocessorName & name) const;
 
  PostprocessorValue getDefaultPostprocessorValueByName(const PostprocessorName & name) const;
 
  void checkParam(const std::string & param_name,
                  const unsigned int index = std::numeric_limits<unsigned int>::max()) const;
 
  bool postprocessorsAdded() const;
};