#include <ComputeReducedOrderEigenstrain.h>

Inheritance diagram for ComputeReducedOrderEigenstrain:

Public Member Functions
	ComputeReducedOrderEigenstrain (const InputParameters &parameters)

void	initQpStatefulProperties ()

void	computeProperties ()

void	computeQpEigenstrain ()
	Compute the eigenstrain and store in _eigenstrain. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpProperties ()

Real	computeVolumetricStrainComponent (const Real volumetric_strain) const
	Helper function for models that compute the eigenstrain based on a volumetric strain. More...

Protected Attributes
const std::string	_base_name
	Base name prepended to material property name. More...

std::string	_eigenstrain_name
	Material property name for the eigenstrain tensor. More...

MaterialProperty< RankTwoTensor > &	_eigenstrain
	Stores the current total eigenstrain. More...

bool &	_step_zero
	Restartable data to check for the zeroth and first time steps for thermal calculations. More...

Private Member Functions
void	applyEigenstrain (MaterialProperty< RankTwoTensor > &strain)
	Subtract adjusted eigenstrain from strain. More...

void	sumEigenstrain ()
	Add contributions from every eigenstrain at each integration point. More...

void	prepareEigenstrain ()
	Compute either the volume average or linear eigenstrain field in an element. More...

Private Attributes
std::vector< MaterialPropertyName >	_input_eigenstrain_names

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

SubProblem &	_subproblem

const unsigned	_ncols
	Number of columns in A matrix (1 plus mesh dimension) More...

const bool	_second_order
	Whether the mesh is made of second order elements. More...

std::vector< RankTwoTensor >	_eigsum
	The sum of all eigenstrains at each integration point. More...

DenseMatrix< Real >	_A
	The (num q points x ncols) array for the least squares. Holds 1, xcoor, ycoor, zcoor. More...

std::vector< DenseVector< Real > >	_b
	The b array holding the unique eigenstrain components for each integration point. More...

DenseMatrix< Real >	_AT
	Transpose of A. More...

DenseVector< Real >	_ATb
	Transpose of A times b. More...

std::vector< DenseVector< Real > >	_x
	The solution vector for each unique component of the adjusted eigenstrain. More...

std::vector< Real >	_vals
	Vector to hold the adjusted strain as computed with _x. More...

RankTwoTensor	_adjusted_eigenstrain
	Filled with _vals and subracted from strain. More...

Detailed Description

Definition at line 28 of file ComputeReducedOrderEigenstrain.h.

Constructor & Destructor Documentation

◆ ComputeReducedOrderEigenstrain()

ComputeReducedOrderEigenstrain::ComputeReducedOrderEigenstrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeReducedOrderEigenstrain.C.

   : ComputeEigenstrainBase(parameters),
     _input_eigenstrain_names(
         getParam<std::vector<MaterialPropertyName>>("input_eigenstrain_names")),
     _eigenstrains(_input_eigenstrain_names.size()),
     _subproblem(*parameters.get<SubProblem *>("_subproblem")),
     _ncols(1 + _subproblem.mesh().dimension()),
     _second_order(_subproblem.mesh().hasSecondOrderElements()),
     _eigsum(),
     _A(),
     _b(6),
     _AT(),
     _ATb(_ncols),
     _x(6, DenseVector<Real>(_ncols)),
     _vals(6),
     _adjusted_eigenstrain()
 {
   for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
   {
     _input_eigenstrain_names[i] = _base_name + _input_eigenstrain_names[i];
     _eigenstrains[i] = &getMaterialProperty<RankTwoTensor>(_input_eigenstrain_names[i]);
   }
 }

Member Function Documentation

◆ applyEigenstrain()

void ComputeReducedOrderEigenstrain::applyEigenstrain ( MaterialProperty< RankTwoTensor > & strain )

private

Subtract adjusted eigenstrain from strain.

◆ computeProperties()

void ComputeReducedOrderEigenstrain::computeProperties ( )

Definition at line 61 of file ComputeReducedOrderEigenstrain.C.

 {
   sumEigenstrain();
  
   prepareEigenstrain();
  
   Material::computeProperties();
 }

◆ computeQpEigenstrain()

void ComputeReducedOrderEigenstrain::computeQpEigenstrain ( )

virtual

Compute the eigenstrain and store in _eigenstrain.

Implements ComputeEigenstrainBase.

Definition at line 71 of file ComputeReducedOrderEigenstrain.C.

 {
   if (_second_order)
   {
     for (unsigned i = 0; i < 6; ++i)
     {
       _vals[i] = _x[i](0);
       for (unsigned j = 1; j < _ncols; ++j)
         _vals[i] += _x[i](j) * _q_point[_qp](j - 1);
     }
     _adjusted_eigenstrain.fillFromInputVector(_vals);
   }
   _eigenstrain[_qp] = _adjusted_eigenstrain;
 }

◆ computeQpProperties()

void ComputeEigenstrainBase::computeQpProperties ( )

