GrainGrowthAction Class Reference

#include <GrainGrowthAction.h>

Inheritance diagram for GrainGrowthAction:

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

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

Detailed Description

Definition at line 24 of file GrainGrowthAction.h.

Constructor & Destructor Documentation

GrainGrowthAction()

GrainGrowthAction::GrainGrowthAction

(

const InputParameters &

params

)

Definition at line 74 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")))
{
}

Member Function Documentation

act()

void GrainGrowthAction::act ( )

virtual

Definition at line 84 of file GrainGrowthAction.C.

{
  // Loop over order parameters
  for (unsigned int op = 0; op < _op_num; op++)
  {
    // Create variable name
    std::string var_name = _var_name_base + Moose::stringify(op);

    // Add variable
    if (_current_task == "add_variable")
      _problem->addVariable(var_name, _fe_type, getParam<Real>("scaling"));

    // Add Kernels
    else if (_current_task == "add_kernel")
    {
      //
      // Add time derivative kernel
      //

      {
        std::string kernel_type = "TimeDerivative";

        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params = _factory.getValidParams(kernel_type);
        params.set<NonlinearVariableName>("variable") = var_name;
        params.applyParameters(parameters());

        _problem->addKernel(kernel_type, kernel_name, params);
      }

      //
      // Add ACGrGrPoly kernel
      //

      {
        std::string kernel_type = "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);
        params.set<NonlinearVariableName>("variable") = var_name;
        params.set<std::vector<VariableName>>("v") = v;
        params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
        params.applyParameters(parameters());

        _problem->addKernel(kernel_type, kernel_name, params);
      }

      //
      // Add ACInterface kernel
      //

      {
        std::string kernel_type = "ACInterface";

        std::string kernel_name = var_name + "_" + kernel_type;
        InputParameters params = _factory.getValidParams(kernel_type);
        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());

        _problem->addKernel(kernel_type, kernel_name, params);
      }

      //
      // Set up optional ACGBPoly bubble interaction kernels
      //

      if (isParamValid("c"))
      {
        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")
    _problem->addAuxVariable("bnds",
                             FEType(Utility::string_to_enum<Order>("FIRST"),
                                    Utility::string_to_enum<FEFamily>("LAGRANGE")));
  // 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);
  }
}

Member Data Documentation

_fe_type

const FEType GrainGrowthAction::_fe_type

protected

FEType for the variable being created.

Definition at line 37 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 33 of file GrainGrowthAction.h.

Referenced by act().

_var_name_base

const std::string GrainGrowthAction::_var_name_base

protected

Definition at line 34 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