Phenomenological constitutive model state variable evolution rate component userobject class. More...

#include <CrystalPlasticityStateVarRateComponentVoce.h>

Inheritance diagram for CrystalPlasticityStateVarRateComponentVoce:

Public Member Functions
	CrystalPlasticityStateVarRateComponentVoce (const InputParameters &parameters)

virtual bool	calcStateVariableEvolutionRateComponent (unsigned int qp, std::vector< Real > &val) const
	computing the slip system hardening rate More...

virtual unsigned int	variableSize () const
	Returns the size of variable. More...

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	crystalLatticeTypeOptions ()
	class for switching between different crystal lattice types More...

Protected Member Functions
virtual void	initSlipSystemPlaneID (std::vector< unsigned int > &_slipSystem_PlaneID) const
	method associating slip system to their group by generating a vector containing the association between slip system number and slip plane number More...

virtual void	initSlipSystemGroupID (std::vector< unsigned int > &_slipSystem_GroupID) const
	method associating slip system to their slip plane by generating a vector containing the association between slip system number and provided group edges More...

virtual Real	getHardeningCoefficient (unsigned int slipSystemIndex_i, unsigned int slipSystemIndex_j) const
	method retriving the appropiate self/latent hardening coefficient More...

Protected Attributes
const MaterialProperty< std::vector< Real > > &	_mat_prop_slip_rate

const MaterialProperty< std::vector< Real > > &	_mat_prop_state_var

MooseEnum	_crystal_lattice_type
	the variable to switch crystal lattice type (i.e. FCC or BCC) More...

const unsigned int	_n_groups
	the number of slip system groups More...

std::vector< unsigned int >	_slipSystem_PlaneID
	the vector associating a slip system to its slip plane ID More...

std::vector< unsigned int >	_slipSystem_GroupID
	the vector associating a slip system to its groud ID More...

unsigned int	_variable_size


std::vector< unsigned int >	_groups
	the vectors of the input paramters More...

std::vector< Real >	_h0_group_values

std::vector< Real >	_tau0_group_values

std::vector< Real >	_tauSat_group_values

std::vector< Real >	_hardeningExponent_group_values

std::vector< Real >	_selfHardening_group_values

std::vector< Real >	_coplanarHardening_group_values

std::vector< Real >	_GroupGroup_Hardening_group_values

Detailed Description

Phenomenological constitutive model state variable evolution rate component userobject class.

Definition at line 23 of file CrystalPlasticityStateVarRateComponentVoce.h.

Constructor & Destructor Documentation

◆ CrystalPlasticityStateVarRateComponentVoce()

CrystalPlasticityStateVarRateComponentVoce::CrystalPlasticityStateVarRateComponentVoce ( const InputParameters & parameters )

Definition at line 80 of file CrystalPlasticityStateVarRateComponentVoce.C.

   : CrystalPlasticityStateVarRateComponent(parameters),
     _mat_prop_slip_rate(
         getMaterialProperty<std::vector<Real>>(parameters.get<std::string>("uo_slip_rate_name"))),
     _mat_prop_state_var(
         getMaterialProperty<std::vector<Real>>(parameters.get<std::string>("uo_state_var_name"))),
     _crystal_lattice_type(getParam<MooseEnum>("crystal_lattice_type")),
     _groups(getParam<std::vector<unsigned int>>("groups")),
     _h0_group_values(getParam<std::vector<Real>>("h0_group_values")),
     _tau0_group_values(getParam<std::vector<Real>>("tau0_group_values")),
     _tauSat_group_values(getParam<std::vector<Real>>("tauSat_group_values")),
     _hardeningExponent_group_values(getParam<std::vector<Real>>("hardeningExponent_group_values")),
     _selfHardening_group_values(getParam<std::vector<Real>>("selfHardening_group_values")),
     _coplanarHardening_group_values(getParam<std::vector<Real>>("coplanarHardening_group_values")),
     _GroupGroup_Hardening_group_values(
         getParam<std::vector<Real>>("GroupGroup_Hardening_group_values")),
     _n_groups(_groups.size())
 {
   // perform input checks
   if (_n_groups < 2)
     paramError("groups",
                "the number of slip system groups provided is not "
                "correct. At least two values are expected");
  
   // check the size of all the user provided parameters
   if (_h0_group_values.size() != _n_groups - 1)
     paramError("h0_group_values",
                "the number of supplied parameters does not"
                " match the number of ip system groups");
  
   if (_tau0_group_values.size() != _n_groups - 1)
     paramError("tau0_group_values",
                "the number of supplied parameters does "
                "not match the number of slip system groups");
  
   if (_tauSat_group_values.size() != _n_groups - 1)
     paramError("tauSat_group_values",
                "the number of supplied parameters does "
                "not match the number of slip system groups");
  
   if (_hardeningExponent_group_values.size() != _n_groups - 1)
     paramError("hardeningExponent_group_values",
                "the number of supplied "
                "parameters does not match the number of slip system groups");
  
   if (_selfHardening_group_values.size() != _n_groups - 1)
     paramError("selfHardening_group_values",
                "the number of supplied parameters "
                "does not match the number of slip system groups");
  
   if (_coplanarHardening_group_values.size() != _n_groups - 1)
     paramError("coplanarHardening_group_values",
                "the number of supplied "
                "parameters does not match the number of slip system groups");
  
   if (_GroupGroup_Hardening_group_values.size() != (_n_groups - 1) * (_n_groups - 1))
     paramError("GroupGroup_Hardening_group_values",
                "the number of supplied "
                "parameters does not match the number of slip system groups");
  
   // initialize useful variables;
   initSlipSystemPlaneID(_slipSystem_PlaneID);
   initSlipSystemGroupID(_slipSystem_GroupID);
 }

