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 "LagrangianStressDivergenceBase.h"
      11             : 
      12             : InputParameters
      13        2986 : LagrangianStressDivergenceBase::validParams()
      14             : {
      15        2986 :   InputParameters params = Kernel::validParams();
      16             : 
      17        5972 :   params.addRequiredParam<unsigned int>("component", "Which direction this kernel acts in");
      18        5972 :   params.addRequiredCoupledVar("displacements", "The displacement components");
      19             : 
      20        5972 :   params.addParam<bool>("large_kinematics", false, "Use large displacement kinematics");
      21        5972 :   params.addParam<bool>("stabilize_strain", false, "Average the volumetric strains");
      22             : 
      23        5972 :   params.addParam<std::string>("base_name", "Material property base name");
      24             : 
      25        5972 :   params.addCoupledVar("temperature",
      26             :                        "The name of the temperature variable used in the "
      27             :                        "ComputeThermalExpansionEigenstrain.  (Not required for "
      28             :                        "simulations without temperature coupling.)");
      29             : 
      30        5972 :   params.addParam<std::vector<MaterialPropertyName>>(
      31             :       "eigenstrain_names",
      32             :       {},
      33             :       "List of eigenstrains used in the strain calculation. Used for computing their derivatives "
      34             :       "for off-diagonal Jacobian terms.");
      35             : 
      36        5972 :   params.addCoupledVar("out_of_plane_strain",
      37             :                        "The out-of-plane strain variable for weak plane stress formulation.");
      38             : 
      39        2986 :   return params;
      40           0 : }
      41             : 
      42        1493 : LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(const InputParameters & parameters)
      43             :   : JvarMapKernelInterface<DerivativeMaterialInterface<Kernel>>(parameters),
      44        1493 :     _large_kinematics(getParam<bool>("large_kinematics")),
      45        2986 :     _stabilize_strain(getParam<bool>("stabilize_strain")),
      46        3022 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      47        2986 :     _alpha(getParam<unsigned int>("component")),
      48        1493 :     _ndisp(coupledComponents("displacements")),
      49        1493 :     _disp_nums(_ndisp),
      50        1493 :     _avg_grad_trial(_ndisp),
      51        1493 :     _F_ust(
      52        1493 :         getMaterialPropertyByName<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
      53        2986 :     _F_avg(getMaterialPropertyByName<RankTwoTensor>(_base_name + "average_deformation_gradient")),
      54        2986 :     _f_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name +
      55             :                                                     "inverse_incremental_deformation_gradient")),
      56        2986 :     _F_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name + "inverse_deformation_gradient")),
      57        2986 :     _F(getMaterialPropertyByName<RankTwoTensor>(_base_name + "deformation_gradient")),
      58        1595 :     _temperature(isCoupled("temperature") ? getVar("temperature", 0) : nullptr),
      59        1523 :     _out_of_plane_strain(isCoupled("out_of_plane_strain") ? getVar("out_of_plane_strain", 0)
      60        2986 :                                                           : nullptr)
      61             : {
      62             :   // Do the vector coupling of the displacements
      63        5367 :   for (unsigned int i = 0; i < _ndisp; i++)
      64        3874 :     _disp_nums[i] = coupled("displacements", i);
      65             : 
      66             :   // We need to use identical discretizations for all displacement components
      67        1493 :   auto order_x = getVar("displacements", 0)->order();
      68        3874 :   for (unsigned int i = 1; i < _ndisp; i++)
      69             :   {
      70        4762 :     if (getVar("displacements", i)->order() != order_x)
      71           0 :       mooseError("The Lagrangian StressDivergence kernels require equal "
      72             :                  "order interpolation for all displacements.");
      73             :   }
      74             : 
      75             :   // fetch eigenstrain derivatives
      76             :   const auto nvar = _coupled_moose_vars.size();
      77        1493 :   _deigenstrain_dargs.resize(nvar);
      78        5499 :   for (std::size_t i = 0; i < nvar; ++i)
      79        8480 :     for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
      80        1404 :       _deigenstrain_dargs[i].push_back(&getMaterialPropertyDerivative<RankTwoTensor>(
      81         468 :           eigenstrain_name, _coupled_moose_vars[i]->name()));
      82        1493 : }
      83             : 
      84             : void
      85      310368 : LagrangianStressDivergenceBase::precalculateJacobian()
      86             : {
      87             :   // Skip if we are not doing stabilization
      88      310368 :   if (!_stabilize_strain)
      89             :     return;
      90             : 
      91             :   // We need the gradients of shape functions in the reference frame
      92       28988 :   _fe_problem.prepareShapes(_var.number(), _tid);
      93       28988 :   _avg_grad_trial[_alpha].resize(_phi.size());
      94       28988 :   precalculateJacobianDisplacement(_alpha);
      95             : }
      96             : 
      97             : void
      98      551376 : LagrangianStressDivergenceBase::precalculateOffDiagJacobian(unsigned int jvar)
      99             : {
     100             :   // Skip if we are not doing stabilization
     101      551376 :   if (!_stabilize_strain)
     102             :     return;
     103             : 
     104      203744 :   for (auto beta : make_range(_ndisp))
     105      150816 :     if (jvar == _disp_nums[beta])
     106             :     {
     107             :       // We need the gradients of shape functions in the reference frame
     108       51040 :       _fe_problem.prepareShapes(jvar, _tid);
     109       51040 :       _avg_grad_trial[beta].resize(_phi.size());
     110       51040 :       precalculateJacobianDisplacement(beta);
     111             :     }
     112             : }
     113             : 
     114             : Real
     115   134864704 : LagrangianStressDivergenceBase::computeQpJacobian()
     116             : {
     117   134864704 :   return computeQpJacobianDisplacement(_alpha, _alpha);
     118             : }
     119             : 
     120             : Real
     121   262176512 : LagrangianStressDivergenceBase::computeQpOffDiagJacobian(unsigned int jvar)
     122             : {
     123             :   // Bail if jvar not coupled
     124   262176512 :   if (getJvarMap()[jvar] < 0)
     125             :     return 0.0;
     126             : 
     127             :   // Off diagonal terms for other displacements
     128   524455424 :   for (auto beta : make_range(_ndisp))
     129   523686656 :     if (jvar == _disp_nums[beta])
     130   261407744 :       return computeQpJacobianDisplacement(_alpha, beta);
     131             : 
     132             :   // Off diagonal temperature term due to eigenstrain
     133      768768 :   if (_temperature && jvar == _temperature->number())
     134      684288 :     return computeQpJacobianTemperature(mapJvarToCvar(jvar));
     135             : 
     136             :   // Off diagonal term due to weak plane stress
     137       84480 :   if (_out_of_plane_strain && jvar == _out_of_plane_strain->number())
     138       84480 :     return computeQpJacobianOutOfPlaneStrain();
     139             : 
     140             :   return 0;
     141             : }