19#include "libmesh/dof_map.h"
22#include "libmesh/boundary_info.h"
23#include "libmesh/dense_matrix.h"
24#include "libmesh/dense_vector.h"
25#include "libmesh/dirichlet_boundaries.h"
26#include "libmesh/elem.h"
27#include "libmesh/elem_range.h"
28#include "libmesh/fe_base.h"
29#include "libmesh/fe_interface.h"
30#include "libmesh/fe_type.h"
31#include "libmesh/function_base.h"
32#include "libmesh/int_range.h"
33#include "libmesh/libmesh_logging.h"
34#include "libmesh/linear_solver.h"
35#include "libmesh/mesh_base.h"
36#include "libmesh/null_output_iterator.h"
37#include "libmesh/mesh_tools.h"
38#include "libmesh/nonlinear_implicit_system.h"
39#include "libmesh/numeric_vector.h"
40#include "libmesh/parallel_algebra.h"
41#include "libmesh/parallel_elem.h"
42#include "libmesh/parallel_node.h"
43#include "libmesh/periodic_boundaries.h"
44#include "libmesh/periodic_boundary.h"
45#include "libmesh/periodic_boundary_base.h"
46#include "libmesh/point_locator_base.h"
47#include "libmesh/quadrature.h"
48#include "libmesh/raw_accessor.h"
49#include "libmesh/sparse_matrix.h"
50#include "libmesh/static_condensation_dof_map.h"
51#include "libmesh/system.h"
52#include "libmesh/tensor_tools.h"
53#include "libmesh/threads.h"
54#include "libmesh/enum_to_string.h"
55#include "libmesh/coupling_matrix.h"
69#include <unordered_set>
76class ComputeConstraints
81#ifdef LIBMESH_ENABLE_PERIODIC
85 const unsigned int variable_number) :
86 _constraints(constraints),
88#ifdef LIBMESH_ENABLE_PERIODIC
89 _periodic_boundaries(periodic_boundaries),
92 _variable_number(variable_number)
97 const Variable & var_description = _dof_map.variable(_variable_number);
99#ifdef LIBMESH_ENABLE_PERIODIC
100 std::unique_ptr<PointLocatorBase> point_locator;
101 const bool have_periodic_boundaries =
102 !_periodic_boundaries.empty();
103 if (have_periodic_boundaries && !range.
empty())
104 point_locator = _mesh.sub_point_locator();
107 for (
const auto & elem : range)
108 if (var_description.active_on_subdomain(elem->subdomain_id()))
110#ifdef LIBMESH_ENABLE_AMR
116#ifdef LIBMESH_ENABLE_PERIODIC
120 if (have_periodic_boundaries)
123 _periodic_boundaries,
135#ifdef LIBMESH_ENABLE_PERIODIC
139 const unsigned int _variable_number;
144#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
145class ComputeNodeConstraints
149#ifdef LIBMESH_ENABLE_PERIODIC
153 _node_constraints(node_constraints),
154#ifdef LIBMESH_ENABLE_PERIODIC
155 _periodic_boundaries(periodic_boundaries),
162#ifdef LIBMESH_ENABLE_PERIODIC
163 std::unique_ptr<PointLocatorBase> point_locator;
164 bool have_periodic_boundaries = !_periodic_boundaries.empty();
165 if (have_periodic_boundaries && !range.
empty())
166 point_locator = _mesh.sub_point_locator();
169 for (
const auto & elem : range)
171#ifdef LIBMESH_ENABLE_AMR
174#ifdef LIBMESH_ENABLE_PERIODIC
178 if (have_periodic_boundaries)
180 _periodic_boundaries,
190#ifdef LIBMESH_ENABLE_PERIODIC
198#ifdef LIBMESH_ENABLE_DIRICHLET
209 AddConstraint(
DofMap & dof_map_in) : dof_map(dof_map_in) {}
213 const Number constraint_rhs)
const = 0;
216class AddPrimalConstraint :
public AddConstraint
219 AddPrimalConstraint(
DofMap & dof_map_in) : AddConstraint(dof_map_in) {}
223 const Number constraint_rhs)
const
225 if (!dof_map.is_constrained_dof(dof_number))
226 dof_map.add_constraint_row (dof_number, constraint_row,
227 constraint_rhs,
true);
231class AddAdjointConstraint :
public AddConstraint
234 const unsigned int qoi_index;
237 AddAdjointConstraint(
DofMap & dof_map_in,
unsigned int qoi_index_in)
238 : AddConstraint(dof_map_in), qoi_index(qoi_index_in) {}
242 const Number constraint_rhs)
const
244 dof_map.add_adjoint_constraint_row
245 (qoi_index, dof_number, constraint_row, constraint_rhs,
257class ConstrainDirichlet
265 const AddConstraint & add_fn;
279 return std::numeric_limits<Real>::quiet_NaN();
296 return std::numeric_limits<Number>::quiet_NaN();
309 struct SingleElemBoundaryInfo
312 const std::map<
boundary_id_type, std::set<std::pair<unsigned int, DirichletBoundary *>>> & ordered_map_in) :
314 boundary_id_to_ordered_dirichlet_boundaries(ordered_map_in),
322 const std::map<boundary_id_type, std::set<std::pair<unsigned int, DirichletBoundary *>>> & boundary_id_to_ordered_dirichlet_boundaries;
325 unsigned short n_sides;
326 unsigned short n_edges;
332 std::map<const DirichletBoundary *, std::vector<bool>> is_boundary_node_map;
333 std::map<const DirichletBoundary *, std::vector<bool>> is_boundary_side_map;
334 std::map<const DirichletBoundary *, std::vector<bool>> is_boundary_edge_map;
335 std::map<const DirichletBoundary *, std::vector<bool>> is_boundary_shellface_map;
337 std::map<const DirichletBoundary *, std::vector<bool>> is_boundary_nodeset_map;
341 std::set<std::pair<unsigned int, DirichletBoundary *>> ordered_dbs;
350 bool reinit(
const Elem * elem_in)
359 is_boundary_node_map.clear();
360 is_boundary_side_map.clear();
361 is_boundary_edge_map.clear();
362 is_boundary_shellface_map.clear();
363 is_boundary_nodeset_map.clear();
370 bool has_dirichlet_constraint =
false;
374 std::vector<boundary_id_type> ids_vec;
376 for (
unsigned char s = 0; s != n_sides; ++s)
381 bool do_this_side =
false;
382 for (
const auto & bc_id : ids_vec)
384 if (
auto it = boundary_id_to_ordered_dirichlet_boundaries.find(bc_id);
385 it != boundary_id_to_ordered_dirichlet_boundaries.end())
390 ordered_dbs.insert(it->second.begin(), it->second.end());
393 for (
const auto & db_pair : it->second)
400 auto pr = is_boundary_side_map.emplace(db_pair.second, std::vector<bool>(n_sides,
false));
401 pr.first->second[s] =
true;
409 has_dirichlet_constraint =
true;
412 for (
unsigned int n = 0; n !=
n_nodes; ++n)
420 for (
const auto & db_pair : ordered_dbs)
424 if (
auto side_it = is_boundary_side_map.find(db_pair.second);
425 side_it != is_boundary_side_map.end() && side_it->second[s])
427 auto pr = is_boundary_node_map.emplace(db_pair.second, std::vector<bool>(n_nodes,
false));
428 pr.first->second[n] =
true;
434 for (
unsigned int e = 0; e != n_edges; ++e)
442 for (
const auto & db_pair : ordered_dbs)
446 if (
auto side_it = is_boundary_side_map.find(db_pair.second);
447 side_it != is_boundary_side_map.end() && side_it->second[s])
449 auto pr = is_boundary_edge_map.emplace(db_pair.second, std::vector<bool>(n_edges,
false));
450 pr.first->second[e] =
true;
458 for (
unsigned int n=0; n !=
n_nodes; ++n)
462 for (
const auto & bc_id : ids_vec)
464 if (
auto it = boundary_id_to_ordered_dirichlet_boundaries.find(bc_id);
465 it != boundary_id_to_ordered_dirichlet_boundaries.end())
468 ordered_dbs.insert(it->second.begin(), it->second.end());
471 for (
const auto & db_pair : it->second)
473 auto pr = is_boundary_node_map.emplace(db_pair.second, std::vector<bool>(n_nodes,
false));
474 pr.first->second[n] =
true;
476 auto pr2 = is_boundary_nodeset_map.emplace(db_pair.second, std::vector<bool>(n_nodes,
false));
477 pr2.first->second[n] =
true;
480 has_dirichlet_constraint =
true;
487 for (
unsigned short e=0; e != n_edges; ++e)
491 bool do_this_side =
false;
492 for (
const auto & bc_id : ids_vec)
494 if (
auto it = boundary_id_to_ordered_dirichlet_boundaries.find(bc_id);
495 it != boundary_id_to_ordered_dirichlet_boundaries.end())
500 ordered_dbs.insert(it->second.begin(), it->second.end());
503 for (
const auto & db_pair : it->second)
505 auto pr = is_boundary_edge_map.emplace(db_pair.second, std::vector<bool>(n_edges,
false));
506 pr.first->second[e] =
true;
514 has_dirichlet_constraint =
true;
517 for (
unsigned int n = 0; n !=
n_nodes; ++n)
525 for (
const auto & db_pair : ordered_dbs)
529 if (
auto edge_it = is_boundary_edge_map.find(db_pair.second);
530 edge_it != is_boundary_edge_map.end() && edge_it->second[e])
532 auto pr = is_boundary_node_map.emplace(db_pair.second, std::vector<bool>(n_nodes,
false));
533 pr.first->second[n] =
true;
541 for (
unsigned short shellface=0; shellface != 2; ++shellface)
544 bool do_this_shellface =
false;
546 for (
const auto & bc_id : ids_vec)
548 if (
auto it = boundary_id_to_ordered_dirichlet_boundaries.find(bc_id);
549 it != boundary_id_to_ordered_dirichlet_boundaries.end())
551 has_dirichlet_constraint =
true;
552 do_this_shellface =
true;
555 ordered_dbs.insert(it->second.begin(), it->second.end());
558 for (
const auto & db_pair : it->second)
560 auto pr = is_boundary_shellface_map.emplace(db_pair.second, std::vector<bool>(2,
false));
561 pr.first->second[shellface] =
true;
566 if (do_this_shellface)
569 for (
unsigned int n = 0; n !=
n_nodes; ++n)
570 for (
const auto & db_pair : ordered_dbs)
574 if (
auto side_it = is_boundary_shellface_map.find(db_pair.second);
575 side_it != is_boundary_shellface_map.end() && side_it->second[shellface])
577 auto pr = is_boundary_node_map.emplace(db_pair.second, std::vector<bool>(n_nodes,
false));
578 pr.first->second[n] =
true;
584 return has_dirichlet_constraint;
591 template<
typename OutputType>
592 void apply_lagrange_dirichlet_impl(
const SingleElemBoundaryInfo & sebi,
598 const Elem * elem = sebi.elem;
628 const unsigned int var_component =
632 const unsigned int var = variable.
number();
638 std::unique_ptr<FEMContext> context;
644 context = std::make_unique<FEMContext>
651 if (f_system && context.get())
652 context->pre_fe_reinit(*f_system, elem);
658 const std::vector<dof_id_type> & dof_indices =
662 const unsigned int n_dofs =
663 cast_int<unsigned int>(dof_indices.size());
666 std::vector<char> dof_is_fixed(n_dofs,
false);
678 unsigned int current_dof = 0;
679 for (
unsigned int n=0; n!= sebi.n_nodes; ++n)
684 const unsigned int nc =
694 auto is_boundary_node_it = sebi.is_boundary_node_map.find(&dirichlet);
695 const bool is_boundary_node =
696 (is_boundary_node_it != sebi.is_boundary_node_map.end() &&
697 is_boundary_node_it->second[n]);
700 auto is_boundary_nodeset_it = sebi.is_boundary_nodeset_map.find(&dirichlet);
701 const bool is_boundary_nodeset =
702 (is_boundary_nodeset_it != sebi.is_boundary_nodeset_map.end() &&
703 is_boundary_nodeset_it->second[n]);
706 if ( !(is_boundary_node || is_boundary_nodeset) )
713 libmesh_assert_equal_to (nc, n_vec_dim);
714 for (
unsigned int c = 0; c < n_vec_dim; c++)
717 f_component(f, f_fem, context.get(), var_component+c,
718 elem->
point(n), time);
719 dof_is_fixed[current_dof+c] =
true;
721 current_dof += n_vec_dim;
728 for (
unsigned int i = 0; i < n_dofs; i++)
732 add_fn (dof_indices[i], empty_row, Ue(i));
740 template<
typename OutputType>
741 void apply_dirichlet_impl(
const SingleElemBoundaryInfo & sebi,
747 const Elem * elem = sebi.elem;
754 typedef OutputType OutputShape;
795 const unsigned int var_component =
799 const unsigned int var = variable.
number();
821 std::unique_ptr<FEMContext> context;
827 context = std::make_unique<FEMContext>
848 if (f_system && context.get())
849 context->pre_fe_reinit(*f_system, elem);
855 const std::vector<dof_id_type> & dof_indices =
859 const unsigned int n_dofs =
860 cast_int<unsigned int>(dof_indices.size());
863 std::vector<char> dof_is_fixed(n_dofs,
false);
864 std::vector<int> free_dof(n_dofs, 0);
882 unsigned int current_dof = 0;
883 for (
unsigned int n=0; n!= sebi.n_nodes; ++n)
890 const unsigned int nc =
897 auto is_boundary_node_it = sebi.is_boundary_node_map.find(&dirichlet);
903 const bool not_boundary_node =
904 (is_boundary_node_it == sebi.is_boundary_node_map.end() ||
905 !is_boundary_node_it->second[n]);
907 if (!elem->
is_vertex(n) || not_boundary_node)
914 libmesh_assert_equal_to (nc, 0);
920 libmesh_assert_equal_to (nc, n_vec_dim);
921 for (
unsigned int c = 0; c < n_vec_dim; c++)
924 f_component(f, f_fem, context.get(), var_component+c,
925 elem->
point(n), time);
926 dof_is_fixed[current_dof+c] =
true;
928 current_dof += n_vec_dim;
934 f_component(f, f_fem, context.get(), var_component,
935 elem->
point(n), time);
936 dof_is_fixed[current_dof] =
true;
939 g_component(g, g_fem, context.get(), var_component,
940 elem->
point(n), time);
942 Ue(current_dof) = grad(0);
943 dof_is_fixed[current_dof] =
true;
949 nxplus = elem->
point(n);
953 g_component(g, g_fem, context.get(), var_component,
956 g_component(g, g_fem, context.get(), var_component,
959 Ue(current_dof) = grad(1);
960 dof_is_fixed[current_dof] =
true;
963 Ue(current_dof) = (gxplus(1) - gxminus(1))
965 dof_is_fixed[current_dof] =
true;
971 Ue(current_dof) = grad(2);
972 dof_is_fixed[current_dof] =
true;
975 Ue(current_dof) = (gxplus(2) - gxminus(2))
977 dof_is_fixed[current_dof] =
true;
981 nyplus = elem->
point(n);
985 g_component(g, g_fem, context.get(), var_component,
988 g_component(g, g_fem, context.get(), var_component,
991 Ue(current_dof) = (gyplus(2) - gyminus(2))
993 dof_is_fixed[current_dof] =
true;
997 nxmyp = elem->
point(n),
998 nxpym = elem->
point(n),
999 nxpyp = elem->
point(n);
1009 g_component(g, g_fem, context.get(), var_component,
1012 g_component(g, g_fem, context.get(), var_component,
1015 g_component(g, g_fem, context.get(), var_component,
1018 g_component(g, g_fem, context.get(), var_component,
1020 Number gxzplus = (gxpyp(2) - gxmyp(2))
1022 Number gxzminus = (gxpym(2) - gxmym(2))
1025 Ue(current_dof) = (gxzplus - gxzminus)
1027 dof_is_fixed[current_dof] =
true;
1035 else if (cont ==
C_ONE)
1037 libmesh_assert_equal_to (nc, 1 +
dim);
1039 f_component(f, f_fem, context.get(), var_component,
1040 elem->
point(n), time);
1041 dof_is_fixed[current_dof] =
true;
1044 g_component(g, g_fem, context.get(), var_component,
1045 elem->
point(n), time);
1046 for (
unsigned int i=0; i!=
dim; ++i)
1048 Ue(current_dof) = grad(i);
1049 dof_is_fixed[current_dof] =
true;
1054 libmesh_error_msg(
"Unknown continuity cont = " << cont);
1074 const std::vector<std::vector<OutputShape>> & phi = edge_fe->
get_phi();
1075 const std::vector<Point> & xyz_values = edge_fe->
get_xyz();
1076 const std::vector<Real> & JxW = edge_fe->
get_JxW();
1079 const std::vector<std::vector<OutputGradient>> * dphi =
nullptr;
1082 const std::vector<std::vector<OutputGradient>> & ref_dphi = edge_fe->
get_dphi();
1087 std::vector<unsigned int> edge_dofs;
1093 if (
const auto is_boundary_edge_it = sebi.is_boundary_edge_map.find(&dirichlet);
1094 is_boundary_edge_it != sebi.is_boundary_edge_map.end())
1096 for (
unsigned int e=0; e != sebi.n_edges; ++e)
1098 if (!is_boundary_edge_it->second[e])
1104 const unsigned int n_edge_dofs =
1105 cast_int<unsigned int>(edge_dofs.size());
1109 unsigned int free_dofs = 0;
1110 for (
unsigned int i=0; i != n_edge_dofs; ++i)
1111 if (!dof_is_fixed[edge_dofs[i]])
1112 free_dof[free_dofs++] = i;
1128 for (
unsigned int qp=0; qp<n_qp; qp++)
1131 OutputNumber fineval(0);
1134 for (
unsigned int c = 0; c < n_vec_dim; c++)
1136 f_component(f, f_fem, context.get(), var_component+c,
1137 xyz_values[qp], time);
1140 OutputNumberGradient finegrad;
1143 unsigned int g_rank;
1157 libmesh_error_msg(
"Unknown field type!");
1161 for (
unsigned int c = 0; c < n_vec_dim; c++)
1162 for (
unsigned int d = 0; d < g_rank; d++)
1163 g_accessor(c + d*
dim ) =
1164 g_component(g, g_fem, context.get(), var_component,
1165 xyz_values[qp], time)(c);
1168 for (
unsigned int sidei=0, freei=0; sidei != n_edge_dofs; ++sidei)
1170 unsigned int i = edge_dofs[sidei];
1172 if (dof_is_fixed[i])
1174 for (
unsigned int sidej=0, freej=0; sidej != n_edge_dofs; ++sidej)
1176 unsigned int j = edge_dofs[sidej];
1177 if (dof_is_fixed[j])
1178 Fe(freei) -= phi[i][qp] * phi[j][qp] *
1181 Ke(freei,freej) += phi[i][qp] *
1182 phi[j][qp] * JxW[qp];
1185 if (dof_is_fixed[j])
1186 Fe(freei) -= ((*dphi)[i][qp].contract((*dphi)[j][qp]) ) *
1189 Ke(freei,freej) += ((*dphi)[i][qp].contract((*dphi)[j][qp]))
1192 if (!dof_is_fixed[j])
1195 Fe(freei) += phi[i][qp] * fineval * JxW[qp];
1197 Fe(freei) += (finegrad.contract( (*dphi)[i][qp]) ) *
1206 for (
unsigned int i=0; i != free_dofs; ++i)
1208 Number & ui = Ue(edge_dofs[free_dof[i]]);
1212 dof_is_fixed[edge_dofs[free_dof[i]]] =
true;
1232 const std::vector<std::vector<OutputShape>> & phi = side_fe->
get_phi();
1233 const std::vector<Point> & xyz_values = side_fe->
get_xyz();
1234 const std::vector<Real> & JxW = side_fe->
get_JxW();
1237 const std::vector<std::vector<OutputGradient>> * dphi =
nullptr;
1240 const std::vector<std::vector<OutputGradient>> & ref_dphi = side_fe->
get_dphi();
1245 std::vector<unsigned int> side_dofs;
1251 if (
const auto is_boundary_side_it = sebi.is_boundary_side_map.find(&dirichlet);
1252 is_boundary_side_it != sebi.is_boundary_side_map.end())
1254 for (
unsigned int s=0; s != sebi.n_sides; ++s)
1256 if (!is_boundary_side_it->second[s])
1262 const unsigned int n_side_dofs =
1263 cast_int<unsigned int>(side_dofs.size());
1267 unsigned int free_dofs = 0;
1268 for (
unsigned int i=0; i != n_side_dofs; ++i)
1269 if (!dof_is_fixed[side_dofs[i]])
1270 free_dof[free_dofs++] = i;
1282 side_fe->
reinit(elem, s);
1286 for (
unsigned int qp=0; qp<n_qp; qp++)
1289 OutputNumber fineval(0);
1292 for (
unsigned int c = 0; c < n_vec_dim; c++)
1294 f_component(f, f_fem, context.get(), var_component+c,
1295 xyz_values[qp], time);
1298 OutputNumberGradient finegrad;
1301 unsigned int g_rank;
1315 libmesh_error_msg(
"Unknown field type!");
1319 for (
unsigned int c = 0; c < n_vec_dim; c++)
1320 for (
unsigned int d = 0; d < g_rank; d++)
1321 g_accessor(c + d*
dim ) =
1322 g_component(g, g_fem, context.get(), var_component,
1323 xyz_values[qp], time)(c);
1326 for (
unsigned int sidei=0, freei=0; sidei != n_side_dofs; ++sidei)
1328 unsigned int i = side_dofs[sidei];
1330 if (dof_is_fixed[i])
1332 for (
unsigned int sidej=0, freej=0; sidej != n_side_dofs; ++sidej)
1334 unsigned int j = side_dofs[sidej];
1335 if (dof_is_fixed[j])
1336 Fe(freei) -= phi[i][qp] * phi[j][qp] *
1339 Ke(freei,freej) += phi[i][qp] *
1340 phi[j][qp] * JxW[qp];
1343 if (dof_is_fixed[j])
1344 Fe(freei) -= ((*dphi)[i][qp].contract((*dphi)[j][qp])) *
1347 Ke(freei,freej) += ((*dphi)[i][qp].contract((*dphi)[j][qp]))
1350 if (!dof_is_fixed[j])
1353 Fe(freei) += (fineval * phi[i][qp]) * JxW[qp];
1355 Fe(freei) += (finegrad.contract((*dphi)[i][qp])) *
1364 for (
unsigned int i=0; i != free_dofs; ++i)
1366 Number & ui = Ue(side_dofs[free_dof[i]]);
1372 dof_is_fixed[side_dofs[free_dof[i]]] =
true;
1392 const std::vector<std::vector<OutputShape>> & phi = fe->
get_phi();
1393 const std::vector<Point> & xyz_values = fe->
get_xyz();
1394 const std::vector<Real> & JxW = fe->
get_JxW();
1397 const std::vector<std::vector<OutputGradient>> * dphi =
nullptr;
1400 const std::vector<std::vector<OutputGradient>> & ref_dphi = fe->
get_dphi();
1408 if (
const auto is_boundary_shellface_it = sebi.is_boundary_shellface_map.find(&dirichlet);
1409 is_boundary_shellface_it != sebi.is_boundary_shellface_map.end())
1411 for (
unsigned int shellface=0; shellface != 2; ++shellface)
1413 if (!is_boundary_shellface_it->second[shellface])
1417 std::vector<unsigned int> shellface_dofs(n_dofs);
1418 std::iota(shellface_dofs.begin(), shellface_dofs.end(), 0);
1422 unsigned int free_dofs = 0;
1423 for (
unsigned int i=0; i != n_dofs; ++i)
1424 if (!dof_is_fixed[shellface_dofs[i]])
1425 free_dof[free_dofs++] = i;
1441 for (
unsigned int qp=0; qp<n_qp; qp++)
1444 OutputNumber fineval(0);
1447 for (
unsigned int c = 0; c < n_vec_dim; c++)
1449 f_component(f, f_fem, context.get(), var_component+c,
1450 xyz_values[qp], time);
1453 OutputNumberGradient finegrad;
1456 unsigned int g_rank;
1470 libmesh_error_msg(
"Unknown field type!");
1474 for (
unsigned int c = 0; c < n_vec_dim; c++)
1475 for (
unsigned int d = 0; d < g_rank; d++)
1476 g_accessor(c + d*
dim ) =
1477 g_component(g, g_fem, context.get(), var_component,
1478 xyz_values[qp], time)(c);
1481 for (
unsigned int shellfacei=0, freei=0;
1482 shellfacei != n_dofs; ++shellfacei)
1484 unsigned int i = shellface_dofs[shellfacei];
1486 if (dof_is_fixed[i])
1488 for (
unsigned int shellfacej=0, freej=0;
1489 shellfacej != n_dofs; ++shellfacej)
1491 unsigned int j = shellface_dofs[shellfacej];
1492 if (dof_is_fixed[j])
1493 Fe(freei) -= phi[i][qp] * phi[j][qp] *
1496 Ke(freei,freej) += phi[i][qp] *
1497 phi[j][qp] * JxW[qp];
1500 if (dof_is_fixed[j])
1501 Fe(freei) -= ((*dphi)[i][qp].contract((*dphi)[j][qp])) *
1504 Ke(freei,freej) += ((*dphi)[i][qp].contract((*dphi)[j][qp]))
1507 if (!dof_is_fixed[j])
1510 Fe(freei) += (fineval * phi[i][qp]) * JxW[qp];
1512 Fe(freei) += (finegrad.contract((*dphi)[i][qp])) *
1521 for (
unsigned int i=0; i != free_dofs; ++i)
1523 Number & ui = Ue(shellface_dofs[free_dof[i]]);
1525 std::abs(ui - Ushellface(i)) <
TOLERANCE);
1527 dof_is_fixed[shellface_dofs[free_dof[i]]] =
true;
1537 for (
unsigned int i = 0; i < n_dofs; i++)
1541 add_fn (dof_indices[i], empty_row, Ue(i));
1547 ConstrainDirichlet (
DofMap & dof_map_in,
1551 const AddConstraint & add_in) :
1552 dof_map(dof_map_in),
1555 dirichlets(dirichlets_in),
1559 ConstrainDirichlet (ConstrainDirichlet &&) =
default;
1560 ConstrainDirichlet (
const ConstrainDirichlet &) =
default;
1564 ConstrainDirichlet & operator= (
const ConstrainDirichlet &) =
delete;
1565 ConstrainDirichlet & operator= (ConstrainDirichlet &&) =
delete;
1579 System * system =
nullptr;
1584 std::map<boundary_id_type, std::set<std::pair<unsigned int, DirichletBoundary *>>>
1585 boundary_id_to_ordered_dirichlet_boundaries;
1590 const auto & dirichlet = dirichlets[dirichlet_id];
1593 for (
const auto & b_id : dirichlet->
b)
1594 boundary_id_to_ordered_dirichlet_boundaries[b_id].emplace(dirichlet_id, dirichlet.
get());
1596 for (
const auto & var : dirichlet->variables)
1599 auto current_system = variable.
system();
1602 system = current_system;
1604 libmesh_error_msg_if(current_system != system,
1605 "All variables should be defined on the same System");
1614 libmesh_error_msg_if(!system,
"Valid System not found for any Variables.");
1621 auto fem_context = std::make_unique<FEMContext>
1622 (*system,
nullptr,
false);
1633 SingleElemBoundaryInfo sebi(boundary_info, boundary_id_to_ordered_dirichlet_boundaries);
1636 for (
const auto & elem : range)
1644 bool has_dirichlet_constraint = sebi.reinit(elem);
1647 if (!has_dirichlet_constraint)
1650 for (
const auto & db_pair : sebi.ordered_dbs)
1653 const auto & dirichlet = db_pair.second;
1656 for (
const auto & var : dirichlet->variables)
1662 libmesh_assert_equal_to(variable.
number(), var);
1677 this->apply_lagrange_dirichlet_impl<Real>( sebi, variable, *dirichlet, *fem_context );
1679 this->apply_dirichlet_impl<Real>( sebi, variable, *dirichlet, *fem_context );
1684 this->apply_dirichlet_impl<RealGradient>( sebi, variable, *dirichlet, *fem_context );
1688 libmesh_error_msg(
"Unknown field type!");
1711#ifdef LIBMESH_ENABLE_CONSTRAINTS
1716 parallel_object_only();
1726 const DofConstraints::const_iterator lower =
1731 return cast_int<dof_id_type>(std::distance(lower, upper));
1738 parallel_object_only();
1740 LOG_SCOPE(
"create_dof_constraints()",
"DofMap");
1754 const bool possible_local_constraints =
false
1757#ifdef LIBMESH_ENABLE_AMR
1760#ifdef LIBMESH_ENABLE_PERIODIC
1763#ifdef LIBMESH_ENABLE_DIRICHLET
1769 bool possible_global_constraints = possible_local_constraints;
1770#if defined(LIBMESH_ENABLE_PERIODIC) || defined(LIBMESH_ENABLE_DIRICHLET) || defined(LIBMESH_ENABLE_AMR)
1773 this->
comm().
max(possible_global_constraints);
1781#ifdef LIBMESH_ENABLE_CONSTRAINTS
1786#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
1790 if (!possible_global_constraints)
1800 mesh.local_elements_end());
1811#ifdef LIBMESH_ENABLE_PERIODIC
1814 this->
comm().
max(need_point_locator);
1816 if (need_point_locator)
1820#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
1823#ifdef LIBMESH_ENABLE_PERIODIC
1838#ifdef LIBMESH_ENABLE_PERIODIC
1844#ifdef LIBMESH_ENABLE_DIRICHLET
1863 AddPrimalConstraint(*
this)));
1877 ConstrainDirichlet(*
this,
mesh, time, adb_q,
1878 AddAdjointConstraint(*
this, qoi_index)));
1906 bool constraint_rows_empty = constraint_rows.empty();
1907 this->
comm().
min(constraint_rows_empty);
1916#ifdef LIBMESH_ENABLE_PERIODIC
1918 "Periodic boundary conditions are not yet implemented for spline meshes");
1923 std::unique_ptr<SparsityPattern::Build> sp;
1924 std::unique_ptr<SparseMatrix<Number>> mat;
1926 const unsigned int n_adjoint_rhs =
1930 std::vector<std::unique_ptr<NumericVector<Number>>>
1931 solve_rhs(n_adjoint_rhs+1);
1936 std::set<dof_id_type> my_dirichlet_spline_dofs;
1939 std::unordered_set<dof_id_type> was_previously_constrained;
1941 const unsigned int sys_num = this->
sys_number();
1942 for (
auto & node_row : constraint_rows)
1944 const Node * node = node_row.first;
1966 for (
const auto & [pr, val] : node_row.second)
1968 const Elem * spline_elem = pr.first;
1971 const Node & spline_node =
1976 dc_row[spline_dof_id] = val;
1982 was_previously_constrained.insert(constrained_id);
1986 for (
auto & row_entry : dc_row)
1987 my_dirichlet_spline_dofs.insert(row_entry.first);
2006 if (this->
comm().size() > 1)
2010 their_dirichlet_spline_dofs;
2016 my_dirichlet_spline_dofs.end()));
2018 for (
auto d : my_dirichlet_spline_dofs)
2020 libmesh_assert_less(d, this->
end_dof(this->
comm().size()-1));
2021 while (d >= this->
end_dof(destination_pid))
2025 their_dirichlet_spline_dofs[destination_pid].push_back(d);
2028 auto receive_dof_functor =
2029 [& my_dirichlet_spline_dofs]
2031 const std::vector<dof_id_type> & dofs)
2033 my_dirichlet_spline_dofs.insert(dofs.begin(), dofs.end());
2037 (this->
comm(), their_dirichlet_spline_dofs, receive_dof_functor);
2047 bool important_prior_constraints =
2048 !was_previously_constrained.empty();
2049 this->
comm().
max(important_prior_constraints);
2051 if (important_prior_constraints)
2067 mat->attach_dof_map(*
this);
2069 mat->attach_sparsity_pattern(*sp);
2072 for (
auto & node_row : constraint_rows)
2074 const Node * node = node_row.first;
2089 if (was_previously_constrained.count(constrained_id))
2095 std::vector<dof_id_type>
dof_indices(1, constrained_id);
2103 DofConstraintValueMap::const_iterator rhsit =
2104 vals.find(constrained_id);
2105 F(0) = (rhsit == vals.end()) ? 0 : rhsit->second;
2108 if (rhsit != vals.end())
2126 if (!was_previously_constrained.count(d) &&
2127 !my_dirichlet_spline_dofs.count(d))
2132 std::unique_ptr<LinearSolver<Number>> linear_solver =
2135 std::unique_ptr<NumericVector<Number>> projected_vals =
2142 for (
auto sd : my_dirichlet_spline_dofs)
2151 const unsigned int max_its = 5000;
2153 linear_solver->solve(*mat, *projected_vals,
2154 *(solve_rhs[q]), tol, max_its);
2160 for (
auto sd : my_dirichlet_spline_dofs)
2163 Number constraint_rhs = (*projected_vals)(sd);
2165 std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
2166 vals.emplace(sd, constraint_rhs);
2168 rhs_it.first->second = constraint_rhs;
2178 const Number constraint_rhs,
2179 const bool forbid_constraint_overwrite)
2182 libmesh_error_msg_if(forbid_constraint_overwrite && this->
is_constrained_dof(dof_number),
2183 "ERROR: DOF " << dof_number <<
" was already constrained!");
2185 libmesh_assert_less(dof_number, this->
n_dofs());
2189 libmesh_assert_msg(!constraint_row.count(dof_number),
2190 "Error: constraint_row for dof " << dof_number <<
2191 " should not contain an entry for dof " << dof_number);
2194 for (
const auto & pr : constraint_row)
2195 libmesh_assert_less(pr.first, this->n_dofs());
2201 std::pair<DofConstraintValueMap::iterator, bool> rhs_it =
2204 rhs_it.first->second = constraint_rhs;
2211 const Number constraint_rhs,
2212 const bool forbid_constraint_overwrite)
2215 if (forbid_constraint_overwrite)
2218 "ERROR: DOF " << dof_number <<
" has no corresponding primal constraint!");
2250 bool print_nonlocal)
const
2252 parallel_object_only();
2254 std::string local_constraints =
2259 this->
comm().
send(0, local_constraints);
2263 os <<
"Processor 0:\n";
2264 os << local_constraints;
2269 os <<
"Processor " << p <<
":\n";
2270 os << local_constraints;
2277 std::ostringstream os;
2278#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
2284 os <<
"Node Constraints:"
2290 if (!print_nonlocal &&
2295 const Point & offset = pr.second;
2297 os <<
"Constraints for Node id " << node->id()
2300 for (
const auto & [cnode, val] : row)
2301 os <<
" (" << cnode->id() <<
"," << val <<
")\t";
2303 os <<
"rhs: " << offset;
2314 os <<
"DoF Constraints:"
2323 DofConstraintValueMap::const_iterator rhsit =
2328 os <<
"Constraints for DoF " << i
2331 for (
const auto & item : row)
2332 os <<
" (" << item.first <<
"," << item.second <<
")\t";
2334 os <<
"rhs: " << rhs;
2338 for (
unsigned int qoi_index = 0,
2340 qoi_index != n_qois; ++qoi_index)
2342 os <<
"Adjoint " << qoi_index <<
" DoF rhs values:"
2347 for (
const auto & [i, rhs] : adjoint_map_it->second)
2353 os <<
"RHS for DoF " << i
2366 std::vector<dof_id_type> & elem_dofs,
2367 bool asymmetric_constraint_rows)
const
2369 libmesh_assert_equal_to (elem_dofs.size(), matrix.
m());
2370 libmesh_assert_equal_to (elem_dofs.size(), matrix.
n());
2382 LOG_SCOPE(
"constrain_elem_matrix()",
"DofMap");
2385 if ((C.
m() == matrix.
m()) &&
2386 (C.
n() == elem_dofs.size()))
2393 libmesh_assert_equal_to (matrix.
m(), matrix.
n());
2394 libmesh_assert_equal_to (matrix.
m(), elem_dofs.size());
2395 libmesh_assert_equal_to (matrix.
n(), elem_dofs.size());
2398 for (
unsigned int i=0,
2399 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2400 i != n_elem_dofs; i++)
2409 if (asymmetric_constraint_rows)
2411 DofConstraints::const_iterator
2424 for (
const auto & item : constraint_row)
2425 for (unsigned
int j=0; j != n_elem_dofs; j++)
2426 if (elem_dofs[j] == item.first)
2427 matrix(i,j) = -item.second;
2437 std::vector<dof_id_type> & elem_dofs,
2438 bool asymmetric_constraint_rows)
const
2440 libmesh_assert_equal_to (elem_dofs.size(), matrix.
m());
2441 libmesh_assert_equal_to (elem_dofs.size(), matrix.
n());
2442 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2454 LOG_SCOPE(
"cnstrn_elem_mat_vec()",
"DofMap");
2457 if ((C.
m() == matrix.
m()) &&
2458 (C.
n() == elem_dofs.size()))
2465 libmesh_assert_equal_to (matrix.
m(), matrix.
n());
2466 libmesh_assert_equal_to (matrix.
m(), elem_dofs.size());
2467 libmesh_assert_equal_to (matrix.
n(), elem_dofs.size());
2470 for (
unsigned int i=0,
2471 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2472 i != n_elem_dofs; i++)
2484 if (asymmetric_constraint_rows)
2486 DofConstraints::const_iterator
2496 for (
const auto & item : constraint_row)
2497 for (unsigned
int j=0; j != n_elem_dofs; j++)
2498 if (elem_dofs[j] == item.first)
2499 matrix(i,j) = -item.second;
2516 std::vector<dof_id_type> & elem_dofs,
2517 bool asymmetric_constraint_rows,
2518 int qoi_index)
const
2520 libmesh_assert_equal_to (elem_dofs.size(), matrix.
m());
2521 libmesh_assert_equal_to (elem_dofs.size(), matrix.
n());
2522 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2535 LOG_SCOPE(
"hetero_cnstrn_elem_mat_vec()",
"DofMap");
2538 if ((C.
m() == matrix.
m()) &&
2539 (C.
n() == elem_dofs.size()))
2547 rhs_values = &it->second;
2562 libmesh_assert_equal_to (matrix.
m(), matrix.
n());
2563 libmesh_assert_equal_to (matrix.
m(), elem_dofs.size());
2564 libmesh_assert_equal_to (matrix.
n(), elem_dofs.size());
2566 for (
unsigned int i=0,
2567 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2568 i != n_elem_dofs; i++)
2583 if (asymmetric_constraint_rows)
2585 DofConstraints::const_iterator
2592 for (
const auto & item : constraint_row)
2593 for (unsigned
int j=0; j != n_elem_dofs; j++)
2594 if (elem_dofs[j] == item.first)
2595 matrix(i,j) = -item.second;
2599 const DofConstraintValueMap::const_iterator valpos =
2600 rhs_values->find(dof_id);
2602 rhs(i) = (valpos == rhs_values->end()) ?
2618 std::vector<dof_id_type> & elem_dofs,
2621 libmesh_assert_equal_to (elem_dofs.size(), matrix.
m());
2622 libmesh_assert_equal_to (elem_dofs.size(), matrix.
n());
2623 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2640 LOG_SCOPE(
"hetero_cnstrn_elem_jac_res()",
"DofMap");
2643 if ((C.
m() != matrix.
m()) ||
2644 (C.
n() != elem_dofs.size()))
2655 libmesh_assert_equal_to (matrix.
m(), matrix.
n());
2656 libmesh_assert_equal_to (matrix.
m(), elem_dofs.size());
2657 libmesh_assert_equal_to (matrix.
n(), elem_dofs.size());
2659 for (
unsigned int i=0,
2660 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2661 i != n_elem_dofs; i++)
2679 for (
const auto & item : constraint_row)
2680 for (
unsigned int j=0; j != n_elem_dofs; j++)
2681 if (elem_dofs[j] == item.first)
2682 matrix(i,j) = -item.second;
2684 const DofConstraintValueMap::const_iterator valpos =
2687 Number & rhs_val = rhs(i);
2689 0 : -valpos->second;
2690 for (
const auto & [constraining_dof, coef] : constraint_row)
2691 rhs_val -= coef * solution_local(constraining_dof);
2692 rhs_val += solution_local(dof_id);
2700 std::vector<dof_id_type> & elem_dofs,
2703 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2719 LOG_SCOPE(
"hetero_cnstrn_elem_res()",
"DofMap");
2722 if ((C.
m() != rhs.
size()) ||
2723 (C.
n() != elem_dofs.size()))
2730 for (
unsigned int i=0,
2731 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2732 i != n_elem_dofs; i++)
2744 const DofConstraintValueMap::const_iterator valpos =
2747 Number & rhs_val = rhs(i);
2749 0 : -valpos->second;
2750 for (
const auto & [constraining_dof, coef] : constraint_row)
2751 rhs_val -= coef * solution_local(constraining_dof);
2752 rhs_val += solution_local(dof_id);
2760 std::vector<dof_id_type> & elem_dofs,
2763 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2777 LOG_SCOPE(
"cnstrn_elem_residual()",
"DofMap");
2780 if (C.
n() != elem_dofs.size())
2787 for (
unsigned int i=0,
2788 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2789 i != n_elem_dofs; i++)
2801 Number & rhs_val = rhs(i);
2803 for (
const auto & [constraining_dof, coef] : constraint_row)
2804 rhs_val -= coef * solution_local(constraining_dof);
2805 rhs_val += solution_local(dof_id);
2813 std::vector<dof_id_type> & elem_dofs,
2814 bool asymmetric_constraint_rows,
2815 int qoi_index)
const
2817 libmesh_assert_equal_to (elem_dofs.size(), matrix.
m());
2818 libmesh_assert_equal_to (elem_dofs.size(), matrix.
n());
2819 libmesh_assert_equal_to (elem_dofs.size(), rhs.
size());
2832 LOG_SCOPE(
"hetero_cnstrn_elem_vec()",
"DofMap");
2835 if ((C.
m() == matrix.
m()) &&
2836 (C.
n() == elem_dofs.size()))
2844 rhs_values = &it->second;
2855 for (
unsigned int i=0,
2856 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
2857 i != n_elem_dofs; i++)
2866 if (asymmetric_constraint_rows && rhs_values)
2868 const DofConstraintValueMap::const_iterator valpos =
2869 rhs_values->find(dof_id);
2871 rhs(i) = (valpos == rhs_values->end()) ?
2886 std::vector<dof_id_type> & row_dofs,
2887 std::vector<dof_id_type> & col_dofs,
2888 bool asymmetric_constraint_rows)
const
2890 libmesh_assert_equal_to (row_dofs.size(), matrix.
m());
2891 libmesh_assert_equal_to (col_dofs.size(), matrix.
n());
2904 std::vector<dof_id_type> orig_row_dofs(row_dofs);
2905 std::vector<dof_id_type> orig_col_dofs(col_dofs);
2910 LOG_SCOPE(
"constrain_elem_matrix()",
"DofMap");
2912 row_dofs = orig_row_dofs;
2913 col_dofs = orig_col_dofs;
2915 bool constraint_found =
false;
2919 if ((R.
m() == matrix.
m()) &&
2920 (R.
n() == row_dofs.size()))
2923 constraint_found =
true;
2926 if ((C.
m() == matrix.
n()) &&
2927 (C.
n() == col_dofs.size()))
2930 constraint_found =
true;
2934 if (constraint_found)
2936 libmesh_assert_equal_to (matrix.
m(), row_dofs.size());
2937 libmesh_assert_equal_to (matrix.
n(), col_dofs.size());
2940 for (
unsigned int i=0,
2941 n_row_dofs = cast_int<unsigned int>(row_dofs.size());
2942 i != n_row_dofs; i++)
2947 if (row_dofs[i] != col_dofs[j])
2953 if (asymmetric_constraint_rows)
2955 DofConstraints::const_iterator
2964 for (
const auto & item : constraint_row)
2965 for (unsigned
int j=0,
2966 n_col_dofs =
cast_int<unsigned
int>(col_dofs.size());
2967 j != n_col_dofs; j++)
2968 if (col_dofs[j] == item.first)
2969 matrix(i,j) = -item.second;
2978 std::vector<dof_id_type> & row_dofs,
2981 libmesh_assert_equal_to (rhs.
size(), row_dofs.size());
2992 LOG_SCOPE(
"constrain_elem_vector()",
"DofMap");
2995 if ((R.
m() == rhs.
size()) &&
2996 (R.
n() == row_dofs.size()))
3002 libmesh_assert_equal_to (row_dofs.size(), rhs.
size());
3004 for (
unsigned int i=0,
3005 n_row_dofs = cast_int<unsigned int>(row_dofs.size());
3006 i != n_row_dofs; i++)
3021 std::vector<dof_id_type> & row_dofs,
3024 libmesh_assert_equal_to (v.
size(), row_dofs.size());
3025 libmesh_assert_equal_to (w.
size(), row_dofs.size());
3036 LOG_SCOPE(
"cnstrn_elem_dyad_mat()",
"DofMap");
3039 if ((R.
m() == v.
size()) &&
3040 (R.
n() == row_dofs.size()))
3050 libmesh_assert_equal_to (row_dofs.size(), v.
size());
3051 libmesh_assert_equal_to (row_dofs.size(), w.
size());
3055 for (
unsigned int i=0,
3056 n_row_dofs = cast_int<unsigned int>(row_dofs.size());
3057 i != n_row_dofs; i++)
3086 bool homogeneous)
const
3088 parallel_object_only();
3093 LOG_SCOPE(
"enforce_constraints_exactly()",
"DofMap");
3103 std::unique_ptr<NumericVector<Number>> v_built;
3111 i<v_built->last_local_index(); i++)
3112 v_built->set(i, (*v)(i));
3114 v_global = v_built.
get();
3123 this->get_send_list(),
true,
3127 v_local = v_built.
get();
3144 libmesh_assert_equal_to (
this, &(system.
get_dof_map()));
3158 for (
const auto & [dof, val] : constraint_row)
3179 bool homogeneous)
const
3181 parallel_object_only();
3192 std::unique_ptr<NumericVector<Number>> solution_built;
3194 solution_local = solution;
3199 this->get_send_list(),
true,
GHOSTED);
3201 solution_built->close();
3202 solution_local = solution_built.
get();
3210 libmesh_assert_equal_to (
this, &(system.
get_dof_map()));
3218 for (
const auto & [dof, val] : constraint_row)
3220 exact_value += (*solution_local)(constrained_dof);
3235 parallel_object_only();
3243 libmesh_assert_equal_to (
this, &(system.
get_dof_map()));
3250 for (
const auto & j : constraint_row)
3251 jac->set(constrained_dof, j.first, -j.second);
3252 jac->
set(constrained_dof, constrained_dof, 1);
3258 unsigned int q)
const
3260 parallel_object_only();
3265 LOG_SCOPE(
"enforce_adjoint_constraints_exactly()",
"DofMap");
3269 std::unique_ptr<NumericVector<Number>> v_built;
3277 i<v_built->last_local_index(); i++)
3278 v_built->set(i, v(i));
3280 v_global = v_built.
get();
3289 this->get_send_list(),
true,
GHOSTED);
3292 v_local = v_built.
get();
3302 libmesh_error_msg(
"ERROR: Unknown v.type() == " << v.
type());
3311 const AdjointDofConstraintValues::const_iterator
3315 nullptr : &adjoint_constraint_map_it->second;
3325 if (
const auto adjoint_constraint_it = constraint_map->find(constrained_dof);
3326 adjoint_constraint_it != constraint_map->end())
3330 for (
const auto & j : constraint_row)
3350std::pair<Real, Real>
3361 Real max_absolute_error = 0., max_relative_error = 0.;
3365 libmesh_assert_equal_to (
this, &(system.
get_dof_map()));
3368 std::vector<dof_id_type> local_dof_indices;
3370 for (
const auto & elem :
mesh.active_local_element_ptr_range())
3373 std::vector<dof_id_type> raw_dof_indices = local_dof_indices;
3384 libmesh_assert_equal_to (C.
m(), raw_dof_indices.size());
3385 libmesh_assert_equal_to (C.
n(), local_dof_indices.size());
3396 DofConstraints::const_iterator
3403 DofConstraintValueMap::const_iterator rhsit =
3410 if (local_dof_indices[j] != global_dof)
3412 vec(local_dof_indices[j]);
3415 max_absolute_error = std::max(max_absolute_error,
3417 max_relative_error = std::max(max_relative_error,
3424 return std::pair<Real, Real>(max_absolute_error, max_relative_error);
3430 std::vector<dof_id_type> & elem_dofs,
3431 const bool called_recursively)
const
3433 LOG_SCOPE_IF(
"build_constraint_matrix()",
"DofMap", !called_recursively);
3436 typedef std::set<dof_id_type> RCSet;
3439 bool we_have_constraints =
false;
3446 for (
const auto & dof : elem_dofs)
3449 we_have_constraints =
true;
3452 DofConstraints::const_iterator
3462 for (
const auto & item : constraint_row)
3463 dof_set.insert (item.first);
3468 if (!we_have_constraints)
3471 for (
const auto & dof : elem_dofs)
3472 dof_set.erase (dof);
3480 if (!dof_set.empty() ||
3481 !called_recursively)
3483 const unsigned int old_size =
3484 cast_int<unsigned int>(elem_dofs.size());
3487 elem_dofs.insert(elem_dofs.end(),
3488 dof_set.begin(), dof_set.end());
3493 cast_int<unsigned int>(elem_dofs.size()));
3496 for (
unsigned int i=0; i != old_size; i++)
3500 DofConstraints::const_iterator
3510 for (
const auto & item : constraint_row)
3511 for (
unsigned int j=0,
3512 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
3513 j != n_elem_dofs; j++)
3514 if (elem_dofs[j] == item.first)
3515 C(i,j) = item.second;
3529 if ((C.
n() == Cnew.
m()) &&
3530 (Cnew.
n() == elem_dofs.size()))
3533 libmesh_assert_equal_to (C.
n(), elem_dofs.size());
3541 std::vector<dof_id_type> & elem_dofs,
3543 const bool called_recursively)
const
3545 LOG_SCOPE_IF(
"build_constraint_matrix_and_vector()",
"DofMap", !called_recursively);
3548 typedef std::set<dof_id_type> RCSet;
3551 bool we_have_constraints =
false;
3558 for (
const auto & dof : elem_dofs)
3561 we_have_constraints =
true;
3564 DofConstraints::const_iterator
3574 for (
const auto & item : constraint_row)
3575 dof_set.insert (item.first);
3580 if (!we_have_constraints)
3583 for (
const auto & dof : elem_dofs)
3584 dof_set.erase (dof);
3592 if (!dof_set.empty() ||
3593 !called_recursively)
3600 rhs_values = &it->second;
3602 const unsigned int old_size =
3603 cast_int<unsigned int>(elem_dofs.size());
3606 elem_dofs.insert(elem_dofs.end(),
3607 dof_set.begin(), dof_set.end());
3612 cast_int<unsigned int>(elem_dofs.size()));
3616 for (
unsigned int i=0; i != old_size; i++)
3620 DofConstraints::const_iterator
3630 for (
const auto & item : constraint_row)
3631 for (
unsigned int j=0,
3632 n_elem_dofs = cast_int<unsigned int>(elem_dofs.size());
3633 j != n_elem_dofs; j++)
3634 if (elem_dofs[j] == item.first)
3635 C(i,j) = item.second;
3639 if (
const auto rhsit = rhs_values->find(elem_dofs[i]);
3640 rhsit != rhs_values->end())
3641 H(i) = rhsit->second;
3658 if ((C.
n() == Cnew.
m()) &&
3659 (Cnew.
n() == elem_dofs.size()))
3668 libmesh_assert_equal_to (C.
n(), elem_dofs.size());
3676 parallel_object_only();
3685#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
3689 this->
comm().
max(has_constraints);
3690 if (!has_constraints)
3695 const unsigned int max_qoi_num =
3699#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
3701 std::vector<Parallel::Request> packed_range_sends;
3715 std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;
3717#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
3718 std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
3721 const unsigned int sys_num = this->
sys_number();
3724 for (
auto & elem :
as_range(
mesh.active_not_local_elements_begin(),
3725 mesh.active_not_local_elements_end()))
3741 for (
unsigned int v=0; v !=
n_vars; ++v)
3743 const unsigned int n_comp = elem->
n_comp(sys_num,v);
3744 for (
unsigned int c=0; c != n_comp; ++c)
3746 const unsigned int id =
3754 for (
unsigned short n = 0; n !=
n_nodes; ++n)
3758 for (
unsigned int v=0; v !=
n_vars; ++v)
3760 const unsigned int n_comp = node.
n_comp(sys_num,v);
3761 for (
unsigned int c=0; c != n_comp; ++c)
3763 const unsigned int id =
3771#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
3772 for (
unsigned short n = 0; n !=
n_nodes; ++n)
3780 std::map<processor_id_type, std::vector<dof_id_type>>
3781 pushed_id_vecs, received_id_vecs;
3782 for (
auto & p : pushed_ids)
3783 pushed_id_vecs[p.first].assign(p.second.begin(), p.second.end());
3785 std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
3786 pushed_keys_vals, received_keys_vals;
3787 std::map<processor_id_type, std::vector<std::vector<Number>>> pushed_rhss, received_rhss;
3788 for (
auto & p : pushed_id_vecs)
3790 auto & keys_vals = pushed_keys_vals[p.first];
3791 keys_vals.reserve(p.second.size());
3793 auto & rhss = pushed_rhss[p.first];
3794 rhss.reserve(p.second.size());
3795 for (
auto & pushed_id : p.second)
3798 keys_vals.emplace_back(row.begin(), row.end());
3800 rhss.push_back(std::vector<Number>(max_qoi_num+1));
3801 std::vector<Number> & rhs = rhss.back();
3802 DofConstraintValueMap::const_iterator rhsit =
3807 for (
unsigned int q = 0; q != max_qoi_num; ++q)
3809 AdjointDofConstraintValues::const_iterator adjoint_map_it =
3816 adjoint_map_it->second;
3818 DofConstraintValueMap::const_iterator adj_rhsit =
3819 constraint_map.find(pushed_id);
3822 (adj_rhsit == constraint_map.end()) ?
3823 0 : adj_rhsit->second;
3828 auto ids_action_functor =
3829 [& received_id_vecs]
3831 const std::vector<dof_id_type> & data)
3833 received_id_vecs[pid] = data;
3837 (this->
comm(), pushed_id_vecs, ids_action_functor);
3839 auto keys_vals_action_functor =
3840 [& received_keys_vals]
3842 const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
3844 received_keys_vals[pid] = data;
3848 (this->
comm(), pushed_keys_vals, keys_vals_action_functor);
3850 auto rhss_action_functor =
3853 const std::vector<std::vector<Number>> & data)
3855 received_rhss[pid] = data;
3859 (this->
comm(), pushed_rhss, rhss_action_functor);
3864#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
3865 std::map<processor_id_type, std::vector<dof_id_type>>
3866 pushed_node_id_vecs, received_node_id_vecs;
3867 for (
auto & p : pushed_node_ids)
3868 pushed_node_id_vecs[p.first].assign(p.second.begin(), p.second.end());
3870 std::map<processor_id_type, std::vector<std::vector<std::pair<dof_id_type,Real>>>>
3871 pushed_node_keys_vals, received_node_keys_vals;
3872 std::map<processor_id_type, std::vector<Point>> pushed_offsets, received_offsets;
3874 for (
auto & p : pushed_node_id_vecs)
3880 std::set<const Node *> nodes_requested;
3882 auto & node_keys_vals = pushed_node_keys_vals[pid];
3883 node_keys_vals.reserve(p.second.size());
3885 auto & offsets = pushed_offsets[pid];
3886 offsets.reserve(p.second.size());
3888 for (
auto & pushed_node_id : p.second)
3892 const std::size_t row_size = row.size();
3893 node_keys_vals.push_back
3894 (std::vector<std::pair<dof_id_type,Real>>());
3895 std::vector<std::pair<dof_id_type,Real>> & this_node_kv =
3896 node_keys_vals.back();
3897 this_node_kv.reserve(row_size);
3898 for (
const auto & j : row)
3900 this_node_kv.emplace_back(j.first->id(), j.second);
3905 if (j.first->processor_id() != pid && dist_mesh)
3906 nodes_requested.insert(j.first);
3920 (pid, &
mesh, nodes_requested.begin(), nodes_requested.end(),
3921 packed_range_sends.back(), range_tag);
3925 auto node_ids_action_functor =
3926 [& received_node_id_vecs]
3928 const std::vector<dof_id_type> & data)
3930 received_node_id_vecs[pid] = data;
3934 (this->
comm(), pushed_node_id_vecs, node_ids_action_functor);
3936 auto node_keys_vals_action_functor =
3937 [& received_node_keys_vals]
3939 const std::vector<std::vector<std::pair<dof_id_type,Real>>> & data)
3941 received_node_keys_vals[pid] = data;
3945 (this->
comm(), pushed_node_keys_vals,
3946 node_keys_vals_action_functor);
3948 auto node_offsets_action_functor =
3949 [& received_offsets]
3951 const std::vector<Point> & data)
3953 received_offsets[pid] = data;
3957 (this->
comm(), pushed_offsets, node_offsets_action_functor);
3962 for (
auto & [pid, pushed_ids_to_me] : received_id_vecs)
3966 const auto & pushed_keys_vals_to_me = received_keys_vals.at(pid);
3967 const auto & pushed_rhss_to_me = received_rhss.at(pid);
3969 libmesh_assert_equal_to (pushed_ids_to_me.size(),
3970 pushed_keys_vals_to_me.size());
3971 libmesh_assert_equal_to (pushed_ids_to_me.size(),
3972 pushed_rhss_to_me.size());
3983 for (
auto & kv : pushed_keys_vals_to_me[i])
3985 libmesh_assert_less(kv.first, this->n_dofs());
3986 row[kv.first] = kv.second;
3989 const Number primal_rhs = pushed_rhss_to_me[i][max_qoi_num];
3994 if (primal_rhs !=
Number(0))
3999 for (
unsigned int q = 0; q != max_qoi_num; ++q)
4001 AdjointDofConstraintValues::iterator adjoint_map_it =
4004 const Number adj_rhs = pushed_rhss_to_me[i][q];
4015 adjoint_map_it->second;
4017 if (adj_rhs !=
Number(0))
4018 constraint_map[constrained] = adj_rhs;
4020 constraint_map.erase(constrained);
4026#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
4028 for (
auto & [pid, pushed_node_ids_to_me] : received_node_id_vecs)
4035 (
Node**)
nullptr, range_tag);
4039 const auto & pushed_node_keys_vals_to_me = received_node_keys_vals.at(pid);
4040 const auto & pushed_offsets_to_me = received_offsets.at(pid);
4042 libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
4043 pushed_node_keys_vals_to_me.size());
4044 libmesh_assert_equal_to (pushed_node_ids_to_me.size(),
4045 pushed_offsets_to_me.size());
4049 dof_id_type constrained_id = pushed_node_ids_to_me[i];
4057 for (
auto & kv : pushed_node_keys_vals_to_me[i])
4061 row[key_node] = kv.second;
4074 typedef std::set<dof_id_type> DoF_RCSet;
4075 DoF_RCSet unexpanded_dofs;
4078 unexpanded_dofs.insert(i.first);
4084#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
4085 typedef std::set<const Node *> Node_RCSet;
4086 Node_RCSet unexpanded_nodes;
4089 unexpanded_nodes.insert(i.first);
4093 bool unexpanded_set_nonempty = !unexpanded_nodes.empty();
4094 this->
comm().
max(unexpanded_set_nonempty);
4096 while (unexpanded_set_nonempty)
4099 parallel_object_only();
4102 Node_RCSet node_request_set;
4105 std::map<processor_id_type, std::vector<dof_id_type>>
4109 std::map<processor_id_type, dof_id_type> node_ids_on_proc;
4112 for (
const auto & i : unexpanded_nodes)
4115 for (
const auto & j : row)
4117 const Node *
const node = j.first;
4124 node_request_set.insert(node);
4130 unexpanded_nodes.clear();
4133 for (
const auto & node : node_request_set)
4136 libmesh_assert_less (node->processor_id(), this->n_processors());
4137 node_ids_on_proc[node->processor_id()]++;
4140 for (
auto pair : node_ids_on_proc)
4141 requested_node_ids[pair.first].reserve(pair.second);
4144 for (
const auto & node : node_request_set)
4145 requested_node_ids[node->processor_id()].push_back(node->id());
4147 typedef std::vector<std::pair<dof_id_type, Real>> row_datum;
4149 auto node_row_gather_functor =
4153 & packed_range_sends,
4156 const std::vector<dof_id_type> & ids,
4157 std::vector<row_datum> & data)
4161 std::set<const Node *> nodes_requested;
4164 const std::size_t query_size = ids.size();
4166 data.resize(query_size);
4167 for (std::size_t i=0; i != query_size; ++i)
4174 std::size_t row_size = row.size();
4175 data[i].reserve(row_size);
4176 for (
const auto & j : row)
4178 const Node * node = j.first;
4179 data[i].emplace_back(node->
id(), j.second);
4185 nodes_requested.insert(node);
4211 (pid, &
mesh, nodes_requested.begin(), nodes_requested.end(),
4212 packed_range_sends.back(), range_tag);
4216 typedef Point node_rhs_datum;
4218 auto node_rhs_gather_functor =
4222 const std::vector<dof_id_type> & ids,
4223 std::vector<node_rhs_datum> & data)
4226 const std::size_t query_size = ids.size();
4228 data.resize(query_size);
4229 for (std::size_t i=0; i != query_size; ++i)
4236 data[i](0) = std::numeric_limits<Real>::quiet_NaN();
4240 auto node_row_action_functor =
4247 const std::vector<dof_id_type> & ids,
4248 const std::vector<row_datum> & data)
4255 (
Node**)
nullptr, range_tag);
4258 const std::size_t query_size = ids.size();
4260 for (std::size_t i=0; i != query_size; ++i)
4266 if (data[i].empty())
4277 for (
auto & pair : data[i])
4279 const Node * key_node =
4282 row[key_node] = pair.second;
4286 unexpanded_nodes.insert(constrained_node);
4291 auto node_rhs_action_functor =
4295 const std::vector<dof_id_type> & ids,
4296 const std::vector<node_rhs_datum> & data)
4299 const std::size_t query_size = ids.size();
4301 for (std::size_t i=0; i != query_size; ++i)
4314 row_datum * node_row_ex =
nullptr;
4316 (this->
comm(), requested_node_ids, node_row_gather_functor,
4317 node_row_action_functor, node_row_ex);
4320 node_rhs_datum * node_rhs_ex =
nullptr;
4322 (this->
comm(), requested_node_ids, node_rhs_gather_functor,
4323 node_rhs_action_functor, node_rhs_ex);
4328 unexpanded_set_nonempty = !unexpanded_nodes.empty();
4329 this->
comm().
max(unexpanded_set_nonempty);
4356 const unsigned int max_qoi_num =
4361 typedef std::set<dof_id_type> RCSet;
4362 RCSet unexpanded_set;
4365 unexpanded_set.insert(i.first);
4367 while (!unexpanded_set.empty())
4368 for (RCSet::iterator i = unexpanded_set.begin();
4369 i != unexpanded_set.end(); )
4372 DofConstraints::iterator
4379 DofConstraintValueMap::iterator rhsit =
4385 std::vector<DofConstraintValueMap::iterator> adjoint_rhs_iterators;
4386 adjoint_rhs_iterators.resize(max_qoi_num);
4389 std::vector<Number> adjoint_constraint_rhs(max_qoi_num, 0.0);
4394 const std::size_t q = adjoint_map.first;
4395 adjoint_rhs_iterators[q] = adjoint_map.second.find(*i);
4397 adjoint_constraint_rhs[q] =
4398 (adjoint_rhs_iterators[q] == adjoint_map.second.end()) ?
4399 0 : adjoint_rhs_iterators[q]->second;
4402 std::vector<dof_id_type> constraints_to_expand;
4404 for (
const auto & item : constraint_row)
4405 if (item.first != *i && this->is_constrained_dof(item.first))
4407 unexpanded_set.insert(item.first);
4408 constraints_to_expand.push_back(item.first);
4411 for (
const auto & expandable : constraints_to_expand)
4413 const Real this_coef = constraint_row[expandable];
4415 DofConstraints::const_iterator
4422 for (
const auto & item : subconstraint_row)
4426 constraint_row[item.first] += item.second * this_coef;
4431 constraint_rhs += subrhsit->second * this_coef;
4436 if (
auto adjoint_subrhsit = adjoint_map.second.find(expandable);
4437 adjoint_subrhsit != adjoint_map.second.end())
4438 adjoint_constraint_rhs[adjoint_map.first] += adjoint_subrhsit->second * this_coef;
4441 constraint_row.erase(expandable);
4446 if (constraint_rhs !=
Number(0))
4453 if (constraint_rhs !=
Number(0))
4454 rhsit->second = constraint_rhs;
4462 const std::size_t q = adjoint_map.first;
4464 if(adjoint_rhs_iterators[q] == adjoint_map.second.end())
4466 if (adjoint_constraint_rhs[q] !=
Number(0))
4467 (adjoint_map.second)[*i] = adjoint_constraint_rhs[q];
4469 adjoint_map.second.erase(*i);
4473 if (adjoint_constraint_rhs[q] !=
Number(0))
4474 adjoint_rhs_iterators[q]->second = adjoint_constraint_rhs[q];
4476 adjoint_map.second.erase(adjoint_rhs_iterators[q]);
4480 if (constraints_to_expand.empty())
4481 i = unexpanded_set.erase(i);
4498#ifdef LIBMESH_ENABLE_CONSTRAINTS
4508 typedef std::set<dof_id_type> RCSet;
4509 RCSet unexpanded_set;
4515 for (
const auto & i : dof_constraints_copy)
4516 unexpanded_set.insert(i.first);
4518 while (!unexpanded_set.empty())
4519 for (RCSet::iterator i = unexpanded_set.begin();
4520 i != unexpanded_set.end(); )
4523 DofConstraints::iterator
4524 pos = dof_constraints_copy.find(*i);
4536 std::vector<dof_id_type> constraints_to_expand;
4538 for (
const auto & item : constraint_row)
4539 if (item.first != *i && this->is_constrained_dof(item.first))
4541 unexpanded_set.insert(item.first);
4542 constraints_to_expand.push_back(item.first);
4545 for (
const auto & expandable : constraints_to_expand)
4547 const Real this_coef = constraint_row[expandable];
4549 DofConstraints::const_iterator
4550 subpos = dof_constraints_copy.find(expandable);
4556 for (
const auto & item : subconstraint_row)
4558 libmesh_error_msg_if(item.first == expandable,
"Constraint loop detected");
4560 constraint_row[item.first] += item.second * this_coef;
4569 constraint_row.erase(expandable);
4588 if (constraints_to_expand.empty())
4589 i = unexpanded_set.erase(i);
4610 parallel_object_only();
4619#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
4623 this->
comm().
max(has_constraints);
4624 if (!has_constraints)
4631#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
4632 std::map<processor_id_type, std::set<dof_id_type>> pushed_node_ids;
4635 std::map<processor_id_type, std::set<dof_id_type>> pushed_ids;
4641 while (constrained >=
_end_df[constrained_proc_id])
4642 constrained_proc_id++;
4647 for (
auto & j : row)
4652 while (constraining >=
_end_df[constraining_proc_id])
4653 constraining_proc_id++;
4656 constraining_proc_id != constrained_proc_id)
4657 pushed_ids[constraining_proc_id].insert(constrained);
4664 std::vector<std::vector<std::pair<dof_id_type, Real>>>>
4665 pushed_keys_vals, pushed_keys_vals_to_me;
4667 std::map<processor_id_type, std::vector<std::pair<dof_id_type, Number>>>
4668 pushed_ids_rhss, pushed_ids_rhss_to_me;
4677 for (
const auto & [pid, pid_ids] : pushed_ids)
4679 const std::size_t ids_size = pid_ids.size();
4680 std::vector<std::vector<std::pair<dof_id_type, Real>>> &
4681 keys_vals = pushed_keys_vals[pid];
4682 std::vector<std::pair<dof_id_type,Number>> &
4683 ids_rhss = pushed_ids_rhss[pid];
4684 keys_vals.resize(ids_size);
4685 ids_rhss.resize(ids_size);
4688 std::set<dof_id_type>::const_iterator it;
4689 for (push_i = 0, it = pid_ids.begin();
4690 it != pid_ids.end(); ++push_i, ++it)
4694 keys_vals[push_i].assign(row.begin(), row.end());
4696 DofConstraintValueMap::const_iterator rhsit =
4698 ids_rhss[push_i].first = constrained;
4699 ids_rhss[push_i].second =
4708 auto ids_rhss_action_functor =
4709 [& pushed_ids_rhss_to_me]
4711 const std::vector<std::pair<dof_id_type, Number>> & data)
4713 pushed_ids_rhss_to_me[pid] = data;
4716 auto keys_vals_action_functor =
4717 [& pushed_keys_vals_to_me]
4719 const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
4721 pushed_keys_vals_to_me[pid] = data;
4725 (this->
comm(), pushed_ids_rhss, ids_rhss_action_functor);
4727 (this->
comm(), pushed_keys_vals, keys_vals_action_functor);
4730 auto receive_dof_constraints =
4732 & pushed_ids_rhss_to_me,
4733 & pushed_keys_vals_to_me]
4736 for (
const auto & [pid, ids_rhss] : pushed_ids_rhss_to_me)
4738 const auto & keys_vals = pushed_keys_vals_to_me[pid];
4740 libmesh_assert_equal_to
4741 (ids_rhss.size(), keys_vals.size());
4753 for (
auto & key_val : keys_vals[i])
4755 libmesh_assert_less(key_val.first, this->n_dofs());
4756 row[key_val.first] = key_val.second;
4758 if (ids_rhss[i].second !=
Number(0))
4768 receive_dof_constraints();
4770#ifdef LIBMESH_ENABLE_NODE_CONSTRAINTS
4774 const Node * constrained = i.first;
4780 for (
auto & j : row)
4782 const Node * constraining = j.first;
4786 pushed_node_ids[constraining->
processor_id()].insert(constrained->
id());
4792 std::vector<std::vector<std::pair<dof_id_type,Real>>>>
4793 pushed_node_keys_vals, pushed_node_keys_vals_to_me;
4794 std::map<processor_id_type, std::vector<std::pair<dof_id_type, Point>>>
4795 pushed_node_ids_offsets, pushed_node_ids_offsets_to_me;
4796 std::map<processor_id_type, std::vector<const Node *>> pushed_node_vecs;
4798 for (
const auto & [pid, pid_ids]: pushed_node_ids)
4800 const std::size_t ids_size = pid_ids.size();
4801 std::vector<std::vector<std::pair<dof_id_type,Real>>> &
4802 keys_vals = pushed_node_keys_vals[pid];
4803 std::vector<std::pair<dof_id_type, Point>> &
4804 ids_offsets = pushed_node_ids_offsets[pid];
4805 keys_vals.resize(ids_size);
4806 ids_offsets.resize(ids_size);
4807 std::set<Node *> nodes;
4810 std::set<dof_id_type>::const_iterator it;
4811 for (push_i = 0, it = pid_ids.begin();
4812 it != pid_ids.end(); ++push_i, ++it)
4817 nodes.insert(constrained);
4820 std::size_t row_size = row.size();
4821 keys_vals[push_i].reserve(row_size);
4822 for (
const auto & j : row)
4824 Node * constraining =
const_cast<Node *
>(j.first);
4826 keys_vals[push_i].emplace_back(constraining->
id(), j.second);
4829 nodes.insert(constraining);
4832 ids_offsets[push_i].first = *it;
4838 auto & pid_nodes = pushed_node_vecs[pid];
4839 pid_nodes.assign(nodes.begin(), nodes.end());
4843 auto node_ids_offsets_action_functor =
4844 [& pushed_node_ids_offsets_to_me]
4846 const std::vector<std::pair<dof_id_type, Point>> & data)
4848 pushed_node_ids_offsets_to_me[pid] = data;
4851 auto node_keys_vals_action_functor =
4852 [& pushed_node_keys_vals_to_me]
4854 const std::vector<std::vector<std::pair<dof_id_type, Real>>> & data)
4856 pushed_node_keys_vals_to_me[pid] = data;
4861 (this->
comm(), pushed_node_ids_offsets, node_ids_offsets_action_functor);
4863 (this->
comm(), pushed_node_keys_vals, node_keys_vals_action_functor);
4869 auto null_node_functor = [](
processor_id_type,
const std::vector<const Node *> &){};
4873 (this->
comm(), pushed_node_vecs, &
mesh, null_node_functor);
4875 for (
const auto & [pid, ids_offsets] : pushed_node_ids_offsets_to_me)
4877 const auto & keys_vals = pushed_node_keys_vals_to_me[pid];
4879 libmesh_assert_equal_to
4880 (ids_offsets.size(), keys_vals.size());
4885 dof_id_type constrained_id = ids_offsets[i].first;
4893 for (
auto & key_val : keys_vals[i])
4896 row[key_node] = key_val.second;
4899 ids_offsets[i].second;
4916 typedef std::map<dof_id_type, std::set<dof_id_type>> DofConstrainsMap;
4917 DofConstrainsMap dof_id_constrains;
4921 for (
const auto & j : row)
4926 while (constraining >=
_end_df[constraining_proc_id])
4927 constraining_proc_id++;
4930 dof_id_constrains[constraining].insert(constrained);
4938 for (
const auto & elem :
as_range(
mesh.active_not_local_elements_begin(),
4939 mesh.active_not_local_elements_end()))
4941 std::vector<dof_id_type> my_dof_indices;
4944 for (
const auto & dof : my_dof_indices)
4946 if (
auto dcmi = dof_id_constrains.find(dof);
4947 dcmi != dof_id_constrains.end())
4949 for (
const auto & constrained : dcmi->second)
4952 while (constrained >=
_end_df[the_constrained_proc_id])
4953 the_constrained_proc_id++;
4956 if (elemproc != the_constrained_proc_id)
4957 pushed_ids[elemproc].insert(constrained);
4963 pushed_ids_rhss.clear();
4964 pushed_ids_rhss_to_me.clear();
4965 pushed_keys_vals.clear();
4966 pushed_keys_vals_to_me.clear();
4972 (this->
comm(), pushed_ids_rhss, ids_rhss_action_functor);
4974 (this->
comm(), pushed_keys_vals, keys_vals_action_functor);
4976 receive_dof_constraints();
4988 (elements_to_couple,
4989 temporary_coupling_matrices,
4992 mesh.active_local_elements_begin(),
4993 mesh.active_local_elements_end(),
4997 std::set<dof_id_type> requested_dofs;
4999 for (
const auto & pr : elements_to_couple)
5001 const Elem * elem = pr.first;
5004 std::vector<dof_id_type> element_dofs;
5007 for (
auto dof : element_dofs)
5008 requested_dofs.insert(dof);
5016 std::set<dof_id_type> & unexpanded_dofs,
5019 typedef std::set<dof_id_type> DoF_RCSet;
5023 const unsigned int max_qoi_num =
5029 bool unexpanded_set_nonempty = !unexpanded_dofs.empty();
5030 this->
comm().
max(unexpanded_set_nonempty);
5032 while (unexpanded_set_nonempty)
5035 parallel_object_only();
5038 DoF_RCSet dof_request_set;
5041 std::map<processor_id_type, std::vector<dof_id_type>>
5045 std::map<processor_id_type, dof_id_type>
5049 for (
const auto & unexpanded_dof : unexpanded_dofs)
5058 dof_request_set.insert(unexpanded_dof);
5066 for (
const auto & j : row)
5074 dof_request_set.insert(constraining_dof);
5080 unexpanded_dofs.clear();
5084 for (
const auto & i : dof_request_set)
5088 dof_ids_on_proc[proc_id]++;
5091 for (
auto & pair : dof_ids_on_proc)
5093 requested_dof_ids[pair.first].reserve(pair.second);
5098 for (
const auto & i : dof_request_set)
5102 requested_dof_ids[proc_id].push_back(i);
5105 typedef std::vector<std::pair<dof_id_type, Real>> row_datum;
5107 typedef std::vector<Number> rhss_datum;
5109 auto row_gather_functor =
5112 const std::vector<dof_id_type> & ids,
5113 std::vector<row_datum> & data)
5116 const std::size_t query_size = ids.size();
5118 data.resize(query_size);
5119 for (std::size_t i=0; i != query_size; ++i)
5125 std::size_t row_size = row.size();
5126 data[i].reserve(row_size);
5127 for (
const auto & j : row)
5129 data[i].push_back(j);
5157 auto rhss_gather_functor =
5161 const std::vector<dof_id_type> & ids,
5162 std::vector<rhss_datum> & data)
5165 const std::size_t query_size = ids.size();
5167 data.resize(query_size);
5168 for (std::size_t i=0; i != query_size; ++i)
5174 DofConstraintValueMap::const_iterator rhsit =
5180 for (
unsigned int q = 0; q != max_qoi_num; ++q)
5182 AdjointDofConstraintValues::const_iterator adjoint_map_it =
5187 data[i].push_back(0);
5192 adjoint_map_it->second;
5194 DofConstraintValueMap::const_iterator adj_rhsit =
5195 constraint_map.find(constrained);
5197 ((adj_rhsit == constraint_map.end()) ?
5198 0 : adj_rhsit->second);
5204 auto row_action_functor =
5208 const std::vector<dof_id_type> & ids,
5209 const std::vector<row_datum> & data)
5212 const std::size_t query_size = ids.size();
5214 for (std::size_t i=0; i != query_size; ++i)
5220 if (data[i].empty())
5229 for (
auto & pair : data[i])
5231 libmesh_assert_less(pair.first, this->n_dofs());
5232 row[pair.first] = pair.second;
5236 unexpanded_dofs.insert(constrained);
5241 auto rhss_action_functor =
5245 const std::vector<dof_id_type> & ids,
5246 const std::vector<rhss_datum> & data)
5249 const std::size_t query_size = ids.size();
5251 for (std::size_t i=0; i != query_size; ++i)
5253 if (!data[i].empty())
5256 if (data[i][0] !=
Number(0))
5261 for (
unsigned int q = 0; q != max_qoi_num; ++q)
5263 AdjointDofConstraintValues::iterator adjoint_map_it =
5267 data[i][q+1] ==
Number(0))
5275 adjoint_map_it->second;
5277 if (data[i][q+1] !=
Number(0))
5278 constraint_map[constrained] =
5281 constraint_map.erase(constrained);
5289 row_datum * row_ex =
nullptr;
5291 (this->
comm(), requested_dof_ids, row_gather_functor,
5292 row_action_functor, row_ex);
5295 rhss_datum * rhs_ex =
nullptr;
5297 (this->
comm(), requested_dof_ids, rhss_gather_functor,
5298 rhss_action_functor, rhs_ex);
5302 unexpanded_set_nonempty = !unexpanded_dofs.empty();
5303 this->
comm().
max(unexpanded_set_nonempty);
5310 parallel_object_only();
5319 this->
comm().
max(has_constraints);
5320 if (!has_constraints)
5324 for (
const auto & j : constraint_row)
5339 add_row(constraint_row);
5360 for (
auto & elem :
mesh.active_local_element_ptr_range())
5362 std::vector<dof_id_type> di;
5364 for (
const auto & dof_id : di)
5368 add_row(pos->second);
5377#ifdef LIBMESH_ENABLE_AMR
5387 libmesh_assert_greater (elem->
p_level(), p);
5388 libmesh_assert_less (s, elem->
n_sides());
5390 const unsigned int sys_num = this->
sys_number();
5394 for (
unsigned int n = 0; n !=
n_nodes; ++n)
5398 const unsigned int low_nc =
5400 const unsigned int high_nc =
5412 for (
unsigned int i = low_nc; i != high_nc; ++i)
5420 const unsigned int total_dofs = node.
n_comp(sys_num, var);
5421 libmesh_assert_greater_equal (total_dofs, high_nc);
5424 for (
unsigned int j = low_nc; j != high_nc; ++j)
5426 const unsigned int i = total_dofs - j - 1;
5437#ifdef LIBMESH_ENABLE_DIRICHLET
5445 unsigned int qoi_index)
5447 unsigned int old_size = cast_int<unsigned int>
5449 for (
unsigned int i = old_size; i <= qoi_index; ++i)
5454 (std::make_unique<DirichletBoundary>(dirichlet_boundary));
5478 unsigned int old_size = cast_int<unsigned int>
5480 for (
unsigned int i = old_size; i <= q; ++i)
5490 auto lam = [&boundary_to_remove](
const auto & bdy)
5491 {
return bdy->b == boundary_to_remove.
b && bdy->variables == boundary_to_remove.
variables;};
5502 unsigned int qoi_index)
5507 auto lam = [&boundary_to_remove](
const auto & bdy)
5508 {
return bdy->b == boundary_to_remove.
b && bdy->variables == boundary_to_remove.
variables;};
5523 const std::set<boundary_id_type>& mesh_side_bcids =
5525 const std::set<boundary_id_type>& mesh_edge_bcids =
5527 const std::set<boundary_id_type>& mesh_node_bcids =
5529 const std::set<boundary_id_type>& dbc_bcids = boundary.
b;
5534 for (
const auto & bc_id : dbc_bcids)
5539 bool found_bcid = (mesh_side_bcids.find(bc_id) != mesh_side_bcids.end() ||
5540 mesh_edge_bcids.find(bc_id) != mesh_edge_bcids.end() ||
5541 mesh_node_bcids.find(bc_id) != mesh_node_bcids.end());
5548 libmesh_error_msg_if(!found_bcid,
5549 "Could not find Dirichlet boundary id " << bc_id <<
" in mesh!");
5556#ifdef LIBMESH_ENABLE_PERIODIC
5577 if (!existing_boundary)
5590 existing_boundary->
merge(boundary);
5597 existing_inverse_boundary->
merge(inverse_boundary);
5601#ifdef LIBMESH_HAVE_RTTI
5605 libmesh_assert(
typeid(inverse_boundary) ==
typeid(*existing_inverse_boundary));
Number exact_value(const Point &p, const Parameters ¶meters, const std::string &, const std::string &)
void ErrorVector unsigned int
void max(const T &r, T &o, Request &req) const
MessageTag get_unique_tag(int tagvalue=MessageTag::invalid_tag) const
void receive_packed_range(const unsigned int dest_processor_id, Context *context, OutputIter out, const T *output_type, const MessageTag &tag=any_tag) const
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
void min(const T &r, T &o, Request &req) const
timpi_pure bool verify(const T &r) const
void send_packed_range(const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, const MessageTag &tag=no_tag, std::size_t approx_buffer_size=1000000) const
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
The BoundaryInfo class contains information relevant to boundary conditions including storing faces,...
void shellface_boundary_ids(const Elem *const elem, const unsigned short int shellface, std::vector< boundary_id_type > &vec_to_fill) const
void edge_boundary_ids(const Elem *const elem, const unsigned short int edge, std::vector< boundary_id_type > &vec_to_fill) const
const std::set< boundary_id_type > & get_edge_boundary_ids() const
void boundary_ids(const Node *node, std::vector< boundary_id_type > &vec_to_fill) const
Fills a user-provided std::vector with the boundary ids associated with Node node.
const std::set< boundary_id_type > & get_boundary_ids() const
const std::set< boundary_id_type > & get_node_boundary_ids() const
Defines a dense matrix for use in Finite Element-type computations.
void vector_mult(DenseVector< T > &dest, const DenseVector< T > &arg) const
Performs the matrix-vector multiplication, dest := (*this) * arg.
void cholesky_solve(const DenseVector< T2 > &b, DenseVector< T2 > &x)
For symmetric positive definite (SPD) matrices.
void resize(const unsigned int new_m, const unsigned int new_n)
Resizes the matrix to the specified size and calls zero().
virtual void right_multiply(const DenseMatrixBase< T > &M2) override final
Performs the operation: (*this) <- (*this) * M3.
void vector_mult_transpose(DenseVector< T > &dest, const DenseVector< T > &arg) const
Performs the matrix-vector multiplication, dest := (*this)^T * arg.
void left_multiply_transpose(const DenseMatrix< T > &A)
Left multiplies by the transpose of the matrix A.
void vector_mult_add(DenseVector< T > &dest, const T factor, const DenseVector< T > &arg) const
Performs the scaled matrix-vector multiplication, dest += factor * (*this) * arg.
virtual void zero() override final
Sets all elements of the matrix to 0 and resets any decomposition flag which may have been previously...
Defines a dense vector for use in Finite Element-type computations.
void resize(const unsigned int n)
Resize the vector.
virtual void zero() override final
Set every element in the vector to 0.
virtual unsigned int size() const override final
const std::vector< dof_id_type > & get_dof_indices() const
Accessor for element dof indices.
const System & get_system() const
Accessor for associated system.
We're using a class instead of a typedef to allow forward declarations and future flexibility.
This class allows one to associate Dirichlet boundary values with a given set of mesh boundary ids an...
std::vector< unsigned int > variables
std::set< boundary_id_type > b
std::unique_ptr< FunctionBase< Number > > f
Real jacobian_tolerance
Defaults to zero, but can be set to a custom small negative value to try and avoid spurious zero (or ...
std::unique_ptr< FunctionBase< Gradient > > g
std::unique_ptr< FEMFunctionBase< Number > > f_fem
std::unique_ptr< FEMFunctionBase< Gradient > > g_fem
Storage for DofConstraint right hand sides for a particular problem.
The constraint matrix storage format.
std::vector< dof_id_type > _end_df
Last DOF index (plus 1) on processor p.
dof_id_type end_dof() const
dof_id_type first_dof() const
This class handles the numbering of degrees of freedom on a mesh.
dof_id_type n_dofs() const
bool _verify_dirichlet_bc_consistency
Flag which determines whether we should do some additional checking of the consistency of the Dirichl...
void remove_adjoint_dirichlet_boundary(const DirichletBoundary &dirichlet_boundary, unsigned int q)
Removes from the system the specified Dirichlet boundary for the adjoint equation defined by Quantity...
void constrain_p_dofs(unsigned int var, const Elem *elem, unsigned int s, unsigned int p)
Constrains degrees of freedom on side s of element elem which correspond to variable number var and t...
unsigned int n_variables() const override
const std::vector< dof_id_type > & get_send_list() const
void allgather_recursive_constraints(MeshBase &)
Gathers constraint equation dependencies from other processors.
GhostingFunctorIterator coupling_functors_begin() const
Beginning of range of coupling functors.
DofConstraintValueMap _primal_constraint_values
void check_dirichlet_bcid_consistency(const MeshBase &mesh, const DirichletBoundary &boundary) const
Check that all the ids in dirichlet_bcids are actually present in the mesh.
void gather_constraints(MeshBase &mesh, std::set< dof_id_type > &unexpanded_dofs, bool look_for_constrainees)
Helper function for querying about constraint equations on other processors.
std::vector< dof_id_type > _send_list
A list containing all the global DOF indices that affect the solution on my processor.
std::unique_ptr< DirichletBoundaries > _dirichlet_boundaries
Data structure containing Dirichlet functions.
void check_for_cyclic_constraints()
Throw an error if we detect any constraint loops, i.e.
void heterogeneously_constrain_element_vector(const DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
Constrains the element vector.
std::vector< std::unique_ptr< DirichletBoundaries > > _adjoint_dirichlet_boundaries
Data structure containing Dirichlet functions.
dof_id_type n_constrained_dofs() const
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
const DirichletBoundaries * get_adjoint_dirichlet_boundaries(unsigned int q) const
void heterogeneously_constrain_element_residual(DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
Constrains the element residual.
void scatter_constraints(MeshBase &)
Sends constraint equations to constraining processors.
void heterogeneously_constrain_element_jacobian_and_residual(DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
Constrains the element Jacobian and residual.
void add_dirichlet_boundary(const DirichletBoundary &dirichlet_boundary)
Adds a copy of the specified Dirichlet boundary to the system.
void process_mesh_constraint_rows(const MeshBase &mesh)
Adds any spline constraints from the Mesh to our DoF constraints.
void add_constraints_to_send_list(const MeshBase &mesh)
Adds entries to the _send_list vector corresponding to DoFs which are dependencies for constraint equ...
GhostingFunctorIterator coupling_functors_end() const
End of range of coupling functors.
bool _need_ghost_constraints
Default false; set to true if the dependencies of constrained ghost DOFs supported by local elements ...
void build_constraint_matrix(DenseMatrix< Number > &C, std::vector< dof_id_type > &elem_dofs, const bool called_recursively=false) const
Build the constraint matrix C associated with the element degree of freedom indices elem_dofs.
void enforce_constraints_on_residual(const NonlinearImplicitSystem &system, NumericVector< Number > *rhs, NumericVector< Number > const *solution, bool homogeneous=true) const
void constrain_element_matrix(DenseMatrix< Number > &matrix, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
Constrains the element matrix.
unsigned int n_vars() const
void print_dof_constraints(std::ostream &os=libMesh::out, bool print_nonlocal=false) const
Prints (from processor 0) all DoF and Node constraints.
void constrain_element_residual(DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, NumericVector< Number > &solution_local) const
Constrains the element residual.
void add_adjoint_dirichlet_boundary(const DirichletBoundary &dirichlet_boundary, unsigned int q)
Adds a copy of the specified Dirichlet boundary to the system, corresponding to the adjoint problem d...
const FEType & variable_type(const unsigned int i) const
std::pair< Real, Real > max_constraint_error(const System &system, NumericVector< Number > *v=nullptr) const
Tests the constrained degrees of freedom on the numeric vector v, which represents a solution defined...
void create_dof_constraints(const MeshBase &, Real time=0)
Rebuilds the raw degree of freedom and DofObject constraints, based on attached DirichletBoundary obj...
unsigned int sys_number() const
unsigned int variable_number(std::string_view var) const
void constrain_nothing(std::vector< dof_id_type > &dofs) const
Does not actually constrain anything, but modifies dofs in the same way as any of the constrain funct...
NodeConstraints _node_constraints
Data structure containing DofObject constraints.
AdjointDofConstraintValues _adjoint_constraint_values
bool is_constrained_dof(const dof_id_type dof) const
void constrain_element_vector(DenseVector< Number > &rhs, std::vector< dof_id_type > &dofs, bool asymmetric_constraint_rows=true) const
Constrains the element vector.
static void merge_ghost_functor_outputs(GhostingFunctor::map_type &elements_to_ghost, CouplingMatricesSet &temporary_coupling_matrices, const GhostingFunctorIterator &gf_begin, const GhostingFunctorIterator &gf_end, const MeshBase::const_element_iterator &elems_begin, const MeshBase::const_element_iterator &elems_end, processor_id_type p)
bool local_index(dof_id_type dof_index) const
const Variable & variable(const unsigned int c) const override
void enforce_constraints_exactly(const System &system, NumericVector< Number > *v=nullptr, bool homogeneous=false) const
Constrains the numeric vector v, which represents a solution defined on the mesh.
void enforce_constraints_on_jacobian(const NonlinearImplicitSystem &system, SparseMatrix< Number > *jac) const
bool has_adjoint_dirichlet_boundaries(unsigned int q) const
dof_id_type n_local_constrained_dofs() const
void check_for_constraint_loops()
std::unique_ptr< PeriodicBoundaries > _periodic_boundaries
Data structure containing periodic boundaries.
void constrain_element_dyad_matrix(DenseVector< Number > &v, DenseVector< Number > &w, std::vector< dof_id_type > &row_dofs, bool asymmetric_constraint_rows=true) const
Constrains a dyadic element matrix B = v w'.
std::set< std::unique_ptr< CouplingMatrix >, Utility::CompareUnderlying > CouplingMatricesSet
bool has_static_condensation() const
Checks whether we have static condensation.
dof_id_type n_local_dofs() const
void add_adjoint_constraint_row(const unsigned int qoi_index, const dof_id_type dof_number, const DofConstraintRow &constraint_row, const Number constraint_rhs, const bool forbid_constraint_overwrite)
Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side ...
bool is_constrained_node(const Node *node) const
void build_constraint_matrix_and_vector(DenseMatrix< Number > &C, DenseVector< Number > &H, std::vector< dof_id_type > &elem_dofs, int qoi_index=-1, const bool called_recursively=false) const
Build the constraint matrix C and the forcing vector H associated with the element degree of freedom ...
void add_constraint_row(const dof_id_type dof_number, const DofConstraintRow &constraint_row, const Number constraint_rhs, const bool forbid_constraint_overwrite)
Adds a copy of the user-defined row to the constraint matrix, using an inhomogeneous right-hand-side ...
void heterogeneously_constrain_element_matrix_and_vector(DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true, int qoi_index=-1) const
Constrains the element matrix and vector.
void add_periodic_boundary(const PeriodicBoundaryBase &periodic_boundary)
Adds a copy of the specified periodic boundary to the system.
void process_constraints(MeshBase &)
Postprocesses any constrained degrees of freedom to be constrained only in terms of unconstrained dof...
void enforce_adjoint_constraints_exactly(NumericVector< Number > &v, unsigned int q) const
Heterogeneously constrains the numeric vector v, which represents an adjoint solution defined on the ...
void remove_dirichlet_boundary(const DirichletBoundary &dirichlet_boundary)
Removes the specified Dirichlet boundary from the system.
std::unique_ptr< SparsityPattern::Build > build_sparsity(const MeshBase &mesh, bool calculate_constrained=false, bool use_condensed_system=false) const
Builds a sparsity pattern for matrices using the current degree-of-freedom numbering and coupling.
bool _error_on_constraint_loop
This flag indicates whether or not we do an opt-mode check for the presence of constraint loops,...
std::string get_local_constraints(bool print_nonlocal=false) const
Gets a string reporting all DoF and Node constraints local to this processor.
void constrain_element_matrix_and_vector(DenseMatrix< Number > &matrix, DenseVector< Number > &rhs, std::vector< dof_id_type > &elem_dofs, bool asymmetric_constraint_rows=true) const
Constrains the element matrix and vector.
DofConstraints _dof_constraints
Data structure containing DOF constraints.
unsigned int n_comp(const unsigned int s, const unsigned int var) const
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
processor_id_type processor_id() const
static constexpr dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
This is the base class from which all geometric element types are derived.
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
const Point & point(const unsigned int i) const
const Node & node_ref(const unsigned int i) const
virtual unsigned int n_nodes() const =0
subdomain_id_type subdomain_id() const
const Node * node_ptr(const unsigned int i) const
virtual bool is_vertex(const unsigned int i) const =0
virtual bool is_node_on_edge(const unsigned int n, const unsigned int e) const =0
virtual unsigned int n_edges() const =0
virtual unsigned int n_sides() const =0
dof_id_type node_id(const unsigned int i) const
unsigned int p_level() const
virtual bool is_edge_on_side(const unsigned int e, const unsigned int s) const =0
NumericVector< Number > * rhs
The system matrix.
static void compute_node_constraints(NodeConstraints &constraints, const Elem *elem)
Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geome...
virtual void edge_reinit(const Elem *elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > *pts=nullptr, const std::vector< Real > *weights=nullptr)=0
Reinitializes all the physical element-dependent data based on the edge of the element elem.
static void compute_periodic_node_constraints(NodeConstraints &constraints, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const Elem *elem)
Computes the node position constraint equation contributions (for meshes with periodic boundary condi...
virtual_for_inffe const std::vector< Real > & get_JxW() const
virtual_for_inffe const std::vector< Point > & get_xyz() const
virtual void reinit(const Elem *elem, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)=0
This is at the core of this class.
const FEMap & get_fe_map() const
This class forms the foundation from which generic finite elements may be derived.
const std::vector< std::vector< OutputShape > > & get_phi() const
const std::vector< std::vector< OutputGradient > > & get_dphi() const
static void dofs_on_side(const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int s, std::vector< unsigned int > &di, const bool add_p_level=true)
Fills the vector di with the local degree of freedom indices associated with side s of element elem A...
static unsigned int n_vec_dim(const MeshBase &mesh, const FEType &fe_type)
static FEContinuity get_continuity(const FEType &fe_type)
Returns the input FEType's FEContinuity based on the underlying FEFamily and potentially the Order,...
static FEFieldType field_type(const FEType &fe_type)
static void compute_periodic_constraints(DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase *point_locator, const unsigned int variable_number, const Elem *elem)
Computes the constraint matrix contributions (for periodic boundary conditions) corresponding to vari...
static unsigned int n_dofs_at_node(const unsigned int dim, const FEType &fe_t, const ElemType t, const unsigned int n)
static void dofs_on_edge(const Elem *const elem, const unsigned int dim, const FEType &fe_t, unsigned int e, std::vector< unsigned int > &di, const bool add_p_level=true)
Fills the vector di with the local degree of freedom indices associated with edge e of element elem A...
static void compute_constraints(DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to var...
This class provides all data required for a physics package (e.g.
void get_side_fe(unsigned int var, FEGenericBase< OutputShape > *&fe) const
Accessor for edge/face (2D/3D) finite element object for variable var for the largest dimension in th...
void get_edge_fe(unsigned int var, FEGenericBase< OutputShape > *&fe) const
Accessor for edge (3D only!) finite element object for variable var.
virtual void pre_fe_reinit(const System &, const Elem *e)
Reinitializes local data vectors/matrices on the current geometric element.
const QBase & get_element_qrule() const
Accessor for element interior quadrature rule for the dimension of the current _elem.
const QBase & get_edge_qrule() const
Accessor for element edge quadrature rule.
void get_element_fe(unsigned int var, FEGenericBase< OutputShape > *&fe) const
Accessor for interior finite element object for variable var for the largest dimension in the mesh.
void set_algebraic_type(const AlgebraicType atype)
Setting which determines whether to initialize algebraic structures (elem_*) on each element and set ...
const QBase & get_side_qrule() const
Accessor for element side quadrature rule for the dimension of the current _elem.
FEMFunctionBase is a base class from which users can derive in order to define "function-like" object...
virtual void init_context(const FEMContext &)
Prepares a context object for use.
virtual Output component(const FEMContext &, unsigned int i, const Point &p, Real time=0.)
void set_jacobian_tolerance(Real tol)
Set the Jacobian tolerance used for determining when the mapping fails.
class FEType hides (possibly multiple) FEFamily and approximation orders, thereby enabling specialize...
FEFamily family
The type of finite element.
Base class for functors that can be evaluated at a point and (optionally) time.
virtual Output component(unsigned int i, const Point &p, Real time=0.)
std::map< const Elem *, const CouplingMatrix *, CompareDofObjectsByPIDAndThenID > map_type
What elements do we care about and what variables do we care about on each element?
SparseMatrix< Number > * matrix
The system matrix.
The IntRange templated class is intended to make it easy to loop over integers which are indices of a...
static std::unique_ptr< LinearSolver< T > > build(const libMesh::Parallel::Communicator &comm_in, const SolverPackage solver_package=libMesh::default_solver_package())
Builds a LinearSolver using the linear solver package specified by solver_package.
This is the MeshBase class.
virtual bool is_serial() const
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
virtual const Node * node_ptr(const dof_id_type i) const =0
unsigned int mesh_dimension() const
virtual dof_id_type n_elem() const =0
virtual const Elem * elem_ptr(const dof_id_type i) const =0
constraint_rows_type & get_constraint_rows()
Constraint rows accessors.
dof_id_type n_constraint_rows() const
Returns how many total constraint rows we have.
std::unique_ptr< PointLocatorBase > sub_point_locator() const
The Node constraint storage format.
A Node is like a Point, but with more information.
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and non-linear solv...
Provides a uniform interface to vector storage schemes for different linear algebra libraries.
virtual void set(const numeric_index_type i, const T value)=0
Sets v(i) = value.
virtual void get(const std::vector< numeric_index_type > &index, T *values) const
Access multiple components at once.
virtual numeric_index_type last_local_index() const =0
ParallelType type() const
virtual void close()=0
Calls the NumericVector's internal assembly routines, ensuring that the values are consistent across ...
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, SolverPackage solver_package=libMesh::default_solver_package(), ParallelType parallel_type=AUTOMATIC)
Builds a NumericVector on the processors in communicator comm using the linear solver package specifi...
virtual void localize(std::vector< T > &v_local) const =0
Creates a copy of the global vector in the local vector v_local.
virtual numeric_index_type size() const =0
virtual bool closed() const
virtual numeric_index_type local_size() const =0
virtual numeric_index_type first_local_index() const =0
processor_id_type processor_id() const
const Parallel::Communicator & comm() const
processor_id_type n_processors() const
We're using a class instead of a typedef to allow forward declarations and future flexibility.
The base class for defining periodic boundaries.
const std::set< unsigned int > & get_variables() const
Get the set of variables for this periodic boundary condition.
boundary_id_type myboundary
The boundary ID of this boundary and its counterpart.
boundary_id_type pairedboundary
void merge(const PeriodicBoundaryBase &pb)
virtual std::unique_ptr< PeriodicBoundaryBase > clone(TransformationType t=FORWARD) const =0
If we want the DofMap to be able to make copies of references and store them in the underlying map,...
A Point defines a location in LIBMESH_DIM dimensional Real space.
unsigned int n_points() const
This class provides single index access to FieldType (i.e.
static std::unique_ptr< SparseMatrix< T > > build(const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package(), const MatrixBuildType matrix_build_type=MatrixBuildType::AUTOMATIC)
Builds a SparseMatrix<T> using the linear solver package specified by solver_package.
virtual void set(const numeric_index_type i, const numeric_index_type j, const T value)=0
Set the element (i,j) to value.
The StoredRange class defines a contiguous, divisible set of objects.
StoredRange< iterator_type, object_type > & reset(const iterator_type &first, const iterator_type &last)
Resets the StoredRange to contain [first,last).
Manages consistently variables, degrees of freedom, and coefficient vectors.
std::unique_ptr< NumericVector< Number > > current_local_solution
All the values I need to compute my contribution to the simulation at hand.
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
const DofMap & get_dof_map() const
const MeshBase & get_mesh() const
This class defines the notion of a variable in the system.
unsigned int first_scalar_number() const
bool active_on_subdomain(subdomain_id_type sid) const
unsigned int number() const
const FEType & type() const
This class defines a vector in LIBMESH_DIM dimensional Real or Complex space.
void pull_parallel_vector_data(const Communicator &comm, const MapToVectors &queries, GatherFunctor &gather_data, const ActionFunctor &act_on_data, const datum *example)
void push_parallel_vector_data(const Communicator &comm, MapToVectors &&data, const ActionFunctor &act_on_data)
Tnew cast_int(Told oldvar)
void push_parallel_packed_range(const Communicator &comm, MapToContainers &&data, Context *context, const ActionFunctor &act_on_data)
const Elem & get(const ElemType type_in)
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
void parallel_for(const Range &range, const Body &body, unsigned int n_threads=libMesh::n_threads())
Execute the provided function object in parallel on the specified range.
std::string enum_to_string(const T e)
The libMesh namespace provides an interface to certain functionality in the library.
std::map< const Node *, Real, std::less< const Node * >, Threads::scalable_allocator< std::pair< const Node *const, Real > > > NodeConstraintRow
A row of the Node constraint mapping.
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Helper function that allows us to treat a homogenous pair as a range.
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
LIBMESH_DEVICE_INLINE bool libmesh_isnan(T x)
std::map< dof_id_type, Real, std::less< dof_id_type >, Threads::scalable_allocator< std::pair< const dof_id_type, Real > > > DofConstraintRow
A row of the Dof constraint matrix.
static constexpr Real TOLERANCE
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
uint8_t processor_id_type
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
A do-nothing class for templated methods that expect output iterator arguments.
const dof_id_type n_nodes