* Exception
*/
DeclException3 (ExcAccessToNonLocalElement,
- int, int, int,
+ size_type, size_type, size_type,
<< "You tried to access element " << arg1
- << " of a distributed vector, but only elements "
+ << " of a distributed vector, but it is not stored on "
+ << "the current processor. Note: the elements stored "
+ << "on the current processor are within the range "
<< arg2 << " through " << arg3
- << " are stored locally and can be accessed.");
+ << " but Trilinos vectors need not store contiguous "
+ << "ranges on each processor, and not every element in "
+ << "this range may in fact be stored locally.");
private:
/**
* that is stored locally. If
* this is a sequential vector,
* then the result will be the
- * pair (0,N), otherwise it will
- * be a pair (i,i+n), where
- * <tt>n=local_size()</tt>.
+ * pair <code>(0,N)</code>, otherwise it will
+ * be a pair <code>(i,i+n)</code>, where
+ * <code>n=local_size()</code> and <code>i</code> is the first
+ * element of the vector stored on this processor, corresponding
+ * to the half open interval $[i,i+n)$
+ *
+ * @note The description above is true most of the time, but
+ * not always. In particular, Trilinos vectors need not store
+ * contiguous ranges of elements such as $[i,i+n)$. Rather, it
+ * can store vectors where the elements are distributed in
+ * an arbitrary way across all processors and each processor
+ * simply stores a particular subset, not necessarily contiguous.
+ * In this case, this function clearly makes no sense since it
+ * could, at best, return a range that includes all elements
+ * that are stored locally. Thus, the function only succeeds
+ * if the locally stored range is indeed contiguous. It will
+ * trigger an assertion if the local portion of the vector
+ * is not contiguous.
*/
- std::pair<unsigned int, unsigned int> local_range () const;
+ std::pair<size_type, size_type> local_range () const;
/**
* Return whether @p index is in
* the local range or not, see
* also local_range().
+ *
+ * @note The same limitation for the applicability of this
+ * function applies as listed in the documentation of local_range().
*/
- bool in_local_range (const unsigned int index) const;
+ bool in_local_range (const size_type index) const;
/**
* Return if the vector contains ghost
inline
- std::pair<unsigned int, unsigned int>
+ std::pair<VectorBase::size_type, VectorBase::size_type>
VectorBase::local_range () const
{
- int begin, end;
+ TrilinosWrappers::types::int_type begin, end;
+#ifndef DEAL_II_USE_LARGE_INDEX_TYPE
begin = vector->Map().MinMyGID();
end = vector->Map().MaxMyGID()+1;
++<<<<<<< .working
+#else
+ begin = vector->Map().MinMyGID64();
+ end = vector->Map().MaxMyGID64()+1;
+#endif
++=======
+
+ Assert (end-begin == vector->Map().NumMyElements(),
+ ExcMessage ("This function only makes sense if the elements that this "
+ "vector stores on the current processor form a contiguous range. "
+ "This does not appear to be the case for the current vector."));
+
++>>>>>>> .merge-right.r29088
return std::make_pair (begin, end);
}