This postprocessor computes homogenized elastic constants. More...

#include <AsymptoticExpansionHomogenizationElasticConstants.h>

Inheritance diagram for AsymptoticExpansionHomogenizationElasticConstants:

Public Member Functions
	AsymptoticExpansionHomogenizationElasticConstants (const InputParameters &parameters)

virtual void	initialize ()

virtual void	execute ()

virtual Real	getValue ()

virtual void	threadJoin (const UserObject &y)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual Real	computeQpIntegral ()

Private Attributes
const std::string	_base_name

const std::array< std::array< const VariableGradient *, 3 >, 6 >	_grad

const MaterialProperty< RankFourTensor > &	_elasticity_tensor

const unsigned int	_column

const unsigned int	_row

const std::array< unsigned int, 6 >	_ik_index

const std::array< unsigned int, 6 >	_jl_index

const unsigned	_i

const unsigned	_j

const unsigned	_k

const unsigned	_l

Real	_volume

Real	_integral_value

Detailed Description

This postprocessor computes homogenized elastic constants.

Definition at line 23 of file AsymptoticExpansionHomogenizationElasticConstants.h.

Constructor & Destructor Documentation

◆ AsymptoticExpansionHomogenizationElasticConstants()

AsymptoticExpansionHomogenizationElasticConstants::AsymptoticExpansionHomogenizationElasticConstants ( const InputParameters & parameters )

Definition at line 58 of file AsymptoticExpansionHomogenizationElasticConstants.C.

   : ElementIntegralPostprocessor(parameters),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _grad({{{{&coupledGradient("dx_xx"),
               &coupledGradient("dy_xx"),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_xx") : &_grad_zero)}},
             {{&coupledGradient("dx_yy"),
               &coupledGradient("dy_yy"),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_yy") : &_grad_zero)}},
             {{(_subproblem.mesh().dimension() == 3 ? &coupledGradient("dx_zz") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dy_zz") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_zz") : &_grad_zero)}},
             {{(_subproblem.mesh().dimension() == 3 ? &coupledGradient("dx_yz") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dy_yz") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_yz") : &_grad_zero)}},
             {{(_subproblem.mesh().dimension() == 3 ? &coupledGradient("dx_zx") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dy_zx") : &_grad_zero),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_zx") : &_grad_zero)}},
             {{(&coupledGradient("dx_xy")),
               (&coupledGradient("dy_xy")),
               (_subproblem.mesh().dimension() == 3 ? &coupledGradient("dz_xy") : &_grad_zero)}}}}),
     _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_base_name + "elasticity_tensor")),
     _column(getParam<MooseEnum>("column")),
     _row(getParam<MooseEnum>("row")),
     _ik_index({{0, 1, 2, 1, 0, 0}}),
     _jl_index({{0, 1, 2, 2, 2, 1}}),
     _i(_ik_index[_row]),
     _j(_jl_index[_row]),
     _k(_ik_index[_column]),
     _l(_jl_index[_column]),
     _volume(0),
     _integral_value(0)
 {
 }

Member Function Documentation

◆ computeQpIntegral()

Real AsymptoticExpansionHomogenizationElasticConstants::computeQpIntegral ( )

protectedvirtual

Definition at line 128 of file AsymptoticExpansionHomogenizationElasticConstants.C.

 {
   Real value = 0;
   for (unsigned p = 0; p < 3; ++p)
     for (unsigned q = 0; q < 3; ++q)
       value += _elasticity_tensor[_qp](_i, _j, p, q) * (*_grad[_column][p])[_qp](q);
  
   return _elasticity_tensor[_qp](_i, _j, _k, _l) + value;
 }

◆ execute()

void AsymptoticExpansionHomogenizationElasticConstants::execute ( )

virtual

Definition at line 101 of file AsymptoticExpansionHomogenizationElasticConstants.C.

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

◆ getValue()

Real AsymptoticExpansionHomogenizationElasticConstants::getValue ( )

virtual

Definition at line 108 of file AsymptoticExpansionHomogenizationElasticConstants.C.

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

◆ initialize()

void AsymptoticExpansionHomogenizationElasticConstants::initialize ( )

virtual

Definition at line 94 of file AsymptoticExpansionHomogenizationElasticConstants.C.

 {
   _integral_value = 0;
   _volume = 0;
 }

◆ threadJoin()

void AsymptoticExpansionHomogenizationElasticConstants::threadJoin ( const UserObject & y )

virtual

Definition at line 118 of file AsymptoticExpansionHomogenizationElasticConstants.C.

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

◆ validParams()

InputParameters AsymptoticExpansionHomogenizationElasticConstants::validParams ( )

static

Definition at line 18 of file AsymptoticExpansionHomogenizationElasticConstants.C.

 {
   InputParameters params = ElementIntegralPostprocessor::validParams();
   params.addClassDescription(
       "Postprocessor for asymptotic expansion homogenization for elasticity");
   params.addRequiredCoupledVar("dx_xx", "solution in xx");
   params.addRequiredCoupledVar("dy_xx", "solution in xx");
   params.addCoupledVar("dz_xx", "solution in xx");
   params.addRequiredCoupledVar("dx_yy", "solution in yy");
   params.addRequiredCoupledVar("dy_yy", "solution in yy");
   params.addCoupledVar("dz_yy", "solution in yy");
   params.addCoupledVar("dx_zz", "solution in zz");
   params.addCoupledVar("dy_zz", "solution in zz");
   params.addCoupledVar("dz_zz", "solution in zz");
   params.addRequiredCoupledVar("dx_xy", "solution in xy");
   params.addRequiredCoupledVar("dy_xy", "solution in xy");
   params.addCoupledVar("dz_xy", "solution in xy");
   params.addCoupledVar("dx_yz", "solution in yz");
   params.addCoupledVar("dy_yz", "solution in yz");
   params.addCoupledVar("dz_yz", "solution in yz");
   params.addCoupledVar("dx_zx", "solution in zx");
   params.addCoupledVar("dy_zx", "solution in zx");
   params.addCoupledVar("dz_zx", "solution in zx");
   params.addParam<std::string>("base_name",
                                "Optional parameter that allows the user to define "
                                "multiple mechanics material systems on the same "
                                "block, i.e. for multiple phases");
   MooseEnum column("xx yy zz yz xz xy");
   params.addRequiredParam<MooseEnum>("column",
                                      column,
                                      "The column of the material matrix this kernel acts in. "
                                      "(xx, yy, zz, yz, xz, or xy)");
   params.addRequiredParam<MooseEnum>("row",
                                      column,
                                      "The row of the material matrix this kernel acts in. "
                                      "(xx, yy, zz, yz, xz, or xy)");
   return params;
 }