This postprocessor computes the average grain area in a polycrystal. More...

#include <HomogenizedElasticConstants.h>

Inheritance diagram for HomogenizedElasticConstants:

Public Member Functions
	HomogenizedElasticConstants (const InputParameters &parameters)

virtual void	initialize ()

virtual void	execute ()

virtual Real	getValue ()

virtual void	threadJoin (const UserObject &y)

Protected Member Functions
virtual Real	computeQpIntegral ()

Private Attributes
const VariableGradient &	_grad_disp_x_xx

const VariableGradient &	_grad_disp_y_xx

const VariableGradient &	_grad_disp_z_xx

const VariableGradient &	_grad_disp_x_yy

const VariableGradient &	_grad_disp_y_yy

const VariableGradient &	_grad_disp_z_yy

const VariableGradient &	_grad_disp_x_zz

const VariableGradient &	_grad_disp_y_zz

const VariableGradient &	_grad_disp_z_zz

const VariableGradient &	_grad_disp_x_xy

const VariableGradient &	_grad_disp_y_xy

const VariableGradient &	_grad_disp_z_xy

const VariableGradient &	_grad_disp_x_yz

const VariableGradient &	_grad_disp_y_yz

const VariableGradient &	_grad_disp_z_yz

const VariableGradient &	_grad_disp_x_zx

const VariableGradient &	_grad_disp_y_zx

const VariableGradient &	_grad_disp_z_zx

const MaterialProperty< SymmElasticityTensor > &	_elasticity_tensor

const unsigned int	_column

const unsigned int	_row

unsigned	_I

unsigned	_J

unsigned	_l

unsigned	_k

unsigned	_i

unsigned	_j

Real	_volume

Real	_integral_value

Detailed Description

This postprocessor computes the average grain area in a polycrystal.

Definition at line 25 of file HomogenizedElasticConstants.h.

Constructor & Destructor Documentation

◆ HomogenizedElasticConstants()

HomogenizedElasticConstants::HomogenizedElasticConstants ( const InputParameters & parameters )

