Material class for conventional correspondence material model with fictitious force stabilization for small strain. More...

#include <ComputeForceStabilizedSmallStrainNOSPD.h>

Inheritance diagram for ComputeForceStabilizedSmallStrainNOSPD:

[legend]

Public Member Functions
	ComputeForceStabilizedSmallStrainNOSPD (const InputParameters &parameters)

virtual void	initQpStatefulProperties () override

Protected Member Functions
virtual void	computeQpDeformationGradient () override
	Function to compute bond-associated deformation gradient. More...

virtual void	computeQpStrain () override
	Function to compute strain tensors. More...

virtual void	computeQpTotalStrain ()
	Function to compute the total strain tensor for small strain case. More...

virtual void	computeProperties () override

virtual void	computeBondStretch () override

Protected Attributes
const MaterialProperty< RankFourTensor > &	_Cijkl
	Elasticity tensor. More...

MaterialProperty< Real > &	_sf_coeff
	Material property for fictitious force. More...

const bool	_plane_strain
	Plane strain problem or not, this is only used for mechanical stretch calculation. More...


std::vector< MaterialPropertyName >	_eigenstrain_names

std::vector< const MaterialProperty< RankTwoTensor > * >	_eigenstrains


MaterialProperty< RankTwoTensor > &	_shape2
	Material properties to store. More...

MaterialProperty< RankTwoTensor > &	_deformation_gradient

MaterialProperty< RankTwoTensor > &	_ddgraddu

MaterialProperty< RankTwoTensor > &	_ddgraddv

MaterialProperty< RankTwoTensor > &	_ddgraddw

MaterialProperty< RankTwoTensor > &	_total_strain

MaterialProperty< RankTwoTensor > &	_mechanical_strain

MaterialProperty< Real > &	_multi

Detailed Description

Material class for conventional correspondence material model with fictitious force stabilization for small strain.

Definition at line 23 of file ComputeForceStabilizedSmallStrainNOSPD.h.

Constructor & Destructor Documentation

◆ ComputeForceStabilizedSmallStrainNOSPD()

ComputeForceStabilizedSmallStrainNOSPD::ComputeForceStabilizedSmallStrainNOSPD ( const InputParameters & parameters )

Definition at line 27 of file ComputeForceStabilizedSmallStrainNOSPD.C.

   : ComputeSmallStrainNOSPD(parameters),
     _Cijkl(getMaterialProperty<RankFourTensor>("elasticity_tensor")),
     _sf_coeff(declareProperty<Real>("stabilization_force_coeff"))
 {
 }

Member Function Documentation

◆ computeBondStretch()

void ComputeStrainBaseNOSPD::computeBondStretch ( )

overrideprotectedvirtualinherited

Definition at line 156 of file ComputeStrainBaseNOSPD.C.

 {
   _total_stretch[0] = _current_length / _origin_length - 1.0;
   _total_stretch[1] = _total_stretch[0];
   _mechanical_stretch[0] = _total_stretch[0];
  
   Real factor = 1.0;
   if (_plane_strain)
     factor = 1.0 + ElasticityTensorTools::getIsotropicPoissonsRatio(_Cijkl[0]);
  
   for (auto es : _eigenstrains)
     _mechanical_stretch[0] -= 0.5 * factor * ((*es)[0](2, 2) + (*es)[1](2, 2));
  
   _mechanical_stretch[1] = _mechanical_stretch[0];
 }

Referenced by ComputeStrainBaseNOSPD::computeProperties().

◆ computeProperties()

void ComputeStrainBaseNOSPD::computeProperties ( )

overrideprotectedvirtualinherited

Definition at line 145 of file ComputeStrainBaseNOSPD.C.

 {
   setupMeshRelatedData();     // function from base class
   computeBondCurrentLength(); // current length of a bond from base class
   computeBondStretch();       // stretch of a bond
  
   for (_qp = 0; _qp < _nnodes; ++_qp)
     computeQpStrain();
 }

◆ computeQpDeformationGradient()

void ComputeForceStabilizedSmallStrainNOSPD::computeQpDeformationGradient ( )

overrideprotectedvirtual

Function to compute bond-associated deformation gradient.

Reimplemented from ComputeStrainBaseNOSPD.

