Function[kappa, gamma, m, L] = parameters (sigma, mob, w_GB, sigma0) Parameter determination method is elaborated in Phys. More...

#include <GBWidthAnisotropy.h>

Inheritance diagram for GBWidthAnisotropy:

[legend]

Public Member Functions
	GBWidthAnisotropy (const InputParameters &parameters)

Protected Member Functions
virtual void	computeQpProperties ()

Protected Attributes
const unsigned int	_mesh_dimension

const Real	_length_scale

const Real	_time_scale

const Real	_M_V

const Real	_delta_sigma

const Real	_delta_mob

const FileName	_Anisotropic_GB_file_name

const bool	_inclination_anisotropy

const VariableValue &	_T

std::vector< std::vector< Real > >	_sigma

std::vector< std::vector< Real > >	_mob

std::vector< std::vector< Real > >	_Q

std::vector< std::vector< Real > >	_kappa_gamma

std::vector< std::vector< Real > >	_a_g2

MaterialProperty< Real > &	_gamma

MaterialProperty< Real > &	_L

MaterialProperty< Real > &	_molar_volume

MaterialProperty< Real > &	_entropy_diff

MaterialProperty< Real > &	_act_wGB

const Real	_kb

const Real	_JtoeV

Real	_mu_qp

const unsigned int	_op_num

std::vector< const VariableValue * >	_vals

std::vector< const VariableGradient * >	_grad_vals

Private Attributes
const Real	_mu

const Real	_kappa

Detailed Description

Function[kappa, gamma, m, L] = parameters (sigma, mob, w_GB, sigma0) Parameter determination method is elaborated in Phys.

Rev. B, 78(2), 024113, 2008, by N. Moelans This material uses user-supplied m, kappa and calculates remaining parameters using Eq. (36a) - (36c) from the paper. The interface width is allowed to vary in this material. By maintaining kappa constant and equal for all interfaces, the Allen-Cahn equation is fully variational, as described in Moelans, Acta Mat., 59, 1077-1086, 2011.

Definition at line 28 of file GBWidthAnisotropy.h.

Constructor & Destructor Documentation

◆ GBWidthAnisotropy()

GBWidthAnisotropy::GBWidthAnisotropy ( const InputParameters & parameters )

Definition at line 25 of file GBWidthAnisotropy.C.

   : GBAnisotropyBase(parameters), _mu(getParam<Real>("mu")), _kappa(getParam<Real>("kappa"))
 {
   _mu_qp = _mu;
   Real g2 = 0.0;
   Real f_interf = 0.0;
   Real a = 0.0;
   Real gamma = 0.0;
   Real y = 0.0; // 1/gamma
   Real yyy = 0.0;
  
   for (unsigned int m = 0; m < _op_num - 1; ++m)
     for (unsigned int n = m + 1; n < _op_num; ++n)
     {
       // Convert units of mobility and energy
       _sigma[m][n] *= _JtoeV * (_length_scale * _length_scale); // eV/nm^2
  
       _mob[m][n] *= _time_scale / (_JtoeV * (_length_scale * _length_scale * _length_scale *
                                              _length_scale)); // Convert to nm^4/(eV*ns);
     }
  
   for (unsigned int m = 0; m < _op_num - 1; ++m)
     for (unsigned int n = m + 1; n < _op_num; ++n) // m<n
     {
       g2 = _sigma[m][n] * _sigma[m][n] / (_kappa * _mu_qp);
       y = -5.288 * g2 * g2 * g2 * g2 - 0.09364 * g2 * g2 * g2 + 9.965 * g2 * g2 - 8.183 * g2 +
           2.007;
       gamma = 1 / y;
       yyy = y * y * y;
       f_interf = 0.05676 * yyy * yyy - 0.2924 * yyy * y * y + 0.6367 * yyy * y - 0.7749 * yyy +
                  0.6107 * y * y - 0.4324 * y + 0.2792;
       a = std::sqrt(f_interf / g2);
  
       _kappa_gamma[m][n] = _kappa; // upper triangle stores the discrete set of kappa values
       _kappa_gamma[n][m] = gamma;  // lower triangle stores the discrete set of gamma values
  
       _a_g2[m][n] = a;  // upper triangle stores "a" data.
       _a_g2[n][m] = g2; // lower triangle stores "g2" data.
     }
 }