Definition at line 53 of file HomogenizedElasticConstants.C.

   : ElementAverageValue(parameters),
     _grad_disp_x_xx(coupledGradient("dx_xx")),
     _grad_disp_y_xx(coupledGradient("dy_xx")),
     _grad_disp_z_xx(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_xx") : _grad_zero),
     _grad_disp_x_yy(coupledGradient("dx_yy")),
     _grad_disp_y_yy(coupledGradient("dy_yy")),
     _grad_disp_z_yy(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_yy") : _grad_zero),
     _grad_disp_x_zz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dx_zz") : _grad_zero),
     _grad_disp_y_zz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dy_zz") : _grad_zero),
     _grad_disp_z_zz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_zz") : _grad_zero),
     _grad_disp_x_xy(coupledGradient("dx_xy")),
     _grad_disp_y_xy(coupledGradient("dy_xy")),
     _grad_disp_z_xy(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_xy") : _grad_zero),
     _grad_disp_x_yz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dx_yz") : _grad_zero),
     _grad_disp_y_yz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dy_yz") : _grad_zero),
     _grad_disp_z_yz(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_yz") : _grad_zero),
     _grad_disp_x_zx(_subproblem.mesh().dimension() == 3 ? coupledGradient("dx_zx") : _grad_zero),
     _grad_disp_y_zx(_subproblem.mesh().dimension() == 3 ? coupledGradient("dy_zx") : _grad_zero),
     _grad_disp_z_zx(_subproblem.mesh().dimension() == 3 ? coupledGradient("dz_zx") : _grad_zero),
     _elasticity_tensor(getMaterialProperty<SymmElasticityTensor>(
         "elasticity_tensor" + getParam<std::string>("appended_property_name"))),
     _column(getParam<unsigned int>("column")),
     _row(getParam<unsigned int>("row")),
     _volume(0),
     _integral_value(0)
 {
  
   if (_column == 0)
   {
     _k = 0;
     _l = 0;
   }
  
   if (_column == 1)
   {
     _k = 1;
     _l = 1;
   }
  
   if (_column == 2)
   {
     _k = 2;
     _l = 2;
   }
  
   if (_column == 3)
   {
     _k = 0;
     _l = 1;
   }
  
   if (_column == 4)
   {
     _k = 1;
     _l = 2;
   }
  
   if (_column == 5)
   {
     _k = 2;
     _l = 0;
   }
  
   if (_row == 0)
   {
     _i = 0;
     _j = 0;
   }
  
   if (_row == 1)
   {
     _i = 1;
     _j = 1;
   }
  
   if (_row == 2)
   {
     _i = 2;
     _j = 2;
   }
  
   if (_row == 3)
   {
     _i = 0;
     _j = 1;
   }
  
   if (_row == 4)
   {
     _i = 1;
     _j = 2;
   }
  
   if (_row == 5)
   {
     _i = 2;
     _j = 0;
   }
  
   _J = (3 * _l + _k);
   _I = (3 * _j + _i);
 }

Member Function Documentation

◆ computeQpIntegral()

Real HomogenizedElasticConstants::computeQpIntegral ( )

protectedvirtual

Definition at line 191 of file HomogenizedElasticConstants.C.

 {
   ColumnMajorMatrix E(_elasticity_tensor[_qp].columnMajorMatrix9x9());
   Real value;
  
   value = 0.0;
  
   const VariableGradient * grad[6][3];
   grad[0][0] = &_grad_disp_x_xx;
   grad[0][1] = &_grad_disp_y_xx;
   grad[0][2] = &_grad_disp_z_xx;
  
   grad[1][0] = &_grad_disp_x_yy;
   grad[1][1] = &_grad_disp_y_yy;
   grad[1][2] = &_grad_disp_z_yy;
  
   grad[2][0] = &_grad_disp_x_zz;
   grad[2][1] = &_grad_disp_y_zz;
   grad[2][2] = &_grad_disp_z_zz;
  
   grad[3][0] = &_grad_disp_x_xy;
   grad[3][1] = &_grad_disp_y_xy;
   grad[3][2] = &_grad_disp_z_xy;
  
   grad[4][0] = &_grad_disp_x_yz;
   grad[4][1] = &_grad_disp_y_yz;
   grad[4][2] = &_grad_disp_z_yz;
  
   grad[5][0] = &_grad_disp_x_zx;
   grad[5][1] = &_grad_disp_y_zx;
   grad[5][2] = &_grad_disp_z_zx;
  
   for (int p = 0; p < 3; p++)
   {
     for (int q = 0; q < 3; q++)
     {
       value += E(_I, 3 * q + p) * (*grad[_column][p])[_qp](q);
     }
   }
  
   return (E(_I, _J) + value);
 }

◆ execute()

void HomogenizedElasticConstants::execute ( )

virtual

Definition at line 165 of file HomogenizedElasticConstants.C.

 {
   _integral_value += computeIntegral();
   _volume += _current_elem_volume;
 }

◆ getValue()

Real HomogenizedElasticConstants::getValue ( )

virtual

Definition at line 172 of file HomogenizedElasticConstants.C.

 {
  
   gatherSum(_integral_value);
   gatherSum(_volume);
  
   return (_integral_value / _volume);
 }

◆ initialize()

void HomogenizedElasticConstants::initialize ( )

virtual

Definition at line 158 of file HomogenizedElasticConstants.C.

 {
   _integral_value = 0;
   _volume = 0;
 }

◆ threadJoin()

void HomogenizedElasticConstants::threadJoin ( const UserObject & y )

virtual

Definition at line 182 of file HomogenizedElasticConstants.C.

 {
   const HomogenizedElasticConstants & pps = dynamic_cast<const HomogenizedElasticConstants &>(y);
  
   _integral_value += pps._integral_value;
   _volume += pps._volume;
 }