GrainGrowthAction.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "GrainGrowthAction.h"
 
// MOOSE includes
#include "AddVariableAction.h"
#include "Conversion.h"
#include "FEProblem.h"
#include "Factory.h"
#include "MooseObjectAction.h"
#include "MooseMesh.h"
#include "NonlinearSystemBase.h"
 
#include "libmesh/string_to_enum.h"
 
using namespace libMesh;
 
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "add_aux_variable");
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "add_aux_kernel");
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "add_variable");
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "add_kernel");
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "copy_nodal_vars");
registerMooseAction("PhaseFieldApp", GrainGrowthAction, "check_copy_nodal_vars");
 
InputParameters
GrainGrowthAction::validParams()
{
  InputParameters params = Action::validParams();
  params.addClassDescription(
      "Set up the variable and the kernels needed for a grain growth simulation");
  params.addRequiredParam<unsigned int>("op_num",
                                        "specifies the number of order parameters to create");
  params.addRequiredParam<std::string>("var_name_base", "specifies the base name of the variables");
  params.addParam<Real>(
      "scaling", 1.0, "Specifies a scaling factor to apply to the order parameters");
  params.addParam<bool>(
      "initial_from_file",
      false,
      "Take the initial condition of all polycrystal variables from the mesh file");
 
  // Get MooseEnums for the possible order/family options for this variable
  MooseEnum families(AddVariableAction::getNonlinearVariableFamilies());
  MooseEnum orders(AddVariableAction::getNonlinearVariableOrders());
  params.addParam<MooseEnum>("family",
                             families,
                             "Specifies the family of FE "
                             "shape function to use for the order parameters");
  params.addParam<MooseEnum>("order",
                             orders,
                             "Specifies the order of the FE "
                             "shape function to use for the order parameters");
 
  params.addParam<MaterialPropertyName>(
      "mobility", "L", "The isotropic mobility used with the kernels");
  params.addParam<MaterialPropertyName>("kappa", "kappa_op", "The kappa used with the kernels");
 
  params.addParam<VariableName>("c", "Name of coupled concentration variable");
 
  params.addParam<Real>("en_ratio", 1.0, "Ratio of surface to GB energy");
  params.addParam<unsigned int>("ndef", 0, "Specifies the number of deformed grains to create");
  params.addParam<bool>("variable_mobility",
                        true,
                        "The mobility is a function of any MOOSE variable (if "
                        "this is set to false, L must be constant over the "
                        "entire domain!)");
  params.addCoupledVar("coupled_variables",
                       "Vector of nonlinear variable arguments that L depends on");
 
  params.addParam<bool>("implicit", true, "Whether kernels are implicit or not");
  params.addParam<bool>(
      "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
  params.addParam<bool>("use_automatic_differentiation",
                        false,
                        "Flag to use automatic differentiation (AD) objects when possible");
  params.addParam<std::vector<SubdomainName>>(
      "block", {}, "Block restriction for the variables and kernels");
 
  params.addParamNamesToGroup("scaling implicit use_displaced_mesh", "Advanced");
  params.addParamNamesToGroup("c en_ratio ndef", "Multiphysics");
 
  return params;
}
 
GrainGrowthAction::GrainGrowthAction(const InputParameters & params)
  : Action(params),
    _op_num(getParam<unsigned int>("op_num")),
    _var_name_base(getParam<std::string>("var_name_base")),
    _fe_type(Utility::string_to_enum<Order>(getParam<MooseEnum>("order")),
             Utility::string_to_enum<FEFamily>(getParam<MooseEnum>("family"))),
    _initial_from_file(getParam<bool>("initial_from_file")),
    _use_ad(getParam<bool>("use_automatic_differentiation"))
{
}
 
void
GrainGrowthAction::act()
{
  // Add Variables
  addVariables();
 
  // Add Kernels
  for (unsigned int op = 0; op < _op_num; op++)
  {
    // Create variable name
    std::string var_name = _var_name_base + Moose::stringify(op);
 
    // Add the kernels for each grain growth variable
    if (_current_task == "add_kernel")
    {
      //
      // Add time derivative kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADTimeDerivative" : "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 ACGrGrPoly kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADGrainGrowth" : "ACGrGrPoly";
 
        // Make vector of order parameter names, excluding this one
        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);
 
        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") = v;
        params.set<MaterialPropertyName>("mob_name") = getParam<MaterialPropertyName>("mobility");
        params.applyParameters(parameters());
 
        _problem->addKernel(kernel_type, kernel_name, params);
      }
 
      //
      // Add ACInterface kernel
      //
 
      {
        std::string kernel_type = _use_ad ? "ADACInterface" : "ACInterface";
 
        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.set<bool>("variable_L") = getParam<bool>("variable_mobility");
        params.applyParameters(parameters());
 
        _problem->addKernel(kernel_type, kernel_name, params);
      }
 
      //
      // Set up optional ACGBPoly bubble interaction kernels
      //
 
      if (isParamValid("c"))
      {
        if (_use_ad)
          mooseError("AD version of ACGBPoly is not implemented");
 
        std::string kernel_type = "ACGBPoly";
 
        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>>("c") = {getParam<VariableName>("c")};
        params.applyParameters(parameters());
 
        _problem->addKernel(kernel_type, kernel_name, params);
      }
    }
  }
 
  // Add AuxVriable and AuxKernel for Bnds variable
  addBnds(_var_name_base);
}
 
