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       18624 : NEML2ToMOOSEMaterialProperty<T>::validParams()
      26             : {
      27       18624 :   auto params = Material::validParams();
      28       18624 :   params.addClassDescription("Provide an output (or its derivative) from a NEML2 model as a MOOSE "
      29             :                              "material property of type " +
      30             :                              demangle(typeid(T).name()) + ".");
      31             : 
      32       74496 :   params.addRequiredParam<UserObjectName>("neml2_executor",
      33             :                                           "User object managing the execution of the NEML2 model.");
      34       74496 :   params.addRequiredParam<MaterialPropertyName>(
      35             :       "to_moose",
      36             :       "MOOSE material property used to store the NEML2 output variable (or its derivative)");
      37       74496 :   params.addRequiredParam<std::string>("from_neml2", "NEML2 output variable to read from");
      38       74496 :   params.addParam<std::string>(
      39             :       "neml2_input_derivative",
      40             : 
      41             :       "If supplied return the derivative of the NEML2 output variable with respect to this");
      42       74496 :   params.addParam<std::string>(
      43             :       "neml2_parameter_derivative",
      44             :       "If supplied return the derivative of neml2_variable with respect to this");
      45             : 
      46             :   // provide an optional initialization of the moose property (because we don't really know if it is
      47             :   // going to become stateful or not)
      48       55872 :   params.addParam<MaterialPropertyName>("moose_material_property_init",
      49             :                                         "Optional material property as the initial condition");
      50             : 
      51       18624 :   return params;
      52           0 : }
      53             : 
      54             : template <typename T>
      55         195 : NEML2ToMOOSEMaterialProperty<T>::NEML2ToMOOSEMaterialProperty(const InputParameters & params)
      56           0 :   : Material(params)
      57             : #ifdef NEML2_ENABLED
      58             :     ,
      59         195 :     _execute_neml2_model(getUserObject<NEML2ModelExecutor>("neml2_executor")),
      60         390 :     _prop(declareProperty<T>(getParam<MaterialPropertyName>("to_moose"))),
      61         390 :     _prop0(isParamValid("moose_material_property_init")
      62         195 :                ? &getMaterialProperty<T>("moose_material_property_init")
      63             :                : nullptr),
      64         390 :     _value(!isParamValid("neml2_input_derivative")
      65         750 :                ? (!isParamValid("neml2_parameter_derivative")
      66         555 :                       ? _execute_neml2_model.getOutput(getParam<std::string>("from_neml2"))
      67           0 :                       : _execute_neml2_model.getOutputParameterDerivative(
      68         195 :                             getParam<std::string>("from_neml2"),
      69         195 :                             getParam<std::string>("neml2_parameter_derivative")))
      70          75 :                : _execute_neml2_model.getOutputDerivative(
      71         270 :                      getParam<std::string>("from_neml2"),
      72         615 :                      getParam<std::string>("neml2_input_derivative")))
      73             : #endif
      74             : {
      75         195 :   NEML2Utils::assertNEML2Enabled();
      76         195 : }
      77             : 
      78             : #ifdef NEML2_ENABLED
      79             : template <typename T>
      80             : void
      81      103310 : NEML2ToMOOSEMaterialProperty<T>::computeProperties()
      82             : {
      83             :   // See issue #28971: Using _prop0 to set initial condition for this possibly stateful property may
      84             :   // not work. As a workaround, we set the initial condition here when _t_step == 0.
      85      103310 :   if (_t_step == 0 && _prop0)
      86             :   {
      87           0 :     _prop.set() = _prop0->get();
      88           0 :     return;
      89             :   }
      90             : 
      91      103310 :   if (!_execute_neml2_model.outputReady())
      92       34020 :     return;
      93             : 
      94             :   // look up start index for current element
      95       69290 :   const auto i = _execute_neml2_model.getBatchIndex(_current_elem->id());
      96      250170 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      97      180880 :     if (_value.batch_dim())
      98      542640 :       NEML2Utils::copyTensorToMOOSEData(_value.batch_index({neml2::Size(i + _qp)}), _prop[_qp]);
      99             :     else
     100           0 :       NEML2Utils::copyTensorToMOOSEData(_value, _prop[_qp]);
     101      180880 : }
     102             : #endif
     103             : 
     104             : #define instantiateNEML2ToMOOSEMaterialProperty(T) template class NEML2ToMOOSEMaterialProperty<T>
     105             : 
     106             : instantiateNEML2ToMOOSEMaterialProperty(Real);
     107             : instantiateNEML2ToMOOSEMaterialProperty(SymmetricRankTwoTensor);
     108             : instantiateNEML2ToMOOSEMaterialProperty(SymmetricRankFourTensor);
     109             : instantiateNEML2ToMOOSEMaterialProperty(RealVectorValue);
     110             : instantiateNEML2ToMOOSEMaterialProperty(RankTwoTensor);
     111             : instantiateNEML2ToMOOSEMaterialProperty(RankFourTensor);