#include <KKSPhaseConcentrationMaterial.h>

Inheritance diagram for KKSPhaseConcentrationMaterial:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	KKSPhaseConcentrationMaterial (const InputParameters &parameters)

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)

const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)

void	validateDerivativeMaterialPropertyBase (const std::string &base)

const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)

const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)

void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initQpStatefulProperties () override

virtual void	initialSetup () override

virtual void	computeQpProperties () override

Protected Attributes
const std::vector< const VariableValue * >	_prop_c
	Global concentrations.

const unsigned int	_num_c
	Number of global concentrations.

const MaterialProperty< Real > &	_prop_h
	Switching functions.

const std::vector< VariableName >	_args_names
	Coupled variables of free energies.

const unsigned int	_n_args
	Number of coupled variables of free energies.

MaterialProperty< Real > &	_iter
	Number of nested Newton iteration.

const bool	_damped_newton
	Add damping functionality to nested Newton solve.

NestedSolve	_nested_solve
	Instantiation of the NestedSolve class.


const std::vector< MaterialPropertyName >	_ci_names
	Phase concentrations.

std::vector< MaterialProperty< Real > * >	_prop_ci

std::vector< const MaterialProperty< Real > * >	_ci_old

const std::vector< Real >	_ci_IC


const MaterialName	_Fa_name
	Free energies.

const MaterialName	_Fb_name

std::vector< const MaterialProperty< Real > * >	_prop_Fi

std::vector< MaterialProperty< Real > * >	_Fi_copy


std::vector< const MaterialProperty< Real > * >	_dFidci
	Derivative of free energies wrt phase concentrations \( \frac d{dc_i} F_i \).

std::vector< MaterialProperty< Real > * >	_dFidci_copy


std::vector< std::vector< std::vector< const MaterialProperty< Real > * > > >	_d2Fidcidbi

std::vector< std::vector< MaterialProperty< Real > * > >	_d2Fadc1db1_copy


std::vector< const MaterialProperty< Real > * >	_dFadarg
	Derivative of free energies wrt coupled variables \( \frac d{dq} F_a \).

std::vector< MaterialProperty< Real > * >	_dFadarg_copy


std::vector< const MaterialProperty< Real > * >	_dFbdarg
	Derivative of free energies wrt coupled variables \( \frac d{dq} F_b \).

std::vector< MaterialProperty< Real > * >	_dFbdarg_copy


std::vector< std::vector< const MaterialProperty< Real > * > >	_d2Fadcadarg

std::vector< std::vector< MaterialProperty< Real > * > >	_d2Fadcadarg_copy


const Real	_abs_tol
	Absolute and relative tolerance of nested Newton iteration.

const Real	_rel_tol


MaterialName	_condition_name
	Material property that defines the confidence bounds for the newton solve.

MaterialBase *	_condition

const MaterialProperty< Real > *	_C


MaterialBase *	_Fa
	Free energy instantiation of the MaterialBase class.

MaterialBase *	_Fb

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)

std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)

void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)

bool	isNotObjectVariable (const VariableName &name)

Private Attributes
FEProblemBase &	_dmi_fe_problem

Detailed Description

Definition at line 15 of file KKSPhaseConcentrationMaterial.h.

Constructor & Destructor Documentation

◆ KKSPhaseConcentrationMaterial()

KKSPhaseConcentrationMaterial::KKSPhaseConcentrationMaterial ( const InputParameters & parameters )

