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 "ADCompute2DFiniteStrain.h"
      11             : 
      12             : #include "libmesh/quadrature.h"
      13             : 
      14             : InputParameters
      15         220 : ADCompute2DFiniteStrain::validParams()
      16             : {
      17         220 :   InputParameters params = ADComputeFiniteStrain::validParams();
      18         220 :   params.addClassDescription(
      19             :       "Compute a strain increment and rotation increment for finite strains in 2D geometries.");
      20             : 
      21         440 :   MooseEnum outOfPlaneDirection("x y z", "z");
      22         440 :   params.addParam<MooseEnum>(
      23             :       "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
      24         220 :   return params;
      25         220 : }
      26             : 
      27         165 : ADCompute2DFiniteStrain::ADCompute2DFiniteStrain(const InputParameters & parameters)
      28             :   : ADComputeFiniteStrain(parameters),
      29         330 :     _out_of_plane_direction(getParam<MooseEnum>("out_of_plane_direction"))
      30             : {
      31         165 : }
      32             : 
      33             : void
      34         165 : ADCompute2DFiniteStrain::initialSetup()
      35             : {
      36         660 :   for (unsigned int i = 0; i < 3; ++i)
      37             :   {
      38         495 :     if (_out_of_plane_direction == i)
      39             :     {
      40         165 :       _disp[i] = &_ad_zero;
      41         165 :       _grad_disp[i] = &_ad_grad_zero;
      42             :     }
      43             :     else
      44             :     {
      45         330 :       _disp[i] = &adCoupledValue("displacements", i);
      46         330 :       _grad_disp[i] = &adCoupledGradient("displacements", i);
      47             :     }
      48             : 
      49         495 :     if (_fe_problem.isTransient() && i != _out_of_plane_direction)
      50         330 :       _grad_disp_old[i] = &coupledGradientOld("displacements", i);
      51             :     else
      52         165 :       _grad_disp_old[i] = &_grad_zero;
      53             :   }
      54         165 : }
      55             : 
      56             : void
      57      296334 : ADCompute2DFiniteStrain::computeProperties()
      58             : {
      59      296334 :   ADRankTwoTensor ave_Fhat;
      60             : 
      61     1566838 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      62             :   {
      63             :     // Deformation gradient calculation for 2D problems
      64             :     auto A = ADRankTwoTensor::initializeFromRows(
      65     1270504 :         (*_grad_disp[0])[_qp], (*_grad_disp[1])[_qp], (*_grad_disp[2])[_qp]);
      66             : 
      67             :     // Old Deformation gradient
      68             :     auto Fbar = RankTwoTensor::initializeFromRows(
      69     1270504 :         (*_grad_disp_old[0])[_qp], (*_grad_disp_old[1])[_qp], (*_grad_disp_old[2])[_qp]);
      70             : 
      71             :     // Compute the displacement gradient for the out of plane direction for plane strain,
      72             :     // generalized plane strain, or axisymmetric problems
      73     1270504 :     A(_out_of_plane_direction, _out_of_plane_direction) = computeOutOfPlaneGradDisp();
      74     1270504 :     Fbar(_out_of_plane_direction, _out_of_plane_direction) = computeOutOfPlaneGradDispOld();
      75             : 
      76     1270504 :     A -= Fbar; // very nearly A = gradU - gradUold
      77             : 
      78     1270504 :     Fbar.addIa(1.0); // Fbar = ( I + gradUold)
      79             : 
      80             :     // Incremental deformation gradient _Fhat = I + A Fbar^-1
      81     1270504 :     _Fhat[_qp] = A * Fbar.inverse();
      82     1270504 :     _Fhat[_qp].addIa(1.0);
      83             : 
      84             :     // Calculate average _Fhat for volumetric locking correction
      85     1270504 :     if (_volumetric_locking_correction)
      86      506416 :       ave_Fhat += _Fhat[_qp] * _JxW[_qp] * _coord[_qp];
      87             :   }
      88             : 
      89      296334 :   if (_volumetric_locking_correction)
      90      126604 :     ave_Fhat /= _current_elem_volume;
      91             : 
      92     1566838 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      93             :   {
      94             :     // Finalize volumetric locking correction
      95     1270504 :     if (_volumetric_locking_correction)
      96             :     {
      97             :       using std::cbrt;
      98     1012832 :       _Fhat[_qp] *= cbrt(ave_Fhat.det() / _Fhat[_qp].det());
      99             :     }
     100             : 
     101     1270504 :     computeQpStrain();
     102             :   }
     103      296334 : }
     104             : 
     105             : void
     106           0 : ADCompute2DFiniteStrain::displacementIntegrityCheck()
     107             : {
     108           0 :   if (_out_of_plane_direction != 2 && _ndisp != 3)
     109           0 :     mooseError("For 2D simulations where the out-of-plane direction is x or y the number of "
     110             :                "supplied displacements must be three.");
     111           0 :   else if (_out_of_plane_direction == 2 && _ndisp != 2)
     112           0 :     mooseError("For 2D simulations where the out-of-plane direction is z the number of supplied "
     113             :                "displacements must be two.");
     114           0 : }