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;
};