#include <KKSPhaseConcentrationMultiPhaseMaterial.h>

Inheritance diagram for KKSPhaseConcentrationMultiPhaseMaterial:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	KKSPhaseConcentrationMultiPhaseMaterial (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 unsigned int	_num_j
	Number of phase parameters.

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
	Check whether to use damping.

NestedSolve	_nested_solve
	Instantiation of the NestedSolve class.

std::vector< MaterialBase * >	_Fj_mat
	Free energy instantiation of the MaterialBase class.


std::vector< MaterialPropertyName >	_hj_names
	Switching functions.

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


const std::vector< MaterialName >	_Fj_names
	Free energies.

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


std::vector< MaterialPropertyName >	_ci_names
	Phase concentrations.

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

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

std::vector< Real >	_ci_IC


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


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


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


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


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

const Real	_rel_tol


MaterialName	_condition_name
	Condition that must be violated for damping to occur.

MaterialBase *	_condition

const MaterialProperty< Real > *	_C

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 KKSPhaseConcentrationMultiPhaseMaterial.h.

Constructor & Destructor Documentation

◆ KKSPhaseConcentrationMultiPhaseMaterial()

KKSPhaseConcentrationMultiPhaseMaterial::KKSPhaseConcentrationMultiPhaseMaterial ( const InputParameters & parameters )

Definition at line 50 of file KKSPhaseConcentrationMultiPhaseMaterial.C.

  : DerivativeMaterialInterface<Material>(parameters),
    _prop_c(coupledValues("global_cs")),
    _num_c(coupledComponents("global_cs")),
    _num_j(coupledComponents("all_etas")),
    _hj_names(getParam<std::vector<MaterialPropertyName>>("hj_names")),
    _prop_hj(_num_j),
    _Fj_names(getParam<std::vector<MaterialName>>("Fj_names")),
    _prop_Fi(_num_j),
    _ci_names(getParam<std::vector<MaterialPropertyName>>("ci_names")),
    _prop_ci(_num_c * _num_j),
    _ci_old(_num_c * _num_j),
    _ci_IC(getParam<std::vector<Real>>("ci_IC")),
    _dFidci(_num_j),
    _d2Fidcidbi(_num_j),
    _args_names(coupledNames("args")),
    _n_args(coupledComponents("args")),
    _dFidarg(_num_j),
    _d2F1dc1darg(_num_c),
    _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 * _num_j))
  {
    _ci_old[m] = &getMaterialPropertyOld<Real>(_ci_names[m]);
    _prop_ci[m] = &declareProperty<Real>(_ci_names[m]);
  }
 
  // free energies
  for (const auto m : make_range(_num_j))
    _prop_Fi[m] = &getMaterialPropertyByName<Real>(_Fj_names[m]);
 
  // free energy derivatives w.r.t. phase concentrations
  for (const auto m : make_range(_num_j))
  {
    _prop_hj[m] = &getMaterialPropertyByName<Real>(_hj_names[m]);
 
    _dFidci[m].resize(_num_c);
    _d2Fidcidbi[m].resize(_num_c);
 
    for (const auto n : make_range(_num_c))
    {
      _dFidci[m][n] = &getMaterialPropertyDerivative<Real>(_Fj_names[m], _ci_names[m + n * _num_j]);
 
      _d2Fidcidbi[m][n].resize(_num_c);
 
      for (unsigned int l = 0; l < _num_c; ++l)
      {
        _d2Fidcidbi[m][n][l] = &getMaterialPropertyDerivative<Real>(
            _Fj_names[m], _ci_names[m + n * _num_j], _ci_names[m + l * _num_j]);
      }
    }
  }
 
  // derivative of free energies wrt coupled variables
  for (const auto m : make_range(_num_j))
  {
    _dFidarg[m].resize(_n_args);
 
    for (const auto n : make_range(_n_args))
      _dFidarg[m][n] = &getMaterialPropertyDerivative<Real>(_Fj_names[m], _args_names[n]);
  }
 
  // second derivatives of F1 wrt c1 and other coupled variables
  for (const auto m : make_range(_num_c))
  {
    _d2F1dc1darg[m].resize(_n_args);
 
    for (const auto n : make_range(_n_args))
    {
      _d2F1dc1darg[m][n] =
          &getMaterialPropertyDerivative<Real>(_Fj_names[0], _ci_names[m * _num_j], _args_names[n]);
    }
  }
 
  if (_damped_newton)
    _C = &getMaterialPropertyByName<Real>(_condition_name);
  else
    _C = nullptr;
}

Member Function Documentation

◆ computeQpProperties()

