FunctorInterface.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
 
#include "ADReal.h"
#include "MooseTypes.h"
#include "SubProblem.h"
#include "MooseFunctorForward.h"
 
#include <vector>
#include <memory>
#include <string>
 
class InputParameters;
class MooseObject;
 
class FunctorInterface
{
public:
  static InputParameters validParams();
 
  FunctorInterface(const MooseObject * moose_object);
 
#ifdef MOOSE_KOKKOS_ENABLED
  FunctorInterface(const FunctorInterface & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  static std::string deduceFunctorName(const std::string & name, const InputParameters & params);
 
protected:
  template <typename T>
  const Moose::Functor<T> & getFunctor(const std::string & name);
 
  template <typename T>
  const Moose::Functor<T> & getFunctor(const std::string & name, THREAD_ID tid);
 
  template <typename T>
  const Moose::Functor<T> & getFunctor(const std::string & name, SubProblem & subproblem);
 
  template <typename T>
  const Moose::Functor<T> &
  getFunctor(const std::string & name, SubProblem & subproblem, THREAD_ID tid);
 
  bool isFunctor(const std::string & name) const;
 
  bool isFunctor(const std::string & name, const SubProblem & subproblem) const;
 
  std::string deduceFunctorName(const std::string & name) const;
 
  Moose::ElemArg makeElemArg(const Elem * elem, bool correct_skewnewss = false) const;
 
  template <typename T>
  void checkFunctorSupportsSideIntegration(const std::string & name, bool qp_integration);
 
  template <typename T>
  const Moose::Functor<T> & getFunctorByName(const std::string & name);
 
private:
  template <typename T>
  const Moose::Functor<T> &
  getFunctorByName(const std::string & name, SubProblem & subproblem, THREAD_ID tid);
 
  virtual bool isADObject() const = 0;
 
  template <typename T>
  const Moose::Functor<T> * defaultFunctor(const std::string & name);
 
  const InputParameters & _fi_params;
 
  const std::string _fi_name;
 
  SubProblem * const _fi_subproblem;
 
  const THREAD_ID _fi_tid;
 
  std::vector<std::unique_ptr<Moose::Functor<Real>>> _default_real_functors;
 
  std::vector<std::unique_ptr<Moose::Functor<ADReal>>> _default_ad_real_functors;
};
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctor(const std::string & name, SubProblem & subproblem, const THREAD_ID tid)
{
  // Check if the supplied parameter is a valid input parameter key
  std::string functor_name = deduceFunctorName(name);
  return getFunctorByName<T>(functor_name, subproblem, tid);
}
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctor(const std::string & name, SubProblem & subproblem)
{
  return getFunctor<T>(name, subproblem, _fi_tid);
}
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctor(const std::string & name, const THREAD_ID tid)
{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, tid);
}
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctor(const std::string & name)
{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, _fi_tid);
}
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctorByName(const std::string & name)
{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctorByName<T>(name, *_fi_subproblem, _fi_tid);
}
 
template <typename T>
const Moose::Functor<T> &
FunctorInterface::getFunctorByName(const std::string & name,
                                   SubProblem & subproblem,
                                   const THREAD_ID tid)
{
  // Check if it's just a constant
  const auto * const default_functor = defaultFunctor<T>(name);
  if (default_functor)
    return *default_functor;
 
  return subproblem.getFunctor<T>(name, tid, _fi_name, isADObject());
}
 
template <>
const Moose::Functor<Real> * FunctorInterface::defaultFunctor<Real>(const std::string & name);
 
template <>
const Moose::Functor<ADReal> * FunctorInterface::defaultFunctor<ADReal>(const std::string & name);
 
// General version for types that do not accept default values
template <typename T>
const Moose::Functor<T> *
FunctorInterface::defaultFunctor(const std::string & /*name*/)
{
  return nullptr;
}
 
template <typename T>
void
FunctorInterface::checkFunctorSupportsSideIntegration(const std::string & name, bool qp_integration)
{
  const std::string functor_name = deduceFunctorName(name);
  const auto & functor = getFunctor<T>(name);
  if (qp_integration)
  {
    if (!functor.supportsElemSideQpArg())
      mooseError("Quadrature point integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
  else
  {
    if (!functor.supportsFaceArg())
      mooseError("Face info integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
}