Member Function Documentation

◆ calcStateVariableEvolutionRateComponent()

bool CrystalPlasticityStateVarRateComponentVoce::calcStateVariableEvolutionRateComponent	(	unsigned int	qp,
		std::vector< Real > &	val
	)		const

virtual

computing the slip system hardening rate

Implements CrystalPlasticityStateVarRateComponent.

Definition at line 147 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
   val.assign(_variable_size, 0.0);
  
   unsigned int group_i;
   Real h0;
   Real tau_0;
   Real tau_sat;
   Real hardening_exponenet;
   Real delta_tau;
  
   DenseVector<Real> hb(_variable_size);
  
   for (unsigned int i = 0; i < _variable_size; ++i)
   {
     group_i = _slipSystem_GroupID[i];
     h0 = _h0_group_values[group_i];
     tau_0 = _tau0_group_values[group_i];
     tau_sat = _tauSat_group_values[group_i];
     hardening_exponenet = _hardeningExponent_group_values[group_i];
  
     delta_tau = tau_sat - tau_0;
  
     hb(i) = h0 *
             std::pow(std::abs(1.0 - (_mat_prop_state_var[qp][i] - tau_0) / delta_tau),
                      hardening_exponenet) *
             std::copysign(1.0, 1.0 - (_mat_prop_state_var[qp][i] - tau_0) / delta_tau);
   }
  
   for (unsigned int i = 0; i < _variable_size; ++i)
     for (unsigned int j = 0; j < _variable_size; ++j)
     {
       const Real q_ab = getHardeningCoefficient(i, j);
       val[i] += std::abs(_mat_prop_slip_rate[qp][j]) * q_ab * hb(j);
     }
  
   return true;
 }

◆ crystalLatticeTypeOptions()

MooseEnum CrystalPlasticityStateVarRateComponentVoce::crystalLatticeTypeOptions ( )

static

class for switching between different crystal lattice types

Definition at line 188 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
   return MooseEnum("FCC BCC", "FCC");
 }

Referenced by validParams().

◆ getHardeningCoefficient()

Real CrystalPlasticityStateVarRateComponentVoce::getHardeningCoefficient	(	unsigned int	slipSystemIndex_i,
		unsigned int	slipSystemIndex_j
	)		const

protectedvirtual

method retriving the appropiate self/latent hardening coefficient

Definition at line 243 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
   // collect slip system plane and group
   const unsigned int group_i = _slipSystem_GroupID[slipSystemIndex_i];
   const unsigned int group_j = _slipSystem_GroupID[slipSystemIndex_j];
   const unsigned int plane_i = _slipSystem_PlaneID[slipSystemIndex_i];
   const unsigned int plane_j = _slipSystem_PlaneID[slipSystemIndex_j];
  
   // create check for clarity
   const bool same_slipSystem = slipSystemIndex_i == slipSystemIndex_j;
   const bool same_group = group_i == group_j;
   const bool same_plane = plane_i == plane_j;
  
   // retrieve appropriate coefficient
   Real q_ab;
   if (same_slipSystem)
     q_ab = _selfHardening_group_values[group_i];
   else if (same_plane)
     q_ab = _coplanarHardening_group_values[group_i];
   else if (same_group) // here for debugging purposes this if could be removed
     q_ab = _GroupGroup_Hardening_group_values[group_i * (_n_groups - 1) + group_i];
   else if (!same_group)
     q_ab = _GroupGroup_Hardening_group_values[group_i * (_n_groups - 1) + group_j];
   else // here for debugging purposes
     mooseError("VoceHardeningError:getHardeningCoefficient: case not listed, abort ");
  
   return q_ab;
 }

Referenced by calcStateVariableEvolutionRateComponent().

◆ initSlipSystemGroupID()

void CrystalPlasticityStateVarRateComponentVoce::initSlipSystemGroupID ( std::vector< unsigned int > & _slipSystem_GroupID ) const

protectedvirtual

method associating slip system to their slip plane by generating a vector containing the association between slip system number and provided group edges

Definition at line 228 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
   _slipSystem_GroupID.assign(_variable_size, 0);
  
   for (unsigned int slipSystemIndex = 0; slipSystemIndex < _variable_size; ++slipSystemIndex)
     for (unsigned int i = 0; i < _n_groups - 1; ++i)
       if (slipSystemIndex >= _groups[i] && slipSystemIndex < _groups[i + 1])
       {
         _slipSystem_GroupID[slipSystemIndex] = i;
         break;
       }
 }

