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          71 : NonconservedAction::validParams()
      29             : {
      30          71 :   InputParameters params = Action::validParams();
      31          71 :   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          71 :   MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
      35          71 :   MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
      36         142 :   params.addParam<MooseEnum>("family",
      37             :                              families,
      38             :                              "Specifies the family of FE "
      39             :                              "shape functions to use for this variable");
      40         142 :   params.addParam<MooseEnum>("order",
      41             :                              orders,
      42             :                              "Specifies the order of the FE "
      43             :                              "shape function to use for this variable");
      44         142 :   params.addParam<Real>("scaling", 1.0, "Specifies a scaling factor to apply to this variable");
      45         142 :   params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
      46         142 :   params.addParam<bool>(
      47         142 :       "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
      48         142 :   params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
      49         142 :   params.addParam<MaterialPropertyName>("mobility", "L", "The mobility used with the kernel");
      50         142 :   params.addCoupledVar("args", "Vector of nonlinear variable arguments this kernel depends on");
      51         142 :   params.deprecateCoupledVar("args", "coupled_variables", "02/27/2024");
      52         142 :   params.addRequiredParam<MaterialPropertyName>(
      53             :       "free_energy", "Base name of the free energy function F defined in a free energy material");
      54         142 :   params.addParam<MaterialPropertyName>("kappa", "kappa_op", "The kappa used with the kernel");
      55         142 :   params.addParam<bool>("variable_mobility",
      56         142 :                         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         142 :   params.addParam<std::vector<SubdomainName>>(
      61             :       "block", {}, "Block restriction for the variables and kernels");
      62          71 :   return params;
      63          71 : }
      64             : 
      65          71 : NonconservedAction::NonconservedAction(const InputParameters & params)
      66             :   : Action(params),
      67             :     _var_name(name()),
      68         213 :     _fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
      69          71 :              Utility::string_to_enum<libMesh::FEFamily>(getParam<MooseEnum>("family")))
      70             : {
      71          71 : }
      72             : 
      73             : void
      74         142 : NonconservedAction::act()
      75             : {
      76             :   //
      77             :   // Add variable
      78             :   //
      79         142 :   if (_current_task == "add_variable")
      80             :   {
      81          71 :     auto type = AddVariableAction::variableType(_fe_type);
      82          71 :     auto var_params = _factory.getValidParams(type);
      83             : 
      84          71 :     var_params.applySpecificParameters(_pars, {"family", "order", "block"});
      85         213 :     var_params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
      86             : 
      87             :     // Create nonconserved variable
      88          71 :     _problem->addVariable(type, _var_name, var_params);
      89          71 :   }
      90             : 
      91             :   //
      92             :   // Add Kernels
      93             :   //
      94          71 :   else if (_current_task == "add_kernel")
      95             :   {
      96             :     // Add time derivative kernel
      97          71 :     std::string kernel_type = "TimeDerivative";
      98             : 
      99          71 :     std::string kernel_name = _var_name + "_" + kernel_type;
     100          71 :     InputParameters params1 = _factory.getValidParams(kernel_type);
     101         142 :     params1.set<NonlinearVariableName>("variable") = _var_name;
     102          71 :     params1.applyParameters(parameters());
     103             : 
     104          71 :     _problem->addKernel(kernel_type, kernel_name, params1);
     105             : 
     106             :     // Add AllenCahn kernel
     107             :     kernel_type = "AllenCahn";
     108             : 
     109          71 :     kernel_name = _var_name + "_" + kernel_type;
     110          71 :     InputParameters params2 = _factory.getValidParams(kernel_type);
     111          71 :     params2.set<NonlinearVariableName>("variable") = _var_name;
     112         213 :     params2.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
     113         213 :     params2.set<MaterialPropertyName>("f_name") = getParam<MaterialPropertyName>("free_energy");
     114          71 :     params2.applyParameters(parameters());
     115             : 
     116          71 :     _problem->addKernel(kernel_type, kernel_name, params2);
     117             : 
     118             :     // Add ACInterface kernel
     119             :     kernel_type = "ACInterface";
     120             : 
     121          71 :     kernel_name = _var_name + "_" + kernel_type;
     122          71 :     InputParameters params3 = _factory.getValidParams(kernel_type);
     123          71 :     params3.set<NonlinearVariableName>("variable") = _var_name;
     124         213 :     params3.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
     125         213 :     params3.set<MaterialPropertyName>("kappa_name") = getParam<MaterialPropertyName>("kappa");
     126         142 :     params3.set<bool>("variable_L") = getParam<bool>("variable_mobility");
     127          71 :     params3.applyParameters(parameters());
     128             : 
     129          71 :     _problem->addKernel(kernel_type, kernel_name, params3);
     130          71 :   }
     131         142 : }