ConservedAction Class Reference

#include <ConservedAction.h>

Inheritance diagram for ConservedAction:

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

Protected Types
enum	SolveType { SolveType::DIRECT, SolveType::REVERSE_SPLIT, SolveType::FORWARD_SPLIT }
	Type of solve. More...

Protected Attributes
std::string	_chempot_name
	Name of chemical potential variable for split solves. More...
const SolveType	_solve_type
	Type of solve to use used in the action. More...
const NonlinearVariableName	_var_name
	Name of the variable being created. More...
FEType	_fe_type
	FEType for the variable being created. More...
const Real	_scaling
	Scaling parameter. More...

Detailed Description

Definition at line 23 of file ConservedAction.h.

Member Enumeration Documentation

SolveType

enum ConservedAction::SolveType

strongprotected

Type of solve.

Enumerator
DIRECT
REVERSE_SPLIT
FORWARD_SPLIT

Definition at line 32 of file ConservedAction.h.

  {
    DIRECT,
    REVERSE_SPLIT,
    FORWARD_SPLIT
  };

Constructor & Destructor Documentation

ConservedAction()

ConservedAction::ConservedAction

(

const InputParameters &

params

)

Definition at line 62 of file ConservedAction.C.

  : Action(params),
    _solve_type(getParam<MooseEnum>("solve_type").getEnum<SolveType>()),
    _var_name(name()),
    _scaling(getParam<Real>("scaling"))
{
  switch (_solve_type)
  {
    case SolveType::DIRECT:
      _fe_type = FEType(Utility::string_to_enum<Order>("THIRD"),
                        Utility::string_to_enum<FEFamily>("HERMITE"));
      if (!parameters().isParamSetByAddParam("order") &&
          !parameters().isParamSetByAddParam("family"))
        mooseWarning("Order and family autoset to third and hermite in ConservedAction");
      break;
    case SolveType::REVERSE_SPLIT:
    case SolveType::FORWARD_SPLIT:
      _fe_type = FEType(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
                        Utility::string_to_enum<FEFamily>(getParam<MooseEnum>("family")));
      // Set name of chemical potential variable
      _chempot_name = "chem_pot_" + _var_name;
      break;
    default:
      paramError("solve_type", "Incorrect solve_type in ConservedAction");
  }
}

Member Function Documentation

act()

void ConservedAction::act ( )

overridevirtual

Definition at line 90 of file ConservedAction.C.

{
  //
  // Add variable(s)
  //
  if (_current_task == "add_variable")
  {
    auto type = AddVariableAction::determineType(_fe_type, 1);
    auto var_params = _factory.getValidParams(type);
    var_params.set<MooseEnum>("family") = Moose::stringify(_fe_type.family);
    var_params.set<MooseEnum>("order") = _fe_type.order.get_order();
    var_params.set<std::vector<Real>>("scaling") = {_scaling};
 
    // Create conserved variable _var_name
    _problem->addVariable(type, _var_name, var_params);
 
    // Create chemical potential variable for split form
    switch (_solve_type)
    {
      case SolveType::DIRECT:
        break;
      case SolveType::REVERSE_SPLIT:
      case SolveType::FORWARD_SPLIT:
        _problem->addVariable(type, _chempot_name, var_params);
    }
  }
 
  //
  // Add Kernels
  //
  else if (_current_task == "add_kernel")
  {
    switch (_solve_type)
    {
      case SolveType::DIRECT:
        // 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 CahnHilliard kernel
        {
          std::string kernel_type = "CahnHilliard";
 
          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>("f_name") =
              getParam<MaterialPropertyName>("free_energy");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
 
        // Add ACInterface kernel
        {
          std::string kernel_type = "CHInterface";
 
          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.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
        break;
 
      case SolveType::REVERSE_SPLIT:
        // Add time derivative kernel
        {
          std::string kernel_type = "CoupledTimeDerivative";
 
          std::string kernel_name = _var_name + "_" + kernel_type;
          InputParameters params = _factory.getValidParams(kernel_type);
          params.set<NonlinearVariableName>("variable") = _chempot_name;
          params.set<std::vector<VariableName>>("v") = {_var_name};
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
 
        // Add SplitCHWRes kernel
        {
          std::string kernel_type = "SplitCHWRes";
 
          std::string kernel_name = _var_name + "_" + kernel_type;
          InputParameters params = _factory.getValidParams(kernel_type);
          params.set<NonlinearVariableName>("variable") = _chempot_name;
          params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
 
        // Add SplitCHParsed kernel
        {
          std::string kernel_type = "SplitCHParsed";
 
          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>>("w") = {_chempot_name};
          params.set<MaterialPropertyName>("f_name") =
              getParam<MaterialPropertyName>("free_energy");
          params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
        break;
 
      case SolveType::FORWARD_SPLIT:
        // 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 MatDiffusion kernel for c residual
        {
          std::string kernel_type = "MatDiffusion";
 
          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") = {_chempot_name};
          params.set<MaterialPropertyName>("diffusivity") =
              getParam<MaterialPropertyName>("mobility");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
        // Add MatDiffusion kernel for chemical potential residual
        {
          std::string kernel_type = "MatDiffusion";
 
          std::string kernel_name = _chempot_name + "_" + kernel_type;
          InputParameters params = _factory.getValidParams(kernel_type);
          params.set<NonlinearVariableName>("variable") = _chempot_name;
          params.set<std::vector<VariableName>>("v") = {_var_name};
          params.set<MaterialPropertyName>("diffusivity") = getParam<MaterialPropertyName>("kappa");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
 
        // Add CoupledMaterialDerivative kernel
        {
          std::string kernel_type = "CoupledMaterialDerivative";
 
          std::string kernel_name = _chempot_name + "_" + kernel_type;
          InputParameters params = _factory.getValidParams(kernel_type);
          params.set<NonlinearVariableName>("variable") = _chempot_name;
          params.set<std::vector<VariableName>>("v") = {_var_name};
          params.set<MaterialPropertyName>("f_name") =
              getParam<MaterialPropertyName>("free_energy");
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
 
        // Add CoefReaction kernel
        {
          std::string kernel_type = "CoefReaction";
 
          std::string kernel_name = _chempot_name + "_" + kernel_type;
          InputParameters params = _factory.getValidParams(kernel_type);
          params.set<NonlinearVariableName>("variable") = _chempot_name;
          params.set<Real>("coefficient") = -1.0;
          params.applyParameters(parameters());
 
          _problem->addKernel(kernel_type, kernel_name, params);
        }
    }
  }
}

Member Data Documentation

_chempot_name

std::string ConservedAction::_chempot_name

protected

Name of chemical potential variable for split solves.

Definition at line 39 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

_fe_type

FEType ConservedAction::_fe_type

protected

FEType for the variable being created.

Definition at line 45 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

_scaling

const Real ConservedAction::_scaling

protected

Scaling parameter.

Definition at line 47 of file ConservedAction.h.

Referenced by act().

_solve_type

const SolveType ConservedAction::_solve_type

protected

Type of solve to use used in the action.

Definition at line 41 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

_var_name

const NonlinearVariableName ConservedAction::_var_name

protected

Name of the variable being created.

Definition at line 43 of file ConservedAction.h.

Referenced by act(), and ConservedAction().

---

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

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