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