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 "LagrangianStressDivergenceBase.h"
      11             : 
      12             : InputParameters
      13        3464 : LagrangianStressDivergenceBase::validParams()
      14             : {
      15        3464 :   InputParameters params = KernelScalarBase::validParams();
      16             : 
      17        6928 :   params.addRequiredParam<unsigned int>("component", "Which direction this kernel acts in");
      18        6928 :   params.addRequiredCoupledVar("displacements", "The displacement components");
      19             : 
      20        6928 :   params.addParam<bool>("large_kinematics", false, "Use large displacement kinematics");
      21        6928 :   params.addParam<bool>("stabilize_strain", false, "Average the volumetric strains");
      22             : 
      23        6928 :   params.addParam<std::string>("base_name", "Material property base name");
      24             : 
      25        6928 :   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        6928 :   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        6928 :   params.addCoupledVar("out_of_plane_strain",
      37             :                        "The out-of-plane strain variable for weak plane stress formulation.");
      38             : 
      39        3464 :   return params;
      40           0 : }
      41             : 
      42        1732 : LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(const InputParameters & parameters)
      43             :   : JvarMapKernelInterface<DerivativeMaterialInterface<KernelScalarBase>>(parameters),
      44        1732 :     _large_kinematics(getParam<bool>("large_kinematics")),
      45        3464 :     _stabilize_strain(getParam<bool>("stabilize_strain")),
      46        3512 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      47        3464 :     _alpha(getParam<unsigned int>("component")),
      48        1732 :     _ndisp(coupledComponents("displacements")),
      49        1732 :     _disp_nums(_ndisp),
      50        1732 :     _avg_grad_trial(_ndisp),
      51        1732 :     _F_ust(
      52        1732 :         getMaterialPropertyByName<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
      53        3464 :     _F_avg(getMaterialPropertyByName<RankTwoTensor>(_base_name + "average_deformation_gradient")),
      54        3464 :     _f_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name +
      55             :                                                     "inverse_incremental_deformation_gradient")),
      56        3464 :     _F_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name + "inverse_deformation_gradient")),
      57        3464 :     _F(getMaterialPropertyByName<RankTwoTensor>(_base_name + "deformation_gradient")),
      58        1842 :     _temperature(isCoupled("temperature") ? getVar("temperature", 0) : nullptr),
      59        1764 :     _out_of_plane_strain(isCoupled("out_of_plane_strain") ? getVar("out_of_plane_strain", 0)
      60        1732 :                                                           : nullptr)
      61             : {
      62             :   // Do the vector coupling of the displacements
      63        6218 :   for (unsigned int i = 0; i < _ndisp; i++)
      64        4486 :     _disp_nums[i] = coupled("displacements", i);
      65             : 
      66             :   // We need to use identical discretizations for all displacement components
      67        1732 :   auto order_x = getVar("displacements", 0)->order();
      68        4486 :   for (unsigned int i = 1; i < _ndisp; i++)
      69             :   {
      70        5508 :     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        1732 :   _deigenstrain_dargs.resize(nvar);
      78        6360 :   for (std::size_t i = 0; i < nvar; ++i)
      79        9784 :     for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
      80        1056 :       _deigenstrain_dargs[i].push_back(&getMaterialPropertyDerivative<RankTwoTensor>(
      81         528 :           eigenstrain_name, _coupled_moose_vars[i]->name()));
      82        1732 : }
      83             : 
      84             : void
      85      467409 : LagrangianStressDivergenceBase::precalculateJacobian()
      86             : {
      87             :   // Skip if we are not doing stabilization
      88      467409 :   if (!_stabilize_strain)
      89             :     return;
      90             : 
      91             :   // We need the gradients of shape functions in the reference frame
      92       29965 :   _fe_problem.prepareShapes(_var.number(), _tid);
      93       29965 :   _avg_grad_trial[_alpha].resize(_phi.size());
      94       29965 :   precalculateJacobianDisplacement(_alpha);
      95             : }
      96             : 
      97             : void
      98      828822 : LagrangianStressDivergenceBase::precalculateOffDiagJacobian(unsigned int jvar)
      99             : {
     100             :   // Skip if we are not doing stabilization
     101      828822 :   if (!_stabilize_strain)
     102             :     return;
     103             : 
     104      197924 :   for (auto beta : make_range(_ndisp))
     105      145758 :     if (jvar == _disp_nums[beta])
     106             :     {
     107             :       // We need the gradients of shape functions in the reference frame
     108       50256 :       _fe_problem.prepareShapes(jvar, _tid);
     109       50256 :       _avg_grad_trial[beta].resize(_phi.size());
     110       50256 :       precalculateJacobianDisplacement(beta);
     111             :     }
     112             : }
     113             : 
     114             : Real
     115   201219996 : LagrangianStressDivergenceBase::computeQpJacobian()
     116             : {
     117   201219996 :   return computeQpJacobianDisplacement(_alpha, _alpha);
     118             : }
     119             : 
     120             : Real
     121   392563804 : LagrangianStressDivergenceBase::computeQpOffDiagJacobian(unsigned int jvar)
     122             : {
     123             :   // Bail if jvar not coupled
     124   392563804 :   if (getJvarMap()[jvar] < 0)
     125             :     return 0.0;
     126             : 
     127             :   // Off diagonal terms for other displacements
     128   784401098 :   for (auto beta : make_range(_ndisp))
     129   783614794 :     if (jvar == _disp_nums[beta])
     130   391777500 :       return computeQpJacobianDisplacement(_alpha, beta);
     131             : 
     132             :   // Off diagonal temperature term due to eigenstrain
     133      786304 :   if (_temperature && jvar == _temperature->number())
     134      700416 :     return computeQpJacobianTemperature(mapJvarToCvar(jvar));
     135             : 
     136             :   // Off diagonal term due to weak plane stress
     137       85888 :   if (_out_of_plane_strain && jvar == _out_of_plane_strain->number())
     138       85888 :     return computeQpJacobianOutOfPlaneStrain();
     139             : 
     140             :   return 0;
     141             : }