Material class for 2D correspondence material model for small strain: plane strain, generalized plane strain, weak plane stress. More...

#include <ComputePlaneSmallStrainNOSPD.h>

Inheritance diagram for ComputePlaneSmallStrainNOSPD:

[legend]

Public Member Functions
	ComputePlaneSmallStrainNOSPD (const InputParameters &parameters)

virtual void	initQpStatefulProperties () override

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

Real	computeOutOfPlaneStrain ()
	Function to compute out-of-plane component of strain tensor for generalized plane strain and weak plane stress. More...

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

virtual void	computeProperties () override

virtual void	computeBondStretch () override

virtual void	computeQpDeformationGradient ()
	Function to compute bond-associated deformation gradient. More...

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


const MaterialProperty< RankFourTensor > &	_Cijkl
	Material properties to fetch. 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

Private Attributes

const bool	_scalar_out_of_plane_strain_coupled
	Scalar out-of-plane strain for generalized plane strain. More...

const VariableValue &	_scalar_out_of_plane_strain


const bool	_out_of_plane_strain_coupled
	Out-of-plane strain for weak plane stress. More...

const VariableValue &	_out_of_plane_strain

Detailed Description

Material class for 2D correspondence material model for small strain: plane strain, generalized plane strain, weak plane stress.

Definition at line 24 of file ComputePlaneSmallStrainNOSPD.h.

Constructor & Destructor Documentation

◆ ComputePlaneSmallStrainNOSPD()

ComputePlaneSmallStrainNOSPD::ComputePlaneSmallStrainNOSPD ( const InputParameters & parameters )

Definition at line 32 of file ComputePlaneSmallStrainNOSPD.C.

   : ComputeSmallStrainNOSPD(parameters),
     _scalar_out_of_plane_strain_coupled(isCoupledScalar("scalar_out_of_plane_strain")),
     _scalar_out_of_plane_strain(_scalar_out_of_plane_strain_coupled
                                     ? coupledScalarValue("scalar_out_of_plane_strain")
                                     : _zero),
     _out_of_plane_strain_coupled(isCoupled("out_of_plane_strain")),
     _out_of_plane_strain(_out_of_plane_strain_coupled ? coupledValue("out_of_plane_strain") : _zero)
 {
 }

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().

◆ computeOutOfPlaneStrain()

Real ComputePlaneSmallStrainNOSPD::computeOutOfPlaneStrain ( )

protected

Function to compute out-of-plane component of strain tensor for generalized plane strain and weak plane stress.

Returns: The value of out-of-plane strain

Definition at line 53 of file ComputePlaneSmallStrainNOSPD.C.

 {
   if (_scalar_out_of_plane_strain_coupled)
     return _scalar_out_of_plane_strain[0];
   else
     return _out_of_plane_strain[_qp];
 }

Referenced by computeQpTotalStrain().

◆ 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 ComputeStrainBaseNOSPD::computeQpDeformationGradient ( )

protectedvirtualinherited

Function to compute bond-associated deformation gradient.

Reimplemented in ComputeForceStabilizedSmallStrainNOSPD.

Definition at line 71 of file ComputeStrainBaseNOSPD.C.

 {
   _shape2[_qp].zero();
   _deformation_gradient[_qp].zero();
   _ddgraddu[_qp].zero();
   _ddgraddv[_qp].zero();
   _ddgraddw[_qp].zero();
   _multi[_qp] = 0.0;
  
   // for cases when current bond was broken, assign shape tensor and deformation gradient to unity
   if (_bond_status_var->getElementalValue(_current_elem) < 0.5)
   {
     _shape2[_qp] = RankTwoTensor::initIdentity;
     _deformation_gradient[_qp] = _shape2[_qp];
   }
   else
   {
     if (_dim == 2)
       _shape2[_qp](2, 2) = _deformation_gradient[_qp](2, 2) = 1.0;
  
     const Node * cur_nd = _current_elem->node_ptr(_qp);
     const Node * end_nd = _current_elem->node_ptr(1 - _qp); // two nodes for edge2 element
     std::vector<dof_id_type> neighbors = _pdmesh.getNeighbors(cur_nd->id());
     std::vector<dof_id_type> bonds = _pdmesh.getBonds(cur_nd->id());
  
     unsigned int nb =
         std::find(neighbors.begin(), neighbors.end(), end_nd->id()) - neighbors.begin();
     std::vector<dof_id_type> dg_neighbors = _pdmesh.getDefGradNeighbors(cur_nd->id(), nb);
  
     // calculate the shape tensor and prepare the deformation gradient tensor
     Real dgnodes_vsum = 0.0;
     RealGradient ori_vec(_dim), cur_vec(_dim);
  
     for (unsigned int j = 0; j < dg_neighbors.size(); ++j)
       if (_bond_status_var->getElementalValue(_pdmesh.elemPtr(bonds[dg_neighbors[j]])) > 0.5)
       {
         Node * node_j = _pdmesh.nodePtr(neighbors[dg_neighbors[j]]);
         Real vol_j = _pdmesh.getPDNodeVolume(neighbors[dg_neighbors[j]]);
         dgnodes_vsum += vol_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) += _horiz_rad[_qp] / ori_len * ori_vec(k) * ori_vec(l) * vol_j;
             _deformation_gradient[_qp](k, l) +=
                 _horiz_rad[_qp] / ori_len * cur_vec(k) * ori_vec(l) * vol_j;
           }
           // calculate derivatives of deformation_gradient w.r.t displacements of node i
           _ddgraddu[_qp](0, k) += -_horiz_rad[_qp] / ori_len * ori_vec(k) * vol_j;
           _ddgraddv[_qp](1, k) += -_horiz_rad[_qp] / ori_len * ori_vec(k) * vol_j;
           if (_dim == 3)
             _ddgraddw[_qp](2, k) += -_horiz_rad[_qp] / ori_len * ori_vec(k) * vol_j;
         }
       }
     // finalize the deformation gradient and its derivatives
     _deformation_gradient[_qp] *= _shape2[_qp].inverse();
     _ddgraddu[_qp] *= _shape2[_qp].inverse();
     _ddgraddv[_qp] *= _shape2[_qp].inverse();
     _ddgraddw[_qp] *= _shape2[_qp].inverse();
  
     // force state multiplier
     _multi[_qp] = _horiz_rad[_qp] / _origin_length * _node_vol[0] * _node_vol[1] * dgnodes_vsum /
                   _horiz_vol[_qp];
   }
 }

Referenced by ComputeSmallStrainNOSPD::computeQpStrain(), and ComputeFiniteStrainNOSPD::computeQpStrain().

◆ 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 ComputePlaneSmallStrainNOSPD::computeQpTotalStrain ( )

overrideprotectedvirtual

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

Reimplemented from ComputeSmallStrainNOSPD.

Definition at line 44 of file ComputePlaneSmallStrainNOSPD.C.

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

◆ 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");
 }