protectedvirtualinherited

Definition at line 49 of file ComputeEigenstrainBase.C.

 {
   if (_t_step >= 1)
     _step_zero = false;
  
   // Skip the eigenstrain calculation in step zero because no solution is computed during
   // the zeroth step, hence computing the eigenstrain in the zeroth step would result in
   // an incorrect calculation of mechanical_strain, which is stateful.
   if (!_step_zero)
     computeQpEigenstrain();
 }

◆ computeVolumetricStrainComponent()

Real ComputeEigenstrainBase::computeVolumetricStrainComponent ( const Real volumetric_strain ) const

protectedinherited

Helper function for models that compute the eigenstrain based on a volumetric strain.

This function computes the diagonal components of the eigenstrain tensor as logarithmic strains.

Parameters

volumetric_strain The current volumetric strain to be applied

Returns: Current strain in one direction due to volumetric strain, expressed as a logarithmic strain

Definition at line 62 of file ComputeEigenstrainBase.C.

 {
   // The engineering strain in a given direction is:
   // epsilon_eng = cbrt(volumetric_strain + 1.0) - 1.0
   //
   // We need to provide this as a logarithmic strain to be consistent with the strain measure
   // used for finite strain:
   // epsilon_log = log(1.0 + epsilon_eng)
   //
   // This can be simplified down to a more direct form:
   // epsilon_log = log(cbrt(volumetric_strain + 1.0))
   // or:
   // epsilon_log = (1/3) log(volumetric_strain + 1.0)
  
   return std::log(volumetric_strain + 1.0) / 3.0;
 }

◆ initQpStatefulProperties()

void ComputeReducedOrderEigenstrain::initQpStatefulProperties ( )

virtual

Reimplemented from ComputeEigenstrainBase.

Definition at line 55 of file ComputeReducedOrderEigenstrain.C.

 {
   _eigenstrain[_qp].zero();
 }

◆ prepareEigenstrain()

void ComputeReducedOrderEigenstrain::prepareEigenstrain ( )

private

Compute either the volume average or linear eigenstrain field in an element.

Definition at line 99 of file ComputeReducedOrderEigenstrain.C.

 {
   // The eigenstrains can either be constant in an element or linear in x, y, z
   // If constant, do volume averaging.
   if (!_second_order || _qrule->n_points() == 1)
   {
     // Volume average
     _adjusted_eigenstrain.zero();
     Real vol = 0.0;
     for (unsigned qp = 0; qp < _qrule->n_points(); ++qp)
     {
       _adjusted_eigenstrain += _eigsum[qp] * _JxW[qp] * _coord[qp];
       vol += _JxW[qp] * _coord[qp];
     }
     _adjusted_eigenstrain /= vol;
   }
   else
   {
     // 1 x y z
  
     // Six sets (one for each unique component of eigen) of qp data
     _A.resize(_qrule->n_points(), _ncols);
     for (auto && b : _b)
       b.resize(_qrule->n_points());
  
     for (unsigned qp = 0; qp < _qrule->n_points(); ++qp)
     {
       _A(qp, 0) = 1.0;
       for (unsigned j = 1; j < _ncols; ++j)
         _A(qp, j) = _q_point[qp](j - 1);
  
       _b[0](qp) = _eigsum[qp](0, 0);
       _b[1](qp) = _eigsum[qp](1, 1);
       _b[2](qp) = _eigsum[qp](2, 2);
       _b[3](qp) = _eigsum[qp](1, 2);
       _b[4](qp) = _eigsum[qp](0, 2);
       _b[5](qp) = _eigsum[qp](0, 1);
     }
  
     _A.get_transpose(_AT);
     _A.left_multiply(_AT);
     for (unsigned i = 0; i < 6; ++i)
     {
       _AT.vector_mult(_ATb, _b[i]);
  
       _A.cholesky_solve(_ATb, _x[i]);
     }
   }
 }

Referenced by computeProperties().

◆ sumEigenstrain()

void ComputeReducedOrderEigenstrain::sumEigenstrain ( )

private

Add contributions from every eigenstrain at each integration point.

Definition at line 87 of file ComputeReducedOrderEigenstrain.C.

 {
   _eigsum.resize(_qrule->n_points());
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     _eigsum[_qp].zero();
     for (auto es : _eigenstrains)
       _eigsum[_qp] += (*es)[_qp];
   }
 }

Referenced by computeProperties().

◆ validParams()

InputParameters ComputeReducedOrderEigenstrain::validParams ( )

static

Definition at line 20 of file ComputeReducedOrderEigenstrain.C.

 {
   InputParameters params = ComputeEigenstrainBase::validParams();
   params.addClassDescription("accepts eigenstrains and computes a reduced order eigenstrain for "
                              "consistency in the order of strain and eigenstrains.");
   params.addRequiredParam<std::vector<MaterialPropertyName>>(
       "input_eigenstrain_names", "List of eigenstrains to be applied in this strain calculation");
   return params;
 }