84 #include "libmesh/nonlinear_solver.h" 85 #include "libmesh/quadrature_gauss.h" 86 #include "libmesh/dense_vector.h" 87 #include "libmesh/boundary_info.h" 88 #include "libmesh/petsc_matrix.h" 89 #include "libmesh/petsc_vector.h" 90 #include "libmesh/petsc_nonlinear_solver.h" 91 #include "libmesh/numeric_vector.h" 92 #include "libmesh/mesh.h" 93 #include "libmesh/dense_subvector.h" 94 #include "libmesh/dense_submatrix.h" 95 #include "libmesh/dof_map.h" 96 #include "libmesh/sparse_matrix.h" 97 #include "libmesh/petsc_matrix.h" 98 #include "libmesh/default_coupling.h" 99 #include "libmesh/diagonal_matrix.h" 100 #include "libmesh/fe_interface.h" 101 #include "libmesh/petsc_solver_exception.h" 105 #include "petscsnes.h" 115 const std::string & name)
121 _residual_ghosted(NULL),
124 _Re_non_time_tag(-1),
126 _scalar_kernels(false),
128 _preset_nodal_bcs(false),
129 _ad_preset_nodal_bcs(false),
130 #ifdef MOOSE_KOKKOS_ENABLED
131 _kokkos_kernels(false),
132 _kokkos_integrated_bcs(false),
133 _kokkos_nodal_bcs(false),
134 _kokkos_preset_nodal_bcs(false),
135 _kokkos_nodal_kernels(false),
137 _general_dampers(false),
139 _increment_vec(NULL),
140 _use_finite_differenced_preconditioner(false),
141 _fdcoloring(nullptr),
143 _add_implicit_geometric_coupling_entries_to_jacobian(false),
144 _assemble_constraints_separately(false),
145 _need_residual_ghosted(false),
146 _debugging_residuals(false),
150 _n_residual_evaluations(0),
152 _computing_pre_smo_residual(false),
153 _pre_smo_residual(0),
154 _initial_residual(0),
155 _use_pre_smo_residual(false),
156 _print_all_var_norms(false),
158 _has_diag_save_in(false),
159 _has_nodalbc_save_in(false),
160 _has_nodalbc_diag_save_in(false),
161 _computed_scaling(false),
162 _compute_scaling_once(true),
163 _resid_vs_jac_scaling_param(0),
164 _off_diagonals_in_auto_scaling(false),
165 _auto_scaling_initd(false)
183 dof_map.set_implicit_neighbor_dofs(
false);
200 #ifdef MOOSE_KOKKOS_ENABLED 212 functor.second.setupMortarMaterials();
214 functor.second.setupMortarMaterials();
227 TIME_SECTION(
"nlInitialSetup", 2,
"Setting Up Nonlinear System");
232 TIME_SECTION(
"kernelsInitialSetup", 2,
"Setting Up Kernels/BCs/Constraints");
249 std::vector<FVElementalKernel *> fv_elemental_kernels;
252 .template condition<AttribSystem>(
"FVElementalKernel")
253 .
template condition<AttribThread>(tid)
256 for (
auto * fv_kernel : fv_elemental_kernels)
257 fv_kernel->initialSetup();
259 std::vector<FVFluxKernel *> fv_flux_kernels;
262 .template condition<AttribSystem>(
"FVFluxKernel")
263 .
template condition<AttribThread>(tid)
266 for (
auto * fv_kernel : fv_flux_kernels)
267 fv_kernel->initialSetup();
278 #ifdef MOOSE_KOKKOS_ENABLED 287 TIME_SECTION(
"mortarSetup", 2,
"Initializing Mortar Interfaces");
289 auto create_mortar_functors = [
this](
const bool displaced)
293 for (
const auto & mortar_interface : mortar_interfaces)
295 const auto primary_secondary_boundary_pair = mortar_interface.first;
299 const auto & mortar_generation_object = mortar_interface.second;
301 auto & mortar_constraints =
308 auto & mortar_functors =
311 mortar_functors.emplace(primary_secondary_boundary_pair,
313 mortar_generation_object,
321 create_mortar_functors(
false);
322 create_mortar_functors(
true);
356 std::vector<FVFluxBC *> bcs;
359 .template condition<AttribSystem>(
"FVFluxBC")
360 .
template condition<AttribThread>(tid)
363 std::vector<FVInterfaceKernel *> iks;
366 .template condition<AttribSystem>(
"FVInterfaceKernel")
367 .
template condition<AttribThread>(tid)
370 std::vector<FVFluxKernel *> kernels;
373 .template condition<AttribSystem>(
"FVFluxKernel")
374 .
template condition<AttribThread>(tid)
377 for (
auto * bc : bcs)
379 for (
auto * ik : iks)
381 for (
auto * kernel : kernels)
382 kernel->timestepSetup();
392 #ifdef MOOSE_KOKKOS_ENABLED 419 std::vector<FVFluxBC *> bcs;
422 .template condition<AttribSystem>(
"FVFluxBC")
423 .
template condition<AttribThread>(tid)
426 std::vector<FVInterfaceKernel *> iks;
429 .template condition<AttribSystem>(
"FVInterfaceKernel")
430 .
template condition<AttribThread>(tid)
433 std::vector<FVFluxKernel *> kernels;
436 .template condition<AttribSystem>(
"FVFluxKernel")
437 .
template condition<AttribThread>(tid)
440 for (
auto * bc : bcs)
441 bc->customSetup(exec_type);
442 for (
auto * ik : iks)
443 ik->customSetup(exec_type);
444 for (
auto * kernel : kernels)
445 kernel->customSetup(exec_type);
455 #ifdef MOOSE_KOKKOS_ENABLED 472 const std::string & name,
478 std::shared_ptr<KernelBase> kernel =
486 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
488 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
494 const std::string & name,
511 const std::string & name,
517 std::shared_ptr<NodalKernelBase> kernel =
525 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
527 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
533 const std::string & name,
536 std::shared_ptr<ScalarKernelBase> kernel =
546 const std::string & name,
553 std::shared_ptr<BoundaryCondition> bc =
558 const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
560 _vars[tid].addBoundaryVar(boundary_ids, bc_var);
569 if (nbc->checkNodalVar() && !nbc->variable().isNodal())
570 mooseError(
"Trying to use nodal boundary condition '",
572 "' on a non-nodal variable '",
573 nbc->variable().name(),
579 _vars[tid].addBoundaryVars(boundary_ids, nbc->getCoupledVars());
581 if (parameters.get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
583 if (parameters.get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
588 if (dbc && dbc->preset())
592 if (addbc && addbc->preset())
602 _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
604 if (parameters.get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
606 if (parameters.get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
618 const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
619 _vars[tid].addBoundaryVar(boundary_ids, bc_var);
624 _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
629 mooseError(
"Unknown BoundaryCondition type for object named ", bc->name());
634 const std::string & name,
641 if (constraint && constraint->addCouplingEntriesToJacobian())
647 const std::string & name,
652 std::shared_ptr<DiracKernelBase> kernel =
663 const std::string & name,
677 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
679 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
685 const std::string & name,
690 std::shared_ptr<InterfaceKernelBase> interface_kernel =
694 const std::set<BoundaryID> & boundary_ids = interface_kernel->boundaryIDs();
696 _vars[tid].addBoundaryVar(boundary_ids, ik_var);
701 _vars[tid].addBoundaryVars(boundary_ids, interface_kernel->getCoupledVars());
707 const std::string & name,
735 const std::string & name,
744 std::shared_ptr<Split>
762 if (
_app.
parameters().
get<
bool>(
"use_legacy_initial_residual_evaluation_behavior"))
778 mooseError(
"pre-SMO residual is requested but not evaluated.");
830 parallel_object_only();
832 TIME_SECTION(
"nl::computeResidualTags", 5);
837 bool required_residual = tags.find(
residualVectorTag()) == tags.end() ? false :
true;
860 if (required_residual)
866 ti->postResidual(residual);
909 const std::set<TagID> & matrix_tags)
911 const bool required_residual =
921 if (required_residual)
927 ti->postResidual(residual);
965 TIME_SECTION(
"applyPredictor", 2,
"Applying Predictor");
971 _console <<
" Skipping predictor this step" << std::endl;
976 TIME_SECTION(
"initialBCs", 2,
"Applying BCs To Initial Condition");
979 for (
const auto & bnode : bnd_nodes)
982 Node * node = bnode->_node;
990 if (has_preset_nodal_bcs || has_ad_preset_nodal_bcs)
993 if (has_preset_nodal_bcs)
996 for (
const auto & preset_bc : preset_bcs)
997 preset_bc->computeValue(initial_solution);
999 if (has_ad_preset_nodal_bcs)
1002 for (
const auto & preset_bc : preset_bcs_res)
1003 preset_bc->computeValue(initial_solution);
1009 #ifdef MOOSE_KOKKOS_ENABLED 1100 mooseError(
"The required residual vector is not available");
1112 for (
const auto & nc : ncs)
1114 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
1115 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
1117 if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
1121 nc->computeResidual(residual);
1141 for (
const auto & nc : ncs)
1143 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
1144 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
1146 if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
1150 nc->computeJacobian(jacobian);
1161 const bool displaced)
1166 const Elem * primary_elem =
info._elem;
1167 unsigned int primary_side =
info._side_num;
1168 std::vector<Point> points;
1169 points.push_back(
info._closest_point);
1190 const Elem *
const undisplaced_primary_elem =
1192 const Point undisplaced_primary_physical_point =
1193 [&points, displaced, primary_elem, undisplaced_primary_elem]()
1197 const Point reference_point =
1198 FEMap::inverse_map(primary_elem->dim(), primary_elem, points[0]);
1199 return FEMap::map(primary_elem->dim(), undisplaced_primary_elem, reference_point);
1208 undisplaced_primary_elem, primary_side, {undisplaced_primary_physical_point}, 0);
1225 "If we're calling this method with displaced = true, then we better well have a " 1226 "displaced problem");
1231 bool constraints_applied =
false;
1233 for (
const auto & it : penetration_locators)
1244 const auto & constraints =
1246 std::unordered_set<unsigned int> needed_mat_props;
1247 for (
const auto & constraint : constraints)
1249 const auto & mp_deps = constraint->getMatPropDependencies();
1250 needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
1254 for (
unsigned int i = 0; i < secondary_nodes.size(); i++)
1256 dof_id_type secondary_node_num = secondary_nodes[i];
1267 for (
const auto & nfc : constraints)
1269 if (nfc->isExplicitConstraint())
1275 if (nfc->secondaryBoundary() != secondary_boundary ||
1276 nfc->primaryBoundary() != primary_boundary)
1279 if (nfc->shouldApply())
1281 constraints_applied =
true;
1282 nfc->computeSecondaryValue(
solution);
1285 if (nfc->hasWritableCoupledVariables())
1287 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1288 for (
auto * var : nfc->getWritableCoupledVariables())
1290 if (var->isNodalDefined())
1302 std::set<dof_id_type> unique_secondary_node_ids;
1310 const auto & constraints =
1314 unique_secondary_node_ids.clear();
1316 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
1317 meshhelper.active_subdomain_elements_end(secondary_id)))
1319 for (
auto & n : elem->node_ref_range())
1320 unique_secondary_node_ids.insert(n.id());
1323 for (
auto secondary_node_id : unique_secondary_node_ids)
1337 for (
const auto & nec : constraints)
1339 if (nec->shouldApply())
1341 constraints_applied =
true;
1342 nec->computeSecondaryValue(
solution);
1354 if (constraints_applied)
1369 "If we're calling this method with displaced = true, then we better well have a " 1370 "displaced problem");
1375 bool constraints_applied;
1376 bool residual_has_inserted_values =
false;
1378 constraints_applied =
false;
1379 for (
const auto & it : penetration_locators)
1385 constraints_applied =
false;
1394 bool has_writable_variables(
false);
1398 const auto & constraints =
1401 for (
unsigned int i = 0; i < secondary_nodes.size(); i++)
1403 dof_id_type secondary_node_num = secondary_nodes[i];
1414 for (
const auto & nfc : constraints)
1420 if (nfc->secondaryBoundary() != secondary_boundary ||
1421 nfc->primaryBoundary() != primary_boundary)
1424 if (nfc->shouldApply())
1426 constraints_applied =
true;
1427 nfc->computeResidual();
1429 if (nfc->overwriteSecondaryResidual())
1435 const auto & secondary_var = nfc->variable();
1436 const auto & secondary_dofs = secondary_var.dofIndices();
1437 mooseAssert(secondary_dofs.size() == secondary_var.count(),
1438 "We are on a node so there should only be one dof per variable (for " 1439 "an ArrayVariable we should have a number of dofs equal to the " 1440 "number of components");
1446 std::vector<Number> values = {nfc->secondaryResidual()};
1447 residual.
insert(values, secondary_dofs);
1448 residual_has_inserted_values =
true;
1454 if (nfc->hasWritableCoupledVariables())
1456 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1457 has_writable_variables =
true;
1458 for (
auto * var : nfc->getWritableCoupledVariables())
1460 if (var->isNodalDefined())
1471 if (has_writable_variables)
1489 if (constraints_applied)
1494 if (residual_has_inserted_values)
1497 residual_has_inserted_values =
false;
1511 if (constraints_applied)
1516 if (residual_has_inserted_values)
1530 for (
const auto & it : element_pair_locators)
1537 const auto & element_constraints =
1541 const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
1543 for (
const auto & pr : elem_pairs)
1545 const Elem * elem1 = pr.first;
1546 const Elem * elem2 = pr.second;
1554 for (
const auto & ec : element_constraints)
1561 ec->prepareShapes(ec->variable().number());
1562 ec->prepareNeighborShapes(ec->variable().number());
1565 ec->computeResidual();
1575 std::set<dof_id_type> unique_secondary_node_ids;
1577 constraints_applied =
false;
1578 residual_has_inserted_values =
false;
1579 bool has_writable_variables =
false;
1586 const auto & constraints =
1590 unique_secondary_node_ids.clear();
1592 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
1593 meshhelper.active_subdomain_elements_end(secondary_id)))
1595 for (
auto & n : elem->node_ref_range())
1596 unique_secondary_node_ids.insert(n.id());
1599 for (
auto secondary_node_id : unique_secondary_node_ids)
1612 for (
const auto & nec : constraints)
1614 if (nec->shouldApply())
1616 constraints_applied =
true;
1617 nec->computeResidual();
1619 if (nec->overwriteSecondaryResidual())
1622 residual_has_inserted_values =
true;
1628 if (nec->hasWritableCoupledVariables())
1630 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1631 has_writable_variables =
true;
1632 for (
auto * var : nec->getWritableCoupledVariables())
1634 if (var->isNodalDefined())
1647 if (constraints_applied)
1652 if (residual_has_inserted_values)
1663 if (has_writable_variables)
1686 for (
const auto & it : penetration_locators)
1696 const auto & constraints =
1700 const auto secondary_node_num = secondary_nodes[i];
1705 for (
const auto & nfc : constraints)
1707 if (!nfc->isExplicitConstraint())
1714 if (nfc->secondaryBoundary() != secondary_boundary ||
1715 nfc->primaryBoundary() != primary_boundary)
1718 nfc->overwriteBoundaryVariables(soln, secondary_node);
1729 TIME_SECTION(
"residualSetup", 3);
1752 #ifdef MOOSE_KOKKOS_ENABLED 1768 parallel_object_only();
1770 TIME_SECTION(
"computeResidualInternal", 3);
1774 #ifdef MOOSE_KOKKOS_ENABLED 1783 std::vector<UserObject *> uos;
1789 for (
auto & uo : uos)
1790 uo->residualSetup();
1791 for (
auto & uo : uos)
1805 TIME_SECTION(
"Kernels", 3 );
1810 Threads::parallel_reduce(elem_range, cr);
1822 Threads::parallel_reduce(faces, fvr);
1831 Threads::parallel_reduce(faces, fvr);
1847 TIME_SECTION(
"ScalarKernels", 3 );
1855 else if (tags.size() == 1)
1856 scalar_kernel_warehouse =
1862 bool have_scalar_contributions =
false;
1864 for (
const auto & scalar_kernel : scalars)
1866 scalar_kernel->reinit();
1867 const std::vector<dof_id_type> & dof_indices = scalar_kernel->variable().dofIndices();
1873 if (dof >= first_dof && dof < end_dof)
1875 scalar_kernel->computeResidual();
1876 have_scalar_contributions =
true;
1881 if (have_scalar_contributions)
1892 TIME_SECTION(
"NodalKernels", 3 );
1902 Threads::parallel_reduce(range, cnk);
1924 TIME_SECTION(
"NodalKernelBCs", 3 );
1930 Threads::parallel_reduce(bnd_node_range, cnk);
1992 const std::set<TagID> & matrix_tags)
1994 TIME_SECTION(
"computeResidualAndJacobianInternal", 3);
1999 for (
auto tag : matrix_tags)
2008 LibmeshPetscCall(MatSetOption(petsc_matrix->mat(),
2009 MAT_KEEP_NONZERO_PATTERN,
2013 MatSetOption(petsc_matrix->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
2016 MAT_IGNORE_ZERO_ENTRIES,
2025 std::vector<UserObject *> uos;
2031 for (
auto & uo : uos)
2032 uo->residualSetup();
2033 for (
auto & uo : uos)
2047 TIME_SECTION(
"Kernels", 3 );
2052 Threads::parallel_reduce(elem_range, crj);
2060 Threads::parallel_reduce(faces, fvrj);
2069 Threads::parallel_reduce(faces, fvr);
2091 for (
const auto & residual_vector_tag : residual_vector_tags)
2122 else if (tags.size() == 1)
2128 if (!nbc_warehouse->
size())
2135 if (!bnd_nodes.
empty())
2137 TIME_SECTION(
"NodalBCs", 3 );
2139 for (
const auto & bnode : bnd_nodes)
2142 Node * node = bnode->_node;
2151 for (
const auto & nbc : bcs)
2152 if (nbc->shouldApply())
2153 nbc->computeResidual();
2172 if (!bnd_nodes.
empty())
2174 TIME_SECTION(
"NodalBCs", 3 );
2176 for (
const auto & bnode : bnd_nodes)
2179 Node * node = bnode->_node;
2188 for (
const auto & nbc : bcs)
2189 if (nbc->shouldApply())
2190 nbc->computeResidualAndJacobian();
2206 unsigned int s =
number();
2209 for (
unsigned int v = 0; v <
nVariables(); v++)
2210 for (
unsigned int c = 0; c < node.
n_comp(s, v); c++)
2218 std::unordered_map<
dof_id_type, std::vector<dof_id_type>> & graph)
2222 for (
const auto & it : nearest_node_locators)
2224 std::vector<dof_id_type> & secondary_nodes = it.second->_secondary_nodes;
2226 for (
const auto & secondary_node : secondary_nodes)
2228 std::set<dof_id_type> unique_secondary_indices;
2229 std::set<dof_id_type> unique_primary_indices;
2231 auto node_to_elem_pair = node_to_elem_map.find(secondary_node);
2232 if (node_to_elem_pair != node_to_elem_map.end())
2234 const std::vector<dof_id_type> & elems = node_to_elem_pair->second;
2237 for (
const auto & cur_elem : elems)
2239 std::vector<dof_id_type> dof_indices;
2242 for (
const auto & dof : dof_indices)
2243 unique_secondary_indices.insert(dof);
2247 std::vector<dof_id_type> primary_nodes = it.second->_neighbor_nodes[secondary_node];
2249 for (
const auto & primary_node : primary_nodes)
2251 auto primary_node_to_elem_pair = node_to_elem_map.find(primary_node);
2252 mooseAssert(primary_node_to_elem_pair != node_to_elem_map.end(),
2253 "Missing entry in node to elem map");
2254 const std::vector<dof_id_type> & primary_node_elems = primary_node_to_elem_pair->second;
2257 for (
const auto & cur_elem : primary_node_elems)
2259 std::vector<dof_id_type> dof_indices;
2262 for (
const auto & dof : dof_indices)
2263 unique_primary_indices.insert(dof);
2267 for (
const auto & secondary_id : unique_secondary_indices)
2268 for (
const auto & primary_id : unique_primary_indices)
2270 graph[secondary_id].push_back(primary_id);
2271 graph[primary_id].push_back(secondary_id);
2278 for (
const auto & nc : ncs)
2280 std::vector<dof_id_type> primary_dofs;
2281 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
2282 for (
const auto & node_id : primary_node_ids)
2293 std::vector<dof_id_type> secondary_dofs;
2294 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
2295 for (
const auto & node_id : secondary_node_ids)
2306 for (
const auto & primary_id : primary_dofs)
2307 for (
const auto & secondary_id : secondary_dofs)
2309 graph[primary_id].push_back(secondary_id);
2310 graph[secondary_id].push_back(primary_id);
2315 for (
auto & it : graph)
2317 std::vector<dof_id_type> & row = it.second;
2318 std::sort(row.begin(), row.end());
2319 std::vector<dof_id_type>::iterator uit = std::unique(row.begin(), row.end());
2320 row.resize(uit - row.begin());
2334 std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
2338 for (
const auto & it : graph)
2341 const auto & row = it.second;
2343 for (
const auto & coupled_dof : row)
2344 jacobian.add(dof, coupled_dof, 0);
2359 MAT_NEW_NONZERO_ALLOCATION_ERR,
2362 LibmeshPetscCall(MatSetOption(
2363 static_cast<PetscMatrix<Number> &
>(jacobian).mat(), MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
2365 std::vector<numeric_index_type> zero_rows;
2369 "If we're calling this method with displaced = true, then we better well have a " 2370 "displaced problem");
2375 bool constraints_applied;
2377 constraints_applied =
false;
2378 for (
const auto & it : penetration_locators)
2384 constraints_applied =
false;
2396 const auto & constraints =
2399 for (
const auto & secondary_node_num : secondary_nodes)
2412 for (
const auto & nfc : constraints)
2414 if (nfc->isExplicitConstraint())
2420 if (nfc->secondaryBoundary() != secondary_boundary ||
2421 nfc->primaryBoundary() != primary_boundary)
2424 nfc->_jacobian = &jacobian_to_view;
2426 if (nfc->shouldApply())
2428 constraints_applied =
true;
2430 nfc->prepareShapes(nfc->variable().number());
2431 nfc->prepareNeighborShapes(nfc->variable().number());
2433 nfc->computeJacobian();
2435 if (nfc->overwriteSecondaryJacobian())
2438 zero_rows.push_back(nfc->variable().nodalDofIndex());
2441 std::vector<dof_id_type> secondary_dofs(1, nfc->variable().nodalDofIndex());
2447 Real scaling_factor =
2448 nfc->overwriteSecondaryJacobian() ? 1. : nfc->variable().scalingFactor();
2454 nfc->_connected_dof_indices,
2458 if (nfc->addCouplingEntriesToJacobian())
2465 nfc->primaryVariable().dofIndicesNeighbor(),
2471 nfc->primaryVariable().dofIndicesNeighbor(),
2472 nfc->_connected_dof_indices,
2473 nfc->primaryVariable().scalingFactor());
2480 const std::vector<MooseVariableFEBase *> coupled_vars = nfc->getCoupledMooseVars();
2481 for (
const auto & jvar : coupled_vars)
2489 if (nfc->variable().number() == jvar->number() ||
2491 nfc->variable().number(), jvar->number(), this->
number()))
2497 nfc->prepareShapes(nfc->variable().number());
2498 nfc->prepareNeighborShapes(jvar->number());
2500 nfc->computeOffDiagJacobian(jvar->number());
2506 nfc->_connected_dof_indices,
2510 if (nfc->addCouplingEntriesToJacobian())
2517 jvar->dofIndicesNeighbor(),
2523 nfc->variable().dofIndicesNeighbor(),
2524 nfc->_connected_dof_indices,
2525 nfc->variable().scalingFactor());
2542 if (constraints_applied)
2545 MAT_KEEP_NONZERO_PATTERN,
2549 jacobian.zero_rows(zero_rows, 0.0);
2561 if (constraints_applied)
2564 MAT_KEEP_NONZERO_PATTERN,
2568 jacobian.zero_rows(zero_rows, 0.0);
2578 for (
const auto & it : element_pair_locators)
2585 const auto & element_constraints =
2589 const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
2591 for (
const auto & pr : elem_pairs)
2593 const Elem * elem1 = pr.first;
2594 const Elem * elem2 = pr.second;
2602 for (
const auto & ec : element_constraints)
2609 ec->prepareShapes(ec->variable().number());
2610 ec->prepareNeighborShapes(ec->variable().number());
2613 ec->computeJacobian();
2623 std::set<dof_id_type> unique_secondary_node_ids;
2624 constraints_applied =
false;
2631 const auto & constraints =
2635 unique_secondary_node_ids.clear();
2637 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
2638 meshhelper.active_subdomain_elements_end(secondary_id)))
2640 for (
auto & n : elem->node_ref_range())
2641 unique_secondary_node_ids.insert(n.id());
2644 for (
auto secondary_node_id : unique_secondary_node_ids)
2658 for (
const auto & nec : constraints)
2660 if (nec->shouldApply())
2662 constraints_applied =
true;
2664 nec->_jacobian = &jacobian_to_view;
2665 nec->prepareShapes(nec->variable().number());
2666 nec->prepareNeighborShapes(nec->variable().number());
2668 nec->computeJacobian();
2670 if (nec->overwriteSecondaryJacobian())
2673 zero_rows.push_back(nec->variable().nodalDofIndex());
2676 std::vector<dof_id_type> secondary_dofs(1, nec->variable().nodalDofIndex());
2682 nec->_connected_dof_indices,
2683 nec->variable().scalingFactor());
2688 nec->primaryVariable().dofIndicesNeighbor(),
2689 nec->_connected_dof_indices,
2690 nec->primaryVariable().scalingFactor());
2696 const std::vector<MooseVariableFEBase *> coupled_vars = nec->getCoupledMooseVars();
2697 for (
const auto & jvar : coupled_vars)
2705 if (nec->variable().number() == jvar->number() ||
2707 nec->variable().number(), jvar->number(), this->
number()))
2713 nec->prepareShapes(nec->variable().number());
2714 nec->prepareNeighborShapes(jvar->number());
2716 nec->computeOffDiagJacobian(jvar->number());
2722 nec->_connected_dof_indices,
2723 nec->variable().scalingFactor());
2728 nec->variable().dofIndicesNeighbor(),
2729 nec->_connected_dof_indices,
2730 nec->variable().scalingFactor());
2745 if (constraints_applied)
2748 MAT_KEEP_NONZERO_PATTERN,
2752 jacobian.zero_rows(zero_rows, 0.0);
2766 else if (tags.size() == 1)
2780 bool have_scalar_contributions =
false;
2781 for (
const auto & kernel : scalars)
2783 if (!kernel->computesJacobian())
2787 const std::vector<dof_id_type> & dof_indices = kernel->variable().dofIndices();
2793 if (dof >= first_dof && dof < end_dof)
2795 kernel->computeJacobian();
2797 have_scalar_contributions =
true;
2803 if (have_scalar_contributions)
2832 #ifdef MOOSE_KOKKOS_ENABLED 2848 TIME_SECTION(
"computeJacobianInternal", 3);
2855 for (
auto tag : tags)
2864 LibmeshPetscCall(MatSetOption(petsc_matrix->mat(),
2865 MAT_KEEP_NONZERO_PATTERN,
2869 MatSetOption(petsc_matrix->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
2872 MAT_IGNORE_ZERO_ENTRIES,
2879 #ifdef MOOSE_KOKKOS_ENABLED 2886 std::vector<UserObject *> uos;
2892 for (
auto & uo : uos)
2893 uo->jacobianSetup();
2894 for (
auto & uo : uos)
2917 Threads::parallel_reduce(range, cnkjt);
2933 Threads::parallel_reduce(faces, fvj);
2942 Threads::parallel_reduce(faces, fvr);
2958 Threads::parallel_reduce(elem_range, cj);
2980 Threads::parallel_reduce(elem_range, cj);
2993 Threads::parallel_reduce(bnd_range, cnkjt);
3006 Threads::parallel_reduce(elem_range, cj);
3009 for (
unsigned int i = 0; i <
n_threads; i++)
3018 Threads::parallel_reduce(bnd_range, cnkjt);
3030 static bool first =
true;
3055 #if PETSC_RELEASE_GREATER_EQUALS(3, 23, 0) 3057 std::unique_ptr<SparseMatrix<Number>> hash_copy;
3058 if (system_matrix.use_hash_table())
3060 hash_copy = libMesh::cast_ref<PetscMatrix<Number> &>(system_matrix).copy_from_hash();
3061 view_jac_ptr = hash_copy.get();
3064 view_jac_ptr = &system_matrix;
3065 auto & jacobian_to_view = *view_jac_ptr;
3067 auto & jacobian_to_view = system_matrix;
3069 if (&jacobian_to_view == &system_matrix)
3070 system_matrix.
close();
3096 else if (tags.size() == 1)
3113 std::map<std::string, std::set<unsigned int>> bc_involved_vars;
3115 for (
const auto & bid : all_boundary_ids)
3122 for (
const auto & bc : bcs)
3124 const std::vector<MooseVariableFEBase *> & coupled_moose_vars =
3125 bc->getCoupledMooseVars();
3129 std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
3130 for (
const auto & coupled_var : coupled_moose_vars)
3132 var_set.insert(coupled_var->number());
3134 var_set.insert(bc->variable().number());
3154 for (
const auto & bnode : bnd_nodes)
3157 Node * node = bnode->_node;
3165 for (
const auto & bc : bcs)
3168 std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
3174 for (
const auto & it : coupling_entries)
3176 unsigned int ivar = it.first->number(), jvar = it.second->number();
3182 if ((bc->variable().number() == ivar) && var_set.count(jvar) && bc->shouldApply())
3183 bc->computeOffDiagJacobian(jvar);
3186 const auto & coupled_scalar_vars = bc->getCoupledMooseScalarVars();
3187 for (
const auto & jvariable : coupled_scalar_vars)
3189 bc->computeOffDiagJacobianScalar(jvariable->number());
3223 for (
auto & tag : tags)
3242 TIME_SECTION(
"computeJacobianTags", 5);
3264 for (
auto & tag : tags)
3272 const std::set<TagID> & tags)
3274 TIME_SECTION(
"computeJacobianBlocks", 3);
3277 for (
unsigned int i = 0; i <
blocks.size(); i++)
3282 MAT_KEEP_NONZERO_PATTERN,
3286 MAT_NEW_NONZERO_ALLOCATION_ERR,
3299 Threads::parallel_reduce(elem_range, cjb);
3303 for (
unsigned int i = 0; i <
blocks.size(); i++)
3304 blocks[i]->_jacobian.close();
3306 for (
unsigned int i = 0; i <
blocks.size(); i++)
3311 unsigned int ivar =
blocks[i]->_ivar;
3312 unsigned int jvar =
blocks[i]->_jvar;
3315 std::vector<numeric_index_type> zero_rows;
3319 for (
const auto & bnode : bnd_nodes)
3322 Node * node = bnode->_node;
3332 for (
const auto & bc : bcs)
3333 if (bc->variable().number() == ivar && bc->shouldApply())
3379 #ifdef MOOSE_KOKKOS_ENABLED 3395 bool has_active_dampers =
false;
3403 TIME_SECTION(
"computeDampers", 3,
"Computing Dampers");
3404 has_active_dampers =
true;
3417 TIME_SECTION(
"computeDamping::element", 3,
"Computing Element Damping");
3419 has_active_dampers =
true;
3432 TIME_SECTION(
"computeDamping::general", 3,
"Computing General Damping");
3434 has_active_dampers =
true;
3436 for (
const auto & damper : gdampers)
3441 damper->checkMinDamping(gd_damping);
3447 damping =
std::min(gd_damping, damping);
3462 if (has_active_dampers && damping < 1.0)
3463 _console <<
" Damping factor: " << damping << std::endl;
3473 std::set<const Elem *> dirac_elements;
3477 TIME_SECTION(
"computeDirac", 3,
"Computing DiracKernels");
3483 for (
const auto & dkernel : dkernels)
3485 dkernel->clearPoints();
3486 dkernel->addPoints();
3494 DistElemRange range(dirac_elements.begin(), dirac_elements.end(), 1);
3543 std::vector<dof_id_type> & n_nz,
3544 std::vector<dof_id_type> & n_oz)
3550 std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
3565 for (
const auto & git : graph)
3570 if (dof < first_dof_on_proc || dof >= end_dof_on_proc)
3573 const auto & row = git.second;
3577 unsigned int original_row_length = sparsity_row.size();
3579 sparsity_row.insert(sparsity_row.end(), row.begin(), row.end());
3581 SparsityPattern::sort_row(
3582 sparsity_row.begin(), sparsity_row.begin() + original_row_length, sparsity_row.end());
3585 for (
const auto & coupled_dof : row)
3587 if (coupled_dof < first_dof_on_proc || coupled_dof >= end_dof_on_proc)
3589 if (n_oz[local_dof] < n_dofs_not_on_proc)
3594 if (n_nz[local_dof] < n_dofs_on_proc)
3630 mooseError(
"More than one active Preconditioner detected");
3649 const std::set<MooseVariable *> & damped_vars)
3651 for (
const auto & var : damped_vars)
3657 const std::set<MooseVariable *> & damped_vars)
3659 for (
const auto & var : damped_vars)
3667 std::set<SubdomainID> input_subdomains;
3668 std::set<std::string> kernel_variables;
3670 bool global_kernels_exist =
false;
3680 #ifdef MOOSE_KOKKOS_ENABLED 3687 std::vector<FVElementalKernel *> fv_elemental_kernels;
3690 .template condition<AttribSystem>(
"FVElementalKernel")
3691 .queryInto(fv_elemental_kernels);
3693 for (
auto fv_kernel : fv_elemental_kernels)
3695 if (fv_kernel->blockRestricted())
3696 for (
auto block_id : fv_kernel->blockIDs())
3697 input_subdomains.insert(block_id);
3699 global_kernels_exist =
true;
3700 kernel_variables.insert(fv_kernel->variable().name());
3703 if (dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel))
3704 kernel_variables.insert(dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel)
3709 std::vector<FVFluxKernel *> fv_flux_kernels;
3712 .template condition<AttribSystem>(
"FVFluxKernel")
3713 .queryInto(fv_flux_kernels);
3715 for (
auto fv_kernel : fv_flux_kernels)
3717 if (fv_kernel->blockRestricted())
3718 for (
auto block_id : fv_kernel->blockIDs())
3719 input_subdomains.insert(block_id);
3721 global_kernels_exist =
true;
3722 kernel_variables.insert(fv_kernel->variable().name());
3725 std::vector<FVInterfaceKernel *> fv_interface_kernels;
3728 .template condition<AttribSystem>(
"FVInterfaceKernel")
3729 .queryInto(fv_interface_kernels);
3731 for (
auto fvik : fv_interface_kernels)
3732 if (
auto scalar_fvik = dynamic_cast<FVScalarLagrangeMultiplierInterface *>(fvik))
3733 kernel_variables.insert(scalar_fvik->lambdaVariable().name());
3735 std::vector<FVFluxBC *> fv_flux_bcs;
3738 .template condition<AttribSystem>(
"FVFluxBC")
3739 .queryInto(fv_flux_bcs);
3741 for (
auto fvbc : fv_flux_bcs)
3742 if (
auto scalar_fvbc = dynamic_cast<FVBoundaryScalarLagrangeMultiplierConstraint *>(fvbc))
3743 kernel_variables.insert(scalar_fvbc->lambdaVariable().name());
3747 if (!global_kernels_exist)
3749 std::set<SubdomainID> difference;
3750 std::set_difference(mesh_subdomains.begin(),
3751 mesh_subdomains.end(),
3752 input_subdomains.begin(),
3753 input_subdomains.end(),
3754 std::inserter(difference, difference.end()));
3758 difference.erase(
id);
3760 difference.erase(
id);
3762 if (!difference.empty())
3764 std::vector<SubdomainID> difference_vec =
3765 std::vector<SubdomainID>(difference.begin(), difference.end());
3767 std::stringstream missing_block_names;
3768 std::copy(difference_names.begin(),
3769 difference_names.end(),
3770 std::ostream_iterator<std::string>(missing_block_names,
" "));
3771 std::stringstream missing_block_ids;
3772 std::copy(difference.begin(),
3774 std::ostream_iterator<unsigned int>(missing_block_ids,
" "));
3776 mooseError(
"Each subdomain must contain at least one Kernel.\nThe following block(s) lack an " 3778 missing_block_names.str(),
3780 missing_block_ids.str(),
3788 std::set<VariableName> difference;
3789 std::set_difference(variables.begin(),
3791 kernel_variables.begin(),
3792 kernel_variables.end(),
3793 std::inserter(difference, difference.end()));
3796 std::set<VariableName>
vars(difference);
3797 for (
auto & var_name :
vars)
3800 for (
const auto &
id : blks)
3802 difference.erase(var_name);
3805 if (!difference.empty())
3807 std::stringstream missing_kernel_vars;
3808 std::copy(difference.begin(),
3810 std::ostream_iterator<std::string>(missing_kernel_vars,
" "));
3811 mooseError(
"Each variable must be referenced by at least one active Kernel.\nThe following " 3812 "variable(s) lack an active kernel: " +
3813 missing_kernel_vars.str());
3825 std::vector<std::string>
3828 std::vector<std::string> variable_names;
3830 if (time_kernels.hasActiveObjects())
3831 for (
const auto & kernel : time_kernels.getObjects())
3832 variable_names.push_back(kernel->variable().name());
3834 return variable_names;
3844 if (std::static_pointer_cast<MaterialPropertyInterface>(bc)->getMaterialPropertyCalled())
3851 if (std::static_pointer_cast<MaterialPropertyInterface>(ik)->getMaterialPropertyCalled())
3859 if (
auto mpi = std::dynamic_pointer_cast<MaterialPropertyInterface>(ct);
3860 mpi && mpi->getMaterialPropertyCalled())
3872 if (std::static_pointer_cast<MaterialPropertyInterface>(ik)->getMaterialPropertyCalled())
3884 if (std::static_pointer_cast<MaterialPropertyInterface>(dg)->getMaterialPropertyCalled())
3907 const std::set<TagID> & vector_tags,
3908 const std::set<TagID> & matrix_tags)
3910 parallel_object_only();
3915 map_pr.second(compute_type, vector_tags, matrix_tags);
3918 map_pr.second(compute_type, vector_tags, matrix_tags);
3920 catch (MetaPhysicL::LogicError &)
3923 "We caught a MetaPhysicL error in NonlinearSystemBase::mortarConstraints. This is very " 3924 "likely due to AD not having a sufficiently large derivative container size. Please run " 3925 "MOOSE configure with the '--with-derivative-size=<n>' option");
3948 std::set<unsigned int> var_numbers, var_numbers_covered, var_numbers_not_covered;
3950 var_numbers.insert(var_number);
3960 "', provided to the 'scaling_group_variables' parameter, does not exist in " 3961 "the nonlinear system.");
3968 if (!map_pair.second)
3969 mooseError(
"Variable ", var_name,
" is contained in multiple scaling grouplings");
3970 var_numbers_covered.insert(var.
number());
3973 std::set_difference(var_numbers.begin(),
3975 var_numbers_covered.begin(),
3976 var_numbers_covered.end(),
3977 std::inserter(var_numbers_not_covered, var_numbers_not_covered.begin()));
3982 for (
auto var_number : var_numbers_not_covered)
3987 const auto & number_to_var_map =
_vars[0].numberToVariableMap();
3993 libmesh_map_find(number_to_var_map, i)->name()) !=
4006 _console <<
"\nPerforming automatic scaling calculation\n" << std::endl;
4008 TIME_SECTION(
"computeScaling", 3,
"Computing Automatic Scaling");
4015 std::vector<dof_id_type> dof_indices;
4023 auto & dof_map =
dofMap();
4067 auto examine_dof_indices = [
this,
4071 &jac_inverse_scaling_factors,
4072 &resid_inverse_scaling_factors,
4073 &scaling_residual](
const auto & dof_indices,
const auto var_number)
4075 for (
auto dof_index : dof_indices)
4076 if (dof_map.local_index(dof_index))
4081 auto mat_value = (*_scaling_matrix)(dof_index, dof_index);
4087 auto vec_value = scaling_residual(dof_index);
4099 dof_map.dof_indices(elem, dof_indices, i);
4100 examine_dof_indices(dof_indices, i);
4106 dof_map.SCALAR_dof_indices(dof_indices, i);
4107 examine_dof_indices(dof_indices, i);
4115 if (jac_scaling && resid_scaling)
4116 for (MooseIndex(inverse_scaling_factors) i = 0; i < inverse_scaling_factors.size(); ++i)
4119 if (!resid_inverse_scaling_factors[i])
4121 if (!jac_inverse_scaling_factors[i])
4122 inverse_scaling_factors[i] = 1;
4124 inverse_scaling_factors[i] = jac_inverse_scaling_factors[i];
4126 else if (!jac_inverse_scaling_factors[i])
4128 inverse_scaling_factors[i] = resid_inverse_scaling_factors[i];
4130 inverse_scaling_factors[i] =
4134 else if (jac_scaling)
4135 inverse_scaling_factors = jac_inverse_scaling_factors;
4136 else if (resid_scaling)
4137 inverse_scaling_factors = resid_inverse_scaling_factors;
4139 mooseError(
"We shouldn't be calling this routine if we're not performing any scaling");
4142 for (
auto & scaling_factor : inverse_scaling_factors)
4143 if (scaling_factor == 0)
4147 std::vector<Real> flattened_inverse_scaling_factors(
system().
n_vars());
4148 for (
const auto i :
index_range(flattened_inverse_scaling_factors))
4149 flattened_inverse_scaling_factors[i] = inverse_scaling_factors[
_var_to_group_var[i]];
4155 flattened_inverse_scaling_factors);
4168 auto & scaling_vector =
getVector(
"scaling_factors");
4171 const auto & dof_map =
dofMap();
4173 const auto & field_variables =
_vars[0].fieldVariables();
4174 const auto & scalar_variables =
_vars[0].scalars();
4176 std::vector<dof_id_type> dof_indices;
4178 for (
const Elem *
const elem :
4179 as_range(lm_mesh.active_local_elements_begin(), lm_mesh.active_local_elements_end()))
4180 for (
const auto *
const field_var : field_variables)
4182 const auto & factors = field_var->arrayScalingFactor();
4183 for (
const auto i :
make_range(field_var->count()))
4185 dof_map.dof_indices(elem, dof_indices, field_var->number() + i);
4186 for (
const auto dof : dof_indices)
4187 scaling_vector.set(dof, factors[i]);
4191 for (
const auto *
const scalar_var : scalar_variables)
4193 mooseAssert(scalar_var->count() == 1,
4194 "Scalar variables should always have only one component.");
4195 dof_map.SCALAR_dof_indices(dof_indices, scalar_var->number());
4196 for (
const auto dof : dof_indices)
4197 scaling_vector.set(dof, scalar_var->scalingFactor());
4201 scaling_vector.close();
4223 if (!scaling_succeeded)
4238 LibmeshPetscCall(MatFDColoringDestroy(&
_fdcoloring));
4245 mooseError(
"No field split preconditioner is present for this system");
std::string name(const ElemQuality q)
std::vector< std::shared_ptr< TimeIntegrator > > _time_integrators
Time integrator.
virtual void setSolutionUDotDotOld(const NumericVector< Number > &u_dotdot_old)
virtual void reinitNeighborPhys(const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid)=0
virtual void residualSetup(THREAD_ID tid=0) const
NumericVector< Number > & getResidualTimeVector()
Return a numeric vector that is associated with the time tag.
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.
MooseObjectTagWarehouse< NodalKernelBase > _nodal_kernels
NodalKernels for each thread.
NumericVector< Number > * _Re_time
residual vector for time contributions
void computeJacobianBlocks(std::vector< JacobianBlock *> &blocks)
Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditio...
virtual void insert(const T *v, const std::vector< numeric_index_type > &dof_indices)
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
TagID _Re_time_tag
Tag for time contribution residual.
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
unsigned int size(THREAD_ID tid=0) const
Return how many kernels we store in the current warehouse.
std::map< std::pair< BoundaryID, BoundaryID >, PenetrationLocator * > _penetration_locators
dof_id_type end_dof(const processor_id_type proc) const
virtual void addKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a kernel.
virtual void setSolutionUDotDot(const NumericVector< Number > &udotdot)
Set transient term used by residual and Jacobian evaluation.
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
A kernel for hybridized finite element formulations.
MooseObjectTagWarehouse< ResidualObject > _kokkos_nodal_kernels
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
void reinitIncrementAtNodeForDampers(THREAD_ID tid, const std::set< MooseVariable *> &damped_vars)
Compute the incremental change in variables at nodes for dampers.
void overwriteNodeFace(NumericVector< Number > &soln)
Called from explicit time stepping to overwrite boundary positions (explicit dynamics).
Base class for deriving general dampers.
bool _use_pre_smo_residual
Whether to use the pre-SMO initial residual in the relative convergence check.
MoosePreconditioner const * getPreconditioner() 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)
void findImplicitGeometricCouplingEntries(GeometricSearchData &geom_search_data, std::unordered_map< dof_id_type, std::vector< dof_id_type >> &graph)
Finds the implicit sparsity graph between geometrically related dofs.
void setupDampers()
Setup damping stuff (called before we actually start)
Real _initial_residual
The initial (i.e., 0th nonlinear iteration) residual, see setPreSMOResidual for a detailed explanatio...
std::vector< bool > _variable_autoscaled
Container to hold flag if variable is to participate in autoscaling.
void zeroVectorForResidual(const std::string &vector_name)
virtual void cacheResidualNeighbor(const THREAD_ID tid) override
bool identifyVariableGroupsInNL() const
Whether to identify variable groups in nonlinear systems.
void zeroTaggedVectors(const std::set< TagID > &tags)
Zero all vectors for given tags.
const std::set< SubdomainID > & interiorLowerDBlocks() const
Base class for split-based preconditioners.
bool hasActiveBlockObjects(THREAD_ID tid=0) const
std::shared_ptr< DisplacedProblem > displaced_problem
bool hasVector(const std::string &tag_name) const
Check if the named vector exists in the system.
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...
unsigned int n_comp(const unsigned int s, const unsigned int var) const
void applyScalingFactors(const std::vector< Real > &inverse_scaling_factors)
Applies scaling factors to the system's variables.
void computeNodalBCsResidualAndJacobian()
compute the residual and Jacobian for nodal boundary conditions
bool _debugging_residuals
true if debugging residuals
BoundaryID _secondary_boundary
NumericVector< Number > * _Re_non_time
residual vector for non-time contributions
const std::map< SubdomainID, std::vector< std::shared_ptr< T > > > & getActiveBlockObjects(THREAD_ID tid=0) const
MooseObjectTagWarehouse< ResidualObject > _kokkos_kernels
Real computeDamping(const NumericVector< Number > &solution, const NumericVector< Number > &update)
Compute damping.
virtual void reinitNode(const Node *node, const THREAD_ID tid) override
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.
void enforceNodalConstraintsJacobian()
bool _assemble_constraints_separately
Whether or not to assemble the residual and Jacobian after the application of each constraint...
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.
MooseObjectTagWarehouse< DGKernelBase > _dg_kernels
virtual bool haveFV() const override
returns true if this problem includes/needs finite volume functionality.
face_info_iterator ownedFaceInfoBegin()
Iterators to owned faceInfo objects.
void reinitIncrementAtQpsForDampers(THREAD_ID tid, const std::set< MooseVariable *> &damped_vars)
Compute the incremental change in variables at QPs for dampers.
void computeResidualAndJacobianInternal(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
Compute residual and Jacobian from contributions not related to constraints, such as nodal boundary c...
void addImplicitGeometricCouplingEntriesToJacobian(bool add=true)
If called with true this will add entries into the jacobian to link together degrees of freedom that ...
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
bool areCoupled(const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
unsigned int number() const
Get variable number coming from libMesh.
virtual void initialSetup() override
Setup Functions.
Data structure used to hold penetration information.
const std::vector< std::shared_ptr< NodalConstraint > > & getActiveNodalConstraints() const
Access methods for active objects.
NumericVector< Number > * _u_dot_old
old solution vector for u^dot
bool _has_nodalbc_diag_save_in
If there is a nodal BC having diag_save_in.
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
Base class for automatic differentiation Dirichlet BCs.
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...
virtual void getDiracElements(std::set< const Elem *> &elems) override
Fills "elems" with the elements that should be looped over for Dirac Kernels.
void setupDM()
Setup the PETSc DM object (when appropriate)
void setCurrentlyComputingResidual(bool currently_computing_residual) final
Set whether or not the problem is in the process of computing the residual.
void checkKernelCoverage(const std::set< SubdomainID > &mesh_subdomains) const
void addDGKernel(std::string dg_kernel_name, const std::string &name, InputParameters ¶meters)
Adds a DG kernel.
void computeJacobian(libMesh::SparseMatrix< Number > &jacobian, const std::set< TagID > &tags)
Associate jacobian to systemMatrixTag, and then form a matrix for all the tags.
const InputParameters & parameters() const
Get the parameters of the object.
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< T * > & queryInto(std::vector< T *> &results, Args &&... args)
queryInto executes the query and stores the results in the given vector.
void getNodeDofs(dof_id_type node_id, std::vector< dof_id_type > &dofs)
Base class for all Constraint types.
std::set< TagID > _nl_vector_tags
Vector tags to temporarily store all tags associated with the current system.
std::vector< std::string > _ignore_variables_for_autoscaling
A container for variables that do not partipate in autoscaling.
void residualSetup() override
Base boundary condition of a Dirichlet type.
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
MooseObjectTagWarehouse< NodalBCBase > _nodal_bcs
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...
const std::vector< std::shared_ptr< NodeFaceConstraint > > & getActiveNodeFaceConstraints(BoundaryID boundary_id, bool displaced) const
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
MooseObjectWarehouse< T > & getVectorTagsObjectWarehouse(const std::set< TagID > &tags, THREAD_ID tid)
Retrieve a moose object warehouse in which every moose object at least has one of the given vector ta...
virtual const Node * queryNodePtr(const dof_id_type i) const
const ElementPairInfo & getElemPairInfo(std::pair< const Elem *, const Elem *> elem_pair) const
MooseObjectWarehouseBase< Split > _splits
Decomposition splits.
NumericVector< Number > * _u_dotdot
solution vector for u^dotdot
bool hasActiveMortarConstraints(const std::pair< BoundaryID, BoundaryID > &mortar_interface_key, bool displaced) const
const Parallel::Communicator & comm() const
NumericVector< Number > & add_vector(std::string_view vec_name, const bool projections=true, const ParallelType type=PARALLEL)
Solving a linear problem.
bool _has_nodalbc_save_in
If there is a nodal BC having save_in.
bool hasActiveNodalConstraints() const
Deterimine if active objects exist.
virtual bool hasMatrix(TagID tag) const
Check if the tagged matrix exists in the system.
MooseObjectWarehouse< NodalDamper > _nodal_dampers
Nodal Dampers for each thread.
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.
virtual libMesh::NonlinearSolver< Number > * nonlinearSolver()=0
dof_id_type n_dofs(const unsigned int vn) const
Real preSMOResidual() const
The pre-SMO residual.
std::unique_ptr< libMesh::DiagonalMatrix< Number > > _scaling_matrix
A diagonal matrix used for computing scaling.
virtual void setSolutionUDotOld(const NumericVector< Number > &u_dot_old)
virtual void associateMatrixToTag(libMesh::SparseMatrix< Number > &matrix, TagID tag)
Associate a matrix to a tag.
bool hasDiagSaveIn() const
Weather or not the nonlinear system has diagonal Jacobian save-ins.
This class provides an interface for common operations on field variables of both FE and FV types wit...
const Parallel::Communicator & _communicator
void updateActive(THREAD_ID tid=0) override
Update the various active lists.
Real initialResidual() const
The initial residual.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
bool needInterfaceMaterialOnSide(BoundaryID bnd_id, THREAD_ID tid) const
Indicated whether this system needs material properties on interfaces.
const libMesh::ConstElemRange & getCurrentAlgebraicElementRange()
These are the element and nodes that contribute to the jacobian and residual for this local processor...
MooseObjectWarehouse< ResidualObject > _kokkos_preset_nodal_bcs
std::size_t _num_scaling_groups
The number of scaling groups.
const libMesh::ConstNodeRange & getCurrentAlgebraicNodeRange()
void computingScalingJacobian(bool computing_scaling_jacobian)
Setter for whether we're computing the scaling jacobian.
dof_id_type n_local_dofs(const unsigned int vn) const
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
bool has_dofs(const unsigned int s=libMesh::invalid_uint) const
std::map< dof_id_type, PenetrationInfo * > & _penetration_info
Data structure of nodes and their associated penetration information.
bool hasActiveNodeElemConstraints(SubdomainID secondary_id, SubdomainID primary_id, bool displaced) const
Real _pre_smo_residual
The pre-SMO residual, see setPreSMOResidual for a detailed explanation.
bool hasDampers()
Whether or not this system has dampers.
const std::vector< std::shared_ptr< NodeElemConstraintBase > > & getActiveNodeElemConstraints(SubdomainID secondary_id, SubdomainID primary_id, bool displaced) const
bool _compute_scaling_once
Whether the scaling factors should only be computed once at the beginning of the simulation through a...
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.
bool _has_save_in
If there is any Kernel or IntegratedBC having save_in.
virtual const Node & nodeRef(const dof_id_type i) const
TagID _Ke_system_tag
Tag for system contribution Jacobian.
virtual void setResidual(NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
dof_id_type n_dofs() const
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.
auto max(const L &left, const R &right)
Serves as a base class for DGKernel and ADDGKernel.
const Variable & variable(const unsigned int c) const override
void constraintResiduals(NumericVector< Number > &residual, bool displaced)
Add residual contributions from Constraints.
Base class for MOOSE preconditioners.
NumericVector< Number > & addVector(const std::string &vector_name, const bool project, const libMesh::ParallelType type)
Adds a solution length vector to the system.
virtual GeometricSearchData & geomSearchData() override
std::unordered_map< std::pair< BoundaryID, BoundaryID >, ComputeMortarFunctor > _undisplaced_mortar_functors
Functors for computing undisplaced mortar constraints.
Specialization for filling multiple "small" preconditioning matrices simulatenously.
virtual bool matrixFromColoring() const
Whether a system matrix is formed from coloring.
void update()
Update the system (doing libMesh magic)
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num) override
void addScalarKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a scalar kernel.
void addBoundaryCondition(const std::string &bc_name, const std::string &name, InputParameters ¶meters)
Adds a boundary condition.
bool hasActiveNodeFaceConstraints(BoundaryID boundary_id, bool displaced) const
void computeResidual(NumericVector< Number > &residual, TagID tag_id)
Form a residual vector for a given tag.
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...
virtual unsigned int nVariables() const
Get the number of variables in this system.
EXTERN_C_BEGIN PetscErrorCode DMCreate_Moose(DM)
bool hasActiveBoundaryObjects(THREAD_ID tid=0) const
bool _need_residual_ghosted
Whether or not a ghosted copy of the residual needs to be made.
virtual void activateAllMatrixTags()
Make all existing matrices active.
virtual const std::string & name() const
virtual void jacobianSetup()
virtual bool containsTimeKernel() override
If the system has a kernel that corresponds to a time derivative.
void onTimestepBegin()
Called at the beginning of the time step.
const ConstBndNodeRange & getCurrentAlgebraicBndNodeRange()
std::vector< dof_id_type, Threads::scalable_allocator< dof_id_type > > Row
MooseObjectTagWarehouse< DiracKernelBase > _dirac_kernels
Dirac Kernel storage for each thread.
void closeTaggedMatrices(const std::set< TagID > &tags)
Close all matrices associated the tags.
TagID _Re_non_time_tag
Tag for non-time contribution residual.
std::set< TagID > _nl_matrix_tags
Matrix tags to temporarily store all tags associated with the current system.
void solutionInvalidAccumulation()
Pass the number of solution invalid occurrences from current iteration to cumulative counters...
void set_basic_system_only()
std::map< std::pair< BoundaryID, BoundaryID >, NearestNodeLocator * > _nearest_node_locators
void setPredictor(std::shared_ptr< Predictor > predictor)
Real _resid_vs_jac_scaling_param
The param that indicates the weighting of the residual vs the Jacobian in determining variable scalin...
bool _auto_scaling_initd
Whether we've initialized the automatic scaling data structures.
virtual void computeScalingResidual()=0
Compute a "residual" for automatic scaling purposes.
bool _doing_dg
true if DG is active (optimization reasons)
virtual libMesh::DofMap & dofMap()
Gets writeable reference to the dof map.
void syncIteration()
Sync iteration counts to main processor.
virtual void deactivateAllMatrixTags()
Make matrices inactive.
unsigned int number() const
void computeResidualAndJacobianTags(const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
Form possibly multiple tag-associated vectors and matrices.
bool needBoundaryMaterialOnSide(BoundaryID bnd_id, THREAD_ID tid) const
Indicated whether this system needs material properties on boundaries.
MooseObjectWarehouse< DirichletBCBase > _preset_nodal_bcs
std::unordered_map< unsigned int, unsigned int > _var_to_group_var
A map from variable index to group variable index and it's associated (inverse) scaling factor...
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...
std::vector< unsigned int > _current_l_its
virtual std::unique_ptr< Base > create()=0
void setCurrentNonlinearSystem(const unsigned int nl_sys_num)
std::shared_ptr< T > getActiveObject(const std::string &name, THREAD_ID tid=0) const
This is the common base class for the three main kernel types implemented in MOOSE, Kernel, VectorKernel and ArrayKernel.
std::vector< dof_id_type > _secondary_nodes
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
void min(const T &r, T &o, Request &req) const
void computeDiracContributions(const std::set< TagID > &tags, bool is_jacobian)
void updateActive(THREAD_ID tid)
Update active objects of Warehouses owned by NonlinearSystemBase.
TheWarehouse & theWarehouse() const
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
const ElementPairList & getElemPairs() const
FieldSplitPreconditionerBase & getFieldSplitPreconditioner()
std::unordered_map< std::pair< BoundaryID, BoundaryID >, ComputeMortarFunctor > _displaced_mortar_functors
Functors for computing displaced mortar constraints.
unsigned int _current_nl_its
boundary_id_type BoundaryID
Real referenceResidual() const
The reference residual used in relative convergence check.
void addSplit(const std::string &split_name, const std::string &name, InputParameters ¶meters)
Adds a split.
bool _automatic_scaling
Whether to automatically scale the variables.
MatFDColoring _fdcoloring
void computeJacobianTags(const std::set< TagID > &tags)
Computes multiple (tag associated) Jacobian matricese.
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
std::shared_ptr< MoosePreconditioner > _preconditioner
Preconditioner.
virtual void timestepSetup(THREAD_ID tid=0) const
NonlinearSystemBase & currentNonlinearSystem()
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
void computingScalingResidual(bool computing_scaling_residual)
Setter for whether we're computing the scaling residual.
virtual void setupDM()=0
setup the data management data structure that manages the field split
SubProblem & subproblem()
std::vector< std::string > _vecs_to_zero_for_residual
vectors that will be zeroed before a residual computation
virtual TagID addMatrixTag(TagName tag_name)
Create a Tag.
std::shared_ptr< Split > getSplit(const std::string &name)
Retrieves a split by name.
void setInitialSolution()
std::unique_ptr< NumericVector< Number > > solution
SubProblem & _subproblem
The subproblem for whom this class holds variable data, etc; this can either be the governing finite ...
void subdomainsCovered(std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
Populates a set of covered subdomains and the associated variable names.
void addImplicitGeometricCouplingEntries(GeometricSearchData &geom_search_data)
Adds entries to the Jacobian in the correct positions for couplings coming from dofs being coupled th...
virtual void addHDGKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a hybridized discontinuous Galerkin (HDG) kernel.
virtual void zero_rows(std::vector< numeric_index_type > &rows, T diag_value=0.0)
MooseObjectTagWarehouse< KernelBase > _kernels
MooseObjectWarehouse< T > & getMatrixTagObjectWarehouse(TagID tag_id, THREAD_ID tid)
Retrieve a moose object warehouse in which every moose object has the given matrix tag...
bool shouldEvaluatePreSMOResidual() const
We offer the option to check convergence against the pre-SMO residual.
std::vector< VectorTag > getVectorTags(const std::set< TagID > &tag_ids) const
Base class for deriving nodal dampers.
virtual void disassociateVectorFromTag(NumericVector< Number > &vec, TagID tag)
Disassociate a given vector from a given tag.
virtual void cacheResidual(const THREAD_ID tid) override
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
virtual void computeScalingJacobian()=0
Compute a "Jacobian" for automatic scaling purposes.
bool errorOnJacobianNonzeroReallocation() const
Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by P...
This is the ElementPairLocator class.
This is the ElementPairInfo class.
std::map< BoundaryID, std::shared_ptr< ElementPairLocator > > _element_pair_locators
Moose::CouplingType coupling() const
unsigned int number() const
Gets the number of this system.
void setupScalingData()
Setup group scaling containers.
virtual GeometricSearchData & geomSearchData()=0
const bool & usePreSMOResidual() const
Whether we are using pre-SMO residual in relative convergence checks.
MooseObjectTagWarehouse< HDGKernel > _hybridized_kernels
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.
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 closeTaggedVectors(const std::set< TagID > &tags)
Close all vectors for given tags.
Base class for deriving any boundary condition that works at nodes.
void computeResidualInternal(const std::set< TagID > &tags)
Compute the residual for a given tag.
virtual void prepareAssembly(const THREAD_ID tid) override
bool computeScaling()
Method used to obtain scaling factors for variables.
Interface for objects interacting with the PerfGraph.
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 bool hasVariable(const std::string &var_name) const
Query a system for a variable.
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
virtual void clearDiracInfo() override
Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in...
void destroyColoring()
Destroy the coloring object if it exists.
virtual void reinitNodesNeighbor(const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
bool identify_variable_groups() const
virtual void jacobianSetup(THREAD_ID tid=0) const
ConstraintWarehouse _constraints
Constraints storage object.
virtual void turnOffJacobian()
Turn off the Jacobian (must be called before equation system initialization)
void computeKokkosJacobian(const std::set< TagID > &tags)
Compute Jacobian with Kokkos objects.
TagID residualVectorTag() const override
const std::map< BoundaryID, std::vector< std::shared_ptr< T > > > & getActiveBoundaryObjects(THREAD_ID tid=0) const
void computingNonlinearResid(bool computing_nonlinear_residual) final
Set whether or not the problem is in the process of computing the nonlinear residual.
virtual void customSetup(const ExecFlagType &exec_type) override
ComputeType
The type of nonlinear computation being performed.
Base class for deriving element dampers.
Base interface for field split preconditioner.
bool _add_implicit_geometric_coupling_entries_to_jacobian
Whether or not to add implicit geometric couplings to the Jacobian for FDP.
const_iterator end() const
MooseObjectTagWarehouse< ResidualObject > _kokkos_integrated_bcs
virtual void addNodalKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a NodalKernel.
virtual unsigned int numMatrixTags() const
The total number of tags.
Base class for creating new types of boundary conditions.
FEProblemBase & _fe_problem
the governing finite element/volume problem
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid)=0
virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a scalar variable with specified number.
ParallelType type() const
virtual NumericVector< Number > & RHS()=0
std::vector< VariableWarehouse > _vars
Variable warehouses (one for each thread)
Provides a way for users to bail out of the current solve.
unsigned int _n_residual_evaluations
Total number of residual evaluations that have been performed.
void addDiracKernel(const std::string &kernel_name, const std::string &name, InputParameters ¶meters)
Adds a Dirac kernel.
void computeJacobianInternal(const std::set< TagID > &tags)
Form multiple matrices for all the tags.
bool _has_diag_save_in
If there is any Kernel or IntegratedBC having diag_save_in.
Base class for creating new types of nodal kernels.
const FEType & variable_type(const unsigned int i) const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
std::unique_ptr< NumericVector< Number > > _residual_copy
Copy of the residual vector, or nullptr if a copy is not needed.
virtual void subdomainSetup()
bool hasSaveIn() const
Weather or not the nonlinear system has save-ins.
Generic class for solving transient nonlinear problems.
TagID timeVectorTag() const override
Ideally, we should not need this API.
Class for containing MooseEnum item information.
virtual std::vector< std::string > timeKernelVariableNames() override
Returns the names of the variables that have time derivative kernels in the system.
bool hasActiveObjects(THREAD_ID tid=0) const
NonlinearSystemBase(FEProblemBase &problem, libMesh::System &sys, const std::string &name)
void max(const T &r, T &o, Request &req) const
NumericVector< Number > * _u_dot
solution vector for u^dot
MooseObjectWarehouse< ElementDamper > _element_dampers
Element Dampers for each thread.
void addObject(std::shared_ptr< Constraint > object, THREAD_ID tid=0, bool recurse=true) override
Add Constraint object to the warehouse.
virtual void setSolutionUDot(const NumericVector< Number > &udot)
Set transient term used by residual and Jacobian evaluation.
virtual libMesh::SparseMatrix< Number > & getMatrix(TagID tag)
Get a raw SparseMatrix.
virtual void augmentSparsity(libMesh::SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz) override
Will modify the sparsity pattern to add logical geometric connections.
const std::vector< std::shared_ptr< MortarConstraintBase > > & getActiveMortarConstraints(const std::pair< BoundaryID, BoundaryID > &mortar_interface_key, bool displaced) const
MooseObjectWarehouse< T > & getMatrixTagsObjectWarehouse(const std::set< TagID > &tags, THREAD_ID tid)
Retrieve a moose object warehouse in which every moose object has one of the given matrix tags...
void computeScalarKernelsJacobians(const std::set< TagID > &tags)
void setInitialResidual(Real r)
Record the initial residual (for later relative convergence check)
Query query()
query creates and returns an initialized a query object for querying objects from the warehouse...
virtual Assembly & assembly(const THREAD_ID tid, const unsigned int sys_num)=0
const_iterator begin() const
bool needInternalNeighborSideMaterial(SubdomainID subdomain_id, THREAD_ID tid) const
Indicates whether this system needs material properties on internal sides.
void computeKokkosResidual(const std::set< TagID > &tags)
Compute residual with Kokkos objects.
Base class for deriving dampers.
bool getFailNextNonlinearConvergenceCheck() const
Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s) ...
Base class shared by AD and non-AD scalar kernels.
void addDamper(const std::string &damper_name, const std::string &name, InputParameters ¶meters)
Adds a damper.
IntRange< T > make_range(T beg, T end)
virtual MooseMesh & mesh() override
virtual void postAddResidualObject(ResidualObject &)
Called after any ResidualObject-derived objects are added to the system.
const std::vector< VariableName > & getVariableNames() const
virtual void preInit() override
This is called prior to the libMesh system has been init'd.
virtual void updateActive(THREAD_ID tid=0) override
Update the active status of Kernels.
virtual void timestepSetup() override
bool hasActiveElemElemConstraints(const InterfaceID interface_id, bool displaced) const
bool _off_diagonals_in_auto_scaling
Whether to include off diagonals when determining automatic scaling factors.
virtual unsigned int numVectorTags(const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
The total number of tags, which can be limited to the tag type.
void reinitNodeFace(const Node &secondary_node, const BoundaryID secondary_boundary, const PenetrationInfo &info, const bool displaced)
Reinitialize quantities such as variables, residuals, Jacobians, materials for node-face constraints...
Base class for deriving any boundary condition of a integrated type.
SolverParams & solverParams(unsigned int solver_sys_num=0)
Get the solver parameters.
NumericVector< Number > * _residual_ghosted
ghosted form of the residual
void setCachedJacobian(GlobalDataKey)
Sets previously-cached Jacobian values via SparseMatrix::set() calls.
TagID _Re_tag
Used for the residual vector from PETSc.
virtual void customSetup(const ExecFlagType &exec_type)
MooseObjectWarehouse< T > & getVectorTagObjectWarehouse(TagID tag_id, THREAD_ID tid)
Retrieve a moose object warehouse in which every moose object has the given vector tag...
void computeNodalBCs(NumericVector< Number > &residual)
Enforces nodal boundary conditions.
const std::set< SubdomainID > & getSubdomainsForVar(unsigned int var_number) const
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true)
Adds an object to the storage structure.
bool ignoreZerosInJacobian() const
Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.
const ExecFlagType EXEC_PRE_KERNELS
void mortarConstraints(Moose::ComputeType compute_type, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
Do mortar constraint residual/jacobian computations.
NumericVector< Number > * _increment_vec
increment vector
InterfaceKernelBase is the base class for all InterfaceKernel type classes.
QueryCache & condition(Args &&... args)
Adds a new condition to the query.
bool doingDG() const
Getter for _doing_dg.
void computeResidualTag(NumericVector< Number > &residual, TagID tag_id)
Computes residual for a given tag.
void addConstraint(const std::string &c_name, const std::string &name, InputParameters ¶meters)
Adds a Constraint.
virtual TagName vectorTagName(const TagID tag) const
Retrieve the name associated with a TagID.
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.
bool hasKokkosObjects() const
bool restoreOriginalNonzeroPattern() const
face_info_iterator ownedFaceInfoEnd()
void constraintJacobians(const SparseMatrix< Number > &jacobian_to_view, bool displaced)
Add jacobian contributions from Constraints.
virtual libMesh::System & system() override
Get the reference to the libMesh system.
MooseVariableFieldBase & getVariable(THREAD_ID tid, const std::string &var_name) const
Gets a reference to a variable of with specified name.
std::vector< BoundaryID > getBoundaryIDs(const Elem *const elem, const unsigned short int side) const
Returns a vector of boundary IDs for the requested element on the requested side. ...
bool preSolve()
Perform some steps to get ready for the solver.
void full_sparsity_pattern_needed()
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > & getMortarInterfaces(bool on_displaced) const
bool _has_constraints
Whether or not this system has any Constraints.
dof_id_type first_dof(const processor_id_type proc) const
bool _computed_scaling
Flag used to indicate whether we have already computed the scaling Jacobian.
void remove_algebraic_ghosting_functor(GhostingFunctor &evaluable_functor)
MooseObjectTagWarehouse< InterfaceKernelBase > _interface_kernels
unsigned int n_vars() const
void resetSolutionInvalidCurrentIteration()
Reset the number of solution invalid occurrences back to zero.
NumericVector< Number > & residualVector(TagID tag)
Return a residual vector that is associated with the residual tag.
NumericVector< Number > & solutionOld()
NumericVector< Number > & getResidualNonTimeVector()
Return a numeric vector that is associated with the nontime tag.
virtual bool hasScalarVariable(const std::string &var_name) const
const TagName PREVIOUS_NL_SOLUTION_TAG
processor_id_type processor_id() const
std::shared_ptr< Predictor > _predictor
If predictor is active, this is non-NULL.
void enforceNodalConstraintsResidual(NumericVector< Number > &residual)
Enforce nodal constraints.
void subdomainsCovered(std::set< SubdomainID > &subdomains_covered, std::set< std::string > &unique_variables, THREAD_ID tid=0) const
Update supplied subdomain and variable coverate containters.
MooseObjectWarehouse< GeneralDamper > _general_dampers
General Dampers.
const std::vector< std::shared_ptr< ElemElemConstraint > > & getActiveElemElemConstraints(InterfaceID interface_id, bool displaced) const
virtual void initialSetup()
Setup Functions.
bool defaultGhosting()
Whether or not the user has requested default ghosting ot be on.
void addCachedJacobian(GlobalDataKey)
Adds the values that have been cached by calling cacheJacobian() and or cacheJacobianNeighbor() to th...
virtual void cacheJacobian(const THREAD_ID tid) override
auto min(const L &left, const R &right)
void jacobianSetup() override
void setKokkosInitialSolution()
virtual NumericVector< Number > & getVector(const std::string &name)
Get a raw NumericVector by name.
MooseObjectTagWarehouse< IntegratedBCBase > _integrated_bcs
const DofMap & get_dof_map() const
virtual void reinitNodeFace(const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
virtual void residualSetup()
virtual void reinitOffDiagScalars(const THREAD_ID tid) override
processor_id_type processor_id() const
virtual void addObject(std::shared_ptr< T > object, THREAD_ID tid=0, bool recurse=true) override
Adds an object to the storage structure.
virtual void setNeighborSubdomainID(const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void addResidualScalar(const THREAD_ID tid=0)
virtual void subdomainSetup(THREAD_ID tid=0) const
virtual void jacobianSetup() override
virtual void addCachedResidual(const THREAD_ID tid) override
std::vector< std::vector< std::string > > _scaling_group_variables
A container of variable groupings that can be used in scaling calculations.
void addInterfaceKernel(std::string interface_kernel_name, const std::string &name, InputParameters ¶meters)
Adds an interface kernel.
FieldSplitPreconditionerBase * _fsp
The field split preconditioner if this sytem is using one.
auto index_range(const T &sizable)
virtual NumericVector< Number > & residualCopy() override
void reinitMortarFunctors()
Update the mortar functors if the mesh has changed.
virtual NumericVector< Number > & residualGhosted() override
DiracKernelBase is the base class for all DiracKernel type classes.
virtual void updateActive(THREAD_ID tid=0)
Updates the active objects storage.
MooseObjectTagWarehouse< ResidualObject > _kokkos_nodal_bcs
void assembleScalingVector()
Assemble the numeric vector of scaling factors such that it can be used during assembly of the system...
BoundaryID _primary_boundary
NumericVector< Number > * _u_dotdot_old
old solution vector for u^dotdot
MooseObjectTagWarehouse< ScalarKernelBase > _scalar_kernels
virtual void residualEnd(THREAD_ID tid=0) const
void setConstraintSecondaryValues(NumericVector< Number > &solution, bool displaced)
Sets the value of constrained variables in the solution vector.
virtual void addJacobianScalar(const THREAD_ID tid=0)
NearestNodeLocator & _nearest_node
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToElemMap()
If not already created, creates a map from every node to all elements to which they are connected...
const std::set< SubdomainID > & meshSubdomains() const
Returns a read-only reference to the set of subdomains currently present in the Mesh.
virtual void addCachedJacobian(const THREAD_ID tid) override
virtual void timestepSetup()
virtual ~NonlinearSystemBase()
virtual void preInit() override
This is called prior to the libMesh system has been init'd.
virtual void residualSetup() override
void setPreconditioner(std::shared_ptr< MoosePreconditioner > pc)
Sets a preconditioner.
virtual void localize(std::vector< T > &v_local) const=0
MooseObjectWarehouse< ADDirichletBCBase > _ad_preset_nodal_bcs
virtual libMesh::System & system() override
Get the reference to the libMesh system.
Key structure for APIs manipulating global vectors/matrices.