
Public Types | |
| typedef Number | value_type |
Public Member Functions | |
1: Basic Object-handling | |
| Vector () | |
| Vector (const Vector< Number > &in_vector) | |
| Vector (const unsigned int size) | |
| Vector (const IndexSet &local_range, const IndexSet &ghost_indices, const MPI_Comm communicator) | |
| Vector (const std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > &partitioner) | |
| ~Vector () | |
| void | reinit (const unsigned int 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 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 (const bool add_ghost_data=true) |
| void | update_ghost_values () const |
| void | compress_start (const unsigned int communication_channel=0) |
| void | compress_finish (const bool add_ghost_data=true) |
| void | update_ghost_values_start (const unsigned int communication_channel=0) const |
| void | update_ghost_values_finish () const |
| void | zero_out_ghosts () |
| 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 |
| types::global_dof_index | size () const |
| unsigned int | local_size () const |
| std::pair < types::global_dof_index, types::global_dof_index > | local_range () const |
| bool | in_local_range (const types::global_dof_index global_index) const |
| unsigned int | n_ghost_entries () 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 types::global_dof_index global_index) const |
| Number & | operator() (const types::global_dof_index global_index) |
| Number | operator[] (const types::global_dof_index global_index) const |
| Number & | operator[] (const types::global_dof_index global_index) |
| Number | local_element (const unsigned int local_index) const |
| Number & | local_element (const unsigned int 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< unsigned int > &indices, const std::vector< OtherNumber > &values) |
| template<typename OtherNumber > | |
| void | add (const std::vector< unsigned int > &indices, const ::Vector< OtherNumber > &values) |
| template<typename OtherNumber > | |
| void | add (const unsigned int n_elements, const unsigned int *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) |
| 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 | |
| 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 |
Private Member Functions | |
| void | clear_mpi_requests () |
| void | resize_val (const unsigned int new_allocated_size) |
Private Attributes | |
| std_cxx1x::shared_ptr< const Utilities::MPI::Partitioner > | partitioner |
| unsigned int | allocated_size |
| Number * | val |
| Number * | import_data |
| VectorView< Number > | vector_view |
| Threads::ThreadMutex | mutex |
Friends | |
| class | Vector |
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_indices()).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.Definition at line 84 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 93 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 unsigned int | 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 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 parallel::distributed::Vector< Number >::reinit | ( | const unsigned int | size, |
| const bool | fast = false |
||
| ) |
Sets the global size of the vector to size without any actual parallel distribution.
| void parallel::distributed::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).
| void parallel::distributed::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.
| void parallel::distributed::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.
| void parallel::distributed::Vector< Number >::swap | ( | Vector< Number > & | v | ) |
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.
Referenced by Vector< Number >::swap().
| 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 parallel::distributed::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.
| 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 | ( | const bool | add_ghost_data = true | ) |
This function copies the data that has accumulated in the data buffer for ghost indices to the owning processor. If the optional argument add_ghost_data is set to true, the data is added into the respective positions of the owning processor, otherwise the new data overwrites the old content in the host vector. In that case, data coming from different processor to the same target entry should be identical. However, no checking is performed, so it is the user's responsibility to ensure consistency of data.
For the meaning of this argument, see the entry on Compressing distributed vectors and matrices in the glossary.
| 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.
| void parallel::distributed::Vector< Number >::compress_start | ( | const unsigned int | communication_channel = 0 | ) |
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.
| void parallel::distributed::Vector< Number >::compress_finish | ( | const bool | add_ghost_data = true | ) |
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 whether add_ghost_data is true or false) 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().
Must follow a call to the compress_start function.
| void parallel::distributed::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.
| void parallel::distributed::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.
| void parallel::distributed::Vector< Number >::zero_out_ghosts | ( | ) |
This method zeros the entries on ghost dofs, but does not touch locally owned DoFs.
| 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 seldomly 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).
| types::global_dof_index 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.
| unsigned int parallel::distributed::Vector< Number >::local_size | ( | ) | const |
Returns the local size of the vector, i.e., the number of indices owned locally.
| std::pair<types::global_dof_index, types::global_dof_index> 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 types::global_dof_index | global_index | ) | const |
Returns true if the given global index is in the local range of this processor.
| unsigned int parallel::distributed::Vector< Number >::n_ghost_entries | ( | ) | const |
Returns the number of ghost elements present on the vector.
| 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.
| const_iterator parallel::distributed::Vector< Number >::begin | ( | ) | const |
Return constant iterator to the start 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 types::global_dof_index | 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.
| Number& parallel::distributed::Vector< Number >::operator() | ( | const types::global_dof_index | 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.
| Number parallel::distributed::Vector< Number >::operator[] | ( | const types::global_dof_index | 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 types::global_dof_index | 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().
| Number parallel::distributed::Vector< Number >::local_element | ( | const unsigned int | 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].
| Number& parallel::distributed::Vector< Number >::local_element | ( | const unsigned int | 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].
| 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< unsigned int > & | 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< unsigned int > & | 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 unsigned int | n_elements, |
| const unsigned int * | 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.
This function is deprecated and will be removed in a future version. Use 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.
| 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 parallel::distributed::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.
| std::size_t parallel::distributed::Vector< Number >::memory_consumption | ( | ) | const |
Returns the memory consumption of this class in bytes.
| void parallel::distributed::Vector< Number >::clear_mpi_requests | ( | ) | [private] |
A helper function that clears the compress_requests and update_ghost_values_requests field. Used in reinit functions.
| void parallel::distributed::Vector< Number >::resize_val | ( | const unsigned int | new_allocated_size | ) | [private] |
A helper function that is used to resize the val array.
std_cxx1x::shared_ptr<const Utilities::MPI::Partitioner> parallel::distributed::Vector< Number >::partitioner [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 898 of file parallel_vector.h.
unsigned int parallel::distributed::Vector< Number >::allocated_size [private] |
The size that is currently allocated in the val array.
Definition at line 904 of file parallel_vector.h.
Number* parallel::distributed::Vector< Number >::val [private] |
Pointer to the array of local elements of this vector.
Definition at line 910 of file parallel_vector.h.
Number* parallel::distributed::Vector< Number >::import_data [mutable, private] |
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 918 of file parallel_vector.h.
VectorView<Number> parallel::distributed::Vector< Number >::vector_view [private] |
Provide this class with all functionality of Vector by creating a VectorView object.
Definition at line 925 of file parallel_vector.h.
Threads::ThreadMutex parallel::distributed::Vector< Number >::mutex [mutable, private] |
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 958 of file parallel_vector.h.
documentation generated on Tue May 22 2012 12:07:05 by
doxygen
1.7.3