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 "ComputeEigenstrainFromInitialStress.h"
      11             : #include "RankTwoTensor.h"
      12             : #include "Function.h"
      13             : #include "Conversion.h" // for stringify
      14             : 
      15             : registerMooseObject("SolidMechanicsApp", ComputeEigenstrainFromInitialStress);
      16             : 
      17             : InputParameters
      18        2388 : ComputeEigenstrainFromInitialStress::validParams()
      19             : {
      20        2388 :   InputParameters params = ComputeEigenstrainBase::validParams();
      21        2388 :   params.addClassDescription("Computes an eigenstrain from an initial stress");
      22        4776 :   params.addRequiredParam<std::vector<FunctionName>>(
      23             :       "initial_stress",
      24             :       "A list of functions describing the initial stress.  There must be 9 of these, corresponding "
      25             :       "to the xx, yx, zx, xy, yy, zy, xz, yz, zz components respectively.  To compute the "
      26             :       "eigenstrain correctly, your elasticity tensor should not be time-varying in the first "
      27             :       "timestep");
      28        4776 :   params.addCoupledVar("initial_stress_aux",
      29             :                        "A list of 9 AuxVariables describing the initial stress.  If provided, each "
      30             :                        "of these is multiplied by its corresponding initial_stress function to "
      31             :                        "obtain the relevant component of initial stress.");
      32        4776 :   params.addParam<std::string>("base_name",
      33             :                                "The base_name for the elasticity tensor that will be "
      34             :                                "used to compute strain from stress.  Do not provide "
      35             :                                "any base_name if your elasticity tensor does not use "
      36             :                                "one.");
      37        2388 :   return params;
      38           0 : }
      39             : 
      40        1792 : ComputeEigenstrainFromInitialStress::ComputeEigenstrainFromInitialStress(
      41        1792 :     const InputParameters & parameters)
      42             :   : ComputeEigenstrainBase(parameters),
      43        1792 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      44        3584 :     _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_base_name + "elasticity_tensor")),
      45        1792 :     _eigenstrain_old(getMaterialPropertyOld<RankTwoTensor>(_eigenstrain_name)),
      46        3584 :     _ini_aux_provided(isParamValid("initial_stress_aux")),
      47        1792 :     _ini_aux(_ini_aux_provided ? coupledValues("initial_stress_aux")
      48        3584 :                                : std::vector<const VariableValue *>())
      49             : {
      50             :   const std::vector<FunctionName> & fcn_names(
      51        3584 :       getParam<std::vector<FunctionName>>("initial_stress"));
      52             :   const std::size_t num = fcn_names.size();
      53             : 
      54        1792 :   if (num != LIBMESH_DIM * LIBMESH_DIM)
      55           4 :     paramError(
      56             :         "initial_stress",
      57           2 :         "ComputeEigenstrainFromInitialStress: " + Moose::stringify(LIBMESH_DIM * LIBMESH_DIM) +
      58           2 :             " initial stress functions must be provided.  You supplied " + Moose::stringify(num) +
      59             :             "\n");
      60             : 
      61        1790 :   _initial_stress_fcn.resize(num);
      62       17900 :   for (unsigned i = 0; i < num; ++i)
      63       16110 :     _initial_stress_fcn[i] = &getFunctionByName(fcn_names[i]);
      64             : 
      65        1790 :   if (_ini_aux_provided)
      66             :   {
      67          20 :     const std::size_t aux_size = coupledComponents("initial_stress_aux");
      68          20 :     if (aux_size != LIBMESH_DIM * LIBMESH_DIM)
      69           4 :       paramError("initial_stress_aux",
      70           2 :                  "ComputeEigenstrainFromInitialStress: If you supply initial_stress_aux, " +
      71           0 :                      Moose::stringify(LIBMESH_DIM * LIBMESH_DIM) +
      72           2 :                      " values must be given.  You supplied " + Moose::stringify(aux_size) + "\n");
      73             :   }
      74        1788 : }
      75             : 
      76             : void
      77      264720 : ComputeEigenstrainFromInitialStress::computeQpEigenstrain()
      78             : {
      79      264720 :   if (_t_step == 1)
      80             :   {
      81      264528 :     RankTwoTensor initial_stress;
      82     1058112 :     for (unsigned i = 0; i < LIBMESH_DIM; ++i)
      83     3174336 :       for (unsigned j = 0; j < LIBMESH_DIM; ++j)
      84             :       {
      85     2380752 :         initial_stress(i, j) = _initial_stress_fcn[i * LIBMESH_DIM + j]->value(_t, _q_point[_qp]);
      86     2380752 :         if (_ini_aux_provided)
      87        8640 :           initial_stress(i, j) *= (*_ini_aux[i * LIBMESH_DIM + j])[_qp];
      88             :       }
      89             : 
      90      264528 :     _eigenstrain[_qp] = -_elasticity_tensor[_qp].invSymm() * initial_stress;
      91             :   }
      92             :   else
      93         192 :     _eigenstrain[_qp] = _eigenstrain_old[_qp];
      94      264720 : }