Public Types | Private Member Functions | Private Attributes | Friends

parallel::distributed::Vector< Number > Class Template Reference

Inheritance diagram for parallel::distributed::Vector< Number >:
Inheritance graph
[legend]

List of all members.

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

Detailed Description

template<typename Number>
class parallel::distributed::Vector< Number >

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:

Functions related to parallel functionality:

Author:
Katharina Kormann, Martin Kronbichler, 2010, 2011

Definition at line 84 of file parallel_vector.h.


Member Typedef Documentation

template<typename Number>
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.


Constructor & Destructor Documentation

template<typename Number>
parallel::distributed::Vector< Number >::Vector ( )

Empty constructor.

template<typename Number>
parallel::distributed::Vector< Number >::Vector ( const Vector< Number > &  in_vector)

Copy constructor. Uses the parallel partitioning of in_vector.

template<typename Number>
parallel::distributed::Vector< Number >::Vector ( const unsigned int  size)

Constructs a parallel vector of the given global size without any actual parallel distribution.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
parallel::distributed::Vector< Number >::~Vector ( )

Destructor.


Member Function Documentation

template<typename Number>
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.

template<typename Number>
template<typename Number2 >
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).

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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().

template<typename Number>
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.

template<typename Number>
template<typename Number2 >
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
void parallel::distributed::Vector< Number >::zero_out_ghosts ( )

This method zeros the entries on ghost dofs, but does not touch locally owned DoFs.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
template<typename Number2 >
bool parallel::distributed::Vector< Number >::operator== ( const Vector< Number2 > &  v) const

Checks for equality of the two vectors.

template<typename Number>
template<typename Number2 >
bool parallel::distributed::Vector< Number >::operator!= ( const Vector< Number2 > &  v) const

Checks for inequality of the two vectors.

template<typename Number>
template<typename Number2 >
Number parallel::distributed::Vector< Number >::operator* ( const Vector< Number2 > &  V) const

Perform the inner product of two vectors.

template<typename Number>
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).

template<typename Number>
Number parallel::distributed::Vector< Number >::mean_value ( ) const

Computes the mean value of all the entries in the vector.

template<typename Number>
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).

template<typename Number>
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).

template<typename Number>
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).

template<typename Number>
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).

template<typename Number>
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.

template<typename Number>
unsigned int parallel::distributed::Vector< Number >::local_size ( ) const

Returns the local size of the vector, i.e., the number of indices owned locally.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
unsigned int parallel::distributed::Vector< Number >::n_ghost_entries ( ) const

Returns the number of ghost elements present on the vector.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
const_iterator parallel::distributed::Vector< Number >::begin ( ) const

Return constant iterator to the start of the vector.

template<typename Number>
iterator parallel::distributed::Vector< Number >::end ( )

Return an iterator pointing to the element past the end of the array of locally owned entries.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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().

template<typename Number>
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().

template<typename Number>
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].

template<typename Number>
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].

template<typename Number>
Vector<Number>& parallel::distributed::Vector< Number >::operator+= ( const Vector< Number > &  V)

Add the given vector to the present one.

template<typename Number>
Vector<Number>& parallel::distributed::Vector< Number >::operator-= ( const Vector< Number > &  V)

Subtract the given vector from the present one.

template<typename Number>
template<typename OtherNumber >
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.

template<typename Number>
template<typename OtherNumber >
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.

template<typename Number>
template<typename OtherNumber >
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.

template<typename Number>
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.

template<typename Number>
void parallel::distributed::Vector< Number >::add ( const Vector< Number > &  V)

Simple vector addition, equal to the operator +=.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
void parallel::distributed::Vector< Number >::sadd ( const Number  s,
const Vector< Number > &  V 
)

Scaling and simple vector addition, i.e. *this = s*(*this)+V.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
Vector<Number>& parallel::distributed::Vector< Number >::operator*= ( const Number  factor)

Scale each element of the vector by a constant value.

template<typename Number>
Vector<Number>& parallel::distributed::Vector< Number >::operator/= ( const Number  factor)

Scale each element of the vector by the inverse of the given value.

template<typename Number>
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.

template<typename Number>
template<typename Number2 >
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.

template<typename Number>
void parallel::distributed::Vector< Number >::equ ( const Number  a,
const Vector< Number > &  u 
)

Assignment *this = a*u.

template<typename Number>
template<typename Number2 >
void parallel::distributed::Vector< Number >::equ ( const Number  a,
const Vector< Number2 > &  u 
)

Assignment *this = a*u.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
std::size_t parallel::distributed::Vector< Number >::memory_consumption ( ) const

Returns the memory consumption of this class in bytes.

template<typename Number>
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.

template<typename Number>
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.


Member Data Documentation

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.

template<typename Number>
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.


The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

deal.II documentation generated on Tue May 22 2012 12:07:05 by doxygen 1.7.3