void
PressureAction::act()
{
const std::string kernel_name = "Pressure";
std::vector<NonlinearVariableName> displacements;
if (isParamValid("displacements"))
displacements = getParam<std::vector<NonlinearVariableName>>("displacements");
else
{
// Legacy parameter scheme for displacements
if (!isParamValid("disp_x"))
mooseError("Specify displacement variables using the `displacements` parameter.");
displacements.push_back(getParam<NonlinearVariableName>("disp_x"));
if (isParamValid("disp_y"))
{
displacements.push_back(getParam<NonlinearVariableName>("disp_y"));
if (isParamValid("disp_z"))
displacements.push_back(getParam<NonlinearVariableName>("disp_z"));
}
}
// Create pressure BCs
for (unsigned int i = 0; i < displacements.size(); ++i)
{
// Create unique kernel name for each of the components
std::string unique_kernel_name = kernel_name + "_" + _name + "_" + Moose::stringify(i);
InputParameters params = _factory.getValidParams(kernel_name);
params.applyParameters(parameters());
params.set<bool>("use_displaced_mesh") = true;
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = displacements[i];
if (_has_save_in_vars[i])
params.set<std::vector<AuxVariableName>>("save_in") = _save_in_vars[i];
_problem->addBoundaryCondition(kernel_name, unique_kernel_name, params);
}
}
void
PolycrystalKernelAction::act()
{
for (unsigned int op = 0; op < _op_num; ++op)
{
//
// Create variable names
//
std::string var_name = _var_name_base + Moose::stringify(op);
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);
//
// Set up ACGrGrPoly kernels
//
{
InputParameters params = _factory.getValidParams("ACGrGrPoly");
params.set<NonlinearVariableName>("variable") = var_name;
params.set<std::vector<VariableName>>("v") = v;
params.applyParameters(parameters());
std::string kernel_name = "ACBulk_" + var_name;
_problem->addKernel("ACGrGrPoly", kernel_name, params);
}
//
// Set up ACInterface kernels
//
{
InputParameters params = _factory.getValidParams("ACInterface");
params.set<NonlinearVariableName>("variable") = var_name;
params.applyParameters(parameters());
std::string kernel_name = "ACInt_" + var_name;
_problem->addKernel("ACInterface", kernel_name, params);
}
//
// Set up TimeDerivative kernels
//
{
InputParameters params = _factory.getValidParams("TimeDerivative");
params.set<NonlinearVariableName>("variable") = var_name;
params.set<bool>("implicit") = true;
params.applyParameters(parameters());
std::string kernel_name = "IE_" + var_name;
_problem->addKernel("TimeDerivative", kernel_name, params);
}
//
// Set up optional ACGBPoly bubble interaction kernels
//
if (isParamValid("c"))
{
InputParameters params = _factory.getValidParams("ACGBPoly");
params.set<NonlinearVariableName>("variable") = var_name;
params.set<std::vector<VariableName>>("c") = {getParam<VariableName>("c")};
params.applyParameters(parameters());
std::string kernel_name = "ACBubInteraction_" + var_name;
_problem->addKernel("ACGBPoly", kernel_name, params);
}
}
}
void
ConservedAction::act()
{
//
// Add variable(s)
//
if (_current_task == "add_variable")
{
// Create conserved variable _var_name
_problem->addVariable(_var_name, _fe_type, _scaling);
// Create chemical potential variable for split form
switch (_solve_type)
{
case SolveType::DIRECT:
break;
case SolveType::REVERSE_SPLIT:
case SolveType::FORWARD_SPLIT:
_problem->addVariable(_chempot_name, _fe_type, _scaling);
}
}
//
// 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>>("conc") = {_chempot_name};
params.set<MaterialPropertyName>("D_name") = 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>>("conc") = {_var_name};
params.set<MaterialPropertyName>("D_name") = 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);
}
}
}
}
void
ContactAction::act()
{
if (!_problem->getDisplacedProblem())
mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the "
"Mesh block.");
std::string action_name = MooseUtils::shortName(name());
std::vector<NonlinearVariableName> displacements;
if (isParamValid("displacements"))
displacements = getParam<std::vector<NonlinearVariableName>>("displacements");
else
{
// Legacy parameter scheme for displacements
if (!isParamValid("disp_x"))
mooseError("Specify displacement variables using the `displacements` parameter.");
displacements.push_back(getParam<NonlinearVariableName>("disp_x"));
if (isParamValid("disp_y"))
{
displacements.push_back(getParam<NonlinearVariableName>("disp_y"));
if (isParamValid("disp_z"))
displacements.push_back(getParam<NonlinearVariableName>("disp_z"));
}
mooseDeprecated("use the `displacements` parameter rather than the `disp_*` parameters (those "
"will go away with the deprecation of the Solid Mechanics module).");
}
// Determine number of dimensions
const unsigned int ndisp = displacements.size();
// convert vector of NonlinearVariableName to vector of VariableName
std::vector<VariableName> coupled_displacements(ndisp);
for (unsigned int i = 0; i < ndisp; ++i)
coupled_displacements[i] = displacements[i];
if (_current_task == "add_dirac_kernel")
{
// MechanicalContactConstraint has to be added after the init_problem task, so it cannot be
// added for the add_constraint task.
if (_system == "Constraint")
{
InputParameters params = _factory.getValidParams("MechanicalContactConstraint");
params.applyParameters(parameters(), {"displacements", "formulation"});
params.set<std::string>("formulation") = _formulation;
params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area_" + name()};
params.set<std::vector<VariableName>>("displacements") = coupled_displacements;
params.set<BoundaryName>("boundary") = _master;
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i = 0; i < ndisp; ++i)
{
std::string name = action_name + "_constraint_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = displacements[i];
params.set<std::vector<VariableName>>("master_variable") = {coupled_displacements[i]};
_problem->addConstraint("MechanicalContactConstraint", name, params);
}
}
if (_system == "DiracKernel")
{
{
InputParameters params = _factory.getValidParams("ContactMaster");
params.applyParameters(parameters(), {"displacements", "formulation"});
params.set<std::string>("formulation") = _formulation;
params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area_" + name()};
params.set<std::vector<VariableName>>("displacements") = coupled_displacements;
params.set<BoundaryName>("boundary") = _master;
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i = 0; i < ndisp; ++i)
{
std::string name = action_name + "_master_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = displacements[i];
_problem->addDiracKernel("ContactMaster", name, params);
}
}
{
InputParameters params = _factory.getValidParams("SlaveConstraint");
params.applyParameters(parameters(), {"displacements", "formulation"});
params.set<std::string>("formulation") = _formulation;
params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area_" + name()};
params.set<std::vector<VariableName>>("displacements") = coupled_displacements;
params.set<BoundaryName>("boundary") = _slave;
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i = 0; i < ndisp; ++i)
{
std::string name = action_name + "_slave_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = displacements[i];
_problem->addDiracKernel("SlaveConstraint", name, params);
}
}
}
}
}
