120 #include "libmesh/exodusII_io.h" 121 #include "libmesh/quadrature.h" 122 #include "libmesh/coupling_matrix.h" 123 #include "libmesh/nonlinear_solver.h" 124 #include "libmesh/sparse_matrix.h" 125 #include "libmesh/string_to_enum.h" 126 #include "libmesh/fe_interface.h" 127 #include "libmesh/enum_norm_type.h" 128 #include "libmesh/petsc_solver_exception.h" 130 #include "metaphysicl/dualnumber.h" 153 params.
addParam<
unsigned int>(
"null_space_dimension", 0,
"The dimension of the nullspace");
155 "transpose_null_space_dimension", 0,
"The dimension of the transpose nullspace");
157 "near_null_space_dimension", 0,
"The dimension of the near nullspace");
160 "Whether or not to actually solve the Nonlinear system. " 161 "This is handy in the case that all you want to do is " 162 "execute AuxKernels, Transfers, etc. without actually " 164 params.
addParam<
bool>(
"use_nonlinear",
166 "Determines whether to use a Nonlinear vs a " 167 "Eigenvalue system (Automatically determined based " 169 params.
addParam<
bool>(
"error_on_jacobian_nonzero_reallocation",
170 "This causes PETSc to error if it had to reallocate memory in the Jacobian " 171 "matrix due to not having enough nonzeros");
172 params.
addParam<
bool>(
"ignore_zeros_in_jacobian",
174 "Do not explicitly store zero values in " 175 "the Jacobian matrix if true");
176 params.
addParam<
bool>(
"force_restart",
178 "EXPERIMENTAL: If true, a sub_app may use a " 179 "restart file instead of using of using the master " 183 "True to skip additional data in equation system for restart.",
184 "This parameter is no longer used, as we do not load additional " 185 "vectors by default with restart");
186 params.
addParam<
bool>(
"skip_nl_system_check",
188 "True to skip the NonlinearSystem check for work to do (e.g. Make sure " 189 "that there are variables to solve for).");
190 params.
addParam<
bool>(
"allow_initial_conditions_with_restart",
192 "True to allow the user to specify initial conditions when restarting. " 193 "Initial conditions can override any restarted field");
201 "block", {},
"Block IDs for the coordinate systems",
"Please use 'Mesh/coord_block' instead");
206 "Type of the coordinate system per block param",
207 "Please use 'Mesh/coord_type' instead");
210 "The rotation axis (X | Y) for axisymetric coordinates",
211 "Please use 'Mesh/rz_coord_axis' instead");
212 auto coverage_check_description = [](std::string scope, std::string list_param_name)
214 return "Controls, if and how a " + scope +
215 " subdomain coverage check is performed. " 216 "With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' " 217 "will disable the check for all subdomains. " 218 "To exclude a predefined set of subdomains 'SKIP_LIST' is to " 219 "be used, while the subdomains to skip are to be defined in the parameter '" +
221 "'. To limit the check to a list of subdomains, 'ONLY_LIST' is to " 222 "be used (again, using the parameter '" +
223 list_param_name +
"').";
225 MooseEnum kernel_coverage_check_modes(
"FALSE TRUE OFF ON SKIP_LIST ONLY_LIST",
"TRUE");
227 kernel_coverage_check_modes,
228 coverage_check_description(
"kernel",
"kernel_coverage_block_list"));
229 params.
addParam<std::vector<SubdomainName>>(
230 "kernel_coverage_block_list",
232 "List of subdomains for kernel coverage check. The meaning of this list is controlled by the " 233 "parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, " 234 "not to be checked or not taken into account).");
236 "boundary_restricted_node_integrity_check",
238 "Set to false to disable checking of boundary restricted nodal object variable dependencies, " 239 "e.g. are the variable dependencies defined on the selected boundaries?");
240 params.
addParam<
bool>(
"boundary_restricted_elem_integrity_check",
242 "Set to false to disable checking of boundary restricted elemental object " 243 "variable dependencies, e.g. are the variable dependencies defined on the " 244 "selected boundaries?");
245 MooseEnum material_coverage_check_modes(
"FALSE TRUE OFF ON SKIP_LIST ONLY_LIST",
"TRUE");
247 "material_coverage_check",
248 material_coverage_check_modes,
249 coverage_check_description(
"material",
"material_coverage_block_list"));
250 params.
addParam<std::vector<SubdomainName>>(
251 "material_coverage_block_list",
253 "List of subdomains for material coverage check. The meaning of this list is controlled by " 254 "the parameter 'material_coverage_check' (whether this is the list of subdomains to be " 255 "checked, not to be checked or not taken into account).");
257 params.
addParam<
bool>(
"fv_bcs_integrity_check",
259 "Set to false to disable checking of overlapping Dirichlet and Flux BCs " 260 "and/or multiple DirichletBCs per sideset");
263 "material_dependency_check",
true,
"Set to false to disable material dependency check");
264 params.
addParam<
bool>(
"parallel_barrier_messaging",
266 "Displays messaging from parallel " 267 "barrier notifications when executing " 268 "or transferring to/from Multiapps " 271 MooseEnum verbosity(
"false true extra",
"false");
274 "Set to 'true' to have the problem report on any object created. Set " 275 "to 'extra' to also display all parameters.");
276 params.
addParam<
bool>(
"verbose_multiapps",
278 "Set to True to enable verbose screen printing related to MultiApps");
282 "Set to True to enable verbose screen printing related to solution restoration");
284 params.
addParam<FileNameNoExtension>(
"restart_file_base",
285 "File base name used for restart (e.g. " 286 "<path>/<filebase> or <path>/LATEST to " 287 "grab the latest file available)");
289 params.
addParam<std::vector<std::vector<TagName>>>(
292 "Extra vectors to add to the system that can be filled by objects which compute residuals " 293 "and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which " 294 "nonlinear system the extra tag vectors should be added for");
296 params.
addParam<std::vector<std::vector<TagName>>>(
297 "not_zeroed_tag_vectors",
299 "Extra vector tags which the sytem will not zero when other vector tags are zeroed. " 300 "The outer index is for which nonlinear system the extra tag vectors should be added for");
302 params.
addParam<std::vector<std::vector<TagName>>>(
303 "extra_tag_matrices",
305 "Extra matrices to add to the system that can be filled " 306 "by objects which compute residuals and Jacobians " 307 "(Kernels, BCs, etc.) by setting tags on them. The outer index is for which " 308 "nonlinear system the extra tag vectors should be added for");
310 params.
addParam<std::vector<TagName>>(
311 "extra_tag_solutions",
313 "Extra solution vectors to add to the system that can be used by " 314 "objects for coupling variable values stored in them.");
316 params.
addParam<
bool>(
"previous_nl_solution_required",
318 "True to indicate that this calculation requires a solution vector for " 319 "storing the previous nonlinear iteration.");
321 params.
addParam<std::vector<NonlinearSystemName>>(
322 "nl_sys_names", std::vector<NonlinearSystemName>{
"nl0"},
"The nonlinear system names");
324 params.
addParam<std::vector<LinearSystemName>>(
"linear_sys_names", {},
"The linear system names");
326 params.
addParam<
bool>(
"check_uo_aux_state",
328 "True to turn on a check that no state presents during the evaluation of " 329 "user objects and aux kernels");
336 "allow_invalid_solution",
338 "Set to true to allow convergence even though the solution has been marked as 'invalid'");
339 params.
addParam<
bool>(
"show_invalid_solution_console",
341 "Set to true to show the invalid solution occurance summary in console");
342 params.
addParam<
bool>(
"immediately_print_invalid_solution",
344 "Whether or not to report invalid solution warnings at the time the " 345 "warning is produced instead of after the calculation");
348 "identify_variable_groups_in_nl",
350 "Whether to identify variable groups in nonlinear systems. This affects dof ordering");
353 "regard_general_exceptions_as_errors",
355 "If we catch an exception during residual/Jacobian evaluaton for which we don't have " 356 "specific handling, immediately error instead of allowing the time step to be cut");
358 params.
addParam<
bool>(
"use_hash_table_matrix_assembly",
360 "Whether to assemble matrices using hash tables instead of preallocating " 361 "matrix memory. This can be a good option if the sparsity pattern changes " 362 "throughout the course of the simulation.");
364 "restore_original_nonzero_pattern",
365 "Whether we should reset matrix memory for every Jacobian evaluation. This option is useful " 366 "if the sparsity pattern is constantly changing and you are using hash table assembly or if " 367 "you wish to continually restore the matrix to the originally preallocated sparsity pattern " 368 "computed by relationship managers.");
371 "skip_nl_system_check kernel_coverage_check kernel_coverage_block_list " 372 "boundary_restricted_node_integrity_check " 373 "boundary_restricted_elem_integrity_check material_coverage_check " 374 "material_coverage_block_list fv_bcs_integrity_check " 375 "material_dependency_check check_uo_aux_state error_on_jacobian_nonzero_reallocation",
376 "Simulation checks");
378 "ignore_zeros_in_jacobian identify_variable_groups_in_nl " 379 "use_hash_table_matrix_assembly restore_original_nonzero_pattern",
380 "Nonlinear system(s)");
382 "restart_file_base force_restart allow_initial_conditions_with_restart",
"Restart");
384 "verbose_setup verbose_multiapps verbose_restore parallel_barrier_messaging",
"Verbosity");
386 "null_space_dimension transpose_null_space_dimension near_null_space_dimension",
387 "Null space removal");
389 "extra_tag_vectors extra_tag_matrices extra_tag_solutions not_zeroed_tag_vectors",
390 "Contribution to tagged field data");
392 "allow_invalid_solution show_invalid_solution_console immediately_print_invalid_solution",
393 "Solution validity control");
401 _mesh(*getCheckedPointerParam<
MooseMesh *>(
"mesh")),
403 "equation_systems", nullptr, _mesh)),
405 _solve(getParam<bool>(
"solve")),
407 _time(declareRestartableData<
Real>(
"time")),
408 _time_old(declareRestartableData<
Real>(
"time_old")),
409 _t_step(declareRecoverableData<
int>(
"t_step")),
410 _dt(declareRestartableData<
Real>(
"dt")),
411 _dt_old(declareRestartableData<
Real>(
"dt_old")),
412 _need_to_add_default_nonlinear_convergence(false),
413 _need_to_add_default_multiapp_fixed_point_convergence(false),
414 _linear_sys_names(getParam<
std::vector<LinearSystemName>>(
"linear_sys_names")),
415 _num_linear_sys(_linear_sys_names.size()),
416 _linear_systems(_num_linear_sys, nullptr),
417 _current_linear_sys(nullptr),
418 _using_default_nl(!isParamSetByUser(
"nl_sys_names")),
419 _nl_sys_names(!_using_default_nl || (_using_default_nl && !_linear_sys_names.size())
420 ? getParam<
std::vector<NonlinearSystemName>>(
"nl_sys_names")
421 :
std::vector<NonlinearSystemName>()),
422 _num_nl_sys(_nl_sys_names.size()),
423 _nl(_num_nl_sys, nullptr),
424 _current_nl_sys(nullptr),
425 _solver_systems(_num_nl_sys + _num_linear_sys, nullptr),
428 _mesh_divisions(true),
430 "material_props", &_mesh, _material_prop_registry)),
432 "bnd_material_props", &_mesh, _material_prop_registry)),
434 "neighbor_material_props", &_mesh, _material_prop_registry)),
435 _reporter_data(_app),
437 _all_user_objects(_app.getExecuteOnEnum()),
438 _multi_apps(_app.getExecuteOnEnum()),
439 _transient_multi_apps(_app.getExecuteOnEnum()),
440 _transfers(_app.getExecuteOnEnum(), false),
441 _to_multi_app_transfers(_app.getExecuteOnEnum(), false),
442 _from_multi_app_transfers(_app.getExecuteOnEnum(), false),
443 _between_multi_app_transfers(_app.getExecuteOnEnum(), false),
444 #ifdef LIBMESH_ENABLE_AMR
446 _cycles_completed(0),
448 _displaced_mesh(nullptr),
449 _geometric_search_data(*this, _mesh),
451 _reinit_displaced_elem(false),
452 _reinit_displaced_face(false),
453 _reinit_displaced_neighbor(false),
454 _input_file_saved(false),
456 _has_constraints(false),
457 _snesmf_reuse_base(true),
458 _skip_exception_check(false),
459 _snesmf_reuse_base_set_by_user(false),
460 _has_initialized_stateful(false),
461 _const_jacobian(false),
462 _has_jacobian(false),
463 _needs_old_newton_iter(false),
464 _previous_nl_solution_required(getParam<bool>(
"previous_nl_solution_required")),
465 _has_nonlocal_coupling(false),
466 _calculate_jacobian_in_uo(false),
467 _kernel_coverage_check(
469 _kernel_coverage_blocks(getParam<
std::vector<SubdomainName>>(
"kernel_coverage_block_list")),
470 _boundary_restricted_node_integrity_check(
471 getParam<bool>(
"boundary_restricted_node_integrity_check")),
472 _boundary_restricted_elem_integrity_check(
473 getParam<bool>(
"boundary_restricted_elem_integrity_check")),
474 _material_coverage_check(
476 _material_coverage_blocks(getParam<
std::vector<SubdomainName>>(
"material_coverage_block_list")),
477 _fv_bcs_integrity_check(getParam<bool>(
"fv_bcs_integrity_check")),
478 _material_dependency_check(getParam<bool>(
"material_dependency_check")),
479 _uo_aux_state_check(getParam<bool>(
"check_uo_aux_state")),
480 _max_qps(
std::numeric_limits<unsigned
int>::
max()),
482 _has_time_integrator(false),
483 _has_exception(false),
484 _parallel_barrier_messaging(getParam<bool>(
"parallel_barrier_messaging")),
485 _verbose_setup(getParam<
MooseEnum>(
"verbose_setup")),
486 _verbose_multiapps(getParam<bool>(
"verbose_multiapps")),
487 _verbose_restore(getParam<bool>(
"verbose_restore")),
489 _control_warehouse(_app.getExecuteOnEnum(), false),
490 _is_petsc_options_inserted(false),
491 _line_search(nullptr),
492 _using_ad_mat_props(false),
493 _current_ic_state(0),
494 _use_hash_table_matrix_assembly(getParam<bool>(
"use_hash_table_matrix_assembly")),
495 _error_on_jacobian_nonzero_reallocation(
496 isParamValid(
"error_on_jacobian_nonzero_reallocation")
497 ? getParam<bool>(
"error_on_jacobian_nonzero_reallocation")
498 : _app.errorOnJacobianNonzeroReallocation()),
499 _restore_original_nonzero_pattern(isParamValid(
"restore_original_nonzero_pattern")
500 ? getParam<bool>(
"restore_original_nonzero_pattern")
501 : _use_hash_table_matrix_assembly),
502 _ignore_zeros_in_jacobian(getParam<bool>(
"ignore_zeros_in_jacobian")),
503 _preserve_matrix_sparsity_pattern(true),
504 _force_restart(getParam<bool>(
"force_restart")),
505 _allow_ics_during_restart(getParam<bool>(
"allow_initial_conditions_with_restart")),
506 _skip_nl_system_check(getParam<bool>(
"skip_nl_system_check")),
507 _fail_next_system_convergence_check(false),
508 _allow_invalid_solution(getParam<bool>(
"allow_invalid_solution")),
509 _show_invalid_solution_console(getParam<bool>(
"show_invalid_solution_console")),
510 _immediately_print_invalid_solution(getParam<bool>(
"immediately_print_invalid_solution")),
511 _started_initial_setup(false),
512 _has_internal_edge_residual_objects(false),
513 _u_dot_requested(false),
514 _u_dotdot_requested(false),
515 _u_dot_old_requested(false),
516 _u_dotdot_old_requested(false),
519 _print_execution_on(),
520 _identify_variable_groups_in_nl(getParam<bool>(
"identify_variable_groups_in_nl")),
521 _regard_general_exceptions_as_errors(getParam<bool>(
"regard_general_exceptions_as_errors")),
522 _requires_nonlocal_coupling(false)
527 ADReal::do_derivatives =
true;
591 getParam<MultiMooseEnum>(
"coord_type"));
597 std::string restart_file_base = getParam<FileNameNoExtension>(
"restart_file_base");
604 if (restart_file_base.size())
622 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 641 mooseWarning(
"Displaced mesh was requested but the displaced problem does not exist. " 642 "Regular mesh will be returned");
650 auto & vectors = getParam<std::vector<std::vector<TagName>>>(
"extra_tag_vectors");
652 for (
auto & vector : vectors[sys_num])
658 auto & not_zeroed_vectors = getParam<std::vector<std::vector<TagName>>>(
"not_zeroed_tag_vectors");
659 for (
const auto sys_num :
index_range(not_zeroed_vectors))
660 for (
auto & vector : not_zeroed_vectors[sys_num])
668 auto & matrices = getParam<std::vector<std::vector<TagName>>>(
"extra_tag_matrices");
670 for (
auto & matrix : matrices[sys_num])
680 for (
auto & vector :
getParam<std::vector<TagName>>(
"extra_tag_solutions"))
699 sys->associateVectorToTag(*sys->system().current_local_solution.get(), tag);
700 _aux->associateVectorToTag(*
_aux->system().current_local_solution.get(), tag);
707 for (
const auto i :
make_range((
unsigned)0, oldest_needed))
710 sys->needSolutionState(i, iteration_type);
711 _aux->needSolutionState(i, iteration_type);
723 _assembly[i].resize(solver_systems.size());
725 _assembly[i][j] = std::make_unique<Assembly>(*solver_systems[j], i);
731 std::vector<std::shared_ptr<NonlinearSystemBase>> & nls)
733 TIME_SECTION(
"initNullSpaceVectors", 5,
"Initializing Null Space Vectors");
735 unsigned int dimNullSpace =
parameters.
get<
unsigned int>(
"null_space_dimension");
736 unsigned int dimTransposeNullSpace =
737 parameters.
get<
unsigned int>(
"transpose_null_space_dimension");
738 unsigned int dimNearNullSpace =
parameters.
get<
unsigned int>(
"near_null_space_dimension");
739 for (
unsigned int i = 0; i < dimNullSpace; ++i)
741 std::ostringstream oss;
745 for (
auto & nl : nls)
749 for (
unsigned int i = 0; i < dimTransposeNullSpace; ++i)
751 std::ostringstream oss;
755 for (
auto & nl : nls)
759 for (
unsigned int i = 0; i < dimNearNullSpace; ++i)
761 std::ostringstream oss;
765 for (
auto & nl : nls)
780 for (
unsigned int i = 0; i <
n_threads; i++)
796 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 801 CHKERRABORT(this->
comm().
get(), ierr);
810 TIME_SECTION(
"setCoordSystem", 5,
"Setting Coordinate System");
825 std::vector<const DofMap *> dof_maps(
es().n_systems());
829 dof_maps[i] = &sys.get_dof_map();
832 std::make_unique<ConstElemRange>(
_mesh.
getMesh().multi_evaluable_elements_begin(dof_maps),
833 _mesh.
getMesh().multi_evaluable_elements_end(dof_maps));
843 std::vector<const DofMap *> dof_maps(
_nl.size());
845 dof_maps[i] = &
_nl[i]->dofMap();
847 std::make_unique<ConstElemRange>(
_mesh.
getMesh().multi_evaluable_elements_begin(dof_maps),
848 _mesh.
getMesh().multi_evaluable_elements_end(dof_maps));
857 TIME_SECTION(
"initialSetup", 2,
"Performing Initial Setup");
862 mooseError(
"Checkpoint recovery and restart and exodus restart are all mutually exclusive.");
865 mooseWarning(
"MOOSE may fail to catch an exception when the \"skip_exception_check\" parameter " 866 "is used. If you receive a terse MPI error during execution, remove this " 867 "parameter and rerun your simulation");
882 _aux->initSolutionState();
895 TIME_SECTION(
"computingMaxDofs", 3,
"Computing Max Dofs Per Element");
899 max_var_n_dofs_per_elem = mvndpe.
max();
904 max_var_n_dofs_per_node = mvndpn.
max();
906 global_max_var_n_dofs_per_elem =
907 std::max(global_max_var_n_dofs_per_elem, max_var_n_dofs_per_elem);
911 TIME_SECTION(
"assignMaxDofs", 5,
"Assigning Maximum Dofs Per Elem");
913 sys.assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
916 displaced_problem->solverSys(i).assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
918 sys.assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
920 displaced_problem->solverSys(i).assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
925 TIME_SECTION(
"resizingVarValues", 5,
"Resizing Variable Values");
929 _phi_zero[tid].resize(global_max_var_n_dofs_per_elem, std::vector<Real>(
getMaxQps(), 0.));
949 props->setRecovering();
951 TIME_SECTION(
"restore", 3,
"Restoring from backup");
978 TIME_SECTION(
"copyingFromExodus", 3,
"Copying Variables From Exodus");
981 sys->copyVars(*reader);
982 _aux->copyVars(*reader);
987 mooseError(
"Need Exodus reader to restart variables but the reader is not available\n" 988 "Use either FileMesh with an Exodus mesh file or FileMeshGenerator with an " 989 "Exodus mesh file and with use_for_exodus_restart equal to true");
1005 mooseError(
"Stateful neighbor material properties do not work with mesh adaptivity");
1021 "Doing extra refinements when restarting is NOT supported for sub-apps of a MultiApp");
1031 TIME_SECTION(
"convergenceInitialSetup", 5,
"Initializing Convergence objects");
1039 std::set<std::string> depend_objects_aux =
_aux->getDependObjects();
1043 std::vector<UserObject *> userobjs;
1048 std::map<int, std::vector<UserObject *>> group_userobjs;
1049 for (
auto obj : userobjs)
1050 group_userobjs[obj->getParam<
int>(
"execution_order_group")].push_back(obj);
1052 for (
auto & [group, objs] : group_userobjs)
1053 for (
auto obj : objs)
1054 obj->initialSetup();
1066 TIME_SECTION(
"initializingFunctions", 5,
"Initializing Functions");
1078 TIME_SECTION(
"initializingRandomObjects", 5,
"Initializing Random Objects");
1090 TIME_SECTION(
"ICinitialSetup", 5,
"Setting Up Initial Conditions");
1104 TIME_SECTION(
"materialInitialSetup", 3,
"Setting Up Materials");
1126 TIME_SECTION(
"computingInitialStatefulProps", 3,
"Computing Initial Material Values");
1142 props->setRestartInPlace();
1143 props->setRecovering();
1154 #ifdef LIBMESH_ENABLE_AMR 1160 mooseError(
"Cannot perform initial adaptivity during restart on sub-apps of a MultiApp!");
1165 #endif // LIBMESH_ENABLE_AMR 1176 unsigned short ic_state_max = 0;
1178 auto findMax = [&ic_state_max](
const auto & obj_list)
1180 for (
auto ic : obj_list.getActiveObjects())
1181 ic_state_max =
std::max(ic_state_max, ic->getState());
1188 if (ic_state_max > 0)
1192 std::vector<std::unique_ptr<NumericVector<Real>>> state0_sys_buffers(
_solver_systems.size());
1193 std::unique_ptr<NumericVector<Real>> state0_aux_buffer;
1199 state0_aux_buffer =
_aux->solutionState(0).clone();
1220 _aux->solutionState(0) = *state0_aux_buffer;
1221 _aux->solutionState(0).close();
1234 sys->initialSetup();
1237 _aux->initialSetup();
1244 sys->setSolution(*(sys->system().current_local_solution.get()));
1274 const auto & tis = sys->getTimeIntegrators();
1277 TIME_SECTION(
"timeIntegratorInitialSetup", 5,
"Initializing Time Integrator");
1278 for (
auto & ti : tis)
1289 TIME_SECTION(
"initialSetupMultiApps", 2,
"Initializing MultiApps",
false);
1295 TIME_SECTION(
"initialSetupTransfers", 2,
"Initializing Transfers");
1301 for (
const auto & transfer : to_multi_app_objects)
1303 transfer->setCurrentDirection(Transfer::DIRECTION::TO_MULTIAPP);
1304 transfer->initialSetup();
1309 for (
const auto & transfer : from_multi_app_objects)
1311 transfer->setCurrentDirection(Transfer::DIRECTION::FROM_MULTIAPP);
1312 transfer->initialSetup();
1317 for (
const auto & transfer : between_multi_app_objects)
1319 transfer->setCurrentDirection(Transfer::DIRECTION::BETWEEN_MULTIAPP);
1320 transfer->initialSetup();
1326 TIME_SECTION(
"BoundaryRestrictedNodeIntegrityCheck", 5);
1331 Threads::parallel_reduce(bnd_nodes, bnict);
1335 for (
const auto & bnode : bnd_nodes)
1337 const auto boundary_id = bnode->_bnd_id;
1338 const Node *
const node = bnode->_node;
1345 const Elem *
const an_elem =
1352 for (
auto & nl :
_nl)
1354 const auto & nodal_bcs = nl->getNodalBCWarehouse();
1355 if (!nodal_bcs.hasBoundaryObjects(boundary_id, 0))
1358 const auto & bnd_objects = nodal_bcs.getBoundaryObjects(boundary_id, 0);
1359 for (
const auto & bnd_object : bnd_objects)
1362 if (!bnd_object->requiresGeometricSearch() &&
1363 bnd_object->checkVariableBoundaryIntegrity())
1365 std::set<MooseVariableFieldBase *> vars_to_omit = {
1370 *bnd_object, bnd_object->checkAllVariables(*node, vars_to_omit), bnd_name);
1378 TIME_SECTION(
"BoundaryRestrictedElemIntegrityCheck", 5);
1383 Threads::parallel_reduce(bnd_elems, beict);
1392 mooseError(
"failed to converge initial MultiApp");
1424 TIME_SECTION(
"computeMaterials", 2,
"Computing Initial Material Properties");
1433 for (
unsigned int tid = 0; tid <
n_threads; tid++)
1451 TIME_SECTION(
"lineSearchInitialSetup", 5,
"Initializing Line Search");
1473 "\" has the same name as a scalar variable in the system.");
1484 std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(
nullptr);
1486 displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);
1502 displaced_mesh_refinement->uniformly_coarsen();
1550 _aux->timestepSetup();
1552 sys->timestepSetup();
1565 std::vector<UserObject *> userobjs;
1567 for (
auto obj : userobjs)
1568 obj->timestepSetup();
1595 TIME_SECTION(
"checkNonlocalCoupling", 5,
"Checking Nonlocal Coupling");
1598 for (
auto & nl :
_nl)
1600 const auto & all_kernels = nl->getKernelWarehouse();
1601 const auto & kernels = all_kernels.getObjects(tid);
1602 for (
const auto & kernel : kernels)
1604 std::shared_ptr<NonlocalKernel> nonlocal_kernel =
1606 if (nonlocal_kernel)
1614 nl->getIntegratedBCWarehouse();
1615 const auto & integrated_bcs = all_integrated_bcs.
getObjects(tid);
1616 for (
const auto & integrated_bc : integrated_bcs)
1618 std::shared_ptr<NonlocalIntegratedBC> nonlocal_integrated_bc =
1620 if (nonlocal_integrated_bc)
1633 std::set<const MooseVariableFEBase *> uo_jacobian_moose_vars;
1635 std::vector<ShapeElementUserObject *> objs;
1639 .condition<AttribThread>(tid)
1642 for (
const auto & uo : objs)
1645 const auto & mv_deps = uo->jacobianMooseVariables();
1646 uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1650 std::vector<ShapeSideUserObject *> objs;
1654 .condition<AttribThread>(tid)
1656 for (
const auto & uo : objs)
1659 const auto & mv_deps = uo->jacobianMooseVariables();
1660 uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1672 for (
unsigned int i = 0; i < moose_vars.size(); ++i)
1674 VariableName var_name = moose_vars[i]->name();
1676 sys->setVariableGlobalDoFs(var_name);
1694 _assembly[tid][i]->prepareJacobianBlock();
1717 for (
auto & nl :
_nl)
1718 nl->prepareFace(tid,
true);
1719 _aux->prepareFace(tid,
false);
1729 const std::vector<dof_id_type> & dof_indices,
1735 _nl[i]->prepare(tid);
1740 _assembly[tid][current_nl_sys_num]->prepareBlock(ivar, jvar, dof_indices);
1745 _assembly[tid][current_nl_sys_num]->prepareBlockNonlocal(
1767 _assembly[tid][i]->setCurrentSubdomainID(did);
1780 _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
1793 _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
1995 std::vector<dof_id_type> & dof_indices,
1996 const std::set<TagID> & tags,
2019 _displaced_problem->addJacobianBlockTags(jacobian, ivar, jvar, dof_map, dof_indices, tags, tid);
2025 jacobian, ivar, jvar, dof_map, dof_indices, jv.
allDofIndices(), tags, tid);
2035 std::vector<dof_id_type> & dof_indices,
2036 std::vector<dof_id_type> & neighbor_dof_indices,
2037 const std::set<TagID> & tags,
2045 neighbor_dof_indices,
2050 jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices, tags, tid);
2089 TIME_SECTION(
"ghostGhostedBoundaries", 3,
"Ghosting Ghosted Boundaries");
2101 "This function is deprecated and no longer performs any function. Please do not call it."));
2109 unsigned int n_points = points.size();
2126 _zero[tid].resize(max_qpts, 0);
2136 _assembly[tid][i]->reinitAtPhysical(elem, points);
2137 _nl[i]->prepare(tid);
2148 bool have_points = n_points > 0;
2163 sys->reinitElem(elem, tid);
2164 _aux->reinitElem(elem, tid);
2172 const std::vector<Point> & phys_points_in_elem,
2176 "Are you calling this method with a displaced mesh element?");
2180 _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
2193 const unsigned int side,
2198 "reinitElemFace with a BoundaryID argument is deprecated because the boundary id was never " 2199 "used. Please call reinitElemFace without the BoundaryID argument instead");
2212 _aux->reinitElemFace(elem, side, tid);
2221 const std::vector<Point> *
const pts,
2222 const std::vector<Real> *
const weights)
2240 _nl[i]->reinitNode(node, tid);
2242 _aux->reinitNode(node, tid);
2254 _nl[i]->reinitNodeFace(node, bnd_id, tid);
2256 _aux->reinitNodeFace(node, bnd_id, tid);
2265 for (
auto & nl :
_nl)
2266 nl->reinitNodes(nodes, tid);
2267 _aux->reinitNodes(nodes, tid);
2276 for (
auto & nl :
_nl)
2277 nl->reinitNodesNeighbor(nodes, tid);
2278 _aux->reinitNodesNeighbor(nodes, tid);
2284 TIME_SECTION(
"reinitScalars", 3,
"Reinitializing Scalar Variables");
2289 for (
auto & nl :
_nl)
2290 nl->reinitScalars(tid, reinit_for_derivative_reordering);
2291 _aux->reinitScalars(tid, reinit_for_derivative_reordering);
2316 _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
2317 _nl[i]->prepareNeighbor(tid);
2321 _aux->prepareNeighbor(tid);
2323 for (
auto & nl :
_nl)
2325 nl->reinitElemFace(elem, side, tid);
2326 nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2328 _aux->reinitElemFace(elem, side, tid);
2329 _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2338 const auto & displaced_ref_pts =
_assembly[tid][0]->qRuleNeighbor()->get_points();
2358 auto & neighbor =
_assembly[tid][0]->neighbor();
2359 auto & neighbor_side =
_assembly[tid][0]->neighborSide();
2361 if (lower_d_elem_neighbor &&
2364 auto qps =
_assembly[tid][0]->qPointsFaceNeighbor().stdVector();
2365 std::vector<Point> reference_points;
2367 lower_d_elem_neighbor->
dim(), lower_d_elem_neighbor, qps, reference_points);
2380 unsigned int neighbor_side,
2381 const std::vector<Point> & physical_points,
2385 "Are you calling this method with a displaced mesh element?");
2390 _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, neighbor_side, physical_points);
2393 _nl[i]->prepareNeighbor(tid);
2395 _aux->prepareNeighbor(tid);
2401 for (
auto & nl :
_nl)
2402 nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2403 _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2408 const std::vector<Point> & physical_points,
2412 "Are you calling this method with a displaced mesh element?");
2417 _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, physical_points);
2420 _nl[i]->prepareNeighbor(tid);
2422 _aux->prepareNeighbor(tid);
2428 for (
auto & nl :
_nl)
2429 nl->reinitNeighbor(neighbor, tid);
2430 _aux->reinitNeighbor(neighbor, tid);
2441 std::set<const Elem *> displaced_elements;
2446 for (
const auto & elem : displaced_elements)
2469 for (
auto & nl :
_nl)
2470 nl->subdomainSetup(subdomain, tid);
2484 const std::string & name,
2487 parallel_object_only();
2504 mooseError(
"Unrecognized function functor type");
2510 const std::string & name,
2513 parallel_object_only();
2525 const std::string class_name =
"DefaultNonlinearConvergence";
2529 params.
set<
bool>(
"added_as_default") =
true;
2537 const std::string class_name =
"DefaultMultiAppFixedPointConvergence";
2541 params.
set<
bool>(
"added_as_default") =
true;
2561 std::istringstream ss(
name);
2565 if (ss >> real_value && ss.eof())
2568 params.
set<
Real>(
"value") = real_value;
2569 addFunction(
"ConstantFunction", ss.str(), params);
2574 std::string
vars =
"x,y,z,t,NaN,pi,e";
2579 params.
set<std::string>(
"expression") =
name;
2607 mooseError(
"The Convergence object '",
name,
"' does not exist.");
2612 const std::vector<std::shared_ptr<Convergence>> &
2620 const std::string & name,
2623 parallel_object_only();
2638 mooseError(
"No MeshDivision object named ",
name,
" of appropriate type");
2651 mooseDeprecated(
"FEProblemBase::getNonlinearSystem() is deprecated, please use " 2652 "FEProblemBase::getNonlinearSystemBase() \n");
2654 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
2665 const std::string & name,
2675 std::vector<Distribution *> objs;
2679 .condition<AttribName>(
name)
2682 mooseError(
"Unable to find Distribution with name '" +
name +
"'");
2688 const std::string & name,
2692 for (
auto & sampler : samplers)
2699 std::vector<Sampler *> objs;
2703 .condition<AttribThread>(tid)
2708 "Unable to find Sampler with name '" +
name +
2709 "', if you are attempting to access this object in the constructor of another object then " 2710 "the object being retrieved must occur prior to the caller within the input file.");
2718 const std::set<SubdomainID> *
const active_subdomains)
2721 std::set<SubdomainID> subdomainIDs;
2722 if (active_subdomains->size() == 0)
2725 subdomainIDs.insert(subdomains.begin(), subdomains.end());
2728 subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());
2734 std::string error_prefix =
"";
2737 curr_sys_ptr =
_aux.get();
2738 other_sys_ptr = sys.get();
2739 error_prefix =
"aux";
2743 mooseError(
"Cannot have an auxiliary variable and a solver variable with the same name: ",
2754 const auto stringifyType = [](
FEType t)
2757 mooseError(
"Mismatching types are specified for ",
2759 "variable with name '",
2762 stringifyType(var.
type()),
2764 stringifyType(
type),
2772 std::set<SubdomainID> varSubdomainIDs;
2773 if (varActiveSubdomains.size() == 0)
2776 varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
2779 varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());
2783 const auto isSubset = std::includes(varSubdomainIDs.begin(),
2784 varSubdomainIDs.end(),
2785 subdomainIDs.begin(),
2786 subdomainIDs.end());
2791 const auto stringifySubdomains = [
this](std::set<SubdomainID> subdomainIDs)
2793 std::stringstream s;
2794 for (
auto const i : subdomainIDs)
2802 if (subdomainName.empty())
2805 s << subdomainName <<
" (" << i <<
")";
2810 const std::string msg =
"Mismatching block-restrictions are specified for " +
2811 error_prefix +
"variable with name '" + var_name +
"': {" +
2812 stringifySubdomains(varSubdomainIDs) +
"} and {" +
2813 stringifySubdomains(subdomainIDs) +
"}";
2828 const std::string & var_name,
2831 parallel_object_only();
2833 const auto order = Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order"));
2834 const auto family = Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"));
2835 const auto fe_type =
FEType(order, family);
2837 const auto active_subdomains_vector =
2839 const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
2840 active_subdomains_vector.end());
2847 SolverSystemName sys_name = params.
get<SolverSystemName>(
"solver_sys");
2849 const auto solver_system_number =
solverSysNum(sys_name);
2850 logAdd(
"Variable", var_name, var_type, params);
2851 _solver_systems[solver_system_number]->addVariable(var_type, var_name, params);
2861 std::pair<bool, unsigned int>
2863 const bool error_if_not_found)
const 2870 "If the variable is in our FEProblem solver system map, then it must be in the " 2871 "solver system we expect");
2872 else if (error_if_not_found)
2874 if (
_aux->hasVariable(var_name) ||
_aux->hasScalarVariable(var_name))
2877 " found. Did you specify an auxiliary variable when you meant to specify a " 2878 "solver variable?");
2882 "'. It does not exist in the solver system(s) or auxiliary system");
2890 const std::string & name,
2892 const unsigned int nl_sys_num,
2893 const std::string & base_name,
2894 bool & reinit_displaced)
2900 reinit_displaced =
true;
2923 const std::string & name,
2926 parallel_object_only();
2929 mooseError(
"You are trying to add a Kernel to a linear variable/system, which is not " 2930 "supported at the moment!");
2939 const std::string & name,
2942 parallel_object_only();
2945 mooseError(
"You are trying to add a HDGKernel to a linear variable/system, which is not " 2946 "supported at the moment!");
2955 const std::string & name,
2958 parallel_object_only();
2988 const std::string & name,
2991 parallel_object_only();
2995 mooseError(
"You are trying to add a ScalarKernel to a linear variable/system, which is not " 2996 "supported at the moment!");
3025 const std::string & name,
3028 parallel_object_only();
3033 "You are trying to add a BoundaryCondition to a linear variable/system, which is not " 3034 "supported at the moment!");
3043 const std::string & name,
3046 parallel_object_only();
3050 auto determine_var_param_name = [&
parameters,
this]()
3059 if (!has_secondary_var && !has_primary_var)
3061 "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
3064 return has_secondary_var ?
"secondary_variable" :
"primary_variable";
3068 const auto nl_sys_num =
3071 mooseError(
"You are trying to add a Constraint to a linear variable/system, which is not " 3072 "supported at the moment!");
3096 const std::string & var_name,
3099 parallel_object_only();
3101 const auto order = Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order"));
3102 const auto family = Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"));
3103 const auto fe_type =
FEType(order, family);
3105 const auto active_subdomains_vector =
3107 const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
3108 active_subdomains_vector.end());
3116 logAdd(
"AuxVariable", var_name, var_type, params);
3117 _aux->addVariable(var_type, var_name, params);
3128 const std::set<SubdomainID> *
const active_subdomains)
3130 parallel_object_only();
3132 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3137 std::string var_type;
3139 var_type =
"MooseVariableConstMonomial";
3141 var_type =
"MooseVariableScalar";
3143 var_type =
"VectorMooseVariable";
3145 var_type =
"MooseVariable";
3153 if (active_subdomains)
3157 logAdd(
"AuxVariable", var_name, var_type, params);
3158 _aux->addVariable(var_type, var_name, params);
3168 unsigned int components,
3169 const std::set<SubdomainID> *
const active_subdomains)
3171 parallel_object_only();
3173 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3183 params.
set<
unsigned int>(
"components") = components;
3185 if (active_subdomains)
3189 logAdd(
"Variable", var_name,
"ArrayMooseVariable", params);
3190 _aux->addVariable(
"ArrayMooseVariable", var_name, params);
3201 const std::set<SubdomainID> *
const active_subdomains)
3203 parallel_object_only();
3205 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3220 params.
set<std::vector<Real>>(
"scaling") = {1};
3221 if (active_subdomains)
3225 logAdd(
"ScalarVariable", var_name,
"MooseVariableScalar", params);
3226 _aux->addVariable(
"MooseVariableScalar", var_name, params);
3233 const std::string & name,
3236 parallel_object_only();
3243 if (!
parameters.
get<std::vector<BoundaryName>>(
"boundary").empty())
3271 const std::string & name,
3274 parallel_object_only();
3303 const std::string & name,
3306 parallel_object_only();
3310 mooseError(
"You are trying to add a DiracKernel to a linear variable/system, which is not " 3311 "supported at the moment!");
3343 const std::string & name,
3346 parallel_object_only();
3350 mooseError(
"You are trying to add a DGKernel to a linear variable/system, which is not " 3351 "supported at the moment!");
3383 const std::string & name,
3397 const std::string & name,
3405 const std::string & name,
3410 addObject<FVInterfaceKernel>(
3416 const std::string & name,
3424 const std::string & name,
3434 const std::string & name,
3437 parallel_object_only();
3441 mooseError(
"You are trying to add a InterfaceKernel to a linear variable/system, which is not " 3442 "supported at the moment!");
3474 const std::string & name,
3475 const VariableName & var_name)
3479 std::string restart_method =
"";
3482 "a checkpoint restart, by IC object '" + ic_name +
"' for variable '" +
name +
"'";
3488 restarted_vars.insert(restarted_vars.end(), nodal_vars.begin(), nodal_vars.end());
3489 restarted_vars.insert(restarted_vars.end(), global_vars.begin(), global_vars.end());
3491 if (std::find(restarted_vars.begin(), restarted_vars.end(), var_name) != restarted_vars.end())
3492 restart_method =
"an Exodus restart, by IC object '" + ic_name +
"' for variable '" +
name +
3493 "' that is also being restarted";
3495 if (!restart_method.empty())
3497 "Initial conditions have been specified during ",
3499 ".\nThis is only allowed if you specify 'allow_initial_conditions_with_restart' to " 3500 "the [Problem], as initial conditions can override restarted fields");
3506 const std::string & name,
3509 parallel_object_only();
3513 const std::string & var_name =
parameters.
get<VariableName>(
"variable");
3528 std::shared_ptr<InitialConditionBase> ic;
3529 if (dynamic_cast<MooseVariable *>(&var))
3531 else if (dynamic_cast<VectorMooseVariable *>(&var))
3533 else if (dynamic_cast<ArrayMooseVariable *>(&var))
3535 else if (dynamic_cast<MooseVariableFVReal *>(&var))
3537 else if (dynamic_cast<MooseLinearVariableFVReal *>(&var))
3540 mooseError(
"Your FE variable in initial condition ",
3542 " must be either of scalar or vector type");
3553 std::shared_ptr<ScalarInitialCondition> ic =
3561 "Variable '", var_name,
"' requested in initial condition '",
name,
"' does not exist.");
3566 const std::string & name,
3569 parallel_object_only();
3573 const std::string & var_name =
parameters.
get<VariableName>(
"variable");
3588 std::shared_ptr<FVInitialConditionBase> ic;
3593 "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
3600 "' requested in finite volume initial condition '",
3602 "' does not exist.");
3608 TIME_SECTION(
"projectSolution", 2,
"Projecting Initial Solutions")
3614 Threads::parallel_reduce(elem_range, cic);
3622 Threads::parallel_reduce(elem_info_range, cfvic);
3626 for (
auto & nl :
_nl)
3627 nl->solution().close();
3628 _aux->solution().close();
3633 Threads::parallel_reduce(bnd_nodes, cbic);
3635 for (
auto & nl :
_nl)
3636 nl->solution().close();
3637 _aux->solution().close();
3645 for (
const auto & ic : ics)
3653 const unsigned int n_SCALAR_dofs = var.
dofIndices().size();
3654 for (
unsigned int i = 0; i < n_SCALAR_dofs; i++)
3665 sys->solution().close();
3666 sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
3669 _aux->solution().close();
3670 _aux->solution().localize(*
_aux->sys().current_local_solution,
_aux->dofMap().get_send_list());
3678 Threads::parallel_reduce(elem_range, cic);
3681 for (
auto & nl :
_nl)
3682 nl->solution().close();
3683 _aux->solution().close();
3686 Threads::parallel_reduce(bnd_nodes, cbic);
3688 for (
auto & nl :
_nl)
3689 nl->solution().close();
3690 _aux->solution().close();
3698 for (
const auto & ic : ics)
3706 const unsigned int n_SCALAR_dofs = var.
dofIndices().size();
3707 for (
unsigned int i = 0; i < n_SCALAR_dofs; i++)
3716 for (
auto & nl :
_nl)
3718 nl->solution().close();
3719 nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
3722 _aux->solution().close();
3723 _aux->solution().localize(*
_aux->sys().current_local_solution,
_aux->dofMap().get_send_list());
3726 std::shared_ptr<MaterialBase>
3735 name +=
"_neighbor";
3748 "), but its compute flag is set to true. This indicates that MOOSE is " 3749 "computing this property which may not be desired and produce un-expected " 3770 mooseError(
"FEProblemBase::getMaterialData(): Invalid MaterialDataType ",
type);
3778 "ignore_zeros_in_jacobian",
3779 "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which " 3780 "leads to removing those entries from the Jacobian sparsity pattern");
3793 const std::string & name,
3796 parallel_object_only();
3798 auto add_functor_materials = [&](
const auto &
parameters,
const auto &
name)
3803 std::shared_ptr<MaterialBase> material =
3817 add_functor_materials(disp_params,
name +
"_displaced");
3823 const std::string & name,
3831 const std::string & name,
3839 const std::string & mat_name,
3840 const std::string & name,
3843 parallel_object_only();
3868 std::shared_ptr<MaterialBase> material =
3871 bool discrete = !material->getParam<
bool>(
"compute");
3875 if (material->boundaryRestricted() ||
dynamic_cast<FunctorMaterial *
>(material.get()))
3881 for (
auto && warehouse : warehouses)
3882 warehouse->addObject(material, tid);
3894 std::string object_name;
3903 object_name =
name +
"_face";
3904 std::shared_ptr<MaterialBase> face_material =
3910 current_parameters.set<
bool>(
"_neighbor") =
true;
3911 object_name =
name +
"_neighbor";
3912 std::shared_ptr<MaterialBase> neighbor_material =
3921 for (
auto && warehouse : warehouses)
3922 warehouse->addObjects(material, neighbor_material, face_material, tid);
3925 const std::string & base =
parameters.
get<std::string>(
"_moose_base");
3927 const auto param_names =
3932 for (
const auto & p_name : param_names)
3935 p_name.parameter());
3937 p_name.parameter());
3939 p_name.parameter());
3941 primary_name, face_name,
false);
3943 primary_name, neighbor_name,
false);
3954 std::set<MooseVariableFEBase *> needed_moose_vars;
3955 std::unordered_set<unsigned int> needed_mat_props;
3964 for (
const auto id : ids)
3971 needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
3972 current_active_elemental_moose_variables.end());
3974 needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());
3985 auto && elem =
_assembly[tid][0]->elem();
3986 unsigned int n_points =
_assembly[tid][0]->qRule()->n_points();
3989 material_data.
resize(n_points);
3993 material_data.swap(*elem);
4006 const bool swap_stateful,
4007 const std::deque<MaterialBase *> *
const reinit_mats)
4011 auto && elem =
_assembly[tid][0]->elem();
4012 unsigned int side =
_assembly[tid][0]->side();
4013 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4016 bnd_material_data.
resize(n_points);
4018 if (swap_stateful && !bnd_material_data.isSwapped())
4019 bnd_material_data.swap(*elem, side);
4022 bnd_material_data.reset(
4026 bnd_material_data.reinit(*reinit_mats);
4028 bnd_material_data.reinit(
4036 const bool swap_stateful,
4037 const std::deque<MaterialBase *> *
const reinit_mats)
4047 mooseAssert(neighbor,
"neighbor should be non-null");
4049 "The provided blk_id " << blk_id <<
" and neighbor subdomain ID " 4052 unsigned int n_points =
_assembly[tid][0]->qRuleNeighbor()->n_points();
4055 neighbor_material_data.
resize(n_points);
4059 neighbor_material_data.swap(*neighbor, neighbor_side);
4062 neighbor_material_data.reset(
4066 neighbor_material_data.reinit(*reinit_mats);
4068 neighbor_material_data.reinit(
4076 const bool swap_stateful,
4077 const std::deque<MaterialBase *> *
const reinit_mats)
4081 auto && elem =
_assembly[tid][0]->elem();
4082 unsigned int side =
_assembly[tid][0]->side();
4083 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4086 bnd_material_data.
resize(n_points);
4088 if (swap_stateful && !bnd_material_data.isSwapped())
4089 bnd_material_data.swap(*elem, side);
4095 bnd_material_data.reinit(*reinit_mats);
4109 unsigned int side =
_assembly[tid][0]->side();
4110 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4113 bnd_material_data.
resize(n_points);
4115 if (swap_stateful && !bnd_material_data.isSwapped())
4116 bnd_material_data.swap(*elem, side);
4126 auto && elem =
_assembly[tid][0]->elem();
4133 auto && elem =
_assembly[tid][0]->elem();
4134 unsigned int side =
_assembly[tid][0]->side();
4143 unsigned int neighbor_side =
4157 neighbor_side =
_assembly[tid][0]->side();
4158 mooseAssert(neighbor,
"We should have an appropriate value for elem coming from Assembly");
4169 const std::string & name,
4170 const std::string & type,
4174 _console <<
"[DBG] Adding " << system <<
" '" <<
name <<
"' of type " <<
type << std::endl;
4181 const std::string & object_name,
4182 const std::string & var_param_name)
4188 unsigned int sys_num = 0;
4200 if (sys_num ==
_aux->number())
4216 if (sys_num ==
_aux->number())
4225 const std::string & name,
4232 "\" already exists. You may not add a Postprocessor by the same name.");
4239 const std::string & name,
4246 "\" already exists. You may not add a VectorPostprocessor by the same name.");
4253 const std::string & name,
4259 "\" already exists. You may not add a Reporter by the same name.");
4264 std::vector<std::shared_ptr<UserObject>>
4266 const std::string & name,
4269 parallel_object_only();
4271 std::vector<std::shared_ptr<UserObject>> uos;
4279 std::shared_ptr<UserObject> user_object =
4282 uos.push_back(user_object);
4285 user_object->setPrimaryThreadCopy(uos[0].
get());
4306 if (euo || nuo || duo)
4308 else if (suo || duo)
4311 else if (iuob || duo)
4316 if ((guo && !tguo) || muo)
4325 const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
4340 std::vector<UserObject *> objs;
4344 .condition<AttribThread>(tid)
4348 mooseError(
"Unable to find user object with name '" +
name +
"'");
4349 mooseAssert(objs.size() == 1,
"Should only find one UO");
4356 std::vector<Positions *> objs;
4360 .condition<AttribName>(
name)
4363 mooseError(
"Unable to find Positions object with name '" +
name +
"'");
4364 mooseAssert(objs.size() == 1,
"Should only find one Positions");
4371 std::vector<UserObject *> objs;
4375 .condition<AttribThread>(0)
4378 return !objs.empty();
4389 std::size_t t_index)
const 4398 std::size_t t_index)
4407 mooseDeprecated(
"FEProblemBase::hasPostprocssor is being removed; use " 4408 "hasPostprocessorValueByName instead.");
4414 const std::string & vector_name,
4415 std::size_t t_index)
const 4423 const std::string & vector_name,
4425 std::size_t t_index)
4435 return getUserObject<VectorPostprocessor>(object_name, tid);
4443 const auto & objects = it.second.getActiveObjects();
4444 for (
const auto & obj : objects)
4445 obj->parentOutputPositionChanged();
4462 TIME_SECTION(
"computeIndicators", 1,
"Computing Indicators");
4466 const auto old_do_derivatives = ADReal::do_derivatives;
4467 ADReal::do_derivatives =
false;
4469 std::vector<std::string>
fields;
4473 for (
const auto & indicator : indicators)
4474 fields.push_back(indicator->name());
4478 for (
const auto & internal_indicator : internal_indicators)
4479 fields.push_back(internal_indicator->name());
4486 _aux->solution().close();
4491 _aux->solution().close();
4494 ADReal::do_derivatives = old_do_derivatives;
4503 TIME_SECTION(
"computeMarkers", 1,
"Computing Markers");
4505 std::vector<std::string>
fields;
4509 for (
const auto & marker : markers)
4510 fields.push_back(marker->name());
4519 for (
const auto & marker : markers)
4520 marker->markerSetup();
4526 _aux->solution().close();
4563 _aux->customSetup(exec_type);
4564 for (
auto & nl :
_nl)
4565 nl->customSetup(exec_type);
4577 std::vector<UserObject *> userobjs;
4579 for (
auto obj : userobjs)
4580 obj->customSetup(exec_type);
4632 std::unique_ptr<NumericVector<Number>> x =
_aux->currentSolution()->clone();
4640 const Real check_tol = 1e-8;
4642 const Real xnorm = x->l2_norm();
4643 *x -= *
_aux->currentSolution();
4644 if (x->l2_norm() > check_tol * xnorm)
4646 const auto & sys =
_aux->system();
4647 const unsigned int n_vars = sys.n_vars();
4648 std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4652 ordered_map.emplace(vnorm, sys.variable_name(i));
4655 std::ostringstream oss;
4656 for (
const auto & [error_norm, var_name] : ordered_map)
4657 oss <<
" {" << var_name <<
", " << error_norm <<
"},\n";
4659 mooseError(
"Aux kernels, user objects appear to have states for aux variables on ",
4661 ".\nVariable error norms in descending order:\n",
4666 if (pp_values.
size() != new_pp_values.
size())
4667 mooseError(
"Second execution for uo/aux state check should not change the number of " 4668 "real reporter values");
4671 pp_values -= new_pp_values;
4672 if (pp_values.
l2_norm() > check_tol * ppnorm)
4675 std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4677 ordered_map.emplace(
std::abs(pp_values(i)), pp_names[i]);
4679 std::ostringstream oss;
4680 for (
const auto & [error_norm, pp_name] : ordered_map)
4681 oss <<
" {" << pp_name <<
", " << error_norm <<
"},\n";
4683 mooseError(
"Aux kernels, user objects appear to have states for real reporter values on ",
4685 ".\nErrors of real reporter values in descending order:\n",
4695 std::vector<UserObject *> objs;
4696 query.queryInto(objs);
4701 for (
auto obj : objs)
4702 if (obj->primaryThreadCopy())
4703 obj->primaryThreadCopy()->threadJoin(*obj);
4709 for (
auto obj : objs)
4711 if (isgen && dynamic_cast<ThreadedGeneralUserObject *>(obj))
4717 _console <<
"[DBG] Initializing, executing & finalizing general UO '" << obj->name()
4742 auto reporter =
dynamic_cast<Reporter *
>(obj);
4751 const std::string & name)
4758 .condition<AttribExecOns>(
type)
4779 TIME_SECTION(
"computeUserObjects", 1,
"Computing User Objects");
4790 std::vector<UserObject *> uos;
4792 std::set<int> execution_groups;
4793 for (
const auto & uo : uos)
4794 execution_groups.insert(uo->getParam<
int>(
"execution_order_group"));
4797 for (
const auto execution_group : execution_groups)
4801 std::vector<GeneralUserObject *> genobjs;
4804 std::vector<UserObject *> userobjs;
4810 .queryInto(userobjs);
4812 std::vector<UserObject *> tgobjs;
4817 std::vector<UserObject *> nodal;
4820 std::vector<MortarUserObject *> mortar;
4823 if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
4832 for (
auto obj : userobjs)
4833 obj->residualSetup();
4834 for (
auto obj : nodal)
4835 obj->residualSetup();
4836 for (
auto obj : mortar)
4837 obj->residualSetup();
4838 for (
auto obj : tgobjs)
4839 obj->residualSetup();
4840 for (
auto obj : genobjs)
4841 obj->residualSetup();
4845 for (
auto obj : userobjs)
4846 obj->jacobianSetup();
4847 for (
auto obj : nodal)
4848 obj->jacobianSetup();
4849 for (
auto obj : mortar)
4850 obj->jacobianSetup();
4851 for (
auto obj : tgobjs)
4852 obj->jacobianSetup();
4853 for (
auto obj : genobjs)
4854 obj->jacobianSetup();
4857 for (
auto obj : userobjs)
4861 if (!userobjs.empty())
4880 for (
const auto & uo : userobjs)
4881 if (
auto euo = dynamic_cast<const ElementUserObject *>(uo);
4882 euo && euo->hasWritableCoupledVariables())
4884 _aux->solution().close();
4885 _aux->system().update();
4893 for (
auto obj : nodal)
4903 for (
const auto & uo : nodal)
4904 if (
auto nuo = dynamic_cast<const NodalUserObject *>(uo);
4905 nuo && nuo->hasWritableCoupledVariables())
4907 _aux->solution().close();
4908 _aux->system().update();
4914 for (
auto obj : mortar)
4916 if (!mortar.empty())
4918 auto create_and_run_mortar_functors = [
this,
type, &mortar](
const bool displaced)
4922 for (
const auto & mortar_interface : mortar_interfaces)
4924 const auto primary_secondary_boundary_pair = mortar_interface.first;
4925 auto mortar_uos_to_execute =
4927 primary_secondary_boundary_pair.second,
4930 const auto & mortar_generation_object = mortar_interface.second;
4932 auto *
const subproblem = displaced
4934 : static_cast<SubProblem *>(
this);
4936 mortar_generation_object,
4940 subproblem->assembly(0, 0));
4946 create_and_run_mortar_functors(
false);
4948 create_and_run_mortar_functors(
true);
4950 for (
auto obj : mortar)
4955 for (
auto obj : tgobjs)
4957 std::vector<GeneralUserObject *> tguos_zero;
4961 .queryInto(tguos_zero);
4962 for (
auto obj : tguos_zero)
4964 std::vector<GeneralUserObject *> tguos;
4965 auto q =
query.clone()
4991 TIME_SECTION(
"executeControls", 1,
"Executing Controls");
4997 for (
const auto & it : controls_wh.getActiveObjects())
5002 std::vector<std::string> & dependent_controls = it->getDependencies();
5003 for (
const auto & depend_name : dependent_controls)
5005 if (controls_wh.hasActiveObject(depend_name))
5007 auto dep_control = controls_wh.getActiveObject(depend_name);
5008 resolver.
addEdge(dep_control, it);
5013 "\" was not created, did you make a " 5014 "spelling mistake or forget to include it " 5015 "in your input file?");
5021 if (!ordered_controls.empty())
5025 for (
const auto & control : ordered_controls)
5038 std::vector<Sampler *> objects;
5042 .condition<AttribThread>(tid)
5044 .queryInto(objects);
5046 if (!objects.empty())
5048 TIME_SECTION(
"executeSamplers", 1,
"Executing Samplers");
5049 FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
5050 FEProblemBase::objectExecuteHelper<Sampler>(objects);
5058 TIME_SECTION(
"updateActiveObjects", 5,
"Updating Active Objects");
5062 for (
auto & nl :
_nl)
5063 nl->updateActive(tid);
5064 _aux->updateActive(tid);
5091 TIME_SECTION(
"reinitBecauseOfGhostingOrNewGeomObjects",
5093 "Reinitializing Because of Geometric Search Objects");
5117 const std::string & name,
5120 parallel_object_only();
5122 const auto nl_sys_num =
5128 mooseError(
"You are trying to add a DGKernel to a linear variable/system, which is not " 5129 "supported at the moment!");
5142 for (
auto & nl :
_nl)
5148 const std::string & name,
5151 parallel_object_only();
5177 std::shared_ptr<Indicator> indicator =
5180 std::shared_ptr<InternalSideIndicatorBase> isi =
5191 const std::string & name,
5194 parallel_object_only();
5228 const std::string & name,
5231 parallel_object_only();
5260 multi_app->setupPositions();
5265 std::shared_ptr<TransientMultiApp> trans_multi_app =
5267 if (trans_multi_app)
5283 std::shared_ptr<MultiApp>
5294 std::string string_direction;
5296 string_direction =
" To ";
5297 else if (from_multiapp)
5298 string_direction =
" From ";
5300 string_direction =
" Between ";
5308 TIME_SECTION(
"execMultiAppTransfers", 1,
"Executing Transfers");
5315 <<
"MultiApps" << COLOR_DEFAULT <<
":" << std::endl;
5318 {
"Name",
"Type",
"From",
"To"});
5321 for (
const auto & transfer : transfers)
5325 table.addRow(multiapp_transfer->name(),
5326 multiapp_transfer->type(),
5327 multiapp_transfer->getFromName(),
5328 multiapp_transfer->getToName());
5335 for (
const auto & transfer : transfers)
5338 transfer->execute();
5345 << COLOR_DEFAULT << std::endl;
5352 << COLOR_DEFAULT << std::endl;
5356 std::vector<std::shared_ptr<Transfer>>
5367 std::vector<std::shared_ptr<Transfer>>
5393 const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
5397 for (
const auto & multi_app : multi_apps)
5398 multi_app->preTransfer(
_dt,
_time);
5407 if (multi_apps.size())
5409 TIME_SECTION(
"execMultiApps", 1,
"Executing MultiApps",
false);
5413 << COLOR_DEFAULT << std::endl;
5415 bool success =
true;
5417 for (
const auto & multi_app : multi_apps)
5419 success = multi_app->solveStep(
_dt,
_time, auto_advance);
5434 << COLOR_DEFAULT << std::endl;
5449 for (
const auto & multi_app : multi_apps)
5450 multi_app->finalize();
5458 for (
const auto & multi_app : multi_apps)
5459 multi_app->postExecute();
5467 if (multi_apps.size())
5468 for (
const auto & multi_app : multi_apps)
5469 multi_app->incrementTStep(
_time);
5477 if (multi_apps.size())
5480 _console << COLOR_CYAN <<
"\nAdvancing MultiApps on " <<
type.name() << COLOR_DEFAULT
5483 for (
const auto & multi_app : multi_apps)
5484 multi_app->finishStep(recurse_through_multiapp_levels);
5489 _console << COLOR_CYAN <<
"Finished Advancing MultiApps on " <<
type.name() <<
"\n" 5490 << COLOR_DEFAULT << std::endl;
5499 if (multi_apps.size())
5501 TIME_SECTION(
"backupMultiApps", 5,
"Backing Up MultiApp");
5504 _console << COLOR_CYAN <<
"\nBacking Up MultiApps on " <<
type.name() << COLOR_DEFAULT
5507 for (
const auto & multi_app : multi_apps)
5508 multi_app->backup();
5513 _console << COLOR_CYAN <<
"Finished Backing Up MultiApps on " <<
type.name() <<
"\n" 5514 << COLOR_DEFAULT << std::endl;
5523 if (multi_apps.size())
5528 _console << COLOR_CYAN <<
"\nRestoring Multiapps on " <<
type.name()
5529 <<
" because of solve failure!" << COLOR_DEFAULT << std::endl;
5531 _console << COLOR_CYAN <<
"\nRestoring MultiApps on " <<
type.name() << COLOR_DEFAULT
5535 for (
const auto & multi_app : multi_apps)
5536 multi_app->restore(force);
5541 _console << COLOR_CYAN <<
"Finished Restoring MultiApps on " <<
type.name() <<
"\n" 5542 << COLOR_DEFAULT << std::endl;
5553 for (
const auto & multi_app : multi_apps)
5554 smallest_dt =
std::min(smallest_dt, multi_app->computeDT());
5564 TIME_SECTION(
"execTransfers", 3,
"Executing Transfers");
5568 for (
const auto & transfer : transfers)
5569 transfer->execute();
5575 const std::string & name,
5578 parallel_object_only();
5609 std::shared_ptr<MultiApp> multiapp;
5620 exec_enum = multiapp->getParam<
ExecFlagEnum>(
"execute_on");
5628 std::shared_ptr<MultiAppTransfer> multi_app_transfer =
5630 if (multi_app_transfer)
5647 if (sys->hasVariable(var_name))
5649 if (
_aux->hasVariable(var_name))
5659 if (sys->hasVariable(var_name))
5667 const std::string & var_name,
5679 if (sys->hasVariable(var_name))
5680 return sys->getFieldVariable<
Real>(tid, var_name);
5681 if (
_aux->hasVariable(var_name))
5682 return _aux->getFieldVariable<
Real>(tid, var_name);
5691 if (sys->hasVariable(var_name))
5692 return sys->getActualFieldVariable<
Real>(tid, var_name);
5693 if (
_aux->hasVariable(var_name))
5694 return _aux->getActualFieldVariable<
Real>(tid, var_name);
5703 if (sys->hasVariable(var_name))
5705 if (
_aux->hasVariable(var_name))
5715 if (sys->hasVariable(var_name))
5717 if (
_aux->hasVariable(var_name))
5727 if (sys->hasScalarVariable(var_name))
5729 if (
_aux->hasScalarVariable(var_name))
5739 if (sys->hasScalarVariable(var_name))
5740 return sys->getScalarVariable(tid, var_name);
5741 if (
_aux->hasScalarVariable(var_name))
5742 return _aux->getScalarVariable(tid, var_name);
5753 else if (
_aux->hasVariable(var_name) ||
_aux->hasScalarVariable(var_name))
5754 return _aux->system();
5756 mooseError(
"Unable to find a system containing the variable " + var_name);
5858 mat->setActiveProperties(mat_prop_ids);
5860 mat->setActiveProperties(mat_prop_ids);
5862 mat->setActiveProperties(mat_prop_ids);
5882 #ifdef LIBMESH_ENABLE_AMR 5892 const std::string & redistributer_name,
5893 const bool use_displaced_mesh)
5897 redistribute_params.
set<std::string>(
"for_whom") = this->
name();
5901 redistribute_params.
set<
bool>(
"use_displaced_mesh") = use_displaced_mesh;
5904 std::shared_ptr<RedistributeProperties> redistributer =
5906 "RedistributeProperties", redistributer_name, redistribute_params);
5920 add_redistributer(
_mesh,
"mesh_property_redistributer",
false);
5922 add_redistributer(
_displaced_problem->mesh(),
"displaced_mesh_property_redistributer",
true);
5924 #endif // LIBMESH_ENABLE_AMR 5944 mooseError(
"Max quadrature points per element assumptions made in some code (e.g. Coupleable ",
5945 "and MaterialPropertyInterface classes) have been violated.\n",
5946 "Complain to Moose developers to have constMaxQpsPerElem increased from ",
5954 _zero[tid].resize(max_qpts, 0);
5997 const bool allow_negative_qweights)
6006 if (order < _aux->getMinQuadratureOrder())
6007 order =
_aux->getMinQuadratureOrder();
6011 volume_order = order;
6019 type, order, volume_order, face_order, block, allow_negative_qweights);
6023 type, order, volume_order, face_order, block, allow_negative_qweights);
6034 mooseError(
"Someone told us (the FEProblemBase) to trust the user coupling matrix, but we " 6035 "haven't been provided a coupling matrix!");
6056 _cm[i] = std::move(cm);
6063 mooseError(
"Someone told us (the FEProblemBase) to trust the user coupling matrix, but we " 6064 "haven't been provided a coupling matrix!");
6072 TIME_SECTION(
"setNonlocalCouplingMatrix", 5,
"Setting Nonlocal Coupling Matrix");
6075 mooseError(
"Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support " 6076 "multiple nonlinear systems with nonlocal kernels.");
6080 auto & nl =
_nl[nl_sys_num];
6082 unsigned int n_vars = nl->nVariables();
6083 nonlocal_cm.resize(
n_vars);
6084 const auto &
vars = nl->getVariables(0);
6087 for (
const auto & ivar :
vars)
6089 for (
const auto & kernel : nonlocal_kernel)
6091 for (
unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6092 if (i == kernel->variable().number())
6093 for (
const auto & jvar :
vars)
6098 unsigned int j = jvar->number();
6099 nonlocal_cm(i, j) = 1;
6103 for (
const auto & integrated_bc : nonlocal_integrated_bc)
6105 for (
unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6106 if (i == integrated_bc->variable().number())
6107 for (
const auto & jvar :
vars)
6112 unsigned int j = jvar->number();
6113 nonlocal_cm(i, j) = 1;
6123 const unsigned int jvar,
6124 const unsigned int nl_sys)
const 6126 return (*
_cm[nl_sys])(ivar, jvar);
6129 std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
6132 return _assembly[tid][nl_sys]->couplingEntries();
6135 std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
6138 return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
6147 TIME_SECTION(
"init", 2,
"Initializing");
6163 unsigned int n_vars = nl->nVariables();
6165 TIME_SECTION(
"fillCouplingMatrix", 3,
"Filling Coupling Matrix");
6170 cm = std::make_unique<CouplingMatrix>(
n_vars);
6171 for (
unsigned int i = 0; i <
n_vars; i++)
6177 cm = std::make_unique<CouplingMatrix>(
n_vars);
6178 for (
unsigned int i = 0; i <
n_vars; i++)
6179 for (
unsigned int j = 0; j <
n_vars; j++)
6189 nl->dofMap()._dof_coupling = cm.get();
6195 nl->dofMap()._dof_coupling =
nullptr;
6197 nl->dofMap().attach_extra_sparsity_function(&
extraSparsity, nl.get());
6198 nl->dofMap().attach_extra_send_list_function(&
extraSendList, nl.get());
6202 mooseError(
"No variables specified in nonlinear system '", nl->name(),
"'.");
6224 for (
auto & nl :
_nl)
6226 nl->turnOffJacobian();
6244 TIME_SECTION(
"EquationSystems::Init", 2,
"Initializing Equation Systems");
6266 "Coupling matrix not set for system " 6268 <<
". This should only happen if a preconditioner was not setup for this system");
6281 std::istringstream ss(nl_sys_name);
6282 unsigned int nl_sys_num;
6283 if (!(ss >> nl_sys_num) || !ss.eof())
6292 std::istringstream ss(linear_sys_name);
6293 unsigned int linear_sys_num;
6294 if (!(ss >> linear_sys_num) || !ss.eof())
6297 return linear_sys_num;
6303 std::istringstream ss(solver_sys_name);
6304 unsigned int solver_sys_num;
6305 if (!(ss >> solver_sys_num) || !ss.eof())
6309 mooseError(
"The solver system number was requested for system '" + solver_sys_name,
6310 "' but this system does not exist in the Problem. Systems can be added to the " 6311 "problem using the 'nl_sys_names' parameter.\nSystems in the Problem: " +
6313 solver_sys_num = search->second;
6316 return solver_sys_num;
6323 if (solver_sys->hasVariable(variable_name))
6324 return solver_sys->number();
6325 mooseAssert(
_aux,
"Should have an auxiliary system");
6326 if (
_aux->hasVariable(variable_name))
6327 return _aux->number();
6331 "' was not found in any solver (nonlinear/linear) or auxiliary system");
6337 TIME_SECTION(
"solve", 1,
"Solving",
false);
6351 #if PETSC_RELEASE_LESS_THAN(3, 12, 0) 6390 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 6392 LibmeshPetscCall(PetscOptionsPop());
6409 TIME_SECTION(
"checkExceptionAndStopSolve", 5);
6430 <<
"To recover, the solution will fail and then be re-attempted with a reduced time " 6445 _aux->solution().close();
6459 mooseError(
"The following parallel-communicated exception was detected during " +
6462 "\nBecause this did not occur during residual evaluation, there" 6463 " is no way to handle this, so the solution is aborting.\n");
6471 ADReal::do_derivatives =
true;
6496 TIME_SECTION(
"solve", 1,
"Solving",
false);
6506 #if PETSC_RELEASE_LESS_THAN(3, 12, 0) 6508 options, solver_params));
6526 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 6528 LibmeshPetscCall(PetscOptionsPop());
6544 return _nl[nl_sys_num]->nNonlinearIterations();
6550 return _nl[nl_sys_num]->nLinearIterations();
6556 return _nl[nl_sys_num]->finalNonlinearResidual();
6562 return _nl[nl_sys_num]->computingPreSMOResidual();
6568 TIME_SECTION(
"copySolutionsBackwards", 3,
"Copying Solutions Backward");
6571 sys->copySolutionsBackwards();
6572 _aux->copySolutionsBackwards();
6578 TIME_SECTION(
"advanceState", 5,
"Advancing State");
6581 sys->copyOldSolutions();
6582 _aux->copyOldSolutions();
6608 TIME_SECTION(
"restoreSolutions", 5,
"Restoring Solutions");
6613 _console <<
"Restoring solutions on system " << sys->name() <<
"..." << std::endl;
6614 sys->restoreSolutions();
6618 _console <<
"Restoring solutions on Auxiliary system..." << std::endl;
6619 _aux->restoreSolutions();
6622 _console <<
"Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
6632 TIME_SECTION(
"saveOldSolutions", 5,
"Saving Old Solutions");
6635 sys->saveOldSolutions();
6636 _aux->saveOldSolutions();
6642 TIME_SECTION(
"restoreOldSolutions", 5,
"Restoring Old Solutions");
6645 sys->restoreOldSolutions();
6646 _aux->restoreOldSolutions();
6652 TIME_SECTION(
"outputStep", 1,
"Outputting");
6689 TIME_SECTION(
"onTimestepBegin", 2);
6691 for (
auto & nl :
_nl)
6692 nl->onTimestepBegin();
6708 switch (state.
state)
6717 mooseError(
"Unhandled state ", state.
state,
" in FEProblemBase::getTimeFromStateArg");
6723 const std::string & name,
6726 parallel_object_only();
6738 _aux->addDotVectors();
6739 for (
auto & nl :
_nl)
6741 nl->addDotVectors();
6743 auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
6744 if (!nl->hasVector(tag_udot))
6745 nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
6746 auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
6748 nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
6758 const std::string & name,
6761 parallel_object_only();
6764 mooseError(
"Vector bounds cannot be used with LinearSystems!");
6770 for (
auto & nl :
_nl)
6771 nl->setPredictor(predictor);
6795 residual->scale(-1.0);
6797 return residual->l2_norm();
6803 TIME_SECTION(
"computeResidualL2Norm", 2,
"Computing L2 Norm of Residual");
6807 for (
auto sys :
_nl)
6827 parallel_object_only();
6829 TIME_SECTION(
"computeResidualSys", 5);
6847 const unsigned int nl_sys_num)
6856 mooseAssert(
_fe_vector_tags.empty(),
"This should be empty indicating a clean starting state");
6879 "This should be empty indicating a clean starting state");
6891 for (
auto & tag : tags)
6909 for (
auto index :
make_range(matrix.row_start(), matrix.row_stop()))
6910 matrix.add(index, index, 0);
6913 _aux->zeroVariablesForResidual();
6937 for (
unsigned int tid = 0; tid <
n_threads; tid++)
6942 _aux->residualSetup();
7019 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7020 "contact the MOOSE team for assistance.");
7027 const std::set<TagID> & tags)
7029 parallel_object_only();
7031 TIME_SECTION(
"computeResidualInternal", 1);
7052 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7053 "contact the MOOSE team for assistance.");
7062 TIME_SECTION(
"computeResidualType", 5);
7083 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7084 "contact the MOOSE team for assistance.");
7091 auto create_exception_message =
7092 [&calling_method](
const std::string & exception_type,
const auto & exception)
7094 return std::string(
"A " + exception_type +
" was raised during FEProblemBase::" +
7095 calling_method +
"\n" + std::string(exception.what()));
7104 setException(create_exception_message(
"libMesh::LogicError", e));
7108 setException(create_exception_message(
"MooseException", e));
7110 catch (
const MetaPhysicL::LogicError & e)
7126 mooseError(create_exception_message(
"libMesh::PetscSolverException", e));
7128 catch (
const std::exception & e)
7130 const auto message = create_exception_message(
"std::exception", e);
7143 parallel_object_only();
7149 TIME_SECTION(
"computeResidualTags", 5,
"Computing Residual");
7151 ADReal::do_derivatives =
false;
7155 _aux->zeroVariablesForResidual();
7169 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7174 _aux->residualSetup();
7245 const unsigned int nl_sys_num)
7252 for (
auto & tag : tags)
7261 const std::set<TagID> & tags)
7263 TIME_SECTION(
"computeJacobianInternal", 1);
7283 TIME_SECTION(
"computeJacobianTags", 5,
"Computing Jacobian");
7285 for (
auto tag : tags)
7297 for (
auto index :
make_range(matrix.row_start(), matrix.row_stop()))
7298 matrix.add(index, index, 0);
7301 _aux->zeroVariablesForJacobian();
7317 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7322 _aux->jacobianSetup();
7330 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7377 const unsigned int nl_sys_num)
7379 TIME_SECTION(
"computeTransientImplicitJacobian", 2);
7401 JacobianBlock jac_block(precond_system, jacobian, ivar, jvar);
7402 std::vector<JacobianBlock *>
blocks = {&jac_block};
7417 "I expect these system numbers to be the same");
7422 TIME_SECTION(
"computeBounds", 1,
"Computing Bounds");
7431 _aux->residualSetup();
7455 const bool compute_gradients)
7457 TIME_SECTION(
"computeLinearSystemSys", 5);
7490 const std::set<TagID> & vector_tags,
7491 const std::set<TagID> & matrix_tags,
7492 const bool compute_gradients)
7494 TIME_SECTION(
"computeLinearSystemTags", 5,
"Computing Linear System");
7498 for (
auto tag : matrix_tags)
7517 _aux->jacobianSetup();
7530 _console <<
"\nA MooseException was raised during Auxiliary variable computation.\n" 7531 <<
"The next solve will fail, the timestep will be reduced, and we will try again.\n" 7561 "I expect these system numbers to be the same");
7564 for (
unsigned int i = 0; i <
subspaceDim(
"NearNullSpace"); ++i)
7566 std::stringstream postfix;
7567 postfix <<
"_" << i;
7568 std::string modename =
"NearNullSpace" + postfix.str();
7578 "I expect these system numbers to be the same");
7580 for (
unsigned int i = 0; i <
subspaceDim(
"NullSpace"); ++i)
7582 std::stringstream postfix;
7583 postfix <<
"_" << i;
7593 "I expect these system numbers to be the same");
7595 for (
unsigned int i = 0; i <
subspaceDim(
"TransposeNullSpace"); ++i)
7597 std::stringstream postfix;
7598 postfix <<
"_" << i;
7608 bool & changed_search_direction,
7609 bool & changed_new_soln)
7612 "I expect these system numbers to be the same");
7623 TIME_SECTION(
"computePostCheck", 2,
"Computing Post Check");
7638 std::unique_ptr<NumericVector<Number>> ghosted_solution =
7640 ghosted_search_direction =
7644 *ghosted_solution = new_soln;
7645 *ghosted_search_direction = search_direction;
7656 new_soln = old_soln;
7657 new_soln.
add(-damping, search_direction);
7658 changed_new_soln =
true;
7665 if (changed_new_soln)
7666 *ghosted_solution = new_soln;
7668 bool updated_solution =
updateSolution(new_soln, *ghosted_solution);
7669 if (updated_solution)
7670 changed_new_soln =
true;
7677 _aux->copyCurrentIntoPreviousNL();
7681 changed_search_direction =
false;
7695 TIME_SECTION(
"computeDamping", 1,
"Computing Damping");
7736 parallel_object_only();
7745 TIME_SECTION(
"updateGeometricSearch", 3,
"Updating Geometric Search");
7756 TIME_SECTION(
"updateMortarMesh", 5,
"Updating Mortar Mesh");
7765 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
7766 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
7770 const bool correct_edge_dropping,
7771 const Real minimum_projection_angle)
7777 primary_secondary_subdomain_pair,
7782 correct_edge_dropping,
7783 minimum_projection_angle);
7786 primary_secondary_subdomain_pair,
7791 correct_edge_dropping,
7792 minimum_projection_angle);
7797 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
7798 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
7799 bool on_displaced)
const 7802 primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
7807 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
7808 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
7812 primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
7826 TIME_SECTION(
"possiblyRebuildGeomSearchPatches", 5,
"Rebuilding Geometric Search Patches");
7860 libmesh_fallthrough();
7866 _console <<
"\n\nUpdating geometric search patches\n" << std::endl;
7882 #ifdef LIBMESH_ENABLE_AMR 7891 mooseError(
"HFEM does not support mesh adaptivity currently.");
7893 TIME_SECTION(
"initialAdaptMesh", 2,
"Performing Initial Adaptivity");
7895 for (
unsigned int i = 0; i < n; i++)
7912 _console <<
"Mesh unchanged, skipping remaining steps..." << std::endl;
7928 TIME_SECTION(
"adaptMesh", 3,
"Adapting Mesh");
7932 bool mesh_changed =
false;
7934 for (
unsigned int i = 0; i < cycles_per_step; ++i)
7937 mooseError(
"HFEM does not support mesh adaptivity currently.");
7943 bool mesh_changed_this_step;
7946 if (mesh_changed_this_step)
7948 mesh_changed =
true;
7961 _console <<
"Mesh unchanged, skipping remaining steps..." << std::endl;
7977 return mesh_changed;
7979 #endif // LIBMESH_ENABLE_AMR 7993 data[tid] = &storage.getMaterialData(tid);
8000 for (
unsigned int i = 0; i <
n_threads; ++i)
8012 TIME_SECTION(
"updateMeshXFEM", 5,
"Updating XFEM");
8014 bool updated =
false;
8017 if (
_xfem->updateHeal())
8022 false,
true,
false);
8028 false,
true,
false);
8038 const bool contract_mesh,
8039 const bool clean_refinement_flags)
8041 TIME_SECTION(
"meshChanged", 3,
"Handling Mesh Changes");
8059 if (intermediate_change)
8067 if (clean_refinement_flags)
8075 if (!intermediate_change)
8138 Threads::parallel_reduce(range, pmp);
8146 for (
const auto & elem : range)
8159 Threads::parallel_reduce(range, pmp);
8163 for (
const auto & elem : range)
8166 for (
auto && child : coarsened_children)
8202 mdi->meshDisplaced();
8211 Threads::parallel_reduce(elem_range, cmt);
8213 cmt(elem_range,
true);
8219 TIME_SECTION(
"checkProblemIntegrity", 5);
8228 std::set<SubdomainID>
blocks;
8231 blocks = mesh_subdomains;
8234 blocks = mesh_subdomains;
8240 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8250 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8254 for (
auto & nl :
_nl)
8255 nl->checkKernelCoverage(
blocks);
8260 #ifdef LIBMESH_ENABLE_AMR 8265 _console <<
"Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n" 8270 std::set<SubdomainID> local_mesh_subs(mesh_subdomains);
8279 bool check_material_coverage =
false;
8281 for (
const auto &
id : ids)
8283 local_mesh_subs.erase(
id);
8284 check_material_coverage =
true;
8295 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8296 local_mesh_subs.erase(
id);
8301 std::set<SubdomainID>
blocks(local_mesh_subs);
8307 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8310 for (
const auto id :
blocks)
8311 local_mesh_subs.erase(
id);
8316 for (
auto subdomain_id : mortar_subdomain_ids)
8317 local_mesh_subs.erase(subdomain_id);
8320 if (check_material_coverage && !local_mesh_subs.empty())
8322 std::stringstream extra_subdomain_ids;
8324 std::copy(local_mesh_subs.begin(),
8325 local_mesh_subs.end(),
8326 std::ostream_iterator<unsigned int>(extra_subdomain_ids,
" "));
8328 std::vector<SubdomainID> local_mesh_subs_vec(local_mesh_subs.begin(),
8329 local_mesh_subs.end());
8331 mooseError(
"The following blocks from your input mesh do not contain an active material: " +
8332 extra_subdomain_ids.str() +
8334 ")\nWhen ANY mesh block contains a Material object, " 8335 "all blocks must contain a Material object.\n");
8345 for (
const auto & material : materials)
8346 material->checkStatefulSanity();
8366 mooseError(
"Coordinate transformation parameters, listed below, are only to be used in the " 8367 "context of application to application field transfers at this time. The mesh is " 8368 "not modified by these parameters within an application.\n" 8369 "You should likely use a 'TransformGenerator' in the [Mesh] block to achieve the " 8370 "desired mesh modification.\n\n",
8387 bool mesh_has_second_order_elements =
false;
8393 mesh_has_second_order_elements =
true;
8403 if (mesh_has_second_order_elements)
8405 const std::vector<std::string> & displacement_variables =
8408 for (
const auto & var_name : displacement_variables)
8416 mooseError(
"Error: mesh has SECOND order elements, so all displacement variables must be " 8428 std::set<SubdomainID> user_objects_blocks;
8432 std::set<std::string> names;
8434 std::vector<UserObject *> objects;
8437 for (
const auto & obj : objects)
8438 names.insert(obj->name());
8441 std::set<SubdomainID> difference;
8442 std::set_difference(user_objects_blocks.begin(),
8443 user_objects_blocks.end(),
8444 mesh_subdomains.begin(),
8445 mesh_subdomains.end(),
8446 std::inserter(difference, difference.end()));
8448 if (!difference.empty())
8450 std::ostringstream oss;
8451 oss <<
"One or more UserObjects is referencing a nonexistent block:\n";
8452 for (
const auto &
id : difference)
8460 const std::map<
SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map)
8462 for (
const auto & it : materials_map)
8465 std::set<std::string> block_depend_props, block_supplied_props;
8467 for (
const auto & mat1 : it.second)
8469 const std::set<std::string> & depend_props = mat1->getRequestedItems();
8470 block_depend_props.insert(depend_props.begin(), depend_props.end());
8472 auto & alldeps = mat1->getMatPropDependencies();
8473 for (
auto & dep : alldeps)
8475 block_depend_props.insert(*
name);
8478 for (
const auto & mat2 : it.second)
8480 const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
8481 block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
8490 std::set<std::string> difference;
8491 std::set_difference(block_depend_props.begin(),
8492 block_depend_props.end(),
8493 block_supplied_props.begin(),
8494 block_supplied_props.end(),
8495 std::inserter(difference, difference.end()));
8497 if (!difference.empty())
8499 std::ostringstream oss;
8500 oss <<
"One or more Material Properties were not supplied on block ";
8502 if (subdomain_name.length() > 0)
8503 oss << subdomain_name <<
" (" << it.first <<
")";
8507 for (
const auto &
name : difference)
8508 oss <<
name <<
"\n";
8514 for (
const auto & it : materials_map)
8516 const auto & materials = it.second;
8517 std::set<std::string> inner_supplied, outer_supplied;
8519 for (
const auto & outer_mat : materials)
8522 outer_supplied = outer_mat->getSuppliedItems();
8523 inner_supplied.clear();
8526 std::map<std::string, std::set<std::string>> prop_to_mat;
8527 for (
const auto &
name : outer_supplied)
8528 prop_to_mat[
name].insert(outer_mat->name());
8530 for (
const auto & inner_mat : materials)
8532 if (outer_mat == inner_mat)
8536 auto outer_mat_type = outer_mat->type();
8537 auto inner_mat_type = inner_mat->type();
8542 if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
8543 inner_mat_type != inner_mat->type())
8546 inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
8547 inner_mat->getSuppliedItems().end());
8549 for (
const auto & inner_supplied_name : inner_supplied)
8550 prop_to_mat[inner_supplied_name].insert(inner_mat->name());
8554 std::set<std::string> intersection;
8555 std::set_intersection(outer_supplied.begin(),
8556 outer_supplied.end(),
8557 inner_supplied.begin(),
8558 inner_supplied.end(),
8559 std::inserter(intersection, intersection.end()));
8561 if (!intersection.empty())
8563 std::ostringstream oss;
8564 oss <<
"The following material properties are declared on block " << it.first
8565 <<
" by multiple materials:\n";
8567 <<
"Material Objects\n";
8568 for (
const auto & outer_name : intersection)
8571 for (
const auto & inner_name : prop_to_mat[outer_name])
8572 oss << inner_name <<
" ";
8594 mooseInfo(
"Restart file ", file_name,
" is NOT being used since we are performing recovery.");
8600 mooseInfo(
"Using ", file_name,
" for restart.");
8604 std::vector<VariableName>
8607 std::vector<VariableName> names;
8611 const std::vector<VariableName> & var_names = sys->getVariableNames();
8612 names.insert(names.end(), var_names.begin(), var_names.end());
8615 const std::vector<VariableName> & aux_var_names =
_aux->getVariableNames();
8616 names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());
8625 "Solver system number '" << solver_sys_num <<
"' is out of bounds. We have '" 8642 auto random_data_ptr = insert_pair.first->second.get();
8652 bnd_mat_side_cache =
false;
8654 if (
_aux->needMaterialOnSide(bnd_id))
8656 bnd_mat_side_cache =
true;
8660 for (
auto & nl :
_nl)
8661 if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
8663 bnd_mat_side_cache =
true;
8674 bnd_mat_side_cache =
true;
8688 interface_mat_side_cache =
false;
8690 for (
auto & nl :
_nl)
8691 if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
8693 interface_mat_side_cache =
true;
8704 interface_mat_side_cache =
true;
8709 interface_mat_side_cache =
true;
8723 for (
auto & nl :
_nl)
8724 if (nl->needSubdomainMaterialOnSide(subdomain_id, tid))
8755 mooseError(
"Previous nonlinear solution is required but not added through " 8756 "Problem/previous_nl_solution_required=true");
8773 const std::string & object_name,
8776 parallel_object_only();
8783 mooseError(
"The name '", object_name,
"' is a reserved name for output objects");
8787 if (output_warehouse.
hasOutput(object_name))
8788 mooseError(
"An output object named '", object_name,
"' already exists");
8794 std::vector<std::string> exclude;
8795 if (object_type ==
"Console")
8797 exclude.push_back(
"execute_on");
8805 else if (object_type ==
"Checkpoint")
8806 exclude.push_back(
"execute_on");
8812 if (common && std::find(exclude.begin(), exclude.end(),
"execute_on") != exclude.
end() &&
8815 "'execute_on' parameter specified in [Outputs] block is ignored for object '" +
8817 "'.\nDefine this object in its own sub-block of [Outputs] to modify its " 8818 "execution schedule.");
8821 if (object_type ==
"XDR")
8823 else if (object_type ==
"XDA")
8827 if (object_name ==
"auto_recovery_checkpoint")
8865 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
8866 return *
_nl[sys_num];
8872 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
8873 return *
_nl[sys_num];
8880 "System number greater than the number of linear systems");
8888 "System number greater than the number of linear systems");
8896 "System number greater than the number of solver systems");
8904 "System number greater than the number of solver systems");
8923 parallel_object_only();
8967 const std::vector<Point> *
const pts,
8968 const std::vector<Real> *
const weights,
8980 unsigned int neighbor_side,
8982 const std::vector<Point> *
const pts,
8983 const std::vector<Real> *
const weights,
8996 std::vector<std::shared_ptr<MaterialBase>> & face_materials,
8997 std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
8998 std::set<MooseVariableFieldBase *> & variables,
9003 auto & this_face_mats =
9005 for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
9006 if (face_mat->ghostable())
9008 face_materials.push_back(face_mat);
9009 auto & var_deps = face_mat->getMooseVariableDependencies();
9010 for (
auto * var : var_deps)
9014 "Ghostable materials should only have finite volume variables coupled into them.");
9015 else if (face_mat->hasStatefulProperties())
9016 mooseError(
"Finite volume materials do not currently support stateful properties.");
9017 variables.insert(var);
9024 auto & this_neighbor_mats =
9026 for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
9027 if (neighbor_mat->ghostable())
9029 neighbor_materials.push_back(neighbor_mat);
9031 auto & var_deps = neighbor_mat->getMooseVariableDependencies();
9032 for (
auto * var : var_deps)
9036 "Ghostable materials should only have finite volume variables coupled into them.");
9037 else if (neighbor_mat->hasStatefulProperties())
9038 mooseError(
"Finite volume materials do not currently support stateful properties.");
9039 auto pr = variables.insert(var);
9040 mooseAssert(!pr.second,
9041 "We should not have inserted any new variables dependencies from our " 9042 "neighbor materials that didn't exist for our face materials");
9051 const unsigned int nqp,
9062 "There must be one convergence object per nonlinear system");
9072 const std::vector<ConvergenceName> &
9077 mooseError(
"The nonlinear system convergence name(s) have not been set.");
9092 paramError(
"linear_convergence",
"There must be one convergence object per linear system");
9096 const std::vector<ConvergenceName> &
9101 mooseError(
"The linear convergence name(s) have not been set.");
9104 const ConvergenceName &
9110 mooseError(
"The fixed point convergence name has not been set.");
9121 _nl[i]->residualSetup();
9135 _nl[i]->jacobianSetup();
9155 return current_nl_sys_num;
9166 return current_linear_sys_num;
9183 std::vector<MortarUserObject *>
9186 const bool displaced,
9187 const std::vector<MortarUserObject *> & mortar_uo_superset)
9189 std::vector<MortarUserObject *> mortar_uos;
9191 : static_cast<SubProblem *>(
this);
9192 for (
auto *
const obj : mortar_uo_superset)
9193 if (obj->onInterface(primary_boundary_id, secondary_boundary_id) &&
9194 (&obj->getSubProblem() == subproblem))
9195 mortar_uos.push_back(obj);
9200 std::vector<MortarUserObject *>
9203 const bool displaced)
9205 std::vector<MortarUserObject *> mortar_uos;
9209 .queryInto(mortar_uos);
9210 return getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced, mortar_uos);
9216 const bool displaced)
9218 const auto mortar_uos =
9220 for (
auto *
const mortar_uo : mortar_uos)
9222 mortar_uo->setNormals();
9223 mortar_uo->reinit();
9255 mooseAssert(nl_sys_num <
_nl.size(),
9256 "System number greater than the number of nonlinear systems");
9265 "System number greater than the number of linear systems");
9278 solver_sys->compute(
type);
9360 return solver_params;
bool _reinit_displaced_elem
Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.
This class determines the maximum number of Quadrature Points and Shape Functions used for a given si...
virtual void addInterfaceMaterial(const std::string &material_name, const std::string &name, InputParameters ¶meters)
std::map< NonlinearSystemName, unsigned int > _nl_sys_name_to_num
Map from nonlinear system name to number.
void setCurrentAlgebraicElementRange(libMesh::ConstElemRange *range)
These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes tha...
std::string indent(unsigned int spaces)
Create empty string for indenting.
std::vector< Point > _point_zero
Interface for objects that need parallel consistent random numbers without patterns over the course o...
void updateVariableDependency(std::set< MooseVariableFieldBase *> &needed_moose_vars, THREAD_ID tid=0) const
Update variable dependency vector.
virtual void addCachedResidual(const THREAD_ID tid)
virtual void computeJacobianTag(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
Form a Jacobian matrix for a given tag.
void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
unsigned short getCurrentICState()
Retrieves the current initial condition state.
virtual void addFVInitialCondition(const std::string &ic_name, const std::string &name, InputParameters ¶meters)
Add an initial condition for a finite volume variables.
bool adaptMesh(std::string marker_name=std::string())
Adapts the mesh based on the error estimator used.
void sort(THREAD_ID tid=0)
Sort the objects using the DependencyResolver.
virtual void addMaterialHelper(std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters ¶meters)
bool initialAdaptMesh()
Used during initial adaptivity.
virtual void residualSetup(THREAD_ID tid=0) const
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
virtual void stopSolve(const ExecFlagType &exec_flag, const std::set< TagID > &vector_tags_to_close) override
Quit the current solve as soon as possible.
bool hasInvalidSolutionError() const
Whether or not an invalid solution was encountered that was an error.
void setActiveMaterialProperties(const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)
Record and set the material properties required by the current computing thread.
const bool _regard_general_exceptions_as_errors
If we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling...
const std::size_t _num_nl_sys
The number of nonlinear systems.
void setVariableAllDoFMap(const std::vector< const MooseVariableFEBase *> &moose_vars)
void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
virtual void initPetscOutputAndSomeSolverSettings()
Reinitialize PETSc output for proper linear/nonlinear iteration display.
const std::vector< ConvergenceName > & getNonlinearConvergenceNames() const
Gets the nonlinear system convergence object name(s).
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
void timestepSetup() override
virtual void addSampler(const std::string &type, const std::string &name, InputParameters ¶meters)
The following functions will enable MOOSE to have the capability to import Samplers.
bool _skip_exception_check
If or not skip 'exception and stop solve'.
const std::vector< std::string > & get_global_var_names()
bool isFiniteVolumeInfoDirty() const
Helper class for holding the preconditioning blocks to fill.
virtual void restore_original_nonzero_pattern()
bool _reinit_displaced_neighbor
Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid)
void outputStep(ExecFlagType type)
Calls the outputStep method for each output object.
virtual void meshChanged()
Deprecated.
virtual void addDamper(const std::string &damper_name, const std::string &name, InputParameters ¶meters)
std::map< LinearSystemName, unsigned int > _linear_sys_name_to_num
Map from linear system name to number.
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid)
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
void getFVMatsAndDependencies(SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase >> &face_materials, std::vector< std::shared_ptr< MaterialBase >> &neighbor_materials, std::set< MooseVariableFieldBase *> &variables, const THREAD_ID tid)
Get the materials and variables potentially needed for FV.
std::vector< MooseArray< ADRealTensorValue > > _ad_second_zero
bool _have_ad_objects
AD flag indicating whether any AD objects have been added.
void shift()
Shift the material properties in time.
virtual void prepareFace(const Elem *elem, const THREAD_ID tid) override
Base class for function objects.
void setPreserveMatrixSparsityPattern(bool preserve)
Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian)...
void reinitBecauseOfGhostingOrNewGeomObjects(bool mortar_changed=false)
Call when it is possible that the needs for ghosted elements has changed.
void fill_data(std::map< processor_id_type, std::vector< std::set< unsigned int >>> &data, int M)
virtual void addTransfer(const std::string &transfer_name, const std::string &name, InputParameters ¶meters)
Add a Transfer to the problem.
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
A MultiMooseEnum object to hold "execute_on" flags.
static SolverParams makeLinearSolverParams()
Make basic solver params for linear solves.
bool _parallel_barrier_messaging
Whether or not information about how many transfers have completed is printed.
MooseVariableFieldBase & getVariableHelper(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
Helper function called by getVariable that handles the logic for checking whether Variables of the re...
virtual void addResidualLower(const THREAD_ID tid) override
A class for creating restricted objects.
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
virtual void addJacobianLowerD(const THREAD_ID tid) override
Factory & _factory
The Factory for building objects.
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid) override
MaterialPropertyStorage & _bnd_material_props
virtual void addGhostedElem(dof_id_type elem_id) override
Will make sure that all dofs connected to elem_id are ghosted to this processor.
void setNonlocalCouplingMatrix()
Set custom coupling matrix for variables requiring nonlocal contribution.
Threads::spin_mutex get_function_mutex
void initialSetup()
Calls the initialSetup function for each of the output objects.
virtual Real & time() const
virtual const char * what() const
Get out the error message.
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & couplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
const Variable & variable(unsigned int var) const
void checkDependMaterialsHelper(const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
Helper method for checking Material object dependency.
void extraSparsity(libMesh::SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz, void *context)
Free function used for a libMesh callback.
virtual void cacheResidualNeighbor(const THREAD_ID tid) override
ExecFlagType _current_execute_on_flag
Current execute_on flag.
const std::set< SubdomainID > & interiorLowerDBlocks() const
void clearCurrentResidualVectorTags()
Clear the current residual vector tag data structure.
bool hasActiveBlockObjects(THREAD_ID tid=0) const
QueryCache is a convenient way to construct and pass around (possible partially constructed) warehous...
std::shared_ptr< DisplacedProblem > displaced_problem
const unsigned int invalid_uint
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)
RelationshipManagerType
Main types of Relationship Managers.
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
unsigned int get_node_index(const Node *node_ptr) const
virtual void checkExceptionAndStopSolve(bool print_message=true)
Check to see if an exception has occurred on any processor and, if possible, force the solve to fail...
virtual void meshDisplaced()
Update data after a mesh displaced.
const std::set< BoundaryID > & getSubdomainBoundaryIds(const SubdomainID subdomain_id) const
Get the list of boundary ids associated with the given subdomain id.
void mooseDeprecated(Args &&... args) const
std::optional< ConvergenceName > _multiapp_fixed_point_convergence_name
MultiApp fixed point convergence name.
const std::string & name() const
MooseAppCoordTransform & coordTransform()
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
void setCurrentAlgebraicNodeRange(libMesh::ConstNodeRange *range)
void setResidualObjectParamsAndLog(const std::string &ro_name, const std::string &name, InputParameters ¶ms, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
Set the subproblem and system parameters for residual objects and log their addition.
const AutomaticMortarGeneration & getMortarInterface(const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &, bool on_displaced) const
Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and subdomain k...
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
Real computeDamping(const NumericVector< Number > &solution, const NumericVector< Number > &update)
Compute damping.
virtual void reinitNode(const Node *node, const THREAD_ID tid) override
virtual std::size_t numNonlinearSystems() const override
Base class for implementing interface user objects.
virtual void setPreviousNewtonSolution(const NumericVector< Number > &soln)
virtual void predictorCleanup(NumericVector< libMesh::Number > &ghosted_solution)
Perform cleanup tasks after application of predictor to solution vector.
virtual void prepare(const Elem *elem, const THREAD_ID tid) override
TagID rightHandSideVectorTag() const
virtual Elem * elemPtr(const dof_id_type i)
TagID systemMatrixTag() const override
Return the Matrix Tag ID for System.
NumericVector< Number > & solution()
bool hasObjects(THREAD_ID tid=0) const
Convenience functions for determining if objects exist.
bool _has_jacobian
Indicates if the Jacobian was computed.
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
Interface for objects acting when the mesh has been displaced.
static void uniformRefine(MooseMesh *mesh, unsigned int level=libMesh::invalid_uint)
Performs uniform refinement of the passed Mesh object.
bool _has_dampers
Whether or not this system has any Dampers associated with it.
MooseObjectWarehouse< InternalSideIndicatorBase > _internal_side_indicators
std::vector< SubdomainName > _kernel_coverage_blocks
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToActiveSemilocalElemMap()
If not already created, creates a map from every node to all active semilocal elements to which they ...
virtual Distribution & getDistribution(const std::string &name)
void swapBack(const Elem &elem, unsigned int side=0)
material properties for given element (and possible side)
bool _has_nonlocal_coupling
Indicates if nonlocal coupling is required/exists.
void setCurrentAlgebraicBndNodeRange(ConstBndNodeRange *range)
This is the base class for Samplers as used within the Stochastic Tools module.
Base class for predictors.
bool areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
Moose::LineSearchType _line_search
void setPostprocessorValueByName(const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
Set the value of a PostprocessorValue.
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid) override
virtual void postExecute()
Method called at the end of the simulation.
void reinit(bool reinit_for_derivative_reordering=false)
Fill out the VariableValue arrays from the system solution vector.
std::shared_ptr< CommandLine > commandLine() const
Get the command line.
unsigned int number() const
Get variable number coming from libMesh.
void eraseProperty(const Elem *elem)
Remove the property storage and element pointer from internal data structures Use this when elements ...
bool isSolverSystemNonlinear(const unsigned int sys_num)
Check if the solver system is nonlinear.
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
void joinAndFinalize(TheWarehouse::Query query, bool isgen=false)
bool hasInitialBackup() const
std::vector< MooseArray< ADRealVectorValue > > _ad_grad_zero
std::vector< SolverParams > _solver_params
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
void mooseInfo(Args &&... args) const
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
void updateActive(THREAD_ID tid=0) override
Updates the active objects storage.
virtual std::pair< bool, unsigned int > determineSolverSystem(const std::string &var_name, bool error_if_not_found=false) const override
Determine what solver system the provided variable name lies in.
std::unique_ptr< libMesh::ConstNodeRange > _current_algebraic_node_range
virtual void setActiveScalarVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid) override
void setCoupling(Moose::CouplingType type)
Set the coupling between variables TODO: allow user-defined coupling.
constexpr std::size_t constMaxQpsPerElem
This is used for places where we initialize some qp-sized data structures that would end up being siz...
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
unsigned int _cycles_completed
bool _currently_computing_jacobian
Flag to determine whether the problem is currently computing Jacobian.
virtual void reinitScalars(const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
fills the VariableValue arrays for scalar variables from the solution vector
const ExecFlagEnum & getExecuteOnEnum() const
Return the app level ExecFlagEnum, this contains all the available flags for the app.
virtual void init() override
void add(std::shared_ptr< MooseObject > obj)
add adds a new object to the warehouse and stores attributes/metadata about it for running queries/fi...
void translateMetaPhysicLError(const MetaPhysicL::LogicError &)
emit a relatively clear error message when we catch a MetaPhysicL logic error
virtual void getDiracElements(std::set< const Elem *> &elems) override
Fills "elems" with the elements that should be looped over for Dirac Kernels.
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFieldBase *> &moose_vars, const THREAD_ID tid)
Set the MOOSE variables to be reinited on each element.
void parentOutputPositionChanged()
Calls parentOutputPositionChanged() on all sub apps.
void setupDM()
Setup the PETSc DM object (when appropriate)
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid)
sets the current boundary ID in assembly
virtual void addInterfaceKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual void neighborSubdomainSetup(THREAD_ID tid=0) const
libMesh::LinearImplicitSystem & linearImplicitSystem()
Return a reference to the stored linear implicit system.
bool _is_petsc_options_inserted
If or not PETSc options have been added to database.
void setCurrentlyComputingResidual(bool currently_computing_residual) final
Set whether or not the problem is in the process of computing the residual.
virtual void addMaterial(const std::string &material_name, const std::string &name, InputParameters ¶meters)
virtual void lineSearch()
execute MOOSE line search
const std::vector< T > & getSortedValues()
This function also returns dependency resolved values but with a simpler single vector interface...
unsigned int getCyclesPerStep() const
Pull out the number of cycles_per_step previously set through the AdaptivityAction.
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid)
Set the current lower dimensional element.
const Elem * getLowerDElem(const Elem *, unsigned short int) const
Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensi...
NonlocalIntegratedBC is used for solving integral terms in integro-differential equations.
virtual bool checkNonlocalCouplingRequirement() const override
virtual bool uDotDotRequested()
Get boolean flag to check whether solution second time derivative needs to be stored.
void updateErrorVectors()
Update the ErrorVectors that have been requested through calls to getErrorVector().
unsigned short _current_ic_state
virtual void reinitNeighborPhys(const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
virtual TagID addVectorTag(const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
Create a Tag.
std::vector< MeshDisplacedInterface * > _notify_when_mesh_displaces
Objects to be notified when the mesh displaces.
std::vector< T * > & queryInto(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
void trustUserCouplingMatrix()
Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a ...
virtual void newAssemblyArray(std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
const bool _uo_aux_state_check
Whether or not checking the state of uo/aux evaluation.
virtual const std::set< MooseVariableFieldBase * > & getActiveElementalMooseVariables(const THREAD_ID tid) const
Get the MOOSE variables to be reinited on each element.
This is a template class that implements the workhorse compute and computeNodal methods.
virtual void addMeshDivision(const std::string &type, const std::string &name, InputParameters ¶ms)
Add a MeshDivision.
const ExecFlagType EXEC_NONE
A struct for storing the various types of petsc options and values.
virtual void computeMarkers()
void reportMooseObjectDependency(MooseObject *a, MooseObject *b)
Register a MOOSE object dependency so we can either order operations properly or report when we canno...
void residualSetup() override
MaterialDataType
MaterialData types.
void computeUserObjectsInternal(const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
TagID nonTimeVectorTag() const override
A class for "pretty printing" a table of data.
virtual void addCachedJacobian(const THREAD_ID tid)
const std::string & getBoundaryName(BoundaryID boundary_id)
Return the name of the boundary given the id.
void cacheChangedLists()
Cache information about what elements were refined and coarsened in the previous step.
virtual void residualSetup()
Positions objects are under the hood Reporters.
void reinitMortarUserObjects(BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID...
virtual TagID systemMatrixTag() const override
Return the Matrix Tag ID for System.
virtual void associateVectorToTag(NumericVector< Number > &vec, TagID tag)
Associate a vector for a given tag.
virtual void reinitNodes(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
virtual void updateActiveObjects()
Update the active objects in the warehouses.
Stores the stateful material properties computed by materials.
virtual void computeIndicatorsAndMarkers()
void reinitMaterialsBoundary(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on a boundary
virtual void addJacobianOffDiagScalar(unsigned int ivar, const THREAD_ID tid=0)
virtual void setException(const std::string &message)
Set an exception, which is stored at this point by toggling a member variable in this class...
virtual void addJacobian(const THREAD_ID tid) override
void addFunctor(const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
add a functor to the problem functor container
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
std::filesystem::path restartFolderBase(const std::filesystem::path &folder_base) const
The file suffix for restartable data.
virtual void addAuxScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
bool isReservedName(const std::string &name)
Test if the given name is reserved.
bool globalADIndexing()
Whether we are using global AD indexing.
bool hasOutput(const std::string &name) const
Returns true if the output object exists.
Base class for MOOSE-based applications.
void disable_refine_in_reinit()
void mooseInfoRepeated(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
PetscOptions _petsc_option_data_base
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
These methods are used to determine whether stateful material properties need to be stored on interna...
virtual const std::vector< VectorTag > & currentResidualVectorTags() const override
Return the residual vector tags we are currently computing.
processor_id_type rank() const
std::vector< SubdomainName > _material_coverage_blocks
bool computingScalingJacobian() const
Whether we are computing an initial Jacobian for automatic variable scaling.
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
NumericVector< Number > * rhs
virtual void addAuxScalarVariable(const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
virtual const SystemBase & systemBaseLinear(unsigned int sys_num) const override
Get a constant base class reference to a linear system.
const Parallel::Communicator & comm() const
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.
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
void setSolution(const NumericVector< Number > &soln)
Set the solution to a given vector.
MultiApp Implementation for Transient Apps.
Solving a linear problem.
void resizeMaterialData(Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
Resize material data.
void finishMultiAppStep(ExecFlagType type, bool recurse_through_multiapp_levels=false)
Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.
virtual void addFunctorMaterial(const std::string &functor_material_name, const std::string &name, InputParameters ¶meters)
virtual void timestepSetup(THREAD_ID tid=0) const
std::vector< VariableSecond > _second_zero
void clean_refinement_flags()
std::map< SolverVariableName, unsigned int > _solver_var_to_sys_num
Map connecting variable names with their respective solver systems.
virtual std::unique_ptr< NumericVector< T > > clone() const=0
std::vector< MooseArray< ADReal > > _ad_zero
void customSetup(const ExecFlagType &exec_type)
Calls the setup function for each of the output objects.
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
bool _requires_nonlocal_coupling
nonlocal coupling requirement flag
virtual void onTimestepEnd() override
virtual void computeNearNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void addNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
std::vector< std::shared_ptr< SolverSystem > > _solver_systems
Combined container to base pointer of every solver system.
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0) const
All Distributions should inherit from this class.
void setCurrentDirection(const int direction)
Set this Transfer to be executed in a given direction.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
ConstElemPointerRange * refinedElementRange() const
Return a range that is suitable for threaded execution over elements that were just refined...
std::vector< VectorVariableCurl > _vector_curl_zero
static void selectVectorTagsFromSystem(const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
Select the vector tags which belong to a specific system.
Base class for user objects executed one or more sidesets, which may be on the outer boundary of the ...
bool _has_exception
Whether or not an exception has occurred.
unsigned int _num_grid_steps
Number of steps in a grid sequence.
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
bool haveXFEM()
Find out whether the current analysis is using XFEM.
virtual void addJacobianBlockTags(libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)
void registerRandomInterface(RandomInterface &random_interface, const std::string &name)
bool _has_time_integrator
Indicates whether or not this executioner has a time integrator (during setup)
This class provides an interface for common operations on field variables of both FE and FV types wit...
const Parallel::Communicator & _communicator
virtual void addAuxKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual void jacobianSetup()
void clearActiveMaterialProperties(const THREAD_ID tid)
Clear the active material properties.
virtual unsigned int nLinearIterations(const unsigned int nl_sys_num) const override
ExecuteMooseObjectWarehouse< TransientMultiApp > _transient_multi_apps
Storage for TransientMultiApps (only needed for calling 'computeDT')
bool hasUserObject(const std::string &name) const
Check if there if a user object of given name.
MaterialWarehouse _interface_materials
Real getStartTime() const
Thread to compute threaded general user objects.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
bool _ignore_zeros_in_jacobian
Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.
const libMesh::ConstElemRange & getCurrentAlgebraicElementRange()
These are the element and nodes that contribute to the jacobian and residual for this local processor...
void setup(const ExecFlagType &exec_flag, THREAD_ID tid=0) const
void setCurrentExecuteOnFlag(const ExecFlagType &)
virtual void computeResidualInternal(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)
Form a residual vector for a set of tags.
void copyValuesBack()
Copies current chain control data values into old values.
void initElementStatefulProps(const libMesh::ConstElemRange &elem_range, const bool threaded)
Initialize stateful properties for elements in a specific elem_range This is needed when elements/bou...
const libMesh::ConstNodeRange & getCurrentAlgebraicNodeRange()
void setCurrentlyComputingResidualAndJacobian(bool currently_computing_residual_and_jacobian)
Set whether or not the problem is in the process of computing the Jacobian.
ExecuteMooseObjectWarehouse< Transfer > _from_multi_app_transfers
Transfers executed just after MultiApps to transfer data from them.
virtual void addKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
libMesh::TensorValue< ADReal > ADRealTensorValue
Base class for a system (of equations)
const ExecFlagType EXEC_ALWAYS
SparseMatrix< Number > & getSystemMatrix()
Fetching the system matrix from the libmesh system.
This user object allows related evaluations on elements, boundaries, internal sides, interfaces in one single place.
virtual void addAuxVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶ms)
Canonical method for adding an auxiliary variable.
std::pair< typename M::iterator, bool > moose_try_emplace(M &m, const typename M::key_type &k, Args &&... args)
Function to mirror the behavior of the C++17 std::map::try_emplace() method (no hint).
const T_sys & get_system(std::string_view name) const
Base class for MeshDivision objects.
bool computingNonlinearResid() const
Returns true if the problem is in the process of computing the nonlinear residual.
virtual void addFVInterfaceKernel(const std::string &fv_ik_name, const std::string &name, InputParameters ¶meters)
MeshDivision & getMeshDivision(const std::string &name, const THREAD_ID tid=0) const
Get a MeshDivision.
bool isRestarting() const
Whether or not this is a "restart" calculation.
Base class for creating new nodally-based mortar user objects.
Reporter objects allow for the declaration of arbitrary data types that are aggregate values for a si...
const Positions & getPositionsObject(const std::string &name) const
Get the Positions object by its name.
libMesh::ConstNodeRange * getLocalNodeRange()
std::map< SolverSystemName, unsigned int > _solver_sys_name_to_num
Map connecting solver system names with their respective systems.
FEProblemBase(const InputParameters ¶meters)
void addEdge(const T &a, const T &b)
Add an edge between nodes 'a' and 'b'.
std::string convertLatestCheckpoint(std::string orig)
Replaces "LATEST" placeholders with the latest checkpoint file name.
bool isOn()
Is adaptivity on?
void computeResidualTags(const std::set< TagID > &tags)
Form multiple tag-associated residual vectors for all the given tags.
virtual void cacheJacobianNeighbor(const THREAD_ID tid) override
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid)
Clear the active elemental MooseVariableFieldBase.
std::vector< std::unordered_map< BoundaryID, bool > > _bnd_mat_side_cache
Cache for calculating materials on side.
bool hasLinearConvergenceObjects() const
Whether we have linear convergence objects.
virtual const Node & nodeRef(const dof_id_type i) const
std::set< dof_id_type > _ghosted_elems
Elements that should have Dofs ghosted to the local processor.
ExecFlagEnum _print_execution_on
When to print the execution of loops.
virtual const std::string & name() const
Get the name of the class.
std::vector< SubdomainID > getSubdomainIDs(const std::vector< SubdomainName > &subdomain_names) const
Get the associated subdomainIDs for the subdomain names that are passed in.
void clearAllDofIndices()
Clear dof indices from variables in nl and aux systems.
virtual void setResidual(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void solve(const unsigned int nl_sys_num)
virtual void setCurrentLowerDElem(const Elem *const lower_d_elem, const THREAD_ID tid) override
Set the current lower dimensional element.
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
std::set< TagID > _linear_matrix_tags
Temporary storage for filtered matrix tags for linear systems.
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
void bumpAllQRuleOrder(libMesh::Order order, SubdomainID block)
Real computeMultiAppsDT(ExecFlagType type)
Find the smallest timestep over all MultiApps.
const std::string & getSubdomainName(SubdomainID subdomain_id) const
Return the name of a block given an id.
virtual void reinitNeighborFaceRef(const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0)
reinitialize FE objects on a given neighbor element on a given side at a given set of reference point...
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
Returns the variable reference for requested variable which must be of the expected_var_type (Nonline...
void reinitMaterialsFace(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on element faces
std::unique_ptr< libMesh::ConstElemRange > _nl_evaluable_local_elem_range
virtual void disassociateMatrixFromTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Disassociate a matrix from a tag.
void projectInitialConditionOnCustomRange(libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range)
Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boun...
Scope guard for starting and stopping Floating Point Exception Trapping.
virtual void computeResidualTags(const std::set< TagID > &tags)
Form multiple residual vectors and each is associated with one tag.
void forceOutput()
Indicates that the next call to outputStep should be forced This is private, users should utilize FEP...
virtual void computeJacobianSys(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a Jacobian matrix.
auto max(const L &left, const R &right)
std::shared_ptr< MultiApp > getMultiApp(const std::string &multi_app_name) const
Get a MultiApp object by name.
ExecuteMooseObjectWarehouse< UserObject > _all_user_objects
virtual void reinitElemNeighborAndLowerD(const Elem *elem, unsigned int side, const THREAD_ID tid) override
bool hasSolverVariable(const std::string &var_name) const
void preparePRefinement()
Prepare DofMap and Assembly classes with our p-refinement information.
AuxGroup
Flag for AuxKernel related execution type.
virtual Elem * queryElemPtr(const dof_id_type i)
virtual void addMarker(const std::string &marker_name, const std::string &name, InputParameters ¶meters)
void updateGhostedElems()
Updates the list of ghosted elements at the start of each time step for the nonlinear iteration patch...
unsigned int subspaceDim(const std::string &prefix) const
Dimension of the subspace spanned by vectors with a given prefix.
elem_info_iterator ownedElemInfoBegin()
Iterators to owned faceInfo objects.
void setCurrentlyComputingJacobian(const bool currently_computing_jacobian)
Set whether or not the problem is in the process of computing the Jacobian.
unsigned int variable_number(std::string_view var) const
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
Return all automatic mortar generation objects on either the displaced or undisplaced mesh...
A ReporterName that represents a VectorPostprocessor.
bool needsPreviousNewtonIteration() const
Check to see whether we need to compute the variable values of the previous Newton iterate...
virtual void addBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters ¶meters)
bool _computing_nonlinear_residual
Whether the non-linear residual is being evaluated.
virtual bool computingPreSMOResidual(const unsigned int nl_sys_num) const override
Returns true if the problem is in the process of computing it's initial residual. ...
void update()
Update the system (doing libMesh magic)
This class is a container/interface for the objects involved in automatic generation of mortar spaces...
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
const bool _skip_nl_system_check
virtual void resetState()
Reset state of this object in preparation for the next evaluation.
void jacobianSetup()
Calls the jacobianSetup function for each of the output objects.
virtual void addInitialCondition(const std::string &ic_name, const std::string &name, InputParameters ¶meters)
virtual void addCachedResidualDirectly(NumericVector< libMesh::Number > &residual, const THREAD_ID tid)
Allows for all the residual contributions that are currently cached to be added directly into the vec...
bool hasObjects() const
Returns whether we have any active AutomaticMortarGeneration objects.
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
virtual void jacobianSetup(THREAD_ID tid=0) const
const SubdomainID INVALID_BLOCK_ID
ScalarInitialConditionWarehouse _scalar_ics
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
Assemble both the right hand side and the system matrix of a given linear system. ...
Nonlinear system to be solved.
bool getExodusFileRestart() const
Whether or not we need to use a separate Exodus reader to read the mesh BEFORE we create the mesh...
virtual void swapBackMaterialsFace(const THREAD_ID tid)
virtual void addDistribution(const std::string &type, const std::string &name, InputParameters ¶meters)
The following functions will enable MOOSE to have the capability to import distributions.
virtual void advanceState()
Advance all of the state holding vectors / datastructures so that we can move to the next timestep...
A user object that runs over all the nodes and does an aggregation step to compute a single value...
ExecuteMooseObjectWarehouse< Transfer > _transfers
Normal Transfers.
virtual void customSetup(const ExecFlagType &exec_type)
virtual void checkBoundaryMatProps()
Checks boundary material properties integrity.
std::map< std::string, std::vector< dof_id_type > > _var_dof_map
Based class for output objects.
const VectorPostprocessorValue & getVectorPostprocessorValueByName(const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
Get a read-only reference to the vector value associated with the VectorPostprocessor.
virtual void addPredictor(const std::string &type, const std::string &name, InputParameters ¶meters)
virtual Function & getFunction(const std::string &name, const THREAD_ID tid=0)
virtual void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
virtual void copySolutionsBackwards()
const ConstBndNodeRange & getCurrentAlgebraicBndNodeRange()
bool _calculate_jacobian_in_uo
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
virtual void reinitElemFaceRef(const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
reinitialize FE objects on a given element on a given side at a given set of reference points and the...
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
virtual void prepareFaceShapes(unsigned int var, const THREAD_ID tid) override
virtual void addPostprocessor(const std::string &pp_name, const std::string &name, InputParameters ¶meters)
virtual Real finalNonlinearResidual(const unsigned int nl_sys_num) const override
void addItem(const T &value)
Add an independent item to the set.
std::vector< std::shared_ptr< NonlinearSystemBase > > _nl
The nonlinear systems.
bool automaticScaling() const
Automatic scaling getter.
virtual void computeUserObjects(const ExecFlagType &type, const Moose::AuxGroup &group)
Call compute methods on UserObjects.
virtual void setActiveElementalMooseVariables(const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
Set the MOOSE variables to be reinited on each element.
virtual void reinit_systems()
std::map< std::pair< BoundaryID, BoundaryID >, NearestNodeLocator * > _nearest_node_locators
std::vector< VariablePhiGradient > _grad_phi_zero
void initialSetup(THREAD_ID tid)
Initial setup.
bool hasJacobian() const
Returns _has_jacobian.
void notifyWhenMeshDisplaces(MeshDisplacedInterface *mdi)
Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh ge...
void createTagSolutions()
Create extra tagged solution vectors.
std::vector< SolverSystemName > _solver_sys_names
The union of nonlinear and linear system names.
virtual void execute(const ExecFlagType &exec_type)
Convenience function for performing execution of MOOSE systems.
bool _verbose_restore
Whether or not to be verbose on solution restoration post a failed time step.
bool _previous_nl_solution_required
Indicates we need to save the previous NL iteration variable values.
processor_id_type n_processors() const
bool _trust_user_coupling_matrix
Whether to trust the user coupling matrix no matter what.
void setRestartRecoverFileBase(const std::string &file_base)
mutator for recover_base (set by RecoverBaseAction)
unsigned int number() const
void computeResidualAndJacobianTags(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
Form possibly multiple tag-associated vectors and matrices.
void handleException(const std::string &calling_method)
Handle exceptions.
virtual std::vector< VariableName > getVariableNames()
Returns a list of all the variables in the problem (both from the NL and Aux systems.
ReporterData _reporter_data
void uniformRefine()
uniformly refine the problem mesh(es).
virtual void computeResidualSys(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
const ReporterData & getReporterData() const
Provides const access the ReporterData object.
virtual const libMesh::CouplingMatrix & nonlocalCouplingMatrix(const unsigned i) const override
std::unique_ptr< libMesh::ConstElemRange > _current_algebraic_elem_range
FunctorMaterials compute functor material properties.
const std::string _type
The type of this class.
std::vector< std::shared_ptr< Transfer > > getTransfers(ExecFlagType type, Transfer::DIRECTION direction) const
Get Transfers by ExecFlagType and direction.
virtual void addConvergence(const std::string &type, const std::string &name, InputParameters ¶meters)
Adds a Convergence object.
MultiPointMap & getPoints()
Returns a writeable reference to the _points container.
bool shouldPrintExecution(const THREAD_ID tid) const
Check whether the problem should output execution orders at this time.
const std::vector< std::shared_ptr< T > > & getActiveObjects(THREAD_ID tid=0) const
Retrieve complete vector to the active all/block/boundary restricted objects for a given thread...
const std::set< subdomain_id_type > & active_subdomains() const
bool havePRefinement() const
Query whether p-refinement has been requested at any point during the simulation. ...
virtual Real l2_norm() const=0
bool getRecomputeMarkersFlag() const
Pull out the _recompute_markers_during_cycles flag previously set through the AdaptivityAction.
const bool & _solve
Whether or not to actually solve the nonlinear system.
virtual const SystemBase & systemBaseSolver(const unsigned int sys_num) const override
Return the solver system object as a base class reference given the system number.
DenseVector< Real > getAllRealReporterValues() const
Get all real reporter values including postprocessor and vector postprocessor values into a dense vec...
ExecuteMooseObjectWarehouse< Transfer > _to_multi_app_transfers
Transfers executed just before MultiApps to transfer data to them.
std::set< SubdomainID > getActiveBlocks(THREAD_ID tid=0) const
Return a set of active SubdomainsIDs.
NonlinearSystemBase * _current_nl_sys
The current nonlinear system that we are solving.
MooseObjectWarehouse< Convergence > _convergences
convergence warehouse
Interface for notifications that the mesh has changed.
virtual std::unique_ptr< Base > create()=0
void createMortarInterface(const std::pair< BoundaryID, BoundaryID > &boundary_key, const std::pair< SubdomainID, SubdomainID > &subdomain_key, SubProblem &subproblem, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle)
Create mortar generation object.
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
const std::vector< std::shared_ptr< T > > & getObjects(THREAD_ID tid=0) const
Retrieve complete vector to the all/block/boundary restricted objects for a given thread...
virtual const NumericVector< Number > *const & currentSolution() const override final
The solution vector that is currently being operated on.
void initialSetup()
Initial setup.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
Base class for convergence criteria.
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
void min(const T &r, T &o, Request &req) const
virtual void reinitElem(const Elem *elem, const THREAD_ID tid) override
bool needSubdomainMaterialOnSide(SubdomainID subdomain_id, const THREAD_ID tid)
const T & getReporterValue(const ReporterName &reporter_name, const MooseObject &consumer, const ReporterMode &mode, const std::size_t time_index=0) const
Method for returning read only references to Reporter values.
virtual Convergence & getConvergence(const std::string &name, const THREAD_ID tid=0) const
Gets a Convergence object.
TheWarehouse & theWarehouse() const
void createTagVectors()
Create extra tagged vectors and matrices.
virtual void createQRules(libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
void reinitMaterialsNeighbor(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
reinit materials on the neighboring element face
void setMultiAppFixedPointConvergenceName(const ConvergenceName &convergence_name)
Sets the MultiApp fixed point convergence object name if there is one.
Moose::CouplingType _coupling
Type of variable coupling.
Every object that can be built by the factory should be derived from this class.
void parallelBarrierNotify(const libMesh::Parallel::Communicator &comm, bool messaging=true)
This function implements a parallel barrier function but writes progress to stdout.
virtual bool shouldUpdateSolution()
Check to see whether the problem should update the solution.
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid)
void extraSendList(std::vector< dof_id_type > &send_list, void *context)
///< Type of coordinate system
void addObjects(std::shared_ptr< MaterialBase > block, std::shared_ptr< MaterialBase > neighbor, std::shared_ptr< MaterialBase > face, THREAD_ID tid=0)
A special method unique to this class for adding Block, Neighbor, and Face material objects...
const ConvergenceName & getMultiAppFixedPointConvergenceName() const
Gets the MultiApp fixed point convergence object name.
std::vector< std::string > getAllRealReporterFullNames() const
Get full names of all real reporter values Note: For a postprocessor, the full name is the postproces...
virtual void clearActiveScalarVariableCoupleableVectorTags(const THREAD_ID tid)
Real getTimeFromStateArg(const Moose::StateArg &state) const
Returns the time associated with the requested state.
virtual std::string solverTypeString(unsigned int solver_sys_num=0)
Return solver type as a human readable string.
const ExecFlagType EXEC_TIMESTEP_BEGIN
std::shared_ptr< T > getObject(const std::string &name, THREAD_ID tid=0) const
void executeSamplers(const ExecFlagType &exec_type)
Performs setup and execute calls for Sampler objects.
unsigned int which_neighbor_am_i(const Elem *e) const
virtual void computeJacobianInternal(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
Form a Jacobian matrix for multiple tags.
bool _safe_access_tagged_vectors
Is it safe to retrieve data from tagged vectors.
virtual void computeJacobian(const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const unsigned int nl_sys_num)
Form a Jacobian matrix with the default tag (system).
std::optional< std::string > queryStatefulPropName(const unsigned int id) const
void addOutput(const std::string &, const std::string &, InputParameters &)
Adds an Output object.
SolutionIterationType iteration_type
The solution iteration type, e.g. time or nonlinear.
boundary_id_type BoundaryID
void boundaryIntegrityCheckError(const MooseObject &object, const std::set< MooseVariableFieldBase *> &variables, const BoundaryName &boundary_name)
Compose boundary restricted error message for the provided object, variables, and boundary_name if th...
const bool _allow_ics_during_restart
bool constJacobian() const
Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the pr...
virtual void clearActiveFEVariableCoupleableMatrixTags(const THREAD_ID tid) override
void computeJacobianTags(const std::set< TagID > &tags)
Computes multiple (tag associated) Jacobian matricese.
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
std::vector< MeshChangedInterface * > _notify_when_mesh_changes
Objects to be notified when the mesh changes.
virtual void timestepSetup(THREAD_ID tid=0) const
void checkNonlocalCoupling()
VarKindType
Framework-wide stuff.
NonlinearSystemBase & currentNonlinearSystem()
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Jacobian-Free Newton Krylov.
void groupUserObjects(TheWarehouse &w, AuxiliarySystem &aux, const ExecFlagEnum &execute_flags, const std::vector< T *> &objs, const std::set< std::string > &ic_deps)
void checkDisplacementOrders()
Verify that SECOND order mesh uses SECOND order displacements.
virtual void addFunction(const std::string &type, const std::string &name, InputParameters ¶meters)
Real PostprocessorValue
various MOOSE typedefs
void uniformly_coarsen(unsigned int n=1)
virtual void addJacobianNeighbor(const THREAD_ID tid) override
virtual TagID addMatrixTag(TagName tag_name)
Create a Tag.
virtual libMesh::EquationSystems & es() override
std::vector< std::unordered_map< SubdomainID, bool > > _block_mat_side_cache
Cache for calculating materials on side.
std::shared_ptr< AuxiliarySystem > _aux
The auxiliary system.
void setRestart(bool value)
Sets the restart/recover flags.
AttribBoundaries tracks all boundary IDs associated with an object.
void setValue(unsigned int i, Number value)
Set the nodal value for this variable (to keep everything up to date.
virtual void reinitElemFaceRef(const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0)
reinitialize FE objects on a given element on a given side at a given set of reference points and the...
virtual void addVectorPostprocessor(const std::string &pp_name, const std::string &name, InputParameters ¶meters)
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
virtual bool converged(const unsigned int sys_num)
Eventually we want to convert this virtual over to taking a solver system number argument.
virtual unsigned int currentNlSysNum() const override
virtual void computeIndicators()
virtual MooseVariableScalar & getScalarVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the scalar variable reference from whichever system contains it.
const bool _boundary_restricted_node_integrity_check
whether to perform checking of boundary restricted nodal object variable dependencies, e.g.
virtual void setActiveScalarVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
virtual void updateActive(THREAD_ID tid=0)
Update the active status of Kernels.
virtual bool updateMeshXFEM()
Update the mesh due to changing XFEM cuts.
virtual const SystemBase & systemBaseNonlinear(const unsigned int sys_num) const override
Return the nonlinear system object as a base class reference given the system number.
std::vector< MortarUserObject * > getMortarUserObjects(BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced, const std::vector< MortarUserObject *> &mortar_uo_superset)
Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID...
virtual void restoreSolutions()
virtual bool hasConvergence(const std::string &name, const THREAD_ID tid=0) const
Returns true if the problem has a Convergence object of the given name.
void markFamilyPRefinement(const InputParameters ¶ms)
Mark a variable family for either disabling or enabling p-refinement with valid parameters of a varia...
virtual const std::vector< dof_id_type > & dofIndices() const
Get local DoF indices.
void addAnyRedistributers()
const std::string & type() const
Get the type of this class.
bool hasPostprocessorValueByName(const PostprocessorName &name) const
Whether or not a Postprocessor value exists by a given name.
virtual void checkBlockMatProps()
Checks block material properties integrity.
void restoreFromInitialBackup(const bool for_restart)
Restores from a "initial" backup, that is, one set in _initial_backup.
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
void initialSetup() override
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
void reinit()
Completely redo all geometric search objects.
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
bool allowInvalidSolution() const
Whether to accept / allow an invalid solution.
virtual const SystemBase & systemBaseAuxiliary() const override
Return the auxiliary system object as a base class reference.
void setLinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the linear convergence object name(s) if there is one.
void checkUserObjectJacobianRequirement(THREAD_ID tid)
MooseVariableFieldBase & getActualFieldVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested MooseVariableField which may be in any system...
void finalize(const std::string &object_name)
Helper function for performing post calculation actions via the ReporterContext objects.
void addObject(std::shared_ptr< InitialConditionBase > object, THREAD_ID tid, bool recurse=true)
Add object to the warehouse.
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
virtual void computeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void addTimeIntegrator(const std::string &type, const std::string &name, InputParameters ¶meters)
LinearSystem * _current_linear_sys
The current linear system that we are solving.
virtual void cacheResidual(const THREAD_ID tid) override
virtual void computeResidualType(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
Form a residual vector for a given tag and "residual" tag.
const bool _force_restart
void checkCoordinateSystems()
Performs a sanity check for every element in the mesh.
QueryCache clone() const
clone creates and returns an independent copy of the query in its current state.
const std::set< SubdomainID > & getMortarSubdomainIDs() const
Returns the mortar covered subdomains.
void forceOutput()
Indicates that the next call to outputStep should be forced.
const VectorPostprocessor & getVectorPostprocessorObjectByName(const std::string &object_name, const THREAD_ID tid=0) const
Return the VPP object given the name.
std::vector< VariablePhiSecond > _second_phi_zero
StoredRange< std::vector< GeneralUserObject * >::iterator, GeneralUserObject * > GeneralUserObjectRange
bool _started_initial_setup
At or beyond initialSteup stage.
std::map< std::string, std::unique_ptr< RandomData > > _random_data_objects
A map of objects that consume random numbers.
virtual bool vectorTagExists(const TagID tag_id) const
Check to see if a particular Tag exists.
std::unique_ptr< ConstBndNodeRange > _current_algebraic_bnd_node_range
virtual void addResidual(const THREAD_ID tid) override
virtual void addResidualNeighbor(const THREAD_ID tid) override
virtual void reinitNeighborFaceRef(const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
reinitialize FE objects on a given neighbor element on a given side at a given set of reference point...
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
Set the coordinate system for the provided blocks to coord_sys.
Base class for all Postprocessors.
libMesh::ExodusII_IO * getExReaderForRestart() const
Get the Exodus reader to restart variables from an Exodus mesh file.
void needSolutionState(unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)
Declare that we need up to old (1) or older (2) solution states for a given type of iteration...
void clearPoints()
Remove all of the current points and elements.
MooseApp & _app
The MOOSE application this is associated with.
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 ...
virtual void clearActiveFEVariableCoupleableVectorTags(const THREAD_ID tid) override
void maxloc(T &r, unsigned int &max_id) const
bool isValueSet(const std::string &value) const
Methods for seeing if a value is set in the MultiMooseEnum.
void setCouplingMatrix(std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
Set custom coupling matrix.
unsigned int number() const
Gets the number of this system.
virtual void addDefaultNonlinearConvergence(const InputParameters ¶ms)
Adds the default nonlinear Convergence associated with the problem.
virtual void solve() override
Solve the system (using libMesh magic)
void setNonlinearConvergenceNames(const std::vector< ConvergenceName > &convergence_names)
Sets the nonlinear convergence object name(s) if there is one.
unsigned int uniformRefineLevel() const
Returns the level of uniform refinement requested (zero if AMR is disabled).
const ExecFlagType EXEC_LINEAR
TODO: delete this later - it is a temporary hack for dealing with inter-system dependencies.
virtual bool solverSystemConverged(const unsigned int solver_sys_num) override
std::string stringify(const T &t)
conversion to string
std::string _exception_message
The error message to go with an exception.
const std::set< SubdomainID > & boundaryLowerDBlocks() const
std::vector< SubdomainName > getSubdomainNames(const std::vector< SubdomainID > &subdomain_ids) const
Get the associated subdomainNames for the subdomain ids that are passed in.
virtual void checkProblemIntegrity()
Method called to perform a series of sanity checks before a simulation is run.
void setReporterValue(const ReporterName &reporter_name, const T &value, const std::size_t time_index=0)
Method for setting Reporter values that already exist.
Class for storing and utilizing output objects.
AuxiliarySystem & getAuxiliarySystem()
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods.
virtual void updateGeomSearch(GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
void petscSetOptions(const PetscOptions &po, const SolverParams &solver_params, FEProblemBase *const problem=nullptr)
A function for setting the PETSc options in PETSc from the options supplied to MOOSE.
MooseObjectWarehouse< MeshDivision > _mesh_divisions
Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the ...
virtual void addConstraint(const std::string &c_name, const std::string &name, InputParameters ¶meters)
void buildRefinementAndCoarseningMaps(Assembly *assembly)
Create the refinement and coarsening maps necessary for projection of stateful material properties wh...
MooseObjectWarehouse< Indicator > _indicators
virtual void addMultiApp(const std::string &multi_app_name, const std::string &name, InputParameters ¶meters)
Add a MultiApp to the problem.
virtual void prepareAssembly(const THREAD_ID tid) override
bool haveADObjects() const
Method for reading wehther we have any ad objects.
unsigned int systemNumForVariable(const VariableName &variable_name) const
bool _checking_uo_aux_state
Flag used to indicate whether we are doing the uo/aux state check in execute.
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.
MeshBase::element_iterator activeLocalElementsBegin()
Calls active_local_nodes_begin/end() on the underlying libMesh mesh object.
InitialConditions are objects that set the initial value of variables.
Base class for user objects executed on all element sides internal to one or more blocks...
virtual void clearActiveScalarVariableCoupleableMatrixTags(const THREAD_ID tid)
virtual std::map< TagName, TagID > & getMatrixTags()
Return all matrix tags in the system, where a tag is represented by a map from name to ID...
virtual void initNullSpaceVectors(const InputParameters ¶meters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
virtual bool hasVariable(const std::string &var_name) const
Query a system for a variable.
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void clearDiracInfo() override
Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in...
virtual void addIndicator(const std::string &indicator_name, const std::string &name, InputParameters ¶meters)
virtual void reinitNodesNeighbor(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
bool duplicateVariableCheck(const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)
Helper to check for duplicate variable names across systems or within a single system.
virtual void solve() override=0
Solve the system (using libMesh magic)
GeometricSearchType
Used to select groups of geometric search objects to update.
void backupMultiApps(ExecFlagType type)
Backup the MultiApps associated with the ExecFlagType.
A ReporterName that represents a Postprocessor.
virtual void addVariable(const std::string &var_type, const std::string &var_name, InputParameters ¶ms)
Canonical method for adding a non-linear variable.
bool doingPRefinement() const
ExecuteMooseObjectWarehouse< MultiApp > _multi_apps
MultiApp Warehouse.
virtual void jacobianSetup(THREAD_ID tid=0) const
void updateBoundaryMatPropDependency(std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void uniformRefineWithProjection()
Performs uniform refinement on the meshes in the current object.
TagID residualVectorTag() const override
std::vector< std::vector< std::unique_ptr< Assembly > > > _assembly
The Assembly objects.
virtual void addDisplacedProblem(std::shared_ptr< DisplacedProblem > displaced_problem)
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
void computeResidual(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
This function is called by Libmesh to form a residual.
virtual void cacheJacobianNeighbor(const THREAD_ID tid)
void setVectorPostprocessorValueByName(const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
Set the value of a VectorPostprocessor vector.
virtual MooseVariable & getStandardVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested MooseVariable which may be in any system.
virtual void initialSetup(THREAD_ID tid=0) const
Convenience methods for calling object setup methods that handle the extra neighbor and face objects...
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
virtual void swapBackMaterialsNeighbor(const THREAD_ID tid)
virtual void addLinearFVKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
bool hasStatefulProperties() const
void residualSetup()
Calls the residualSetup function for each of the output objects.
virtual NonlinearSystem & getNonlinearSystem(const unsigned int sys_num)
void solveSetup()
Calls the timestepSetup function for each of the output objects.
void sort(THREAD_ID tid=0)
virtual bool reinitDirac(const Elem *elem, const THREAD_ID tid) override
Returns true if the Problem has Dirac kernels it needs to compute on elem.
MooseAppCoordTransform & coordTransform()
virtual void cacheResidual(const THREAD_ID tid)
virtual void timestepSetup()
libMesh::Order order() const
Get the order of this variable Note: Order enum can be implicitly converted to unsigned int...
const ExecFlagType EXEC_PRE_DISPLACE
virtual const Elem * elem_ptr(const dof_id_type i) const=0
const std::vector< NonlinearSystemName > _nl_sys_names
The nonlinear system names.
const ExecFlagType EXEC_POSTCHECK
PetscErrorCode PetscInt const PetscInt fields[]
const ExecFlagType EXEC_NONLINEAR
std::vector< Real > VectorPostprocessorValue
virtual void updateMortarMesh()
void copyValuesBack()
At the end of a timestep this method is called to copy the values back in time in preparation for the...
void update()
Builds mortar segment meshes for each mortar interface.
const std::vector< const Elem * > & coarsenedElementChildren(const Elem *elem) const
Get the newly removed children element ids for an element that was just coarsened.
void restore(const std::filesystem::path &folder_base, const bool for_restart)
Restore an application from file.
void addDefaultMultiAppFixedPointConvergence(const InputParameters ¶ms)
Adds the default fixed point Convergence associated with the problem.
std::set< TagID > _fe_matrix_tags
virtual NumericVector< Number > & RHS()=0
virtual void addAuxArrayVariable(const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
const ExecuteMooseObjectWarehouse< Transfer > & getMultiAppTransferWarehouse(Transfer::DIRECTION direction) const
Return the complete warehouse for MultiAppTransfer object for the given direction.
virtual const SystemBase & getSystemBase(const unsigned int sys_num) const
Get constant reference to a system in this problem.
const Elem * neighbor_ptr(unsigned int i) const
virtual void reinitLowerDElem(const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr) override
const T & getParam(const std::string &name)
Retrieve a parameter for the object.
void removeSubstring(std::string &main, const std::string &sub)
find, erase, length algorithm for removing a substring from a string
Provides a way for users to bail out of the current solve.
virtual void addReporter(const std::string &type, const std::string &name, InputParameters ¶meters)
Add a Reporter object to the simulation.
virtual void swapBackMaterials(const THREAD_ID tid)
std::vector< VariablePhiValue > _phi_zero
InitialConditionWarehouse _ics
std::vector< unsigned char > _has_active_material_properties
Whether there are active material properties on each thread.
MaterialWarehouse _discrete_materials
bool _reinit_displaced_face
Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.
void updateBlockMatPropDependency(SubdomainID id, std::unordered_set< unsigned int > &needed_mat_props, THREAD_ID tid=0) const
void setSinglePetscOption(const std::string &name, const std::string &value="", FEProblemBase *const problem=nullptr)
A wrapper function for dealing with different versions of PetscOptionsSetValue.
virtual void initialSetup()
NumericVector< Number > & getRightHandSideVector()
Fetching the right hand side vector from the libmesh system.
virtual void addDGKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual void setCurrentBoundaryID(BoundaryID bid, const THREAD_ID tid) override
sets the current boundary ID in assembly
SolverSystem * _current_solver_sys
The current solver system.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
virtual bool contract()=0
std::optional< std::vector< ConvergenceName > > _nonlinear_convergence_names
Nonlinear system(s) convergence name(s)
Generic class for solving transient nonlinear problems.
virtual void preProblemInit()
Perform initializations during executing actions right before init_problem task.
void updateActiveSemiLocalNodeRange(std::set< dof_id_type > &ghosted_elems)
Clears the "semi-local" node list and rebuilds it.
subdomain_id_type subdomain_id() const
virtual void stopSolve(const ExecFlagType &exec_flag, const std::set< TagID > &vector_tags_to_close)=0
Quit the current solve as soon as possible.
const InputParameters * getCommonParameters() const
Get a reference to the common output parameters.
TagID timeVectorTag() const override
Ideally, we should not need this API.
std::map< SubdomainID, std::set< MaterialPropertyName > > _zero_block_material_props
Set of properties returned as zero properties.
Class for containing MooseEnum item information.
unsigned int solverSysNum(const SolverSystemName &solver_sys_name) const override
std::shared_ptr< MaterialBase > getMaterial(std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)
Return a pointer to a MaterialBase object.
virtual void swap(NumericVector< T > &v)
bool hasActiveObject(const std::string &name, THREAD_ID tid=0) const
Convenience functions for checking/getting specific objects.
std::vector< VariableGradient > _grad_zero
bool hasActiveObjects(THREAD_ID tid=0) const
void clearCurrentJacobianMatrixTags()
Clear the current Jacobian matrix tag data structure ...
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
virtual void subdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
virtual void restoreOldSolutions()
Restore old solutions from the backup vectors and deallocate them.
unsigned int getInitialSteps() const
Pull out the number of initial steps previously set by calling init()
void max(const T &r, T &o, Request &req) const
void reinitMaterials(SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
virtual unsigned short dim() const=0
const AutomaticMortarGeneration & getMortarInterface(const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
Return the undisplaced or displaced mortar generation object associated with the provided boundaries ...
bool acceptInvalidSolution() const
Whether or not to accept the solution based on its invalidity.
void setLoadAllVectors(const bool load_all_vectors)
Sets whether or not all vectors are to be loaded.
Class for threaded computation of UserObjects.
const bool _restore_original_nonzero_pattern
Whether we should restore the original nonzero pattern for every Jacobian evaluation.
void setRandomDataPointer(RandomData *random_data)
Base class for all MultiAppTransfer objects.
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
void execMultiAppTransfers(ExecFlagType type, Transfer::DIRECTION direction)
Execute MultiAppTransfers associated with execution flag and direction.
T & set(const std::string &)
Wrapper class that owns a libMesh EquationSystem and adds advanced restart capability to it...
void restoreMultiApps(ExecFlagType type, bool force=false)
Restore the MultiApps associated with the ExecFlagType.
virtual void addLinearFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters ¶meters)
virtual bool is_vertex(const unsigned int i) const=0
void subdomainSetup()
Calls the subdomainSetup function for each of the output objects.
const std::vector< dof_id_type > & allDofIndices() const
Get all global dofindices for the variable.
const std::vector< std::string > & get_elem_var_names()
void addMaterialPropertyStorage(MaterialPropertyStorage &mat_props)
Pushes the given pair ( mat_data , mat_props ) onto our list of _materials data to redistribute each ...
SparseMatrix< Number > * matrix
void customSetup(const ExecFlagType &exec_type) override
void setRestartFile(const std::string &file_name)
Communicate to the Resurector the name of the restart filer.
void setCurrentLinearSystem(unsigned int sys_num)
Set the current linear system pointer.
void initNonlocalCoupling()
Create pair of variables requiring nonlocal jacobian contributions.
void executeControls(const ExecFlagType &exec_type)
Performs setup and execute calls for Control objects.
virtual std::vector< std::shared_ptr< UserObject > > addUserObject(const std::string &user_object_name, const std::string &name, InputParameters ¶meters)
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
void allowOutput(bool state)
Ability to enable/disable output calls This is private, users should utilize FEProblemBase::allowOutp...
bool hasStartTime() const
virtual void onTimestepBegin() override
virtual void computeBounds(libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
Nonlinear system to be solved.
virtual void computePostCheck(libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &old_soln, NumericVector< libMesh::Number > &search_direction, NumericVector< libMesh::Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)
void checkDuplicatePostprocessorVariableNames()
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
For axisymmetric simulations, set the symmetry coordinate axis.
void addOutput(std::shared_ptr< Output > output)
Adds an existing output object to the warehouse.
void computeResidualAndJacobian(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
Form a residual and Jacobian with default tags.
bool hasDisplacedObjects() const
Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh...
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & nonlocalCouplingEntries(const THREAD_ID tid, const unsigned int nl_sys_num)
static void selectMatrixTagsFromSystem(const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
Select the matrix tags which belong to a specific system.
std::vector< VariableValue > _scalar_zero
virtual Real computeResidualL2Norm()
Computes the residual using whatever is sitting in the current solution vector then returns the L2 no...
void update(GeometricSearchType type=ALL)
Update all of the search objects.
const std::vector< LinearSystemName > _linear_sys_names
The linear system names.
void incrementMultiAppTStep(ExecFlagType type)
Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.
Class for scalar variables (they are different).
IntRange< T > make_range(T beg, T end)
void computeLinearSystemTags(const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
Assemble the current linear system given a set of vector and matrix tags.
void bumpVolumeQRuleOrder(libMesh::Order order, SubdomainID block)
Increases the element/volume quadrature order for the specified mesh block if and only if the current...
const bool _material_dependency_check
Determines whether a check to verify material dependencies on every subdomain.
std::vector< std::vector< const MooseVariableFEBase * > > _uo_jacobian_moose_vars
virtual MooseMesh & mesh() override
NonlocalKernel is used for solving integral terms in integro-differential equations.
virtual void subdomainSetup(THREAD_ID tid=0) const
std::vector< VariableValue > _zero
const ExecFlagType EXEC_SAME_AS_MULTIAPP
unsigned int linearSysNum(const LinearSystemName &linear_sys_name) const override
LinearSystem & currentLinearSystem()
Get a non-constant reference to the current linear system.
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
std::set< TagID > _fe_vector_tags
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addObjectParamsHelper(InputParameters ¶ms, const std::string &object_name, const std::string &var_param_name="variable")
Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject().
virtual unsigned int size() const override final
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
virtual void saveOldSolutions()
Allocate vectors and save old solutions into them.
std::unique_ptr< NumericVector< Number > > current_local_solution
ADRealVectorValue ADRealGradient
virtual void setActiveFEVariableCoupleableMatrixTags(std::set< TagID > &mtags, const THREAD_ID tid)
void mooseConsole()
Send current output buffer to Console output objects.
std::set< std::string > getDependObjects() const
Get a list of dependent UserObjects for this exec type.
virtual void computeTransposeNullSpace(libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
bool hasPostprocessor(const std::string &name) const
Deprecated.
virtual bool updateSolution(NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
Update the solution.
ChainControlDataSystem & getChainControlDataSystem()
Gets the system that manages the ChainControls.
std::shared_ptr< DisplacedProblem > _displaced_problem
GeometricSearchData _geometric_search_data
const InputParameters & parameters() const
Get the parameters of the object.
State argument for evaluating functors.
void setCurrentResidualVectorTags(const std::set< TagID > &vector_tags)
Set the current residual vector tag data structure based on the passed in tag IDs.
MooseObjectWarehouse< Function > _functions
functions
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
Adds an object to the storage structure.
virtual Real & timeOld() const
Proxy for accessing MaterialPropertyStorage.
std::vector< VectorVariableValue > _vector_zero
bool hasMultiApp(const std::string &name) const
void createMortarInterface(const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle)
std::vector< std::unique_ptr< libMesh::CouplingMatrix > > _cm
Coupling matrix for variables.
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, const THREAD_ID tid)
void reinitElemFace(const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
virtual void cacheResidualNeighbor(const THREAD_ID tid)
Linear system to be solved.
bool hasReporterValue(const ReporterName &reporter_name) const
Return True if a Reporter value with the given type and name have been created.
std::optional< std::vector< ConvergenceName > > _linear_convergence_names
Linear system(s) convergence name(s) (if any)
bool _has_initialized_stateful
Whether nor not stateful materials have been initialized.
void checkICRestartError(const std::string &ic_name, const std::string &name, const VariableName &var_name)
Checks if the variable of the initial condition is getting restarted and errors for specific cases...
virtual void setResidualNeighbor(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
const TagName SOLUTION_TAG
unsigned int _max_qps
Maximum number of quadrature points used in the problem.
A class for storing an input parameter name.
static InputParameters validParams()
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
virtual void addScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
elem_info_iterator ownedElemInfoEnd()
std::set< const Elem * > & getElements()
Returns a writeable reference to the _elements container.
virtual void set(const numeric_index_type i, const T value)=0
void addGhostedBoundary(BoundaryID boundary_id)
This will add the boundary ids to be ghosted to this processor.
bool _preserve_matrix_sparsity_pattern
Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually...
virtual unsigned int nNonlinearIterations(const unsigned int nl_sys_num) const override
CoverageCheckMode _material_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active material...
bool isAdaptivityDue()
Query if an adaptivity step should be performed at the current time / time step.
virtual std::size_t numLinearSystems() const override
MaterialPropertyStorage & _neighbor_material_props
std::unique_ptr< Backup > finalizeRestore()
Finalizes (closes) the restoration process done in restore().
libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > * getBoundaryElementRange()
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
const std::size_t _num_linear_sys
The number of linear systems.
std::map< std::string, unsigned int > _subspace_dim
Dimension of the subspace spanned by the vectors with a given prefix.
const libMesh::ConstElemRange & getEvaluableElementRange()
In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.
void paramWarning(const std::string ¶m, Args... args) const
Emits a warning prefixed with the file and line number of the given param (from the input file) along...
static InputParameters validParams()
bool _currently_computing_residual
Whether the residual is being evaluated.
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
bool _has_internal_edge_residual_objects
Whether the problem has dgkernels or interface kernels.
bool execMultiApps(ExecFlagType type, bool auto_advance=true)
Execute the MultiApps associated with the ExecFlagType.
const std::string & name() const
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
virtual ArrayMooseVariable & getArrayVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested ArrayMooseVariable which may be in any system...
const ExecFlagType EXEC_SUBDOMAIN
bool _has_constraints
Whether or not this system has any Constraints.
virtual bool isTransient() const override
bool hasMultiApps() const
Returns whether or not the current simulation has any multiapps.
virtual void reinitNeighbor(const Elem *elem, unsigned int side, const THREAD_ID tid) override
const MaterialData & getMaterialData(const THREAD_ID tid) const
void doingPRefinement(bool doing_p_refinement)
Indicate whether the kind of adaptivity we're doing is p-refinement.
const bool & currentlyComputingJacobian() const
Returns true if the problem is in the process of computing the Jacobian.
void notifyWhenMeshChanges(MeshChangedInterface *mci)
Register an object that derives from MeshChangedInterface to be notified when the mesh changes...
ConstElemPointerRange * coarsenedElementRange() const
Return a range that is suitable for threaded execution over elements that were just coarsened...
std::unique_ptr< libMesh::ConstElemRange > _evaluable_local_elem_range
const Moose::PatchUpdateType & getPatchUpdateStrategy() const
Get the current patch update strategy.
virtual void executeAllObjects(const ExecFlagType &exec_type)
CoverageCheckMode _kernel_coverage_check
Determines whether and which subdomains are to be checked to ensure that they have an active kernel...
virtual void setActiveFEVariableCoupleableVectorTags(std::set< TagID > &vtags, const THREAD_ID tid) override
void check() const
Perform integrity check for get/declare calls.
std::set< std::string > getPostprocessorNames() const
Return a list of all postprocessor names.
bool _fail_next_system_convergence_check
void ghostGhostedBoundaries()
Actually do the ghosting of boundaries that need to be ghosted to this processor. ...
std::vector< std::shared_ptr< LinearSystem > > _linear_systems
The vector of linear systems.
std::shared_ptr< XFEMInterface > _xfem
Pointer to XFEM controller.
virtual void prepareShapes(unsigned int var, const THREAD_ID tid) override
const bool _boundary_restricted_elem_integrity_check
whether to perform checking of boundary restricted elemental object variable dependencies, e.g.
void reinitMaterialsInterface(BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
bool _const_jacobian
true if the Jacobian is constant
virtual void computeJacobianBlock(libMesh::SparseMatrix< libMesh::Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)
Really not a good idea to use this.
virtual void solveLinearSystem(const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
Build and solve a linear system.
virtual void computeUserObjectByName(const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
Compute an user object with the given name.
virtual void possiblyRebuildGeomSearchPatches()
virtual void add(const numeric_index_type i, const T value)=0
bool _safe_access_tagged_matrices
Is it safe to retrieve data from tagged matrices.
std::set< TagID > _linear_vector_tags
Temporary storage for filtered vector tags for linear systems.
Class that represents the dependecy as a graph.
DiracKernelInfo _dirac_kernel_info
A MultiApp represents one or more MOOSE applications that are running simultaneously.
const TagName PREVIOUS_NL_SOLUTION_TAG
void updateBoundaryVariableDependency(std::set< MooseVariableFieldBase *> &needed_moose_vars, THREAD_ID tid=0) const
processor_id_type processor_id() const
void addObject(std::shared_ptr< FVInitialConditionBase > object, THREAD_ID tid, bool recurse=true)
Add object to the warehouse.
std::vector< T * > & queryIntoUnsorted(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
const libMesh::ConstElemRange & getNonlinearEvaluableElementRange()
A class for storing the names of MooseObject by tag and object name.
MaterialPropertyStorage & _material_props
Base class for Postprocessors that produce a vector of values.
virtual Order default_order() const=0
void prepareMaterials(const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
Add the MooseVariables and the material properties that the current materials depend on to the depend...
virtual void addFVKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual void addFVBC(const std::string &fv_bc_name, const std::string &name, InputParameters ¶meters)
libMesh::Order _max_scalar_order
Maximum scalar variable order.
virtual void addGhostedBoundary(BoundaryID boundary_id) override
Will make sure that all necessary elements from boundary_id are ghosted to this processor.
virtual bool hasFunction(const std::string &name, const THREAD_ID tid=0)
Adaptivity & adaptivity()
bool hasActiveMaterialProperties(const THREAD_ID tid) const
Method to check whether or not a list of active material roperties has been set.
ExecuteMooseObjectWarehouse< Transfer > _between_multi_app_transfers
Transfers executed just before MultiApps to transfer data between them.
bool isRecovering() const
Whether or not this is a "recover" calculation.
SystemBase & sys()
Get the system this variable is part of.
virtual void cacheJacobian(const THREAD_ID tid) override
auto min(const L &left, const R &right)
void jacobianSetup() override
virtual std::size_t numSolverSystems() const override
virtual void addHDGKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
Restartable::ManagedValue< RestartableEquationSystems > _req
The EquationSystems object, wrapped for restart.
virtual unsigned int currentLinearSysNum() const override
std::vector< libMesh::CouplingMatrix > _nonlocal_cm
nonlocal coupling matrix
virtual void reinitNodeFace(const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
virtual void reinitOffDiagScalars(const THREAD_ID tid) override
processor_id_type processor_id() const
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
std::vector< std::unordered_map< BoundaryID, bool > > _interface_mat_side_cache
Cache for calculating materials on interface.
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
const std::vector< std::string > & get_nodal_var_names()
std::string getRestartRecoverFileBase() const
The file_base for the recovery file.
virtual void addJacobianNeighborLowerD(const THREAD_ID tid) override
virtual void prepareNeighborShapes(unsigned int var, const THREAD_ID tid) override
MooseObjectWarehouse< Marker > _markers
FVInitialConditionWarehouse _fv_ics
void setVerboseProblem(bool verbose)
Make the problem be verbose.
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual const VectorTag & getVectorTag(const TagID tag_id) const
Get a VectorTag from a TagID.
MaterialBases compute MaterialProperties.
virtual void initialAdaptMesh()
void updatePointLocator(const MooseMesh &mesh)
Called during FEProblemBase::meshChanged() to update the PointLocator object used by the DiracKernels...
virtual void addResidualScalar(const THREAD_ID tid=0)
This is a template class that implements the workhorse compute and computeNodal methods.
MaterialWarehouse _all_materials
const MeshBase::element_iterator activeLocalElementsEnd()
virtual void addCachedResidual(const THREAD_ID tid) override
for(PetscInt i=0;i< nvars;++i)
void clearNearestNodeLocators()
Clear out the Penetration Locators so they will redo the search.
Moose::PetscSupport::PetscOptions _petsc_options
PETSc option storage.
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
virtual const std::vector< std::shared_ptr< Convergence > > & getConvergenceObjects(const THREAD_ID tid=0) const
Gets the Convergence objects.
void ErrorVector unsigned int
virtual void clearActiveElementalMooseVariables(const THREAD_ID tid) override
Clear the active elemental MooseVariableFEBase.
auto index_range(const T &sizable)
Base class for user-specific data.
void timestepSetup()
Calls the timestepSetup function for each of the output objects.
void allowOutput(bool state)
Ability to enable/disable all output calls.
virtual void cacheJacobian(const THREAD_ID tid)
virtual Sampler & getSampler(const std::string &name, const THREAD_ID tid=0)
virtual void outputStep(ExecFlagType type)
Output the current step.
virtual unsigned int nlSysNum(const NonlinearSystemName &nl_sys_name) const override
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
MooseEnum _verbose_setup
Whether or not to be verbose during setup.
static InputParameters validParams()
RedistributeProperties is used for its redistribute() callback, which ensures that any stateful prope...
unsigned int state
The state.
virtual void computeJacobianTags(const std::set< TagID > &tags)
Form multiple matrices, and each is associated with a tag.
void computeSystems(const ExecFlagType &type)
Do generic system computations.
MooseMesh * _displaced_mesh
void resize(unsigned int n_qpoints)
Resize the data to hold properties for n_qpoints quadrature points.
bool _has_mortar
Whether the simulation requires mortar coupling.
void computeLinearSystemTags(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
Compute the right hand side and the system matrix of the system for given tags.
libMesh::Order getMaxScalarOrder() const
void execTransfers(ExecFlagType type)
Execute the Transfers associated with the ExecFlagType.
void addNotZeroedVectorTag(const TagID tag)
Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are...
void restoreState(bool verbose=false)
When a time step fails, this method is called to revert the current reporter values to their old stat...
void meshChanged()
Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.
void buildPRefinementAndCoarseningMaps(Assembly *assembly)
const std::vector< ConvergenceName > & getLinearConvergenceNames() const
Gets the linear convergence object name(s).
virtual void ghostGhostedBoundaries() override
Causes the boundaries added using addGhostedBoundary to actually be ghosted.
const ExecFlagType EXEC_POST_ADAPTIVITY
void add_ghosting_functor(GhostingFunctor &ghosting_functor)
MaterialWarehouse _materials
virtual void addJacobianScalar(const THREAD_ID tid=0)
virtual void addDiracKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
An instance of this object type has one copy per thread that runs on each thread. ...
MooseObjectWarehouse< IntegratedBCBase > _nonlocal_integrated_bcs
nonlocal integrated_bcs
virtual void computeResidualTag(const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
Form a residual vector for a given tag.
virtual VectorMooseVariable & getVectorVariable(const THREAD_ID tid, const std::string &var_name) override
Returns the variable reference for requested VectorMooseVariable which may be in any system...
std::shared_ptr< LineSearch > _line_search
void initXFEM(std::shared_ptr< XFEMInterface > xfem)
Create XFEM controller object.
const std::set< SubdomainID > & meshSubdomains() const
Returns a read-only reference to the set of subdomains currently present in the Mesh.
SubdomainID getSubdomainID(const SubdomainName &subdomain_name) const
Get the associated subdomain ID for the subdomain name.
const FEType & type() const
Base class for all Transfer objects.
virtual void neighborSubdomainSetup(SubdomainID subdomain, const THREAD_ID tid)
void setupFiniteVolumeMeshData() const
Sets up the additional data needed for finite volume computations.
virtual void addCachedJacobian(const THREAD_ID tid) override
virtual void residualSetup(THREAD_ID tid=0) const
virtual void sizeZeroes(unsigned int size, const THREAD_ID tid)
virtual Real computeDamping(const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
std::vector< Real > _real_zero
Convenience zeros.
MooseObjectWarehouse< KernelBase > _nonlocal_kernels
nonlocal kernels
void checkCoordinateSystems()
Verify that there are no element type/coordinate type conflicts.
unsigned int getMaxQps() const
const ExecFlagType EXEC_INITIAL
bool _verbose_multiapps
Whether or not to be verbose with multiapps.
Key structure for APIs manipulating global vectors/matrices.