ComputeVolumetricEigenstrain computes an eigenstrain that is defined by a set of scalar material properties that summed together define the volumetric change. More...

#include <ComputeVolumetricEigenstrain.h>

Inheritance diagram for ComputeVolumetricEigenstrain:

[legend]

Public Member Functions
	ComputeVolumetricEigenstrain (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initialSetup ()

virtual void	computeQpEigenstrain ()

Protected Attributes
const unsigned int	_num_args
	number of variables the material depends on More...

const std::vector< MaterialPropertyName >	_volumetric_material_names
	Names of the material properties that define volumetric change. More...

std::vector< const MaterialProperty< Real > * >	_volumetric_materials
	The material properties that define volumetric change. More...

std::vector< std::vector< const MaterialProperty< Real > * > >	_dvolumetric_materials
	first derivatives of the volumetric materials with respect to the args More...

std::vector< std::vector< std::vector< const MaterialProperty< Real > * > > >	_d2volumetric_materials
	second derivatives of the volumetric materials with respect to the args More...

std::vector< MaterialProperty< RankTwoTensor > * >	_delastic_strain
	first derivatives of the elastic strain with respect to the args More...

std::vector< std::vector< MaterialProperty< RankTwoTensor > * > >	_d2elastic_strain
	second derivatives of the elastic strain with respect to the args More...

Detailed Description

ComputeVolumetricEigenstrain computes an eigenstrain that is defined by a set of scalar material properties that summed together define the volumetric change.

This also computes the derivatives of that eigenstrain with respect to a supplied set of variable dependencies.");

Definition at line 26 of file ComputeVolumetricEigenstrain.h.

Constructor & Destructor Documentation

◆ ComputeVolumetricEigenstrain()

ComputeVolumetricEigenstrain::ComputeVolumetricEigenstrain ( const InputParameters & parameters )

Definition at line 31 of file ComputeVolumetricEigenstrain.C.

   : DerivativeMaterialInterface<ComputeEigenstrainBase>(parameters),
     _num_args(coupledComponents("args")),
     _volumetric_material_names(getParam<std::vector<MaterialPropertyName>>("volumetric_materials")),
     _volumetric_materials(_volumetric_material_names.size()),
     _dvolumetric_materials(_volumetric_material_names.size()),
     _d2volumetric_materials(_volumetric_material_names.size()),
     _delastic_strain(_num_args),
     _d2elastic_strain(_num_args)
 {
   for (unsigned int i = 0; i < _volumetric_material_names.size(); ++i)
     _volumetric_materials[i] = &getMaterialProperty<Real>(_volumetric_material_names[i]);
  
   // fetch prerequisite derivatives and build elastic_strain derivatives and cross-derivatives
   for (unsigned int i = 0; i < _volumetric_material_names.size(); ++i)
   {
     const MaterialPropertyName & vol_matl_name = _volumetric_material_names[i];
     _dvolumetric_materials[i].resize(_num_args);
     _d2volumetric_materials[i].resize(_num_args);
     for (unsigned int j = 0; j < _num_args; ++j)
     {
       const VariableName & jname = getVar("args", j)->name();
       _dvolumetric_materials[i][j] = &getMaterialPropertyDerivative<Real>(vol_matl_name, jname);
       _d2volumetric_materials[i][j].resize(_num_args);
  
       for (unsigned int k = j; k < _num_args; ++k)
       {
         const VariableName & kname = getVar("args", k)->name();
         _d2volumetric_materials[i][j][k] =
             &getMaterialPropertyDerivative<Real>("prefactor", jname, kname);
       }
     }
   }
  
   for (unsigned int j = 0; j < _num_args; ++j)
   {
     const VariableName & jname = getVar("args", j)->name();
     _delastic_strain[j] =
         &declarePropertyDerivative<RankTwoTensor>(_base_name + "elastic_strain", jname);
     _d2elastic_strain[j].resize(_num_args);
  
     for (unsigned int k = j; k < _num_args; ++k)
     {
       const VariableName & kname = getVar("args", k)->name();
       _d2elastic_strain[j][k] =
           &declarePropertyDerivative<RankTwoTensor>(_base_name + "elastic_strain", jname, kname);
     }
   }
 }

Member Function Documentation

◆ computeQpEigenstrain()

void ComputeVolumetricEigenstrain::computeQpEigenstrain ( )

protectedvirtual

Definition at line 108 of file ComputeVolumetricEigenstrain.C.

 {
   Real volumetric_strain = 0;
   for (unsigned int i = 0; i < _volumetric_materials.size(); ++i)
     volumetric_strain += (*_volumetric_materials[i])[_qp];
  
   const Real eigenstrain_comp = computeVolumetricStrainComponent(volumetric_strain);
   _eigenstrain[_qp].zero();
   _eigenstrain[_qp].addIa(eigenstrain_comp);
  
   // TODO: Compute derivatives of the elastic strain wrt the variables specified in args
 }

◆ initialSetup()

void ComputeVolumetricEigenstrain::initialSetup ( )

protectedvirtual

Definition at line 82 of file ComputeVolumetricEigenstrain.C.

 {
   for (auto vmn : _volumetric_material_names)
     validateCoupling<Real>(vmn);
  
   for (unsigned int i = 0; i < _num_args; ++i)
   {
     const VariableName & iname = getVar("args", i)->name();
     if (_fe_problem.isMatPropRequested(
             derivativePropertyNameFirst(_base_name + "elastic_strain", iname)))
       mooseError("Derivative of elastic_strain requested, but not yet implemented");
     else
       _delastic_strain[i] = nullptr;
     for (unsigned int j = 0; j < _num_args; ++j)
     {
       const VariableName & jname = getVar("args", j)->name();
       if (_fe_problem.isMatPropRequested(
               derivativePropertyNameSecond(_base_name + "elastic_strain", iname, jname)))
         mooseError("Second Derivative of elastic_strain requested, but not yet implemented");
       else
         _d2elastic_strain[i][j] = nullptr;
     }
   }
 }

◆ validParams()

InputParameters ComputeVolumetricEigenstrain::validParams ( )

static

Definition at line 18 of file ComputeVolumetricEigenstrain.C.

 {
   InputParameters params = ComputeEigenstrainBase::validParams();
   params.addClassDescription("Computes an eigenstrain that is defined by a set of scalar material "
                              "properties that summed together define the volumetric change.  This "
                              "also computes the derivatives of that eigenstrain with respect to a "
                              "supplied set of variable dependencies.");
   params.addRequiredParam<std::vector<MaterialPropertyName>>(
       "volumetric_materials", "List of scalar materials defining the volumetric change");
   params.addRequiredCoupledVar("args", "variable dependencies for the volumetric_expansion");
   return params;
 }