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