Referenced by CrystalPlasticityStateVarRateComponentVoce().

◆ initSlipSystemPlaneID()

void CrystalPlasticityStateVarRateComponentVoce::initSlipSystemPlaneID ( std::vector< unsigned int > & _slipSystem_PlaneID ) const

protectedvirtual

method associating slip system to their group by generating a vector containing the association between slip system number and slip plane number

Definition at line 194 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
   _slipSystem_PlaneID.assign(_variable_size, 0);
  
   for (unsigned int slipSystemIndex = 0; slipSystemIndex < _variable_size; ++slipSystemIndex)
     switch (_crystal_lattice_type)
     {
       case 0: // FCC
         if (slipSystemIndex < 12)
           _slipSystem_PlaneID[slipSystemIndex] = slipSystemIndex / 3;
         else
           mooseError("FCC with more than 12 slip planes is not implemented ");
  
         break;
  
       case 1: // BCC
         if (slipSystemIndex < 12)
           _slipSystem_PlaneID[slipSystemIndex] = slipSystemIndex / 2;
  
         else if (slipSystemIndex >= 12 && slipSystemIndex < 48)
           _slipSystem_PlaneID[slipSystemIndex] = (slipSystemIndex - 6);
  
         else
           mooseError("BCC with more than 48 slip systems is not implemented ");
  
         break;
  
       default:
         mooseError("VoceHardeningError: Pass valid crustal_structure_type ");
     }
 }

Referenced by CrystalPlasticityStateVarRateComponentVoce().

◆ validParams()

InputParameters CrystalPlasticityStateVarRateComponentVoce::validParams ( )

static

Definition at line 18 of file CrystalPlasticityStateVarRateComponentVoce.C.

 {
  
   InputParameters params = CrystalPlasticityStateVarRateComponent::validParams();
   params.addParam<std::string>(
       "uo_slip_rate_name",
       "Name of slip rate property: Same as slip rate user object specified in input file.");
   params.addParam<std::string>("uo_state_var_name",
                                "Name of state variable property: Same as "
                                "state variable user object specified in input "
                                "file.");
   params.addParam<MooseEnum>(
       "crystal_lattice_type",
       CrystalPlasticityStateVarRateComponentVoce::crystalLatticeTypeOptions(),
       "Type of crystal lattyce structure output");
   params.addParam<std::vector<unsigned int>>("groups",
                                              "To group the initial values on different "
                                              "slip systems 'format: [start end)', i.e.'0 "
                                              "12 24 48' groups 0-11, 12-23 and 24-48 ");
   params.addParam<std::vector<Real>>("h0_group_values",
                                      "h0 hardening constant for each group "
                                      " i.e. '0.0 1.0 2.0' means 0-11 = 0.0, "
                                      "12-23 = 1.0 and 24-48 = 2.0 ");
   params.addParam<std::vector<Real>>("tau0_group_values",
                                      "The initial critical resolved shear stress"
                                      "corresponding to each group"
                                      " i.e. '100.0 110.0 120.0' means 0-11 = 100.0, "
                                      "12-23 = 110.0 and 24-48 = 120.0 ");
   params.addParam<std::vector<Real>>("tauSat_group_values",
                                      "The saturation resolved shear stress"
                                      "corresponding to each group"
                                      " i.e. '150.0 170.0 180.0' means 0-11 = 150.0, "
                                      "12-23 = 170.0 and 24-48 = 180.0 ");
   params.addParam<std::vector<Real>>("hardeningExponent_group_values",
                                      "The hardening exponent m"
                                      "corresponding to each group"
                                      " i.e. '1.0 2.0 3.0' means 0-11 = 1.0, "
                                      "12-23 = 2.0 and 24-48 = 3.0 ");
   params.addParam<std::vector<Real>>("selfHardening_group_values",
                                      "The self hardening coefficient q_aa"
                                      "corresponding to each group"
                                      " i.e. '1.0 2.0 3.0' means 0-11 = 1.0, "
                                      "12-23 = 2.0 and 24-48 = 3.0 "
                                      " usually these are all 1.");
   params.addParam<std::vector<Real>>("coplanarHardening_group_values",
                                      "The coplanar latent hardening coefficient q_ab"
                                      "corresponding to each group"
                                      " i.e. '1.0 2.0 3.0' means 0-11 = 1.0, "
                                      "12-23 = 2.0 and 24-48 = 3.0 ");
   params.addParam<std::vector<Real>>("GroupGroup_Hardening_group_values",
                                      "The group-to-group latent hardening coefficient q_ab"
                                      "This is a NxN vector"
                                      " i.e. '1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0' "
                                      "means non-coplanar slip systems in gr_11,22,33= "
                                      "1.0, 5.0 and 9.0 respectively."
                                      "latent hardening between for gr_12,13 = 2.0 3.0"
                                      " respectively");
   params.addClassDescription("Phenomenological Voce constitutive model state variable evolution "
                              "rate component base class.");
   return params;
 }