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 "ADComputeStrainBase.h"
      11             : #include "RankTwoTensor.h"
      12             : #include "SymmetricRankTwoTensor.h"
      13             : #include "MooseMesh.h"
      14             : #include "Assembly.h"
      15             : 
      16             : template <typename R2>
      17             : InputParameters
      18        5472 : ADComputeStrainBaseTempl<R2>::validParams()
      19             : {
      20        5472 :   InputParameters params = Material::validParams();
      21       10944 :   params.addRequiredCoupledVar(
      22             :       "displacements",
      23             :       "The displacements appropriate for the simulation geometry and coordinate system");
      24       10944 :   params.addParam<std::string>("base_name",
      25             :                                "Optional parameter that allows the user to define "
      26             :                                "multiple mechanics material systems on the same "
      27             :                                "block, i.e. for multiple phases");
      28       10944 :   params.addParam<bool>(
      29       10944 :       "volumetric_locking_correction", false, "Flag to correct volumetric locking");
      30       10944 :   params.addParam<std::vector<MaterialPropertyName>>(
      31             :       "eigenstrain_names", {}, "List of eigenstrains to be applied in this strain calculation");
      32       10944 :   params.addParam<MaterialPropertyName>("global_strain",
      33             :                                         "Optional material property holding a global strain "
      34             :                                         "tensor applied to the mesh as a whole");
      35        5472 :   params.suppressParameter<bool>("use_displaced_mesh");
      36        5472 :   return params;
      37           0 : }
      38             : 
      39             : template <typename R2>
      40        4104 : ADComputeStrainBaseTempl<R2>::ADComputeStrainBaseTempl(const InputParameters & parameters)
      41             :   : Material(parameters),
      42        4104 :     _ndisp(coupledComponents("displacements")),
      43        4104 :     _disp(adCoupledValues("displacements")),
      44        4104 :     _grad_disp(adCoupledGradients("displacements")),
      45        8352 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      46        4104 :     _mechanical_strain(declareADProperty<R2>(_base_name + "mechanical_strain")),
      47        4104 :     _total_strain(declareADProperty<R2>(_base_name + "total_strain")),
      48        8208 :     _eigenstrain_names(getParam<std::vector<MaterialPropertyName>>("eigenstrain_names")),
      49        4104 :     _eigenstrains(_eigenstrain_names.size()),
      50        4104 :     _global_strain(isParamValid("global_strain")
      51        4104 :                        ? &getADMaterialProperty<R2>(_base_name + "global_strain")
      52             :                        : nullptr),
      53       12166 :     _volumetric_locking_correction(getParam<bool>("volumetric_locking_correction") &&
      54             :                                    !this->isBoundaryMaterial()),
      55        8208 :     _current_elem_volume(_assembly.elemVolume())
      56             : {
      57             :   // set unused dimensions to zero
      58        6192 :   for (unsigned i = _ndisp; i < 3; ++i)
      59             :   {
      60        2088 :     _disp.push_back(&_ad_zero);
      61        2088 :     _grad_disp.push_back(&_ad_grad_zero);
      62             :   }
      63             : 
      64        4572 :   for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
      65             :   {
      66         936 :     _eigenstrain_names[i] = _base_name + _eigenstrain_names[i];
      67         468 :     _eigenstrains[i] = &getADMaterialProperty<R2>(_eigenstrain_names[i]);
      68             :   }
      69             : 
      70        4104 :   if (_ndisp == 1 && _volumetric_locking_correction)
      71           0 :     paramError("volumetric_locking_correction", "has to be set to false for 1-D problems.");
      72             : 
      73        8208 :   if (getParam<bool>("use_displaced_mesh"))
      74           0 :     paramError("use_displaced_mesh", "The strain calculator needs to run on the undisplaced mesh.");
      75        4104 : }
      76             : 
      77             : template <typename R2>
      78             : void
      79        1008 : ADComputeStrainBaseTempl<R2>::initialSetup()
      80             : {
      81        3618 :   displacementIntegrityCheck();
      82        1008 : }
      83             : 
      84             : template <typename R2>
      85             : void
      86        3564 : ADComputeStrainBaseTempl<R2>::displacementIntegrityCheck()
      87             : {
      88             :   // Checking for consistency between mesh size and length of the provided displacements vector
      89        3564 :   if (_ndisp != _mesh.dimension())
      90           0 :     paramError(
      91             :         "displacements",
      92             :         "The number of variables supplied in 'displacements' must match the mesh dimension.");
      93        3564 : }
      94             : 
      95             : template <typename R2>
      96             : void
      97         768 : ADComputeStrainBaseTempl<R2>::initQpStatefulProperties()
      98             : {
      99         768 :   _mechanical_strain[_qp].zero();
     100         768 :   _total_strain[_qp].zero();
     101         768 : }
     102             : 
     103             : template class ADComputeStrainBaseTempl<RankTwoTensor>;
     104             : template class ADComputeStrainBaseTempl<SymmetricRankTwoTensor>;