![]() |
Reference documentation for deal.II version 8.1.0
|
#include <parallel_vector.h>
Public Types | |
typedef Number | value_type |
typedef value_type * | pointer |
typedef const value_type * | const_pointer |
typedef value_type * | iterator |
typedef const value_type * | const_iterator |
typedef value_type & | reference |
typedef const value_type & | const_reference |
typedef types::global_dof_index | size_type |
typedef numbers::NumberTraits< Number >::real_type | real_type |
Public Member Functions | |
1: Basic Object-handling | |
Vector () | |
Vector (const Vector< Number > &in_vector) | |
Vector (const size_type size) | |
Vector (const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator) | |
Vector (const IndexSet &local_range, const MPI_Comm communicator) | |
Vector (const std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > &partitioner) | |
~Vector () | |
void | reinit (const size_type size, const bool fast=false) |
template<typename Number2 > | |
void | reinit (const Vector< Number2 > &in_vector, const bool fast=false) |
void | reinit (const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator) |
void | reinit (const IndexSet &local_range, const MPI_Comm communicator) |
void | reinit (const std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > &partitioner) |
void | swap (Vector< Number > &v) |
Vector< Number > & | operator= (const Vector< Number > &in_vector) |
template<typename Number2 > | |
Vector< Number > & | operator= (const Vector< Number2 > &in_vector) |
void | copy_from (const Vector< Number > &in_vector, const bool call_update_ghost_values=false) |
Vector< Number > & | operator= (const Number s) |
void | compress (::VectorOperation::values operation) |
void | compress () DEAL_II_DEPRECATED |
void | update_ghost_values () const |
void | compress_start (const unsigned int communication_channel=0,::VectorOperation::values operation=VectorOperation::add) |
void | compress_finish (::VectorOperation::values operation) |
void | compress_finish (const bool add_ghost_data=true) DEAL_II_DEPRECATED |
void | update_ghost_values_start (const unsigned int communication_channel=0) const |
void | update_ghost_values_finish () const |
void | zero_out_ghosts () |
bool | has_ghost_elements () const |
bool | all_zero () const |
bool | is_non_negative () const |
template<typename Number2 > | |
bool | operator== (const Vector< Number2 > &v) const |
template<typename Number2 > | |
bool | operator!= (const Vector< Number2 > &v) const |
template<typename Number2 > | |
Number | operator* (const Vector< Number2 > &V) const |
real_type | norm_sqr () const |
Number | mean_value () const |
real_type | l1_norm () const |
real_type | l2_norm () const |
real_type | lp_norm (const real_type p) const |
real_type | linfty_norm () const |
size_type | size () const |
size_type | local_size () const |
std::pair< size_type, size_type > | local_range () const |
bool | in_local_range (const size_type global_index) const |
IndexSet | locally_owned_elements () const |
size_type | n_ghost_entries () const |
const IndexSet & | ghost_elements () const |
bool | is_ghost_entry (const types::global_dof_index global_index) const |
iterator | begin () |
const_iterator | begin () const |
iterator | end () |
const_iterator | end () const |
2: Data-Access | |
Number | operator() (const size_type global_index) const |
Number & | operator() (const size_type global_index) |
Number | operator[] (const size_type global_index) const |
Number & | operator[] (const size_type global_index) |
template<typename OtherNumber > | |
void | extract_subvector_to (const std::vector< size_type > &indices, std::vector< OtherNumber > &values) const |
template<typename ForwardIterator , typename OutputIterator > | |
void | extract_subvector_to (ForwardIterator indices_begin, const ForwardIterator indices_end, OutputIterator values_begin) const |
Number | local_element (const size_type local_index) const |
Number & | local_element (const size_type local_index) |
3: Modification of vectors | |
Vector< Number > & | operator+= (const Vector< Number > &V) |
Vector< Number > & | operator-= (const Vector< Number > &V) |
template<typename OtherNumber > | |
void | add (const std::vector< size_type > &indices, const std::vector< OtherNumber > &values) |
template<typename OtherNumber > | |
void | add (const std::vector< size_type > &indices, const ::Vector< OtherNumber > &values) |
template<typename OtherNumber > | |
void | add (const size_type n_elements, const size_type *indices, const OtherNumber *values) |
void | add (const Number s) |
void | add (const Vector< Number > &V) |
void | add (const Number a, const Vector< Number > &V) |
void | add (const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W) |
void | sadd (const Number s, const Vector< Number > &V) |
void | sadd (const Number s, const Number a, const Vector< Number > &V) |
void | sadd (const Number s, const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W) |
void | sadd (const Number s, const Number a, const Vector< Number > &V, const Number b, const Vector< Number > &W, const Number c, const Vector< Number > &X) |
void | scale (const Number factor) DEAL_II_DEPRECATED |
Vector< Number > & | operator*= (const Number factor) |
Vector< Number > & | operator/= (const Number factor) |
void | scale (const Vector< Number > &scaling_factors) |
template<typename Number2 > | |
void | scale (const Vector< Number2 > &scaling_factors) |
void | equ (const Number a, const Vector< Number > &u) |
template<typename Number2 > | |
void | equ (const Number a, const Vector< Number2 > &u) |
void | equ (const Number a, const Vector< Number > &u, const Number b, const Vector< Number > &v) |
void | equ (const Number a, const Vector< Number > &u, const Number b, const Vector< Number > &v, const Number c, const Vector< Number > &w) |
void | ratio (const Vector< Number > &a, const Vector< Number > &b) |
4: Mixed stuff | |
const MPI_Comm & | get_mpi_communicator () const |
bool | partitioners_are_compatible (const Utilities::MPI::Partitioner &part) const |
void | print (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const bool across=true) const |
std::size_t | memory_consumption () const |
![]() | |
Subscriptor () | |
Subscriptor (const Subscriptor &) | |
virtual | ~Subscriptor () |
Subscriptor & | operator= (const Subscriptor &) |
void | subscribe (const char *identifier=0) const |
void | unsubscribe (const char *identifier=0) const |
unsigned int | n_subscriptions () const |
void | list_subscribers () const |
DeclException3 (ExcInUse, int, char *, std::string &,<< "Object of class "<< arg2<< " is still used by "<< arg1<< " other objects.\n"<< "(Additional information: "<< arg3<< ")\n"<< "Note the entry in the Frequently Asked Questions of "<< "deal.II (linked to from http://www.dealii.org/) for "<< "more information on what this error means.") | |
DeclException2 (ExcNoSubscriber, char *, char *,<< "No subscriber with identifier \""<< arg2<< "\" did subscribe to this object of class "<< arg1) | |
template<class Archive > | |
void | serialize (Archive &ar, const unsigned int version) |
Static Public Attributes | |
static const bool | supports_distributed_data = true |
Private Member Functions | |
bool | all_zero_local () const |
bool | is_non_negative_local () const |
template<typename Number2 > | |
bool | vectors_equal_local (const Vector< Number2 > &v) const |
template<typename Number2 > | |
Number | inner_product_local (const Vector< Number2 > &V) const |
real_type | norm_sqr_local () const |
Number | mean_value_local () const |
real_type | l1_norm_local () const |
real_type | lp_norm_local (const real_type p) const |
real_type | linfty_norm_local () const |
void | clear_mpi_requests () |
void | resize_val (const size_type new_allocated_size) |
Private Attributes | |
std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > | partitioner |
size_type | allocated_size |
Number * | val |
Number * | import_data |
bool | vector_is_ghosted |
VectorView< Number > | vector_view |
std::vector< MPI_Request > | compress_requests |
std::vector< MPI_Request > | update_ghost_values_requests |
Threads::Mutex | mutex |
Friends | |
template<typename Number2 > | |
class | Vector |
template<typename Number2 > | |
class | BlockVector |
Implementation of a parallel vector class. The design of this class is similar to the standard Vector class in deal.II, with the exception that storage is distributed with MPI.
The vector is designed for the following scheme of parallel partitioning:
[my_first_index,my_last_index)
.reinit (locally_owned, ghost_indices, communicator)
, and retained until the partitioning is changed again. This allows for efficient parallel communication of indices. In particular, it stores the communication pattern, rather than having to compute it again for every communication.local_element()
. Locally owned indices are placed first, [0, local_size()), and then all ghost indices follow after them contiguously, [local_size(), local_size()+n_ghost_entries()).Functions related to parallel functionality:
compress()
goes through the data associated with ghost indices and communicates it to the owner process, which can then add/set it to the correct position. This can be used e.g. after having run an assembly routine involving ghosts that fill this vector.update_ghost_values()
function imports the data from the owning processor to the ghost indices in order to provide read access to the data associated with ghosts.This vector can take two different states with respect to ghost elements:
operator = (0.)
), the vector does only allow writing into ghost elements but not reading from ghost elements.true
exactly when ghost elements have been updated and false
otherwise, irrespective of the actual number of ghost entries in the vector layout (for that information, use n_ghost_entries() instead).Definition at line 105 of file parallel_vector.h.
typedef Number parallel::distributed::Vector< Number >::value_type |
Declare standard types used in all containers. These types parallel those in the C++
standard libraries vector<...>
class.
Definition at line 113 of file parallel_vector.h.
parallel::distributed::Vector< Number >::Vector | ( | ) |
Empty constructor.
parallel::distributed::Vector< Number >::Vector | ( | const Vector< Number > & | in_vector | ) |
Copy constructor. Uses the parallel partitioning of in_vector
.
parallel::distributed::Vector< Number >::Vector | ( | const size_type | size | ) |
Constructs a parallel vector of the given global size without any actual parallel distribution.
parallel::distributed::Vector< Number >::Vector | ( | const IndexSet & | local_range, |
const IndexSet & | ghost_indices, | ||
const MPI_Comm | communicator | ||
) |
Constructs a parallel vector. The local range is specified by locally_owned_set
(note that this must be a contiguous interval, multiple intervals are not possible). The IndexSet ghost_indices
specifies ghost indices, i.e., indices which one might need to read data from or accumulate data from. It is allowed that the set of ghost indices also contains the local range, but it does not need to.
This function involves global communication, so it should only be called once for a given layout. Use the constructor with Vector<Number> argument to create additional vectors with the same parallel layout.
parallel::distributed::Vector< Number >::Vector | ( | const IndexSet & | local_range, |
const MPI_Comm | communicator | ||
) |
Same constructor as above but without any ghost indices.
parallel::distributed::Vector< Number >::Vector | ( | const std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > & | partitioner | ) |
Create the vector based on the parallel partitioning described in partitioner
. The input argument is a shared pointer, which store the partitioner data only once and share it between several vectors with the same layout.
parallel::distributed::Vector< Number >::~Vector | ( | ) |
Destructor.
void Vector< Number >::reinit | ( | const size_type | size, |
const bool | fast = false |
||
) |
Sets the global size of the vector to size
without any actual parallel distribution.
Definition at line 74 of file parallel_vector.templates.h.
void Vector< Number >::reinit | ( | const Vector< Number2 > & | in_vector, |
const bool | fast = false |
||
) |
Uses the parallel layout of the input vector in_vector
and allocates memory for this vector. Recommended initialization function when several vectors with the same layout should be created.
If the flag fast
is set to false, the memory will be initialized with zero, otherwise the memory will be untouched (and the user must make sure to fill it with reasonable data before using it).
Definition at line 104 of file parallel_vector.templates.h.
void Vector< Number >::reinit | ( | const IndexSet & | local_range, |
const IndexSet & | ghost_indices, | ||
const MPI_Comm | communicator | ||
) |
Initialize the vector. The local range is specified by locally_owned_set
(note that this must be a contiguous interval, multiple intervals are not possible). The IndexSet ghost_indices
specifies ghost indices, i.e., indices which one might need to read data from or accumulate data from. It is allowed that the set of ghost indices also contains the local range, but it does not need to.
This function involves global communication, so it should only be called once for a given layout. Use the reinit
function with Vector<Number> argument to create additional vectors with the same parallel layout.
Definition at line 147 of file parallel_vector.templates.h.
void Vector< Number >::reinit | ( | const IndexSet & | local_range, |
const MPI_Comm | communicator | ||
) |
Same as above, but without ghost entries.
Definition at line 162 of file parallel_vector.templates.h.
void Vector< Number >::reinit | ( | const std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > & | partitioner | ) |
Initialize the vector given to the parallel partitioning described in partitioner
. The input argument is a shared pointer, which store the partitioner data only once and share it between several vectors with the same layout.
Definition at line 177 of file parallel_vector.templates.h.
Swap the contents of this vector and the other vector v
. One could do this operation with a temporary variable and copying over the data elements, but this function is significantly more efficient since it only swaps the pointers to the data of the two vectors and therefore does not need to allocate temporary storage and move data around.
This function is analog to the the swap
function of all C++ standard containers. Also, there is a global function swap(u,v)
that simply calls u.swap(v)
, again in analogy to standard functions.
This function is virtual in order to allow for derived classes to handle memory separately.
Definition at line 515 of file parallel_vector.templates.h.
Vector<Number>& parallel::distributed::Vector< Number >::operator= | ( | const Vector< Number > & | in_vector | ) |
Assigns the vector to the parallel partitioning of the input vector in_vector
, and copies all the data.
Vector<Number>& parallel::distributed::Vector< Number >::operator= | ( | const Vector< Number2 > & | in_vector | ) |
Assigns the vector to the parallel partitioning of the input vector in_vector
, and copies all the data.
void Vector< Number >::copy_from | ( | const Vector< Number > & | in_vector, |
const bool | call_update_ghost_values = false |
||
) |
This method copies the local range from another vector with the same local range, but possibly different layout of ghost indices.
Definition at line 209 of file parallel_vector.templates.h.
Vector<Number>& parallel::distributed::Vector< Number >::operator= | ( | const Number | s | ) |
Sets all elements of the vector to the scalar s
. If the scalar is zero, also ghost elements are set to zero, otherwise they remain unchanged.
void parallel::distributed::Vector< Number >::compress | ( | ::VectorOperation::values | operation | ) |
This function copies the data that has accumulated in the data buffer for ghost indices to the owning processor. For the meaning of the argument operation
, see the entry on Compressing distributed vectors and matrices in the glossary.
There are two variants for this function. If called with argument VectorOperation::add
adds all the data accumulated in ghost elements to the respective elements on the owning processor and clears the ghost array afterwards. If called with argument VectorOperation::insert
, a set operation is performed. Since setting elements in a vector with ghost elements is ambiguous (as one can set both the element on the ghost site as well as the owning site), this operation makes the assumption that all data is set correctly on the owning processor. Upon call of compress(VectorOperation::insert), all ghost entries are therefore simply zeroed out (using zero_ghost_values()). In debug mode, a check is performed that makes sure that the data set is actually consistent between processors, i.e., whenever a non-zero ghost element is found, it is compared to the value on the owning processor and an exception is thrown if these elements do not agree.
void parallel::distributed::Vector< Number >::compress | ( | ) |
void parallel::distributed::Vector< Number >::update_ghost_values | ( | ) | const |
Fills the data field for ghost indices with the values stored in the respective positions of the owning processor. This function is needed before reading from ghosts. The function is const
even though ghost data is changed. This is needed to allow functions with a const
vector to perform the data exchange without creating temporaries.
After calling this method, write access to ghost elements of the vector is forbidden and an exception is thrown. Only read access to ghost elements is allowed in this state. Note that all subsequent operations on this vector, like global vector addition, etc., will also update the ghost values by a call to this method after the operation. However, global reduction operations like norms or the inner product will always ignore ghost elements in order to avoid counting the ghost data more than once. To allow writing to ghost elements again, call zero_out_ghosts().
void Vector< Number >::compress_start | ( | const unsigned int | communication_channel = 0 , |
::VectorOperation::values | operation = VectorOperation::add |
||
) |
Initiates communication for the compress()
function with non-blocking communication. This function does not wait for the transfer to finish, in order to allow for other computations during the time it takes until all data arrives.
Before the data is actually exchanged, the function must be followed by a call to compress_finish()
.
In case this function is called for more than one vector before compress_finish()
is invoked, it is mandatory to specify a unique communication channel to each such call, in order to avoid several messages with the same ID that will corrupt this operation.
Definition at line 226 of file parallel_vector.templates.h.
void Vector< Number >::compress_finish | ( | ::VectorOperation::values | operation | ) |
For all requests that have been initiated in compress_start, wait for the communication to finish. Once it is finished, add or set the data (depending on the flag operation) to the respective positions in the owning processor, and clear the contents in the ghost data fields. The meaning of this argument is the same as in compress().
This function should be called exactly once per vector after calling compress_start, otherwise the result is undefined. In particular, it is not well-defined to call compress_start on the same vector again before compress_finished has been called. However, there is no warning to prevent this situation.
Must follow a call to the compress_start
function.
Definition at line 320 of file parallel_vector.templates.h.
void parallel::distributed::Vector< Number >::compress_finish | ( | const bool | add_ghost_data = true | ) |
void Vector< Number >::update_ghost_values_start | ( | const unsigned int | communication_channel = 0 | ) | const |
Initiates communication for the update_ghost_values()
function with non-blocking communication. This function does not wait for the transfer to finish, in order to allow for other computations during the time it takes until all data arrives.
Before the data is actually exchanged, the function must be followed by a call to update_ghost_values_finish()
.
In case this function is called for more than one vector before update_ghost_values_finish()
is invoked, it is mandatory to specify a unique communication channel to each such call, in order to avoid several messages with the same ID that will corrupt this operation.
Definition at line 401 of file parallel_vector.templates.h.
void Vector< Number >::update_ghost_values_finish | ( | ) | const |
For all requests that have been started in update_ghost_values_start, wait for the communication to finish.
Must follow a call to the update_ghost_values_start
function before reading data from ghost indices.
Definition at line 489 of file parallel_vector.templates.h.
void parallel::distributed::Vector< Number >::zero_out_ghosts | ( | ) |
This method zeros the entries on ghost dofs, but does not touch locally owned DoFs.
After calling this method, read access to ghost elements of the vector is forbidden and an exception is thrown. Only write access to ghost elements is allowed in this state.
bool parallel::distributed::Vector< Number >::has_ghost_elements | ( | ) | const |
Returns whether the vector currently is in a state where ghost values can be read or not. This is the same functionality as other parallel vectors have. If this method returns false, this only means that read-access to ghost elements is prohibited whereas write access is still possible (to those entries specified as ghosts during initialization), not that there are no ghost elements at all.
bool parallel::distributed::Vector< Number >::all_zero | ( | ) | const |
Return whether the vector contains only elements with value zero. This function is mainly for internal consistency checks and should seldom be used when not in debug mode since it uses quite some time.
bool parallel::distributed::Vector< Number >::is_non_negative | ( | ) | const |
Return true
if the vector has no negative entries, i.e. all entries are zero or positive. This function is used, for example, to check whether refinement indicators are really all positive (or zero).
The function obviously only makes sense if the template argument of this class is a real type. If it is a complex type, then an exception is thrown.
bool parallel::distributed::Vector< Number >::operator== | ( | const Vector< Number2 > & | v | ) | const |
Checks for equality of the two vectors.
bool parallel::distributed::Vector< Number >::operator!= | ( | const Vector< Number2 > & | v | ) | const |
Checks for inequality of the two vectors.
Number parallel::distributed::Vector< Number >::operator* | ( | const Vector< Number2 > & | V | ) | const |
Perform the inner product of two vectors.
real_type parallel::distributed::Vector< Number >::norm_sqr | ( | ) | const |
Computes the square of the l2 norm of the vector (i.e., the sum of the squares of all entries among all processors).
Number parallel::distributed::Vector< Number >::mean_value | ( | ) | const |
Computes the mean value of all the entries in the vector.
real_type parallel::distributed::Vector< Number >::l1_norm | ( | ) | const |
Returns the l1 norm of the vector (i.e., the sum of the absolute values of all entries among all processors).
real_type parallel::distributed::Vector< Number >::l2_norm | ( | ) | const |
Returns the l2 norm of the vector (i.e., square root of the sum of the square of all entries among all processors).
real_type parallel::distributed::Vector< Number >::lp_norm | ( | const real_type | p | ) | const |
Returns the lp norm with real p
of the vector (i.e., the pth root of sum of the pth power of all entries among all processors).
real_type parallel::distributed::Vector< Number >::linfty_norm | ( | ) | const |
Returns the maximum norm of the vector (i.e., maximum absolute value among all entries among all processors).
size_type parallel::distributed::Vector< Number >::size | ( | ) | const |
Returns the global size of the vector, equal to the sum of the number of locally owned indices among all the processors.
size_type parallel::distributed::Vector< Number >::local_size | ( | ) | const |
Returns the local size of the vector, i.e., the number of indices owned locally.
std::pair<size_type, size_type> parallel::distributed::Vector< Number >::local_range | ( | ) | const |
Returns the half-open interval that specifies the locally owned range of the vector. Note that local_size() == local_range().second - local_range().first
.
bool parallel::distributed::Vector< Number >::in_local_range | ( | const size_type | global_index | ) | const |
Returns true if the given global index is in the local range of this processor.
IndexSet parallel::distributed::Vector< Number >::locally_owned_elements | ( | ) | const |
Return an index set that describes which elements of this vector are owned by the current processor. Note that this index set does not include elements this vector may store locally as ghost elements but that are in fact owned by another processor. As a consequence, the index sets returned on different processors if this is a distributed vector will form disjoint sets that add up to the complete index set. Obviously, if a vector is created on only one processor, then the result would satisfy
size_type parallel::distributed::Vector< Number >::n_ghost_entries | ( | ) | const |
Returns the number of ghost elements present on the vector.
const IndexSet& parallel::distributed::Vector< Number >::ghost_elements | ( | ) | const |
Return an index set that describes which elements of this vector are not owned by the current processor but can be written into or read from locally (ghost elements).
bool parallel::distributed::Vector< Number >::is_ghost_entry | ( | const types::global_dof_index | global_index | ) | const |
Returns whether the given global index is a ghost index on the present processor. Returns false for indices that are owned locally and for indices not present at all.
iterator parallel::distributed::Vector< Number >::begin | ( | ) |
Make the Vector
class a bit like the vector<>
class of the C++ standard library by returning iterators to the start and end of the locally owned elements of this vector.
It holds that end() - begin() == local_size().
const_iterator parallel::distributed::Vector< Number >::begin | ( | ) | const |
Return constant iterator to the start of the locally owned elements of the vector.
iterator parallel::distributed::Vector< Number >::end | ( | ) |
Return an iterator pointing to the element past the end of the array of locally owned entries.
const_iterator parallel::distributed::Vector< Number >::end | ( | ) | const |
Return a constant iterator pointing to the element past the end of the array of the locally owned entries.
Number parallel::distributed::Vector< Number >::operator() | ( | const size_type | global_index | ) | const |
Read access to the data in the position corresponding to global_index
. The index must be either in the local range of the vector or be specified as a ghost index at construction.
Performance: O(1)
for locally owned elements that represent a contiguous range and O(log(nranges))
for ghost elements (quite fast, but slower than local_element()).
Number& parallel::distributed::Vector< Number >::operator() | ( | const size_type | global_index | ) |
Read and write access to the data in the position corresponding to global_index
. The index must be either in the local range of the vector or be specified as a ghost index at construction.
Performance: O(1)
for locally owned elements that represent a contiguous range and O(log(nranges))
for ghost elements (quite fast, but slower than local_element()).
Number parallel::distributed::Vector< Number >::operator[] | ( | const size_type | global_index | ) | const |
Read access to the data in the position corresponding to global_index
. The index must be either in the local range of the vector or be specified as a ghost index at construction.
This function does the same thing as operator().
Number& parallel::distributed::Vector< Number >::operator[] | ( | const size_type | global_index | ) |
Read and write access to the data in the position corresponding to global_index
. The index must be either in the local range of the vector or be specified as a ghost index at construction.
This function does the same thing as operator().
void parallel::distributed::Vector< Number >::extract_subvector_to | ( | const std::vector< size_type > & | indices, |
std::vector< OtherNumber > & | values | ||
) | const |
A collective get operation: instead of getting individual elements of a vector, this function allows to get a whole set of elements at once. The indices of the elements to be read are stated in the first argument, the corresponding values are returned in the second.
void parallel::distributed::Vector< Number >::extract_subvector_to | ( | ForwardIterator | indices_begin, |
const ForwardIterator | indices_end, | ||
OutputIterator | values_begin | ||
) | const |
Just as the above, but with pointers. Useful in minimizing copying of data around.
Number parallel::distributed::Vector< Number >::local_element | ( | const size_type | local_index | ) | const |
Read access to the data field specified by local_index
. Locally owned indices can be accessed with indices [0,local_size)
, and ghost indices with indices [local_size,local_size+ n_ghost_entries]
.
Performance: Direct array access (fast).
Number& parallel::distributed::Vector< Number >::local_element | ( | const size_type | local_index | ) |
Read and write access to the data field specified by local_index
. Locally owned indices can be accessed with indices [0,local_size)
, and ghost indices with indices [local_size,local_size+n_ghosts]
.
Performance: Direct array access (fast).
Vector<Number>& parallel::distributed::Vector< Number >::operator+= | ( | const Vector< Number > & | V | ) |
Add the given vector to the present one.
Vector<Number>& parallel::distributed::Vector< Number >::operator-= | ( | const Vector< Number > & | V | ) |
Subtract the given vector from the present one.
void parallel::distributed::Vector< Number >::add | ( | const std::vector< size_type > & | indices, |
const std::vector< OtherNumber > & | values | ||
) |
A collective add operation: This funnction adds a whole set of values stored in values
to the vector components specified by indices
.
void parallel::distributed::Vector< Number >::add | ( | const std::vector< size_type > & | indices, |
const ::Vector< OtherNumber > & | values | ||
) |
This is a second collective add operation. As a difference, this function takes a deal.II vector of values.
void parallel::distributed::Vector< Number >::add | ( | const size_type | n_elements, |
const size_type * | indices, | ||
const OtherNumber * | values | ||
) |
Take an address where n_elements
are stored contiguously and add them into the vector. Handles all cases which are not covered by the other two add()
functions above.
void parallel::distributed::Vector< Number >::add | ( | const Number | s | ) |
Addition of s
to all components. Note that s
is a scalar and not a vector.
void parallel::distributed::Vector< Number >::add | ( | const Vector< Number > & | V | ) |
Simple vector addition, equal to the operator +=
.
void parallel::distributed::Vector< Number >::add | ( | const Number | a, |
const Vector< Number > & | V | ||
) |
Simple addition of a multiple of a vector, i.e. *this += a*V
.
void parallel::distributed::Vector< Number >::add | ( | const Number | a, |
const Vector< Number > & | V, | ||
const Number | b, | ||
const Vector< Number > & | W | ||
) |
Multiple addition of scaled vectors, i.e. *this += a*V+b*W
.
void parallel::distributed::Vector< Number >::sadd | ( | const Number | s, |
const Vector< Number > & | V | ||
) |
Scaling and simple vector addition, i.e. *this = s*(*this)+V
.
void parallel::distributed::Vector< Number >::sadd | ( | const Number | s, |
const Number | a, | ||
const Vector< Number > & | V | ||
) |
Scaling and simple addition, i.e. *this = s*(*this)+a*V
.
void parallel::distributed::Vector< Number >::sadd | ( | const Number | s, |
const Number | a, | ||
const Vector< Number > & | V, | ||
const Number | b, | ||
const Vector< Number > & | W | ||
) |
Scaling and multiple addition.
void parallel::distributed::Vector< Number >::sadd | ( | const Number | s, |
const Number | a, | ||
const Vector< Number > & | V, | ||
const Number | b, | ||
const Vector< Number > & | W, | ||
const Number | c, | ||
const Vector< Number > & | X | ||
) |
Scaling and multiple addition. *this = s*(*this)+a*V + b*W + c*X
.
void parallel::distributed::Vector< Number >::scale | ( | const Number | factor | ) |
Scale each element of the vector by the given factor.
operator *=
and operator /=
instead. Vector<Number>& parallel::distributed::Vector< Number >::operator*= | ( | const Number | factor | ) |
Scale each element of the vector by a constant value.
Vector<Number>& parallel::distributed::Vector< Number >::operator/= | ( | const Number | factor | ) |
Scale each element of the vector by the inverse of the given value.
void parallel::distributed::Vector< Number >::scale | ( | const Vector< Number > & | scaling_factors | ) |
Scale each element of this vector by the corresponding element in the argument. This function is mostly meant to simulate multiplication (and immediate re-assignment) by a diagonal scaling matrix.
void parallel::distributed::Vector< Number >::scale | ( | const Vector< Number2 > & | scaling_factors | ) |
Scale each element of this vector by the corresponding element in the argument. This function is mostly meant to simulate multiplication (and immediate re-assignment) by a diagonal scaling matrix.
void parallel::distributed::Vector< Number >::equ | ( | const Number | a, |
const Vector< Number > & | u | ||
) |
Assignment *this = a*u
.
void parallel::distributed::Vector< Number >::equ | ( | const Number | a, |
const Vector< Number2 > & | u | ||
) |
Assignment *this = a*u
.
void parallel::distributed::Vector< Number >::equ | ( | const Number | a, |
const Vector< Number > & | u, | ||
const Number | b, | ||
const Vector< Number > & | v | ||
) |
Assignment *this = a*u + b*v
.
void parallel::distributed::Vector< Number >::equ | ( | const Number | a, |
const Vector< Number > & | u, | ||
const Number | b, | ||
const Vector< Number > & | v, | ||
const Number | c, | ||
const Vector< Number > & | w | ||
) |
Assignment *this = a*u + b*v + b*w
.
void parallel::distributed::Vector< Number >::ratio | ( | const Vector< Number > & | a, |
const Vector< Number > & | b | ||
) |
Compute the elementwise ratio of the two given vectors, that is let this[i] = a[i]/b[i]
. This is useful for example if you want to compute the cellwise ratio of true to estimated error.
This vector is appropriately scaled to hold the result.
If any of the b[i]
is zero, the result is undefined. No attempt is made to catch such situations.
const MPI_Comm& parallel::distributed::Vector< Number >::get_mpi_communicator | ( | ) | const |
Return a reference to the MPI communicator object in use with this vector.
bool parallel::distributed::Vector< Number >::partitioners_are_compatible | ( | const Utilities::MPI::Partitioner & | part | ) | const |
Checks whether the given partitioner is compatible with the partitioner used for this vector. Two partitioners are compatible if the have the same local size and the same ghost indices. They do not necessarily need to be the same data field. This is a local operation only, i.e., if only some processors decide that the partitioning is not compatible, only these processors will return false
, whereas the other processors will return true
.
void Vector< Number >::print | ( | std::ostream & | out, |
const unsigned int | precision = 3 , |
||
const bool | scientific = true , |
||
const bool | across = true |
||
) | const |
Prints the vector to the output stream out
.
Definition at line 578 of file parallel_vector.templates.h.
std::size_t Vector< Number >::memory_consumption | ( | ) | const |
Returns the memory consumption of this class in bytes.
Definition at line 558 of file parallel_vector.templates.h.
|
private |
Local part of all_zero().
|
private |
Local part of is_non_negative().
|
private |
Local part of operator==.
|
private |
Local part of the inner product of two vectors.
|
private |
Local part of norm_sqr().
|
private |
Local part of mean_value().
|
private |
Local part of l1_norm().
|
private |
Local part of lp_norm().
|
private |
Local part of linfty_norm().
|
private |
A helper function that clears the compress_requests and update_ghost_values_requests field. Used in reinit functions.
Definition at line 34 of file parallel_vector.templates.h.
|
private |
A helper function that is used to resize the val array.
Definition at line 50 of file parallel_vector.templates.h.
Make BlockVector type friends.
Definition at line 1018 of file parallel_vector.h.
|
static |
A variable that indicates whether this vector supports distributed data storage. If true, then this vector also needs an appropriate compress() function that allows communicating recent set or add operations to individual elements to be communicated to other processors.
For the current class, the variable equals true, since it does support parallel data storage.
Definition at line 134 of file parallel_vector.h.
|
private |
Shared pointer to store the parallel partitioning information. This information can be shared between several vectors that have the same partitioning.
Definition at line 940 of file parallel_vector.h.
|
private |
The size that is currently allocated in the val array.
Definition at line 945 of file parallel_vector.h.
|
private |
Pointer to the array of local elements of this vector.
Definition at line 950 of file parallel_vector.h.
|
mutableprivate |
Temporary storage that holds the data that is sent to this processor in compress()
or sent from this processor in update_ghost_values
.
Definition at line 957 of file parallel_vector.h.
|
mutableprivate |
Stores whether the vector currently allows for reading ghost elements or not. Note that this is to ensure consistent ghost data and does not indicate whether the vector actually can store ghost elements. In particular, when assembling a vector we do not allow reading elements, only writing them.
Definition at line 966 of file parallel_vector.h.
|
private |
Provide this class with all functionality of Vector by creating a VectorView object.
Definition at line 972 of file parallel_vector.h.
|
private |
A vector that collects all requests from compress()
operations. This class uses persistent MPI communicators, i.e., the communication channels are stored during successive calls to a given function. This reduces the overhead involved with setting up the MPI machinery, but it does not remove the need for a receive operation to be posted before the data can actually be sent.
Definition at line 983 of file parallel_vector.h.
|
mutableprivate |
A vector that collects all requests from update_ghost_values()
operations. This class uses persistent MPI communicators.
Definition at line 989 of file parallel_vector.h.
|
mutableprivate |
A lock that makes sure that the compress
and update_ghost_values
functions give reasonable results also when used with several threads.
Definition at line 997 of file parallel_vector.h.