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 "StrainEnergyDensity.h"
      11             : #include "RankTwoTensor.h"
      12             : #include "MooseMesh.h"
      13             : 
      14             : registerMooseObject("SolidMechanicsApp", StrainEnergyDensity);
      15             : registerMooseObject("SolidMechanicsApp", ADStrainEnergyDensity);
      16             : 
      17             : template <bool is_ad>
      18             : InputParameters
      19        1344 : StrainEnergyDensityTempl<is_ad>::validParams()
      20             : {
      21        1344 :   InputParameters params = Material::validParams();
      22        1344 :   params.addClassDescription("Computes the strain energy density using a combination of the "
      23             :                              "elastic and inelastic components of the strain increment, which is a "
      24             :                              "valid assumption for monotonic behavior.");
      25        2688 :   params.addParam<std::string>("base_name",
      26             :                                "Optional parameter that allows the user to define "
      27             :                                "multiple mechanics material systems on the same "
      28             :                                "block, i.e. for multiple phases");
      29        2688 :   params.addParam<std::string>("stress_name",
      30             :                                "stress",
      31             :                                "Optional parameter that allows the user to use "
      32             :                                "different stresses on the same material system. "
      33             :                                "For example, when we have a degraded_stress and an intact_stress, "
      34             :                                "we want to compute the degraded strain energy density and "
      35             :                                "the intact strain energy density.");
      36        2688 :   params.addParam<bool>(
      37             :       "incremental",
      38             :       "Optional flag for error checking if an incremental or total model should be used.");
      39        1344 :   return params;
      40           0 : }
      41             : 
      42             : template <bool is_ad>
      43        1008 : StrainEnergyDensityTempl<is_ad>::StrainEnergyDensityTempl(const InputParameters & parameters)
      44             :   : DerivativeMaterialInterface<Material>(parameters),
      45        1008 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      46        2016 :     _stress_name(getParam<std::string>("stress_name")),
      47        1008 :     _strain_energy_density(declareProperty<Real>(_base_name + "strain_energy_density")),
      48        2016 :     _strain_energy_density_old(getMaterialPropertyOld<Real>(_base_name + "strain_energy_density")),
      49        1008 :     _stress(getGenericMaterialProperty<RankTwoTensor, is_ad>(_base_name + _stress_name)),
      50        2016 :     _stress_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + _stress_name)),
      51        1008 :     _mechanical_strain(
      52        1008 :         getGenericMaterialProperty<RankTwoTensor, is_ad>(_base_name + "mechanical_strain")),
      53        1008 :     _strain_increment(
      54        2016 :         getGenericOptionalMaterialProperty<RankTwoTensor, is_ad>(_base_name + "strain_increment"))
      55             : {
      56        1008 : }
      57             : 
      58             : template <bool is_ad>
      59             : void
      60         994 : StrainEnergyDensityTempl<is_ad>::initialSetup()
      61             : {
      62             :   // optional error checking
      63        1988 :   if (isParamValid("incremental"))
      64             :   {
      65        1988 :     auto incremental = getParam<bool>("incremental");
      66         994 :     if (incremental && !_strain_increment)
      67           2 :       mooseError("StrainEnergyDensity: Specified incremental = true, but material model is "
      68             :                  "not incremental.");
      69         992 :     if (!incremental && _strain_increment)
      70           2 :       mooseError("StrainEnergyDensity: Specified incremental = false, but material model is "
      71             :                  "incremental.");
      72             :   }
      73         990 : }
      74             : template <bool is_ad>
      75             : void
      76      520976 : StrainEnergyDensityTempl<is_ad>::initQpStatefulProperties()
      77             : {
      78      520976 :   _strain_energy_density[_qp] = 0.0;
      79      520976 : }
      80             : 
      81             : template <bool is_ad>
      82             : void
      83    14796396 : StrainEnergyDensityTempl<is_ad>::computeQpProperties()
      84             : {
      85             : 
      86    14796396 :   if (_strain_increment)
      87    14414156 :     _strain_energy_density[_qp] =
      88    14414156 :         _strain_energy_density_old[_qp] +
      89    14414156 :         MetaPhysicL::raw_value(_stress[_qp])
      90    28828312 :                 .doubleContraction(MetaPhysicL::raw_value(_strain_increment[_qp])) /
      91    14414156 :             2.0 +
      92    14414156 :         _stress_old[_qp].doubleContraction(MetaPhysicL::raw_value(_strain_increment[_qp])) / 2.0;
      93             :   else
      94      382240 :     _strain_energy_density[_qp] =
      95      382240 :         MetaPhysicL::raw_value(_stress[_qp])
      96      382240 :             .doubleContraction((MetaPhysicL::raw_value(_mechanical_strain[_qp]))) /
      97             :         2.0;
      98    14796396 : }
      99             : 
     100             : template class StrainEnergyDensityTempl<false>;
     101             : template class StrainEnergyDensityTempl<true>;