Definition at line 47 of file KKSPhaseConcentrationMaterial.C.

  : DerivativeMaterialInterface<Material>(parameters),
    _prop_c(coupledValues("global_cs")),
    _num_c(coupledComponents("global_cs")),
    _prop_h(getMaterialProperty<Real>("h_name")),
    _ci_names(getParam<std::vector<MaterialPropertyName>>("ci_names")),
    _prop_ci(_num_c * 2),
    _ci_old(_num_c * 2),
    _ci_IC(getParam<std::vector<Real>>("ci_IC")),
    _Fa_name(getParam<MaterialName>("fa_name")),
    _Fb_name(getParam<MaterialName>("fb_name")),
    _prop_Fi(2),
    _Fi_copy(2),
    _dFidci(_num_c * 2),
    _dFidci_copy(_num_c * 2),
    _d2Fidcidbi(2),
    _d2Fadc1db1_copy(_num_c),
    _args_names(coupledNames("args")),
    _n_args(coupledComponents("args")),
    _dFadarg(_n_args),
    _dFadarg_copy(_n_args),
    _dFbdarg(_n_args),
    _dFbdarg_copy(_n_args),
    _d2Fadcadarg(_n_args),
    _d2Fadcadarg_copy(_n_args),
    _iter(declareProperty<Real>("nested_iterations")),
    _abs_tol(getParam<Real>("absolute_tolerance")),
    _rel_tol(getParam<Real>("relative_tolerance")),
    _damped_newton(getParam<bool>("damped_Newton")),
    _condition_name(getParam<MaterialName>("conditions")),
    _nested_solve(NestedSolve(parameters))
 
{
  // phase concentrations
  for (const auto m : make_range(_num_c * 2))
  {
    _prop_ci[m] = &declareProperty<Real>(_ci_names[m]);
    _ci_old[m] = &getMaterialPropertyOld<Real>(_ci_names[m]);
  }
 
  // free energies
  _prop_Fi[0] = &getMaterialPropertyByName<Real>(_Fa_name);
  _prop_Fi[1] = &getMaterialPropertyByName<Real>(_Fb_name);
 
  // declare _fi_copy to be passed to the kernels
  _Fi_copy[0] = &declareProperty<Real>("cp" + _Fa_name);
  _Fi_copy[1] = &declareProperty<Real>("cp" + _Fb_name);
 
  // derivative of free energy wrt phase concentrations
  for (const auto m : make_range(_num_c))
  {
    _dFidci[m * 2] = &getMaterialPropertyDerivative<Real>(_Fa_name, _ci_names[m * 2]);
    _dFidci[m * 2 + 1] = &getMaterialPropertyDerivative<Real>(_Fb_name, _ci_names[m * 2 + 1]);
 
    // declare _dFidci_copy to be passed to the kernels
    _dFidci_copy[m * 2] = &declarePropertyDerivative<Real>("cp" + _Fa_name, _ci_names[m * 2]);
    _dFidci_copy[m * 2 + 1] =
        &declarePropertyDerivative<Real>("cp" + _Fb_name, _ci_names[m * 2 + 1]);
  }
 
  // Second derivative of free energy wrt phase concentrations for use in this material. In
  // _d2Fidcidbi[m][n][l], m is phase index of Fi, n is the species index of ci, l is the species
  // index of bi.
  for (const auto m : make_range(2))
  {
    _d2Fidcidbi[m].resize(_num_c);
    for (const auto n : make_range(_num_c))
    {
      _d2Fidcidbi[m][n].resize(_num_c);
      for (const auto l : make_range(_num_c))
      {
        if (m == 0)
          _d2Fidcidbi[0][n][l] =
              &getMaterialPropertyDerivative<Real>(_Fa_name, _ci_names[n * 2], _ci_names[l * 2]);
 
        else
          _d2Fidcidbi[1][n][l] = &getMaterialPropertyDerivative<Real>(
              _Fb_name, _ci_names[n * 2 + 1], _ci_names[l * 2 + 1]);
      }
    }
  }
 
  // _d2Fadc1db1_copy (2D symmetric matrix), to be passed to kernels
  for (const auto m : make_range(_num_c))
  {
    _d2Fadc1db1_copy[m].resize(_num_c);
    for (const auto n : make_range(_num_c))
      _d2Fadc1db1_copy[m][n] =
          &declarePropertyDerivative<Real>("cp" + _Fa_name, _ci_names[m * 2], _ci_names[n * 2]);
  }
 
  // partial derivative of Fa and Fb wrt coupled variables, to be passed to kernels
  for (const auto m : make_range(_n_args))
  {
    _dFadarg[m] = &getMaterialPropertyDerivative<Real>(_Fa_name, _args_names[m]);
    _dFadarg_copy[m] = &declarePropertyDerivative<Real>("cp" + _Fa_name, _args_names[m]);
    _dFbdarg[m] = &getMaterialPropertyDerivative<Real>(_Fb_name, _args_names[m]);
    _dFbdarg_copy[m] = &declarePropertyDerivative<Real>("cp" + _Fb_name, _args_names[m]);
  }
 
  // second partial derivatives of Fa wrt ca and another coupled variable, to be passed to
  // kernels
  for (const auto m : make_range(_n_args))
  {
    _d2Fadcadarg[m].resize(_num_c);
    _d2Fadcadarg_copy[m].resize(_num_c);
    for (const auto n : make_range(_num_c))
    {
      _d2Fadcadarg[m][n] =
          &getMaterialPropertyDerivative<Real>(_Fa_name, _ci_names[n * 2], _args_names[m]);
      _d2Fadcadarg_copy[m][n] =
          &declarePropertyDerivative<Real>("cp" + _Fa_name, _ci_names[n * 2], _args_names[m]);
    }
  }
 
  if (_damped_newton)
    _C = &getMaterialPropertyByName<Real>(_condition_name);
  else
    _C = nullptr;
}

