NEML2Action.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 <memory>
 
#ifdef NEML2_ENABLED
#include "neml2/models/Model.h"
#endif
 
#include "Action.h"
#include "NEML2Utils.h"
#include "DerivativeMaterialPropertyNameInterface.h"
 
class NEML2ActionCommon;
 
class NEML2Action : public Action, public DerivativeMaterialPropertyNameInterface
{
public:
  static InputParameters validParams();
 
  NEML2Action(const InputParameters &);
 
  virtual void act() override;
 
protected:
  const NEML2ActionCommon & getCommonAction() const;
 
#ifdef NEML2_ENABLED
 
  const FileName & fname() const { return _fname; }
 
  struct VariableMapping
  {
    std::string name;
    NEML2Utils::MOOSEIOType moose_type;
    neml2::TensorType neml2_type;
    std::size_t history_order;
  };
 
  struct ParameterMapping
  {
    std::string name;
    NEML2Utils::MOOSEIOType moose_type;
    neml2::TensorType neml2_type;
  };
 
  struct DerivativeMapping
  {
    std::string name;
    std::string y;
    std::string x;
  };
 
  void setupInputMappings(const neml2::Model &);
 
  void setupOutputMappings(const neml2::Model &);
 
  void setupParameterMappings(const neml2::Model &);
 
  void setupDerivativeMappings(const neml2::Model &);
 
  void setupParameterDerivativeMappings(const neml2::Model &);
 
  NEML2Utils::MOOSEIOType inferMOOSEIOType(const neml2::VariableName & name,
                                           const neml2::TensorType & type) const;
 
  FileName _fname;
 
  std::vector<std::string> _cli_args;
 
  std::shared_ptr<neml2::Model> _model;
 
  std::vector<VariableMapping> _inputs;
 
  std::vector<ParameterMapping> _params;
 
  std::vector<VariableMapping> _outputs;
 
  std::vector<DerivativeMapping> _derivs;
 
  std::vector<DerivativeMapping> _param_derivs;
 
#endif
  const UserObjectName _executor_name;
 
  const UserObjectName _idx_generator_name;
 
  const std::vector<SubdomainName> _block;
 
  std::vector<std::string> _skip_input_variables;
 
  std::map<MaterialPropertyName, MaterialPropertyName> _initialize_output_values;
 
  std::map<MaterialPropertyName, std::vector<OutputName>> _export_output_targets;
 
private:
#ifdef NEML2_ENABLED
  template <typename EnumType, typename T>
  std::tuple<std::vector<EnumType>, std::vector<T>>
  getInputParameterMapping(const std::string & source_opt, const std::string & name_opt) const
  {
    const auto moose_types = getParam<MultiMooseEnum>(source_opt).getSetValueIDs<EnumType>();
    const auto neml2_names = getParam<std::vector<T>>(name_opt);
 
    if (moose_types.size() != neml2_names.size())
      paramError(source_opt, source_opt, " must have the same length as ", name_opt);
 
    return {moose_types, neml2_names};
  }
 
  void printSummary() const;
#endif
 
  std::size_t getLongestMOOSEName() const;
};