FunctorChangeFunctorMaterial.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 "FunctorChangeFunctorMaterial.h"
 
registerMooseObject("MooseApp", FunctorChangeFunctorMaterial);
registerMooseObject("MooseApp", ADFunctorChangeFunctorMaterial);
 
template <bool is_ad>
InputParameters
FunctorChangeFunctorMaterialTempl<is_ad>::validParams()
{
  InputParameters params = FunctorMaterial::validParams();
  params.set<ExecFlagEnum>("execute_on") = {EXEC_ALWAYS};
 
  params.addRequiredParam<MooseFunctorName>("functor", "Functor for which to compute the change");
  MooseEnum change_over(
      "time_step nonlinear fixed_point multiapp_fixed_point multisystem_fixed_point");
  change_over.addDocumentation("time_step", "Over the time step");
  change_over.addDocumentation("nonlinear", "Over the nonlinear iteration");
  change_over.addDocumentation("multiapp_fixed_point", "Over the MultiApp fixed point iteration");
  change_over.addDocumentation("multisystem_fixed_point",
                               "Over the multi-system fixed point iteration");
  params.addRequiredParam<MooseEnum>(
      "change_over", change_over, "Interval over which to compute the change");
  params.addRequiredParam<bool>("take_absolute_value",
                                "If true, take the absolute value of the change.");
  params.addRequiredParam<std::string>("prop_name",
                                       "The name to give the functor material property");
 
  params.addClassDescription(
      "Adds a functor material property that computes the change in a functor value over a time "
      "step, fixed point iteration, or nonlinear iteration.");
 
  return params;
}
 
template <bool is_ad>
FunctorChangeFunctorMaterialTempl<is_ad>::FunctorChangeFunctorMaterialTempl(
    const InputParameters & parameters)
  : FunctorMaterial(parameters),
    _functor(getFunctor<GenericReal<is_ad>>("functor")),
    _ref_state(referenceState(getParam<MooseEnum>("change_over"))),
    _take_absolute_value(getParam<bool>("take_absolute_value")),
    _prop_name(getParam<std::string>("prop_name"))
{
  // Request the previous fixed point solution be saved for the relevant systems
  const auto & change_over = getParam<MooseEnum>("change_over");
  if (change_over == "multiapp_fixed_point" || change_over == "fixed_point")
  {
    if (_fe_problem.hasAuxiliaryVariable(getParam<MooseFunctorName>("functor")))
      _fe_problem.needsPreviousMultiAppFixedPointIterationAuxiliary(true);
    if (_fe_problem.hasSolverVariable(getParam<MooseFunctorName>("functor")))
      _fe_problem.needsPreviousMultiAppFixedPointIterationSolution(
          true, _fe_problem.getSystem(getParam<MooseFunctorName>("functor")).number());
  }
  else if (change_over == "multisystem_fixed_point")
  {
    if (_fe_problem.hasAuxiliaryVariable(getParam<MooseFunctorName>("functor")))
      _fe_problem.needsPreviousMultiSystemFixedPointIterationAuxiliary(true);
    if (_fe_problem.hasSolverVariable(getParam<MooseFunctorName>("functor")))
      _fe_problem.needsPreviousMultiSystemFixedPointIterationSolution(
          true, _fe_problem.getSystem(getParam<MooseFunctorName>("functor")).number());
  }
 
  if (change_over == "fixed_point")
    mooseDeprecated(
        "'change_over' option 'fixed_point' is deprecated; use 'multiapp_fixed_point' instead.");
 
  const std::set<ExecFlagType> clearance_schedule(_execute_enum.begin(), _execute_enum.end());
  addFunctorProperty<GenericReal<is_ad>>(
      _prop_name,
      [this](const auto & r, const auto & t) -> GenericReal<is_ad>
      {
        mooseAssert(t == Moose::currentState(),
                    "The functor properties defined by (AD)FunctorChangeFunctorMaterial objects "
                    "may only be evaluated at the current state.");
 
        const auto change = _functor(r, t) - _functor(r, _ref_state);
        if (_take_absolute_value)
        {
          using std::abs;
          return abs(change);
        }
        else
          return change;
      },
      clearance_schedule);
}
 
template <bool is_ad>
Moose::StateArg
FunctorChangeFunctorMaterialTempl<is_ad>::referenceState(const MooseEnum & change_over) const
{
  if (change_over == "time_step")
    return Moose::oldState();
  else if (change_over == "nonlinear")
  {
    _fe_problem.needSolutionState(1, Moose::SolutionIterationType::Nonlinear);
    return Moose::previousNonlinearState();
  }
  else if (change_over == "multiapp_fixed_point" || change_over == "fixed_point")
  {
    _fe_problem.needSolutionState(1, Moose::SolutionIterationType::MultiAppFixedPoint);
    return Moose::previousMultiAppFixedPointState();
  }
  else if (change_over == "multisystem_fixed_point")
  {
    _fe_problem.needSolutionState(1, Moose::SolutionIterationType::MultiSystemFixedPoint);
    return Moose::previousMultiSystemFixedPointState();
  }
  else
    mooseError("Invalid value");
}
 
template class FunctorChangeFunctorMaterialTempl<false>;
template class FunctorChangeFunctorMaterialTempl<true>;