Member Function Documentation

◆ computeQpProperties()

void KKSPhaseConcentrationMaterial::computeQpProperties ( )

overrideprotectedvirtual

Definition at line 185 of file KKSPhaseConcentrationMaterial.C.

{
  // parameters for nested Newton iteration
  NestedSolve::Value<> solution(_num_c * 2);
 
  for (unsigned int m = 0; m < _num_c * 2; ++m)
    solution(m) = (*_ci_old[m])[_qp];
 
  _nested_solve.setAbsoluteTolerance(_abs_tol);
  _nested_solve.setRelativeTolerance(_rel_tol);
 
  auto compute = [&](const NestedSolve::Value<> & guess,
                     NestedSolve::Value<> & residual,
                     NestedSolve::Jacobian<> & jacobian)
  {
    for (const auto m : make_range(_num_c * 2))
      (*_prop_ci[m])[_qp] = guess(m);
 
    _Fa->computePropertiesAtQp(_qp);
    _Fb->computePropertiesAtQp(_qp);
 
    // assign residual functions
    for (const auto m : make_range(_num_c))
    {
      residual(m * 2) = (*_dFidci[m * 2])[_qp] - (*_dFidci[m * 2 + 1])[_qp];
      residual(m * 2 + 1) = (1 - _prop_h[_qp]) * (*_prop_ci[m * 2])[_qp] +
                            _prop_h[_qp] * (*_prop_ci[m * 2 + 1])[_qp] - (*_prop_c[m])[_qp];
    }
 
    jacobian.setZero();
 
    // fill in the non-zero elements in jacobian
    for (const auto m : make_range(_num_c))
    {
      for (const auto n : make_range(_num_c))
      {
        // equal chemical potential derivative equations
        jacobian(m * 2, n * 2) = (*_d2Fidcidbi[0][m][n])[_qp];
        jacobian(m * 2, n * 2 + 1) = -(*_d2Fidcidbi[1][m][n])[_qp];
      }
      // concentration conservation derivative equations
      jacobian(m * 2 + 1, m * 2) = 1 - _prop_h[_qp];
      jacobian(m * 2 + 1, m * 2 + 1) = _prop_h[_qp];
    }
  };
  auto computeCondition = [&](const NestedSolve::Value<> & guess) -> Real
  {
    for (const auto m : make_range(_num_c * 2))
      (*_prop_ci[m])[_qp] = guess(m);
    _condition->computePropertiesAtQp(_qp);
    return ((*_C)[_qp]);
  };
  // choose between Newton or damped Newton's method
  if (!_damped_newton)
    _nested_solve.nonlinear(solution, compute);
  else
    _nested_solve.nonlinearDamped(solution, compute, computeCondition);
  _iter[_qp] = _nested_solve.getIterations();
 
  if (_nested_solve.getState() == NestedSolve::State::NOT_CONVERGED)
    mooseException("Nested Newton iteration did not converge.");
 
  // assign solution to ci
  for (const auto m : make_range(_num_c * 2))
    (*_prop_ci[m])[_qp] = solution[m];
 
  // assign to the copied parameters to be used in kernels
  for (const auto m : make_range(2))
    (*_Fi_copy[m])[_qp] = (*_prop_Fi[m])[_qp];
 
  for (const auto m : make_range(_num_c * 2))
    (*_dFidci_copy[m])[_qp] = (*_dFidci[m])[_qp];
 
  for (const auto m : make_range(_num_c))
  {
    for (const auto n : make_range(_num_c))
      (*_d2Fadc1db1_copy[m][n])[_qp] = (*_d2Fidcidbi[0][m][n])[_qp];
  }
 
  for (const auto m : make_range(_n_args))
  {
    (*_dFadarg_copy[m])[_qp] = (*_dFadarg[m])[_qp];
    (*_dFbdarg_copy[m])[_qp] = (*_dFbdarg[m])[_qp];
  }
 
  for (const auto m : make_range(_n_args))
  {
    for (const auto n : make_range(_num_c))
      (*_d2Fadcadarg_copy[m][n])[_qp] = (*_d2Fadcadarg[m][n])[_qp];
  }
}

