https://mooseframework.inl.gov
Loading...
Searching...
No Matches
MFEMProblem.C
Go to the documentation of this file.
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#ifdef MOOSE_MFEM_ENABLED
11
12#include "MFEMProblem.h"
13#include "MFEMVariable.h"
14#include "MFEMIndicator.h"
15#include "MFEMSubMesh.h"
16#include "MFEMFunctorMaterial.h"
17#include "MFEMExecutedObject.h"
18#include "MFEMVectorUtils.h"
20#include "Postprocessor.h"
21#include "VectorPostprocessor.h"
23#include "DependencyResolver.h"
24#include "MooseUtils.h"
25#include "DataIO.h"
28
29#include "libmesh/string_to_enum.h"
30
31#include <vector>
32#include <algorithm>
33#include <map>
34#include <deque>
35#include <sstream>
36
38
39namespace
40{
41std::vector<MFEMSolverName>
42getMFEMSolverDependencies(const InputParameters & parameters)
43{
44 std::vector<MFEMSolverName> dependencies;
45
46 for (const auto & [param_name, _] : parameters)
47 {
48 if (parameters.isPrivate(param_name))
49 continue;
50
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());
55 }
56
57 return dependencies;
58}
59}
60
63{
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");
69
70 return params;
71}
72
74 : ExternalProblem(params),
75 _num_type{static_cast<int>(getParam<MooseEnum>("numeric_type"))},
76 _solution_state_data(declareRestartableDataWithContext<Moose::MFEM::SolutionState>(
77 "mfem_solution_state", &_problem_data))
78{
79 // Initialise Hypre for all MFEM problems.
80 mfem::Hypre::Init();
81 setMesh();
82}
83
84void
86{
88
89 std::vector<MFEMExecutedObject *> objects;
91 .query()
92 .condition<AttribSystem>("MFEMExecutedObject")
93 .condition<AttribThread>(0)
94 .queryInto(objects);
95 for (auto * const object : objects)
96 object->initialSetup();
97}
98
99void
101{
102 setCurrentExecuteOnFlag(exec_type);
103 executeMFEMObjects(exec_type);
104
105 ExternalProblem::execute(exec_type);
106}
107
108void
110{
111 auto pmesh = mesh().getMFEMParMeshPtr();
112 getProblemData().pmesh = pmesh;
113 getProblemData().comm = pmesh->GetComm();
114 getProblemData().num_procs = pmesh->GetNRanks();
115 getProblemData().myid = pmesh->GetMyRank();
116}
117
118void
119MFEMProblem::addIndicator(const std::string & indicator_type,
120 const std::string & name,
121 InputParameters & parameters)
122{
123 auto estimator = addObject<MFEMIndicator>(indicator_type, name, parameters).front();
124
125 // construct the estimator itself
126 estimator->createEstimator();
127}
128
129void
130MFEMProblem::addMarker(const std::string & marker_type,
131 const std::string & name,
132 InputParameters & parameters)
133{
134 getProblemData().refiner = addObject<MFEMRefinementMarker>(marker_type, name, parameters).front();
135}
136
137void
138MFEMProblem::addMFEMSolver(const std::string & solver_type,
139 const std::string & name,
140 InputParameters & parameters)
141{
142 mooseAssert(!_mfem_solver_definitions.count(name), "Multiple MFEM solvers named '" + name + "'.");
144}
145
146void
148{
149 if (_mfem_solver_definitions.empty())
150 return;
151
153
154 for (auto & [solver_name, definition] : _mfem_solver_definitions)
155 {
156 const auto dependencies = getMFEMSolverDependencies(*definition.parameters);
157 if (dependencies.empty())
158 resolver.addNode(solver_name);
159
160 for (const auto & dependency_name : dependencies)
161 {
162 auto dependency_it = _mfem_solver_definitions.find(dependency_name);
163 if (dependency_it == _mfem_solver_definitions.end())
164 mooseError("MFEM solver '",
165 solver_name,
166 "' references MFEM solver '",
167 dependency_name,
168 "', but no solver with that name was provided in the [Solvers] block.");
169
170 dependency_it->second.referenced = true;
171 resolver.addEdge(dependency_name, solver_name);
172 }
173 }
174
175 const std::vector<std::string> * sorted_solver_names = nullptr;
176 try
177 {
178 sorted_solver_names = &resolver.getSortedValues();
179 }
181 {
182 mooseError("Cyclic MFEM solver dependency detected: ",
183 MooseUtils::join(e.getCyclicDependencies(), " <- "));
184 }
185
186 auto & problem_data = getProblemData();
187 mooseAssert(!problem_data.jacobian_solver, "MFEM linear solver driver already assigned");
188 mooseAssert(!problem_data.nonlinear_solver, "MFEM nonlinear solver driver already assigned");
189
190 for (const auto & solver_name : *sorted_solver_names)
191 {
192 auto & definition = libmesh_map_find(_mfem_solver_definitions, solver_name);
193 auto solver =
194 addObject<Moose::MFEM::SolverBase>(definition.type, solver_name, *definition.parameters)
195 .front();
196
197 if (definition.referenced)
198 continue;
199
200 if (auto linear_solver = std::dynamic_pointer_cast<Moose::MFEM::LinearSolverBase>(solver))
201 {
202 if (problem_data.jacobian_solver)
203 mooseError("Multiple MFEM linear solver drivers provided. '",
204 problem_data.jacobian_solver->name(),
205 "' and '",
206 linear_solver->name(),
207 "' are not referenced by another MFEM solver.");
208 problem_data.jacobian_solver = linear_solver;
209 }
210 else if (auto nonlinear_solver =
211 std::dynamic_pointer_cast<Moose::MFEM::NonlinearSolverBase>(solver))
212 {
213 if (problem_data.nonlinear_solver)
214 mooseError("Multiple MFEM nonlinear solver drivers provided. '",
215 problem_data.nonlinear_solver->name(),
216 "' and '",
217 nonlinear_solver->name(),
218 "' are not referenced by another MFEM solver.");
219 problem_data.nonlinear_solver = nonlinear_solver;
220 }
221 else
222 mooseError("Unsupported MFEM solver object type '",
223 solver->type(),
224 "' for solver '",
225 solver->name(),
226 "'.");
227 }
228
230}
231
232void
233MFEMProblem::addBoundaryCondition(const std::string & bc_name,
234 const std::string & name,
235 InputParameters & parameters)
236{
237 auto bc = addObject<MFEMBoundaryCondition>(bc_name, name, parameters).front();
239}
240
241void
242MFEMProblem::addMaterial(const std::string &, const std::string &, InputParameters &)
243{
245 "MFEM materials must be added through the 'FunctorMaterials' block and not 'Materials'");
246}
247
248void
249MFEMProblem::addFunctorMaterial(const std::string & material_name,
250 const std::string & name,
251 InputParameters & parameters)
252{
253 addObject<MFEMFunctorMaterial>(material_name, name, parameters);
254}
255
256void
257MFEMProblem::addFESpace(const std::string & type,
258 const std::string & name,
259 InputParameters & parameters)
260{
261 if (getProblemData().fespace_hierarchies.Has(name))
262 mooseError("Cannot add FESpace '",
263 name,
264 "': an MFEMFESpaceHierarchy with the same name already exists. "
265 "FESpaces and FESpaceHierarchies share the fespaces namespace.");
266
267 auto & mfem_fespace = *addObject<MFEMFESpace>(type, name, parameters).front();
268
269 // Register fespace and associated fe collection.
270 getProblemData().fecs.Register(name, mfem_fespace.getFEC());
271 getProblemData().fespaces.Register(name, mfem_fespace.getFESpace());
272}
273
274void
275MFEMProblem::addFESpaceHierarchy(const std::string & type,
276 const std::string & name,
277 InputParameters & parameters)
278{
279 if (getProblemData().fespaces.Has(name))
280 mooseError("Cannot add MFEMFESpaceHierarchy '",
281 name,
282 "': a FESpace with the same name already exists. "
283 "FESpaces and FESpaceHierarchies share the fespaces namespace.");
284
285 auto hierarchy_obj = addObject<MFEMFESpaceHierarchy>(type, name, parameters).front();
286 auto hierarchy_shared = hierarchy_obj->getHierarchyShared();
287 // Register the hierarchy for co-ownership by solvers.
288 getProblemData().fespace_hierarchies.Register(name, hierarchy_shared);
289 // Register the finest-level FESpace in fespaces under the hierarchy name so that
290 // variables can say `fespace = <hierarchy_name>` without a separate FESpace definition.
291 // The aliasing shared_ptr keeps the hierarchy alive as long as this entry lives.
292 auto finest = std::shared_ptr<mfem::ParFiniteElementSpace>(
293 hierarchy_shared, &hierarchy_obj->getHierarchy().GetFinestFESpace());
295}
296
297void
298MFEMProblem::validateVariableNumericType(const std::string & var_type,
299 const std::string & var_name) const
300{
301 const bool variable_is_complex = var_type == "MFEMComplexVariable";
302 const bool problem_is_complex = _num_type == NumericType::COMPLEX;
303 if (variable_is_complex != problem_is_complex)
304 paramError("numeric_type",
305 "The problem numeric type does not match primary MFEM variable '",
306 var_name,
307 "', which is ",
308 variable_is_complex ? "complex." : "real.");
309}
310
311void
312MFEMProblem::addVariable(const std::string & var_type,
313 const std::string & var_name,
314 InputParameters & parameters)
315{
316 validateVariableNumericType(var_type, var_name);
317 addGridFunction(var_type, var_name, parameters);
318 // MOOSE variables store DoFs for the trial variable and its time derivatives up to second order;
319 // MFEM GridFunctions store data for only one set of DoFs each, so we must add additional
320 // GridFunctions for time derivatives.
321 if (isTransient())
322 {
323 const auto time_derivative_var_name =
324 getMFEMObject<MFEMVariable>("MooseVariableBase", var_name).getTimeDerivativeName();
326 time_derivative_var_name);
327 addGridFunction(var_type, time_derivative_var_name, parameters);
328 }
329}
330
331void
332MFEMProblem::addGridFunction(const std::string & var_type,
333 const std::string & var_name,
334 InputParameters & parameters)
335{
336
337 if (var_type == "MFEMVariable" || var_type == "MFEMComplexVariable")
338 {
339 // Add MFEM variable directly.
340 if (var_type == "MFEMComplexVariable")
341 addObject<MFEMComplexVariable>(var_type, var_name, parameters);
342 else
343 addObject<MFEMVariable>(var_type, var_name, parameters);
344 }
345 else
346 {
347 // Add MOOSE variable.
348 ExternalProblem::addVariable(var_type, var_name, parameters);
349
350 // Add MFEM variable indirectly ("gridfunction").
352 addObject<MFEMVariable>("MFEMVariable", var_name, mfem_variable_params);
353 }
354
355 // Register gridfunction.
356 if (var_type == "MFEMComplexVariable")
357 {
358 MFEMComplexVariable & mfem_variable =
359 getMFEMObject<MFEMComplexVariable>("MooseVariableBase", var_name);
361 mfem_variable.declareCoefficients();
362 }
363 else // must be real, but may have been set up indirectly from a MOOSE variable
364 {
365 MFEMVariable & mfem_variable = getMFEMObject<MFEMVariable>("MooseVariableBase", var_name);
366 getProblemData().gridfunctions.Register(var_name, mfem_variable.getGridFunction());
367 mfem_variable.declareCoefficients();
368 }
369}
370
371void
372MFEMProblem::addAuxVariable(const std::string & var_type,
373 const std::string & var_name,
374 InputParameters & parameters)
375{
376 // We handle MFEM AuxVariables just like MFEM Variables, except
377 // we do not add additional GridFunctions for time derivatives.
378 addGridFunction(var_type, var_name, parameters);
379}
380
381void
382MFEMProblem::addAuxKernel(const std::string & kernel_name,
383 const std::string & name,
384 InputParameters & parameters)
385{
386 addObject<MFEMExecutedObject>(kernel_name, name, parameters);
387}
388
389void
390MFEMProblem::addKernel(const std::string & kernel_name,
391 const std::string & name,
392 InputParameters & parameters)
393{
394 auto kernel = addObject<MFEMKernel>(kernel_name, name, parameters).front();
396}
397
398void
399MFEMProblem::addRealComponentToKernel(const std::string & kernel_name,
400 const std::string & name,
401 InputParameters & parameters)
402{
403 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
404 getMFEMObject<MFEMComplexKernel>("Kernel", name).getSharedPtr());
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);
408}
409
410void
411MFEMProblem::addImagComponentToKernel(const std::string & kernel_name,
412 const std::string & name,
413 InputParameters & parameters)
414{
415 auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
416 getMFEMObject<MFEMComplexKernel>("Kernel", name).getSharedPtr());
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);
420}
421
422void
423MFEMProblem::addRealComponentToBC(const std::string & kernel_name,
424 const std::string & name,
425 InputParameters & parameters)
426{
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");
430 parameters.set<std::vector<BoundaryName>>("boundary") =
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);
435}
436
437void
438MFEMProblem::addImagComponentToBC(const std::string & kernel_name,
439 const std::string & name,
440 InputParameters & parameters)
441{
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");
445 parameters.set<std::vector<BoundaryName>>("boundary") =
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);
450}
451
452void
453MFEMProblem::addWeakForm(const std::string & weak_form_name,
454 const std::string & name,
455 InputParameters & parameters)
456{
457 addObject<MFEMWeakFormBase>(weak_form_name, name, parameters);
458}
459
460std::shared_ptr<MFEMWeakFormBase>
462{
463 const std::string name("__DefaultWeakForm");
464 std::string type;
465 if (isTransient())
466 type = "MFEMTimeDependentWeakForm";
468 type = "MFEMWeakForm";
470 type = "MFEMComplexWeakForm";
471 else
472 mooseError("Unknown numeric type. "
473 "Please set the Problem numeric type to either 'real' or 'complex'.");
474
476 return addObject<MFEMWeakFormBase>(type, name, parameters).front();
477}
478
479void
481{
482 std::vector<MFEMWeakFormBase *> weak_forms;
483 theWarehouse().query().condition<AttribSystem>("MFEMWeakFormBase").queryInto(weak_forms);
484
485 // Add a default MFEMWeakForm if none has been added by the user.
486 if (weak_forms.empty())
487 weak_forms.push_back(addDefaultWeakForm().get());
488
489 for (auto & weak_form : weak_forms)
490 _problem_data.eqn_systems.Register(weak_form->name(), weak_form->createEquationSystem());
491}
492
493std::shared_ptr<Moose::MFEM::EquationSystem>
494MFEMProblem::getEquationSystem(const std::string & weak_form_name) const
495{
496 const auto & eqn_systems = getProblemData().eqn_systems;
497
498 if (!weak_form_name.empty())
499 return eqn_systems.GetShared(weak_form_name);
500
501 mooseAssert(eqn_systems.size() != 0, "No equation systems have been built for this problem");
502
503 if (eqn_systems.size() > 1)
504 mooseError("This problem has ",
505 eqn_systems.size(),
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.");
508
509 return eqn_systems.begin()->second;
510}
511
512void
513MFEMProblem::addProblemComposer(const std::string & composer_type,
514 const std::string & name,
515 InputParameters & parameters)
516{
517 _problem_composer = addObject<MFEMProblemComposer>(composer_type, name, parameters).front();
518}
519
520std::shared_ptr<MFEMProblemComposer>
522{
523 const std::string name = "__DefaultWeakFormProblemComposer";
524 std::string type;
525 if (isTransient())
526 type = "MFEMTimeDependentWeakFormProblemComposer";
528 type = "MFEMWeakFormProblemComposer";
530 type = "MFEMComplexWeakFormProblemComposer";
531 else
532 mooseError("Unknown numeric type. "
533 "Please set the Problem numeric type to either 'real' or 'complex'.");
534
536 return addObject<MFEMProblemComposer>(type, name, params).front();
537}
538
539void
541{
542 std::vector<MFEMProblemComposer *> problem_composers;
544 .query()
545 .condition<AttribSystem>("MFEMProblemComposer")
546 .queryInto(problem_composers);
547
548 // Add a default MFEMProblemComposer if none has been added by the user.
549 if (problem_composers.empty())
550 problem_composers.push_back(addDefaultProblemComposer().get());
551
552 for (auto & problem_composer : problem_composers)
553 _problem_operators.push_back(problem_composer->createProblemOperator(*this));
554
555 for (const auto & problem_operator : getProblemOperators())
556 problem_operator->Init();
557}
558
559std::vector<std::shared_ptr<Moose::MFEM::ProblemOperatorBase>> &
564
565int
566vectorFunctionDim(const std::string & type, const InputParameters & parameters)
567{
568 if (parameters.isParamSetByUser("expression_z"))
569 return 3;
570 if (parameters.isParamSetByUser("expression_y") || type == "LevelSetOlssonVortex")
571 return 2;
572 if (parameters.isParamSetByUser("expression_x"))
573 return 1;
574
575 return 3;
576}
577
578const std::vector<std::string> SCALAR_FUNCS = {"Axisymmetric2D3DSolutionFunction",
579 "BicubicSplineFunction",
580 "CoarsenedPiecewiseLinear",
581 "CompositeFunction",
582 "ConstantFunction",
583 "ImageFunction",
584 "ParsedFunction",
585 "ParsedGradFunction",
586 "PeriodicFunction",
587 "PiecewiseBilinear",
588 "PiecewiseConstant",
589 "PiecewiseConstantFromCSV",
590 "PiecewiseLinear",
591 "PiecewiseLinearFromVectorPostprocessor",
592 "PiecewiseMultiInterpolation",
593 "PiecewiseMulticonstant",
594 "SolutionFunction",
595 "SplineFunction",
596 "FunctionSeries",
597 "LevelSetOlssonBubble",
598 "LevelSetOlssonPlane",
599 "NearestReporterCoordinatesFunction",
600 "ParameterMeshFunction",
601 "ParsedOptimizationFunction",
602 "FourierNoise",
603 "MovingPlanarFront",
604 "MultiControlDrumFunction",
605 "Grad2ParsedFunction",
606 "GradParsedFunction",
607 "ScaledAbsDifferenceDRLRewardFunction",
608 "CircularAreaHydraulicDiameterFunction",
609 "CosineHumpFunction",
610 "CosineTransitionFunction",
611 "CubicTransitionFunction",
612 "GeneralizedCircumference",
613 "PiecewiseFunction",
614 "TimeRampFunction"},
615 VECTOR_FUNCS = {"ParsedVectorFunction", "LevelSetOlssonVortex"},
616 MFEM_FUNCS = {"MFEMParsedFunction",
617 "MFEMCoordinateTransformations",
618 "MFEMScalarQuadratureFunction",
619 "MFEMVectorQuadratureFunction"};
620
621void
622MFEMProblem::addFunction(const std::string & type,
623 const std::string & name,
624 InputParameters & parameters)
625{
626 // Add function to the warehouse, while avoiding the threading logic in FEProblemBase::addFunction
627 {
628 parallel_object_only();
629
630 parameters.set<SubProblem *>("_subproblem") = this;
631
632 std::shared_ptr<Function> func = _factory.create<Function>(type, name, parameters);
633 logAdd("Function", name, type, parameters);
634 _functions.addObject(func);
635 }
636
637 auto & func = getFunction(name);
638 // FIXME: Do we want to have optimised versions for when functions
639 // are only of space or only of time.
640 if (std::find(SCALAR_FUNCS.begin(), SCALAR_FUNCS.end(), type) != SCALAR_FUNCS.end())
641 {
642 getCoefficients().declareScalar<mfem::FunctionCoefficient>(
643 name,
644 [&func](const mfem::Vector & p, mfem::real_t t) -> mfem::real_t
645 { return func.value(t, Moose::MFEM::libMeshPointFromMFEMVector(p)); });
646 }
647 else if (std::find(VECTOR_FUNCS.begin(), VECTOR_FUNCS.end(), type) != VECTOR_FUNCS.end())
648 {
650 getCoefficients().declareVector<mfem::VectorFunctionCoefficient>(
651 name,
652 dim,
653 [&func, dim](const mfem::Vector & p, mfem::real_t t, mfem::Vector & u)
654 {
655 libMesh::RealVectorValue vector_value =
656 func.vectorValue(t, Moose::MFEM::libMeshPointFromMFEMVector(p));
657 for (int i = 0; i < dim; i++)
658 {
659 u[i] = vector_value(i);
660 }
661 });
662 }
663 else if (std::find(MFEM_FUNCS.begin(), MFEM_FUNCS.end(), type) != MFEM_FUNCS.end())
664 {
665 }
666 else
667 mooseWarning("Could not identify function ", type, "; no MFEM coefficient object created.");
668}
669
670void
671MFEMProblem::addPostprocessor(const std::string & type,
672 const std::string & name,
673 InputParameters & parameters)
674{
675 if (parameters.getSystemAttributeName() == "MFEMExecutedObject")
676 {
677 checkUserObjectNameCollision(name, "Postprocessor");
678 addObject<MFEMExecutedObject>(type, name, parameters);
679 }
680 else
682
683 // Make the postprocessor value available as a spatially uniform scalar coefficient. This is done
684 // for postprocessors of all types so that values calculated elsewhere and transferred in, such
685 // as from a subapp, may also be used to build coefficients.
687 getCoefficients().declareScalar<mfem::FunctionCoefficient>(
688 name, [&val](const mfem::Vector &) -> mfem::real_t { return val; });
689}
690
691void
692MFEMProblem::addVectorPostprocessor(const std::string & type,
693 const std::string & name,
694 InputParameters & parameters)
695{
696 if (parameters.getSystemAttributeName() == "MFEMExecutedObject")
697 {
698 checkUserObjectNameCollision(name, "VectorPostprocessor");
699 addObject<MFEMExecutedObject>(type, name, parameters);
700 }
701 else
703}
704
707{
708
709 InputParameters fespace_params = _factory.getValidParams("MFEMGenericFESpace");
710 InputParameters variable_params = _factory.getValidParams("MFEMVariable");
711
712 const auto family = Utility::string_to_enum<FEFamily>(parameters.get<MooseEnum>("family"));
713 auto order = static_cast<int>(parameters.get<MooseEnum>("order"));
714 const auto dim = mesh().dimension();
715
716 std::string space;
717 int vdim = 1;
718
719 switch (family)
720 {
721 case FEFamily::LAGRANGE:
722 space = "H1";
723 break;
724 case FEFamily::NEDELEC_ONE:
725 space = "ND";
726 break;
727 case FEFamily::RAVIART_THOMAS:
728 space = "RT";
729 --order;
730 break;
731 case FEFamily::MONOMIAL:
732 case FEFamily::L2_LAGRANGE:
733 space = "L2";
734 break;
735 case FEFamily::LAGRANGE_VEC:
736 space = "H1";
737 vdim = dim;
738 break;
739 case FEFamily::MONOMIAL_VEC:
740 case FEFamily::L2_LAGRANGE_VEC:
741 space = "L2";
742 vdim = dim;
743 break;
744 default:
745 mooseError("Unable to set MFEM FESpace for MOOSE variable");
746 break;
747 }
748
749 // Create fespace name. If this already exists, we will reuse this for
750 // the mfem variable ("gridfunction"). If using AMR, this implies all
751 // variables sharing the fespace are affected.
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);
754
755 // Set all fespace parameters.
756 fespace_params.set<std::string>("fec_name") = fec_name;
757 fespace_params.set<int>("vdim") = vdim;
758
759 if (!hasMFEMObject("MFEMFESpace", fes_name))
760 addFESpace("MFEMGenericFESpace", fes_name, fespace_params);
761
762 variable_params.set<MFEMFESpaceName>("fespace") = fes_name;
763
764 return variable_params;
765}
766
767void
769{
770 // Displace mesh
771 if (mesh().shouldDisplace())
772 {
773 mesh().displace(cast_ref<mfem::GridFunction const &>(getMeshDisplacementGridFunction()));
774 // TODO: update FESpaces GridFunctions etc for transient solves
775 }
776}
777
778const mfem::ParGridFunction &
780{
781 return *getGridFunction(mesh().getMeshDisplacementVariable());
782}
783
784void
785MFEMProblem::rebalanceMesh(mfem::ParMesh & pmesh)
786{
787 if (pmesh.Nonconforming())
788 {
789 pmesh.Rebalance();
792 }
793}
794
795void
797{
798 for (const auto & fe_space_pair : _problem_data.fespaces)
799 fe_space_pair.second->Update();
800}
801
802void
804{
805 for (const auto & gridfunction_pair : _problem_data.gridfunctions)
806 gridfunction_pair.second->Update();
807}
808
809std::vector<VariableName>
814
815MFEMMesh &
817{
818 auto * mfem_mesh = dynamic_cast<MFEMMesh *>(&_mesh);
819 mooseAssert(mfem_mesh,
820 "The mesh for an MFEMProblem must be MFEMFileMesh or MFEMMeshGeneratorMesh.");
821 return *mfem_mesh;
822}
823
824const MFEMMesh &
826{
827 return const_cast<MFEMProblem *>(this)->mesh();
828}
829
830void
831MFEMProblem::addSubMesh(const std::string & var_type,
832 const std::string & var_name,
833 InputParameters & parameters)
834{
835 auto & mfem_submesh = *addObject<MFEMSubMesh>(var_type, var_name, parameters).front();
836 // Register submesh.
837 getProblemData().submeshes.Register(var_name, mfem_submesh.getSubMesh());
838}
839
840void
841MFEMProblem::addTransfer(const std::string & transfer_name,
842 const std::string & name,
843 InputParameters & parameters)
844{
845 if (parameters.getBase() == "MFEMSubMeshTransfer")
846 addObject<MFEMExecutedObject>(transfer_name, name, parameters);
847 else
849}
850
851void
852MFEMProblem::addInitialCondition(const std::string & ic_name,
853 const std::string & name,
854 InputParameters & parameters)
855{
856 addObject<MFEMExecutedObject>(ic_name, name, parameters);
857}
858
859void
861{
862 std::vector<MFEMExecutedObject *> objects;
864 .query()
865 .condition<AttribSystem>("MFEMExecutedObject")
866 .condition<AttribExecOns>(exec_type)
867 .condition<AttribThread>(0)
868 .queryInto(objects);
869
870 std::map<std::string, const MFEMExecutedObject *> suppliers;
871 for (auto * const object : objects)
872 for (const auto & item : object->getSuppliedItems())
873 {
874 const auto [it, inserted] = suppliers.emplace(item, object);
875 if (!inserted && it->second != object)
876 mooseError("MFEM executed-object dependency ambiguity on ",
877 exec_type,
878 ": both '",
879 it->second->name(),
880 "' and '",
881 object->name(),
882 "' supply '",
883 item,
884 "'.");
885 }
886
887 for (auto * const object : objects)
888 {
889 object->initialize();
890 object->execute();
891 object->finalize();
892
893 if (auto * const pp = dynamic_cast<const Postprocessor *>(object))
894 {
895 _reporter_data.finalize(pp->PPName());
896 setPostprocessorValueByName(pp->PPName(), pp->getValue());
897 }
898
899 if (auto * const vpp = dynamic_cast<VectorPostprocessor *>(object))
900 _reporter_data.finalize(vpp->PPName());
901 }
902}
903
904std::string
905MFEMProblem::solverTypeString(const unsigned int libmesh_dbg_var(solver_sys_num))
906{
907 mooseAssert(solver_sys_num == 0, "All mfem systems must use the same solver right now.");
908
909 std::vector<std::string> solvers;
910
911 if (const auto * ns = getProblemData().nonlinear_solver.get())
912 solvers.push_back(MooseUtils::prettyCppType(ns));
913
914 if (const auto * js = getProblemData().jacobian_solver.get())
915 {
916 solvers.push_back(MooseUtils::prettyCppType(js));
917 if (const std::string * pc = js->queryParam<MFEMSolverName>("preconditioner"))
918 solvers.push_back(MooseUtils::prettyCppType(
919 &getMFEMObject<Moose::MFEM::LinearSolverBase>("Moose::MFEM::SolverBase", *pc)));
920 }
921
922 return solvers.empty() ? "None" : MooseUtils::stringJoin(solvers);
923}
924
925bool
926MFEMProblem::hasMFEMObject(const std::string & system, const std::string & name) const
927{
928 std::vector<MooseObject *> objs;
930 .query()
931 .condition<AttribSystem>(system)
932 .condition<AttribThread>(0)
933 .condition<AttribName>(name)
934 .queryInto(objs);
935 return !objs.empty();
936}
937
938#endif
const std::vector< std::string > SCALAR_FUNCS
int vectorFunctionDim(const std::string &type, const InputParameters &parameters)
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.
Definition MooseError.h:345
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311
Real PostprocessorValue
various MOOSE typedefs
Definition MooseTypes.h:230
unsigned int dim
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.
MooseMesh & _mesh
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 &params)
Canonical method for adding a non-linear variable.
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters &parameters)
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 &parameters)
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters &parameters)
void logAdd(const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) 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 &parameters, THREAD_ID tid=0, bool print_deprecated=true)
Definition Factory.C:142
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition Factory.C:68
Base class for function objects.
Definition Function.h:30
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
bool isPrivate(const std::string &name) const
Returns a Boolean indicating whether the specified parameter is private or not.
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object.
const std::string & getSystemAttributeName() const
Get the system attribute name if it was registered.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump.
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
const std::string & getBase() const
const T * queryParam(const std::string &name) const
Query a parameter.
Constructs and stores an mfem::ParComplexGridFunction object.
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).
Definition MFEMMesh.h:24
unsigned int dimension() const override
Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh me...
Definition MFEMMesh.h:65
std::shared_ptr< mfem::ParMesh > getMFEMParMeshPtr()
Copy a shared_ptr to the mfem::ParMesh object.
Definition MFEMMesh.h:39
void displace(mfem::GridFunction const &displacement)
Displace the nodes of the mesh by the given displacement.
Definition MFEMMesh.C:136
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 &parameters) 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 &parameters)
Add an MFEM WeakForm to the problem.
void addFESpace(const std::string &type, const std::string &name, InputParameters &parameters)
Add an MFEM FESpace to the problem.
void addMarker(const std::string &type, const std::string &name, InputParameters &parameters) override
Override of FEProblemBase::addMarker.
void addFESpaceHierarchy(const std::string &type, const std::string &name, InputParameters &parameters)
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 &parameters)
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 &parameters) 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 &parameters) 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 &parameters) override
Override of ExternalProblem::addAuxKernel.
void addMaterial(const std::string &material_name, const std::string &name, InputParameters &parameters) override
void addProblemComposer(const std::string &composer_type, const std::string &name, InputParameters &parameters)
Method called in AddMFEMProblemComposerAction which will create the problem composer.
void addSubMesh(const std::string &type, const std::string &name, InputParameters &parameters)
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 &parameters) override
Add an MFEM initial condition to the problem.
static InputParameters validParams()
Return the input parameters used to construct an MFEM problem.
Definition MFEMProblem.C:62
void setMesh()
Set the mesh used by MFEM.
void addKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters) 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 &parameters) 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 &parameters)
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 &parameters)
Adds a real component BC to the parent MFEMComplexIntegratedBC.
void addFunction(const std::string &type, const std::string &name, InputParameters &parameters) 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 &parameters)
Adds one MFEM GridFunction to be used in the MFEM solve.
void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters &parameters) 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 &parameters) 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 &parameters)
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 &params)
Construct an MFEM problem from the supplied parameters.
Definition MFEMProblem.C:73
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 &parameters) 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 &parameters) override
void addImagComponentToKernel(const std::string &kernel_name, const std::string &name, InputParameters &parameters)
Adds an imaginary component kernel to the parent MFEMComplexKernel.
virtual void initialSetup() override
Definition MFEMProblem.C:85
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.
Definition MooseBase.h:131
const std::string & type() const
Get the type of this class.
Definition MooseBase.h:93
const std::string & name() const
Get the name of the class.
Definition MooseBase.h:103
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition MooseBase.h:457
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...
Definition MooseEnum.h:55
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.
Definition MooseObject.C:70
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.
Definition SubProblem.h:79
Factory & _factory
The Factory for building objects.
const std::vector< VariableName > & getVariableNames() const
Definition SystemBase.h:893
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