UserObjectInterface.C

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

#include "UserObjectInterface.h"

// MOOSE includes
#include "FEProblemBase.h"
#include "DiscreteElementUserObject.h"
#include "ThreadedGeneralUserObject.h"
#include "MooseObject.h"

InputParameters
UserObjectInterface::validParams()
{
  return emptyInputParameters();
}

UserObjectInterface::UserObjectInterface(const MooseObject * moose_object)
  : _uoi_moose_object(*moose_object),
    _uoi_feproblem(*_uoi_moose_object.parameters().getCheckedPointerParam<FEProblemBase *>(
        "_fe_problem_base")),
    _uoi_tid(_uoi_moose_object.parameters().have_parameter<THREAD_ID>("_tid")
                 ? _uoi_moose_object.parameters().get<THREAD_ID>("_tid")
                 : 0)
{
}

#ifdef MOOSE_KOKKOS_ENABLED
UserObjectInterface::UserObjectInterface(const UserObjectInterface & object,
                                         const Moose::Kokkos::FunctorCopy &)
  : _uoi_moose_object(object._uoi_moose_object),
    _uoi_feproblem(object._uoi_feproblem),
    _uoi_tid(object._uoi_tid)
{
}
#endif

UserObjectName
UserObjectInterface::getUserObjectName(const std::string & param_name) const
{
  const auto & params = _uoi_moose_object.parameters();

  if (!params.isParamValid(param_name))
    _uoi_moose_object.mooseError("Failed to get a parameter with the name \"",
                                 param_name,
                                 "\" when getting a UserObjectName.",
                                 "\n\nKnown parameters:\n",
                                 _uoi_moose_object.parameters());

  // Other interfaces will use this interface (PostprocessorInterface, VectorPostprocessorInterface)
  // to grab UOs with a specialized name, so we need to check them all
  UserObjectName name;
  if (params.isType<UserObjectName>(param_name))
    name = params.get<UserObjectName>(param_name);
  else if (params.isType<PostprocessorName>(param_name))
    name = params.get<PostprocessorName>(param_name);
  else if (params.isType<VectorPostprocessorName>(param_name))
    name = params.get<VectorPostprocessorName>(param_name);
  else if (params.isType<std::string>(param_name))
    name = params.get<std::string>(param_name);
  else
    _uoi_moose_object.paramError(
        param_name,
        "Parameter of type \"",
        params.type(param_name),
        "\" is not an expected type for getting the name of a UserObject.");

  return name;
}

bool
UserObjectInterface::hasUserObject(const std::string & param_name) const
{
  return hasUserObjectByName(getUserObjectName(param_name));
}

bool
UserObjectInterface::hasUserObjectByName(const UserObjectName & object_name) const
{
  bool flag = _uoi_feproblem.hasUserObject(object_name);

#ifdef MOOSE_KOKKOS_ENABLED
  flag = flag || _uoi_feproblem.hasKokkosUserObject(object_name);
#endif

  return flag;
}

const UserObjectBase &
UserObjectInterface::getUserObjectFromFEProblem(const UserObjectName & object_name,
                                                const THREAD_ID tid) const
{
  const UserObjectBase * uo = nullptr;

  if (_uoi_feproblem.hasUserObject(object_name))
    uo = &_uoi_feproblem.getUserObjectBase(object_name, tid);

#ifdef MOOSE_KOKKOS_ENABLED
  if (_uoi_feproblem.hasKokkosUserObject(object_name))
    uo = &_uoi_feproblem.getKokkosUserObject<UserObjectBase>(object_name);
#endif

  mooseAssert(uo, "getUserObjectFromFEProblem() could not find user object");

  return *uo;
}

const UserObjectBase &
UserObjectInterface::getUserObjectBase(const std::string & param_name,
                                       const bool is_dependency) const
{
  const auto object_name = getUserObjectName(param_name);
  if (!hasUserObjectByName(object_name))
    _uoi_moose_object.paramError(
        param_name, "The requested UserObject with the name \"", object_name, "\" was not found.");

  return getUserObjectBaseByName(object_name, is_dependency);
}

const UserObjectBase &
UserObjectInterface::getUserObjectBaseByName(const UserObjectName & object_name,
                                             const bool is_dependency) const
{
  if (!hasUserObjectByName(object_name))
    _uoi_moose_object.mooseError(
        "The requested UserObject with the name \"", object_name, "\" was not found.");

  const auto & uo_base_tid0 = getUserObjectFromFEProblem(object_name);
  if (is_dependency)
    addUserObjectDependencyHelper(uo_base_tid0);

  const THREAD_ID tid = uo_base_tid0.needThreadedCopy() ? _uoi_tid : 0;
  return getUserObjectFromFEProblem(object_name, tid);
}

const std::string &
UserObjectInterface::userObjectType(const UserObjectBase & uo) const
{
  return uo.type();
}

const std::string &
UserObjectInterface::userObjectName(const UserObjectBase & uo) const
{
  return uo.name();
}

void
UserObjectInterface::mooseObjectError(const std::string & param_name, std::stringstream & oss) const
{
  if (_uoi_moose_object.parameters().isParamValid(param_name))
    _uoi_moose_object.paramError(param_name, oss.str());
  else
    _uoi_moose_object.mooseError(oss.str());
}