ComputeMeanThermalExpansionFunctionEigenstrain computes an eigenstrain for thermal expansion according to a mean thermal expansion function. More...

#include <ComputeMeanThermalExpansionFunctionEigenstrain.h>

Inheritance diagram for ComputeMeanThermalExpansionFunctionEigenstrain:

[legend]

Public Member Functions
	ComputeMeanThermalExpansionFunctionEigenstrain (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual Real	referenceTemperature () override

virtual Real	meanThermalExpansionCoefficient (const Real temperature) override

virtual Real	meanThermalExpansionCoefficientDerivative (const Real temperature) override

virtual void	computeThermalStrain (Real &thermal_strain, Real &instantaneous_cte) override

virtual void	computeQpEigenstrain () override

Protected Attributes
const Function &	_thermal_expansion_function

const Real &	_thexp_func_ref_temp

const VariableValue &	_temperature

MaterialProperty< RankTwoTensor > &	_deigenstrain_dT

const VariableValue &	_stress_free_temperature

Detailed Description

ComputeMeanThermalExpansionFunctionEigenstrain computes an eigenstrain for thermal expansion according to a mean thermal expansion function.

Definition at line 23 of file ComputeMeanThermalExpansionFunctionEigenstrain.h.

Constructor & Destructor Documentation

◆ ComputeMeanThermalExpansionFunctionEigenstrain()

ComputeMeanThermalExpansionFunctionEigenstrain::ComputeMeanThermalExpansionFunctionEigenstrain ( const InputParameters & parameters )

Definition at line 33 of file ComputeMeanThermalExpansionFunctionEigenstrain.C.

   : ComputeMeanThermalExpansionEigenstrainBase(parameters),
     _thermal_expansion_function(getFunction("thermal_expansion_function")),
     _thexp_func_ref_temp(getParam<Real>("thermal_expansion_function_reference_temperature"))
 {
 }

Member Function Documentation

◆ computeQpEigenstrain()

void ComputeThermalExpansionEigenstrainBase::computeQpEigenstrain ( )

overrideprotectedvirtualinherited

Definition at line 38 of file ComputeThermalExpansionEigenstrainBase.C.

 {
   Real thermal_strain = 0.0;
  
   // instantaneous_cte is just the derivative of thermal_strain with respect to temperature
   Real instantaneous_cte = 0.0;
  
   computeThermalStrain(thermal_strain, instantaneous_cte);
  
   _eigenstrain[_qp].zero();
   _eigenstrain[_qp].addIa(thermal_strain);
  
   _deigenstrain_dT[_qp].zero();
   _deigenstrain_dT[_qp].addIa(instantaneous_cte);
 }

◆ computeThermalStrain()

void ComputeMeanThermalExpansionEigenstrainBase::computeThermalStrain	(	Real &	thermal_strain,
		Real &	instantaneous_cte
	)

overrideprotectedvirtualinherited

Implements ComputeThermalExpansionEigenstrainBase.

Definition at line 31 of file ComputeMeanThermalExpansionEigenstrainBase.C.

 {
   const Real small = libMesh::TOLERANCE;
  
   const Real reference_temperature = referenceTemperature();
   const Real & current_temp = _temperature[_qp];
   const Real current_alphabar = meanThermalExpansionCoefficient(current_temp);
   const Real thexp_current_temp = current_alphabar * (current_temp - reference_temperature);
  
   // Mean linear thermal expansion coefficient relative to the reference temperature
   // evaluated at stress_free_temperature.  This is
   // \f$\bar{\alpha} = (\delta L(T_{sf}) / L) / (T_{sf} - T_{ref})\f$
   // where \f$T_sf\f$ is the stress-free temperature and \f$T_{ref}\f$ is the reference temperature.
   const Real alphabar_stress_free_temperature =
       meanThermalExpansionCoefficient(_stress_free_temperature[_qp]);
   // Thermal expansion relative to the reference temperature evaluated at stress_free_temperature
   // \f$(\delta L(T_sf) / L)\f$, where \f$T_sf\f$ is the stress-free temperature.
   const Real thexp_stress_free_temperature =
       alphabar_stress_free_temperature * (_stress_free_temperature[_qp] - referenceTemperature());
  
   // Per M. Niffenegger and K. Reichlin (2012), thermal_strain should be divided
   // by (1.0 + thexp_stress_free_temperature) to account for the ratio of
   // the length at the stress-free temperature to the length at the reference
   // temperature. It can be neglected because it is very close to 1,
   // but we include it for completeness here.
  
   thermal_strain =
       (thexp_current_temp - thexp_stress_free_temperature) / (1.0 + thexp_stress_free_temperature);
  
   const Real dalphabar_dT = meanThermalExpansionCoefficientDerivative(current_temp);
   const Real numerator = dalphabar_dT * (current_temp - reference_temperature) + current_alphabar;
   const Real denominator =
       1.0 +
       alphabar_stress_free_temperature * (_stress_free_temperature[_qp] - reference_temperature);
   if (denominator < small)
     mooseError("Denominator too small in thermal strain calculation");
   instantaneous_cte = numerator / denominator;
 }

◆ meanThermalExpansionCoefficient()

Real ComputeMeanThermalExpansionFunctionEigenstrain::meanThermalExpansionCoefficient ( const Real temperature )

overrideprotectedvirtual

Implements ComputeMeanThermalExpansionEigenstrainBase.

Definition at line 48 of file ComputeMeanThermalExpansionFunctionEigenstrain.C.

 {
   return _thermal_expansion_function.value(temperature, Point());
 }

◆ meanThermalExpansionCoefficientDerivative()

Real ComputeMeanThermalExpansionFunctionEigenstrain::meanThermalExpansionCoefficientDerivative ( const Real temperature )

overrideprotectedvirtual

Implements ComputeMeanThermalExpansionEigenstrainBase.

Definition at line 55 of file ComputeMeanThermalExpansionFunctionEigenstrain.C.

 {
   return _thermal_expansion_function.timeDerivative(temperature, Point());
 }

◆ referenceTemperature()

Real ComputeMeanThermalExpansionFunctionEigenstrain::referenceTemperature ( )

overrideprotectedvirtual

Implements ComputeMeanThermalExpansionEigenstrainBase.

Definition at line 42 of file ComputeMeanThermalExpansionFunctionEigenstrain.C.

 {
   return _thexp_func_ref_temp;
 }

◆ validParams()

InputParameters ComputeMeanThermalExpansionFunctionEigenstrain::validParams ( )

static

Definition at line 18 of file ComputeMeanThermalExpansionFunctionEigenstrain.C.

 {
   InputParameters params = ComputeThermalExpansionEigenstrainBase::validParams();
   params.addClassDescription("Computes eigenstrain due to thermal expansion using a function that "
                              "describes the mean thermal expansion as a function of temperature");
   params.addRequiredParam<FunctionName>(
       "thermal_expansion_function",
       "Function describing the mean thermal expansion as a function of temperature");
   params.addRequiredParam<Real>("thermal_expansion_function_reference_temperature",
                                 "Reference temperature for thermal_exansion_function (IMPORTANT: "
                                 "this is different in general from the stress_free_temperature)");
  
   return params;
 }