ProjectedStatefulMaterialStorageAction.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 "Action.h"
#include "Registry.h"
#include "Conversion.h"
#include "SerialAccess.h"
#include "RankTwoTensorForward.h"
#include "RankFourTensorForward.h"
#include "libmesh/fe_type.h"
 
// created types
#include "InterpolatedStatefulMaterial.h"
#include "ProjectedStatefulMaterialAux.h"
#include "ProjectedStatefulMaterialNodalPatchRecovery.h"
 
class ProjectedStatefulMaterialStorageAction : public Action
{
public:
  static InputParameters validParams();
 
  ProjectedStatefulMaterialStorageAction(const InputParameters & parameters);
 
  virtual void act() override;
 
  using Action::addRelationshipManagers;
  virtual void addRelationshipManagers(Moose::RelationshipManagerType input_rm_type) override;
 
  typedef Moose::TypeList<Real, RealVectorValue, RankTwoTensor, RankFourTensor> SupportedTypes;
 
  static MooseEnum getTypeEnum();
 
  template <typename T, bool is_ad>
  void processProperty(const MaterialPropertyName & prop_name);
 
protected:
  template <typename T, int I>
  struct ProcessProperty
  {
    static void apply(ProjectedStatefulMaterialStorageAction * self,
                      const MaterialPropertyName & prop_name)
    {
      self->processProperty<T, false>(prop_name);
      self->processProperty<T, true>(prop_name);
    }
  };
 
  template <typename... Ts>
  static MooseEnum getTypeEnum(typename Moose::TypeList<Ts...>);
 
  const std::vector<MaterialPropertyName> & _prop_names;
 
  const MooseEnum _order;
 
  FEType _fe_type;
 
  const std::string _var_type;
};
 
template <typename... Ts>
MooseEnum
ProjectedStatefulMaterialStorageAction::getTypeEnum(Moose::TypeList<Ts...>)
{
  return MooseEnum(Moose::stringify(std::vector<std::string>{typeid(Ts).name()...}, " "));
}
 
template <typename T, bool is_ad>
void
ProjectedStatefulMaterialStorageAction::processProperty(const MaterialPropertyName & prop_name)
{
  // check if a property of type T exists
  const auto & block_data = _problem->getMaterialData(Moose::BLOCK_MATERIAL_DATA);
  const auto & boundary_data = _problem->getMaterialData(Moose::BOUNDARY_MATERIAL_DATA);
  if (!block_data.haveGenericProperty<T, is_ad>(prop_name) &&
      !boundary_data.haveGenericProperty<T, is_ad>(prop_name))
    return;
 
  // number of scalar components
  const auto size = Moose::SerialAccess<T>::size();
 
  // generate variable names
  std::vector<VariableName> vars;
  for (const auto i : make_range(size))
    vars.push_back("_var_" + prop_name + '_' + Moose::stringify(i));
 
  if (_current_task == "setup_projected_properties")
  {
    // add the AuxVars for storage
    for (const auto & var : vars)
    {
      auto params = _factory.getValidParams(_var_type);
      params.applyParameters(parameters());
      params.set<std::vector<OutputName>>("outputs") = {"none"};
      _problem->addAuxVariable(_var_type, var, params);
    }
 
    // add material
    {
      const auto type = Registry::getClassName<InterpolatedStatefulMaterialTempl<T>>();
      auto params = _factory.getValidParams(type);
      params.applySpecificParameters(parameters(), {"block"});
      params.template set<std::vector<VariableName>>("old_state") = vars;
      params.template set<MaterialPropertyName>("prop_name") = prop_name;
      _problem->addMaterial(type, "_mat_" + prop_name, params);
    }
 
    // use nodal patch recovery for lagrange
    if (_fe_type.family == LAGRANGE)
    {
      // nodal variables require patch recovery (add user object)
      const auto & type =
          Registry::getClassName<ProjectedStatefulMaterialNodalPatchRecoveryTempl<T, is_ad>>();
      auto params = _factory.getValidParams(type);
      params.applySpecificParameters(parameters(), {"block"});
      params.template set<MaterialPropertyName>("property") = prop_name;
      params.template set<MooseEnum>("patch_polynomial_order") = _order;
      params.template set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
      params.template set<bool>("force_preaux") = true;
      _problem->addUserObject(type, "_npruo_" + prop_name, params);
    }
  }
 
  if (_current_task == "add_aux_kernel")
  {
    // create variables
    std::vector<std::string> auxnames;
    for (const auto i : make_range(size))
      auxnames.push_back("_aux_" + prop_name + '_' + Moose::stringify(i));
 
    // use nodal patch recovery for lagrange
    if (_fe_type.family == LAGRANGE)
    {
      // nodal variables require patch recovery (add aux kernel)
      const auto & type = "ProjectedMaterialPropertyNodalPatchRecoveryAux";
      for (const auto i : make_range(size))
      {
        auto params = _factory.getValidParams(type);
        params.applySpecificParameters(parameters(), {"block"});
        params.template set<AuxVariableName>("variable") = vars[i];
        params.template set<unsigned int>("component") = i;
        params.template set<UserObjectName>("nodal_patch_recovery_uo") = "_npruo_" + prop_name;
        params.template set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
        _problem->addAuxKernel(type, auxnames[i], params);
      }
    }
    else
    {
      // elemental variables
      const auto & type = Registry::getClassName<ProjectedStatefulMaterialAuxTempl<T, is_ad>>();
      for (const auto i : make_range(size))
      {
        auto params = _factory.getValidParams(type);
        params.applySpecificParameters(parameters(), {"block"});
        params.template set<AuxVariableName>("variable") = vars[i];
        params.template set<unsigned int>("component") = i;
        params.template set<MaterialPropertyName>("prop") = prop_name;
        params.template set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
        _problem->addAuxKernel(type, auxnames[i], params);
      }
    }
  }
}