EpetraVector.h

Note

The documentation on this page was automatically extracted from the DOLFIN C++ code and may need to be edited or expanded.

class EpetraVector

Parent class(es)

This class provides a simple vector class based on Epetra. It is a simple wrapper for an Epetra vector object (Epetra_FEVector) implementing the GenericVector interface.

The interface is intentionally simple. For advanced usage, access the Epetra_FEVector object using the function vec() or vec_ptr() and use the standard Epetra interface.

EpetraVector()

Create empty vector

EpetraVector(MPI_Comm comm, std::size_t N)

Create vector of size N

EpetraVector(const EpetraVector &x)

Copy constructor

explicit EpetraVector(std::shared_ptr<Epetra_FEVector> vector)

Create vector view from given Epetra_FEVector pointer

explicit EpetraVector(const Epetra_BlockMap &map)

Create vector from given Epetra_BlockMap

void zero()

Set all entries to zero and keep any sparse structure

void apply(std::string mode)

Finalize assembly of tensor

MPI_Comm mpi_comm() const

Return MPI communicator

std::string str(bool verbose) const

Return informal string representation (pretty-print)

std::shared_ptr<GenericVector> copy() const

Return copy of vector

void init(MPI_Comm comm, std::size_t N)

Initialize vector to size N

void init(MPI_Comm comm, std::pair<std::size_t, std::size_t> range)

Initialize vector with given ownership range

void init(MPI_Comm comm, std::pair<std::size_t, std::size_t> range, const std::vector<la_index> &ghost_indices)

Initialize vector with given ownership range and with ghost values

bool empty() const

Return true if vector is empty

std::size_t size() const

Return size of vector

std::size_t local_size() const

Return size of local vector

std::pair<std::size_t, std::size_t> local_range() const

Return local ownership range of a vector

bool owns_index(std::size_t i) const

Determine whether global vector index is owned by this process

void set(const double *block, std::size_t m, const dolfin::la_index *rows)

Set block of values

void add(const double *block, std::size_t m, const dolfin::la_index *rows)

Add block of values

void get_local(std::vector<double> &values) const

Get all values on local process

void set_local(const std::vector<double> &values)

Set all values on local process

void add_local(const Array<double> &values)

Add all values to each entry on local process

void gather(GenericVector &x, const std::vector<dolfin::la_index> &indices) const

Gather entries into local vector x

void gather(std::vector<double> &x, const std::vector<dolfin::la_index> &indices) const

Gather entries into x

void gather_on_zero(std::vector<double> &x) const

Gather all entries into x on process 0

void axpy(double a, const GenericVector &x)

Add multiple of given vector (AXPY operation)

void abs()

Replace all entries in the vector by their absolute values

double inner(const GenericVector &vector) const

Return inner product with given vector

double norm(std::string norm_type) const

Return norm of vector

double min() const

Return minimum value of vector

double max() const

Return maximum value of vector

double sum() const

Return sum of values of vector

double sum(const Array<std::size_t> &rows) const

Return sum of selected rows in vector

const EpetraVector &operator*=(double a)

Multiply vector by given number

const EpetraVector &operator*=(const GenericVector &x)

Multiply vector by another vector pointwise

const EpetraVector &operator/=(double a)

Divide vector by given number

const EpetraVector &operator+=(const GenericVector &x)

Add given vector

const EpetraVector &operator+=(double a)

Add number to all components of a vector

const EpetraVector &operator-=(const GenericVector &x)

Subtract given vector

const EpetraVector &operator-=(double a)

Subtract number from all components of a vector

const EpetraVector &operator=(const GenericVector &x)

Assignment operator

const EpetraVector &operator=(double a)

Assignment operator

GenericLinearAlgebraFactory &factory() const

Return linear algebra backend factory

void init(const Epetra_BlockMap &map)

Initialize Epetra_FEVector with Epetra map

std::shared_ptr<Epetra_FEVector> vec() const

Return Epetra_FEVector pointer

const EpetraVector &operator=(const EpetraVector &x)

Assignment operator