GrandPotentialKernelAction Class Reference

#include <GrandPotentialKernelAction.h>

Inheritance diagram for GrandPotentialKernelAction:

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

Detailed Description

Definition at line 38 of file GrandPotentialKernelAction.h.

Constructor & Destructor Documentation

GrandPotentialKernelAction()

GrandPotentialKernelAction::GrandPotentialKernelAction

(

const InputParameters &

parameters

)

Definition at line 73 of file GrandPotentialKernelAction.C.

  : Action(parameters)
{
}

Member Function Documentation

act()

void GrandPotentialKernelAction::act ( )

virtual

Definition at line 79 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<bool>("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.");

  // 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") = v1;
    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>("D_name") = M[i];
    kernel_name = "MatDif_" + w_names[i];
    if (aniso)
      _problem->addKernel("MatAnisoDiffusion", kernel_name, params);
    else
      _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") = v1;
      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