MaterialAuxBase.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

// MOOSE includes
#include "AuxKernel.h"
#include "Assembly.h"

#include <unordered_set>

template <typename T, bool is_ad, bool is_functor = false, typename RT = Real>
class MaterialAuxBaseTempl : public AuxKernelTempl<RT>
{
public:
  static InputParameters validParams();

  MaterialAuxBaseTempl(const InputParameters & parameters);

  using PropertyType = typename std::conditional<is_functor,
                                                 Moose::Functor<Moose::GenericType<T, is_ad>>,
                                                 GenericMaterialProperty<T, is_ad>>::type;

protected:
  virtual RT computeValue() override;

  virtual void checkFullValue() {}

  virtual RT getRealValue() = 0;

  const PropertyType & _prop;

  const unsigned int _selected_qp;

  Moose::GenericType<T, is_ad> _full_value;

private:
  const PropertyType & getPropertyHelper();

  const Real _factor;

  const RT _offset;

  const SubdomainID & _current_subdomain_id;
};

template <typename T, bool is_ad, bool is_functor, typename RT>
InputParameters
MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::validParams()
{
  InputParameters params = AuxKernelTempl<RT>::validParams();
  if constexpr (is_functor)
    params.addRequiredParam<MooseFunctorName>("functor", "The functor name.");
  else
    params.addRequiredParam<MaterialPropertyName>("property", "The material property name.");

  params.addParam<Real>(
      "factor", 1, "The factor by which to multiply your material property for visualization");
  params.addParam<RT>("offset", 0, "The offset to add to your material property for visualization");

  if constexpr (!is_functor)
  {
    params.addParam<unsigned int>(
        "selected_qp",
        "Evaluate the material property at a specified quadrature point. This only needs "
        "to be used if you are interested in a particular quadrature point in each element. "
        "Otherwise do not include this parameter in your input file.");
    params.addParamNamesToGroup("selected_qp", "Advanced");
  }

  return params;
}

template <typename T, bool is_ad, bool is_functor, typename RT>
MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::MaterialAuxBaseTempl(
    const InputParameters & parameters)
  : AuxKernelTempl<RT>(parameters),
    _prop(getPropertyHelper()),
    _selected_qp(this->isParamValid("selected_qp")
                     ? this->template getParam<unsigned int>("selected_qp")
                     : libMesh::invalid_uint),
    _factor(this->template getParam<Real>("factor")),
    _offset(this->template getParam<RT>("offset")),
    _current_subdomain_id(this->_assembly.currentSubdomainID())
{
}

template <typename T, bool is_ad, bool is_functor, typename RT>
const typename MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::PropertyType &
MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::getPropertyHelper()
{
  if constexpr (is_functor)
    return this->template getFunctor<Moose::GenericType<T, is_ad>>("functor");
  else
    return this->template getGenericMaterialProperty<T, is_ad>("property");
}

template <typename T, bool is_ad, bool is_functor, typename RT>
RT
MaterialAuxBaseTempl<T, is_ad, is_functor, RT>::computeValue()
{
  // Functor Values
  if constexpr (is_functor)
  {
    if (this->isNodal())
    {
      const std::set<SubdomainID> sub_id_set = {_current_subdomain_id};
      const Moose::NodeArg node_arg{this->_current_node, &sub_id_set};
      const auto state = this->determineState();
      _full_value = _prop(node_arg, state);
    }
    else
    {
      const auto elem_arg = this->makeElemArg(this->_current_elem);
      const auto state = this->determineState();
      _full_value = _prop(elem_arg, state);
    }
  }
  // Material Properties
  else
  {
    if (_selected_qp != libMesh::invalid_uint)
    {
      if (_selected_qp >= this->_q_point.size())
      {
        Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
        this->paramError("selected_qp",
                         "Trying to evaluate qp ",
                         _selected_qp,
                         " but there are only ",
                         this->_q_point.size(),
                         " quadrature points in the element");
      }
      _full_value = _prop[_selected_qp];
    }
    else
      _full_value = _prop[this->_qp];
  }

  checkFullValue();
  return _factor * getRealValue() + _offset;
}

template <typename T = Real>
using MaterialAuxBase = MaterialAuxBaseTempl<T, false, false, Real>;