void KKSPhaseConcentrationMultiPhaseMaterial::computeQpProperties ( )

overrideprotectedvirtual

Definition at line 157 of file KKSPhaseConcentrationMultiPhaseMaterial.C.

{
  // parameters for nested Newton iteration
  NestedSolve::Value<> solution(_num_c * _num_j);
 
  // initialize first guess using the solution from previous step
  for (const auto m : make_range(_num_c * _num_j))
    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 * _num_j))
      (*_prop_ci[m])[_qp] = guess(m);
 
    for (const auto m : make_range(_num_j))
      _Fj_mat[m]->computePropertiesAtQp(_qp);
 
    // assign residual functions
    for (const auto m : make_range(_num_c))
    {
      for (const auto n : make_range(_num_j - 1))
        residual(m * _num_j + n) = (*_dFidci[n][m])[_qp] - (*_dFidci[n + 1][m])[_qp];
 
      residual((m + 1) * _num_j - 1) = -(*_prop_c[m])[_qp];
 
      for (const auto l : make_range(_num_j))
        residual((m + 1) * _num_j - 1) += (*_prop_hj[l])[_qp] * (*_prop_ci[m * _num_j + l])[_qp];
    }
 
    jacobian.setZero();
 
    // fill in the non-zero terms in jacobian
    for (const auto m : make_range(_num_c))
    {
      // equal chemical potential derivative equations
      for (const auto n : make_range(_num_j - 1))
      {
        for (const auto l : make_range(_num_c))
        {
          jacobian(m * _num_j + n, n + l * _num_j) = (*_d2Fidcidbi[n][m][l])[_qp];
          jacobian(m * _num_j + n, n + l * _num_j + 1) = -(*_d2Fidcidbi[n + 1][m][l])[_qp];
        }
      }
 
      // concentration conservation derivative equations
      for (const auto n : make_range(_num_j))
        jacobian((m + 1) * _num_j - 1, m * _num_j + n) = (*_prop_hj[n])[_qp];
    }
  };
 
  auto computeCondition = [&](const NestedSolve::Value<> & guess) -> Real
  {
    for (const auto m : make_range(_num_c * _num_j))
      (*_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 * _num_j))
    (*_prop_ci[m])[_qp] = solution[m];
}

◆ initialSetup()

void KKSPhaseConcentrationMultiPhaseMaterial::initialSetup ( )

overrideprotectedvirtual

Definition at line 146 of file KKSPhaseConcentrationMultiPhaseMaterial.C.

{
  _Fj_mat.resize(_num_j);
 
  for (unsigned int m = 0; m < _num_j; ++m)
    _Fj_mat[m] = &getMaterialByName(_Fj_names[m]);
  if (_damped_newton)
    _condition = &getMaterialByName(_condition_name);
}

◆ initQpStatefulProperties()

void KKSPhaseConcentrationMultiPhaseMaterial::initQpStatefulProperties ( )

overrideprotectedvirtual

Definition at line 139 of file KKSPhaseConcentrationMultiPhaseMaterial.C.

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

◆ validParams()

InputParameters KKSPhaseConcentrationMultiPhaseMaterial::validParams ( )

static

Definition at line 16 of file KKSPhaseConcentrationMultiPhaseMaterial.C.

{
  InputParameters params = DerivativeMaterialInterface<Material>::validParams();
  params.addClassDescription(
      "Computes the KKS phase concentrations by using a nested Newton iteration "
      "to solve the equal chemical potential and concentration conservation equations for "
      "multiphase systems. This class is intented to be used with "
      "KKSPhaseConcentrationMultiPhaseDerivatives.");
  params.addRequiredCoupledVar("global_cs", "The interpolated concentrations c, b, etc.");
  params.addRequiredCoupledVar("all_etas", "Order parameters.");
  params.addRequiredParam<std::vector<MaterialPropertyName>>(
      "hj_names", "Switching functions in the same order as all_etas.");
  params.addRequiredParam<std::vector<MaterialName>>(
      "Fj_names", "Free energy material objects in the same order as all_etas.");
  params.addRequiredParam<std::vector<MaterialPropertyName>>(
      "ci_names",
      "Phase concentrations. They must have the same order as Fj_names and global_cs, for "
      "example, c1, c2, b1, b2.");
  params.addRequiredParam<std::vector<Real>>("ci_IC",
                                             "Initial values of ci in the same order of ci_names");
  params.addParam<MaterialPropertyName>(
      "nested_iterations",
      "The output number of nested Newton iterations at each quadrature point.");
  params.addCoupledVar("args", "The coupled variables of free energies.");
  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;
}