23 #include "libmesh/libmesh.h" 24 #include "libmesh/exodusII_io.h" 25 #include "libmesh/equation_systems.h" 26 #include "libmesh/nonlinear_implicit_system.h" 27 #include "libmesh/explicit_system.h" 28 #include "libmesh/string_to_enum.h" 36 params.addClassDescription(
"Add a non-linear variable to the simulation.");
40 params.set<std::string>(
"type") =
"MooseVariableBase";
46 "family", families,
"Specifies the family of FE shape functions to use for this variable");
49 "Specifies the order of the FE shape function to use " 50 "for this variable (additional orders not listed are " 52 params.addParam<std::vector<Real>>(
"scaling",
53 "Specifies a scaling factor to apply to this variable");
54 params.addParam<std::vector<Real>>(
"initial_condition",
55 "Specifies a constant initial condition for this variable");
61 _fe_type(feType(params)),
62 _scalar_var(_fe_type.family ==
SCALAR),
71 return MooseEnum(
"LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN " 72 "L2_LAGRANGE L2_HIERARCHIC NEDELEC_ONE LAGRANGE_VEC MONOMIAL_VEC " 73 "RAVIART_THOMAS RATIONAL_BERNSTEIN SIDE_HIERARCHIC",
80 return MooseEnum(
"CONSTANT FIRST SECOND THIRD FOURTH",
"FIRST",
true);
86 return {Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order")),
87 Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"))};
95 mooseError(
"There must be at least one variable component, but somehow 0 has been specified");
108 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 109 "`family` parameter set, and they are different values: ",
113 " respectively. I don't know how you achieved this, but you need to rectify it.");
117 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 118 "`order` parameter set, and they are different values: ",
122 " respectively. I don't know how you achieved this, but you need to rectify it.");
125 _pars.
get<std::vector<Real>>(
"scaling") !=
127 mooseError(
"Both the MooseVariable* and Add*VariableAction parameters objects have had the " 128 "`scaling` parameter set, and they are different values. I don't know how you " 129 "achieved this, but you need to rectify it.");
136 if (
_type ==
"MooseVariableBase")
153 std::string var_name =
name();
165 std::string var_name =
name();
167 auto value =
_pars.
get<std::vector<Real>>(
"initial_condition");
170 std::string long_name(
"");
171 long_name += var_name;
172 long_name +=
"_moose";
185 action_params.
set<std::string>(
"type") =
"ScalarConstantIC";
189 action_params.
set<std::string>(
"type") =
"VectorConstantIC";
193 action_params.
set<std::string>(
"type") =
"FVConstantIC";
195 action_params.
set<std::string>(
"type") =
"ConstantIC";
200 action_params.
set<std::string>(
"type") =
"ArrayConstantIC";
202 mooseError(
"Size of 'initial_condition' is not consistent");
206 std::shared_ptr<MooseObjectAction> action;
225 action->getObjectParams().set<
Real>(
"x_value") =
value[0];
226 if (
value.size() > 0)
227 action->getObjectParams().set<
Real>(
"y_value") =
value[1];
228 if (
value.size() > 1)
229 action->getObjectParams().set<
Real>(
"z_value") =
value[2];
232 action->getObjectParams().set<
Real>(
"value") =
value[0];
242 "AddVariableAction::variableType() instead.");
250 return "MooseVariableFVReal";
256 ::mooseError(
"Vector finite element families do not currently have ArrayVariable support");
258 return "ArrayMooseVariable";
260 else if (fe_type == FEType(0,
MONOMIAL))
261 return "MooseVariableConstMonomial";
262 else if (fe_type.family ==
SCALAR)
263 return "MooseVariableScalar";
266 return "VectorMooseVariable";
268 return "MooseVariable";
279 mooseError(
"Size of 'scaling' is not consistent");
295 std::set<SubdomainID>
299 std::set<SubdomainID> blocks;
300 std::vector<SubdomainName> block_param =
302 for (
const auto & subdomain_name : block_param)
305 blocks.insert(blk_id);
static InputParameters validParams()
Class constructor.
std::set< SubdomainID > getSubdomainIDs()
Get the block ids from the input parameters.
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
static std::string variableType(const FEType &fe_type, const bool is_fv=false, const bool is_array=false)
Determines a variable type.
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
InputParameters getValidParams(const std::string &name)
static InputParameters validParams()
FEType _fe_type
FEType for the variable being created.
Storage for action instances.
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
registerMooseAction("MooseApp", AddVariableAction, "add_variable")
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 _fv_var
True if the variable being created is finite volume.
InputParameters & getObjectParams()
Retreive 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)
static std::string determineType(const FEType &fe_type, unsigned int components, bool is_fv=false)
DEPRECATED: Use variableType instead.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
virtual void markEigenVariable(const VariableName &var_name)
Mark a variable as a variable of the eigen system.
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.
static 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)
void createInitialConditionAction()
Create the action to generate the InitialCondition object.
std::function< void(FEProblemBase &, const std::string &, const std::string &, InputParameters &)> _problem_add_var_method