GrandPotentialKernelAction Class Reference

Generates the necessary kernels for the Grand Potential Function for any number of order parameters and chemical potentials. More...

#include <GrandPotentialKernelAction.h>

Inheritance diagram for GrandPotentialKernelAction:

Public Member Functions
	GrandPotentialKernelAction (const InputParameters &parameters)
virtual void	act ()

Detailed Description

Generates the necessary kernels for the Grand Potential Function for any number of order parameters and chemical potentials.

Can do so with two sets of order parameters that use different material properties. Also able to use anisotropic diffusivities for the chemical potential variables.

KERNELS GENERATED BY THIS ACTION chemical_potentials -SusceptibilityTimeDerivative -MatDiffusion (or MatAnisonDiffusion if D is a tensor) -CoupledSwitchingTimeDerivative (one for each gr and op) grains -TimeDerivative -ACInterface -ACSwitching -ACGrGrMulti additional_order_parameters -TimeDerivative -ACInterface -ACSwitching -ACGrGrMulti

Definition at line 37 of file GrandPotentialKernelAction.h.

Constructor & Destructor Documentation

GrandPotentialKernelAction()

GrandPotentialKernelAction::GrandPotentialKernelAction

(

const InputParameters &

parameters

)

Definition at line 75 of file GrandPotentialKernelAction.C.

  : Action(parameters)
{
}

Member Function Documentation

act()

void GrandPotentialKernelAction::act ( )

virtual

Definition at line 81 of file GrandPotentialKernelAction.C.

