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