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),
131 _increment_vec(NULL),
132 _use_finite_differenced_preconditioner(false),
133 _fdcoloring(nullptr),
134 _have_decomposition(false),
135 _use_field_split_preconditioner(false),
136 _add_implicit_geometric_coupling_entries_to_jacobian(false),
137 _assemble_constraints_separately(false),
138 _need_residual_ghosted(false),
139 _debugging_residuals(false),
143 _n_residual_evaluations(0),
145 _computing_pre_smo_residual(false),
146 _pre_smo_residual(0),
147 _initial_residual(0),
148 _use_pre_smo_residual(false),
149 _print_all_var_norms(false),
151 _has_diag_save_in(false),
152 _has_nodalbc_save_in(false),
153 _has_nodalbc_diag_save_in(false),
154 _computed_scaling(false),
155 _compute_scaling_once(true),
156 _resid_vs_jac_scaling_param(0),
157 _off_diagonals_in_auto_scaling(false),
158 _auto_scaling_initd(false)
176 dof_map.set_implicit_neighbor_dofs(
false);
204 TIME_SECTION(
"nlInitialSetup", 2,
"Setting Up Nonlinear System");
209 TIME_SECTION(
"kernelsInitialSetup", 2,
"Setting Up Kernels/BCs/Constraints");
226 std::vector<FVElementalKernel *> fv_elemental_kernels;
229 .template condition<AttribSystem>(
"FVElementalKernel")
230 .
template condition<AttribThread>(tid)
233 for (
auto * fv_kernel : fv_elemental_kernels)
234 fv_kernel->initialSetup();
236 std::vector<FVFluxKernel *> fv_flux_kernels;
239 .template condition<AttribSystem>(
"FVFluxKernel")
240 .
template condition<AttribThread>(tid)
243 for (
auto * fv_kernel : fv_flux_kernels)
244 fv_kernel->initialSetup();
255 TIME_SECTION(
"mortarSetup", 2,
"Initializing Mortar Interfaces");
257 auto create_mortar_functors = [
this](
const bool displaced)
261 for (
const auto & mortar_interface : mortar_interfaces)
263 const auto primary_secondary_boundary_pair = mortar_interface.first;
267 const auto & mortar_generation_object = mortar_interface.second;
269 auto & mortar_constraints =
276 auto & mortar_functors =
279 mortar_functors.emplace(primary_secondary_boundary_pair,
281 mortar_generation_object,
289 create_mortar_functors(
false);
290 create_mortar_functors(
true);
324 std::vector<FVFluxBC *> bcs;
327 .template condition<AttribSystem>(
"FVFluxBC")
328 .
template condition<AttribThread>(tid)
331 std::vector<FVInterfaceKernel *> iks;
334 .template condition<AttribSystem>(
"FVInterfaceKernel")
335 .
template condition<AttribThread>(tid)
338 std::vector<FVFluxKernel *> kernels;
341 .template condition<AttribSystem>(
"FVFluxKernel")
342 .
template condition<AttribThread>(tid)
345 for (
auto * bc : bcs)
347 for (
auto * ik : iks)
349 for (
auto * kernel : kernels)
350 kernel->timestepSetup();
378 std::vector<FVFluxBC *> bcs;
381 .template condition<AttribSystem>(
"FVFluxBC")
382 .
template condition<AttribThread>(tid)
385 std::vector<FVInterfaceKernel *> iks;
388 .template condition<AttribSystem>(
"FVInterfaceKernel")
389 .
template condition<AttribThread>(tid)
392 std::vector<FVFluxKernel *> kernels;
395 .template condition<AttribSystem>(
"FVFluxKernel")
396 .
template condition<AttribThread>(tid)
399 for (
auto * bc : bcs)
400 bc->customSetup(exec_type);
401 for (
auto * ik : iks)
402 ik->customSetup(exec_type);
403 for (
auto * kernel : kernels)
404 kernel->customSetup(exec_type);
424 if (splits.size() && splits.size() != 1)
425 mooseError(
"Only a single top-level split is allowed in a Problem's decomposition.");
443 top_split->setup(*
this);
448 const std::string & name,
454 std::shared_ptr<KernelBase> kernel =
462 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
464 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
470 const std::string & name,
487 const std::string & name,
493 std::shared_ptr<NodalKernelBase> kernel =
501 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
503 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
509 const std::string & name,
512 std::shared_ptr<ScalarKernelBase> kernel =
522 const std::string & name,
529 std::shared_ptr<BoundaryCondition> bc =
534 const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
536 _vars[tid].addBoundaryVar(boundary_ids, bc_var);
545 if (nbc->checkNodalVar() && !nbc->variable().isNodal())
546 mooseError(
"Trying to use nodal boundary condition '",
548 "' on a non-nodal variable '",
549 nbc->variable().name(),
555 _vars[tid].addBoundaryVars(boundary_ids, nbc->getCoupledVars());
557 if (parameters.get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
559 if (parameters.get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
564 if (dbc && dbc->preset())
568 if (addbc && addbc->preset())
578 _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
580 if (parameters.get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
582 if (parameters.get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
594 const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
595 _vars[tid].addBoundaryVar(boundary_ids, bc_var);
600 _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
605 mooseError(
"Unknown BoundaryCondition type for object named ", bc->name());
610 const std::string & name,
617 if (constraint && constraint->addCouplingEntriesToJacobian())
623 const std::string & name,
628 std::shared_ptr<DiracKernelBase> kernel =
639 const std::string & name,
653 if (parameters.
get<std::vector<AuxVariableName>>(
"save_in").size() > 0)
655 if (parameters.
get<std::vector<AuxVariableName>>(
"diag_save_in").size() > 0)
661 const std::string & name,
666 std::shared_ptr<InterfaceKernelBase> interface_kernel =
670 const std::set<BoundaryID> & boundary_ids = interface_kernel->boundaryIDs();
672 _vars[tid].addBoundaryVar(boundary_ids, ik_var);
677 _vars[tid].addBoundaryVars(boundary_ids, interface_kernel->getCoupledVars());
683 const std::string & name,
711 const std::string & name,
720 std::shared_ptr<Split>
738 if (
_app.
parameters().
get<
bool>(
"use_legacy_initial_residual_evaluation_behavior"))
754 mooseError(
"pre-SMO residual is requested but not evaluated.");
806 parallel_object_only();
808 TIME_SECTION(
"nl::computeResidualTags", 5);
813 bool required_residual = tags.find(
residualVectorTag()) == tags.end() ? false :
true;
836 if (required_residual)
842 ti->postResidual(residual);
885 const std::set<TagID> & matrix_tags)
887 const bool required_residual =
897 if (required_residual)
903 ti->postResidual(residual);
941 TIME_SECTION(
"applyPredictor", 2,
"Applying Predictor");
947 _console <<
" Skipping predictor this step" << std::endl;
952 TIME_SECTION(
"initialBCs", 2,
"Applying BCs To Initial Condition");
955 for (
const auto & bnode : bnd_nodes)
958 Node * node = bnode->_node;
968 for (
const auto & preset_bc : preset_bcs)
969 preset_bc->computeValue(initial_solution);
974 for (
const auto & preset_bc : preset_bcs_res)
975 preset_bc->computeValue(initial_solution);
1067 mooseError(
"The required residual vector is not available");
1079 for (
const auto & nc : ncs)
1081 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
1082 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
1084 if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
1088 nc->computeResidual(residual);
1108 for (
const auto & nc : ncs)
1110 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
1111 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
1113 if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
1117 nc->computeJacobian(jacobian);
1128 const bool displaced)
1133 const Elem * primary_elem =
info._elem;
1134 unsigned int primary_side =
info._side_num;
1135 std::vector<Point> points;
1136 points.push_back(
info._closest_point);
1157 const Elem *
const undisplaced_primary_elem =
1159 const Point undisplaced_primary_physical_point =
1160 [&points, displaced, primary_elem, undisplaced_primary_elem]()
1164 const Point reference_point =
1165 FEMap::inverse_map(primary_elem->dim(), primary_elem, points[0]);
1166 return FEMap::map(primary_elem->dim(), undisplaced_primary_elem, reference_point);
1175 undisplaced_primary_elem, primary_side, {undisplaced_primary_physical_point}, 0);
1192 "If we're calling this method with displaced = true, then we better well have a " 1193 "displaced problem");
1198 bool constraints_applied =
false;
1200 for (
const auto & it : penetration_locators)
1211 const auto & constraints =
1213 std::unordered_set<unsigned int> needed_mat_props;
1214 for (
const auto & constraint : constraints)
1216 const auto & mp_deps = constraint->getMatPropDependencies();
1217 needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
1221 for (
unsigned int i = 0; i < secondary_nodes.size(); i++)
1223 dof_id_type secondary_node_num = secondary_nodes[i];
1234 for (
const auto & nfc : constraints)
1236 if (nfc->isExplicitConstraint())
1242 if (nfc->secondaryBoundary() != secondary_boundary ||
1243 nfc->primaryBoundary() != primary_boundary)
1246 if (nfc->shouldApply())
1248 constraints_applied =
true;
1249 nfc->computeSecondaryValue(
solution);
1252 if (nfc->hasWritableCoupledVariables())
1254 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1255 for (
auto * var : nfc->getWritableCoupledVariables())
1257 if (var->isNodalDefined())
1269 std::set<dof_id_type> unique_secondary_node_ids;
1277 const auto & constraints =
1281 unique_secondary_node_ids.clear();
1283 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
1284 meshhelper.active_subdomain_elements_end(secondary_id)))
1286 for (
auto & n : elem->node_ref_range())
1287 unique_secondary_node_ids.insert(n.id());
1290 for (
auto secondary_node_id : unique_secondary_node_ids)
1304 for (
const auto & nec : constraints)
1306 if (nec->shouldApply())
1308 constraints_applied =
true;
1309 nec->computeSecondaryValue(
solution);
1321 if (constraints_applied)
1336 "If we're calling this method with displaced = true, then we better well have a " 1337 "displaced problem");
1342 bool constraints_applied;
1343 bool residual_has_inserted_values =
false;
1345 constraints_applied =
false;
1346 for (
const auto & it : penetration_locators)
1352 constraints_applied =
false;
1361 bool has_writable_variables(
false);
1365 const auto & constraints =
1368 for (
unsigned int i = 0; i < secondary_nodes.size(); i++)
1370 dof_id_type secondary_node_num = secondary_nodes[i];
1381 for (
const auto & nfc : constraints)
1387 if (nfc->secondaryBoundary() != secondary_boundary ||
1388 nfc->primaryBoundary() != primary_boundary)
1391 if (nfc->shouldApply())
1393 constraints_applied =
true;
1394 nfc->computeResidual();
1396 if (nfc->overwriteSecondaryResidual())
1402 const auto & secondary_var = nfc->variable();
1403 const auto & secondary_dofs = secondary_var.dofIndices();
1404 mooseAssert(secondary_dofs.size() == secondary_var.count(),
1405 "We are on a node so there should only be one dof per variable (for " 1406 "an ArrayVariable we should have a number of dofs equal to the " 1407 "number of components");
1413 std::vector<Number> values = {nfc->secondaryResidual()};
1414 residual.
insert(values, secondary_dofs);
1415 residual_has_inserted_values =
true;
1421 if (nfc->hasWritableCoupledVariables())
1423 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1424 has_writable_variables =
true;
1425 for (
auto * var : nfc->getWritableCoupledVariables())
1427 if (var->isNodalDefined())
1438 if (has_writable_variables)
1456 if (constraints_applied)
1461 if (residual_has_inserted_values)
1464 residual_has_inserted_values =
false;
1478 if (constraints_applied)
1483 if (residual_has_inserted_values)
1497 for (
const auto & it : element_pair_locators)
1504 const auto & _element_constraints =
1508 const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
1510 for (
const auto & pr : elem_pairs)
1512 const Elem * elem1 = pr.first;
1513 const Elem * elem2 = pr.second;
1521 for (
const auto & ec : _element_constraints)
1528 ec->prepareShapes(ec->variable().number());
1529 ec->prepareNeighborShapes(ec->variable().number());
1532 ec->computeResidual();
1542 std::set<dof_id_type> unique_secondary_node_ids;
1544 constraints_applied =
false;
1545 residual_has_inserted_values =
false;
1546 bool has_writable_variables =
false;
1553 const auto & constraints =
1557 unique_secondary_node_ids.clear();
1559 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
1560 meshhelper.active_subdomain_elements_end(secondary_id)))
1562 for (
auto & n : elem->node_ref_range())
1563 unique_secondary_node_ids.insert(n.id());
1566 for (
auto secondary_node_id : unique_secondary_node_ids)
1579 for (
const auto & nec : constraints)
1581 if (nec->shouldApply())
1583 constraints_applied =
true;
1584 nec->computeResidual();
1586 if (nec->overwriteSecondaryResidual())
1589 residual_has_inserted_values =
true;
1595 if (nec->hasWritableCoupledVariables())
1597 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1598 has_writable_variables =
true;
1599 for (
auto * var : nec->getWritableCoupledVariables())
1601 if (var->isNodalDefined())
1614 if (constraints_applied)
1619 if (residual_has_inserted_values)
1630 if (has_writable_variables)
1653 for (
const auto & it : penetration_locators)
1663 const auto & constraints =
1667 const auto secondary_node_num = secondary_nodes[i];
1672 for (
const auto & nfc : constraints)
1674 if (!nfc->isExplicitConstraint())
1681 if (nfc->secondaryBoundary() != secondary_boundary ||
1682 nfc->primaryBoundary() != primary_boundary)
1685 nfc->overwriteBoundaryVariables(soln, secondary_node);
1696 TIME_SECTION(
"residualSetup", 3);
1726 parallel_object_only();
1728 TIME_SECTION(
"computeResidualInternal", 3);
1736 std::vector<UserObject *> uos;
1742 for (
auto & uo : uos)
1743 uo->residualSetup();
1744 for (
auto & uo : uos)
1758 TIME_SECTION(
"Kernels", 3 );
1763 Threads::parallel_reduce(elem_range, cr);
1775 Threads::parallel_reduce(faces, fvr);
1784 Threads::parallel_reduce(faces, fvr);
1800 TIME_SECTION(
"ScalarKernels", 3 );
1808 else if (tags.size() == 1)
1809 scalar_kernel_warehouse =
1815 bool have_scalar_contributions =
false;
1817 for (
const auto & scalar_kernel : scalars)
1819 scalar_kernel->reinit();
1820 const std::vector<dof_id_type> & dof_indices = scalar_kernel->variable().dofIndices();
1826 if (dof >= first_dof && dof < end_dof)
1828 scalar_kernel->computeResidual();
1829 have_scalar_contributions =
true;
1834 if (have_scalar_contributions)
1845 TIME_SECTION(
"NodalKernels", 3 );
1855 Threads::parallel_reduce(range, cnk);
1877 TIME_SECTION(
"NodalKernelBCs", 3 );
1883 Threads::parallel_reduce(bnd_node_range, cnk);
1945 const std::set<TagID> & matrix_tags)
1947 TIME_SECTION(
"computeResidualAndJacobianInternal", 3);
1952 for (
auto tag : matrix_tags)
1961 LibmeshPetscCall(MatSetOption(petsc_matrix->mat(),
1962 MAT_KEEP_NONZERO_PATTERN,
1966 MatSetOption(petsc_matrix->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
1969 MAT_IGNORE_ZERO_ENTRIES,
1978 std::vector<UserObject *> uos;
1984 for (
auto & uo : uos)
1985 uo->residualSetup();
1986 for (
auto & uo : uos)
2000 TIME_SECTION(
"Kernels", 3 );
2005 Threads::parallel_reduce(elem_range, crj);
2013 Threads::parallel_reduce(faces, fvrj);
2022 Threads::parallel_reduce(faces, fvr);
2044 for (
const auto & residual_vector_tag : residual_vector_tags)
2075 else if (tags.size() == 1)
2081 if (!nbc_warehouse->
size())
2088 if (!bnd_nodes.
empty())
2090 TIME_SECTION(
"NodalBCs", 3 );
2092 for (
const auto & bnode : bnd_nodes)
2095 Node * node = bnode->_node;
2104 for (
const auto & nbc : bcs)
2105 if (nbc->shouldApply())
2106 nbc->computeResidual();
2125 if (!bnd_nodes.
empty())
2127 TIME_SECTION(
"NodalBCs", 3 );
2129 for (
const auto & bnode : bnd_nodes)
2132 Node * node = bnode->_node;
2141 for (
const auto & nbc : bcs)
2142 if (nbc->shouldApply())
2143 nbc->computeResidualAndJacobian();
2159 unsigned int s =
number();
2162 for (
unsigned int v = 0; v <
nVariables(); v++)
2163 for (
unsigned int c = 0; c < node.
n_comp(s, v); c++)
2171 std::unordered_map<
dof_id_type, std::vector<dof_id_type>> & graph)
2175 for (
const auto & it : nearest_node_locators)
2177 std::vector<dof_id_type> & secondary_nodes = it.second->_secondary_nodes;
2179 for (
const auto & secondary_node : secondary_nodes)
2181 std::set<dof_id_type> unique_secondary_indices;
2182 std::set<dof_id_type> unique_primary_indices;
2184 auto node_to_elem_pair = node_to_elem_map.find(secondary_node);
2185 if (node_to_elem_pair != node_to_elem_map.end())
2187 const std::vector<dof_id_type> & elems = node_to_elem_pair->second;
2190 for (
const auto & cur_elem : elems)
2192 std::vector<dof_id_type> dof_indices;
2195 for (
const auto & dof : dof_indices)
2196 unique_secondary_indices.insert(dof);
2200 std::vector<dof_id_type> primary_nodes = it.second->_neighbor_nodes[secondary_node];
2202 for (
const auto & primary_node : primary_nodes)
2204 auto primary_node_to_elem_pair = node_to_elem_map.find(primary_node);
2205 mooseAssert(primary_node_to_elem_pair != node_to_elem_map.end(),
2206 "Missing entry in node to elem map");
2207 const std::vector<dof_id_type> & primary_node_elems = primary_node_to_elem_pair->second;
2210 for (
const auto & cur_elem : primary_node_elems)
2212 std::vector<dof_id_type> dof_indices;
2215 for (
const auto & dof : dof_indices)
2216 unique_primary_indices.insert(dof);
2220 for (
const auto & secondary_id : unique_secondary_indices)
2221 for (
const auto & primary_id : unique_primary_indices)
2223 graph[secondary_id].push_back(primary_id);
2224 graph[primary_id].push_back(secondary_id);
2231 for (
const auto & nc : ncs)
2233 std::vector<dof_id_type> primary_dofs;
2234 std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
2235 for (
const auto & node_id : primary_node_ids)
2246 std::vector<dof_id_type> secondary_dofs;
2247 std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
2248 for (
const auto & node_id : secondary_node_ids)
2259 for (
const auto & primary_id : primary_dofs)
2260 for (
const auto & secondary_id : secondary_dofs)
2262 graph[primary_id].push_back(secondary_id);
2263 graph[secondary_id].push_back(primary_id);
2268 for (
auto & it : graph)
2270 std::vector<dof_id_type> & row = it.second;
2271 std::sort(row.begin(), row.end());
2272 std::vector<dof_id_type>::iterator uit = std::unique(row.begin(), row.end());
2273 row.resize(uit - row.begin());
2287 std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
2291 for (
const auto & it : graph)
2294 const auto & row = it.second;
2296 for (
const auto & coupled_dof : row)
2297 jacobian.add(dof, coupled_dof, 0);
2312 MAT_NEW_NONZERO_ALLOCATION_ERR,
2315 LibmeshPetscCall(MatSetOption(
2316 static_cast<PetscMatrix<Number> &
>(jacobian).mat(), MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
2318 std::vector<numeric_index_type> zero_rows;
2322 "If we're calling this method with displaced = true, then we better well have a " 2323 "displaced problem");
2328 bool constraints_applied;
2330 constraints_applied =
false;
2331 for (
const auto & it : penetration_locators)
2337 constraints_applied =
false;
2349 const auto & constraints =
2352 for (
const auto & secondary_node_num : secondary_nodes)
2365 for (
const auto & nfc : constraints)
2367 if (nfc->isExplicitConstraint())
2373 if (nfc->secondaryBoundary() != secondary_boundary ||
2374 nfc->primaryBoundary() != primary_boundary)
2377 nfc->_jacobian = &jacobian_to_view;
2379 if (nfc->shouldApply())
2381 constraints_applied =
true;
2383 nfc->prepareShapes(nfc->variable().number());
2384 nfc->prepareNeighborShapes(nfc->variable().number());
2386 nfc->computeJacobian();
2388 if (nfc->overwriteSecondaryJacobian())
2391 zero_rows.push_back(nfc->variable().nodalDofIndex());
2394 std::vector<dof_id_type> secondary_dofs(1, nfc->variable().nodalDofIndex());
2400 Real scaling_factor =
2401 nfc->overwriteSecondaryJacobian() ? 1. : nfc->variable().scalingFactor();
2407 nfc->_connected_dof_indices,
2411 if (nfc->addCouplingEntriesToJacobian())
2418 nfc->primaryVariable().dofIndicesNeighbor(),
2424 nfc->primaryVariable().dofIndicesNeighbor(),
2425 nfc->_connected_dof_indices,
2426 nfc->primaryVariable().scalingFactor());
2433 const std::vector<MooseVariableFEBase *> coupled_vars = nfc->getCoupledMooseVars();
2434 for (
const auto & jvar : coupled_vars)
2442 if (nfc->variable().number() == jvar->number() ||
2444 nfc->variable().number(), jvar->number(), this->
number()))
2450 nfc->prepareShapes(nfc->variable().number());
2451 nfc->prepareNeighborShapes(jvar->number());
2453 nfc->computeOffDiagJacobian(jvar->number());
2459 nfc->_connected_dof_indices,
2463 if (nfc->addCouplingEntriesToJacobian())
2470 jvar->dofIndicesNeighbor(),
2476 nfc->variable().dofIndicesNeighbor(),
2477 nfc->_connected_dof_indices,
2478 nfc->variable().scalingFactor());
2495 if (constraints_applied)
2498 MAT_KEEP_NONZERO_PATTERN,
2502 jacobian.zero_rows(zero_rows, 0.0);
2514 if (constraints_applied)
2517 MAT_KEEP_NONZERO_PATTERN,
2521 jacobian.zero_rows(zero_rows, 0.0);
2531 for (
const auto & it : element_pair_locators)
2538 const auto & _element_constraints =
2542 const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
2544 for (
const auto & pr : elem_pairs)
2546 const Elem * elem1 = pr.first;
2547 const Elem * elem2 = pr.second;
2555 for (
const auto & ec : _element_constraints)
2562 ec->prepareShapes(ec->variable().number());
2563 ec->prepareNeighborShapes(ec->variable().number());
2566 ec->computeJacobian();
2576 std::set<dof_id_type> unique_secondary_node_ids;
2577 constraints_applied =
false;
2584 const auto & constraints =
2588 unique_secondary_node_ids.clear();
2590 for (
const auto & elem :
as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
2591 meshhelper.active_subdomain_elements_end(secondary_id)))
2593 for (
auto & n : elem->node_ref_range())
2594 unique_secondary_node_ids.insert(n.id());
2597 for (
auto secondary_node_id : unique_secondary_node_ids)
2611 for (
const auto & nec : constraints)
2613 if (nec->shouldApply())
2615 constraints_applied =
true;
2617 nec->_jacobian = &jacobian_to_view;
2618 nec->prepareShapes(nec->variable().number());
2619 nec->prepareNeighborShapes(nec->variable().number());
2621 nec->computeJacobian();
2623 if (nec->overwriteSecondaryJacobian())
2626 zero_rows.push_back(nec->variable().nodalDofIndex());
2629 std::vector<dof_id_type> secondary_dofs(1, nec->variable().nodalDofIndex());
2635 nec->_connected_dof_indices,
2636 nec->variable().scalingFactor());
2641 nec->primaryVariable().dofIndicesNeighbor(),
2642 nec->_connected_dof_indices,
2643 nec->primaryVariable().scalingFactor());
2649 const std::vector<MooseVariableFEBase *> coupled_vars = nec->getCoupledMooseVars();
2650 for (
const auto & jvar : coupled_vars)
2658 if (nec->variable().number() == jvar->number() ||
2660 nec->variable().number(), jvar->number(), this->
number()))
2666 nec->prepareShapes(nec->variable().number());
2667 nec->prepareNeighborShapes(jvar->number());
2669 nec->computeOffDiagJacobian(jvar->number());
2675 nec->_connected_dof_indices,
2676 nec->variable().scalingFactor());
2681 nec->variable().dofIndicesNeighbor(),
2682 nec->_connected_dof_indices,
2683 nec->variable().scalingFactor());
2698 if (constraints_applied)
2701 MAT_KEEP_NONZERO_PATTERN,
2705 jacobian.zero_rows(zero_rows, 0.0);
2719 else if (tags.size() == 1)
2733 bool have_scalar_contributions =
false;
2734 for (
const auto & kernel : scalars)
2737 const std::vector<dof_id_type> & dof_indices = kernel->variable().dofIndices();
2743 if (dof >= first_dof && dof < end_dof)
2745 kernel->computeJacobian();
2747 have_scalar_contributions =
true;
2753 if (have_scalar_contributions)
2789 TIME_SECTION(
"computeJacobianInternal", 3);
2796 for (
auto tag : tags)
2805 LibmeshPetscCall(MatSetOption(petsc_matrix->mat(),
2806 MAT_KEEP_NONZERO_PATTERN,
2810 MatSetOption(petsc_matrix->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
2813 MAT_IGNORE_ZERO_ENTRIES,
2822 std::vector<UserObject *> uos;
2828 for (
auto & uo : uos)
2829 uo->jacobianSetup();
2830 for (
auto & uo : uos)
2853 Threads::parallel_reduce(range, cnkjt);
2869 Threads::parallel_reduce(faces, fvj);
2878 Threads::parallel_reduce(faces, fvr);
2894 Threads::parallel_reduce(elem_range, cj);
2916 Threads::parallel_reduce(elem_range, cj);
2929 Threads::parallel_reduce(bnd_range, cnkjt);
2942 Threads::parallel_reduce(elem_range, cj);
2945 for (
unsigned int i = 0; i <
n_threads; i++)
2954 Threads::parallel_reduce(bnd_range, cnkjt);
2966 static bool first =
true;
2991 #if PETSC_RELEASE_GREATER_EQUALS(3, 23, 0) 2993 std::unique_ptr<SparseMatrix<Number>> hash_copy;
2994 if (system_matrix.use_hash_table())
2996 hash_copy = libMesh::cast_ref<PetscMatrix<Number> &>(system_matrix).copy_from_hash();
2997 view_jac_ptr = hash_copy.get();
3000 view_jac_ptr = &system_matrix;
3001 auto & jacobian_to_view = *view_jac_ptr;
3003 auto & jacobian_to_view = system_matrix;
3005 if (&jacobian_to_view == &system_matrix)
3006 system_matrix.
close();
3032 else if (tags.size() == 1)
3049 std::map<std::string, std::set<unsigned int>> bc_involved_vars;
3051 for (
const auto & bid : all_boundary_ids)
3058 for (
const auto & bc : bcs)
3060 const std::vector<MooseVariableFEBase *> & coupled_moose_vars =
3061 bc->getCoupledMooseVars();
3065 std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
3066 for (
const auto & coupled_var : coupled_moose_vars)
3068 var_set.insert(coupled_var->number());
3070 var_set.insert(bc->variable().number());
3090 for (
const auto & bnode : bnd_nodes)
3093 Node * node = bnode->_node;
3101 for (
const auto & bc : bcs)
3104 std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
3110 for (
const auto & it : coupling_entries)
3112 unsigned int ivar = it.first->number(), jvar = it.second->number();
3118 if ((bc->variable().number() == ivar) && var_set.count(jvar) && bc->shouldApply())
3119 bc->computeOffDiagJacobian(jvar);
3122 const auto & coupled_scalar_vars = bc->getCoupledMooseScalarVars();
3123 for (
const auto & jvariable : coupled_scalar_vars)
3125 bc->computeOffDiagJacobianScalar(jvariable->number());
3159 for (
auto & tag : tags)
3178 TIME_SECTION(
"computeJacobianTags", 5);
3200 for (
auto & tag : tags)
3208 const std::set<TagID> & tags)
3210 TIME_SECTION(
"computeJacobianBlocks", 3);
3213 for (
unsigned int i = 0; i <
blocks.size(); i++)
3218 MAT_KEEP_NONZERO_PATTERN,
3222 MAT_NEW_NONZERO_ALLOCATION_ERR,
3235 Threads::parallel_reduce(elem_range, cjb);
3239 for (
unsigned int i = 0; i <
blocks.size(); i++)
3240 blocks[i]->_jacobian.close();
3242 for (
unsigned int i = 0; i <
blocks.size(); i++)
3247 unsigned int ivar =
blocks[i]->_ivar;
3248 unsigned int jvar =
blocks[i]->_jvar;
3251 std::vector<numeric_index_type> zero_rows;
3255 for (
const auto & bnode : bnd_nodes)
3258 Node * node = bnode->_node;
3268 for (
const auto & bc : bcs)
3269 if (bc->variable().number() == ivar && bc->shouldApply())
3321 bool has_active_dampers =
false;
3329 TIME_SECTION(
"computeDampers", 3,
"Computing Dampers");
3330 has_active_dampers =
true;
3343 TIME_SECTION(
"computeDamping::element", 3,
"Computing Element Damping");
3345 has_active_dampers =
true;
3358 TIME_SECTION(
"computeDamping::general", 3,
"Computing General Damping");
3360 has_active_dampers =
true;
3362 for (
const auto & damper : gdampers)
3367 damper->checkMinDamping(gd_damping);
3373 damping =
std::min(gd_damping, damping);
3388 if (has_active_dampers && damping < 1.0)
3389 _console <<
" Damping factor: " << damping << std::endl;
3399 std::set<const Elem *> dirac_elements;
3403 TIME_SECTION(
"computeDirac", 3,
"Computing DiracKernels");
3409 for (
const auto & dkernel : dkernels)
3411 dkernel->clearPoints();
3412 dkernel->addPoints();
3420 DistElemRange range(dirac_elements.begin(), dirac_elements.end(), 1);
3469 std::vector<dof_id_type> & n_nz,
3470 std::vector<dof_id_type> & n_oz)
3476 std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
3491 for (
const auto & git : graph)
3496 if (dof < first_dof_on_proc || dof >= end_dof_on_proc)
3499 const auto & row = git.second;
3503 unsigned int original_row_length = sparsity_row.size();
3505 sparsity_row.insert(sparsity_row.end(), row.begin(), row.end());
3507 SparsityPattern::sort_row(
3508 sparsity_row.begin(), sparsity_row.begin() + original_row_length, sparsity_row.end());
3511 for (
const auto & coupled_dof : row)
3513 if (coupled_dof < first_dof_on_proc || coupled_dof >= end_dof_on_proc)
3515 if (n_oz[local_dof] < n_dofs_not_on_proc)
3520 if (n_nz[local_dof] < n_dofs_on_proc)
3556 mooseError(
"More than one active Preconditioner detected");
3575 const std::set<MooseVariable *> & damped_vars)
3577 for (
const auto & var : damped_vars)
3583 const std::set<MooseVariable *> & damped_vars)
3585 for (
const auto & var : damped_vars)
3593 std::set<SubdomainID> input_subdomains;
3594 std::set<std::string> kernel_variables;
3596 bool global_kernels_exist =
false;
3608 std::vector<FVElementalKernel *> fv_elemental_kernels;
3611 .template condition<AttribSystem>(
"FVElementalKernel")
3612 .queryInto(fv_elemental_kernels);
3614 for (
auto fv_kernel : fv_elemental_kernels)
3616 if (fv_kernel->blockRestricted())
3617 for (
auto block_id : fv_kernel->blockIDs())
3618 input_subdomains.insert(block_id);
3620 global_kernels_exist =
true;
3621 kernel_variables.insert(fv_kernel->variable().name());
3624 if (dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel))
3625 kernel_variables.insert(dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel)
3630 std::vector<FVFluxKernel *> fv_flux_kernels;
3633 .template condition<AttribSystem>(
"FVFluxKernel")
3634 .queryInto(fv_flux_kernels);
3636 for (
auto fv_kernel : fv_flux_kernels)
3638 if (fv_kernel->blockRestricted())
3639 for (
auto block_id : fv_kernel->blockIDs())
3640 input_subdomains.insert(block_id);
3642 global_kernels_exist =
true;
3643 kernel_variables.insert(fv_kernel->variable().name());
3646 std::vector<FVInterfaceKernel *> fv_interface_kernels;
3649 .template condition<AttribSystem>(
"FVInterfaceKernel")
3650 .queryInto(fv_interface_kernels);
3652 for (
auto fvik : fv_interface_kernels)
3653 if (
auto scalar_fvik = dynamic_cast<FVScalarLagrangeMultiplierInterface *>(fvik))
3654 kernel_variables.insert(scalar_fvik->lambdaVariable().name());
3656 std::vector<FVFluxBC *> fv_flux_bcs;
3659 .template condition<AttribSystem>(
"FVFluxBC")
3660 .queryInto(fv_flux_bcs);
3662 for (
auto fvbc : fv_flux_bcs)
3663 if (
auto scalar_fvbc = dynamic_cast<FVBoundaryScalarLagrangeMultiplierConstraint *>(fvbc))
3664 kernel_variables.insert(scalar_fvbc->lambdaVariable().name());
3668 if (!global_kernels_exist)
3670 std::set<SubdomainID> difference;
3671 std::set_difference(mesh_subdomains.begin(),
3672 mesh_subdomains.end(),
3673 input_subdomains.begin(),
3674 input_subdomains.end(),
3675 std::inserter(difference, difference.end()));
3679 difference.erase(
id);
3681 difference.erase(
id);
3683 if (!difference.empty())
3685 std::vector<SubdomainID> difference_vec =
3686 std::vector<SubdomainID>(difference.begin(), difference.end());
3688 std::stringstream missing_block_names;
3689 std::copy(difference_names.begin(),
3690 difference_names.end(),
3691 std::ostream_iterator<std::string>(missing_block_names,
" "));
3692 std::stringstream missing_block_ids;
3693 std::copy(difference.begin(),
3695 std::ostream_iterator<unsigned int>(missing_block_ids,
" "));
3697 mooseError(
"Each subdomain must contain at least one Kernel.\nThe following block(s) lack an " 3699 missing_block_names.str(),
3701 missing_block_ids.str(),
3709 std::set<VariableName> difference;
3710 std::set_difference(variables.begin(),
3712 kernel_variables.begin(),
3713 kernel_variables.end(),
3714 std::inserter(difference, difference.end()));
3717 std::set<VariableName>
vars(difference);
3718 for (
auto & var_name :
vars)
3721 for (
const auto &
id : blks)
3723 difference.erase(var_name);
3726 if (!difference.empty())
3728 std::stringstream missing_kernel_vars;
3729 std::copy(difference.begin(),
3731 std::ostream_iterator<std::string>(missing_kernel_vars,
" "));
3732 mooseError(
"Each variable must be referenced by at least one active Kernel.\nThe following " 3733 "variable(s) lack an active kernel: " +
3734 missing_kernel_vars.str());
3746 std::vector<std::string>
3749 std::vector<std::string> variable_names;
3751 if (time_kernels.hasActiveObjects())
3752 for (
const auto & kernel : time_kernels.getObjects())
3753 variable_names.push_back(kernel->variable().name());
3755 return variable_names;
3792 const std::set<TagID> & vector_tags,
3793 const std::set<TagID> & matrix_tags)
3795 parallel_object_only();
3800 map_pr.second(compute_type, vector_tags, matrix_tags);
3803 map_pr.second(compute_type, vector_tags, matrix_tags);
3805 catch (MetaPhysicL::LogicError &)
3808 "We caught a MetaPhysicL error in NonlinearSystemBase::mortarConstraints. This is very " 3809 "likely due to AD not having a sufficiently large derivative container size. Please run " 3810 "MOOSE configure with the '--with-derivative-size=<n>' option");
3833 std::set<unsigned int> var_numbers, var_numbers_covered, var_numbers_not_covered;
3835 var_numbers.insert(var_number);
3845 "', provided to the 'scaling_group_variables' parameter, does not exist in " 3846 "the nonlinear system.");
3853 if (!map_pair.second)
3854 mooseError(
"Variable ", var_name,
" is contained in multiple scaling grouplings");
3855 var_numbers_covered.insert(var.
number());
3858 std::set_difference(var_numbers.begin(),
3860 var_numbers_covered.begin(),
3861 var_numbers_covered.end(),
3862 std::inserter(var_numbers_not_covered, var_numbers_not_covered.begin()));
3867 for (
auto var_number : var_numbers_not_covered)
3872 const auto & number_to_var_map =
_vars[0].numberToVariableMap();
3878 libmesh_map_find(number_to_var_map, i)->name()) !=
3891 _console <<
"\nPerforming automatic scaling calculation\n" << std::endl;
3893 TIME_SECTION(
"computeScaling", 3,
"Computing Automatic Scaling");
3900 std::vector<dof_id_type> dof_indices;
3908 auto & dof_map =
dofMap();
3952 auto examine_dof_indices = [
this,
3956 &jac_inverse_scaling_factors,
3957 &resid_inverse_scaling_factors,
3958 &scaling_residual](
const auto & dof_indices,
const auto var_number)
3960 for (
auto dof_index : dof_indices)
3961 if (dof_map.local_index(dof_index))
3966 auto mat_value = (*_scaling_matrix)(dof_index, dof_index);
3972 auto vec_value = scaling_residual(dof_index);
3984 dof_map.dof_indices(elem, dof_indices, i);
3985 examine_dof_indices(dof_indices, i);
3991 dof_map.SCALAR_dof_indices(dof_indices, i);
3992 examine_dof_indices(dof_indices, i);
4000 if (jac_scaling && resid_scaling)
4001 for (MooseIndex(inverse_scaling_factors) i = 0; i < inverse_scaling_factors.size(); ++i)
4004 if (!resid_inverse_scaling_factors[i])
4006 if (!jac_inverse_scaling_factors[i])
4007 inverse_scaling_factors[i] = 1;
4009 inverse_scaling_factors[i] = jac_inverse_scaling_factors[i];
4011 else if (!jac_inverse_scaling_factors[i])
4013 inverse_scaling_factors[i] = resid_inverse_scaling_factors[i];
4015 inverse_scaling_factors[i] =
4019 else if (jac_scaling)
4020 inverse_scaling_factors = jac_inverse_scaling_factors;
4021 else if (resid_scaling)
4022 inverse_scaling_factors = resid_inverse_scaling_factors;
4024 mooseError(
"We shouldn't be calling this routine if we're not performing any scaling");
4027 for (
auto & scaling_factor : inverse_scaling_factors)
4028 if (scaling_factor == 0)
4032 std::vector<Real> flattened_inverse_scaling_factors(
system().
n_vars());
4033 for (
const auto i :
index_range(flattened_inverse_scaling_factors))
4034 flattened_inverse_scaling_factors[i] = inverse_scaling_factors[
_var_to_group_var[i]];
4040 flattened_inverse_scaling_factors);
4053 auto & scaling_vector =
getVector(
"scaling_factors");
4056 const auto & dof_map =
dofMap();
4058 const auto & field_variables =
_vars[0].fieldVariables();
4059 const auto & scalar_variables =
_vars[0].scalars();
4061 std::vector<dof_id_type> dof_indices;
4063 for (
const Elem *
const elem :
4064 as_range(lm_mesh.active_local_elements_begin(), lm_mesh.active_local_elements_end()))
4065 for (
const auto *
const field_var : field_variables)
4067 const auto & factors = field_var->arrayScalingFactor();
4068 for (
const auto i :
make_range(field_var->count()))
4070 dof_map.dof_indices(elem, dof_indices, field_var->number() + i);
4071 for (
const auto dof : dof_indices)
4072 scaling_vector.set(dof, factors[i]);
4076 for (
const auto *
const scalar_var : scalar_variables)
4078 mooseAssert(scalar_var->count() == 1,
4079 "Scalar variables should always have only one component.");
4080 dof_map.SCALAR_dof_indices(dof_indices, scalar_var->number());
4081 for (
const auto dof : dof_indices)
4082 scaling_vector.set(dof, scalar_var->scalingFactor());
4086 scaling_vector.close();
4108 if (!scaling_succeeded)
4123 LibmeshPetscCall(MatFDColoringDestroy(&
_fdcoloring));
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.
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
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.
void petscSetupDM(NonlinearSystemBase &nl, const std::string &dm_name)
Setup the PETSc DM object.
NumericVector< Number > & solution()
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 haveFieldSplitPreconditioner() 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.
void setupFieldDecomposition()
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
void setDecomposition(const std::vector< std::string > &decomposition)
If called with a single string, it is used as the name of a the top-level decomposition split...
virtual void customSetup(const ExecFlagType &exec_type, THREAD_ID tid=0) const
bool needSubdomainMaterialOnSide(SubdomainID subdomain_id, THREAD_ID tid) const
Indicates whether this system needs material properties on internal sides.
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...
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.
const InputParameters & parameters()
Get the parameters of the object.
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
bool _have_decomposition
Whether or not the system can be decomposed into splits.
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 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.
virtual void deactiveAllMatrixTags()
Make matrices inactive.
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.
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
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.
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
virtual void activeAllMatrixTags()
Make all exsiting matrices ative.
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)
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.
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
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
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 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.
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.
std::string _decomposition_split
Name of the top-level split of the decomposition.
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
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.
auto index_range(const T &sizable)
virtual NumericVector< Number > & residualCopy() override
virtual NumericVector< Number > & residualGhosted() override
DiracKernelBase is the base class for all DiracKernel type classes.
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.