◆ initialSetup()

void KKSPhaseConcentrationMaterial::initialSetup ( )

overrideprotectedvirtual

Definition at line 176 of file KKSPhaseConcentrationMaterial.C.

{
  _Fa = &getMaterial("fa_name");
  _Fb = &getMaterial("fb_name");
  if (_damped_newton)
    _condition = &getMaterialByName(_condition_name);
}

◆ initQpStatefulProperties()

void KKSPhaseConcentrationMaterial::initQpStatefulProperties ( )

overrideprotectedvirtual

Definition at line 169 of file KKSPhaseConcentrationMaterial.C.

{
  for (const auto m : make_range(_num_c * 2))
    (*_prop_ci[m])[_qp] = _ci_IC[m];
}

◆ validParams()

InputParameters KKSPhaseConcentrationMaterial::validParams ( )

static

Definition at line 16 of file KKSPhaseConcentrationMaterial.C.

{
  InputParameters params = DerivativeMaterialInterface<Material>::validParams();
  params.addClassDescription("Computes the KKS phase concentrations by using nested Newton "
                             "iteration to solve the equal chemical "
                             "potential and concentration conservation equations. This class is "
                             "intended to be used with KKSPhaseConcentrationDerivatives.");
  params.addRequiredCoupledVar("global_cs", "The interpolated concentrations c, b, etc.");
  params.addRequiredParam<MaterialPropertyName>("h_name", "Switching function h(eta).");
  params.addRequiredParam<std::vector<MaterialPropertyName>>(
      "ci_names",
      "Phase concentrations. The order must match Fa, Fb, and global_cs, for example, c1, c2, b1, "
      "b2, etc.");
  params.addRequiredParam<std::vector<Real>>("ci_IC",
                                             "Initial values of ci in the same order as ci_names.");
  params.addRequiredParam<MaterialName>("fa_name", "Fa material object.");
  params.addRequiredParam<MaterialName>("fb_name", "Fb material object.");
  params.addParam<MaterialPropertyName>(
      "nested_iterations",
      "The output number of nested Newton iterations at each quadrature point.");
  params.addCoupledVar("args", "The coupled variables of Fa and Fb.");
  params.addParam<bool>(
      "damped_Newton", false, "Whether or not to use the damped Newton's method.");
  params.addParam<MaterialName>("conditions",
                                "C",
                                "Material property that checks bounds and conditions on the "
                                "material properties being solved for.");
  params += NestedSolve::validParams();
  return params;
}