Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "NEML2ToMOOSEMaterialProperty.h"
      11             : #include "NEML2ModelExecutor.h"
      12             : 
      13             : #define registerNEML2ToMOOSEMaterialProperty(alias)                                                \
      14             :   registerMooseObject("MooseApp", NEML2ToMOOSE##alias##MaterialProperty)
      15             : 
      16             : registerNEML2ToMOOSEMaterialProperty(Real);
      17             : registerNEML2ToMOOSEMaterialProperty(SymmetricRankTwoTensor);
      18             : registerNEML2ToMOOSEMaterialProperty(SymmetricRankFourTensor);
      19             : registerNEML2ToMOOSEMaterialProperty(RealVectorValue);
      20             : registerNEML2ToMOOSEMaterialProperty(RankTwoTensor);
      21             : registerNEML2ToMOOSEMaterialProperty(RankFourTensor);
      22             : 
      23             : template <typename T>
      24             : InputParameters
      25       85824 : NEML2ToMOOSEMaterialProperty<T>::validParams()
      26             : {
      27       85824 :   auto params = Material::validParams();
      28       85824 :   params.addClassDescription(
      29             :       NEML2Utils::docstring("Provide an output (or its derivative) from a NEML2 model as a MOOSE "
      30             :                             "material property of type " +
      31             :                             demangle(typeid(T).name()) + "."));
      32             : 
      33       85824 :   params.addRequiredParam<UserObjectName>(
      34             :       "neml2_executor",
      35             :       NEML2Utils::docstring("User object managing the execution of the NEML2 model."));
      36       85824 :   params.addRequiredParam<MaterialPropertyName>(
      37             :       "to_moose",
      38             :       NEML2Utils::docstring(
      39             :           "MOOSE material property used to store the NEML2 output variable (or its derivative)"));
      40       85824 :   params.addRequiredParam<std::string>("from_neml2",
      41             :                                        NEML2Utils::docstring("NEML2 output variable to read from"));
      42       85824 :   params.addParam<std::string>(
      43             :       "neml2_input_derivative",
      44             :       NEML2Utils::docstring(
      45             :           "If supplied return the derivative of the NEML2 output variable with respect to this"));
      46       85824 :   params.addParam<std::string>(
      47             :       "neml2_parameter_derivative",
      48             :       NEML2Utils::docstring(
      49             :           "If supplied return the derivative of neml2_variable with respect to this"));
      50             : 
      51             :   // provide an optional initialization of the moose property (because we don't really know if it is
      52             :   // going to become stateful or not)
      53       85824 :   params.addParam<MaterialPropertyName>(
      54             :       "moose_material_property_init",
      55             :       NEML2Utils::docstring("Optional material property as the initial condition"));
      56             : 
      57       85824 :   return params;
      58           0 : }
      59             : 
      60             : template <typename T>
      61         177 : NEML2ToMOOSEMaterialProperty<T>::NEML2ToMOOSEMaterialProperty(const InputParameters & params)
      62           0 :   : Material(params)
      63             : #ifdef NEML2_ENABLED
      64             :     ,
      65         177 :     _execute_neml2_model(getUserObject<NEML2ModelExecutor>("neml2_executor")),
      66         177 :     _prop(declareProperty<T>(getParam<MaterialPropertyName>("to_moose"))),
      67         354 :     _prop0(isParamValid("moose_material_property_init")
      68         177 :                ? &getMaterialProperty<T>("moose_material_property_init")
      69             :                : nullptr),
      70         177 :     _value(
      71         354 :         !isParamValid("neml2_input_derivative")
      72         462 :             ? (!isParamValid("neml2_parameter_derivative")
      73         216 :                    ? _execute_neml2_model.getOutput(
      74         285 :                          NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")))
      75           0 :                    : _execute_neml2_model.getOutputParameterDerivative(
      76         177 :                          NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")),
      77         177 :                          getParam<std::string>("neml2_parameter_derivative")))
      78         246 :             : _execute_neml2_model.getOutputDerivative(
      79         246 :                   NEML2Utils::parseVariableName(getParam<std::string>("from_neml2")),
      80         423 :                   NEML2Utils::parseVariableName(getParam<std::string>("neml2_input_derivative"))))
      81             : #endif
      82             : {
      83         177 :   NEML2Utils::assertNEML2Enabled();
      84         177 : }
      85             : 
      86             : #ifdef NEML2_ENABLED
      87             : template <typename T>
      88             : void
      89       77060 : NEML2ToMOOSEMaterialProperty<T>::computeProperties()
      90             : {
      91             :   // See issue #28971: Using _prop0 to set initial condition for this possibly stateful property may
      92             :   // not work. As a workaround, we set the initial condition here when _t_step == 0.
      93       77060 :   if (_t_step == 0 && _prop0)
      94             :   {
      95           0 :     _prop.set() = _prop0->get();
      96           0 :     return;
      97             :   }
      98             : 
      99       77060 :   if (!_execute_neml2_model.outputReady())
     100        9420 :     return;
     101             : 
     102             :   // look up start index for current element
     103       67640 :   const auto i = _execute_neml2_model.getBatchIndex(_current_elem->id());
     104      241920 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     105      522840 :     NEML2Utils::copyTensorToMOOSEData(_value.batch_index({neml2::Size(i + _qp)}), _prop[_qp]);
     106      174280 : }
     107             : #endif
     108             : 
     109             : #define instantiateNEML2ToMOOSEMaterialProperty(T) template class NEML2ToMOOSEMaterialProperty<T>
     110             : 
     111             : instantiateNEML2ToMOOSEMaterialProperty(Real);
     112             : instantiateNEML2ToMOOSEMaterialProperty(SymmetricRankTwoTensor);
     113             : instantiateNEML2ToMOOSEMaterialProperty(SymmetricRankFourTensor);
     114             : instantiateNEML2ToMOOSEMaterialProperty(RealVectorValue);
     115             : instantiateNEML2ToMOOSEMaterialProperty(RankTwoTensor);
     116             : instantiateNEML2ToMOOSEMaterialProperty(RankFourTensor);