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"

class NEML2ActionCommon;

class NEML2Action : public Action
{
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; }

  enum class MOOSEIOType
  {
    MATERIAL,
    VARIABLE,
    POSTPROCESSOR
  };

  struct MOOSEIO
  {
    const std::string name;
    const MOOSEIOType type;
  };

  struct NEML2IO
  {
    const neml2::VariableName name;
    const neml2::TensorType type;
  };

  struct NEML2Param
  {
    const std::string name;
    const neml2::TensorType type;
  };

  struct VariableMapping
  {
    const MOOSEIO moose;
    const NEML2IO neml2;
  };

  struct ParameterMapping
  {
    const MOOSEIO moose;
    const NEML2Param neml2;
  };

  struct DerivativeMapping
  {
    const MOOSEIO moose;
    const struct NEML2Derivative
    {
      const NEML2IO y;
      const NEML2IO x;
    } neml2;
  };

  struct ParameterDerivativeMapping
  {
    const MOOSEIO moose;
    const struct NEML2Derivative
    {
      const NEML2IO y;
      const NEML2Param x;
    } neml2;
  };

  void setupInputMappings(const neml2::Model &);

  void setupParameterMappings(const neml2::Model &);

  void setupOutputMappings(const neml2::Model &);

  void setupDerivativeMappings(const neml2::Model &);

  void setupParameterDerivativeMappings(const neml2::Model &);

  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<ParameterDerivativeMapping> _param_derivs;

#endif
  const UserObjectName _executor_name;

  const UserObjectName _idx_generator_name;

  const std::vector<SubdomainName> _block;

  std::map<MaterialPropertyName, MaterialPropertyName> _initialize_output_values;

  std::map<MaterialPropertyName, std::vector<OutputName>> _export_output_targets;

private:
#ifdef NEML2_ENABLED
  template <typename EnumType, typename T1, typename T2>
  std::tuple<std::vector<EnumType>, std::vector<T1>, std::vector<T2>>
  getInputParameterMapping(const std::string & moose_type_opt,
                           const std::string & moose_name_opt,
                           const std::string & neml2_name_opt) const
  {
    const auto moose_types = getParam<MultiMooseEnum>(moose_type_opt).getSetValueIDs<EnumType>();
    const auto moose_names = getParam<std::vector<T1>>(moose_name_opt);
    const auto neml2_names = getParam<std::vector<T2>>(neml2_name_opt);

    if (moose_types.size() != moose_names.size())
      paramError(moose_name_opt, moose_name_opt, " must have the same length as ", moose_type_opt);
    if (moose_names.size() != neml2_names.size())
      paramError(moose_name_opt, moose_name_opt, " must have the same length as ", neml2_name_opt);

    return {moose_types, moose_names, neml2_names};
  }

  void printSummary() const;
#endif

  std::size_t getLongestMOOSEName() const;
};