10 #ifdef MOOSE_KOKKOS_ENABLED 124 #include "libmesh/exodusII_io.h" 125 #include "libmesh/quadrature.h" 126 #include "libmesh/coupling_matrix.h" 127 #include "libmesh/nonlinear_solver.h" 128 #include "libmesh/sparse_matrix.h" 129 #include "libmesh/string_to_enum.h" 130 #include "libmesh/fe_interface.h" 131 #include "libmesh/enum_norm_type.h" 132 #include "libmesh/petsc_solver_exception.h" 134 #include "metaphysicl/dualnumber.h" 157 params.
addParam<
unsigned int>(
"null_space_dimension", 0,
"The dimension of the nullspace");
159 "transpose_null_space_dimension", 0,
"The dimension of the transpose nullspace");
161 "near_null_space_dimension", 0,
"The dimension of the near nullspace");
164 "Whether or not to actually solve the Nonlinear system. " 165 "This is handy in the case that all you want to do is " 166 "execute AuxKernels, Transfers, etc. without actually " 168 params.
addParam<
bool>(
"use_nonlinear",
170 "Determines whether to use a Nonlinear vs a " 171 "Eigenvalue system (Automatically determined based " 173 params.
addParam<
bool>(
"error_on_jacobian_nonzero_reallocation",
174 "This causes PETSc to error if it had to reallocate memory in the Jacobian " 175 "matrix due to not having enough nonzeros");
176 params.
addParam<
bool>(
"ignore_zeros_in_jacobian",
178 "Do not explicitly store zero values in " 179 "the Jacobian matrix if true");
180 params.
addParam<
bool>(
"force_restart",
182 "EXPERIMENTAL: If true, a sub_app may use a " 183 "restart file instead of using of using the master " 187 "True to skip additional data in equation system for restart.",
188 "This parameter is no longer used, as we do not load additional " 189 "vectors by default with restart");
190 params.
addParam<
bool>(
"skip_nl_system_check",
192 "True to skip the NonlinearSystem check for work to do (e.g. Make sure " 193 "that there are variables to solve for).");
194 params.
addParam<
bool>(
"allow_initial_conditions_with_restart",
196 "True to allow the user to specify initial conditions when restarting. " 197 "Initial conditions can override any restarted field");
199 auto coverage_check_description = [](std::string scope, std::string list_param_name)
201 return "Controls, if and how a " + scope +
202 " subdomain coverage check is performed. " 203 "With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' " 204 "will disable the check for all subdomains. " 205 "To exclude a predefined set of subdomains 'SKIP_LIST' is to " 206 "be used, while the subdomains to skip are to be defined in the parameter '" +
208 "'. To limit the check to a list of subdomains, 'ONLY_LIST' is to " 209 "be used (again, using the parameter '" +
210 list_param_name +
"').";
213 params.
addParam<std::vector<SubdomainName>>(
216 "List of subdomains for kernel coverage and material coverage checks. Setting this parameter " 217 "is equivalent to setting 'kernel_coverage_block_list' and 'material_coverage_block_list' as " 218 "well as using 'ONLY_LIST' as the coverage check mode.");
220 MooseEnum kernel_coverage_check_modes(
"FALSE TRUE OFF ON SKIP_LIST ONLY_LIST",
"TRUE");
222 kernel_coverage_check_modes,
223 coverage_check_description(
"kernel",
"kernel_coverage_block_list"));
224 params.
addParam<std::vector<SubdomainName>>(
225 "kernel_coverage_block_list",
227 "List of subdomains for kernel coverage check. The meaning of this list is controlled by the " 228 "parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, " 229 "not to be checked or not taken into account).");
231 "boundary_restricted_node_integrity_check",
233 "Set to false to disable checking of boundary restricted nodal object variable dependencies, " 234 "e.g. are the variable dependencies defined on the selected boundaries?");
235 params.
addParam<
bool>(
"boundary_restricted_elem_integrity_check",
237 "Set to false to disable checking of boundary restricted elemental object " 238 "variable dependencies, e.g. are the variable dependencies defined on the " 239 "selected boundaries?");
240 MooseEnum material_coverage_check_modes(
"FALSE TRUE OFF ON SKIP_LIST ONLY_LIST",
"TRUE");
242 "material_coverage_check",
243 material_coverage_check_modes,
244 coverage_check_description(
"material",
"material_coverage_block_list"));
245 params.
addParam<std::vector<SubdomainName>>(
246 "material_coverage_block_list",
248 "List of subdomains for material coverage check. The meaning of this list is controlled by " 249 "the parameter 'material_coverage_check' (whether this is the list of subdomains to be " 250 "checked, not to be checked or not taken into account).");
252 params.
addParam<
bool>(
"fv_bcs_integrity_check",
254 "Set to false to disable checking of overlapping Dirichlet and Flux BCs " 255 "and/or multiple DirichletBCs per sideset");
258 "material_dependency_check",
true,
"Set to false to disable material dependency check");
259 params.
addParam<
bool>(
"parallel_barrier_messaging",
261 "Displays messaging from parallel " 262 "barrier notifications when executing " 263 "or transferring to/from Multiapps " 266 MooseEnum verbosity(
"false true extra",
"false");
269 "Set to 'true' to have the problem report on any object created. Set " 270 "to 'extra' to also display all parameters.");
271 params.
addParam<
bool>(
"verbose_multiapps",
273 "Set to True to enable verbose screen printing related to MultiApps");
277 "Set to True to enable verbose screen printing related to solution restoration");
279 params.
addParam<FileNameNoExtension>(
"restart_file_base",
280 "File base name used for restart (e.g. " 281 "<path>/<filebase> or <path>/LATEST to " 282 "grab the latest file available)");
284 params.
addParam<std::vector<std::vector<TagName>>>(
287 "Extra vectors to add to the system that can be filled by objects which compute residuals " 288 "and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which " 289 "nonlinear system the extra tag vectors should be added for");
291 params.
addParam<std::vector<std::vector<TagName>>>(
292 "not_zeroed_tag_vectors",
294 "Extra vector tags which the sytem will not zero when other vector tags are zeroed. " 295 "The outer index is for which nonlinear system the extra tag vectors should be added for");
297 params.
addParam<std::vector<std::vector<TagName>>>(
298 "extra_tag_matrices",
300 "Extra matrices to add to the system that can be filled " 301 "by objects which compute residuals and Jacobians " 302 "(Kernels, BCs, etc.) by setting tags on them. The outer index is for which " 303 "nonlinear system the extra tag vectors should be added for");
305 params.
addParam<std::vector<TagName>>(
306 "extra_tag_solutions",
308 "Extra solution vectors to add to the system that can be used by " 309 "objects for coupling variable values stored in them.");
311 params.
addParam<
bool>(
"previous_nl_solution_required",
313 "True to indicate that this calculation requires a solution vector for " 314 "storing the previous nonlinear iteration.");
316 params.
addParam<std::vector<NonlinearSystemName>>(
317 "nl_sys_names", std::vector<NonlinearSystemName>{
"nl0"},
"The nonlinear system names");
319 params.
addParam<std::vector<LinearSystemName>>(
"linear_sys_names", {},
"The linear system names");
321 params.
addParam<
bool>(
"check_uo_aux_state",
323 "True to turn on a check that no state presents during the evaluation of " 324 "user objects and aux kernels");
331 "allow_invalid_solution",
333 "Set to true to allow convergence even though the solution has been marked as 'invalid'");
334 params.
addParam<
bool>(
"show_invalid_solution_console",
336 "Set to true to show the invalid solution occurance summary in console");
337 params.
addParam<
bool>(
"immediately_print_invalid_solution",
339 "Whether or not to report invalid solution warnings at the time the " 340 "warning is produced instead of after the calculation");
343 "identify_variable_groups_in_nl",
345 "Whether to identify variable groups in nonlinear systems. This affects dof ordering");
348 "regard_general_exceptions_as_errors",
350 "If we catch an exception during residual/Jacobian evaluaton for which we don't have " 351 "specific handling, immediately error instead of allowing the time step to be cut");
353 params.
addParam<
bool>(
"use_hash_table_matrix_assembly",
355 "Whether to assemble matrices using hash tables instead of preallocating " 356 "matrix memory. This can be a good option if the sparsity pattern changes " 357 "throughout the course of the simulation.");
359 "restore_original_nonzero_pattern",
360 "Whether we should reset matrix memory for every Jacobian evaluation. This option is useful " 361 "if the sparsity pattern is constantly changing and you are using hash table assembly or if " 362 "you wish to continually restore the matrix to the originally preallocated sparsity pattern " 363 "computed by relationship managers.");
366 "skip_nl_system_check kernel_coverage_check kernel_coverage_block_list " 367 "boundary_restricted_node_integrity_check " 368 "boundary_restricted_elem_integrity_check material_coverage_check " 369 "material_coverage_block_list fv_bcs_integrity_check " 370 "material_dependency_check check_uo_aux_state error_on_jacobian_nonzero_reallocation",
371 "Simulation checks");
373 "ignore_zeros_in_jacobian identify_variable_groups_in_nl " 374 "use_hash_table_matrix_assembly restore_original_nonzero_pattern",
375 "Nonlinear system(s)");
377 "restart_file_base force_restart allow_initial_conditions_with_restart",
"Restart");
379 "verbose_setup verbose_multiapps verbose_restore parallel_barrier_messaging",
"Verbosity");
381 "null_space_dimension transpose_null_space_dimension near_null_space_dimension",
382 "Null space removal");
384 "extra_tag_vectors extra_tag_matrices extra_tag_solutions not_zeroed_tag_vectors",
385 "Contribution to tagged field data");
387 "allow_invalid_solution show_invalid_solution_console immediately_print_invalid_solution",
388 "Solution validity control");
396 _mesh(*getCheckedPointerParam<
MooseMesh *>(
"mesh")),
398 "equation_systems", nullptr, _mesh)),
400 _solve(getParam<bool>(
"solve")),
402 _time(declareRestartableData<
Real>(
"time")),
403 _time_old(declareRestartableData<
Real>(
"time_old")),
404 _t_step(declareRecoverableData<
int>(
"t_step")),
405 _dt(declareRestartableData<
Real>(
"dt")),
406 _dt_old(declareRestartableData<
Real>(
"dt_old")),
407 _need_to_add_default_nonlinear_convergence(false),
408 _need_to_add_default_multiapp_fixed_point_convergence(false),
409 _need_to_add_default_steady_state_convergence(false),
410 _linear_sys_names(getParam<
std::vector<LinearSystemName>>(
"linear_sys_names")),
411 _num_linear_sys(_linear_sys_names.size()),
412 _linear_systems(_num_linear_sys, nullptr),
413 _current_linear_sys(nullptr),
414 _using_default_nl(!isParamSetByUser(
"nl_sys_names")),
415 _nl_sys_names(!_using_default_nl || (_using_default_nl && !_linear_sys_names.size())
416 ? getParam<
std::vector<NonlinearSystemName>>(
"nl_sys_names")
417 :
std::vector<NonlinearSystemName>()),
418 _num_nl_sys(_nl_sys_names.size()),
419 _nl(_num_nl_sys, nullptr),
420 _current_nl_sys(nullptr),
421 _solver_systems(_num_nl_sys + _num_linear_sys, nullptr),
424 #ifdef MOOSE_KOKKOS_ENABLED
425 _kokkos_assembly(*this),
427 _mesh_divisions(true),
429 "material_props", &_mesh, _material_prop_registry, *this)),
431 "bnd_material_props", &_mesh, _material_prop_registry, *this)),
433 "neighbor_material_props", &_mesh, _material_prop_registry, *this)),
434 #ifdef MOOSE_KOKKOS_ENABLED
435 _kokkos_material_props(
437 "kokkos_material_props", &_mesh, _material_prop_registry, *this)),
438 _kokkos_bnd_material_props(
440 "kokkos_bnd_material_props", &_mesh, _material_prop_registry, *this)),
441 _kokkos_neighbor_material_props(
443 "kokkos_neighbor_material_props", &_mesh, _material_prop_registry, *this)),
445 _reporter_data(_app),
447 _all_user_objects(_app.getExecuteOnEnum()),
448 _multi_apps(_app.getExecuteOnEnum()),
449 _transient_multi_apps(_app.getExecuteOnEnum()),
450 _transfers(_app.getExecuteOnEnum(), false),
451 _to_multi_app_transfers(_app.getExecuteOnEnum(), false),
452 _from_multi_app_transfers(_app.getExecuteOnEnum(), false),
453 _between_multi_app_transfers(_app.getExecuteOnEnum(), false),
454 #ifdef LIBMESH_ENABLE_AMR
456 _cycles_completed(0),
458 _displaced_mesh(nullptr),
459 _geometric_search_data(*this, _mesh),
461 _reinit_displaced_elem(false),
462 _reinit_displaced_face(false),
463 _reinit_displaced_neighbor(false),
464 _input_file_saved(false),
466 _has_constraints(false),
467 _snesmf_reuse_base(true),
468 _skip_exception_check(false),
469 _snesmf_reuse_base_set_by_user(false),
470 _has_initialized_stateful(false),
471 _const_jacobian(false),
472 _has_jacobian(false),
473 _needs_old_newton_iter(false),
474 _previous_nl_solution_required(getParam<bool>(
"previous_nl_solution_required")),
475 _has_nonlocal_coupling(false),
476 _calculate_jacobian_in_uo(false),
477 _kernel_coverage_check(
479 _kernel_coverage_blocks(getParam<
std::vector<SubdomainName>>(
"kernel_coverage_block_list")),
480 _boundary_restricted_node_integrity_check(
481 getParam<bool>(
"boundary_restricted_node_integrity_check")),
482 _boundary_restricted_elem_integrity_check(
483 getParam<bool>(
"boundary_restricted_elem_integrity_check")),
484 _material_coverage_check(
486 _material_coverage_blocks(getParam<
std::vector<SubdomainName>>(
"material_coverage_block_list")),
487 _fv_bcs_integrity_check(getParam<bool>(
"fv_bcs_integrity_check")),
488 _material_dependency_check(getParam<bool>(
"material_dependency_check")),
489 _uo_aux_state_check(getParam<bool>(
"check_uo_aux_state")),
490 _max_qps(
std::numeric_limits<unsigned
int>::
max()),
492 _has_time_integrator(false),
493 _has_exception(false),
494 _parallel_barrier_messaging(getParam<bool>(
"parallel_barrier_messaging")),
495 _verbose_setup(getParam<
MooseEnum>(
"verbose_setup")),
496 _verbose_multiapps(getParam<bool>(
"verbose_multiapps")),
497 _verbose_restore(getParam<bool>(
"verbose_restore")),
499 _control_warehouse(_app.getExecuteOnEnum(), false),
500 _is_petsc_options_inserted(false),
501 _line_search(nullptr),
502 _using_ad_mat_props(false),
503 _current_ic_state(0),
504 _use_hash_table_matrix_assembly(getParam<bool>(
"use_hash_table_matrix_assembly")),
505 _error_on_jacobian_nonzero_reallocation(
506 isParamValid(
"error_on_jacobian_nonzero_reallocation")
507 ? getParam<bool>(
"error_on_jacobian_nonzero_reallocation")
508 : _app.errorOnJacobianNonzeroReallocation()),
509 _restore_original_nonzero_pattern(isParamValid(
"restore_original_nonzero_pattern")
510 ? getParam<bool>(
"restore_original_nonzero_pattern")
511 : _use_hash_table_matrix_assembly),
512 _ignore_zeros_in_jacobian(getParam<bool>(
"ignore_zeros_in_jacobian")),
513 _preserve_matrix_sparsity_pattern(true),
514 _force_restart(getParam<bool>(
"force_restart")),
515 _allow_ics_during_restart(getParam<bool>(
"allow_initial_conditions_with_restart")),
516 _skip_nl_system_check(getParam<bool>(
"skip_nl_system_check")),
517 _fail_next_system_convergence_check(false),
518 _allow_invalid_solution(getParam<bool>(
"allow_invalid_solution")),
519 _show_invalid_solution_console(getParam<bool>(
"show_invalid_solution_console")),
520 _immediately_print_invalid_solution(getParam<bool>(
"immediately_print_invalid_solution")),
521 _started_initial_setup(false),
522 _has_internal_edge_residual_objects(false),
523 _u_dot_requested(false),
524 _u_dotdot_requested(false),
525 _u_dot_old_requested(false),
526 _u_dotdot_old_requested(false),
529 _print_execution_on(),
530 _identify_variable_groups_in_nl(getParam<bool>(
"identify_variable_groups_in_nl")),
531 _regard_general_exceptions_as_errors(getParam<bool>(
"regard_general_exceptions_as_errors")),
532 _requires_nonlocal_coupling(false)
534 auto checkCoverageCheckConflict =
535 [
this](
const std::string & coverage_check,
537 const std::vector<SubdomainName> & coverage_blocks) ->
void 541 if (coverage_blocks.size() > 1)
542 if (
std::find(coverage_blocks.begin(), coverage_blocks.end(),
"ANY_BLOCK_ID") !=
543 coverage_blocks.end())
545 "The list of blocks used for ",
547 " cannot contain 'ANY_BLOCK_ID' along with other blocks. ");
550 checkCoverageCheckConflict(
552 checkCoverageCheckConflict(
558 ADReal::do_derivatives =
true;
622 std::string restart_file_base = getParam<FileNameNoExtension>(
"restart_file_base");
629 if (restart_file_base.size())
647 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 666 mooseWarning(
"Displaced mesh was requested but the displaced problem does not exist. " 667 "Regular mesh will be returned");
675 auto & vectors = getParam<std::vector<std::vector<TagName>>>(
"extra_tag_vectors");
677 for (
auto & vector : vectors[sys_num])
683 auto & not_zeroed_vectors = getParam<std::vector<std::vector<TagName>>>(
"not_zeroed_tag_vectors");
684 for (
const auto sys_num :
index_range(not_zeroed_vectors))
685 for (
auto & vector : not_zeroed_vectors[sys_num])
696 auto & matrices = getParam<std::vector<std::vector<TagName>>>(
"extra_tag_matrices");
698 for (
auto & matrix : matrices[sys_num])
705 sys->sizeVariableMatrixData();
706 _aux->sizeVariableMatrixData();
712 for (
auto & vector :
getParam<std::vector<TagName>>(
"extra_tag_solutions"))
731 sys->associateVectorToTag(*sys->system().current_local_solution.get(), tag);
732 _aux->associateVectorToTag(*
_aux->system().current_local_solution.get(), tag);
739 sys->needSolutionState(state, iteration_type);
740 _aux->needSolutionState(state, iteration_type);
751 _assembly[i].resize(solver_systems.size());
753 _assembly[i][j] = std::make_unique<Assembly>(*solver_systems[j], i);
759 std::vector<std::shared_ptr<NonlinearSystemBase>> & nls)
761 TIME_SECTION(
"initNullSpaceVectors", 5,
"Initializing Null Space Vectors");
763 unsigned int dimNullSpace =
parameters.
get<
unsigned int>(
"null_space_dimension");
764 unsigned int dimTransposeNullSpace =
765 parameters.
get<
unsigned int>(
"transpose_null_space_dimension");
766 unsigned int dimNearNullSpace =
parameters.
get<
unsigned int>(
"near_null_space_dimension");
767 for (
unsigned int i = 0; i < dimNullSpace; ++i)
769 std::ostringstream oss;
773 for (
auto & nl : nls)
777 for (
unsigned int i = 0; i < dimTransposeNullSpace; ++i)
779 std::ostringstream oss;
783 for (
auto & nl : nls)
787 for (
unsigned int i = 0; i < dimNearNullSpace; ++i)
789 std::ostringstream oss;
793 for (
auto & nl : nls)
808 for (
unsigned int i = 0; i <
n_threads; i++)
824 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 829 CHKERRABORT(this->
comm().
get(), ierr);
838 TIME_SECTION(
"setCoordSystem", 5,
"Setting Coordinate System");
853 std::vector<const DofMap *> dof_maps(
es().n_systems());
857 dof_maps[i] = &sys.get_dof_map();
860 std::make_unique<ConstElemRange>(
_mesh.
getMesh().multi_evaluable_elements_begin(dof_maps),
861 _mesh.
getMesh().multi_evaluable_elements_end(dof_maps));
871 std::vector<const DofMap *> dof_maps(
_nl.size());
873 dof_maps[i] = &
_nl[i]->dofMap();
875 std::make_unique<ConstElemRange>(
_mesh.
getMesh().multi_evaluable_elements_begin(dof_maps),
876 _mesh.
getMesh().multi_evaluable_elements_end(dof_maps));
885 TIME_SECTION(
"initialSetup", 2,
"Performing Initial Setup");
890 mooseError(
"Checkpoint recovery and restart and exodus restart are all mutually exclusive.");
893 mooseWarning(
"MOOSE may fail to catch an exception when the \"skip_exception_check\" parameter " 894 "is used. If you receive a terse MPI error during execution, remove this " 895 "parameter and rerun your simulation");
910 _aux->initSolutionState();
923 TIME_SECTION(
"computingMaxDofs", 3,
"Computing Max Dofs Per Element");
927 max_var_n_dofs_per_elem = mvndpe.
max();
932 max_var_n_dofs_per_node = mvndpn.
max();
934 global_max_var_n_dofs_per_elem =
935 std::max(global_max_var_n_dofs_per_elem, max_var_n_dofs_per_elem);
939 TIME_SECTION(
"assignMaxDofs", 5,
"Assigning Maximum Dofs Per Elem");
941 sys.assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
944 displaced_problem->solverSys(i).assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
946 sys.assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
948 displaced_problem->solverSys(i).assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
953 TIME_SECTION(
"resizingVarValues", 5,
"Resizing Variable Values");
957 _phi_zero[tid].resize(global_max_var_n_dofs_per_elem, std::vector<Real>(
getMaxQps(), 0.));
978 props->setRecovering();
980 #ifdef MOOSE_KOKKOS_ENABLED 983 props->setRecovering();
987 TIME_SECTION(
"restore", 3,
"Restoring from backup");
1014 TIME_SECTION(
"copyingFromExodus", 3,
"Copying Variables From Exodus");
1017 sys->copyVars(*reader);
1018 _aux->copyVars(*reader);
1023 mooseError(
"Need Exodus reader to restart variables but the reader is not available\n" 1024 "Use either FileMesh with an Exodus mesh file or FileMeshGenerator with an " 1025 "Exodus mesh file and with use_for_exodus_restart equal to true");
1041 mooseError(
"Stateful neighbor material properties do not work with mesh adaptivity");
1057 "Doing extra refinements when restarting is NOT supported for sub-apps of a MultiApp");
1067 TIME_SECTION(
"convergenceInitialSetup", 5,
"Initializing Convergence objects");
1075 std::set<std::string> depend_objects_aux =
_aux->getDependObjects();
1079 std::vector<UserObject *> userobjs;
1084 std::map<int, std::vector<UserObject *>> group_userobjs;
1085 for (
auto obj : userobjs)
1086 group_userobjs[obj->getParam<
int>(
"execution_order_group")].push_back(obj);
1088 for (
auto & [group, objs] : group_userobjs)
1089 for (
auto obj : objs)
1090 obj->initialSetup();
1102 TIME_SECTION(
"initializingFunctions", 5,
"Initializing Functions");
1114 TIME_SECTION(
"initializingRandomObjects", 5,
"Initializing Random Objects");
1126 TIME_SECTION(
"ICinitialSetup", 5,
"Setting Up Initial Conditions");
1140 TIME_SECTION(
"materialInitialSetup", 3,
"Setting Up Materials");
1161 #ifdef MOOSE_KOKKOS_ENABLED 1166 TIME_SECTION(
"computingInitialStatefulProps", 3,
"Computing Initial Material Values");
1173 #ifdef MOOSE_KOKKOS_ENABLED 1188 props->setRestartInPlace();
1189 props->setRecovering();
1200 #ifdef LIBMESH_ENABLE_AMR 1206 mooseError(
"Cannot perform initial adaptivity during restart on sub-apps of a MultiApp!");
1211 #endif // LIBMESH_ENABLE_AMR 1222 unsigned short ic_state_max = 0;
1224 auto findMax = [&ic_state_max](
const auto & obj_list)
1226 for (
auto ic : obj_list.getActiveObjects())
1227 ic_state_max =
std::max(ic_state_max, ic->getState());
1234 if (ic_state_max > 0)
1238 std::vector<std::unique_ptr<NumericVector<Real>>> state0_sys_buffers(
_solver_systems.size());
1239 std::unique_ptr<NumericVector<Real>> state0_aux_buffer;
1245 state0_aux_buffer =
_aux->solutionState(0).clone();
1266 _aux->solutionState(0) = *state0_aux_buffer;
1267 _aux->solutionState(0).close();
1280 sys->initialSetup();
1283 _aux->initialSetup();
1290 sys->setSolution(*(sys->system().current_local_solution.get()));
1320 const auto & tis = sys->getTimeIntegrators();
1323 TIME_SECTION(
"timeIntegratorInitialSetup", 5,
"Initializing Time Integrator");
1324 for (
auto & ti : tis)
1335 TIME_SECTION(
"initialSetupMultiApps", 2,
"Initializing MultiApps",
false);
1341 TIME_SECTION(
"initialSetupTransfers", 2,
"Initializing Transfers");
1347 for (
const auto & transfer : to_multi_app_objects)
1349 transfer->setCurrentDirection(Transfer::DIRECTION::TO_MULTIAPP);
1350 transfer->initialSetup();
1355 for (
const auto & transfer : from_multi_app_objects)
1357 transfer->setCurrentDirection(Transfer::DIRECTION::FROM_MULTIAPP);
1358 transfer->initialSetup();
1363 for (
const auto & transfer : between_multi_app_objects)
1365 transfer->setCurrentDirection(Transfer::DIRECTION::BETWEEN_MULTIAPP);
1366 transfer->initialSetup();
1372 TIME_SECTION(
"BoundaryRestrictedNodeIntegrityCheck", 5);
1377 Threads::parallel_reduce(bnd_nodes, bnict);
1381 for (
const auto & bnode : bnd_nodes)
1383 const auto boundary_id = bnode->_bnd_id;
1384 const Node *
const node = bnode->_node;
1391 const Elem *
const an_elem =
1398 for (
auto & nl :
_nl)
1400 const auto & nodal_bcs = nl->getNodalBCWarehouse();
1401 if (!nodal_bcs.hasBoundaryObjects(boundary_id, 0))
1404 const auto & bnd_objects = nodal_bcs.getBoundaryObjects(boundary_id, 0);
1405 for (
const auto & bnd_object : bnd_objects)
1408 if (!bnd_object->requiresGeometricSearch() &&
1409 bnd_object->checkVariableBoundaryIntegrity())
1411 std::set<MooseVariableFieldBase *> vars_to_omit = {
1416 *bnd_object, bnd_object->checkAllVariables(*node, vars_to_omit), bnd_name);
1424 TIME_SECTION(
"BoundaryRestrictedElemIntegrityCheck", 5);
1429 Threads::parallel_reduce(bnd_elems, beict);
1438 mooseError(
"failed to converge initial MultiApp");
1470 TIME_SECTION(
"computeMaterials", 2,
"Computing Initial Material Properties");
1479 for (
unsigned int tid = 0; tid <
n_threads; tid++)
1497 TIME_SECTION(
"lineSearchInitialSetup", 5,
"Initializing Line Search");
1519 "\" has the same name as a scalar variable in the system.");
1530 std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(
nullptr);
1532 displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);
1548 displaced_mesh_refinement->uniformly_coarsen();
1596 _aux->timestepSetup();
1598 sys->timestepSetup();
1611 std::vector<UserObject *> userobjs;
1613 for (
auto obj : userobjs)
1614 obj->timestepSetup();
1641 TIME_SECTION(
"checkNonlocalCoupling", 5,
"Checking Nonlocal Coupling");
1644 for (
auto & nl :
_nl)
1646 const auto & all_kernels = nl->getKernelWarehouse();
1647 const auto & kernels = all_kernels.getObjects(tid);
1648 for (
const auto & kernel : kernels)
1650 std::shared_ptr<NonlocalKernel> nonlocal_kernel =
1652 if (nonlocal_kernel)
1660 nl->getIntegratedBCWarehouse();
1661 const auto & integrated_bcs = all_integrated_bcs.
getObjects(tid);
1662 for (
const auto & integrated_bc : integrated_bcs)
1664 std::shared_ptr<NonlocalIntegratedBC> nonlocal_integrated_bc =
1666 if (nonlocal_integrated_bc)
1679 std::set<const MooseVariableFEBase *> uo_jacobian_moose_vars;
1681 std::vector<ShapeElementUserObject *> objs;
1685 .condition<AttribThread>(tid)
1688 for (
const auto & uo : objs)
1691 const auto & mv_deps = uo->jacobianMooseVariables();
1692 uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1696 std::vector<ShapeSideUserObject *> objs;
1700 .condition<AttribThread>(tid)
1702 for (
const auto & uo : objs)
1705 const auto & mv_deps = uo->jacobianMooseVariables();
1706 uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
1718 for (
unsigned int i = 0; i < moose_vars.size(); ++i)
1720 VariableName var_name = moose_vars[i]->name();
1722 sys->setVariableGlobalDoFs(var_name);
1740 _assembly[tid][i]->prepareJacobianBlock();
1763 for (
auto & nl :
_nl)
1764 nl->prepareFace(tid,
true);
1765 _aux->prepareFace(tid,
false);
1775 const std::vector<dof_id_type> & dof_indices,
1781 _nl[i]->prepare(tid);
1786 _assembly[tid][current_nl_sys_num]->prepareBlock(ivar, jvar, dof_indices);
1791 _assembly[tid][current_nl_sys_num]->prepareBlockNonlocal(
1813 _assembly[tid][i]->setCurrentSubdomainID(did);
1826 _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
1839 _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
2041 std::vector<dof_id_type> & dof_indices,
2042 const std::set<TagID> & tags,
2065 _displaced_problem->addJacobianBlockTags(jacobian, ivar, jvar, dof_map, dof_indices, tags, tid);
2071 jacobian, ivar, jvar, dof_map, dof_indices, jv.
allDofIndices(), tags, tid);
2081 std::vector<dof_id_type> & dof_indices,
2082 std::vector<dof_id_type> & neighbor_dof_indices,
2083 const std::set<TagID> & tags,
2091 neighbor_dof_indices,
2096 jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices, tags, tid);
2135 TIME_SECTION(
"ghostGhostedBoundaries", 3,
"Ghosting Ghosted Boundaries");
2147 "This function is deprecated and no longer performs any function. Please do not call it."));
2155 unsigned int n_points = points.size();
2172 _zero[tid].resize(max_qpts, 0);
2182 _assembly[tid][i]->reinitAtPhysical(elem, points);
2183 _nl[i]->prepare(tid);
2194 bool have_points = n_points > 0;
2209 sys->reinitElem(elem, tid);
2210 _aux->reinitElem(elem, tid);
2218 const std::vector<Point> & phys_points_in_elem,
2222 "Are you calling this method with a displaced mesh element?");
2226 _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
2239 const unsigned int side,
2244 "reinitElemFace with a BoundaryID argument is deprecated because the boundary id was never " 2245 "used. Please call reinitElemFace without the BoundaryID argument instead");
2258 _aux->reinitElemFace(elem, side, tid);
2267 const std::vector<Point> *
const pts,
2268 const std::vector<Real> *
const weights)
2286 _nl[i]->reinitNode(node, tid);
2288 _aux->reinitNode(node, tid);
2300 _nl[i]->reinitNodeFace(node, bnd_id, tid);
2302 _aux->reinitNodeFace(node, bnd_id, tid);
2311 for (
auto & nl :
_nl)
2312 nl->reinitNodes(nodes, tid);
2313 _aux->reinitNodes(nodes, tid);
2322 for (
auto & nl :
_nl)
2323 nl->reinitNodesNeighbor(nodes, tid);
2324 _aux->reinitNodesNeighbor(nodes, tid);
2330 TIME_SECTION(
"reinitScalars", 3,
"Reinitializing Scalar Variables");
2335 for (
auto & nl :
_nl)
2336 nl->reinitScalars(tid, reinit_for_derivative_reordering);
2337 _aux->reinitScalars(tid, reinit_for_derivative_reordering);
2362 _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
2363 _nl[i]->prepareNeighbor(tid);
2367 _aux->prepareNeighbor(tid);
2369 for (
auto & nl :
_nl)
2371 nl->reinitElemFace(elem, side, tid);
2372 nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2374 _aux->reinitElemFace(elem, side, tid);
2375 _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2384 const auto & displaced_ref_pts =
_assembly[tid][0]->qRuleNeighbor()->get_points();
2404 auto & neighbor =
_assembly[tid][0]->neighbor();
2405 auto & neighbor_side =
_assembly[tid][0]->neighborSide();
2407 if (lower_d_elem_neighbor &&
2410 auto qps =
_assembly[tid][0]->qPointsFaceNeighbor().stdVector();
2411 std::vector<Point> reference_points;
2413 lower_d_elem_neighbor->
dim(), lower_d_elem_neighbor, qps, reference_points);
2425 unsigned int neighbor_side,
2426 const std::vector<Point> & physical_points,
2430 "Are you calling this method with a displaced mesh element?");
2435 _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, neighbor_side, physical_points);
2438 _nl[i]->prepareNeighbor(tid);
2440 _aux->prepareNeighbor(tid);
2446 for (
auto & nl :
_nl)
2447 nl->reinitNeighborFace(neighbor, neighbor_side, tid);
2448 _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
2453 const std::vector<Point> & physical_points,
2457 "Are you calling this method with a displaced mesh element?");
2462 _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, physical_points);
2465 _nl[i]->prepareNeighbor(tid);
2467 _aux->prepareNeighbor(tid);
2473 for (
auto & nl :
_nl)
2474 nl->reinitNeighbor(neighbor, tid);
2475 _aux->reinitNeighbor(neighbor, tid);
2486 std::set<const Elem *> displaced_elements;
2491 for (
const auto & elem : displaced_elements)
2514 for (
auto & nl :
_nl)
2515 nl->subdomainSetup(subdomain, tid);
2529 const std::string & name,
2532 parallel_object_only();
2549 mooseError(
"Unrecognized function functor type");
2555 const std::string & name,
2558 parallel_object_only();
2570 const std::string class_name =
"DefaultNonlinearConvergence";
2574 params.
set<
bool>(
"added_as_default") =
true;
2582 const std::string class_name =
"DefaultMultiAppFixedPointConvergence";
2586 params.
set<
bool>(
"added_as_default") =
true;
2593 const std::string class_name =
"DefaultSteadyStateConvergence";
2597 params.
set<
bool>(
"added_as_default") =
true;
2617 std::istringstream ss(
name);
2621 if (ss >> real_value && ss.eof())
2624 params.
set<
Real>(
"value") = real_value;
2625 addFunction(
"ConstantFunction", ss.str(), params);
2630 std::string
vars =
"x,y,z,t,NaN,pi,e";
2635 params.
set<std::string>(
"expression") =
name;
2663 mooseError(
"The Convergence object '",
name,
"' does not exist.");
2668 const std::vector<std::shared_ptr<Convergence>> &
2676 const std::string & name,
2679 parallel_object_only();
2694 mooseError(
"No MeshDivision object named ",
name,
" of appropriate type");
2707 mooseDeprecated(
"FEProblemBase::getNonlinearSystem() is deprecated, please use " 2708 "FEProblemBase::getNonlinearSystemBase() \n");
2710 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
2721 const std::string & name,
2731 std::vector<Distribution *> objs;
2735 .condition<AttribName>(
name)
2738 mooseError(
"Unable to find Distribution with name '" +
name +
"'");
2744 const std::string & name,
2748 for (
auto & sampler : samplers)
2755 std::vector<Sampler *> objs;
2759 .condition<AttribThread>(tid)
2764 "Unable to find Sampler with name '" +
name +
2765 "', if you are attempting to access this object in the constructor of another object then " 2766 "the object being retrieved must occur prior to the caller within the input file.");
2774 const std::set<SubdomainID> *
const active_subdomains)
2776 std::set<SubdomainID> subdomainIDs;
2777 if (active_subdomains->size() == 0)
2780 subdomainIDs.insert(subdomains.begin(), subdomains.end());
2783 subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());
2789 std::string error_prefix =
"";
2792 curr_sys_ptr =
_aux.get();
2793 other_sys_ptr = sys.get();
2794 error_prefix =
"aux";
2798 mooseError(
"Cannot have an auxiliary variable and a solver variable with the same name: ",
2809 const auto stringifyType = [](
FEType t)
2812 mooseError(
"Mismatching types are specified for ",
2814 "variable with name '",
2817 stringifyType(var.
type()),
2819 stringifyType(
type),
2827 std::set<SubdomainID> varSubdomainIDs;
2828 if (varActiveSubdomains.size() == 0)
2831 varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
2834 varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());
2838 const auto isSubset = std::includes(varSubdomainIDs.begin(),
2839 varSubdomainIDs.end(),
2840 subdomainIDs.begin(),
2841 subdomainIDs.end());
2846 const auto stringifySubdomains = [
this](std::set<SubdomainID> subdomainIDs)
2848 std::stringstream s;
2849 for (
auto const i : subdomainIDs)
2857 if (subdomainName.empty())
2860 s << subdomainName <<
" (" << i <<
")";
2865 const std::string msg =
"Mismatching block-restrictions are specified for " +
2866 error_prefix +
"variable with name '" + var_name +
"': {" +
2867 stringifySubdomains(varSubdomainIDs) +
"} and {" +
2868 stringifySubdomains(subdomainIDs) +
"}";
2883 const std::string & var_name,
2886 parallel_object_only();
2888 const auto order = Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order"));
2889 const auto family = Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"));
2890 const auto fe_type =
FEType(order, family);
2892 const auto active_subdomains_vector =
2894 const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
2895 active_subdomains_vector.end());
2902 SolverSystemName sys_name = params.
get<SolverSystemName>(
"solver_sys");
2904 const auto solver_system_number =
solverSysNum(sys_name);
2905 logAdd(
"Variable", var_name, var_type, params);
2906 _solver_systems[solver_system_number]->addVariable(var_type, var_name, params);
2916 std::pair<bool, unsigned int>
2918 const bool error_if_not_found)
const 2925 "If the variable is in our FEProblem solver system map, then it must be in the " 2926 "solver system we expect");
2927 else if (error_if_not_found)
2929 if (
_aux->hasVariable(var_name) ||
_aux->hasScalarVariable(var_name))
2932 " found. Did you specify an auxiliary variable when you meant to specify a " 2933 "solver variable?");
2937 "'. It does not exist in the solver system(s) or auxiliary system");
2945 const std::string & name,
2947 const unsigned int nl_sys_num,
2948 const std::string & base_name,
2949 bool & reinit_displaced)
2955 reinit_displaced =
true;
2978 const std::string & name,
2981 parallel_object_only();
2984 mooseError(
"You are trying to add a Kernel to a linear variable/system, which is not " 2985 "supported at the moment!");
2994 const std::string & name,
2997 parallel_object_only();
3000 mooseError(
"You are trying to add a HDGKernel to a linear variable/system, which is not " 3001 "supported at the moment!");
3010 const std::string & name,
3013 parallel_object_only();
3043 const std::string & name,
3046 parallel_object_only();
3050 mooseError(
"You are trying to add a ScalarKernel to a linear variable/system, which is not " 3051 "supported at the moment!");
3080 const std::string & name,
3083 parallel_object_only();
3088 "You are trying to add a BoundaryCondition to a linear variable/system, which is not " 3089 "supported at the moment!");
3098 const std::string & name,
3101 parallel_object_only();
3105 auto determine_var_param_name = [&
parameters,
this]()
3114 if (!has_secondary_var && !has_primary_var)
3116 "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
3119 return has_secondary_var ?
"secondary_variable" :
"primary_variable";
3123 const auto nl_sys_num =
3126 mooseError(
"You are trying to add a Constraint to a linear variable/system, which is not " 3127 "supported at the moment!");
3151 const std::string & var_name,
3154 parallel_object_only();
3156 const auto order = Utility::string_to_enum<Order>(params.
get<
MooseEnum>(
"order"));
3157 const auto family = Utility::string_to_enum<FEFamily>(params.
get<
MooseEnum>(
"family"));
3158 const auto fe_type =
FEType(order, family);
3160 const auto active_subdomains_vector =
3162 const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
3163 active_subdomains_vector.end());
3171 logAdd(
"AuxVariable", var_name, var_type, params);
3172 _aux->addVariable(var_type, var_name, params);
3183 const std::set<SubdomainID> *
const active_subdomains)
3185 parallel_object_only();
3187 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3192 std::string var_type;
3194 var_type =
"MooseVariableConstMonomial";
3196 var_type =
"MooseVariableScalar";
3198 var_type =
"VectorMooseVariable";
3200 var_type =
"MooseVariable";
3208 if (active_subdomains)
3212 logAdd(
"AuxVariable", var_name, var_type, params);
3213 _aux->addVariable(var_type, var_name, params);
3223 unsigned int components,
3224 const std::set<SubdomainID> *
const active_subdomains)
3226 parallel_object_only();
3228 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3238 params.
set<
unsigned int>(
"components") = components;
3240 if (active_subdomains)
3244 logAdd(
"Variable", var_name,
"ArrayMooseVariable", params);
3245 _aux->addVariable(
"ArrayMooseVariable", var_name, params);
3256 const std::set<SubdomainID> *
const active_subdomains)
3258 parallel_object_only();
3260 mooseDeprecated(
"Please use the addAuxVariable(var_type, var_name, params) API instead");
3275 params.
set<std::vector<Real>>(
"scaling") = {1};
3276 if (active_subdomains)
3280 logAdd(
"ScalarVariable", var_name,
"MooseVariableScalar", params);
3281 _aux->addVariable(
"MooseVariableScalar", var_name, params);
3288 const std::string & name,
3291 parallel_object_only();
3298 if (!
parameters.
get<std::vector<BoundaryName>>(
"boundary").empty())
3326 const std::string & name,
3329 parallel_object_only();
3358 const std::string & name,
3361 parallel_object_only();
3365 mooseError(
"You are trying to add a DiracKernel to a linear variable/system, which is not " 3366 "supported at the moment!");
3398 const std::string & name,
3401 parallel_object_only();
3405 mooseError(
"You are trying to add a DGKernel to a linear variable/system, which is not " 3406 "supported at the moment!");
3438 const std::string & name,
3452 const std::string & name,
3460 const std::string & name,
3465 addObject<FVInterfaceKernel>(
3471 const std::string & name,
3479 const std::string & name,
3489 const std::string & name,
3492 parallel_object_only();
3496 mooseError(
"You are trying to add a InterfaceKernel to a linear variable/system, which is not " 3497 "supported at the moment!");
3529 const std::string & name,
3530 const VariableName & var_name)
3534 std::string restart_method =
"";
3537 "a checkpoint restart, by IC object '" + ic_name +
"' for variable '" +
name +
"'";
3543 restarted_vars.insert(restarted_vars.end(), nodal_vars.begin(), nodal_vars.end());
3544 restarted_vars.insert(restarted_vars.end(), global_vars.begin(), global_vars.end());
3546 if (
std::find(restarted_vars.begin(), restarted_vars.end(), var_name) != restarted_vars.end())
3547 restart_method =
"an Exodus restart, by IC object '" + ic_name +
"' for variable '" +
name +
3548 "' that is also being restarted";
3550 if (!restart_method.empty())
3552 "Initial conditions have been specified during ",
3554 ".\nThis is only allowed if you specify 'allow_initial_conditions_with_restart' to " 3555 "the [Problem], as initial conditions can override restarted fields");
3561 const std::string & name,
3564 parallel_object_only();
3568 const std::string & var_name =
parameters.
get<VariableName>(
"variable");
3583 std::shared_ptr<InitialConditionBase> ic;
3584 if (dynamic_cast<MooseVariable *>(&var))
3586 else if (dynamic_cast<VectorMooseVariable *>(&var))
3588 else if (dynamic_cast<ArrayMooseVariable *>(&var))
3590 else if (dynamic_cast<MooseVariableFVReal *>(&var))
3592 else if (dynamic_cast<MooseLinearVariableFVReal *>(&var))
3595 mooseError(
"Your FE variable in initial condition ",
3597 " must be either of scalar or vector type");
3608 std::shared_ptr<ScalarInitialCondition> ic =
3616 "Variable '", var_name,
"' requested in initial condition '",
name,
"' does not exist.");
3621 const std::string & name,
3624 parallel_object_only();
3628 const std::string & var_name =
parameters.
get<VariableName>(
"variable");
3643 std::shared_ptr<FVInitialConditionBase> ic;
3648 "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
3655 "' requested in finite volume initial condition '",
3657 "' does not exist.");
3663 TIME_SECTION(
"projectSolution", 2,
"Projecting Initial Solutions")
3669 Threads::parallel_reduce(elem_range, cic);
3677 Threads::parallel_reduce(elem_info_range, cfvic);
3681 for (
auto & nl :
_nl)
3682 nl->solution().close();
3683 _aux->solution().close();
3688 Threads::parallel_reduce(bnd_nodes, cbic);
3690 for (
auto & nl :
_nl)
3691 nl->solution().close();
3692 _aux->solution().close();
3700 for (
const auto & ic : ics)
3708 const unsigned int n_scalar_dofs = var.
dofIndices().size();
3709 for (
unsigned int i = 0; i < n_scalar_dofs; i++)
3711 const auto global_index = var.
dofIndices()[i];
3720 sys->solution().close();
3721 sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
3724 _aux->solution().close();
3725 _aux->solution().localize(*
_aux->sys().current_local_solution,
_aux->dofMap().get_send_list());
3732 const std::optional<std::set<VariableName>> & target_vars)
3737 Threads::parallel_reduce(elem_range, cic);
3742 Threads::parallel_reduce(elem_range, cic);
3746 for (
auto & nl :
_nl)
3747 nl->solution().close();
3748 _aux->solution().close();
3753 Threads::parallel_reduce(bnd_nodes, cbic);
3758 Threads::parallel_reduce(bnd_nodes, cbic);
3761 for (
auto & nl :
_nl)
3762 nl->solution().close();
3763 _aux->solution().close();
3771 for (
const auto & ic : ics)
3775 if (target_vars && !target_vars->count(var.
name()))
3783 const unsigned int n_scalar_dofs = var.
dofIndices().size();
3784 for (
unsigned int i = 0; i < n_scalar_dofs; i++)
3786 const auto global_index = var.
dofIndices()[i];
3793 for (
auto & nl :
_nl)
3795 nl->solution().close();
3796 nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
3799 _aux->solution().close();
3800 _aux->solution().localize(*
_aux->sys().current_local_solution,
_aux->dofMap().get_send_list());
3805 Number (*func)(
const Point &,
3807 const std::string &,
3808 const std::string &),
3811 const std::string &,
3812 const std::string &),
3814 const VariableName & target_var)
3816 mooseAssert(!Threads::in_threads,
3817 "We're performing a projection based on data from just the thread 0 variable, so any " 3818 "modifications to the variable solution must have been thread joined already");
3821 const auto var_num = var.number();
3832 DofMap & dof_map = sys.dofMap();
3833 std::set<dof_id_type> dof_indices;
3834 std::vector<dof_id_type> elem_dof_indices;
3836 for (
const auto & elem : elem_range)
3838 dof_map.
dof_indices(elem, elem_dof_indices, var_num);
3839 dof_indices.insert(elem_dof_indices.begin(), elem_dof_indices.end());
3841 std::vector<dof_id_type> dof_indices_v(dof_indices.begin(), dof_indices.end());
3844 std::vector<Real> dof_vals;
3845 temp_vec->get(dof_indices_v, dof_vals);
3846 mooseAssert(sys.solution().closed(),
3847 "The solution should be closed before mapping our projection");
3848 sys.solution().insert(dof_vals, dof_indices_v);
3849 sys.solution().close();
3853 std::shared_ptr<MaterialBase>
3862 name +=
"_neighbor";
3875 "), but its compute flag is set to true. This indicates that MOOSE is " 3876 "computing this property which may not be desired and produce un-expected " 3905 mooseError(
"FEProblemBase::getMaterialData(): Invalid MaterialDataType ",
type);
3908 const std::set<const MooseObject *> &
3923 mooseError(
"FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
3932 "ignore_zeros_in_jacobian",
3933 "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which " 3934 "leads to removing those entries from the Jacobian sparsity pattern");
3947 const std::string & name,
3950 parallel_object_only();
3952 auto add_functor_materials = [&](
const auto &
parameters,
const auto &
name)
3957 std::shared_ptr<MaterialBase> material =
3971 add_functor_materials(disp_params,
name +
"_displaced");
3977 const std::string & name,
3985 const std::string & name,
3993 const std::string & mat_name,
3994 const std::string & name,
3997 parallel_object_only();
4022 std::shared_ptr<MaterialBase> material =
4025 bool discrete = !material->getParam<
bool>(
"compute");
4029 if (material->boundaryRestricted() ||
dynamic_cast<FunctorMaterial *
>(material.get()))
4035 for (
auto && warehouse : warehouses)
4036 warehouse->addObject(material, tid);
4048 std::string object_name;
4057 object_name =
name +
"_face";
4058 std::shared_ptr<MaterialBase> face_material =
4064 current_parameters.set<
bool>(
"_neighbor") =
true;
4065 object_name =
name +
"_neighbor";
4066 std::shared_ptr<MaterialBase> neighbor_material =
4075 for (
auto && warehouse : warehouses)
4076 warehouse->addObjects(material, neighbor_material, face_material, tid);
4081 const auto param_names =
4086 for (
const auto & p_name : param_names)
4089 p_name.parameter());
4091 p_name.parameter());
4093 p_name.parameter());
4095 primary_name, face_name,
false);
4097 primary_name, neighbor_name,
false);
4108 std::set<MooseVariableFEBase *> needed_moose_vars;
4109 std::unordered_set<unsigned int> needed_mat_props;
4118 for (
const auto id : ids)
4125 needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
4126 current_active_elemental_moose_variables.end());
4128 needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());
4139 auto && elem =
_assembly[tid][0]->elem();
4140 unsigned int n_points =
_assembly[tid][0]->qRule()->n_points();
4143 material_data.
resize(n_points);
4147 material_data.swap(*elem);
4160 const bool swap_stateful,
4161 const std::deque<MaterialBase *> *
const reinit_mats)
4167 auto && elem =
_assembly[tid][0]->elem();
4168 unsigned int side =
_assembly[tid][0]->side();
4169 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4172 bnd_material_data.
resize(n_points);
4174 if (swap_stateful && !bnd_material_data.isSwapped())
4175 bnd_material_data.swap(*elem, side);
4178 bnd_material_data.reset(
4182 bnd_material_data.reinit(*reinit_mats);
4184 bnd_material_data.reinit(
4193 const bool swap_stateful,
4194 const std::deque<MaterialBase *> *
const reinit_mats)
4200 const auto *
const elem =
_assembly[tid][0]->elem();
4201 unsigned int side =
_assembly[tid][0]->side();
4202 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4205 bnd_material_data.
resize(n_points);
4207 if (swap_stateful && !bnd_material_data.isSwapped())
4208 bnd_material_data.swap(*elem, side);
4211 bnd_material_data.reset(
4215 bnd_material_data.reinit(*reinit_mats);
4217 bnd_material_data.reinit(
4227 const bool swap_stateful,
4228 const std::deque<MaterialBase *> *
const reinit_mats)
4242 const bool swap_stateful,
4243 const std::deque<MaterialBase *> *
const reinit_mats)
4253 mooseAssert(neighbor,
"neighbor should be non-null");
4255 "The provided blk_id " << blk_id <<
" and neighbor subdomain ID " 4258 unsigned int n_points =
_assembly[tid][0]->qRuleNeighbor()->n_points();
4261 neighbor_material_data.
resize(n_points);
4265 neighbor_material_data.swap(*neighbor, neighbor_side);
4268 neighbor_material_data.reset(
4272 neighbor_material_data.reinit(*reinit_mats);
4274 neighbor_material_data.reinit(
4282 const bool swap_stateful,
4283 const std::deque<MaterialBase *> *
const reinit_mats)
4287 auto && elem =
_assembly[tid][0]->elem();
4288 unsigned int side =
_assembly[tid][0]->side();
4289 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4292 bnd_material_data.
resize(n_points);
4294 if (swap_stateful && !bnd_material_data.isSwapped())
4295 bnd_material_data.swap(*elem, side);
4301 bnd_material_data.reinit(*reinit_mats);
4315 unsigned int side =
_assembly[tid][0]->side();
4316 unsigned int n_points =
_assembly[tid][0]->qRuleFace()->n_points();
4319 bnd_material_data.
resize(n_points);
4321 if (swap_stateful && !bnd_material_data.isSwapped())
4322 bnd_material_data.swap(*elem, side);
4332 auto && elem =
_assembly[tid][0]->elem();
4339 auto && elem =
_assembly[tid][0]->elem();
4340 unsigned int side =
_assembly[tid][0]->side();
4349 unsigned int neighbor_side =
4363 neighbor_side =
_assembly[tid][0]->side();
4364 mooseAssert(neighbor,
"We should have an appropriate value for elem coming from Assembly");
4375 const std::string & name,
4376 const std::string & type,
4380 _console <<
"[DBG] Adding " << system <<
" '" <<
name <<
"' of type " <<
type << std::endl;
4387 const std::string & object_name,
4388 const std::string & var_param_name)
4394 unsigned int sys_num = 0;
4403 const auto var_sys_num = sys_num;
4406 mooseError(
"We dont support setting 'variable' to a variable that is not set to the same " 4407 "system as the 'solver_sys' parameter");
4414 if (sys_num ==
_aux->number())
4430 if (sys_num ==
_aux->number())
4439 const std::string & name,
4446 " already exists. You may not add a Postprocessor by the same name.");
4453 const std::string & name,
4460 " already exists. You may not add a VectorPostprocessor by the same name.");
4467 const std::string & name,
4474 " already exists. You may not add a Reporter by the same name.");
4479 std::vector<std::shared_ptr<UserObject>>
4481 const std::string & name,
4484 parallel_object_only();
4486 std::vector<std::shared_ptr<UserObject>> uos;
4494 std::shared_ptr<UserObject> user_object =
4497 uos.push_back(user_object);
4500 user_object->setPrimaryThreadCopy(uos[0].
get());
4529 if (euo || nuo || duo)
4531 if (suo || duo || isuo || iuo)
4533 if (iuo || duo || isuo)
4538 if ((guo && !tguo) || muo)
4547 const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
4562 std::vector<UserObject *> objs;
4566 .condition<AttribThread>(tid)
4570 mooseError(
"Unable to find user object with name '" +
name +
"'");
4571 mooseAssert(objs.size() == 1,
"Should only find one UO");
4578 std::vector<Positions *> objs;
4582 .condition<AttribName>(
name)
4585 mooseError(
"Unable to find Positions object with name '" +
name +
"'");
4586 mooseAssert(objs.size() == 1,
"Should only find one Positions");
4593 std::vector<UserObject *> objs;
4597 .condition<AttribThread>(0)
4600 return !objs.empty();
4611 std::size_t t_index)
const 4620 std::size_t t_index)
4629 mooseDeprecated(
"FEProblemBase::hasPostprocssor is being removed; use " 4630 "hasPostprocessorValueByName instead.");
4636 const std::string & vector_name,
4637 std::size_t t_index)
const 4645 const std::string & vector_name,
4647 std::size_t t_index)
4657 return getUserObject<VectorPostprocessor>(object_name, tid);
4665 const auto & objects = it.second.getActiveObjects();
4666 for (
const auto & obj : objects)
4667 obj->parentOutputPositionChanged();
4684 TIME_SECTION(
"computeIndicators", 1,
"Computing Indicators");
4688 const auto old_do_derivatives = ADReal::do_derivatives;
4689 ADReal::do_derivatives =
false;
4691 std::vector<std::string>
fields;
4695 for (
const auto & indicator : indicators)
4696 fields.push_back(indicator->name());
4700 for (
const auto & internal_indicator : internal_indicators)
4701 fields.push_back(internal_indicator->name());
4708 _aux->solution().close();
4713 _aux->solution().close();
4716 ADReal::do_derivatives = old_do_derivatives;
4725 TIME_SECTION(
"computeMarkers", 1,
"Computing Markers");
4727 std::vector<std::string>
fields;
4731 for (
const auto & marker : markers)
4732 fields.push_back(marker->name());
4741 for (
const auto & marker : markers)
4742 marker->markerSetup();
4748 _aux->solution().close();
4785 _aux->customSetup(exec_type);
4786 for (
auto & nl :
_nl)
4787 nl->customSetup(exec_type);
4799 std::vector<UserObject *> userobjs;
4801 for (
auto obj : userobjs)
4802 obj->customSetup(exec_type);
4854 std::unique_ptr<NumericVector<Number>> x =
_aux->currentSolution()->clone();
4862 const Real check_tol = 1e-8;
4864 const Real xnorm = x->l2_norm();
4865 *x -= *
_aux->currentSolution();
4866 if (x->l2_norm() > check_tol * xnorm)
4868 const auto & sys =
_aux->system();
4869 const unsigned int n_vars = sys.n_vars();
4870 std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4874 ordered_map.emplace(vnorm, sys.variable_name(i));
4877 std::ostringstream oss;
4878 for (
const auto & [error_norm, var_name] : ordered_map)
4879 oss <<
" {" << var_name <<
", " << error_norm <<
"},\n";
4881 mooseError(
"Aux kernels, user objects appear to have states for aux variables on ",
4883 ".\nVariable error norms in descending order:\n",
4888 if (pp_values.
size() != new_pp_values.
size())
4889 mooseError(
"Second execution for uo/aux state check should not change the number of " 4890 "real reporter values");
4893 pp_values -= new_pp_values;
4894 if (pp_values.
l2_norm() > check_tol * ppnorm)
4897 std::multimap<Real, std::string, std::greater<Real>> ordered_map;
4899 ordered_map.emplace(
std::abs(pp_values(i)), pp_names[i]);
4901 std::ostringstream oss;
4902 for (
const auto & [error_norm, pp_name] : ordered_map)
4903 oss <<
" {" << pp_name <<
", " << error_norm <<
"},\n";
4905 mooseError(
"Aux kernels, user objects appear to have states for real reporter values on ",
4907 ".\nErrors of real reporter values in descending order:\n",
4917 std::vector<UserObject *> objs;
4918 query.queryInto(objs);
4923 for (
auto obj : objs)
4924 if (obj->primaryThreadCopy())
4925 obj->primaryThreadCopy()->threadJoin(*obj);
4931 for (
auto obj : objs)
4933 if (isgen && dynamic_cast<ThreadedGeneralUserObject *>(obj))
4939 _console <<
"[DBG] Initializing, executing & finalizing general UO '" << obj->name()
4964 auto reporter =
dynamic_cast<Reporter *
>(obj);
4973 const std::string & name)
4980 .condition<AttribExecOns>(
type)
5001 TIME_SECTION(
"computeUserObjects", 1,
"Computing User Objects");
5012 std::vector<UserObject *> uos;
5014 std::set<int> execution_groups;
5015 for (
const auto & uo : uos)
5016 execution_groups.insert(uo->getParam<
int>(
"execution_order_group"));
5019 for (
const auto execution_group : execution_groups)
5023 std::vector<GeneralUserObject *> genobjs;
5026 std::vector<UserObject *> userobjs;
5032 .queryInto(userobjs);
5034 std::vector<UserObject *> tgobjs;
5039 std::vector<UserObject *> nodal;
5042 std::vector<MortarUserObject *> mortar;
5045 if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
5054 for (
auto obj : userobjs)
5055 obj->residualSetup();
5056 for (
auto obj : nodal)
5057 obj->residualSetup();
5058 for (
auto obj : mortar)
5059 obj->residualSetup();
5060 for (
auto obj : tgobjs)
5061 obj->residualSetup();
5062 for (
auto obj : genobjs)
5063 obj->residualSetup();
5067 for (
auto obj : userobjs)
5068 obj->jacobianSetup();
5069 for (
auto obj : nodal)
5070 obj->jacobianSetup();
5071 for (
auto obj : mortar)
5072 obj->jacobianSetup();
5073 for (
auto obj : tgobjs)
5074 obj->jacobianSetup();
5075 for (
auto obj : genobjs)
5076 obj->jacobianSetup();
5079 for (
auto obj : userobjs)
5083 if (!userobjs.empty())
5102 for (
const auto & uo : userobjs)
5103 if (
auto euo = dynamic_cast<const ElementUserObject *>(uo);
5104 euo && euo->hasWritableCoupledVariables())
5106 _aux->solution().close();
5107 _aux->system().update();
5115 for (
auto obj : nodal)
5125 for (
const auto & uo : nodal)
5126 if (
auto nuo = dynamic_cast<const NodalUserObject *>(uo);
5127 nuo && nuo->hasWritableCoupledVariables())
5129 _aux->solution().close();
5130 _aux->system().update();
5136 for (
auto obj : mortar)
5138 if (!mortar.empty())
5140 auto create_and_run_mortar_functors = [
this,
type, &mortar](
const bool displaced)
5144 for (
const auto & mortar_interface : mortar_interfaces)
5146 const auto primary_secondary_boundary_pair = mortar_interface.first;
5147 auto mortar_uos_to_execute =
5149 primary_secondary_boundary_pair.second,
5152 const auto & mortar_generation_object = mortar_interface.second;
5154 auto *
const subproblem = displaced
5156 : static_cast<SubProblem *>(
this);
5158 mortar_generation_object,
5162 subproblem->assembly(0, 0));
5168 create_and_run_mortar_functors(
false);
5170 create_and_run_mortar_functors(
true);
5172 for (
auto obj : mortar)
5177 for (
auto obj : tgobjs)
5179 std::vector<GeneralUserObject *> tguos_zero;
5183 .queryInto(tguos_zero);
5184 for (
auto obj : tguos_zero)
5186 std::vector<GeneralUserObject *> tguos;
5187 auto q =
query.clone()
5213 TIME_SECTION(
"executeControls", 1,
"Executing Controls");
5219 for (
const auto & it : controls_wh.getActiveObjects())
5224 std::vector<std::string> & dependent_controls = it->getDependencies();
5225 for (
const auto & depend_name : dependent_controls)
5227 if (controls_wh.hasActiveObject(depend_name))
5229 auto dep_control = controls_wh.getActiveObject(depend_name);
5230 resolver.
addEdge(dep_control, it);
5235 "\" was not created, did you make a " 5236 "spelling mistake or forget to include it " 5237 "in your input file?");
5243 if (!ordered_controls.empty())
5247 for (
const auto & control : ordered_controls)
5260 std::vector<Sampler *> objects;
5264 .condition<AttribThread>(tid)
5266 .queryInto(objects);
5268 if (!objects.empty())
5270 TIME_SECTION(
"executeSamplers", 1,
"Executing Samplers");
5271 FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
5272 FEProblemBase::objectExecuteHelper<Sampler>(objects);
5280 TIME_SECTION(
"updateActiveObjects", 5,
"Updating Active Objects");
5284 for (
auto & nl :
_nl)
5285 nl->updateActive(tid);
5286 _aux->updateActive(tid);
5303 #ifdef MOOSE_KOKKOS_ENABLED 5317 TIME_SECTION(
"reinitBecauseOfGhostingOrNewGeomObjects",
5319 "Reinitializing Because of Geometric Search Objects");
5343 const std::string & name,
5346 parallel_object_only();
5348 const auto nl_sys_num =
5354 mooseError(
"You are trying to add a DGKernel to a linear variable/system, which is not " 5355 "supported at the moment!");
5368 for (
auto & nl :
_nl)
5374 const std::string & name,
5377 parallel_object_only();
5403 std::shared_ptr<Indicator> indicator =
5406 std::shared_ptr<InternalSideIndicatorBase> isi =
5417 const std::string & name,
5420 parallel_object_only();
5454 const std::string & name,
5457 parallel_object_only();
5485 multi_app->setupPositions();
5490 std::shared_ptr<TransientMultiApp> trans_multi_app =
5492 if (trans_multi_app)
5508 std::shared_ptr<MultiApp>
5519 std::string string_direction;
5521 string_direction =
" To ";
5522 else if (from_multiapp)
5523 string_direction =
" From ";
5525 string_direction =
" Between ";
5533 TIME_SECTION(
"execMultiAppTransfers", 1,
"Executing Transfers");
5540 <<
"MultiApps" << COLOR_DEFAULT <<
":" << std::endl;
5543 {
"Name",
"Type",
"From",
"To"});
5546 for (
const auto & transfer : transfers)
5550 table.addRow(multiapp_transfer->name(),
5551 multiapp_transfer->type(),
5552 multiapp_transfer->getFromName(),
5553 multiapp_transfer->getToName());
5560 for (
const auto & transfer : transfers)
5563 transfer->execute();
5570 << COLOR_DEFAULT << std::endl;
5577 << COLOR_DEFAULT << std::endl;
5581 std::vector<std::shared_ptr<Transfer>>
5592 std::vector<std::shared_ptr<Transfer>>
5618 const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
5622 for (
const auto & multi_app : multi_apps)
5623 multi_app->preTransfer(
_dt,
_time);
5632 if (multi_apps.size())
5634 TIME_SECTION(
"execMultiApps", 1,
"Executing MultiApps",
false);
5638 << COLOR_DEFAULT << std::endl;
5640 bool success =
true;
5642 for (
const auto & multi_app : multi_apps)
5644 success = multi_app->solveStep(
_dt,
_time, auto_advance);
5659 << COLOR_DEFAULT << std::endl;
5674 for (
const auto & multi_app : multi_apps)
5675 multi_app->finalize();
5683 for (
const auto & multi_app : multi_apps)
5684 multi_app->postExecute();
5692 if (multi_apps.size())
5693 for (
const auto & multi_app : multi_apps)
5694 multi_app->incrementTStep(
_time);
5702 if (multi_apps.size())
5705 _console << COLOR_CYAN <<
"\nAdvancing MultiApps on " <<
type.name() << COLOR_DEFAULT
5708 for (
const auto & multi_app : multi_apps)
5709 multi_app->finishStep(recurse_through_multiapp_levels);
5714 _console << COLOR_CYAN <<
"Finished Advancing MultiApps on " <<
type.name() <<
"\n" 5715 << COLOR_DEFAULT << std::endl;
5724 if (multi_apps.size())
5726 TIME_SECTION(
"backupMultiApps", 5,
"Backing Up MultiApp");
5729 _console << COLOR_CYAN <<
"\nBacking Up MultiApps on " <<
type.name() << COLOR_DEFAULT
5732 for (
const auto & multi_app : multi_apps)
5733 multi_app->backup();
5738 _console << COLOR_CYAN <<
"Finished Backing Up MultiApps on " <<
type.name() <<
"\n" 5739 << COLOR_DEFAULT << std::endl;
5748 if (multi_apps.size())
5753 _console << COLOR_CYAN <<
"\nRestoring Multiapps on " <<
type.name()
5754 <<
" because of solve failure!" << COLOR_DEFAULT << std::endl;
5756 _console << COLOR_CYAN <<
"\nRestoring MultiApps on " <<
type.name() << COLOR_DEFAULT
5760 for (
const auto & multi_app : multi_apps)
5761 multi_app->restore(force);
5766 _console << COLOR_CYAN <<
"Finished Restoring MultiApps on " <<
type.name() <<
"\n" 5767 << COLOR_DEFAULT << std::endl;
5778 for (
const auto & multi_app : multi_apps)
5779 smallest_dt =
std::min(smallest_dt, multi_app->computeDT());
5789 TIME_SECTION(
"execTransfers", 3,
"Executing Transfers");
5793 for (
const auto & transfer : transfers)
5794 transfer->execute();
5800 const std::string & name,
5803 parallel_object_only();
5834 std::shared_ptr<MultiApp> multiapp;
5847 exec_enum = multiapp->getParam<
ExecFlagEnum>(
"execute_on");
5855 std::shared_ptr<MultiAppTransfer> multi_app_transfer =
5857 if (multi_app_transfer)
5874 if (sys->hasVariable(var_name))
5876 if (
_aux->hasVariable(var_name))
5886 if (sys->hasVariable(var_name))
5894 const std::string & var_name,
5906 if (sys->hasVariable(var_name))
5907 return sys->getFieldVariable<
Real>(tid, var_name);
5908 if (
_aux->hasVariable(var_name))
5909 return _aux->getFieldVariable<
Real>(tid, var_name);
5918 if (sys->hasVariable(var_name))
5919 return sys->getActualFieldVariable<
Real>(tid, var_name);
5920 if (
_aux->hasVariable(var_name))
5921 return _aux->getActualFieldVariable<
Real>(tid, var_name);
5930 if (sys->hasVariable(var_name))
5932 if (
_aux->hasVariable(var_name))
5942 if (sys->hasVariable(var_name))
5944 if (
_aux->hasVariable(var_name))
5954 if (sys->hasScalarVariable(var_name))
5956 if (
_aux->hasScalarVariable(var_name))
5966 if (sys->hasScalarVariable(var_name))
5967 return sys->getScalarVariable(tid, var_name);
5968 if (
_aux->hasScalarVariable(var_name))
5969 return _aux->getScalarVariable(tid, var_name);
5980 else if (
_aux->hasVariable(var_name) ||
_aux->hasScalarVariable(var_name))
5981 return _aux->system();
5983 mooseError(
"Unable to find a system containing the variable " + var_name);
6091 mat->setActiveProperties(mat_prop_ids);
6093 mat->setActiveProperties(mat_prop_ids);
6095 mat->setActiveProperties(mat_prop_ids);
6115 #ifdef LIBMESH_ENABLE_AMR 6125 const std::string & redistributer_name,
6126 const bool use_displaced_mesh)
6130 redistribute_params.
set<std::string>(
"for_whom") = this->
name();
6134 redistribute_params.
set<
bool>(
"use_displaced_mesh") = use_displaced_mesh;
6137 std::shared_ptr<RedistributeProperties> redistributer =
6139 "RedistributeProperties", redistributer_name, redistribute_params);
6153 add_redistributer(
_mesh,
"mesh_property_redistributer",
false);
6155 add_redistributer(
_displaced_problem->mesh(),
"displaced_mesh_property_redistributer",
true);
6157 #endif // LIBMESH_ENABLE_AMR 6177 mooseError(
"Max quadrature points per element assumptions made in some code (e.g. Coupleable ",
6178 "and MaterialPropertyInterface classes) have been violated.\n",
6179 "Complain to Moose developers to have constMaxQpsPerElem increased from ",
6187 _zero[tid].resize(max_qpts, 0);
6230 const bool allow_negative_qweights)
6239 if (order < _aux->getMinQuadratureOrder())
6240 order =
_aux->getMinQuadratureOrder();
6244 volume_order = order;
6252 type, order, volume_order, face_order, block, allow_negative_qweights);
6256 type, order, volume_order, face_order, block, allow_negative_qweights);
6267 mooseError(
"Someone told us (the FEProblemBase) to trust the user coupling matrix, but we " 6268 "haven't been provided a coupling matrix!");
6289 _cm[i] = std::move(cm);
6296 mooseError(
"Someone told us (the FEProblemBase) to trust the user coupling matrix, but we " 6297 "haven't been provided a coupling matrix!");
6305 TIME_SECTION(
"setNonlocalCouplingMatrix", 5,
"Setting Nonlocal Coupling Matrix");
6308 mooseError(
"Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support " 6309 "multiple nonlinear systems with nonlocal kernels.");
6313 auto & nl =
_nl[nl_sys_num];
6315 unsigned int n_vars = nl->nVariables();
6316 nonlocal_cm.resize(
n_vars);
6317 const auto &
vars = nl->getVariables(0);
6320 for (
const auto & ivar :
vars)
6322 for (
const auto & kernel : nonlocal_kernel)
6324 for (
unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6325 if (i == kernel->variable().number())
6326 for (
const auto & jvar :
vars)
6331 unsigned int j = jvar->number();
6332 nonlocal_cm(i, j) = 1;
6336 for (
const auto & integrated_bc : nonlocal_integrated_bc)
6338 for (
unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
6339 if (i == integrated_bc->variable().number())
6340 for (
const auto & jvar :
vars)
6345 unsigned int j = jvar->number();
6346 nonlocal_cm(i, j) = 1;
6356 const unsigned int jvar,
6357 const unsigned int nl_sys)
const 6359 return (*
_cm[nl_sys])(ivar, jvar);
6362 std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
6365 return _assembly[tid][nl_sys]->couplingEntries();
6368 std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> &
6371 return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
6380 TIME_SECTION(
"init", 2,
"Initializing");
6396 unsigned int n_vars = nl->nVariables();
6398 TIME_SECTION(
"fillCouplingMatrix", 3,
"Filling Coupling Matrix");
6403 cm = std::make_unique<CouplingMatrix>(
n_vars);
6404 for (
unsigned int i = 0; i <
n_vars; i++)
6410 cm = std::make_unique<CouplingMatrix>(
n_vars);
6411 for (
unsigned int i = 0; i <
n_vars; i++)
6412 for (
unsigned int j = 0; j <
n_vars; j++)
6422 nl->dofMap()._dof_coupling = cm.get();
6428 nl->dofMap()._dof_coupling =
nullptr;
6430 nl->dofMap().attach_extra_sparsity_function(&
extraSparsity, nl.get());
6431 nl->dofMap().attach_extra_send_list_function(&
extraSendList, nl.get());
6435 mooseError(
"No variables specified in nonlinear system '", nl->name(),
"'.");
6457 for (
auto & nl :
_nl)
6459 nl->turnOffJacobian();
6477 TIME_SECTION(
"EquationSystems::Init", 2,
"Initializing Equation Systems");
6499 "Coupling matrix not set for system " 6501 <<
". This should only happen if a preconditioner was not setup for this system");
6508 #ifdef MOOSE_KOKKOS_ENABLED 6519 std::istringstream ss(nl_sys_name);
6520 unsigned int nl_sys_num;
6521 if (!(ss >> nl_sys_num) || !ss.eof())
6530 std::istringstream ss(linear_sys_name);
6531 unsigned int linear_sys_num;
6532 if (!(ss >> linear_sys_num) || !ss.eof())
6535 return linear_sys_num;
6541 std::istringstream ss(solver_sys_name);
6542 unsigned int solver_sys_num;
6543 if (!(ss >> solver_sys_num) || !ss.eof())
6547 mooseError(
"The solver system number was requested for system '" + solver_sys_name,
6548 "' but this system does not exist in the Problem. Systems can be added to the " 6549 "problem using the 'nl_sys_names'/'linear_sys_names' parameter.\nSystems in the " 6552 solver_sys_num = search->second;
6555 return solver_sys_num;
6562 if (solver_sys->hasVariable(variable_name))
6563 return solver_sys->number();
6564 mooseAssert(
_aux,
"Should have an auxiliary system");
6565 if (
_aux->hasVariable(variable_name))
6566 return _aux->number();
6570 "' was not found in any solver (nonlinear/linear) or auxiliary system");
6576 TIME_SECTION(
"solve", 1,
"Solving",
false);
6590 #if PETSC_RELEASE_LESS_THAN(3, 12, 0) 6629 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 6631 LibmeshPetscCall(PetscOptionsPop());
6648 TIME_SECTION(
"checkExceptionAndStopSolve", 5);
6669 <<
"To recover, the solution will fail and then be re-attempted with a reduced time " 6684 _aux->solution().close();
6698 mooseError(
"The following parallel-communicated exception was detected during " +
6701 "\nBecause this did not occur during residual evaluation, there" 6702 " is no way to handle this, so the solution is aborting.\n");
6710 ADReal::do_derivatives =
true;
6735 TIME_SECTION(
"solve", 1,
"Solving",
false);
6745 #if PETSC_RELEASE_LESS_THAN(3, 12, 0) 6747 options, solver_params));
6765 #if !PETSC_RELEASE_LESS_THAN(3, 12, 0) 6767 LibmeshPetscCall(PetscOptionsPop());
6783 return _nl[nl_sys_num]->nNonlinearIterations();
6789 return _nl[nl_sys_num]->nLinearIterations();
6795 return _nl[nl_sys_num]->finalNonlinearResidual();
6801 return _nl[nl_sys_num]->computingPreSMOResidual();
6807 TIME_SECTION(
"copySolutionsBackwards", 3,
"Copying Solutions Backward");
6810 sys->copySolutionsBackwards();
6811 _aux->copySolutionsBackwards();
6817 TIME_SECTION(
"advanceState", 5,
"Advancing State");
6820 sys->copyOldSolutions();
6821 _aux->copyOldSolutions();
6843 #ifdef MOOSE_KOKKOS_ENABLED 6858 TIME_SECTION(
"restoreSolutions", 5,
"Restoring Solutions");
6862 "There is currently no way to restore not-zeroed vectors.");
6867 _console <<
"Restoring solutions on system " << sys->name() <<
"..." << std::endl;
6868 sys->restoreSolutions();
6872 _console <<
"Restoring solutions on Auxiliary system..." << std::endl;
6873 _aux->restoreSolutions();
6876 _console <<
"Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
6886 TIME_SECTION(
"saveOldSolutions", 5,
"Saving Old Solutions");
6889 sys->saveOldSolutions();
6890 _aux->saveOldSolutions();
6896 TIME_SECTION(
"restoreOldSolutions", 5,
"Restoring Old Solutions");
6899 sys->restoreOldSolutions();
6900 _aux->restoreOldSolutions();
6906 TIME_SECTION(
"outputStep", 1,
"Outputting");
6943 TIME_SECTION(
"onTimestepBegin", 2);
6945 for (
auto & nl :
_nl)
6946 nl->onTimestepBegin();
6962 switch (state.
state)
6971 mooseError(
"Unhandled state ", state.
state,
" in FEProblemBase::getTimeFromStateArg");
6977 const std::string & name,
6980 parallel_object_only();
6992 _aux->addDotVectors();
6993 for (
auto & nl :
_nl)
6995 nl->addDotVectors();
6997 auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
6998 if (!nl->hasVector(tag_udot))
6999 nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
7000 auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
7002 nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
7012 const std::string & name,
7015 parallel_object_only();
7018 mooseError(
"Vector bounds cannot be used with LinearSystems!");
7024 for (
auto & nl :
_nl)
7025 nl->setPredictor(predictor);
7049 residual->scale(-1.0);
7051 return residual->l2_norm();
7057 TIME_SECTION(
"computeResidualL2Norm", 2,
"Computing L2 Norm of Residual");
7061 for (
auto sys :
_nl)
7081 parallel_object_only();
7083 TIME_SECTION(
"computeResidualSys", 5);
7101 const unsigned int nl_sys_num)
7110 mooseAssert(
_fe_vector_tags.empty(),
"This should be empty indicating a clean starting state");
7133 "This should be empty indicating a clean starting state");
7145 for (
auto & tag : tags)
7163 for (
auto index :
make_range(matrix.row_start(), matrix.row_stop()))
7164 matrix.add(index, index, 0);
7167 _aux->zeroVariablesForResidual();
7191 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7196 _aux->residualSetup();
7273 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7274 "contact the MOOSE team for assistance.");
7281 const std::set<TagID> & tags)
7283 parallel_object_only();
7285 TIME_SECTION(
"computeResidualInternal", 1);
7306 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7307 "contact the MOOSE team for assistance.");
7316 TIME_SECTION(
"computeResidualType", 5);
7337 mooseError(
"An unhandled MooseException was raised during residual computation. Please " 7338 "contact the MOOSE team for assistance.");
7345 auto create_exception_message =
7346 [&calling_method](
const std::string & exception_type,
const auto & exception)
7348 return std::string(
"A " + exception_type +
" was raised during FEProblemBase::" +
7349 calling_method +
"\n" + std::string(exception.what()));
7358 setException(create_exception_message(
"libMesh::LogicError", e));
7362 setException(create_exception_message(
"MooseException", e));
7364 catch (
const MetaPhysicL::LogicError & e)
7380 mooseError(create_exception_message(
"libMesh::PetscSolverException", e));
7382 catch (
const std::exception & e)
7384 const auto message = create_exception_message(
"std::exception", e);
7397 parallel_object_only();
7403 TIME_SECTION(
"computeResidualTags", 5,
"Computing Residual");
7405 ADReal::do_derivatives =
false;
7409 _aux->zeroVariablesForResidual();
7423 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7428 _aux->residualSetup();
7499 const unsigned int nl_sys_num)
7506 for (
auto & tag : tags)
7515 const std::set<TagID> & tags)
7517 TIME_SECTION(
"computeJacobianInternal", 1);
7537 TIME_SECTION(
"computeJacobianTags", 5,
"Computing Jacobian");
7539 for (
auto tag : tags)
7551 for (
auto index :
make_range(matrix.row_start(), matrix.row_stop()))
7552 matrix.add(index, index, 0);
7555 _aux->zeroVariablesForJacobian();
7571 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7576 _aux->jacobianSetup();
7584 for (
unsigned int tid = 0; tid <
n_threads; tid++)
7631 const unsigned int nl_sys_num)
7633 TIME_SECTION(
"computeTransientImplicitJacobian", 2);
7655 JacobianBlock jac_block(precond_system, jacobian, ivar, jvar);
7656 std::vector<JacobianBlock *>
blocks = {&jac_block};
7671 "I expect these system numbers to be the same");
7676 TIME_SECTION(
"computeBounds", 1,
"Computing Bounds");
7685 _aux->residualSetup();
7709 const bool compute_gradients)
7711 TIME_SECTION(
"computeLinearSystemSys", 5);
7744 const std::set<TagID> & vector_tags,
7745 const std::set<TagID> & matrix_tags,
7746 const bool compute_gradients)
7748 TIME_SECTION(
"computeLinearSystemTags", 5,
"Computing Linear System");
7752 for (
auto tag : matrix_tags)
7771 _aux->jacobianSetup();
7784 _console <<
"\nA MooseException was raised during Auxiliary variable computation.\n" 7785 <<
"The next solve will fail, the timestep will be reduced, and we will try again.\n" 7815 "I expect these system numbers to be the same");
7818 for (
unsigned int i = 0; i <
subspaceDim(
"NearNullSpace"); ++i)
7820 std::stringstream postfix;
7821 postfix <<
"_" << i;
7822 std::string modename =
"NearNullSpace" + postfix.str();
7832 "I expect these system numbers to be the same");
7834 for (
unsigned int i = 0; i <
subspaceDim(
"NullSpace"); ++i)
7836 std::stringstream postfix;
7837 postfix <<
"_" << i;
7847 "I expect these system numbers to be the same");
7849 for (
unsigned int i = 0; i <
subspaceDim(
"TransposeNullSpace"); ++i)
7851 std::stringstream postfix;
7852 postfix <<
"_" << i;
7862 bool & changed_search_direction,
7863 bool & changed_new_soln)
7866 "I expect these system numbers to be the same");
7877 TIME_SECTION(
"computePostCheck", 2,
"Computing Post Check");
7892 std::unique_ptr<NumericVector<Number>> ghosted_solution =
7894 ghosted_search_direction =
7898 *ghosted_solution = new_soln;
7899 *ghosted_search_direction = search_direction;
7910 new_soln = old_soln;
7911 new_soln.
add(-damping, search_direction);
7912 changed_new_soln =
true;
7919 if (changed_new_soln)
7920 *ghosted_solution = new_soln;
7922 bool updated_solution =
updateSolution(new_soln, *ghosted_solution);
7923 if (updated_solution)
7924 changed_new_soln =
true;
7931 _aux->copyCurrentIntoPreviousNL();
7935 changed_search_direction =
false;
7949 TIME_SECTION(
"computeDamping", 1,
"Computing Damping");
7990 parallel_object_only();
7999 TIME_SECTION(
"updateGeometricSearch", 3,
"Updating Geometric Search");
8010 TIME_SECTION(
"updateMortarMesh", 5,
"Updating Mortar Mesh");
8019 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
8020 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
8024 const bool correct_edge_dropping,
8025 const Real minimum_projection_angle)
8031 primary_secondary_subdomain_pair,
8036 correct_edge_dropping,
8037 minimum_projection_angle);
8040 primary_secondary_subdomain_pair,
8045 correct_edge_dropping,
8046 minimum_projection_angle);
8051 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
8052 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
8053 bool on_displaced)
const 8056 primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
8061 const std::pair<BoundaryID, BoundaryID> & primary_secondary_boundary_pair,
8062 const std::pair<SubdomainID, SubdomainID> & primary_secondary_subdomain_pair,
8066 primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
8080 TIME_SECTION(
"possiblyRebuildGeomSearchPatches", 5,
"Rebuilding Geometric Search Patches");
8114 libmesh_fallthrough();
8120 _console <<
"\n\nUpdating geometric search patches\n" << std::endl;
8136 #ifdef LIBMESH_ENABLE_AMR 8145 mooseError(
"HFEM does not support mesh adaptivity currently.");
8147 TIME_SECTION(
"initialAdaptMesh", 2,
"Performing Initial Adaptivity");
8149 for (
unsigned int i = 0; i < n; i++)
8166 _console <<
"Mesh unchanged, skipping remaining steps..." << std::endl;
8182 TIME_SECTION(
"adaptMesh", 3,
"Adapting Mesh");
8186 bool mesh_changed =
false;
8188 for (
unsigned int i = 0; i < cycles_per_step; ++i)
8191 mooseError(
"HFEM does not support mesh adaptivity currently.");
8197 bool mesh_changed_this_step;
8200 if (mesh_changed_this_step)
8202 mesh_changed =
true;
8215 _console <<
"Mesh unchanged, skipping remaining steps..." << std::endl;
8231 return mesh_changed;
8233 #endif // LIBMESH_ENABLE_AMR 8247 data[tid] = &storage.getMaterialData(tid);
8254 for (
unsigned int i = 0; i <
n_threads; ++i)
8266 TIME_SECTION(
"updateMeshXFEM", 5,
"Updating XFEM");
8268 bool updated =
false;
8271 if (
_xfem->updateHeal())
8276 false,
true,
false);
8282 false,
true,
false);
8285 _console <<
"\nXFEM update complete: Mesh modified" << std::endl;
8288 _console <<
"\nXFEM update complete: Mesh not modified" << std::endl;
8295 const bool contract_mesh,
8296 const bool clean_refinement_flags)
8298 TIME_SECTION(
"meshChanged", 3,
"Handling Mesh Changes");
8316 if (intermediate_change)
8324 if (clean_refinement_flags)
8332 if (!intermediate_change)
8382 for (
auto & nl_sys :
_nl)
8383 nl_sys->reinitMortarFunctors();
8400 Threads::parallel_reduce(range, pmp);
8408 for (
const auto & elem : range)
8421 Threads::parallel_reduce(range, pmp);
8425 for (
const auto & elem : range)
8428 for (
auto && child : coarsened_children)
8464 mdi->meshDisplaced();
8473 Threads::parallel_reduce(elem_range, cmt);
8475 cmt(elem_range,
true);
8477 #ifdef MOOSE_KOKKOS_ENABLED 8486 TIME_SECTION(
"checkProblemIntegrity", 5);
8489 const auto & subdomain_names = getParam<std::vector<SubdomainName>>(
"block");
8491 std::set<SubdomainID> mesh_subdomains(mesh_subdomains_vec.begin(), mesh_subdomains_vec.end());
8497 std::set<SubdomainID>
blocks;
8500 blocks = mesh_subdomains;
8503 blocks = mesh_subdomains;
8511 "\" not found in mesh.");
8523 "\" not found in mesh.");
8527 for (
auto & nl :
_nl)
8528 nl->checkKernelCoverage(
blocks);
8533 #ifdef LIBMESH_ENABLE_AMR 8538 _console <<
"Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n" 8543 std::set<SubdomainID> local_mesh_subs(mesh_subdomains);
8552 bool check_material_coverage =
false;
8554 for (
const auto &
id : ids)
8556 local_mesh_subs.erase(
id);
8557 check_material_coverage =
true;
8568 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8569 local_mesh_subs.erase(
id);
8574 std::set<SubdomainID>
blocks(local_mesh_subs);
8580 "Subdomain \"" + subdomain_name +
"\" not found in mesh.");
8583 for (
const auto id :
blocks)
8584 local_mesh_subs.erase(
id);
8589 for (
auto subdomain_id : mortar_subdomain_ids)
8590 local_mesh_subs.erase(subdomain_id);
8593 if (check_material_coverage && !local_mesh_subs.empty())
8595 std::stringstream extra_subdomain_ids;
8597 std::copy(local_mesh_subs.begin(),
8598 local_mesh_subs.end(),
8599 std::ostream_iterator<unsigned int>(extra_subdomain_ids,
" "));
8601 std::vector<SubdomainID> local_mesh_subs_vec(local_mesh_subs.begin(),
8602 local_mesh_subs.end());
8604 mooseError(
"The following blocks from your input mesh do not contain an active material: " +
8605 extra_subdomain_ids.str() +
8607 ")\nWhen ANY mesh block contains a Material object, " 8608 "all blocks must contain a Material object.\n");
8618 for (
const auto & material : materials)
8619 material->checkStatefulSanity();
8639 mooseError(
"Coordinate transformation parameters, listed below, are only to be used in the " 8640 "context of application to application field transfers at this time. The mesh is " 8641 "not modified by these parameters within an application.\n" 8642 "You should likely use a 'TransformGenerator' in the [Mesh] block to achieve the " 8643 "desired mesh modification.\n\n",
8660 bool mesh_has_second_order_elements =
false;
8666 mesh_has_second_order_elements =
true;
8676 if (mesh_has_second_order_elements)
8678 const std::vector<std::string> & displacement_variables =
8681 for (
const auto & var_name : displacement_variables)
8689 mooseError(
"Error: mesh has SECOND order elements, so all displacement variables must be " 8701 std::set<SubdomainID> user_objects_blocks;
8705 std::set<std::string> names;
8707 std::vector<UserObject *> objects;
8710 for (
const auto & obj : objects)
8711 names.insert(obj->name());
8714 std::set<SubdomainID> difference;
8715 std::set_difference(user_objects_blocks.begin(),
8716 user_objects_blocks.end(),
8717 mesh_subdomains.begin(),
8718 mesh_subdomains.end(),
8719 std::inserter(difference, difference.end()));
8721 if (!difference.empty())
8723 std::ostringstream oss;
8724 oss <<
"One or more UserObjects is referencing a nonexistent block:\n";
8725 for (
const auto &
id : difference)
8733 const std::map<
SubdomainID, std::vector<std::shared_ptr<MaterialBase>>> & materials_map)
8735 for (
const auto & it : materials_map)
8738 std::set<std::string> block_depend_props, block_supplied_props;
8740 for (
const auto & mat1 : it.second)
8742 auto & alldeps = mat1->getMatPropDependencies();
8743 for (
auto & dep : alldeps)
8747 for (
const auto & mat2 : it.second)
8749 const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
8750 block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
8759 std::set<std::string> difference;
8760 std::set_difference(block_depend_props.begin(),
8761 block_depend_props.end(),
8762 block_supplied_props.begin(),
8763 block_supplied_props.end(),
8764 std::inserter(difference, difference.end()));
8766 if (!difference.empty())
8768 std::ostringstream oss;
8769 oss <<
"One or more Material Properties were not supplied on block ";
8771 if (subdomain_name.length() > 0)
8772 oss << subdomain_name <<
" (" << it.first <<
")";
8776 for (
const auto &
name : difference)
8777 oss <<
name <<
"\n";
8783 for (
const auto & it : materials_map)
8785 const auto & materials = it.second;
8786 std::set<std::string> inner_supplied, outer_supplied;
8788 for (
const auto & outer_mat : materials)
8791 outer_supplied = outer_mat->getSuppliedItems();
8792 inner_supplied.clear();
8795 std::map<std::string, std::set<std::string>> prop_to_mat;
8796 for (
const auto &
name : outer_supplied)
8797 prop_to_mat[
name].insert(outer_mat->name());
8799 for (
const auto & inner_mat : materials)
8801 if (outer_mat == inner_mat)
8805 auto outer_mat_type = outer_mat->type();
8806 auto inner_mat_type = inner_mat->type();
8811 if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
8812 inner_mat_type != inner_mat->type())
8815 inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
8816 inner_mat->getSuppliedItems().end());
8818 for (
const auto & inner_supplied_name : inner_supplied)
8819 prop_to_mat[inner_supplied_name].insert(inner_mat->name());
8823 std::set<std::string> intersection;
8824 std::set_intersection(outer_supplied.begin(),
8825 outer_supplied.end(),
8826 inner_supplied.begin(),
8827 inner_supplied.end(),
8828 std::inserter(intersection, intersection.end()));
8830 if (!intersection.empty())
8832 std::ostringstream oss;
8833 oss <<
"The following material properties are declared on block " << it.first
8834 <<
" by multiple materials:\n";
8836 <<
"Material Objects\n";
8837 for (
const auto & outer_name : intersection)
8840 for (
const auto & inner_name : prop_to_mat[outer_name])
8841 oss << inner_name <<
" ";
8863 mooseInfo(
"Restart file ", file_name,
" is NOT being used since we are performing recovery.");
8869 mooseInfo(
"Using ", file_name,
" for restart.");
8873 std::vector<VariableName>
8876 std::vector<VariableName> names;
8880 const std::vector<VariableName> & var_names = sys->getVariableNames();
8881 names.insert(names.end(), var_names.begin(), var_names.end());
8884 const std::vector<VariableName> & aux_var_names =
_aux->getVariableNames();
8885 names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());
8894 "Solver system number '" << solver_sys_num <<
"' is out of bounds. We have '" 8911 auto random_data_ptr = insert_pair.first->second.get();
8921 bnd_mat_side_cache =
false;
8924 if (
_aux->needMaterialOnSide(bnd_id))
8926 bnd_mat_side_cache =
true;
8929 for (
auto & nl :
_nl)
8930 if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
8932 bnd_mat_side_cache =
true;
8946 bnd_mat_side_cache =
true;
8960 interface_mat_side_cache =
false;
8963 for (
auto & nl :
_nl)
8964 if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
8966 interface_mat_side_cache =
true;
8979 interface_mat_side_cache =
true;
8984 interface_mat_side_cache =
true;
8998 for (
auto & nl :
_nl)
8999 if (nl->needInternalNeighborSideMaterial(subdomain_id, tid))
9032 mooseError(
"Previous nonlinear solution is required but not added through " 9033 "Problem/previous_nl_solution_required=true");
9050 const std::string & object_name,
9053 parallel_object_only();
9060 mooseError(
"The name '", object_name,
"' is a reserved name for output objects");
9064 if (output_warehouse.
hasOutput(object_name))
9065 mooseError(
"An output object named '", object_name,
"' already exists");
9071 std::vector<std::string> exclude;
9072 if (object_type ==
"Console")
9074 exclude.push_back(
"execute_on");
9082 else if (object_type ==
"Checkpoint")
9083 exclude.push_back(
"execute_on");
9089 if (common &&
std::find(exclude.begin(), exclude.end(),
"execute_on") != exclude.end() &&
9092 "'execute_on' parameter specified in [Outputs] block is ignored for object '" +
9094 "'.\nDefine this object in its own sub-block of [Outputs] to modify its " 9095 "execution schedule.");
9098 if (object_type ==
"XDR")
9100 else if (object_type ==
"XDA")
9104 if (object_name ==
"auto_recovery_checkpoint")
9136 else if (sys_name ==
"aux0")
9139 mooseError(
"System '" + sys_name +
"' was requested from problem but does not exist.");
9154 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
9155 return *
_nl[sys_num];
9161 mooseAssert(sys_num <
_nl.size(),
"System number greater than the number of nonlinear systems");
9162 return *
_nl[sys_num];
9169 "System number greater than the number of linear systems");
9177 "System number greater than the number of linear systems");
9185 "System number greater than the number of solver systems");
9193 "System number greater than the number of solver systems");
9212 parallel_object_only();
9256 const std::vector<Point> *
const pts,
9257 const std::vector<Real> *
const weights,
9269 unsigned int neighbor_side,
9271 const std::vector<Point> *
const pts,
9272 const std::vector<Real> *
const weights,
9285 std::vector<std::shared_ptr<MaterialBase>> & face_materials,
9286 std::vector<std::shared_ptr<MaterialBase>> & neighbor_materials,
9287 std::set<MooseVariableFieldBase *> & variables,
9292 auto & this_face_mats =
9294 for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
9295 if (face_mat->ghostable())
9297 face_materials.push_back(face_mat);
9298 auto & var_deps = face_mat->getMooseVariableDependencies();
9299 for (
auto * var : var_deps)
9303 "Ghostable materials should only have finite volume variables coupled into them.");
9304 else if (face_mat->hasStatefulProperties())
9305 mooseError(
"Finite volume materials do not currently support stateful properties.");
9306 variables.insert(var);
9313 auto & this_neighbor_mats =
9315 for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
9316 if (neighbor_mat->ghostable())
9318 neighbor_materials.push_back(neighbor_mat);
9320 auto & var_deps = neighbor_mat->getMooseVariableDependencies();
9321 for (
auto * var : var_deps)
9325 "Ghostable materials should only have finite volume variables coupled into them.");
9326 else if (neighbor_mat->hasStatefulProperties())
9327 mooseError(
"Finite volume materials do not currently support stateful properties.");
9328 auto pr = variables.insert(var);
9329 mooseAssert(!pr.second,
9330 "We should not have inserted any new variables dependencies from our " 9331 "neighbor materials that didn't exist for our face materials");
9340 const unsigned int nqp,
9351 "There must be one convergence object per nonlinear system");
9367 const std::vector<ConvergenceName> &
9372 mooseError(
"The nonlinear system convergence name(s) have not been set.");
9387 paramError(
"linear_convergence",
"There must be one convergence object per linear system");
9391 const std::vector<ConvergenceName> &
9396 mooseError(
"The linear convergence name(s) have not been set.");
9399 const ConvergenceName &
9405 mooseError(
"The fixed point convergence name has not been set.");
9408 const ConvergenceName &
9414 mooseError(
"The steady convergence name has not been set.");
9425 _nl[i]->residualSetup();
9439 _nl[i]->jacobianSetup();
9459 return current_nl_sys_num;
9470 return current_linear_sys_num;
9487 std::vector<MortarUserObject *>
9490 const bool displaced,
9491 const std::vector<MortarUserObject *> & mortar_uo_superset)
9493 std::vector<MortarUserObject *> mortar_uos;
9495 : static_cast<SubProblem *>(
this);
9496 for (
auto *
const obj : mortar_uo_superset)
9497 if (obj->onInterface(primary_boundary_id, secondary_boundary_id) &&
9498 (&obj->getSubProblem() == subproblem))
9499 mortar_uos.push_back(obj);
9504 std::vector<MortarUserObject *>
9507 const bool displaced)
9509 std::vector<MortarUserObject *> mortar_uos;
9513 .queryInto(mortar_uos);
9514 return getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced, mortar_uos);
9520 const bool displaced)
9522 const auto mortar_uos =
9524 for (
auto *
const mortar_uo : mortar_uos)
9526 mortar_uo->setNormals();
9527 mortar_uo->reinit();
9559 mooseAssert(nl_sys_num <
_nl.size(),
9560 "System number greater than the number of nonlinear systems");
9569 "System number greater than the number of linear systems");
9582 solver_sys->compute(
type);
9664 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 mooseInfo(Args &&... args) const
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.
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
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)
static const std::string app_param
The name of the parameter that contains the MooseApp.
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.
void projectFunctionOnCustomRange(ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters ¶ms, const VariableName &target_var)
Project a function onto a range of elements for a given variable.
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.
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...
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 ...
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.
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
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
void shift()
Shift current, old, and older material property data storages.
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)
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
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
const T & get() const
Get the restartable value.
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.
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.
std::unordered_set< TagID > _not_zeroed_tagged_vectors
the list of vector tags that will not be zeroed when all other tags are
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.
ExecuteMooseObjectWarehouse< Control > _control_warehouse
The control logic warehouse.
void reinitMaterialsFaceOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on element faces on a boundary (internal or external) This specific routine helps us...
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.
bool _has_kokkos_objects
Whether we have any Kokkos objects.
void updateErrorVectors()
Update the ErrorVectors that have been requested through calls to getErrorVector().
const InputParameters & parameters() const
Get the parameters of the object.
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.
const RestartableEquationSystems & getRestartableEquationSystems() const
Get the RestartableEquationSystems object.
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
void setSteadyStateConvergenceName(const ConvergenceName &convergence_name)
Sets the steady-state detection convergence object name if there is one.
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.
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...
MaterialWarehouse _kokkos_materials
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)
MaterialPropertyRegistry _material_prop_registry
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
bool has_static_condensation() const
std::vector< subdomain_id_type > getSubdomainIDs(const libMesh::MeshBase &mesh, const std::vector< SubdomainName > &subdomain_name)
Get the associated subdomainIDs for the subdomain names that are passed in.
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
std::optional< ConvergenceName > _steady_state_convergence_name
Steady-state detection convergence name.
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.
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.
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.
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
void createTagMatrices(CreateTaggedMatrixKey)
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
const ConvergenceName & getSteadyStateConvergenceName() const
Gets the steady-state detection convergence object name.
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
const std::string & name() const
Get the name of the class.
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.
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.
void sort(THREAD_ID tid=0, bool sort_all_objects=false)
By default, this method only sorts block and boundary-wise object storages that are used by the MOOSE...
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
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 mooseDeprecated(Args &&... args) const
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).
void reinitMaterialsNeighborOnBoundary(const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specif...
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.
void addDefaultSteadyStateConvergence(const InputParameters ¶ms)
Adds the default steady-state detection Convergence.
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
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.
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, const THREAD_ID tid)
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.
std::string typeAndName() const
Get the class's combined type and name; useful in error handling.
MooseApp & _app
The MOOSE application this is associated with.
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
MaterialData & getMaterialData(Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
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.
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
Moose::Kokkos::MaterialPropertyStorage & _kokkos_material_props
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
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::string & getName(const unsigned int id) const
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.
void initKokkos()
Construct Kokkos assembly and systems and allocate Kokkos material property storages.
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 addConsumer(Moose::MaterialDataType type, const MooseObject *object)
Add object as the consumer of storage of type type.
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 mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
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
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
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
const std::set< const MooseObject * > & getConsumers(Moose::MaterialDataType type) const
const std::set< const MooseObject * > & getMaterialPropertyStorageConsumers(Moose::MaterialDataType type) const
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
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
void project_vector(NumericVector< Number > &new_vector, FunctionBase< Number > *f, FunctionBase< Gradient > *g=nullptr, int is_adjoint=-1) const
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()
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
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}.
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
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...
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.
const hit::Node * getHitNode() const
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.
Moose::Kokkos::MaterialPropertyStorage & _kokkos_bnd_material_props
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.
void initKokkosStatefulProps()
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)
Moose::Kokkos::MaterialPropertyStorage & _kokkos_neighbor_material_props
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)
const std::string & _type
The type of this class.
virtual void outputStep(ExecFlagType type)
Output the current step.
void projectInitialConditionOnCustomRange(libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName >> &target_vars=std::nullopt)
Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boun...
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
virtual libMesh::System & system() override
Get the reference to the libMesh system.
bool _verbose_multiapps
Whether or not to be verbose with multiapps.
Key structure for APIs manipulating global vectors/matrices.