16 #ifndef dealii_affine_constraints_h
17 #define dealii_affine_constraints_h
32 #include <boost/range/iterator_range.hpp>
36 #include <type_traits>
50 template <
typename number>
52 template <
typename number>
83 Distributing(
const Distributing &in);
86 operator=(
const Distributing &in);
91 return global_row < in.global_row;
112 template <
typename number>
121 insert_new_index(
const std::pair<size_type, number> &pair);
125 const std::pair<size_type, number> &pair);
130 const std::pair<size_type, number> *
135 std::vector<std::pair<size_type, number>> data;
137 std::vector<size_type> individual_size;
170 template <
typename number>
171 class GlobalRowsFromLocal
177 GlobalRowsFromLocal();
185 const number constraint_value);
190 print(std::ostream &os);
203 size(
const size_type counter_index)
const;
209 global_row(
const size_type counter_index)
const;
215 global_row(
const size_type counter_index);
223 local_row(
const size_type counter_index)
const;
229 local_row(
const size_type counter_index);
238 const size_type index_in_constraint)
const;
245 constraint_value(
const size_type counter_index,
246 const size_type index_in_constraint)
const;
255 have_indirect_rows()
const;
262 insert_constraint(
const size_type constrained_local_dof);
270 n_constraints()
const;
277 n_inhomogeneities()
const;
286 set_ith_constraint_inhomogeneous(
const size_type i);
300 std::vector<Distributing> total_row_indices;
306 DataCache<number> data_cache;
340 template <
typename number>
353 ScratchData(
const ScratchData &)
365 std::vector<std::pair<size_type, size_type>> new_entries;
370 std::vector<size_type> rows;
375 std::vector<size_type> columns;
380 std::vector<number>
values;
385 std::vector<size_type> block_starts;
390 std::vector<size_type> vector_indices;
395 std::vector<number> vector_values;
400 GlobalRowsFromLocal<number> global_rows;
405 GlobalRowsFromLocal<number> global_columns;
412 namespace AffineConstraintsImplementation
414 template <
typename VectorType>
416 set_zero_all(
const std::vector<types::global_dof_index> &cm,
421 set_zero_all(
const std::vector<types::global_dof_index> &cm,
426 set_zero_all(
const std::vector<types::global_dof_index> &cm,
506 template <
typename number =
double>
584 DEAL_II_DEPRECATED_EARLY_WITH_COMMENT(
585 "Use the constructor with two index set arguments.")
620 const
IndexSet &locally_stored_constraints);
658 template <typename other_number>
681 DEAL_II_DEPRECATED_EARLY_WITH_COMMENT(
682 "Use the
reinit() function with two index
set arguments.")
696 const
IndexSet &locally_stored_constraints);
757 DEAL_II_DEPRECATED_EARLY_WITH_COMMENT("Use
get_view() and
merge() instead.")
816 const number inhomogeneity = 0);
908 const number weight);
918 const std::vector<std::pair<
size_type, number>> &col_weight_pairs);
998 template <typename other_number>
1003 const
bool allow_different_local_lines = false);
1179 const std::vector<std::pair<
size_type, number>> *
1318 template <typename VectorType>
1328 template <typename VectorType>
1330 condense(const VectorType &vec_ghosted, VectorType &output) const;
1344 template <typename VectorType>
1352 template <typename BlockVectorType>
1362 template <typename VectorType>
1421 template <class InVector, class OutVector>
1424 const std::vector<
size_type> &local_dof_indices,
1425 OutVector &global_vector) const;
1474 template <typename VectorType>
1477 const std::vector<
size_type> &local_dof_indices,
1478 VectorType &global_vector,
1479 const
FullMatrix<number> &local_matrix) const;
1500 template <typename VectorType>
1503 const
Vector<number> &local_vector,
1504 const std::vector<
size_type> &local_dof_indices_row,
1505 const std::vector<
size_type> &local_dof_indices_col,
1506 VectorType &global_vector,
1513 template <typename VectorType>
1517 VectorType &global_vector) const;
1551 template <typename ForwardIteratorVec,
1552 typename ForwardIteratorInd,
1553 typename VectorType>
1556 ForwardIteratorVec local_vector_end,
1557 ForwardIteratorInd local_indices_begin,
1558 VectorType &global_vector) const;
1611 template <typename MatrixType>
1614 const std::vector<
size_type> &local_dof_indices,
1615 MatrixType &global_matrix) const;
1644 template <typename MatrixType>
1647 const std::vector<
size_type> &row_indices,
1648 const std::vector<
size_type> &col_indices,
1649 MatrixType &global_matrix) const;
1667 template <typename MatrixType>
1670 const std::vector<
size_type> &row_indices,
1672 const std::vector<
size_type> &column_indices,
1673 MatrixType &global_matrix) const;
1695 template <typename MatrixType, typename VectorType>
1698 const
Vector<number> &local_vector,
1699 const std::vector<
size_type> &local_dof_indices,
1700 MatrixType &global_matrix,
1701 VectorType &global_vector,
1702 bool use_inhomogeneities_for_rhs = false) const;
1759 const std::vector<
size_type> &local_dof_indices,
1761 const
bool keep_constrained_entries = true,
1762 const
Table<2,
bool> &dof_mask =
Table<2,
bool>()) const;
1769 const std::vector<
size_type> &row_indices,
1770 const std::vector<
size_type> &col_indices,
1772 const
bool keep_constrained_entries = true,
1773 const
Table<2,
bool> &dof_mask =
Table<2,
bool>()) const;
1781 const std::vector<
size_type> &row_indices,
1783 const std::vector<
size_type> &col_indices,
1785 const
bool keep_constrained_entries = true,
1786 const
Table<2,
bool> &dof_mask =
Table<2,
bool>()) const;
1807 template <typename ForwardIteratorVec,
1808 typename ForwardIteratorInd,
1809 typename VectorType>
1812 ForwardIteratorInd local_indices_begin,
1813 ForwardIteratorVec local_vector_begin,
1814 ForwardIteratorVec local_vector_end) const;
1837 template <typename VectorType>
1854 using Entries = std::vector<std::pair<size_type, number>>;
1883 const number inhomogeneity = 0.0);
1919 template <
class Archive>
1923 ar &index &entries &inhomogeneity;
1989 const IndexSet &locally_active_dofs,
1990 const MPI_Comm mpi_communicator,
1991 const bool verbose =
false)
const;
2000 const IndexSet &locally_relevant_dofs,
2001 const MPI_Comm mpi_communicator);
2010 "You are attempting an operation on an AffineConstraints object "
2011 "that requires the object to not be 'closed', i.e., for which you "
2012 "must not already have called the close() member function. But the "
2013 "object is already closed, and so the operation can not be "
2022 "You are attempting an operation on an AffineConstraints object "
2023 "that requires the object to be 'closed', i.e., for which you "
2024 "needed to call the close() member function. But the object "
2025 "is not currently closed, and so the operation can not be "
2034 <<
"The specified line " << arg1 <<
" does not exist.");
2045 <<
"The entry for the indices " << arg1 <<
" and " << arg2
2046 <<
" already exists, but the values " << arg3 <<
" (old) and "
2047 << arg4 <<
" (new) differ "
2048 <<
"by " << (arg4 - arg3) <<
'.');
2057 <<
"You tried to constrain DoF " << arg1 <<
" to DoF " << arg2
2058 <<
", but that one is also constrained. This is not allowed!");
2066 <<
"Degree of freedom " << arg1
2067 <<
" is constrained from both object in a merge operation.");
2075 <<
"In the given argument a degree of freedom is constrained "
2076 <<
"to another DoF with number " << arg1
2077 <<
", which however is constrained by this object. This is not"
2086 <<
"The index set given to this constraints object indicates "
2087 <<
"constraints for degree of freedom " << arg1
2088 <<
" should not be stored by this object, but a constraint "
2089 <<
"is being added.");
2099 <<
"The index set given to this constraints object indicates "
2100 <<
"constraints using degree of freedom " << arg2
2101 <<
" should not be stored by this object, but a constraint "
2102 <<
"for degree of freedom " << arg1 <<
" uses it.");
2112 <<
"While distributing the constraint for DoF " << arg1
2113 <<
", it turns out that one of the processors "
2114 <<
"who own the " << arg2 <<
" degrees of freedom that x_"
2115 << arg1 <<
" is constrained against does not know about "
2116 <<
"the constraint on x_" << arg1
2117 <<
". Did you not initialize the AffineConstraints container "
2118 <<
"with the appropriate locally_relevant set so "
2119 <<
"that every processor who owns a DoF that constrains "
2120 <<
"another DoF also knows about this constraint?");
2204 internal::AffineConstraints::ScratchData<number>>
2218 template <
typename MatrixType,
typename VectorType>
2222 const std::vector<size_type> &local_dof_indices,
2223 MatrixType &global_matrix,
2224 VectorType &global_vector,
2225 const bool use_inhomogeneities_for_rhs,
2226 const std::bool_constant<false>)
const;
2232 template <
typename MatrixType,
typename VectorType>
2236 const std::vector<size_type> &local_dof_indices,
2237 MatrixType &global_matrix,
2238 VectorType &global_vector,
2239 const bool use_inhomogeneities_for_rhs,
2240 const std::bool_constant<true>)
const;
2251 internal::AffineConstraints::GlobalRowsFromLocal<number>
2252 &global_rows)
const;
2263 std::vector<size_type> &active_dofs)
const;
2268 template <
typename MatrixScalar,
typename VectorScalar>
2272 const internal::AffineConstraints::GlobalRowsFromLocal<number> &global_rows,
2274 const std::vector<size_type> &local_dof_indices,
2280 template <
typename number>
2287 template <
typename number>
2289 const IndexSet &locally_stored_constraints)
2291 locally_stored_constraints)
2296 template <
typename number>
2299 const IndexSet &locally_stored_constraints)
2306 ExcMessage(
"The set of locally stored constraints needs to be a "
2307 "superset of the locally owned DoFs."));
2317 template <
typename number>
2332 template <
typename number>
2356 lines.emplace_back();
2357 lines.back().index = line_n;
2358 lines.back().inhomogeneity = 0.;
2364 template <
typename number>
2368 const number weight)
2371 Assert(constrained_dof_index != column,
2372 ExcMessage(
"Can't constrain a degree of freedom to itself"));
2377 ExcMessage(
"The current AffineConstraints does not contain the line "
2378 "for the current entry. Call AffineConstraints::add_line "
2379 "before calling this function."));
2392 for (
const auto &p : line_ptr->
entries)
2393 if (p.first == column)
2395 Assert(std::abs(p.second - weight) < 1.e-14,
2397 constrained_dof_index, column, p.second, weight));
2401 line_ptr->
entries.emplace_back(column, weight);
2406 template <
typename number>
2415 ExcMessage(
"call add_line() before calling set_inhomogeneity()"));
2423 template <
typename number>
2424 template <
typename VectorType>
2430 std::vector<size_type> constrained_lines(
lines.size());
2431 for (
unsigned int i = 0; i <
lines.size(); ++i)
2432 constrained_lines[i] =
lines[i].index;
2433 internal::AffineConstraintsImplementation::set_zero_all(constrained_lines,
2437 template <
typename number>
2441 return lines.size();
2444 template <
typename number>
2448 return std::count_if(
lines.begin(),
2451 return (line.entries.size() == 1) &&
2452 (line.entries[0].second == number(1.));
2456 template <
typename number>
2460 return std::count_if(
lines.begin(),
2463 return (line.inhomogeneity != number(0.));
2467 template <
typename number>
2479 template <
typename number>
2497 template <
typename number>
2498 inline const std::vector<std::pair<types::global_dof_index, number>> *
2514 template <
typename number>
2528 template <
typename number>
2543 template <
typename number>
2552 template <
typename number>
2561 template <
typename number>
2570 template <
typename number>
2571 template <
typename VectorType>
2576 VectorType &global_vector)
const
2581 global_vector(index) += value;
2587 global_vector(position.
entries[j].first) +=
2588 value * position.
entries[j].second;
2592 template <
typename number>
2593 template <
typename ForwardIteratorVec,
2594 typename ForwardIteratorInd,
2595 typename VectorType>
2598 ForwardIteratorVec local_vector_begin,
2599 ForwardIteratorVec local_vector_end,
2600 ForwardIteratorInd local_indices_begin,
2601 VectorType &global_vector)
const
2604 for (; local_vector_begin != local_vector_end;
2605 ++local_vector_begin, ++local_indices_begin)
2609 *local_indices_begin,
2617 (*local_vector_begin) * position.
entries[j].second,
2624 template <
typename number>
2625 template <
class InVector,
class OutVector>
2628 const InVector &local_vector,
2629 const std::vector<size_type> &local_dof_indices,
2630 OutVector &global_vector)
const
2632 Assert(local_vector.size() == local_dof_indices.size(),
2636 local_dof_indices.begin(),
2640 template <
typename number>
2641 template <
typename ForwardIteratorVec,
2642 typename ForwardIteratorInd,
2643 typename VectorType>
2646 const VectorType &global_vector,
2647 ForwardIteratorInd local_indices_begin,
2648 ForwardIteratorVec local_vector_begin,
2649 ForwardIteratorVec local_vector_end)
const
2652 for (; local_vector_begin != local_vector_end;
2653 ++local_vector_begin, ++local_indices_begin)
2656 *local_vector_begin = global_vector(*local_indices_begin);
2661 typename VectorType::value_type value = position.
inhomogeneity;
2663 value += (global_vector(position.
entries[j].first) *
2665 *local_vector_begin = value;
2672 template <
typename MatrixType>
2674 template <
typename SparsityPatternType>
2676 template <
typename number>
2700 template <
typename MatrixType>
2701 struct IsBlockMatrix
2709 template <
typename T>
2710 static std::true_type
2717 template <
typename T>
2718 static std::true_type
2725 static std::false_type
2735 static const bool value =
2736 std::is_same_v<decltype(check(std::declval<MatrixType *>())),
2741 template <
typename MatrixType>
2742 const bool IsBlockMatrix<MatrixType>::value;
2750 template <
typename number>
2751 template <
typename other_number>
2757 lines.reserve(other.
lines.size());
2759 for (
const auto l : other.
lines)
2760 lines.emplace_back(
l.index,
2774 template <
typename number>
2775 template <
typename other_number>
2780 const bool allow_different_local_lines)
2782 (void)allow_different_local_lines;
2783 Assert(allow_different_local_lines ||
2786 "local_lines for this and the other objects are not the same "
2787 "although allow_different_local_lines is false."));
2790 const bool object_was_sorted = sorted;
2805 for (
const std::pair<size_type, number> &entry : line.entries)
2814 ((merge_conflict_behavior != right_object_wins) &&
2816 this->is_constrained(entry.first)))
2817 tmp.push_back(entry);
2823 const auto *other_entries =
2827 const number weight = entry.second;
2829 for (
const auto &other_entry : *other_entries)
2830 tmp.emplace_back(other_entry.first,
2831 other_entry.second * weight);
2833 line.inhomogeneity +=
2838 line.entries.swap(tmp);
2841 if (local_lines.size() != 0)
2842 local_lines.add_indices(other_constraints.
local_lines);
2847 std::fill(lines_cache.begin(),
2855 const size_type local_line_no = calculate_line_index(line.index);
2856 if (local_line_no >= lines_cache.size())
2858 lines_cache[local_line_no] = index++;
2862 for (
const auto &line : other_constraints.
lines)
2864 const size_type local_line_no = calculate_line_index(line.index);
2865 if (local_line_no >= lines_cache.size())
2868 lines.emplace_back(line.index,
2870 line.entries.begin(), line.entries.end()),
2871 line.inhomogeneity);
2872 lines_cache[local_line_no] = index++;
2877 lines.emplace_back(line.index,
2879 line.entries.begin(), line.entries.end()),
2880 line.inhomogeneity);
2882 lines_cache[local_line_no] = index++;
2887 switch (merge_conflict_behavior)
2889 case no_conflicts_allowed:
2891 ExcDoFIsConstrainedFromBothObjects(line.index));
2894 case left_object_wins:
2898 case right_object_wins:
2900 lines[lines_cache[local_line_no]] = {
2903 line.entries.end()),
2904 static_cast<number
>(line.inhomogeneity)};
2914 for (
size_type i = 0; i < lines_cache.size(); ++i)
2916 Assert(i == calculate_line_index(lines[lines_cache[i]].index),
2922 if (object_was_sorted ==
true)
2928 template <
typename number>
2929 template <
typename MatrixType>
2933 const std::vector<size_type> &local_dof_indices,
2934 MatrixType &global_matrix)
const
2939 distribute_local_to_global(
2946 std::integral_constant<
2948 internal::AffineConstraints::IsBlockMatrix<MatrixType>::value>());
2953 template <
typename number>
2954 template <
typename MatrixType,
typename VectorType>
2959 const std::vector<size_type> &local_dof_indices,
2960 MatrixType &global_matrix,
2961 VectorType &global_vector,
2962 bool use_inhomogeneities_for_rhs)
const
2966 distribute_local_to_global(
2972 use_inhomogeneities_for_rhs,
2973 std::integral_constant<
2975 internal::AffineConstraints::IsBlockMatrix<MatrixType>::value>());
2980 template <
typename number>
2984 const number inhomogeneity)
2987 , inhomogeneity(inhomogeneity)
IndexSet locally_owned_dofs
size_type n_inhomogeneities() const
types::global_dof_index size_type
bool has_inhomogeneities() const
LineRange get_lines() const
void add_line(const size_type line_n)
const IndexSet & get_locally_owned_indices() const
void add_selected_constraints(const AffineConstraints &constraints_in, const IndexSet &filter)
bool can_store_line(const size_type line_n) const
Threads::ThreadLocalStorage< internal::AffineConstraints::ScratchData< number > > scratch_data
friend class AffineConstraints
void merge(const AffineConstraints< other_number > &other_constraints, const MergeConflictBehavior merge_conflict_behavior=no_conflicts_allowed, const bool allow_different_local_lines=false)
void add_entry(const size_type constrained_dof_index, const size_type column, const number weight)
void make_consistent_in_parallel(const IndexSet &locally_owned_dofs, const IndexSet &locally_relevant_dofs, const MPI_Comm mpi_communicator)
number get_inhomogeneity(const size_type line_n) const
void make_sorted_row_list(const std::vector< size_type > &local_dof_indices, std::vector< size_type > &active_dofs) const
void get_dof_values(const VectorType &global_vector, ForwardIteratorInd local_indices_begin, ForwardIteratorVec local_vector_begin, ForwardIteratorVec local_vector_end) const
void distribute_local_to_global(const InVector &local_vector, const std::vector< size_type > &local_dof_indices, OutVector &global_vector) const
void make_sorted_row_list(const std::vector< size_type > &local_dof_indices, internal::AffineConstraints::GlobalRowsFromLocal< number > &global_rows) const
const IndexSet & get_local_lines() const
void add_entries_local_to_global(const std::vector< size_type > &local_dof_indices, SparsityPatternBase &sparsity_pattern, const bool keep_constrained_entries=true, const Table< 2, bool > &dof_mask=Table< 2, bool >()) const
void shift(const size_type offset)
size_type n_identities() const
std::size_t memory_consumption() const
typename std::vector< ConstraintLine >::const_iterator const_iterator
void set_inhomogeneity(const size_type constrained_dof_index, const number value)
void condense(SparsityPattern &sparsity) const
size_type max_constraint_indirections() const
void distribute(VectorType &vec) const
void resolve_indices(std::vector< types::global_dof_index > &indices) const
std::vector< ConstraintLine > lines
bool is_constrained(const size_type line_n) const
AffineConstraints get_view(const IndexSet &mask) const
IndexSet needed_elements_for_distribute
const std::vector< std::pair< size_type, number > > * get_constraint_entries(const size_type line_n) const
size_type calculate_line_index(const size_type line_n) const
void distribute_local_to_global(const FullMatrix< number > &local_matrix, const Vector< number > &local_vector, const std::vector< size_type > &local_dof_indices, MatrixType &global_matrix, VectorType &global_vector, const bool use_inhomogeneities_for_rhs, const std::bool_constant< true >) const
bool is_inhomogeneously_constrained(const size_type index) const
void copy_from(const AffineConstraints< other_number > &other)
std::vector< size_type > lines_cache
void constrain_dof_to_zero(const size_type constrained_dof)
void add_constraint(const size_type constrained_dof, const ArrayView< const std::pair< size_type, number >> &dependencies, const number inhomogeneity=0)
void distribute_local_to_global(const FullMatrix< number > &local_matrix, const Vector< number > &local_vector, const std::vector< size_type > &local_dof_indices, MatrixType &global_matrix, VectorType &global_vector, const bool use_inhomogeneities_for_rhs, const std::bool_constant< false >) const
bool is_consistent_in_parallel(const std::vector< IndexSet > &locally_owned_dofs, const IndexSet &locally_active_dofs, const MPI_Comm mpi_communicator, const bool verbose=false) const
bool is_identity_constrained(const size_type line_n) const
size_type n_constraints() const
void print(std::ostream &out) const
void write_dot(std::ostream &) const
void set_zero(VectorType &vec) const
void add_lines(const std::vector< bool > &lines)
boost::iterator_range< const_iterator > LineRange
bool are_identity_constrained(const size_type line_n_1, const size_type line_n_2) const
void add_entries(const size_type constrained_dof_index, const std::vector< std::pair< size_type, number >> &col_weight_pairs)
ProductType< VectorScalar, MatrixScalar >::type resolve_vector_entry(const size_type i, const internal::AffineConstraints::GlobalRowsFromLocal< number > &global_rows, const Vector< VectorScalar > &local_vector, const std::vector< size_type > &local_dof_indices, const FullMatrix< MatrixScalar > &local_matrix) const
bool is_subset_of(const IndexSet &other) const
size_type index_within_set(const size_type global_index) const
bool is_element(const size_type index) const
A class that provides a separate storage location on each thread that accesses the object.
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
__global__ void set(Number *val, const Number s, const size_type N)
static ::ExceptionBase & ExcLineInexistant(size_type arg1)
static ::ExceptionBase & ExcIncorrectConstraint(int arg1, int arg2)
static ::ExceptionBase & ExcInternalError()
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
static ::ExceptionBase & ExcColumnNotStoredHere(size_type arg1, size_type arg2)
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
static ::ExceptionBase & ExcDoFConstrainedToConstrainedDoF(int arg1, int arg2)
#define Assert(cond, exc)
static ::ExceptionBase & ExcDoFIsConstrainedToConstrainedDoF(size_type arg1)
static ::ExceptionBase & ExcNotImplemented()
static ::ExceptionBase & ExcDoFIsConstrainedFromBothObjects(size_type arg1)
static ::ExceptionBase & ExcRowNotStoredHere(size_type arg1)
static ::ExceptionBase & ExcMatrixNotClosed()
#define DeclException2(Exception2, type1, type2, outsequence)
#define AssertIndexRange(index, range)
#define DeclExceptionMsg(Exception, defaulttext)
#define DeclException1(Exception1, type1, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
static ::ExceptionBase & ExcMatrixIsClosed()
#define AssertThrow(cond, exc)
static ::ExceptionBase & ExcEntryAlreadyExists(size_type arg1, size_type arg2, number arg3, number arg4)
@ matrix
Contents is actually a matrix.
@ diagonal
Matrix is diagonal.
types::global_dof_index size_type
void swap(MemorySpaceData< T, MemorySpace > &u, MemorySpaceData< T, MemorySpace > &v)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
bool check(const ConstraintKinds kind_in, const unsigned int dim)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
const types::global_dof_index invalid_dof_index
const types::global_dof_index invalid_size_type
unsigned int global_dof_index
void serialize(Archive &ar, const unsigned int)
friend void swap(ConstraintLine &l1, ConstraintLine &l2)
ConstraintLine(const ConstraintLine &other)=default
ConstraintLine(const size_type &index=numbers::invalid_dof_index, const typename AffineConstraints< number >::ConstraintLine::Entries &entries={}, const number inhomogeneity=0.0)
std::vector< std::pair< size_type, number > > Entries
ConstraintLine & operator=(ConstraintLine &&other) noexcept=default
ConstraintLine(ConstraintLine &&other) noexcept=default
std::size_t memory_consumption() const
ConstraintLine & operator=(const ConstraintLine &other)=default
typename internal::ProductTypeImpl< std::decay_t< T >, std::decay_t< U > >::type type
static void add(const typename VectorType::value_type value, const types::global_dof_index i, VectorType &V)
bool operator<(const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)