{
  // Get Variables from parameters
  const auto w_names = getParam<std::vector<NonlinearVariableName>>("chemical_potentials");
  const auto chis = getParam<std::vector<MaterialPropertyName>>("susceptibilities");
  const auto Fj_gr = getParam<std::vector<MaterialPropertyName>>("free_energies_gr");
  const auto Fj_w = getParam<std::vector<MaterialPropertyName>>("free_energies_w");
  const auto hj = getParam<std::vector<MaterialPropertyName>>("switching_function_names");
  const auto M = getParam<std::vector<MaterialPropertyName>>("mobilities");
  auto n_grs = getParam<unsigned int>("op_num");
  const auto var_name_base = getParam<std::string>("var_name_base");
  const auto Fj_op = getParam<std::vector<MaterialPropertyName>>("free_energies_op");
  const auto kappa_gr = getParam<MaterialPropertyName>("kappa_gr");
  const auto kappa_op = getParam<MaterialPropertyName>("kappa_op");
  const auto gamma_gr = getParam<MaterialPropertyName>("gamma_gr");
  const auto gamma_op = getParam<MaterialPropertyName>("gamma_op");
  const auto gamma_xx = getParam<MaterialPropertyName>("gamma_grxop");
  const auto gr_mob = getParam<MaterialPropertyName>("mobility_name_gr");
  const auto op_mob = getParam<MaterialPropertyName>("mobility_name_op");
  auto implicity = getParam<bool>("implicit");
  auto displaced_mesh = getParam<bool>("use_displaced_mesh");
  auto aniso = getParam<MultiMooseEnum>("anisotropic");
 
  // Size definitions and checks
  unsigned int n_w = w_names.size();
  unsigned int n_hj = hj.size();
  std::vector<NonlinearVariableName> etas;
  unsigned int n_etas = 0;
  std::string kernel_name;
  if (isParamValid("additional_ops"))
  {
    etas = getParam<std::vector<NonlinearVariableName>>("additional_ops");
    n_etas = etas.size();
  }
 
  if (chis.size() != n_w)
    mooseError("susceptibilities and chemical_potentials should be vectors of the same length.");
  if (Fj_w.size() != n_w * n_hj)
    mooseError("free_energies_w should be length of chemcial_potentials * length of "
               "switching_function_names");
  if (M.size() != n_w)
    mooseError("M and chemical_potentials should be vectors of the same length.");
  if (aniso.size() != n_w)
    paramError("anisotropic", "Provide as many values as entries in 'chemical_potentials'.");
 
  // Define additional vectors
  std::vector<std::string> grs; // vector of all grain variable names
  grs.resize(n_grs);
  for (unsigned int i = 0; i < n_grs; ++i)
    grs[i] = var_name_base + Moose::stringify(i);
 
  std::vector<NonlinearVariableName> all_etas; // vector of all grain variables and order parameters
  all_etas.reserve(n_etas + n_grs);
  all_etas.insert(all_etas.end(), etas.begin(), etas.end());
  all_etas.insert(all_etas.end(), grs.begin(), grs.end());
 
  std::vector<std::string> all_vars; // vector of all variables
  all_vars.reserve(n_etas + n_grs + n_w);
  all_vars.insert(all_vars.end(), all_etas.begin(), all_etas.end());
  all_vars.insert(all_vars.end(), w_names.begin(), w_names.end());
 
  std::vector<MaterialPropertyName> fj_temp;
  fj_temp.resize(n_hj);
  std::vector<VariableName> notarealvector;
  notarealvector.resize(1);
  std::vector<VariableName> v0;
  v0.resize(n_etas + n_grs + n_w);
  for (unsigned int i = 0; i < n_etas + n_grs + n_w; ++i)
    v0[i] = all_vars[i];
  std::vector<VariableName> v1;
  v1.resize(n_etas + n_grs);
  for (unsigned int i = 0; i < n_etas + n_grs; ++i)
    v1[i] = all_etas[i];
  std::vector<VariableName> v2;
  v2.resize(n_etas + n_grs - 1);
 
  // Grains and order parameters
  NonlinearVariableName var_name;
  MaterialPropertyName kappa;
  MaterialPropertyName mob_name;
  std::vector<MaterialPropertyName> Fj_names;
 
  for (unsigned int i = 0; i < n_etas + n_grs; ++i)
  {
    var_name = all_etas[i];
    // Distinguish between grains and the additional order parameters
    if (i < n_etas) // First part of list is grain variables
    {
      kappa = kappa_op;
      mob_name = op_mob;
      Fj_names.resize(Fj_op.size());
      Fj_names = Fj_op;
    }
    else // Second part of list is additional order parameters
    {
      kappa = kappa_gr;
      mob_name = gr_mob;
      Fj_names.resize(Fj_gr.size());
      Fj_names = Fj_gr;
    }
 
    // Remove var_name from coupled variables
    std::vector<MaterialPropertyName> gam;
    gam.resize(n_etas + n_grs - 1);
    unsigned int op = 0;
    for (unsigned int j = 0; j < n_etas + n_grs; ++j)
    {
      if (i != j)
      {
        v2[op] = all_etas[j];
        if (j < n_etas)
          gam[op] = gamma_op;
        else
          gam[op] = gamma_gr;
        if (i < n_etas && j < n_etas)
          gam[op] = gamma_op;
        else if (i >= n_etas && j >= n_etas)
          gam[op] = gamma_gr;
        else
          gam[op] = gamma_xx;
        ++op;
      }
    }
 
    // TimeDerivative Kernel
    InputParameters params = _factory.getValidParams("TimeDerivative");
    params.set<NonlinearVariableName>("variable") = var_name;
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    kernel_name = "DT_" + var_name;
    _problem->addKernel("TimeDerivative", kernel_name, params);
 
    // ACInterface Kernel
    params = _factory.getValidParams("ACInterface");
    params.set<NonlinearVariableName>("variable") = var_name;
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    params.set<MaterialPropertyName>("kappa_name") = kappa;
    params.set<MaterialPropertyName>("mob_name") = mob_name;
    params.set<std::vector<VariableName>>("args") = v2;
    kernel_name = "ACInt_" + var_name;
    _problem->addKernel("ACInterface", kernel_name, params);
 
    // ACSwitching Kernel
    params = _factory.getValidParams("ACSwitching");
    params.set<NonlinearVariableName>("variable") = var_name;
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    params.set<std::vector<MaterialPropertyName>>("Fj_names") = Fj_names;
    params.set<std::vector<MaterialPropertyName>>("hj_names") = hj;
    params.set<MaterialPropertyName>("mob_name") = mob_name;
    params.set<std::vector<VariableName>>("args") = v0;
    kernel_name = "ACSwitch_" + var_name;
    _problem->addKernel("ACSwitching", kernel_name, params);
 
    // ACGrGrMulti Kernel
    params = _factory.getValidParams("ACGrGrMulti");
    params.set<NonlinearVariableName>("variable") = var_name;
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    params.set<MaterialPropertyName>("mob_name") = mob_name;
    params.set<std::vector<VariableName>>("v") = v2;
    params.set<std::vector<MaterialPropertyName>>("gamma_names") = gam;
    kernel_name = "AcGrGr_" + var_name;
    _problem->addKernel("ACGrGrMulti", kernel_name, params);
  } // for (unsigned int i = 0; i < n_etas + n_grs; ++i)
 
  // Chemical Potentials
  for (unsigned int i = 0; i < n_w; ++i)
  {
    // SusceptibilityTimeDerivative
    InputParameters params = _factory.getValidParams("SusceptibilityTimeDerivative");
    params.set<NonlinearVariableName>("variable") = w_names[i];
    params.set<MaterialPropertyName>("f_name") = chis[i];
    params.set<std::vector<VariableName>>("args") = v0;
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    kernel_name = "ChiDt_" + w_names[i];
    _problem->addKernel("SusceptibilityTimeDerivative", kernel_name, params);
 
    // MatDiffusion
    params = _factory.getValidParams("MatDiffusion");
    params.set<NonlinearVariableName>("variable") = w_names[i];
    params.set<bool>("implicit") = implicity;
    params.set<bool>("use_displaced_mesh") = displaced_mesh;
    params.set<MaterialPropertyName>("diffusivity") = M[i];
    kernel_name = "MatDif_" + w_names[i];
    if (aniso.get(i))
      _problem->addKernel("MatAnisoDiffusion", kernel_name, params);
    else
    {
      params.set<std::vector<VariableName>>("args") = v0;
      _problem->addKernel("MatDiffusion", kernel_name, params);
    }
 
    // CoupledSwitchingTimeDerivative
    for (unsigned int j = 0; j < n_hj; ++j)
      fj_temp[j] = Fj_w[i * n_hj + j];
    for (unsigned int j = 0; j < n_etas + n_grs; ++j)
    {
      notarealvector[0] = all_etas[j];
      params = _factory.getValidParams("CoupledSwitchingTimeDerivative");
      params.set<NonlinearVariableName>("variable") = w_names[i];
      params.set<std::vector<VariableName>>("v") = notarealvector;
      params.set<std::vector<VariableName>>("args") = v0;
      params.set<std::vector<MaterialPropertyName>>("Fj_names") = fj_temp;
      params.set<std::vector<MaterialPropertyName>>("hj_names") = hj;
      params.set<bool>("implicit") = implicity;
      params.set<bool>("use_displaced_mesh") = displaced_mesh;
      kernel_name = "Coupled_" + w_names[i] + "_" + all_etas[j];
      _problem->addKernel("CoupledSwitchingTimeDerivative", kernel_name, params);
    }
  }
} // GrandPotentialKernelAction::act()

---

The documentation for this class was generated from the following files:

• phase_field/include/action/GrandPotentialKernelAction.h
• phase_field/src/action/GrandPotentialKernelAction.C