Member Function Documentation

◆ computeQpProperties()

void GBAnisotropyBase::computeQpProperties ( )

protectedvirtualinherited

Definition at line 118 of file GBAnisotropyBase.C.

 {
   Real sum_kappa = 0.0;
   Real sum_gamma = 0.0;
   Real sum_L = 0.0;
   Real Val = 0.0;
   Real sum_val = 0.0;
   Real f_sigma = 1.0;
   Real f_mob = 1.0;
   Real gamma_value = 0.0;
  
   for (unsigned int m = 0; m < _op_num - 1; ++m)
   {
     for (unsigned int n = m + 1; n < _op_num; ++n) // m<n
     {
       gamma_value = _kappa_gamma[n][m];
  
       if (_inclination_anisotropy)
       {
         if (_mesh_dimension == 3)
           mooseError("This material doesn't support inclination dependence for 3D for now!");
  
         Real phi_ave = libMesh::pi * n / (2.0 * _op_num);
         Real sin_phi = std::sin(2.0 * phi_ave);
         Real cos_phi = std::cos(2.0 * phi_ave);
  
         Real a = (*_grad_vals[m])[_qp](0) - (*_grad_vals[n])[_qp](0);
         Real b = (*_grad_vals[m])[_qp](1) - (*_grad_vals[n])[_qp](1);
         Real ab = a * a + b * b + 1.0e-7; // for the sake of numerical convergence, the smaller the
                                           // more accurate, but more difficult to converge
  
         Real cos_2phi = cos_phi * (a * a - b * b) / ab + sin_phi * 2.0 * a * b / ab;
         Real cos_4phi = 2.0 * cos_2phi * cos_2phi - 1.0;
  
         f_sigma = 1.0 + _delta_sigma * cos_4phi;
         f_mob = 1.0 + _delta_mob * cos_4phi;
  
         Real g2 = _a_g2[n][m] * f_sigma;
         Real y = -5.288 * g2 * g2 * g2 * g2 - 0.09364 * g2 * g2 * g2 + 9.965 * g2 * g2 -
                  8.183 * g2 + 2.007;
         gamma_value = 1.0 / y;
       }
  
       Val = (100000.0 * ((*_vals[m])[_qp]) * ((*_vals[m])[_qp]) + 0.01) *
             (100000.0 * ((*_vals[n])[_qp]) * ((*_vals[n])[_qp]) + 0.01);
  
       sum_val += Val;
       sum_kappa += _kappa_gamma[m][n] * f_sigma * Val;
       sum_gamma += gamma_value * Val;
       // Following comes from substituting Eq. (36c) from the paper into (36b)
       sum_L += Val * _mob[m][n] * std::exp(-_Q[m][n] / (_kb * _T[_qp])) * f_mob * _mu_qp *
                _a_g2[n][m] / _sigma[m][n];
     }
   }
  
   _kappa[_qp] = sum_kappa / sum_val;
   _gamma[_qp] = sum_gamma / sum_val;
   _L[_qp] = sum_L / sum_val;
   _mu[_qp] = _mu_qp;
  
   _molar_volume[_qp] =
       _M_V / (_length_scale * _length_scale * _length_scale); // m^3/mol converted to ls^3/mol
   _entropy_diff[_qp] = 9.5 * _JtoeV;                          // J/(K mol) converted to eV(K mol)
   _act_wGB[_qp] = 0.5e-9 / _length_scale;                     // 0.5 nm
 }