MooseObject.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
 
// MOOSE includes
#include "MooseObject.h"
#include "MooseApp.h"
#include "MooseUtils.h"
#include "Factory.h"
 
class FEProblem;
class FEProblemBase;
class EigenProblem;
class SubProblem;
class SystemBase;
class AuxiliarySystem;
class TransientBase;
 
InputParameters
MooseObject::validParams()
{
  InputParameters params = ParallelParamObject::validParams();
  params.addParam<bool>("enable", true, "Set the enabled status of the MooseObject.");
  params.addParam<std::vector<std::string>>(
      "control_tags",
      "Adds user-defined labels for accessing object parameters via control logic.");
  params.addParamNamesToGroup("enable control_tags", "Advanced");
  params.addPrivateParam<FEProblem *>("_fe_problem", nullptr);
  params.addPrivateParam<FEProblemBase *>("_fe_problem_base", nullptr);
  params.addPrivateParam<EigenProblem *>("_eigen_problem", nullptr);
  params.addPrivateParam<SubProblem *>("_subproblem", nullptr);
  params.addPrivateParam<SystemBase *>("_sys", nullptr);
  params.addPrivateParam<SystemBase *>("_nl_sys", nullptr);
  params.addPrivateParam<TransientBase *>("_executioner", nullptr);
  params.addPrivateParam<THREAD_ID>("_tid");
  params.addPrivateParam<bool>("_residual_object", false);
  return params;
}
 
MooseObject::MooseObject(const InputParameters & parameters)
  : ParallelParamObject(parameters),
    SolutionInvalidInterface(this, parameters),
    _enabled(getParam<bool>("enable"))
{
  if (Registry::isRegisteredObj(type()) && _app.getFactory().currentlyConstructing() != &parameters)
    mooseError(
        "This registered object was not constructed using the Factory, which is not supported.");
}
 
namespace
{
const std::string not_shared_error =
    "MooseObject::getSharedPtr() must only be called for objects that are managed by a "
    "shared pointer. Make sure this object is build using Factory::create(...).";
}
 
#ifdef MOOSE_KOKKOS_ENABLED
MooseObject::MooseObject(const MooseObject & object, const Moose::Kokkos::FunctorCopy & key)
  : ParallelParamObject(object), SolutionInvalidInterface(object, key), _enabled(object._enabled)
{
}
#endif
 
std::shared_ptr<MooseObject>
MooseObject::getSharedPtr()
{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}
 
std::shared_ptr<const MooseObject>
MooseObject::getSharedPtr() const
{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}