16 #ifndef dealii_matrix_free_tools_h
17 #define dealii_matrix_free_tools_h
41 template <
int dim,
typename AdditionalData>
44 AdditionalData & additional_data);
59 typename VectorizedArrayType,
64 VectorType & diagonal_global,
70 VectorizedArrayType> &)> &local_vmult,
71 const unsigned int dof_no = 0,
72 const unsigned int quad_no = 0,
73 const unsigned int first_selected_component = 0);
78 template <
typename CLASS,
84 typename VectorizedArrayType,
89 VectorType & diagonal_global,
95 VectorizedArrayType> &)
const,
96 const CLASS * owning_class,
97 const unsigned int dof_no = 0,
98 const unsigned int quad_no = 0,
99 const unsigned int first_selected_component = 0);
115 typename VectorizedArrayType,
127 VectorizedArrayType> &)> &local_vmult,
128 const unsigned int dof_no = 0,
129 const unsigned int quad_no = 0,
130 const unsigned int first_selected_component = 0);
135 template <
typename CLASS,
141 typename VectorizedArrayType,
153 VectorizedArrayType> &)
const,
154 const CLASS * owning_class,
155 const unsigned int dof_no = 0,
156 const unsigned int quad_no = 0,
157 const unsigned int first_selected_component = 0);
209 std::vector<unsigned int> valid_fe_indices;
211 const auto &fe_collection =
212 matrix_free.get_dof_handler(additional_data.dof_index)
213 .get_fe_collection();
215 for (
unsigned int i = 0; i < fe_collection.size(); ++i)
216 if (fe_collection[i].n_dofs_per_cell() > 0)
217 valid_fe_indices.push_back(i);
231 template <
typename VectorTypeOut,
typename VectorTypeIn>
236 const VectorTypeIn &,
237 const std::pair<unsigned int, unsigned int>)> &cell_operation,
239 const VectorTypeIn & src,
240 const bool zero_dst_vector =
false)
242 const auto ebd_cell_operation = [&](
const auto &
matrix_free,
246 const auto category =
matrix_free.get_cell_range_category(range);
254 matrix_free->template cell_loop<VectorTypeOut, VectorTypeIn>(
255 ebd_cell_operation, dst, src, zero_dst_vector);
265 template <
typename VectorTypeOut,
typename VectorTypeIn>
270 const VectorTypeIn &,
271 const std::pair<unsigned int, unsigned int>)> &cell_operation,
275 const VectorTypeIn &,
276 const std::pair<unsigned int, unsigned int>)> &face_operation,
280 const VectorTypeIn &,
281 const std::pair<unsigned int, unsigned int>,
282 const bool)> &boundary_operation,
284 const VectorTypeIn & src,
285 const bool zero_dst_vector =
false)
287 const auto ebd_cell_operation = [&](
const auto &
matrix_free,
291 const auto category =
matrix_free.get_cell_range_category(range);
299 const auto ebd_internal_or_boundary_face_operation =
304 const auto category =
matrix_free.get_face_range_category(range);
306 const unsigned int type =
320 matrix_free->template loop<VectorTypeOut, VectorTypeIn>(
322 ebd_internal_or_boundary_face_operation,
323 ebd_internal_or_boundary_face_operation,
346 template <
int dim,
typename AdditionalData>
349 AdditionalData & additional_data)
352 const unsigned int level = additional_data.mg_level;
357 additional_data.cell_vectorization_category.assign(
367 std::sort(bids.begin(), bids.end());
370 unsigned int n_bids = bids.size() + 1;
372 for (
unsigned int i = 0; i < GeometryInfo<dim>::faces_per_cell;
373 i++, offset = offset * n_bids)
377 const auto to_category = [&](
const auto &cell) {
378 unsigned int c_num = 0;
379 for (
unsigned int i = 0; i < GeometryInfo<dim>::faces_per_cell; ++i)
381 auto &face = *cell->face(i);
382 if (face.at_boundary() && !cell->has_periodic_neighbor(i))
384 factors[i] * (1 + std::distance(bids.begin(),
385 std::find(bids.begin(),
387 face.boundary_id())));
396 if (cell->is_locally_owned())
398 .cell_vectorization_category[cell->active_cell_index()] =
406 if (cell->is_locally_owned_on_level())
407 additional_data.cell_vectorization_category[cell->index()] =
413 additional_data.hold_all_faces_to_owned_cells =
true;
414 additional_data.cell_vectorization_categories_strict =
true;
415 additional_data.mapping_update_flags_faces_by_cells =
416 additional_data.mapping_update_flags_inner_faces |
417 additional_data.mapping_update_flags_boundary_faces;
422 template <
typename Number>
429 std::vector<unsigned int> row_lid_to_gid;
430 std::vector<unsigned int> row;
431 std::vector<unsigned int> col;
432 std::vector<Number> val;
440 typename VectorizedArrayType>
441 class ComputeDiagonalHelper
444 static const unsigned int n_lanes = VectorizedArrayType::size();
451 VectorizedArrayType> &phi)
456 reinit(
const unsigned int cell)
458 this->phi.reinit(cell);
460 const auto & dof_info = phi.get_dof_info();
461 const unsigned int n_fe_components = dof_info.start_components.back();
462 const unsigned int dofs_per_component = phi.dofs_per_component;
463 const auto & matrix_free = phi.get_matrix_free();
469 const unsigned int first_selected_component =
470 n_fe_components == 1 ? 0 : phi.get_first_selected_component();
472 const unsigned int n_lanes_filled =
475 std::array<const unsigned int *, n_lanes> dof_indices{};
477 for (
unsigned int v = 0; v < n_lanes_filled; ++v)
479 dof_info.dof_indices.data() +
481 .row_starts[(cell * n_lanes + v) * n_fe_components +
482 first_selected_component]
488 c_pools = std::array<internal::LocalCSR<Number>, n_lanes>();
490 for (
unsigned int v = 0; v < n_lanes_filled; ++v)
492 unsigned int index_indicators, next_index_indicators;
496 .row_starts[(cell * n_lanes + v) * n_fe_components +
497 first_selected_component]
499 next_index_indicators =
501 .row_starts[(cell * n_lanes + v) * n_fe_components +
502 first_selected_component + 1]
507 std::vector<std::tuple<unsigned int, unsigned int, Number>>
508 locally_relevant_constrains;
512 if (n_components == 1 || n_fe_components == 1)
514 unsigned int ind_local = 0;
515 for (; index_indicators != next_index_indicators;
516 ++index_indicators, ++ind_local)
518 const std::pair<unsigned short, unsigned short> indicator =
519 dof_info.constraint_indicator[index_indicators];
521 for (
unsigned int j = 0; j < indicator.first;
523 locally_relevant_constrains.emplace_back(
524 ind_local, dof_indices[v][j], 1.0);
526 dof_indices[v] += indicator.first;
528 const Number *data_val =
530 const Number *end_pool =
533 for (; data_val != end_pool; ++data_val, ++dof_indices[v])
534 locally_relevant_constrains.emplace_back(ind_local,
541 for (; ind_local < dofs_per_component;
542 ++dof_indices[v], ++ind_local)
543 locally_relevant_constrains.emplace_back(ind_local,
554 for (
unsigned int comp = 0; comp < n_components; ++comp)
556 unsigned int ind_local = 0;
560 for (; index_indicators != next_index_indicators;
561 ++index_indicators, ++ind_local)
563 const std::pair<unsigned short, unsigned short>
565 dof_info.constraint_indicator[index_indicators];
568 for (
unsigned int j = 0; j < indicator.first;
570 locally_relevant_constrains.emplace_back(
571 comp * dofs_per_component + ind_local,
574 dof_indices[v] += indicator.first;
576 const Number *data_val =
578 const Number *end_pool =
581 for (; data_val != end_pool;
582 ++data_val, ++dof_indices[v])
583 locally_relevant_constrains.emplace_back(
584 comp * dofs_per_component + ind_local,
592 for (; ind_local < dofs_per_component;
593 ++dof_indices[v], ++ind_local)
594 locally_relevant_constrains.emplace_back(
595 comp * dofs_per_component + ind_local,
599 if (comp + 1 < n_components)
601 next_index_indicators =
603 .row_starts[(cell * n_lanes + v) * n_fe_components +
604 first_selected_component + comp + 2]
612 std::sort(locally_relevant_constrains.begin(),
613 locally_relevant_constrains.end(),
614 [](
const auto &a,
const auto &
b) {
615 if (std::get<0>(a) < std::get<0>(b))
617 return (std::get<0>(a) == std::get<0>(b)) &&
618 (std::get<1>(a) < std::get<1>(b));
622 locally_relevant_constrains.erase(
623 unique(locally_relevant_constrains.begin(),
624 locally_relevant_constrains.end(),
625 [](
const auto &a,
const auto &
b) {
626 return (std::get<1>(a) == std::get<1>(b)) &&
627 (std::get<0>(a) == std::get<0>(b));
629 locally_relevant_constrains.end());
632 if (dof_info.hanging_node_constraint_masks.size() > 0 &&
633 dof_info.hanging_node_constraint_masks_comp.size() > 0 &&
635 .hanging_node_constraint_masks_comp[phi.get_active_fe_index()]
636 [first_selected_component])
639 dof_info.hanging_node_constraint_masks[cell * n_lanes + v];
647 if (locally_relevant_constrains_hn_map.find(mask) ==
648 locally_relevant_constrains_hn_map.end())
657 VectorizedArrayType::size()>
659 constraint_mask.fill(
663 constraint_mask[0] =
mask;
666 std::tuple<unsigned int, unsigned int, Number>>
667 locally_relevant_constrains_hn;
669 for (
unsigned int i = 0; i < dofs_per_component; ++i)
671 for (
unsigned int j = 0; j < dofs_per_component;
673 values_dofs[j][0] =
static_cast<Number
>(i == j);
682 phi.get_shape_info(),
687 for (
unsigned int j = 0; j < dofs_per_component;
689 if (1
e-10 < std::abs(values_dofs[j][0]) &&
691 1
e-10 < std::abs(values_dofs[j][0] - 1.0)))
692 locally_relevant_constrains_hn.emplace_back(
693 j, i, values_dofs[j][0]);
697 std::sort(locally_relevant_constrains_hn.begin(),
698 locally_relevant_constrains_hn.end(),
699 [](
const auto &a,
const auto &
b) {
700 if (std::get<0>(a) < std::get<0>(b))
702 return (std::get<0>(a) == std::get<0>(b)) &&
703 (std::get<1>(a) < std::get<1>(b));
707 const unsigned int n_hn_constraints =
708 locally_relevant_constrains_hn.size();
709 locally_relevant_constrains_hn.resize(n_hn_constraints *
712 for (
unsigned int c = 0; c < n_components; ++c)
713 for (
unsigned int i = 0; i < n_hn_constraints; ++i)
714 locally_relevant_constrains_hn[c *
717 std::tuple<unsigned int, unsigned int, Number>{
718 std::get<0>(locally_relevant_constrains_hn[i]) +
719 c * dofs_per_component,
720 std::get<1>(locally_relevant_constrains_hn[i]) +
721 c * dofs_per_component,
722 std::get<2>(locally_relevant_constrains_hn[i])};
725 locally_relevant_constrains_hn_map[
mask] =
726 locally_relevant_constrains_hn;
729 const auto &locally_relevant_constrains_hn =
730 locally_relevant_constrains_hn_map[
mask];
733 std::vector<std::tuple<unsigned int, unsigned int, Number>>
734 locally_relevant_constrains_temp;
736 for (
unsigned int i = 0;
737 i < dofs_per_component * n_components;
740 const auto lower_bound_fu = [](
const auto &a,
742 return std::get<0>(a) <
b;
745 const auto upper_bound_fu = [](
const auto &a,
747 return a < std::get<0>(
b);
751 locally_relevant_constrains_hn.begin(),
752 locally_relevant_constrains_hn.end(),
755 const auto i_end = std::upper_bound(
756 locally_relevant_constrains_hn.begin(),
757 locally_relevant_constrains_hn.end(),
761 if (i_begin == i_end)
766 locally_relevant_constrains.begin(),
767 locally_relevant_constrains.end(),
770 const auto j_end = std::upper_bound(
771 locally_relevant_constrains.begin(),
772 locally_relevant_constrains.end(),
776 for (
auto v = j_begin; v != j_end; ++v)
777 locally_relevant_constrains_temp.emplace_back(*v);
782 for (
auto v0 = i_begin;
v0 != i_end; ++
v0)
785 locally_relevant_constrains.begin(),
786 locally_relevant_constrains.end(),
789 const auto j_end = std::upper_bound(
790 locally_relevant_constrains.begin(),
791 locally_relevant_constrains.end(),
795 for (
auto v1 = j_begin;
v1 != j_end; ++
v1)
796 locally_relevant_constrains_temp.emplace_back(
799 std::get<2>(*
v0) * std::get<2>(*
v1));
804 locally_relevant_constrains =
805 locally_relevant_constrains_temp;
810 std::sort(locally_relevant_constrains.begin(),
811 locally_relevant_constrains.end(),
812 [](
const auto &a,
const auto &
b) {
813 if (std::get<1>(a) < std::get<1>(b))
815 return (std::get<1>(a) == std::get<1>(b)) &&
816 (std::get<0>(a) < std::get<0>(b));
820 auto &c_pool = c_pools[v];
822 if (locally_relevant_constrains.size() > 0)
823 c_pool.row_lid_to_gid.emplace_back(
824 std::get<1>(locally_relevant_constrains.front()));
825 for (
const auto &j : locally_relevant_constrains)
827 if (c_pool.row_lid_to_gid.back() != std::get<1>(j))
829 c_pool.row_lid_to_gid.push_back(std::get<1>(j));
830 c_pool.row.push_back(c_pool.val.size());
833 c_pool.col.emplace_back(std::get<0>(j));
834 c_pool.val.emplace_back(std::get<2>(j));
837 if (c_pool.val.size() > 0)
838 c_pool.row.push_back(c_pool.val.size());
865 for (
unsigned int v = 0; v < n_lanes_filled; ++v)
866 diagonals_local_constrained[v].assign(
867 c_pools[v].row_lid_to_gid.size() *
868 (n_fe_components == 1 ? n_components : 1),
873 prepare_basis_vector(
const unsigned int i)
880 for (
unsigned int j = 0; j < phi.dofs_per_cell; ++j)
881 phi.begin_dof_values()[j] =
static_cast<Number
>(i == j);
890 const unsigned int n_fe_components =
891 phi.get_dof_info().start_components.back();
892 const unsigned int comp =
893 n_fe_components == 1 ? i / phi.dofs_per_component : 0;
894 const unsigned int i_comp =
895 n_fe_components == 1 ? (i % phi.dofs_per_component) : i;
899 for (
unsigned int v = 0;
900 v < phi.get_matrix_free().n_active_entries_per_cell_batch(
901 phi.get_current_cell_index());
904 const auto &c_pool = c_pools[v];
906 for (
unsigned int j = 0; j < c_pool.row.size() - 1; ++j)
910 const auto scale_iterator =
912 c_pool.col.begin() + c_pool.row[j + 1],
916 if (scale_iterator == c_pool.col.begin() + c_pool.row[j + 1])
920 if (*scale_iterator != i_comp)
925 for (
unsigned int k = c_pool.row[j]; k < c_pool.row[j + 1]; ++k)
926 temp += c_pool.val[k] *
927 phi.begin_dof_values()[comp * phi.dofs_per_component +
931 diagonals_local_constrained
932 [v][j + comp * c_pools[v].row_lid_to_gid.size()] +=
934 c_pool.val[std::distance(c_pool.col.begin(), scale_iterator)];
939 template <
typename VectorType>
941 distribute_local_to_global(
942 std::array<VectorType *, n_components> &diagonal_global)
945 const unsigned int n_fe_components =
946 phi.get_dof_info().start_components.back();
948 for (
unsigned int v = 0;
949 v < phi.get_matrix_free().n_active_entries_per_cell_batch(
950 phi.get_current_cell_index());
955 for (
unsigned int j = 0; j < c_pools[v].row.size() - 1; ++j)
956 for (
unsigned int comp = 0;
957 comp < (n_fe_components == 1 ?
958 static_cast<unsigned int>(n_components) :
962 *diagonal_global[n_fe_components == 1 ? comp : 0],
963 c_pools[v].row_lid_to_gid[j],
964 diagonals_local_constrained
965 [v][j + comp * c_pools[v].row_lid_to_gid.size()]);
974 VectorizedArrayType> φ
978 std::array<internal::LocalCSR<Number>, n_lanes> c_pools;
983 std::array<std::vector<Number>, n_lanes> diagonals_local_constrained;
987 std::vector<std::tuple<unsigned int, unsigned int, Number>>>
988 locally_relevant_constrains_hn_map;
998 typename VectorizedArrayType,
1003 VectorType & diagonal_global,
1009 VectorizedArrayType> &)> &local_vmult,
1010 const unsigned int dof_no,
1011 const unsigned int quad_no,
1012 const unsigned int first_selected_component)
1016 std::array<typename ::internal::BlockVectorSelector<
1020 diagonal_global_components;
1022 for (
unsigned int d = 0;
d < n_components; ++
d)
1023 diagonal_global_components[
d] = ::
internal::
1025 get_vector_component(diagonal_global,
d + first_selected_component);
1027 const auto &dof_info = matrix_free.
get_dof_info(dof_no);
1029 if (dof_info.start_components.back() == 1)
1030 for (
unsigned int comp = 0; comp < n_components; ++comp)
1032 Assert(diagonal_global_components[comp] !=
nullptr,
1033 ExcMessage(
"The finite element underlying this FEEvaluation "
1034 "object is scalar, but you requested " +
1036 " components via the template argument in "
1037 "FEEvaluation. In that case, you must pass an "
1038 "std::vector<VectorType> or a BlockVector to " +
1039 "read_dof_values and distribute_local_to_global."));
1041 *diagonal_global_components[comp], matrix_free, dof_info);
1046 *diagonal_global_components[0], matrix_free, dof_info);
1049 matrix_free.template cell_loop<VectorType, int>(
1053 const std::pair<unsigned int, unsigned int> &range)
mutable {
1059 VectorizedArrayType>
1060 phi(matrix_free, range, dof_no, quad_no, first_selected_component);
1062 internal::ComputeDiagonalHelper<dim,
1067 VectorizedArrayType>
1070 for (
unsigned int cell = range.first; cell < range.second; ++cell)
1072 helper.reinit(cell);
1074 for (
unsigned int i = 0; i < phi.dofs_per_cell; ++i)
1076 helper.prepare_basis_vector(i);
1081 helper.distribute_local_to_global(diagonal_global_components);
1089 template <
typename CLASS,
1095 typename VectorizedArrayType,
1096 typename VectorType>
1100 VectorType & diagonal_global,
1106 VectorizedArrayType> &)
const,
1107 const CLASS * owning_class,
1108 const unsigned int dof_no,
1109 const unsigned int quad_no,
1110 const unsigned int first_selected_component)
1117 VectorizedArrayType,
1121 [&](
auto &feeval) { (owning_class->*cell_operation)(feeval); },
1124 first_selected_component);
1133 template <
typename MatrixType,
1135 std::enable_if_t<std::is_same<
1136 typename std::remove_const<
typename std::remove_reference<
1137 typename MatrixType::value_type>::type>::type,
1138 typename std::remove_const<
typename std::remove_reference<
1139 Number>::type>::type>::value> * =
nullptr>
1141 create_new_affine_constraints_if_needed(
1154 template <
typename MatrixType,
1156 std::enable_if_t<!std::is_same<
1157 typename std::remove_const<
typename std::remove_reference<
1158 typename MatrixType::value_type>::type>::type,
1159 typename std::remove_const<
typename std::remove_reference<
1160 Number>::type>::type>::value> * =
nullptr>
1162 create_new_affine_constraints_if_needed(
1169 std::make_unique<AffineConstraints<typename MatrixType::value_type>>();
1170 new_constraints->
copy_from(constraints);
1172 return *new_constraints;
1181 typename VectorizedArrayType,
1182 typename MatrixType>
1193 VectorizedArrayType> &)> &local_vmult,
1194 const unsigned int dof_no,
1195 const unsigned int quad_no,
1196 const unsigned int first_selected_component)
1198 std::unique_ptr<AffineConstraints<typename MatrixType::value_type>>
1199 constraints_for_matrix;
1201 internal::create_new_affine_constraints_if_needed(
matrix,
1203 constraints_for_matrix);
1205 matrix_free.template cell_loop<MatrixType, MatrixType>(
1206 [&](
const auto &,
auto &dst,
const auto &,
const auto range) {
1212 VectorizedArrayType>
1214 matrix_free, range, dof_no, quad_no, first_selected_component);
1216 const unsigned int dofs_per_cell = integrator.dofs_per_cell;
1218 std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
1219 std::vector<types::global_dof_index> dof_indices_mf(dofs_per_cell);
1221 std::array<FullMatrix<typename MatrixType::value_type>,
1222 VectorizedArrayType::size()>
1225 std::fill_n(matrices.begin(),
1226 VectorizedArrayType::size(),
1230 const auto lexicographic_numbering =
1234 first_selected_component,
1235 integrator.get_active_fe_index(),
1236 integrator.get_active_quadrature_index())
1237 .lexicographic_numbering;
1239 for (
auto cell = range.first; cell < range.second; ++cell)
1241 integrator.reinit(cell);
1243 const unsigned int n_filled_lanes =
1246 for (
unsigned int v = 0; v < n_filled_lanes; ++v)
1249 for (
unsigned int j = 0; j < dofs_per_cell; ++j)
1251 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1252 integrator.begin_dof_values()[i] =
1253 static_cast<Number
>(i == j);
1255 local_vmult(integrator);
1257 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1258 for (
unsigned int v = 0; v < n_filled_lanes; ++v)
1259 matrices[v](i, j) = integrator.begin_dof_values()[i][v];
1262 for (
unsigned int v = 0; v < n_filled_lanes; ++v)
1268 cell_v->get_mg_dof_indices(dof_indices);
1270 cell_v->get_dof_indices(dof_indices);
1272 for (
unsigned int j = 0; j < dof_indices.size(); ++j)
1273 dof_indices_mf[j] = dof_indices[lexicographic_numbering[j]];
1287 template <
typename CLASS,
1293 typename VectorizedArrayType,
1294 typename MatrixType>
1305 VectorizedArrayType> &)
const,
1306 const CLASS * owning_class,
1307 const unsigned int dof_no,
1308 const unsigned int quad_no,
1309 const unsigned int first_selected_component)
1316 VectorizedArrayType,
1321 [&](
auto &feeval) { (owning_class->*cell_operation)(feeval); },
1324 first_selected_component);
void distribute_local_to_global(const InVector &local_vector, const std::vector< size_type > &local_dof_indices, OutVector &global_vector) const
void copy_from(const AffineConstraints< other_number > &other)
unsigned int n_active_entries_per_cell_batch(const unsigned int cell_batch_index) const
unsigned int get_mg_level() const
const Number * constraint_pool_begin(const unsigned int pool_index) const
const internal::MatrixFreeFunctions::ShapeInfo< VectorizedArrayType > & get_shape_info(const unsigned int dof_handler_index_component=0, const unsigned int quad_index=0, const unsigned int fe_base_element=0, const unsigned int hp_active_fe_index=0, const unsigned int hp_active_quad_index=0) const
const internal::MatrixFreeFunctions::DoFInfo & get_dof_info(const unsigned int dof_handler_index_component=0) const
const Number * constraint_pool_end(const unsigned int pool_index) const
DoFHandler< dim >::cell_iterator get_cell_iterator(const unsigned int cell_batch_index, const unsigned int lane_index, const unsigned int dof_handler_index=0) const
virtual std::vector< types::boundary_id > get_boundary_ids() const
cell_iterator begin(const unsigned int level=0) const
unsigned int n_active_cells() const
cell_iterator end() const
active_cell_iterator begin_active(const unsigned int level=0) const
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcMessage(std::string arg1)
@ matrix
Contents is actually a matrix.
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
Iterator lower_bound(Iterator first, Iterator last, const T &val)
std::uint8_t compressed_constraint_kind
constexpr compressed_constraint_kind unconstrained_compressed_constraint_kind
void vector_access_add(VectorType &vec, const unsigned int entry, const typename VectorType::value_type &val)
void check_vector_compatibility(const VectorType &vec, const MatrixFree< dim, Number, VectorizedArrayType > &matrix_free, const internal::MatrixFreeFunctions::DoFInfo &dof_info)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
static const unsigned int invalid_unsigned_int
auto apply(F &&fn, Tuple &&t) -> decltype(apply_impl(std::forward< F >(fn), std::forward< Tuple >(t), std::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >()))
const ::Triangulation< dim, spacedim > & tria