20 #include "libmesh/string_to_enum.h" 21 #include "libmesh/fe_interface.h" 31 params.addClassDescription(
"Add a non-linear variable to the simulation.");
35 params.set<std::string>(
"type") =
"MooseVariableBase";
41 "family", families,
"Specifies the family of FE shape functions to use for this variable");
44 "Specifies the order of the FE shape function to use " 45 "for this variable (additional orders not listed are " 47 params.addParam<std::vector<Real>>(
"scaling",
48 "Specifies a scaling factor to apply to this variable");
49 params.addParam<std::vector<Real>>(
"initial_condition",
50 "Specifies a constant initial condition for this variable");
57 _fe_type(feType(params)),
58 _scalar_var(_fe_type.family ==
SCALAR),
67 return MooseEnum(
"LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN " 68 "L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC " 69 "RAVIART_THOMAS RATIONAL_BERNSTEIN SIDE_HIERARCHIC L2_HIERARCHIC_VEC " 70 "L2_LAGRANGE_VEC L2_RAVIART_THOMAS",
77 return MooseEnum(
"CONSTANT FIRST SECOND THIRD FOURTH",
"FIRST",
true);
83 return {Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order")),
84 Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"))};
92 mooseError(
"There must be at least one variable component, but somehow 0 has been specified");
105 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 106 "`family` parameter set, and they are different values: ",
109 getParam<MooseEnum>(
"family"),
110 " respectively. I don't know how you achieved this, but you need to rectify it.");
114 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 115 "`order` parameter set, and they are different values: ",
118 getParam<MooseEnum>(
"order"),
119 " respectively. I don't know how you achieved this, but you need to rectify it.");
122 getParam<std::vector<Real>>(
"scaling") !=
124 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 125 "`scaling` parameter set, and they are different values. I don't know how you " 126 "achieved this, but you need to rectify it.");
130 "Two initial conditions have been provided for the variable ",
132 " using the 'initial_condition' and 'initial_from_file_var' parameters. Please " 133 "remove one of them.");
140 if (
_type ==
"MooseVariableBase")
157 const auto var_name =
varName();
163 const auto &
value = getParam<std::vector<Real>>(
"initial_condition");
172 const auto var_name =
varName();
175 std::string long_name(
"");
176 long_name += var_name;
177 long_name +=
"_moose";
186 const auto fe_field_type = FEInterface::field_type(
_fe_type);
187 const bool is_vector = fe_field_type ==
TYPE_VECTOR;
190 action_params.
set<std::string>(
"type") =
"ScalarConstantIC";
194 action_params.
set<std::string>(
"type") =
"VectorConstantIC";
198 action_params.
set<std::string>(
"type") =
"FVConstantIC";
200 action_params.
set<std::string>(
"type") =
"ConstantIC";
205 action_params.
set<std::string>(
"type") =
"ArrayConstantIC";
207 mooseError(
"Size of 'initial_condition' is not consistent");
211 std::shared_ptr<MooseObjectAction> action;
230 action->getObjectParams().set<
Real>(
"x_value") =
value[0];
231 if (
value.size() > 0)
232 action->getObjectParams().set<
Real>(
"y_value") =
value[1];
233 if (
value.size() > 1)
234 action->getObjectParams().set<
Real>(
"z_value") =
value[2];
237 action->getObjectParams().set<
Real>(
"value") =
value[0];
247 "AddVariableAction::variableType() instead.");
255 return "MooseVariableFVReal";
257 const auto fe_field_type = FEInterface::field_type(fe_type);
262 ::mooseError(
"Vector finite element families do not currently have ArrayVariable support");
264 return "ArrayMooseVariable";
267 return "MooseVariableConstMonomial";
269 return "MooseVariableScalar";
271 return "VectorMooseVariable";
273 return "MooseVariable";
284 mooseError(
"Size of 'scaling' is not consistent");
300 std::set<SubdomainID>
304 std::set<SubdomainID>
blocks;
305 std::vector<SubdomainName> block_param =
307 for (
const auto & subdomain_name : block_param)
static InputParameters validParams()
std::set< SubdomainID > getSubdomainIDs()
Get the block ids from the input parameters.
virtual std::string varName() const
Return the name of the nonlinear variable to be created.
bool _scalar_var
True if the variable being created is a scalar.
virtual void act() override
Method to add objects to the simulation or perform other setup tasks.
void mooseDeprecated(Args &&... args) const
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
InputParameters getValidParams(const std::string &name)
static InputParameters validParams()
Storage for action instances.
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
static InputParameters validParams()
registerMooseAction("MooseApp", AddVariableAction, "add_variable")
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual const std::string & name() const
Get the name of the class.
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters ¶meters)
static MooseEnum getNonlinearVariableFamilies()
Get the possible variable families.
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
libMesh::FEType _fe_type
FEType for the variable being created.
bool _fv_var
True if the variable being created is finite volume.
InputParameters & getObjectParams()
Retrieve the parameters of the object to be created by this action.
static MooseEnum getNonlinearVariableOrders()
Get the possible variable orders.
unsigned int _components
Number of components for an array variable.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
void createInitialConditionAction(const std::vector< Real > &value)
Create the action to generate the InitialCondition object.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
Determines a variable type.
virtual void markEigenVariable(const VariableName &var_name)
Mark a variable as a variable of the eigen system.
void paramError(const std::string ¶m, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
ActionFactory & _action_factory
Builds Actions.
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶ms)
Canonical method for adding a non-linear variable.
bool isParamSetByUser(const std::string &nm) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
static libMesh::FEType feType(const InputParameters ¶ms)
determine the FEType by examining family and order in the provided parameters
std::string _type
The Object type that is being created.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters _moose_object_pars
The parameters for the object to be created.
virtual void init()
Initialize the action's member variables.
void associateWithParameter(const std::string ¶m_name, InputParameters ¶ms) const
Associates the object's parameters params with the input location from this Action's parameter with t...
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
void addVariable(const std::string &var_name)
Adds a nonlinear variable to the system.
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
AddVariableAction(const InputParameters ¶ms)
static std::string determineType(const libMesh::FEType &fe_type, unsigned int components, bool is_fv=false)
DEPRECATED: Use variableType instead.
std::function< void(FEProblemBase &, const std::string &, const std::string &, InputParameters &)> _problem_add_var_method