Definition at line 36 of file ComputeForceStabilizedSmallStrainNOSPD.C.

 {
   _shape2[_qp].zero();
   _deformation_gradient[_qp].zero();
   _ddgraddu[_qp].zero();
   _ddgraddv[_qp].zero();
   _ddgraddw[_qp].zero();
  
   if (_dim == 2)
     _shape2[_qp](2, 2) = _deformation_gradient[_qp](2, 2) = 1.0;
  
   const Node * cur_nd = _current_elem->node_ptr(_qp);
   std::vector<dof_id_type> neighbors = _pdmesh.getNeighbors(cur_nd->id());
   std::vector<dof_id_type> bonds = _pdmesh.getBonds(cur_nd->id());
  
   // calculate the shape tensor and prepare the deformation gradient tensor
   RealGradient ori_vec(_dim);
   RealGradient cur_vec(_dim);
  
   for (unsigned int j = 0; j < neighbors.size(); ++j)
     if (_bond_status_var->getElementalValue(_pdmesh.elemPtr(bonds[j])) > 0.5)
     {
       Node * node_j = _pdmesh.nodePtr(neighbors[j]);
       Real vol_j = _pdmesh.getPDNodeVolume(neighbors[j]);
       ori_vec = *node_j - *_pdmesh.nodePtr(cur_nd->id());
  
       for (unsigned int k = 0; k < _dim; ++k)
         cur_vec(k) = ori_vec(k) + _disp_var[k]->getNodalValue(*node_j) -
                      _disp_var[k]->getNodalValue(*cur_nd);
  
       Real ori_len = ori_vec.norm();
       for (unsigned int k = 0; k < _dim; ++k)
       {
         for (unsigned int l = 0; l < _dim; ++l)
         {
           _shape2[_qp](k, l) += vol_j * _horiz_rad[_qp] / ori_len * ori_vec(k) * ori_vec(l);
           _deformation_gradient[_qp](k, l) +=
               vol_j * _horiz_rad[_qp] / ori_len * cur_vec(k) * ori_vec(l);
         }
         // calculate derivatives of deformation_gradient w.r.t displacements of node i
         _ddgraddu[_qp](0, k) += -vol_j * _horiz_rad[_qp] / ori_len * ori_vec(k);
         _ddgraddv[_qp](1, k) += -vol_j * _horiz_rad[_qp] / ori_len * ori_vec(k);
         if (_dim == 3)
           _ddgraddw[_qp](2, k) += -vol_j * _horiz_rad[_qp] / ori_len * ori_vec(k);
       }
     }
  
   // finalize the deformation gradient tensor
   _deformation_gradient[_qp] *= _shape2[_qp].inverse();
   _ddgraddu[_qp] *= _shape2[_qp].inverse();
   _ddgraddv[_qp] *= _shape2[_qp].inverse();
   _ddgraddw[_qp] *= _shape2[_qp].inverse();
  
   Real youngs_modulus = ElasticityTensorTools::getIsotropicYoungsModulus(_Cijkl[_qp]);
   _sf_coeff[_qp] = youngs_modulus * _pdmesh.getNodeAvgSpacing(_current_elem->node_id(_qp)) *
                    _horiz_rad[_qp] / _origin_length;
   _multi[_qp] = _horiz_rad[_qp] / _origin_length * _node_vol[0] * _node_vol[1];
 }

◆ computeQpStrain()

void ComputeSmallStrainNOSPD::computeQpStrain ( )

overrideprotectedvirtualinherited

Function to compute strain tensors.

Implements ComputeStrainBaseNOSPD.

Definition at line 33 of file ComputeSmallStrainNOSPD.C.

 {
   computeQpDeformationGradient();
  
   computeQpTotalStrain();
  
   _mechanical_strain[_qp] = _total_strain[_qp];
  
   // Subtract Eigen strains
   for (auto es : _eigenstrains)
     _mechanical_strain[_qp] -= (*es)[_qp];
 }

◆ computeQpTotalStrain()

void ComputeSmallStrainNOSPD::computeQpTotalStrain ( )

protectedvirtualinherited

Function to compute the total strain tensor for small strain case.

Reimplemented in ComputePlaneSmallStrainNOSPD.

Definition at line 47 of file ComputeSmallStrainNOSPD.C.

 {
   // the small strain tensor
   _total_strain[_qp] = 0.5 * (_deformation_gradient[_qp].transpose() + _deformation_gradient[_qp]) -
                        RankTwoTensor(RankTwoTensor::initIdentity);
 }

Referenced by ComputeSmallStrainNOSPD::computeQpStrain().

◆ initQpStatefulProperties()

void ComputeStrainBaseNOSPD::initQpStatefulProperties ( )

overridevirtualinherited

Definition at line 57 of file ComputeStrainBaseNOSPD.C.

 {
   _mechanical_strain[_qp].zero();
   _total_strain[_qp].zero();
   _deformation_gradient[_qp].zero();
   _deformation_gradient[_qp].addIa(1.0);
  
   if (_qrule->n_points() < 2) // Gauss_Lobatto: order = 2n-3 (n is number of qp)
     mooseError(
         "NOSPD models require Gauss_Lobatto rule and a minimum of 2 quadrature points, i.e., "
         "order of FIRST");
 }