Public Types | Public Member Functions | Static Public Member Functions

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

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

List of all members.

Public Types

typedef BlockVectorBase
< Vector< Number > > 
BaseClass
typedef BaseClass::BlockType BlockType
typedef BaseClass::value_type value_type
typedef BaseClass::real_type real_type

Public Member Functions

 BlockVector (const unsigned int num_blocks=0, const unsigned int block_size=0)
 BlockVector (const BlockVector< Number > &V)
template<typename OtherNumber >
 BlockVector (const BlockVector< OtherNumber > &v)
 BlockVector (const std::vector< unsigned int > &block_sizes)
 ~BlockVector ()
BlockVectoroperator= (const value_type s)
BlockVectoroperator= (const BlockVector &V)
template<class Number2 >
BlockVectoroperator= (const BlockVector< Number2 > &V)
BlockVectoroperator= (const Vector< Number > &V)
void reinit (const unsigned int num_blocks, const unsigned int block_size=0, const bool fast=false)
void reinit (const std::vector< unsigned int > &N, const bool fast=false)
template<typename Number2 >
void reinit (const BlockVector< Number2 > &V, const bool fast=false)
void scale (const value_type factor)
template<class BlockVector2 >
void scale (const BlockVector2 &v)
void swap (BlockVector< Number > &v)

Static Public Member Functions

::ExceptionBaseExcIteratorRangeDoesNotMatchVectorSize ()

Detailed Description

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

An implementation of block vectors based on distribued deal.II vectors. While the base class provides for most of the interface, this class handles the actual allocation of vectors and provides functions that are specific to the underlying vector type.

Note:
Instantiations for this template are provided for <float> and <double>; others can be generated in application programs (see the section on Template instantiations in the manual).
See also:
Block (linear algebra)
Author:
Katharina Kormann, Martin Kronbichler, 2011

Definition at line 55 of file parallel_block_vector.h.


Member Typedef Documentation

template<typename Number>
typedef BlockVectorBase<Vector<Number> > parallel::distributed::BlockVector< Number >::BaseClass

Typedef the base class for simpler access to its own typedefs.

Definition at line 62 of file parallel_block_vector.h.

template<typename Number>
typedef BaseClass::BlockType parallel::distributed::BlockVector< Number >::BlockType

Typedef the type of the underlying vector.

Reimplemented from BlockVectorBase< Vector< Number > >.

Definition at line 68 of file parallel_block_vector.h.

template<typename Number>
typedef BaseClass::value_type parallel::distributed::BlockVector< Number >::value_type

Import the typedefs from the base class.

Reimplemented from BlockVectorBase< Vector< Number > >.

Definition at line 74 of file parallel_block_vector.h.

template<typename Number>
typedef BaseClass::real_type parallel::distributed::BlockVector< Number >::real_type

Declare a type that has holds real-valued numbers with the same precision as the template argument to this class. If the template argument of this class is a real data type, then real_type equals the template argument. If the template argument is a std::complex type then real_type equals the type underlying the complex numbers.

This typedef is used to represent the return type of norms.

Reimplemented from BlockVectorBase< Vector< Number > >.

Definition at line 75 of file parallel_block_vector.h.


Constructor & Destructor Documentation

template<typename Number>
parallel::distributed::BlockVector< Number >::BlockVector ( const unsigned int  num_blocks = 0,
const unsigned int  block_size = 0 
) [explicit]

Constructor. There are three ways to use this constructor. First, without any arguments, it generates an object with no blocks. Given one argument, it initializes num_blocks blocks, but these blocks have size zero. The third variant finally initializes all blocks to the same size block_size.

Confer the other constructor further down if you intend to use blocks of different sizes.

template<typename Number>
parallel::distributed::BlockVector< Number >::BlockVector ( const BlockVector< Number > &  V)

Copy-Constructor. Dimension set to that of V, all components are copied from V

