GrainGrowthAction Class Reference

#include <GrainGrowthAction.h>

Inheritance diagram for GrainGrowthAction:

Public Member Functions
	GrainGrowthAction (const InputParameters &params)
virtual void	act ()

Protected Member Functions
void	addKernel (const std::string &kernel_type, const std::string &kernel_name, InputParameters params)

Protected Attributes
const unsigned int	_op_num
	number of variables and variable name base for variable creation More...
const std::string	_var_name_base
const FEType	_fe_type
	FEType for the variable being created. More...
const bool	_use_ad
	use AD objects where possible More...

Detailed Description

Definition at line 23 of file GrainGrowthAction.h.

Constructor & Destructor Documentation

GrainGrowthAction()

GrainGrowthAction::GrainGrowthAction

(

const InputParameters &

params

)

Definition at line 87 of file GrainGrowthAction.C.

  : Action(params),
    _op_num(getParam<unsigned int>("op_num")),
    _var_name_base(getParam<std::string>("var_name_base")),
    _fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
             Utility::string_to_enum<FEFamily>(getParam<MooseEnum>("family"))),
    _use_ad(getParam<bool>("use_automatic_differentiation"))
{
}

Member Function Documentation

act()

void GrainGrowthAction::act ( )

virtual

Definition at line 98 of file GrainGrowthAction.C.

{
  // take initial values from file?
  bool initial_from_file = getParam<bool>("initial_from_file");
 
  // Loop over order parameters
  for (unsigned int op = 0; op < _op_num; op++)
  {
    auto type = AddVariableAction::determineType(_fe_type, 1);
    auto var_params = _factory.getValidParams(type);
 
    var_params.applySpecificParameters(_pars, {"family", "order"});
    var_params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
 
    // Create variable name
    std::string var_name = _var_name_base + Moose::stringify(op);
 
    // Setup initial from file if requested
    if (initial_from_file)
    {
      if (_current_task == "check_copy_nodal_vars")
        _app.setFileRestart() = true;
 
      if (_current_task == "copy_nodal_vars")
      {
        auto * system = &_problem->getNonlinearSystemBase();
        system->addVariableToCopy(var_name, var_name, "LATEST");
      }
    }
 
    // Add variable
    if (_current_task == "add_variable")
      _problem->addVariable(type, var_name, var_params);
 
    // Add Kernels
    else if (_current_task == "add_kernel")
    {
      //
      // Add time derivative kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADTimeDerivative" : "TimeDerivative";
 
        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params =
            _factory.getValidParams(kernel_type + (_use_ad ? "<RESIDUAL>" : ""));
        params.set<NonlinearVariableName>("variable") = var_name;
        params.applyParameters(parameters());
 
        addKernel(kernel_type, kernel_name, params);
      }
 
      //
      // Add ACGrGrPoly kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADGrainGrowth" : "ACGrGrPoly";
 
        // Make vector of order parameter names, excluding this one
        std::vector<VariableName> v;
        v.resize(_op_num - 1);
 
        unsigned int ind = 0;
        for (unsigned int j = 0; j < _op_num; ++j)
          if (j != op)
            v[ind++] = _var_name_base + Moose::stringify(j);
 
        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params =
            _factory.getValidParams(kernel_type + (_use_ad ? "<RESIDUAL>" : ""));
        params.set<NonlinearVariableName>("variable") = var_name;
        params.set<std::vector<VariableName>>("v") = v;
        params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
        params.applyParameters(parameters());
 
        addKernel(kernel_type, kernel_name, params);
      }
 
      //
      // Add ACInterface kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADACInterface" : "ACInterface";
 
        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params =
            _factory.getValidParams(kernel_type + (_use_ad ? "<RESIDUAL>" : ""));
        params.set<NonlinearVariableName>("variable") = var_name;
        params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
        params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
        params.set<bool>("variable_L") = getParam<bool>("variable_mobility");
        params.applyParameters(parameters());
 
        addKernel(kernel_type, kernel_name, params);
      }
 
      //
      // Set up optional ACGBPoly bubble interaction kernels
      //
 
      if (isParamValid("c"))
      {
        if (_use_ad)
          mooseError("AD version of ACGBPoly is not implemented");
 
        std::string kernel_type = "ACGBPoly";
 
        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params = _factory.getValidParams(kernel_type);
        params.set<NonlinearVariableName>("variable") = var_name;
        params.set<std::vector<VariableName>>("c") = {getParam<VariableName>("c")};
        params.applyParameters(parameters());
 
        _problem->addKernel(kernel_type, kernel_name, params);
      }
    }
  }
  // Create auxvariable
  if (_current_task == "add_aux_variable")
  {
    auto var_params = _factory.getValidParams("MooseVariable");
    var_params.set<MooseEnum>("family") = "LAGRANGE";
    var_params.set<MooseEnum>("order") = "FIRST";
    _problem->addAuxVariable("MooseVariable", "bnds", var_params);
  }
 
  // Create BndsCalcAux auxkernel
  else if (_current_task == "add_aux_kernel")
  {
    // Make vector of order parameter names, excluding this one std::vector<VariableName> v;
    std::vector<VariableName> v;
    v.resize(_op_num);
 
    for (unsigned int j = 0; j < _op_num; ++j)
      v[j] = _var_name_base + Moose::stringify(j);
 
    std::string aux_kernel_type = "BndsCalcAux";
 
    std::string aux_kernel_name = "bnds_" + aux_kernel_type;
    InputParameters params = _factory.getValidParams(aux_kernel_type);
    params.set<AuxVariableName>("variable") = "bnds";
    params.set<std::vector<VariableName>>("v") = v;
    params.applyParameters(parameters());
 
    _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
  }
}

addKernel()

void GrainGrowthAction::addKernel ( const std::string &  kernel_type, const std::string &  kernel_name, InputParameters  params  )

protected

Definition at line 250 of file GrainGrowthAction.C.

{
  if (_use_ad)
  {
    _problem->addKernel(kernel_type + "<RESIDUAL>", kernel_name + "_residual", params);
    _problem->addKernel(kernel_type + "<JACOBIAN>", kernel_name + "_jacobian", params);
    _problem->haveADObjects(true);
  }
  else
    _problem->addKernel(kernel_type, kernel_name, params);
}

Referenced by act().

Member Data Documentation

_fe_type

const FEType GrainGrowthAction::_fe_type

protected

FEType for the variable being created.

Definition at line 40 of file GrainGrowthAction.h.

Referenced by act().

_op_num

const unsigned int GrainGrowthAction::_op_num

protected

number of variables and variable name base for variable creation

Definition at line 36 of file GrainGrowthAction.h.

Referenced by act().

_use_ad

const bool GrainGrowthAction::_use_ad

protected

use AD objects where possible

Definition at line 43 of file GrainGrowthAction.h.

Referenced by act(), and addKernel().

_var_name_base

const std::string GrainGrowthAction::_var_name_base

protected

Definition at line 37 of file GrainGrowthAction.h.

Referenced by act().

---

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

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