Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://www.mooseframework.org
       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("TensorMechanicsApp", StrainEnergyDensity);
      15             : registerMooseObject("TensorMechanicsApp", ADStrainEnergyDensity);
      16             : 
      17             : template <bool is_ad>
      18             : InputParameters
      19         696 : StrainEnergyDensityTempl<is_ad>::validParams()
      20             : {
      21         696 :   InputParameters params = Material::validParams();
      22         696 :   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        1392 :   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        1392 :   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        1392 :   params.addParam<bool>(
      37             :       "incremental",
      38             :       "Optional flag for error checking if an incremental or total model should be used.");
      39         696 :   return params;
      40           0 : }
      41             : 
      42             : template <bool is_ad>
      43         522 : StrainEnergyDensityTempl<is_ad>::StrainEnergyDensityTempl(const InputParameters & parameters)
      44             :   : DerivativeMaterialInterface<Material>(parameters),
      45         522 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      46        1044 :     _stress_name(getParam<std::string>("stress_name")),
      47         522 :     _strain_energy_density(declareProperty<Real>(_base_name + "strain_energy_density")),
      48        1044 :     _strain_energy_density_old(getMaterialPropertyOld<Real>(_base_name + "strain_energy_density")),
      49         522 :     _stress(getGenericMaterialProperty<RankTwoTensor, is_ad>(_base_name + _stress_name)),
      50        1044 :     _stress_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + _stress_name)),
      51         522 :     _mechanical_strain(
      52         522 :         getGenericMaterialProperty<RankTwoTensor, is_ad>(_base_name + "mechanical_strain")),
      53         522 :     _strain_increment(
      54        1044 :         getGenericOptionalMaterialProperty<RankTwoTensor, is_ad>(_base_name + "strain_increment"))
      55             : {
      56         522 : }
      57             : 
      58             : template <bool is_ad>
      59             : void
      60         515 : StrainEnergyDensityTempl<is_ad>::initialSetup()
      61             : {
      62             :   // optional error checking
      63        1030 :   if (isParamValid("incremental"))
      64             :   {
      65        1030 :     auto incremental = getParam<bool>("incremental");
      66         515 :     if (incremental && !_strain_increment)
      67           1 :       mooseError("StrainEnergyDensity: Specified incremental = true, but material model is "
      68             :                  "not incremental.");
      69         514 :     if (!incremental && _strain_increment)
      70           1 :       mooseError("StrainEnergyDensity: Specified incremental = false, but material model is "
      71             :                  "incremental.");
      72             :   }
      73         513 : }
      74             : template <bool is_ad>
      75             : void
      76      262888 : StrainEnergyDensityTempl<is_ad>::initQpStatefulProperties()
      77             : {
      78      262888 :   _strain_energy_density[_qp] = 0.0;
      79      262888 : }
      80             : 
      81             : template <bool is_ad>
      82             : void
      83     7699792 : StrainEnergyDensityTempl<is_ad>::computeQpProperties()
      84             : {
      85             : 
      86     7699792 :   if (_strain_increment)
      87     7507064 :     _strain_energy_density[_qp] =
      88     7507064 :         _strain_energy_density_old[_qp] +
      89     7507064 :         MetaPhysicL::raw_value(_stress[_qp])
      90    15014128 :                 .doubleContraction(MetaPhysicL::raw_value(_strain_increment[_qp])) /
      91     7507064 :             2.0 +
      92     7507064 :         _stress_old[_qp].doubleContraction(MetaPhysicL::raw_value(_strain_increment[_qp])) / 2.0;
      93             :   else
      94      192728 :     _strain_energy_density[_qp] =
      95      192728 :         MetaPhysicL::raw_value(_stress[_qp])
      96      192728 :             .doubleContraction((MetaPhysicL::raw_value(_mechanical_strain[_qp]))) /
      97             :         2.0;
      98     7699792 : }
      99             : 
     100             : template class StrainEnergyDensityTempl<false>;
     101             : template class StrainEnergyDensityTempl<true>;