10#ifdef MOOSE_MFEM_ENABLED
29#include "libmesh/string_to_enum.h"
41std::vector<MFEMSolverName>
44 std::vector<MFEMSolverName> dependencies;
46 for (
const auto & [param_name, _] : parameters)
51 if (
auto * name = parameters.
queryParam<MFEMSolverName>(param_name))
52 dependencies.push_back(*name);
53 else if (
auto * names = parameters.
queryParam<std::vector<MFEMSolverName>>(param_name))
54 dependencies.insert(dependencies.end(), names->begin(), names->end());
65 params.
addClassDescription(
"Problem type for building and solving the finite element problem "
66 "using the MFEM finite element library.");
67 MooseEnum numeric_types(
"real complex",
"real");
68 params.
addParam<
MooseEnum>(
"numeric_type", numeric_types,
"Number type used for the problem");
75 _num_type{static_cast<
int>(getParam<
MooseEnum>(
"numeric_type"))},
76 _solution_state_data(declareRestartableDataWithContext<
Moose::MFEM::SolutionState>(
77 "mfem_solution_state", &_problem_data))
89 std::vector<MFEMExecutedObject *> objects;
93 .condition<AttribThread>(0)
95 for (
auto *
const object : objects)
96 object->initialSetup();
120 const std::string & name,
123 auto estimator = addObject<MFEMIndicator>(indicator_type,
name,
parameters).front();
126 estimator->createEstimator();
131 const std::string & name,
139 const std::string & name,
156 const auto dependencies = getMFEMSolverDependencies(*definition.parameters);
157 if (dependencies.empty())
160 for (
const auto & dependency_name : dependencies)
166 "' references MFEM solver '",
168 "', but no solver with that name was provided in the [Solvers] block.");
170 dependency_it->second.referenced =
true;
171 resolver.
addEdge(dependency_name, solver_name);
175 const std::vector<std::string> * sorted_solver_names =
nullptr;
182 mooseError(
"Cyclic MFEM solver dependency detected: ",
187 mooseAssert(!problem_data.jacobian_solver,
"MFEM linear solver driver already assigned");
188 mooseAssert(!problem_data.nonlinear_solver,
"MFEM nonlinear solver driver already assigned");
190 for (
const auto & solver_name : *sorted_solver_names)
194 addObject<Moose::MFEM::SolverBase>(definition.type, solver_name, *definition.parameters)
197 if (definition.referenced)
200 if (
auto linear_solver = std::dynamic_pointer_cast<Moose::MFEM::LinearSolverBase>(solver))
202 if (problem_data.jacobian_solver)
203 mooseError(
"Multiple MFEM linear solver drivers provided. '",
204 problem_data.jacobian_solver->name(),
206 linear_solver->name(),
207 "' are not referenced by another MFEM solver.");
208 problem_data.jacobian_solver = linear_solver;
210 else if (
auto nonlinear_solver =
211 std::dynamic_pointer_cast<Moose::MFEM::NonlinearSolverBase>(solver))
213 if (problem_data.nonlinear_solver)
214 mooseError(
"Multiple MFEM nonlinear solver drivers provided. '",
215 problem_data.nonlinear_solver->name(),
217 nonlinear_solver->name(),
218 "' are not referenced by another MFEM solver.");
219 problem_data.nonlinear_solver = nonlinear_solver;
222 mooseError(
"Unsupported MFEM solver object type '",
234 const std::string & name,
237 auto bc = addObject<MFEMBoundaryCondition>(bc_name,
name,
parameters).front();
245 "MFEM materials must be added through the 'FunctorMaterials' block and not 'Materials'");
250 const std::string & name,
258 const std::string & name,
264 "': an MFEMFESpaceHierarchy with the same name already exists. "
265 "FESpaces and FESpaceHierarchies share the fespaces namespace.");
276 const std::string & name,
280 mooseError(
"Cannot add MFEMFESpaceHierarchy '",
282 "': a FESpace with the same name already exists. "
283 "FESpaces and FESpaceHierarchies share the fespaces namespace.");
286 auto hierarchy_shared = hierarchy_obj->getHierarchyShared();
292 auto finest = std::shared_ptr<mfem::ParFiniteElementSpace>(
293 hierarchy_shared, &hierarchy_obj->getHierarchy().GetFinestFESpace());
299 const std::string & var_name)
const
301 const bool variable_is_complex = var_type ==
"MFEMComplexVariable";
303 if (variable_is_complex != problem_is_complex)
305 "The problem numeric type does not match primary MFEM variable '",
308 variable_is_complex ?
"complex." :
"real.");
313 const std::string & var_name,
323 const auto time_derivative_var_name =
324 getMFEMObject<MFEMVariable>(
"MooseVariableBase", var_name).getTimeDerivativeName();
326 time_derivative_var_name);
333 const std::string & var_name,
337 if (var_type ==
"MFEMVariable" || var_type ==
"MFEMComplexVariable")
340 if (var_type ==
"MFEMComplexVariable")
341 addObject<MFEMComplexVariable>(var_type, var_name,
parameters);
343 addObject<MFEMVariable>(var_type, var_name,
parameters);
352 addObject<MFEMVariable>(
"MFEMVariable", var_name, mfem_variable_params);
356 if (var_type ==
"MFEMComplexVariable")
359 getMFEMObject<MFEMComplexVariable>(
"MooseVariableBase", var_name);
365 MFEMVariable & mfem_variable = getMFEMObject<MFEMVariable>(
"MooseVariableBase", var_name);
373 const std::string & var_name,
383 const std::string & name,
391 const std::string & name,
394 auto kernel = addObject<MFEMKernel>(kernel_name,
name,
parameters).front();
400 const std::string & name,
403 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
405 parameters.
set<VariableName>(
"variable") = parent_ptr->getParam<VariableName>(
"variable");
406 auto kernel_ptr = addObject<MFEMKernel>(kernel_name,
name +
"_real",
parameters).front();
407 parent_ptr->setRealKernel(kernel_ptr);
412 const std::string & name,
415 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
417 parameters.
set<VariableName>(
"variable") = parent_ptr->getParam<VariableName>(
"variable");
418 auto kernel_ptr = addObject<MFEMKernel>(kernel_name,
name +
"_imag",
parameters).front();
419 parent_ptr->setImagKernel(kernel_ptr);
424 const std::string & name,
427 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexIntegratedBC>(
428 getMFEMObject<MFEMComplexIntegratedBC>(
"BoundaryCondition",
name).
getSharedPtr());
429 parameters.
set<VariableName>(
"variable") = parent_ptr->getParam<VariableName>(
"variable");
431 parent_ptr->getParam<std::vector<BoundaryName>>(
"boundary");
432 auto bc_ptr = std::dynamic_pointer_cast<MFEMIntegratedBC>(
433 addObject<MFEMBoundaryCondition>(kernel_name,
name +
"_real",
parameters).front());
434 parent_ptr->setRealBC(bc_ptr);
439 const std::string & name,
442 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexIntegratedBC>(
443 getMFEMObject<MFEMComplexIntegratedBC>(
"BoundaryCondition",
name).
getSharedPtr());
444 parameters.
set<VariableName>(
"variable") = parent_ptr->getParam<VariableName>(
"variable");
446 parent_ptr->getParam<std::vector<BoundaryName>>(
"boundary");
447 auto bc_ptr = std::dynamic_pointer_cast<MFEMIntegratedBC>(
448 addObject<MFEMBoundaryCondition>(kernel_name,
name +
"_imag",
parameters).front());
449 parent_ptr->setImagBC(bc_ptr);
454 const std::string & name,
460std::shared_ptr<MFEMWeakFormBase>
463 const std::string
name(
"__DefaultWeakForm");
466 type =
"MFEMTimeDependentWeakForm";
468 type =
"MFEMWeakForm";
470 type =
"MFEMComplexWeakForm";
473 "Please set the Problem numeric type to either 'real' or 'complex'.");
482 std::vector<MFEMWeakFormBase *> weak_forms;
486 if (weak_forms.empty())
489 for (
auto & weak_form : weak_forms)
493std::shared_ptr<Moose::MFEM::EquationSystem>
498 if (!weak_form_name.empty())
499 return eqn_systems.
GetShared(weak_form_name);
501 mooseAssert(eqn_systems.size() != 0,
"No equation systems have been built for this problem");
503 if (eqn_systems.size() > 1)
506 " equation systems, so the one to use cannot be inferred. Set the 'weak_form' "
507 "parameter to name the weak form whose equation system should be used.");
509 return eqn_systems.begin()->second;
514 const std::string & name,
520std::shared_ptr<MFEMProblemComposer>
523 const std::string
name =
"__DefaultWeakFormProblemComposer";
526 type =
"MFEMTimeDependentWeakFormProblemComposer";
528 type =
"MFEMWeakFormProblemComposer";
530 type =
"MFEMComplexWeakFormProblemComposer";
533 "Please set the Problem numeric type to either 'real' or 'complex'.");
536 return addObject<MFEMProblemComposer>(
type,
name, params).front();
542 std::vector<MFEMProblemComposer *> problem_composers;
546 .queryInto(problem_composers);
549 if (problem_composers.empty())
552 for (
auto & problem_composer : problem_composers)
556 problem_operator->Init();
559std::vector<std::shared_ptr<Moose::MFEM::ProblemOperatorBase>> &
570 if (parameters.
isParamSetByUser(
"expression_y") || type ==
"LevelSetOlssonVortex")
578const std::vector<std::string>
SCALAR_FUNCS = {
"Axisymmetric2D3DSolutionFunction",
579 "BicubicSplineFunction",
580 "CoarsenedPiecewiseLinear",
585 "ParsedGradFunction",
589 "PiecewiseConstantFromCSV",
591 "PiecewiseLinearFromVectorPostprocessor",
592 "PiecewiseMultiInterpolation",
593 "PiecewiseMulticonstant",
597 "LevelSetOlssonBubble",
598 "LevelSetOlssonPlane",
599 "NearestReporterCoordinatesFunction",
600 "ParameterMeshFunction",
601 "ParsedOptimizationFunction",
604 "MultiControlDrumFunction",
605 "Grad2ParsedFunction",
606 "GradParsedFunction",
607 "ScaledAbsDifferenceDRLRewardFunction",
608 "CircularAreaHydraulicDiameterFunction",
609 "CosineHumpFunction",
610 "CosineTransitionFunction",
611 "CubicTransitionFunction",
612 "GeneralizedCircumference",
617 "MFEMCoordinateTransformations",
618 "MFEMScalarQuadratureFunction",
619 "MFEMVectorQuadratureFunction"};
623 const std::string & name,
628 parallel_object_only();
644 [&func](
const mfem::Vector & p, mfem::real_t t) -> mfem::real_t
653 [&func,
dim](
const mfem::Vector & p, mfem::real_t t, mfem::Vector & u)
657 for (
int i = 0; i <
dim; i++)
659 u[i] = vector_value(i);
667 mooseWarning(
"Could not identify function ",
type,
"; no MFEM coefficient object created.");
672 const std::string & name,
688 name, [&val](
const mfem::Vector &) -> mfem::real_t {
return val; });
693 const std::string & name,
721 case FEFamily::LAGRANGE:
724 case FEFamily::NEDELEC_ONE:
727 case FEFamily::RAVIART_THOMAS:
731 case FEFamily::MONOMIAL:
732 case FEFamily::L2_LAGRANGE:
735 case FEFamily::LAGRANGE_VEC:
739 case FEFamily::MONOMIAL_VEC:
740 case FEFamily::L2_LAGRANGE_VEC:
745 mooseError(
"Unable to set MFEM FESpace for MOOSE variable");
752 const auto fec_name = space +
"_" + std::to_string(
dim) +
"D_P" + std::to_string(order);
753 const auto fes_name = fec_name +
"_X" + std::to_string(vdim);
756 fespace_params.
set<std::string>(
"fec_name") = fec_name;
757 fespace_params.
set<
int>(
"vdim") = vdim;
760 addFESpace(
"MFEMGenericFESpace", fes_name, fespace_params);
762 variable_params.
set<MFEMFESpaceName>(
"fespace") = fes_name;
764 return variable_params;
771 if (
mesh().shouldDisplace())
778const mfem::ParGridFunction &
787 if (pmesh.Nonconforming())
799 fe_space_pair.second->Update();
806 gridfunction_pair.second->Update();
809std::vector<VariableName>
819 mooseAssert(mfem_mesh,
820 "The mesh for an MFEMProblem must be MFEMFileMesh or MFEMMeshGeneratorMesh.");
832 const std::string & var_name,
835 auto & mfem_submesh = *addObject<MFEMSubMesh>(var_type, var_name,
parameters).front();
842 const std::string & name,
853 const std::string & name,
862 std::vector<MFEMExecutedObject *> objects;
866 .condition<AttribExecOns>(exec_type)
870 std::map<std::string, const MFEMExecutedObject *> suppliers;
871 for (
auto *
const object : objects)
872 for (
const auto & item :
object->getSuppliedItems())
874 const auto [it, inserted] = suppliers.emplace(item,
object);
875 if (!inserted && it->second !=
object)
876 mooseError(
"MFEM executed-object dependency ambiguity on ",
887 for (
auto *
const object : objects)
889 object->initialize();
893 if (
auto *
const pp =
dynamic_cast<const Postprocessor *
>(
object))
907 mooseAssert(solver_sys_num == 0,
"All mfem systems must use the same solver right now.");
909 std::vector<std::string> solvers;
917 if (
const std::string * pc = js->queryParam<MFEMSolverName>(
"preconditioner"))
919 &getMFEMObject<Moose::MFEM::LinearSolverBase>(
"Moose::MFEM::SolverBase", *pc)));
928 std::vector<MooseObject *> objs;
932 .condition<AttribThread>(0)
935 return !objs.empty();
const std::vector< std::string > SCALAR_FUNCS
int vectorFunctionDim(const std::string &type, const InputParameters ¶meters)
const std::vector< std::string > MFEM_FUNCS
registerMooseObject("MooseApp", MFEMProblem)
const std::vector< std::string > VECTOR_FUNCS
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Real PostprocessorValue
various MOOSE typedefs
void ErrorVector unsigned int
const std::vector< T > & getCyclicDependencies() const
Class that represents the dependecy as a graph.
void addNode(const T &a)
Add a node 'a' to the graph.
const std::vector< T > & getSortedValues()
This function also returns dependency resolved values but with a simpler single vector interface.
void addEdge(const T &a, const T &b)
Add an edge between nodes 'a' and 'b'.
static InputParameters validParams()
ReporterData _reporter_data
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName &name, std::size_t t_index=0) const
Get a read-only reference to the value associated with a Postprocessor that exists.
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶ms)
Canonical method for adding a non-linear variable.
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters ¶meters)
Add a Transfer to the problem.
void checkUserObjectNameCollision(const std::string &name, const std::string &type) const
Check for name collision between different user objects.
virtual void addVectorPostprocessor(const std::string &pp_name, const std::string &name, InputParameters ¶meters)
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters ¶meters)
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters ¶ms) const
Output information about the object just added to the problem.
void setPostprocessorValueByName(const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
Set the value of a PostprocessorValue.
void setCurrentExecuteOnFlag(const ExecFlagType &)
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
TheWarehouse & theWarehouse() const
virtual bool isTransient() const override
virtual Function & getFunction(const std::string &name, const THREAD_ID tid=0)
MooseObjectWarehouse< Function > _functions
functions
void initialSetup() override
std::shared_ptr< MooseObject > create(const std::string &obj_name, const std::string &name, const InputParameters ¶meters, THREAD_ID tid=0, bool print_deprecated=true)
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Base class for function objects.
Constructs and stores an mfem::ParComplexGridFunction object.
void declareCoefficients()
std::shared_ptr< mfem::ParComplexGridFunction > getComplexGridFunction() const
Returns a shared pointer to the constructed gridfunction.
Abstract MooseMesh base for all MFEM-backed mesh types (MFEMFileMesh, MFEMMeshGeneratorMesh).
unsigned int dimension() const override
Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh me...
std::shared_ptr< mfem::ParMesh > getMFEMParMeshPtr()
Copy a shared_ptr to the mfem::ParMesh object.
void displace(mfem::GridFunction const &displacement)
Displace the nodes of the mesh by the given displacement.
virtual std::vector< VariableName > getAuxVariableNames()
Returns all the variable names from the auxiliary system base.
std::shared_ptr< MFEMProblemComposer > _problem_composer
The problem operator builders for this mfem problem.
void addPostprocessor(const std::string &type, const std::string &name, InputParameters ¶meters) override
Override of ExternalProblem::addPostprocessor.
virtual MFEMMesh & mesh() override
Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMes...
void addWeakForm(const std::string &weak_form_name, const std::string &name, InputParameters ¶meters)
Add an MFEM WeakForm to the problem.
void addFESpace(const std::string &type, const std::string &name, InputParameters ¶meters)
Add an MFEM FESpace to the problem.
void addMarker(const std::string &type, const std::string &name, InputParameters ¶meters) override
Override of FEProblemBase::addMarker.
void addFESpaceHierarchy(const std::string &type, const std::string &name, InputParameters ¶meters)
Add an MFEMFESpaceHierarchy to the problem.
void setProblemOperators()
Set all MFEM ProblemOperators to solve in this problem.
virtual void addMFEMSolver(const std::string &user_object_name, const std::string &name, InputParameters ¶meters)
Method called in AddMFEMSolverAction which records a solver for later dependency-ordered construction...
Moose::MFEM::CoefficientManager & getCoefficients()
Method to get the PropertyManager object for storing material properties and converting them to MFEM ...
std::string solverTypeString(unsigned int solver_sys_num) override
Return solver type as a human readable string.
std::vector< std::shared_ptr< Moose::MFEM::ProblemOperatorBase > > _problem_operators
Vector of MFEM problem operators executed in this problem.
bool hasMFEMObject(const std::string &system, const std::string &name) const
Determine whether an MFEM object with the supplied system and name exists.
std::shared_ptr< mfem::ParGridFunction > getGridFunction(const std::string &name)
std::vector< std::shared_ptr< Moose::MFEM::ProblemOperatorBase > > & getProblemOperators()
Get vector of all ProblemOperators added to this problem.
MFEMProblemData & getProblemData()
Method to get the current MFEMProblemData object storing the current data specifying the FE problem.
void updateFESpaces()
Calls Update() on all FE spaces.
void addIndicator(const std::string &type, const std::string &name, InputParameters ¶meters) override
Override of FEProblemBase::addIndicator.
void setEquationSystems()
Set all MFEM EquationSystems for this problem.
void rebalanceMesh(mfem::ParMesh &pmesh)
Rebalance the (necessarily nonconforming) mesh.
void addVectorPostprocessor(const std::string &type, const std::string &name, InputParameters ¶meters) override
Add a vector postprocessor and register its vectors with the MFEM execution system.
void addAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters) override
Override of ExternalProblem::addAuxKernel.
void addMaterial(const std::string &material_name, const std::string &name, InputParameters ¶meters) override
void addProblemComposer(const std::string &composer_type, const std::string &name, InputParameters ¶meters)
Method called in AddMFEMProblemComposerAction which will create the problem composer.
void addSubMesh(const std::string &type, const std::string &name, InputParameters ¶meters)
Add an MFEM SubMesh to the problem.
void validateVariableNumericType(const std::string &var_type, const std::string &var_name) const
Verify that a primary variable's numeric type matches the problem's equation system.
void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters ¶meters) override
Add an MFEM initial condition to the problem.
static InputParameters validParams()
Return the input parameters used to construct an MFEM problem.
void setMesh()
Set the mesh used by MFEM.
void addKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters) override
Override of ExternalProblem::addKernel.
virtual std::shared_ptr< MFEMWeakFormBase > addDefaultWeakForm()
Add default weak form if none has been added by the user.
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶meters) override
Override of ExternalProblem::addVariable.
NumericType getNumericType() const
Retrieve the numeric type of the problem.
void updateGridFunctions()
Calls Update() on all gridfunctions.
void addRealComponentToKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a real component kernel to the parent MFEMComplexKernel.
MFEMProblemData _problem_data
Aggregated MFEM-side state for meshes, spaces, variables, coefficients, and solvers.
void addRealComponentToBC(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a real component BC to the parent MFEMComplexIntegratedBC.
void addFunction(const std::string &type, const std::string &name, InputParameters ¶meters) override
Override of ExternalProblem::addFunction.
std::shared_ptr< Moose::MFEM::EquationSystem > getEquationSystem(const std::string &weak_form_name="") const
Return the EquationSystem built by the weak form named weak_form_name.
InputParameters addMFEMFESpaceFromMOOSEVariable(InputParameters &moosevar_params)
Method used to get an mfem FEC depending on the variable family specified in the input file.
void addGridFunction(const std::string &var_type, const std::string &var_name, InputParameters ¶meters)
Adds one MFEM GridFunction to be used in the MFEM solve.
void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters ¶meters) override
Add transfers between MultiApps and/or MFEM SubMeshes.
void displaceMesh()
Displace the mesh, if mesh displacement is enabled.
void addBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters ¶meters) override
virtual void execute(const ExecFlagType &exec_type) override
Convenience function for performing execution of MOOSE systems.
NumericType _num_type
The numeric representation currently active for this problem.
const mfem::ParGridFunction & getMeshDisplacementGridFunction()
Returns reference to the displacement GridFunction to apply to nodes.
void addImagComponentToBC(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds an imaginary component BC to the parent MFEMComplexIntegratedBC.
virtual std::shared_ptr< MFEMProblemComposer > addDefaultProblemComposer()
Add default problem composer if none has been added by the user.
void executeMFEMObjects(const ExecFlagType &exec_type)
Execute MFEM executed objects scheduled on the supplied execute flag.
MFEMProblem(const InputParameters ¶ms)
Construct an MFEM problem from the supplied parameters.
std::map< std::string, MFEMSolverDefinition > _mfem_solver_definitions
Solver definitions recorded by AddMFEMSolverAction before the dependency resolver constructs them.
void addAuxVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶meters) override
Override of ExternalProblem::addAuxVariable.
virtual void resolveMFEMSolvers()
Construct recorded MFEM solvers in dependency order and select the problem driver solver(s).
void addFunctorMaterial(const std::string &material_name, const std::string &name, InputParameters ¶meters) override
void addImagComponentToKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds an imaginary component kernel to the parent MFEMComplexKernel.
virtual void initialSetup() override
Constructs and stores an mfem::ParGridFunction object.
std::shared_ptr< mfem::ParGridFunction > getGridFunction() const
Returns a shared pointer to the constructed gridfunction.
void declareCoefficients()
Declare default coefficients associated with this gridfunction.
const InputParameters & parameters() const
Get the parameters of the object.
const std::string & type() const
Get the type of this class.
const std::string & name() const
Get the name of the class.
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 ...
Class for containing MooseEnum item information.
const std::string & name() const
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
std::shared_ptr< MooseObject > getSharedPtr()
Get another shared pointer to this object that has the same ownership group.
mfem::Coefficient & declareScalar(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing scalar coefficient or, if it does not exist, try interpreting the nam...
mfem::VectorCoefficient & declareVector(const std::string &name, const std::string &existing_or_literal)
Declare an alias to an existing vector coefficientor or, if it does not exist, try interpreting the n...
void Register(const std::string &field_name, FieldArgs &&... args)
Construct new field with name field_name and register.
std::shared_ptr< T > GetShared(const std::string &field_name) const
Returns a shared pointer to the field. This is guaranteed to return a non-null shared pointer.
void addTimeDerivativeAssociation(const std::string &var_name, const std::string &time_derivative_var_name)
Base class for all Postprocessors.
void finalize(const std::string &object_name)
Helper function for performing post calculation actions via the ReporterContext objects.
Generic class for solving transient nonlinear problems.
Factory & _factory
The Factory for building objects.
const std::vector< VariableName > & getVariableNames() const
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse.
Base class for Postprocessors that produce a vector of values.
std::string prettyCppType(const std::string &cpp_type)
std::string stringJoin(const std::vector< std::string > &values, const std::string &separator=" ")
Concatenates value into a single string separated by separator.
libMesh::Point libMeshPointFromMFEMVector(const mfem::Vector &vec)
Convert an MFEM position vector to a libMesh::Point.
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Moose::MFEM::FESpaces fespaces
Moose::MFEM::SubMeshes submeshes
Moose::MFEM::BoundaryConditions bcs
Moose::MFEM::TimeDerivativeMap time_derivative_map
Moose::MFEM::Kernels kernels
Moose::MFEM::ComplexGridFunctions cmplx_gridfunctions
Moose::MFEM::EquationSystems eqn_systems
std::shared_ptr< MFEMRefinementMarker > refiner
Moose::MFEM::FECollections fecs
std::shared_ptr< mfem::ParMesh > pmesh
Moose::MFEM::GridFunctions gridfunctions
Moose::MFEM::FESpaceHierarchies fespace_hierarchies