Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "NonconservedAction.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Conversion.h"
      14             : #include "FEProblem.h"
      15             : #include "Factory.h"
      16             : #include "MooseObjectAction.h"
      17             : #include "MooseMesh.h"
      18             : 
      19             : #include "libmesh/string_to_enum.h"
      20             : 
      21             : using namespace libMesh;
      22             : 
      23             : registerMooseAction("PhaseFieldApp", NonconservedAction, "add_variable");
      24             : 
      25             : registerMooseAction("PhaseFieldApp", NonconservedAction, "add_kernel");
      26             : 
      27             : InputParameters
      28          47 : NonconservedAction::validParams()
      29             : {
      30          47 :   InputParameters params = Action::validParams();
      31          47 :   params.addClassDescription(
      32             :       "Set up the variable and the kernels needed for a non-conserved phase field variable");
      33             :   // Get MooseEnums for the possible order/family options for this variable
      34          47 :   MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
      35          47 :   MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
      36          94 :   params.addParam<MooseEnum>("family",
      37             :                              families,
      38             :                              "Specifies the family of FE "
      39             :                              "shape functions to use for this variable");
      40          94 :   params.addParam<MooseEnum>("order",
      41             :                              orders,
      42             :                              "Specifies the order of the FE "
      43             :                              "shape function to use for this variable");
      44          94 :   params.addParam<Real>("scaling", 1.0, "Specifies a scaling factor to apply to this variable");
      45          94 :   params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
      46          94 :   params.addParam<bool>(
      47          94 :       "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
      48          94 :   params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
      49          94 :   params.addParam<MaterialPropertyName>("mobility", "L", "The mobility used with the kernel");
      50          94 :   params.addCoupledVar("coupled_variables",
      51             :                        "Vector of nonlinear variable arguments this kernel depends on");
      52          94 :   params.addRequiredParam<MaterialPropertyName>(
      53             :       "free_energy", "Base name of the free energy function F defined in a free energy material");
      54          94 :   params.addParam<MaterialPropertyName>("kappa", "kappa_op", "The kappa used with the kernel");
      55          94 :   params.addParam<bool>("variable_mobility",
      56          94 :                         true,
      57             :                         "The mobility is a function of any MOOSE variable (if "
      58             :                         "this is set to false, L must be constant over the "
      59             :                         "entire domain!)");
      60          94 :   params.addParam<std::vector<SubdomainName>>(
      61             :       "block", {}, "Block restriction for the variables and kernels");
      62          47 :   return params;
      63          47 : }
      64             : 
      65          47 : NonconservedAction::NonconservedAction(const InputParameters & params)
      66             :   : Action(params),
      67             :     _var_name(name()),
      68         141 :     _fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
      69          47 :              Utility::string_to_enum<libMesh::FEFamily>(getParam<MooseEnum>("family")))
      70             : {
      71          47 : }
      72             : 
      73             : void
      74          94 : NonconservedAction::act()
      75             : {
      76             :   //
      77             :   // Add variable
      78             :   //
      79          94 :   if (_current_task == "add_variable")
      80             :   {
      81          47 :     auto type = AddVariableAction::variableType(_fe_type);
      82          47 :     auto var_params = _factory.getValidParams(type);
      83             : 
      84          47 :     var_params.applySpecificParameters(_pars, {"family", "order", "block"});
      85         141 :     var_params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
      86             : 
      87             :     // Create nonconserved variable
      88          47 :     _problem->addVariable(type, _var_name, var_params);
      89          47 :   }
      90             : 
      91             :   //
      92             :   // Add Kernels
      93             :   //
      94          47 :   else if (_current_task == "add_kernel")
      95             :   {
      96             :     // Add time derivative kernel
      97          47 :     std::string kernel_type = "TimeDerivative";
      98             : 
      99          47 :     std::string kernel_name = _var_name + "_" + kernel_type;
     100          47 :     InputParameters params1 = _factory.getValidParams(kernel_type);
     101          94 :     params1.set<NonlinearVariableName>("variable") = _var_name;
     102          47 :     params1.applyParameters(parameters());
     103             : 
     104          47 :     _problem->addKernel(kernel_type, kernel_name, params1);
     105             : 
     106             :     // Add AllenCahn kernel
     107             :     kernel_type = "AllenCahn";
     108             : 
     109          47 :     kernel_name = _var_name + "_" + kernel_type;
     110          47 :     InputParameters params2 = _factory.getValidParams(kernel_type);
     111          47 :     params2.set<NonlinearVariableName>("variable") = _var_name;
     112         141 :     params2.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
     113         141 :     params2.set<MaterialPropertyName>("f_name") = getParam<MaterialPropertyName>("free_energy");
     114          47 :     params2.applyParameters(parameters());
     115             : 
     116          47 :     _problem->addKernel(kernel_type, kernel_name, params2);
     117             : 
     118             :     // Add ACInterface kernel
     119             :     kernel_type = "ACInterface";
     120             : 
     121          47 :     kernel_name = _var_name + "_" + kernel_type;
     122          47 :     InputParameters params3 = _factory.getValidParams(kernel_type);
     123          47 :     params3.set<NonlinearVariableName>("variable") = _var_name;
     124         141 :     params3.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
     125         141 :     params3.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
     126          94 :     params3.set<bool>("variable_L") = getParam<bool>("variable_mobility");
     127          47 :     params3.applyParameters(parameters());
     128             : 
     129          47 :     _problem->addKernel(kernel_type, kernel_name, params3);
     130          47 :   }
     131          94 : }