template<typename Number>
template<typename OtherNumber >
parallel::distributed::BlockVector< Number >::BlockVector ( const BlockVector< OtherNumber > &  v) [explicit]

Copy constructor taking a BlockVector of another data type. This will fail if there is no conversion path from OtherNumber to Number. Note that you may lose accuracy when copying to a BlockVector with data elements with less accuracy.

Older versions of gcc did not honor the explicit keyword on template constructors. In such cases, it is easy to accidentally write code that can be very inefficient, since the compiler starts performing hidden conversions. To avoid this, this function is disabled if we have detected a broken compiler during configuration.

template<typename Number>
parallel::distributed::BlockVector< Number >::BlockVector ( const std::vector< unsigned int > &  block_sizes)

Constructor. Set the number of blocks to block_sizes.size() and initialize each block with block_sizes[i] zero elements.

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

Destructor. Clears memory


Member Function Documentation

template<typename Number>
BlockVector& parallel::distributed::BlockVector< Number >::operator= ( const value_type  s)

Copy operator: fill all components of the vector with the given scalar value.

Reimplemented from BlockVectorBase< Vector< Number > >.

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

Copy operator for arguments of the same type. Resize the present vector if necessary.

template<typename Number>
template<class Number2 >
BlockVector& parallel::distributed::BlockVector< Number >::operator= ( const BlockVector< Number2 > &  V)

Copy operator for template arguments of different types. Resize the present vector if necessary.

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

Copy a regular vector into a block vector.

template<typename Number>
void parallel::distributed::BlockVector< Number >::reinit ( const unsigned int  num_blocks,
const unsigned int  block_size = 0,
const bool  fast = false 
)

Reinitialize the BlockVector to contain num_blocks blocks of size block_size each.

If the second argument is left at its default value, then the block vector allocates the specified number of blocks but leaves them at zero size. You then need to later reinitialize the individual blocks, and call collect_sizes() to update the block system's knowledge of its individual block's sizes.

If fast==false, the vector is filled with zeros.

template<typename Number>
void parallel::distributed::BlockVector< Number >::reinit ( const std::vector< unsigned int > &  N,
const bool  fast = false 
)

Reinitialize the BlockVector such that it contains block_sizes.size() blocks. Each block is reinitialized to dimension block_sizes[i].

If the number of blocks is the same as before this function was called, all vectors remain the same and reinit() is called for each vector.

If fast==false, the vector is filled with zeros.

Note that you must call this (or the other reinit() functions) function, rather than calling the reinit() functions of an individual block, to allow the block vector to update its caches of vector sizes. If you call reinit() on one of the blocks, then subsequent actions on this object may yield unpredictable results since they may be routed to the wrong block.

template<typename Number>
template<typename Number2 >
void parallel::distributed::BlockVector< Number >::reinit ( const BlockVector< Number2 > &  V,
const bool  fast = false 
)

Change the dimension to that of the vector V. The same applies as for the other reinit() function.

The elements of V are not copied, i.e. this function is the same as calling reinit (V.size(), fast).

Note that you must call this (or the other reinit() functions) function, rather than calling the reinit() functions of an individual block, to allow the block vector to update its caches of vector sizes. If you call reinit() of one of the blocks, then subsequent actions of this object may yield unpredictable results since they may be routed to the wrong block.

template<typename Number>
void parallel::distributed::BlockVector< Number >::scale ( const value_type  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.

Deprecated:
Use operator*= instead.
template<typename Number>
template<class BlockVector2 >
void parallel::distributed::BlockVector< Number >::scale ( const BlockVector2 &  v)

Multiply each element of this vector by the corresponding element of v.

Reimplemented from BlockVectorBase< Vector< Number > >.

template<typename Number>
void parallel::distributed::BlockVector< Number >::swap ( BlockVector< 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.

Limitation: right now this function only works if both vectors have the same number of blocks. If needed, the numbers of blocks should be exchanged, too.

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.

Referenced by BlockVector< Number >::swap().


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