void
GrainGrowthAction::addVariables()
{
  for (unsigned int op = 0; op < _op_num; op++)
  {
    // Create variable name
    std::string var_name = _var_name_base + Moose::stringify(op);
 
    // Setup initial from file if requested
    if (_initial_from_file)
    {
      if (_current_task == "check_copy_nodal_vars")
        _app.setExodusFileRestart(true);
 
      if (_current_task == "copy_nodal_vars")
      {
        auto * system = &_problem->getNonlinearSystemBase(/*nl_sys_num=*/0);
        system->addVariableToCopy(var_name, var_name, "LATEST");
      }
    }
 
    // Add each grain growth variable
    if (_current_task == "add_variable")
    {
      auto type = AddVariableAction::variableType(_fe_type);
      auto var_params = _factory.getValidParams(type);
 
      var_params.applySpecificParameters(_pars, {"family", "order", "block"});
      var_params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
 
      // Add variable
      _problem->addVariable(type, var_name, var_params);
    }
  }
}
 
void
GrainGrowthAction::addBnds(const std::string & name_base)
{
  // Create auxvariable
  if (_current_task == "add_aux_variable")
  {
    auto var_params = _factory.getValidParams("MooseVariable");
    var_params.set<MooseEnum>("family") = "LAGRANGE";
    var_params.set<MooseEnum>("order") = "FIRST";
    var_params.applySpecificParameters(_pars, {"block"});
    _problem->addAuxVariable("MooseVariable", "bnds", var_params);
  }
  // Create auxkernel
  else if (_current_task == "add_aux_kernel")
  {
    // Make vector of order parameter names, excluding this one std::vector<VariableName> v;
    std::vector<VariableName> v;
    v.resize(_op_num);
 
    for (unsigned int j = 0; j < _op_num; ++j)
      v[j] = name_base + Moose::stringify(j);
 
    std::string aux_kernel_type = "BndsCalcAux";
 
    std::string aux_kernel_name = "bnds_" + aux_kernel_type;
    InputParameters params = _factory.getValidParams(aux_kernel_type);
    params.set<AuxVariableName>("variable") = "bnds";
    params.set<std::vector<VariableName>>("v") = v;
    params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
    params.applyParameters(parameters());
 
    _problem->addAuxKernel(aux_kernel_type, aux_kernel_name, params);
  }
}