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 "CrystalPlasticityKalidindiUpdate.h"
      11             : #include "libmesh/int_range.h"
      12             : 
      13             : registerMooseObject("SolidMechanicsApp", CrystalPlasticityKalidindiUpdate);
      14             : 
      15             : InputParameters
      16         563 : CrystalPlasticityKalidindiUpdate::validParams()
      17             : {
      18         563 :   InputParameters params = CrystalPlasticityStressUpdateBase::validParams();
      19         563 :   params.addClassDescription("Kalidindi version of homogeneous crystal plasticity.");
      20        1126 :   params.addParam<Real>("r", 1.0, "Latent hardening coefficient");
      21        1126 :   params.addParam<Real>("h", 541.5, "hardening constants");
      22        1126 :   params.addParam<Real>("t_sat", 109.8, "saturated slip system strength");
      23        1126 :   params.addParam<Real>("gss_a", 2.5, "coefficient for hardening");
      24        1126 :   params.addParam<Real>("ao", 0.001, "slip rate coefficient");
      25        1126 :   params.addParam<Real>("xm", 0.1, "exponent for slip rate");
      26        1126 :   params.addParam<Real>("gss_initial", 60.8, "initial lattice friction strength of the material");
      27             : 
      28        1126 :   params.addParam<MaterialPropertyName>(
      29             :       "total_twin_volume_fraction",
      30             :       "Total twin volume fraction, if twinning is considered in the simulation");
      31             : 
      32         563 :   return params;
      33           0 : }
      34             : 
      35         420 : CrystalPlasticityKalidindiUpdate::CrystalPlasticityKalidindiUpdate(
      36         420 :     const InputParameters & parameters)
      37             :   : CrystalPlasticityStressUpdateBase(parameters),
      38             :     // Constitutive values
      39         420 :     _r(getParam<Real>("r")),
      40         840 :     _h(getParam<Real>("h")),
      41         840 :     _tau_sat(getParam<Real>("t_sat")),
      42         840 :     _gss_a(getParam<Real>("gss_a")),
      43         840 :     _ao(getParam<Real>("ao")),
      44         840 :     _xm(getParam<Real>("xm")),
      45         840 :     _gss_initial(getParam<Real>("gss_initial")),
      46             : 
      47             :     // resize vectors used in the consititutive slip hardening
      48         420 :     _hb(_number_slip_systems, 0.0),
      49         420 :     _slip_resistance_increment(_number_slip_systems, 0.0),
      50             : 
      51             :     // resize local caching vectors used for substepping
      52         420 :     _previous_substep_slip_resistance(_number_slip_systems, 0.0),
      53         420 :     _slip_resistance_before_update(_number_slip_systems, 0.0),
      54             : 
      55             :     // Twinning contributions, if used
      56         420 :     _include_twinning_in_Lp(parameters.isParamValid("total_twin_volume_fraction")),
      57         840 :     _twin_volume_fraction_total(_include_twinning_in_Lp
      58         480 :                                     ? &getMaterialPropertyOld<Real>("total_twin_volume_fraction")
      59         420 :                                     : nullptr)
      60             : {
      61         420 : }
      62             : 
      63             : void
      64       26496 : CrystalPlasticityKalidindiUpdate::initQpStatefulProperties()
      65             : {
      66       26496 :   CrystalPlasticityStressUpdateBase::initQpStatefulProperties();
      67      344448 :   for (const auto i : make_range(_number_slip_systems))
      68             :   {
      69      317952 :     _slip_resistance[_qp][i] = _gss_initial;
      70      317952 :     _slip_increment[_qp][i] = 0.0;
      71             :   }
      72       26496 : }
      73             : 
      74             : void
      75     1063043 : CrystalPlasticityKalidindiUpdate::setInitialConstitutiveVariableValues()
      76             : {
      77             :   // Would also set old dislocation densities here if included in this model
      78     1063043 :   _slip_resistance[_qp] = _slip_resistance_old[_qp];
      79     1063043 :   _previous_substep_slip_resistance = _slip_resistance_old[_qp];
      80     1063043 : }
      81             : 
      82             : void
      83     1089553 : CrystalPlasticityKalidindiUpdate::setSubstepConstitutiveVariableValues()
      84             : {
      85             :   // Would also set substepped dislocation densities here if included in this model
      86     1089553 :   _slip_resistance[_qp] = _previous_substep_slip_resistance;
      87     1089553 : }
      88             : 
      89             : bool
      90     4813186 : CrystalPlasticityKalidindiUpdate::calculateSlipRate()
      91             : {
      92    62322802 :   for (const auto i : make_range(_number_slip_systems))
      93             :   {
      94    57530734 :     _slip_increment[_qp][i] =
      95    57530734 :         _ao * std::pow(std::abs(_tau[_qp][i] / _slip_resistance[_qp][i]), 1.0 / _xm);
      96    57530734 :     if (_tau[_qp][i] < 0.0)
      97    24958850 :       _slip_increment[_qp][i] *= -1.0;
      98             : 
      99    57530734 :     if (std::abs(_slip_increment[_qp][i]) * _substep_dt > _slip_incr_tol)
     100             :     {
     101       21118 :       if (_print_convergence_message)
     102           0 :         mooseWarning("Maximum allowable slip increment exceeded ",
     103           0 :                      std::abs(_slip_increment[_qp][i]) * _substep_dt);
     104             : 
     105             :       return false;
     106             :     }
     107             :   }
     108             :   return true;
     109             : }
     110             : 
     111             : void
     112     4792068 : CrystalPlasticityKalidindiUpdate::calculateEquivalentSlipIncrement(
     113             :     RankTwoTensor & equivalent_slip_increment)
     114             : {
     115     4792068 :   if (_include_twinning_in_Lp)
     116             :   {
     117    15795741 :     for (const auto i : make_range(_number_slip_systems))
     118    14580684 :       equivalent_slip_increment += (1.0 - (*_twin_volume_fraction_total)[_qp]) *
     119    14580684 :                                    _flow_direction[_qp][i] * _slip_increment[_qp][i] * _substep_dt;
     120             :   }
     121             :   else // if no twinning volume fraction material property supplied, use base class
     122     3577011 :     CrystalPlasticityStressUpdateBase::calculateEquivalentSlipIncrement(equivalent_slip_increment);
     123     4792068 : }
     124             : 
     125             : void
     126     4753188 : CrystalPlasticityKalidindiUpdate::calculateConstitutiveSlipDerivative(
     127             :     std::vector<Real> & dslip_dtau)
     128             : {
     129    61791444 :   for (const auto i : make_range(_number_slip_systems))
     130             :   {
     131    57038256 :     if (MooseUtils::absoluteFuzzyEqual(_tau[_qp][i], 0.0))
     132     3198990 :       dslip_dtau[i] = 0.0;
     133             :     else
     134    53839266 :       dslip_dtau[i] = _ao / _xm *
     135    53839266 :                       std::pow(std::abs(_tau[_qp][i] / _slip_resistance[_qp][i]), 1.0 / _xm - 1.0) /
     136             :                       _slip_resistance[_qp][i];
     137             :   }
     138     4753188 : }
     139             : 
     140             : bool
     141     1073819 : CrystalPlasticityKalidindiUpdate::areConstitutiveStateVariablesConverged()
     142             : {
     143     1073819 :   return isConstitutiveStateVariableConverged(_slip_resistance[_qp],
     144     1073819 :                                               _slip_resistance_before_update,
     145     1073819 :                                               _previous_substep_slip_resistance,
     146     1073819 :                                               _resistance_tol);
     147             : }
     148             : 
     149             : void
     150     1068435 : CrystalPlasticityKalidindiUpdate::updateSubstepConstitutiveVariableValues()
     151             : {
     152             :   // Would also set substepped dislocation densities here if included in this model
     153     1068435 :   _previous_substep_slip_resistance = _slip_resistance[_qp];
     154     1068435 : }
     155             : 
     156             : void
     157     1211730 : CrystalPlasticityKalidindiUpdate::cacheStateVariablesBeforeUpdate()
     158             : {
     159     1211730 :   _slip_resistance_before_update = _slip_resistance[_qp];
     160     1211730 : }
     161             : 
     162             : void
     163     1211730 : CrystalPlasticityKalidindiUpdate::calculateStateVariableEvolutionRateComponent()
     164             : {
     165    15752490 :   for (const auto i : make_range(_number_slip_systems))
     166             :   {
     167             :     // Clear out increment from the previous iteration
     168    14540760 :     _slip_resistance_increment[i] = 0.0;
     169             : 
     170    14540760 :     _hb[i] = _h * std::pow(std::abs(1.0 - _slip_resistance[_qp][i] / _tau_sat), _gss_a);
     171    14540760 :     const Real hsign = 1.0 - _slip_resistance[_qp][i] / _tau_sat;
     172    14540760 :     if (hsign < 0.0)
     173           0 :       _hb[i] *= -1.0;
     174             :   }
     175             : 
     176    15752490 :   for (const auto i : make_range(_number_slip_systems))
     177             :   {
     178   189029880 :     for (const auto j : make_range(_number_slip_systems))
     179             :     {
     180             :       unsigned int iplane, jplane;
     181   174489120 :       iplane = i / 3;
     182   174489120 :       jplane = j / 3;
     183             : 
     184   174489120 :       if (iplane == jplane) // self vs. latent hardening
     185    43622280 :         _slip_resistance_increment[i] +=
     186    43622280 :             std::abs(_slip_increment[_qp][j]) * _hb[j]; // q_{ab} = 1.0 for self hardening
     187             :       else
     188   130866840 :         _slip_resistance_increment[i] +=
     189   130866840 :             std::abs(_slip_increment[_qp][j]) * _r * _hb[j]; // latent hardenign
     190             :     }
     191             :   }
     192     1211730 : }
     193             : 
     194             : bool
     195     1211730 : CrystalPlasticityKalidindiUpdate::updateStateVariables()
     196             : {
     197             :   // Now perform the check to see if the slip system should be updated
     198    15752490 :   for (const auto i : make_range(_number_slip_systems))
     199             :   {
     200    14540760 :     _slip_resistance_increment[i] *= _substep_dt;
     201    14540760 :     if (_previous_substep_slip_resistance[i] < _zero_tol && _slip_resistance_increment[i] < 0.0)
     202           0 :       _slip_resistance[_qp][i] = _previous_substep_slip_resistance[i];
     203             :     else
     204    14540760 :       _slip_resistance[_qp][i] =
     205    14540760 :           _previous_substep_slip_resistance[i] + _slip_resistance_increment[i];
     206             : 
     207    14540760 :     if (_slip_resistance[_qp][i] < 0.0)
     208             :       return false;
     209             :   }
     210             :   return true;
     211             : }