#include <RigidBodyMultiKernelAction.h>

Inheritance diagram for RigidBodyMultiKernelAction:

Public Member Functions
	RigidBodyMultiKernelAction (const InputParameters &params)

virtual void	act ()

Public Attributes
unsigned int	_op_num

std::string	_var_name_base

bool	_implicit

Detailed Description

Definition at line 14 of file RigidBodyMultiKernelAction.h.

Constructor & Destructor Documentation

◆ RigidBodyMultiKernelAction()

RigidBodyMultiKernelAction::RigidBodyMultiKernelAction ( const InputParameters & params )

Definition at line 50 of file RigidBodyMultiKernelAction.C.

   : Action(params),
     _op_num(getParam<unsigned int>("op_num")),
     _var_name_base(getParam<std::string>("var_name_base")),
     _implicit(getParam<bool>("implicit"))
 {
 }

Member Function Documentation

◆ act()

void RigidBodyMultiKernelAction::act ( )

virtual

Definition at line 59 of file RigidBodyMultiKernelAction.C.

 {
   for (unsigned int op = 0; op < _op_num; ++op)
   {
     //
     // Create variable names
     //
  
     std::string var_name = _var_name_base + Moose::stringify(op);
  
     //
     // Create vector of coupled variables
     //
  
     std::vector<VariableName> arg;
     unsigned int ind = 0;
  
     if (isParamValid("c"))
     {
       VariableName c = getParam<VariableName>("c");
       arg.resize(_op_num);
  
       for (unsigned int j = 0; j < _op_num; ++j)
         if (j != op)
           arg[ind++] = _var_name_base + Moose::stringify(j);
  
       arg[ind++] = c;
     }
     else
     {
       arg.resize(_op_num - 1);
       for (unsigned int j = 0; j < _op_num; ++j)
         if (j != op)
           arg[ind++] = _var_name_base + Moose::stringify(j);
     }
  
     //
     // Create vector of order parameters
     //
  
     std::vector<VariableName> v(_op_num);
     for (unsigned int j = 0; j < _op_num; ++j)
       v[j] = _var_name_base + Moose::stringify(j);
  
     //
     // Set up ACInterface kernels
     //
  
     {
       InputParameters params = _factory.getValidParams("ACInterface");
       params.set<NonlinearVariableName>("variable") = var_name;
       params.set<bool>("implicit") = getParam<bool>("implicit");
       params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
       params.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa_name");
       params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mob_name");
  
       std::string kernel_name = "ACInt_" + var_name;
       _problem->addKernel("ACInterface", kernel_name, params);
     }
  
     //
     // Set up the AllenCahn kernels
     //
  
     {
       InputParameters params = _factory.getValidParams("AllenCahn");
       params.set<NonlinearVariableName>("variable") = var_name;
       params.set<std::vector<VariableName>>("args") = arg;
       params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mob_name");
       params.set<MaterialPropertyName>("f_name") = getParam<MaterialPropertyName>("f_name");
       params.set<bool>("implicit") = _implicit;
       params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
  
       std::string kernel_name = "AC_" + var_name;
       _problem->addKernel("AllenCahn", kernel_name, params);
     }
  
     //
     // Set up SingleGrainRigidBodyMotion kernels
     //
  
     {
       InputParameters params = _factory.getValidParams("SingleGrainRigidBodyMotion");
       params.set<NonlinearVariableName>("variable") = var_name;
       params.set<std::vector<VariableName>>("v") = v;
       params.set<unsigned int>("op_index") = op;
       params.set<std::vector<VariableName>>("c") = {getParam<VariableName>("c")};
       if (isParamValid("base_name"))
         params.set<std::string>("base_name") = getParam<std::string>("base_name");
       params.set<Real>("translation_constant") = getParam<Real>("translation_constant");
       params.set<Real>("rotation_constant") = getParam<Real>("rotation_constant");
       params.set<UserObjectName>("grain_force") = getParam<UserObjectName>("grain_force");
       params.set<UserObjectName>("grain_tracker_object") =
           getParam<UserObjectName>("grain_tracker_object");
       params.set<VectorPostprocessorName>("grain_volumes") =
           getParam<VectorPostprocessorName>("grain_volumes");
  
       params.set<bool>("implicit") = _implicit;
       params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
  
       std::string kernel_name = "RigidBody_" + var_name;
       _problem->addKernel("SingleGrainRigidBodyMotion", kernel_name, params);
     }
  
     //
     // Set up TimeDerivative kernels
     //
  
     {
       InputParameters params = _factory.getValidParams("TimeDerivative");
       params.set<NonlinearVariableName>("variable") = var_name;
       params.set<bool>("implicit") = true;
       params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
  
       std::string kernel_name = "IE_" + var_name;
       _problem->addKernel("TimeDerivative", kernel_name, params);
     }
   }
 }