oomph::DoubleMultiVector Class Reference

#include <double_multi_vector.h>

Inheritance diagram for oomph::DoubleMultiVector:

Public Member Functions
	DoubleMultiVector ()
	Constructor for an uninitialized DoubleMultiVector. More...
	DoubleMultiVector (const unsigned &n_vector, const LinearAlgebraDistribution *const &dist_pt, const double &v=0.0)
	DoubleMultiVector (const unsigned &n_vector, const LinearAlgebraDistribution &dist, const double &v=0.0)
	DoubleMultiVector (const unsigned &n_vector, const DoubleMultiVector &old_vector, const double &initial_value=0.0)
	DoubleMultiVector (const DoubleMultiVector &old_vector, const std::vector< int > &index, const bool &deep_copy=true)
	DoubleMultiVector (const DoubleMultiVector &new_vector)
	Copy constructor. More...
	~DoubleMultiVector ()
void	operator= (const DoubleMultiVector &old_vector)
	assignment operator (deep copy) More...
unsigned	nvector () const
	Return the number of vectors. More...
void	shallow_build (const DoubleMultiVector &old_vector)
	Provide a (shallow) copy of the old vector. More...
void	shallow_build (const unsigned &n_vector, const LinearAlgebraDistribution &dist)
void	shallow_build (const unsigned &n_vector, const LinearAlgebraDistribution *const &dist_pt)
void	build (const DoubleMultiVector &old_vector)
	Provides a (deep) copy of the old_vector. More...
void	build (const unsigned &n_vector, const LinearAlgebraDistribution &dist, const double &initial_value=0.0)
void	build (const unsigned &n_vector, const LinearAlgebraDistribution *const &dist_pt, const double &initial_value=0.0)
void	initialise (const double &initial_value)
	initialise the whole vector with value v More...
void	clear ()
	wipes the DoubleVector More...
bool	built () const
void	redistribute (const LinearAlgebraDistribution *const &dist_pt)
double &	operator() (int v, int i) const
	[] access function to the (local) values of the v-th vector More...
bool	operator== (const DoubleMultiVector &vec)
	== operator More...
void	operator+= (DoubleMultiVector vec)
	+= operator More...
void	operator-= (DoubleMultiVector vec)
	-= operator More...
void	operator*= (const double &scalar_value)
	Multiply by a scalar. More...
double **	values ()
	access function to the underlying values More...
double **	values () const
	access function to the underlying values (const version) More...
double *	values (const unsigned &i)
	access function to the i-th vector's data More...
double *	values (const unsigned &i) const
	access function to the i-th vector's data (const version) More...
DoubleVector &	doublevector (const unsigned &i)
	access to the DoubleVector representatoin More...
const DoubleVector &	doublevector (const unsigned &i) const
	access to the DoubleVector representation (const version) More...
void	output (std::ostream &outfile) const
	output the contents of the vector More...
void	output (std::string filename)
	output the contents of the vector More...
void	dot (const DoubleMultiVector &vec, std::vector< double > &result) const
	compute the 2 norm of this vector More...
void	norm (std::vector< double > &result) const
	compute the 2 norm of this vector More...
Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
	DistributableLinearAlgebraObject ()
	Default constructor - create a distribution. More...
	DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DistributableLinearAlgebraObject &)=delete
	Broken assignment operator. More...
virtual	~DistributableLinearAlgebraObject ()
	Destructor. More...
LinearAlgebraDistribution *	distribution_pt () const
	access to the LinearAlgebraDistribution More...
unsigned	nrow () const
	access function to the number of global rows. More...
unsigned	nrow_local () const
	access function for the num of local rows on this processor. More...
unsigned	nrow_local (const unsigned &p) const
	access function for the num of local rows on this processor. More...
unsigned	first_row () const
	access function for the first row on this processor More...
unsigned	first_row (const unsigned &p) const
	access function for the first row on this processor More...
bool	distributed () const
	distribution is serial or distributed More...
bool	distribution_built () const
void	build_distribution (const LinearAlgebraDistribution *const dist_pt)
void	build_distribution (const LinearAlgebraDistribution &dist)

Private Member Functions
void	setup_doublevector_representation ()
	compute the A-norm using the matrix at matrix_pt More...

Private Attributes
double **	Values
unsigned	Nvector
	The number of vectors. More...
bool	Internal_values
bool	Built
	indicates that the vector has been built and is usable More...
Vector< DoubleVector >	Internal_doublevector
	Need a vector of DoubleVectors to interface with our linear solvers. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Detailed Description

A multi vector in the mathematical sense, initially developed for linear algebra type applications. If MPI then this multi vector can be distributed - its distribution is described by the LinearAlgebraDistribution object at Distribution_pt. Data is stored in a C-style pointer vector (double*)

Constructor & Destructor Documentation

DoubleMultiVector() [1/6]

oomph::DoubleMultiVector::DoubleMultiVector ( )

inline

Constructor for an uninitialized DoubleMultiVector.

      : Values(0), Nvector(0), Internal_values(true), Built(false)
    {
    }

DoubleMultiVector() [2/6]

oomph::DoubleMultiVector::DoubleMultiVector ( const unsigned &  n_vector, const LinearAlgebraDistribution *const &  dist_pt, const double &  v = 0.0  )

inline

Constructor. Assembles a DoubleMultiVector consisting of n_vector vectors, each with a prescribed distribution. Additionally every entry can be set (with argument v - defaults to 0).

      : Values(0), Nvector(n_vector), Internal_values(true), Built(false)
    {
      this->build(n_vector, dist_pt, v);
      this->setup_doublevector_representation();
    }

References build(), setup_doublevector_representation(), and v.

DoubleMultiVector() [3/6]

oomph::DoubleMultiVector::DoubleMultiVector ( const unsigned &  n_vector, const LinearAlgebraDistribution &  dist, const double &  v = 0.0  )

inline

Constructor. Assembles a DoubleMultiVector consisting of n_vector vectors, each with a prescribed distribution. Additionally every entry can be set (with argument v - defaults to 0).

      : Values(0), Nvector(n_vector), Internal_values(true), Built(false)
    {
      this->build(n_vector, dist, v);
      this->setup_doublevector_representation();
    }

References build(), setup_doublevector_representation(), and v.

DoubleMultiVector() [4/6]

oomph::DoubleMultiVector::DoubleMultiVector ( const unsigned &  n_vector, const DoubleMultiVector &  old_vector, const double &  initial_value = 0.0  )

inline

Constructor. Build a multivector using the same distribution of the input vector with n_vector columns and initialised to the value v

      : Values(0), Nvector(n_vector), Internal_values(true), Built(false)
    {
      this->build(n_vector, old_vector.distribution_pt(), initial_value);
      this->setup_doublevector_representation();
    }

References build(), oomph::DistributableLinearAlgebraObject::distribution_pt(), and setup_doublevector_representation().

DoubleMultiVector() [5/6]

oomph::DoubleMultiVector::DoubleMultiVector ( const DoubleMultiVector &  old_vector, const std::vector< int > &  index, const bool &  deep_copy = true  )

inline

Constructor that builds a multivector from selected columns of the input multivector. The boolean controls whether it is a shallow or deep copy (default deep)

      : Values(0), Nvector(0), Internal_values(deep_copy), Built(false)
    {
      // Build the storage based on the size of index
      unsigned n_vector = index.size();
      if (deep_copy)
      {
        // Create an entirely new data structure
        this->build(n_vector, old_vector.distribution_pt());
        // Now (deep) copy the data across
        const unsigned n_row_local = this->nrow_local();
        for (unsigned v = 0; v < n_vector; v++)
        {
          for (unsigned i = 0; i < n_row_local; i++)
          {
            Values[v][i] = old_vector(index[v], i);
          }
        }
      }
      // Otherwise it's a shallow copy
      else
      {
        this->shallow_build(n_vector, old_vector.distribution_pt());
        // Now shallow copy the pointers accross
        for (unsigned v = 0; v < n_vector; ++v)
        {
          Values[v] = old_vector.values(index[v]);
        }
      }
      this->setup_doublevector_representation();
    }

References build(), oomph::CRDoubleMatrixHelpers::deep_copy(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), setup_doublevector_representation(), shallow_build(), v, and values().

DoubleMultiVector() [6/6]

oomph::DoubleMultiVector::DoubleMultiVector ( const DoubleMultiVector &  new_vector )

inline

Copy constructor.

      : DistributableLinearAlgebraObject(),
        Values(0),
        Nvector(0),
        Internal_values(true),
        Built(false)
    {
      this->build(new_vector);
      this->setup_doublevector_representation();
    }

References build(), and setup_doublevector_representation().

~DoubleMultiVector()

oomph::DoubleMultiVector::~DoubleMultiVector ( )

inline

Destructor - just calls this->clear() to delete the distribution and data

    {
      this->clear();
    }

References clear().

Member Function Documentation

build() [1/3]

void oomph::DoubleMultiVector::build ( const DoubleMultiVector &  old_vector )

inline

Provides a (deep) copy of the old_vector.

    {
      // Only bother if the old_vector is not the same as current vector
      if (!(*this == old_vector))
      {
        // the vector owns the internal data
        Internal_values = true;
 
        // Copy the number of vectors
        Nvector = old_vector.nvector();
        // reset the distribution and resize the data
        this->build(Nvector, old_vector.distribution_pt(), 0.0);
 
        // copy the data
        if (this->distribution_built())
        {
          unsigned n_row_local = this->nrow_local();
          double** const old_vector_values = old_vector.values();
          for (unsigned i = 0; i < n_row_local; i++)
          {
            for (unsigned v = 0; v < Nvector; v++)
            {
              Values[v][i] = old_vector_values[v][i];
            }
          }
        }
      }
    }

References oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, Internal_values, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), Nvector, v, and values().

Referenced by build(), DoubleMultiVector(), and operator=().

build() [2/3]

void oomph::DoubleMultiVector::build ( const unsigned &  n_vector, const LinearAlgebraDistribution &  dist, const double &  initial_value = 0.0  )

inline

Assembles a DoubleMultiVector with n_vector vectors, a distribution dist, if v is specified each element is set to v, otherwise each element is set to 0.0

    {
      this->build(n_vector, &dist, initial_value);
    }

References build().

build() [3/3]

void oomph::DoubleMultiVector::build ( const unsigned &  n_vector, const LinearAlgebraDistribution *const &  dist_pt, const double &  initial_value = 0.0  )

inline

Assembles a DoubleMultiVector with n_vector vectors, each with a distribution dist, if v is specified each element is set to v, otherwise each element is set to 0.0

    {
      // clean the memory
      this->clear();
 
      // the vector owns the internal data
      Internal_values = true;
 
      // Set the distribution
      this->build_distribution(dist_pt);
 
      // update the values
      if (dist_pt->built())
      {
        // Set the number of vectors
        Nvector = n_vector;
        // Build the array of pointers to each vector's data
        Values = new double*[n_vector];
        // Now build the contiguous array of real data
        const unsigned n_row_local = this->nrow_local();
        double* values = new double[n_row_local * n_vector];
        // set the data
        for (unsigned v = 0; v < n_vector; v++)
        {
          Values[v] = &values[v * n_row_local];
          for (unsigned i = 0; i < n_row_local; i++)
          {
            Values[v][i] = initial_value;
          }
        }
        Built = true;
      }
      else
      {
        Built = false;
      }
    }

References oomph::DistributableLinearAlgebraObject::build_distribution(), Built, oomph::LinearAlgebraDistribution::built(), clear(), i, Internal_values, oomph::DistributableLinearAlgebraObject::nrow_local(), Nvector, v, and values().

built()

bool oomph::DoubleMultiVector::built ( ) const

inline

    {
      return Built;
    }

References Built.

Referenced by dot(), norm(), operator+=(), operator-=(), and operator==().

clear()

void oomph::DoubleMultiVector::clear ( )

inline

wipes the DoubleVector

initialise the vector with coefficient from the vector v. Note: The vector v must be of length

    {
      // Return if nothing to do
      if (Values == 0)
      {
        return;
      }
 
      // If we are in charge of the data then delete it
      if (Internal_values)
      {
        // Delete the double storage arrays at once
        //(they were allocated as a contiguous block)
        delete[] Values[0];
      }
 
      // Always Delete the pointers to the arrays
      delete[] Values;
 
      // Then set the pointer (to a pointer) to null
      Values = 0;
      this->clear_distribution();
      Built = false;
    }

References Built, oomph::DistributableLinearAlgebraObject::clear_distribution(), Internal_values, and Values.

Referenced by build(), shallow_build(), and ~DoubleMultiVector().

dot()

void oomph::DoubleMultiVector::dot ( const DoubleMultiVector &  vec, std::vector< double > &  result  ) const

inline

compute the 2 norm of this vector

    {
#ifdef PARANOID
      // paranoid check that the vector is setup
      if (!this->built())
      {
        std::ostringstream error_message;
        error_message << "This vector must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (!vec.built())
      {
        std::ostringstream error_message;
        error_message << "The input vector be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (*this->distribution_pt() != *vec.distribution_pt())
      {
        std::ostringstream error_message;
        error_message << "The distribution of this vector and the vector vec "
                      << "must be the same."
                      << "\n\n  this: " << *this->distribution_pt()
                      << "\n  vec:  " << *vec.distribution_pt();
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // compute the local norm
      unsigned nrow_local = this->nrow_local();
      int n_vector = this->nvector();
      double n[n_vector];
      for (int v = 0; v < n_vector; v++)
      {
        // Initialise
        n[v] = 0.0;
        const double* vec_values_pt = vec.values(v);
        for (unsigned i = 0; i < nrow_local; i++)
        {
          n[v] += Values[v][i] * vec_values_pt[i];
        }
      }
 
      // if this vector is distributed and on multiple processors then gather
#ifdef OOMPH_HAS_MPI
      double n2[n_vector];
      for (int v = 0; v < n_vector; v++)
      {
        n2[v] = n[v];
      }
 
      if (this->distributed() &&
          this->distribution_pt()->communicator_pt()->nproc() > 1)
      {
        MPI_Allreduce(&n,
                      &n2,
                      n_vector,
                      MPI_DOUBLE,
                      MPI_SUM,
                      this->distribution_pt()->communicator_pt()->mpi_comm());
      }
      for (int v = 0; v < n_vector; v++)
      {
        n[v] = n2[v];
      }
#endif
 
      result.resize(n_vector);
      for (int v = 0; v < n_vector; v++)
      {
        result[v] = n[v];
      }
    }

References built(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, n, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, v, and values().

Referenced by Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvDot().

doublevector() [1/2]

DoubleVector& oomph::DoubleMultiVector::doublevector ( const unsigned &  i )

inline

access to the DoubleVector representatoin

    {
      return Internal_doublevector[i];
    }

References i, and Internal_doublevector.

doublevector() [2/2]

const DoubleVector& oomph::DoubleMultiVector::doublevector ( const unsigned &  i ) const

inline

access to the DoubleVector representation (const version)

    {
      return Internal_doublevector[i];
    }

References i, and Internal_doublevector.

initialise()

void oomph::DoubleMultiVector::initialise ( const double &  initial_value )

inline

initialise the whole vector with value v

    {
      if (Built)
      {
        const unsigned n_vector = this->Nvector;
        const unsigned n_row_local = this->nrow_local();
 
        // set the residuals
        for (unsigned v = 0; v < n_vector; v++)
        {
          for (unsigned i = 0; i < n_row_local; i++)
          {
            Values[v][i] = initial_value;
          }
        }
      }
    }

References Built, i, oomph::DistributableLinearAlgebraObject::nrow_local(), Nvector, and v.

Referenced by Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvInit().

norm()

void oomph::DoubleMultiVector::norm ( std::vector< double > &  result ) const

inline

compute the 2 norm of this vector

    {
#ifdef PARANOID
      // paranoid check that the vector is setup
      if (!this->built())
      {
        std::ostringstream error_message;
        error_message << "This vector must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // compute the local norm
      unsigned nrow_local = this->nrow_local();
      int n_vector = this->nvector();
      double n[n_vector];
      for (int v = 0; v < n_vector; v++)
      {
        n[v] = 0.0;
        for (unsigned i = 0; i < nrow_local; i++)
        {
          n[v] += Values[v][i] * Values[v][i];
        }
      }
 
      // if this vector is distributed and on multiple processors then gather
#ifdef OOMPH_HAS_MPI
      double n2[n_vector];
      for (int v = 0; v < n_vector; v++)
      {
        n2[v] = n[v];
      }
      if (this->distributed() &&
          this->distribution_pt()->communicator_pt()->nproc() > 1)
      {
        MPI_Allreduce(&n,
                      &n2,
                      n_vector,
                      MPI_DOUBLE,
                      MPI_SUM,
                      this->distribution_pt()->communicator_pt()->mpi_comm());
      }
      for (int v = 0; v < n_vector; v++)
      {
        n[v] = n2[v];
      }
#endif
 
      // Now sqrt the norm and fill in result
      result.resize(n_vector);
      for (int v = 0; v < n_vector; v++)
      {
        result[v] = sqrt(n[v]);
      }
    }

References built(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, n, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, sqrt(), and v.

Referenced by Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvNorm().

nvector()

unsigned oomph::DoubleMultiVector::nvector ( ) const

inline

Return the number of vectors.

    {
      return Nvector;
    }

References Nvector.

Referenced by build(), dot(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::GetNumberVecs(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvRandom(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvScale(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvTimesMatAddMv(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvTransMv(), norm(), operator*=(), operator+=(), operator-=(), operator==(), output(), setup_doublevector_representation(), and shallow_build().

operator()()

double& oomph::DoubleMultiVector::operator() ( int  v, int  i  ) const

inline

[] access function to the (local) values of the v-th vector

    {
#ifdef RANGE_CHECKING
      std::ostringstream error_message;
      bool error = false;
      if (v > int(Nvector))
      {
        error_message << "Range Error: Vector " << v
                      << "is not in the range (0," << Nvector - 1 << ")";
        error = true;
      }
 
      if (i >= int(this->nrow_local()))
      {
        error_message << "Range Error: " << i << " is not in the range (0,"
                      << this->nrow_local() - 1 << ")";
        error = true;
      }
 
      if (error)
      {
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Values[v][i];
    }

References calibrate::error, i, oomph::DistributableLinearAlgebraObject::nrow_local(), Nvector, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and v.

operator*=()

void oomph::DoubleMultiVector::operator*= ( const double &  scalar_value )

inline

Multiply by a scalar.

    {
#ifdef PARANOID
      // PARANOID check that this vector is setup
      if (!this->distribution_built())
      {
        std::ostringstream error_message;
        error_message << "This vector must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      const unsigned n_vector = this->nvector();
      const unsigned n_row_local = this->nrow_local();
      for (unsigned v = 0; v < n_vector; ++v)
      {
        for (unsigned i = 0; i < n_row_local; ++i)
        {
          Values[v][i] *= scalar_value;
        }
      }
    }

References oomph::DistributableLinearAlgebraObject::distribution_built(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and v.

operator+=()

void oomph::DoubleMultiVector::operator+= ( DoubleMultiVector  vec )

inline

+= operator

    {
#ifdef PARANOID
      // PARANOID check that this vector is setup
      if (!this->built())
      {
        std::ostringstream error_message;
        error_message << "This vector must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // PARANOID check that the vector v is setup
      if (!vec.built())
      {
        std::ostringstream error_message;
        error_message << "The vector v must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // PARANOID check that the vectors have the same distribution
      if (!(*vec.distribution_pt() == *this->distribution_pt()))
      {
        std::ostringstream error_message;
        error_message << "The vector v and this vector must have the same "
                      << "distribution.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif //
 
 
      double** v_values = vec.values();
      const unsigned n_vector = this->nvector();
      const unsigned n_row_local = this->nrow_local();
      for (unsigned v = 0; v < n_vector; ++v)
      {
        for (unsigned i = 0; i < n_row_local; ++i)
        {
          Values[v][i] += v_values[v][i];
        }
      }
    }

References built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, v, and values().

operator-=()

void oomph::DoubleMultiVector::operator-= ( DoubleMultiVector  vec )

inline

-= operator

    {
#ifdef PARANOID
      // PARANOID check that this vector is setup
      if (!this->distribution_built())
      {
        std::ostringstream error_message;
        error_message << "This vector must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // PARANOID check that the vector v is setup
      if (!vec.built())
      {
        std::ostringstream error_message;
        error_message << "The vector v must be setup.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      // PARANOID check that the vectors have the same distribution
      if (!(*vec.distribution_pt() == *this->distribution_pt()))
      {
        std::ostringstream error_message;
        error_message << "The vector v and this vector must have the same "
                      << "distribution.";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      double** v_values = vec.values();
      const unsigned n_vector = this->nvector();
      const unsigned n_row_local = this->nrow_local();
      for (unsigned v = 0; v < n_vector; ++v)
      {
        for (unsigned i = 0; i < n_row_local; ++i)
        {
          Values[v][i] -= v_values[v][i];
        }
      }
    }

References built(), oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, v, and values().

operator=()

void oomph::DoubleMultiVector::operator= ( const DoubleMultiVector &  old_vector )

inline

assignment operator (deep copy)

    {
      this->build(old_vector);
      this->setup_doublevector_representation();
    }

References build(), and setup_doublevector_representation().

operator==()

bool oomph::DoubleMultiVector::operator== ( const DoubleMultiVector &  vec )

inline

== operator

    {
      // if vec is not setup return false
      if (vec.built() && !this->built())
      {
        return false;
      }
      else if (!vec.built() && this->built())
      {
        return false;
      }
      else if (!vec.built() && !this->built())
      {
        return true;
      }
      else
      {
        double** const v_values = vec.values();
        const unsigned n_row_local = this->nrow_local();
        const unsigned n_vector = this->nvector();
        for (unsigned v = 0; v < n_vector; ++v)
        {
          for (unsigned i = 0; i < n_row_local; ++i)
          {
            if (Values[v][i] != v_values[v][i])
            {
              return false;
            }
          }
        }
        return true;
      }
    }

References built(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), v, and values().

output() [1/2]

void oomph::DoubleMultiVector::output ( std::ostream &  outfile ) const

inline

output the contents of the vector

    {
      // temp pointer to values
      double** temp;
 
      // Number of vectors
      unsigned n_vector = this->nvector();
 
      // number of global row
      unsigned nrow = this->nrow();
 
#ifdef OOMPH_HAS_MPI
 
      // number of local rows
      int nrow_local = this->nrow_local();
 
      // gather from all processors
      if (this->distributed() &&
          this->distribution_pt()->communicator_pt()->nproc() > 1)
      {
        // number of processors
        int nproc = this->distribution_pt()->communicator_pt()->nproc();
 
        // number of gobal row
        unsigned nrow = this->nrow();
 
        // get the vector of first_row s and nrow_local s
        int* dist_first_row = new int[nproc];
        int* dist_nrow_local = new int[nproc];
        for (int p = 0; p < nproc; p++)
        {
          dist_first_row[p] = this->first_row(p);
          dist_nrow_local[p] = this->nrow_local(p);
        }
 
        // gather
        temp = new double*[n_vector];
        double* temp_value = new double[nrow * n_vector];
        for (unsigned v = 0; v < n_vector; v++)
        {
          temp[v] = &temp_value[v * nrow];
        }
 
        // Now do an all gather for each vector
        // Possibly costly in terms of extra communication, but it's only
        // output!
        for (unsigned v = 0; v < n_vector; ++v)
        {
          MPI_Allgatherv(
            Values[v],
            nrow_local,
            MPI_DOUBLE,
            temp[v],
            dist_nrow_local,
            dist_first_row,
            MPI_DOUBLE,
            this->distribution_pt()->communicator_pt()->mpi_comm());
        }
 
        // clean up
        delete[] dist_first_row;
        delete[] dist_nrow_local;
      }
      else
      {
        temp = Values;
      }
#else
      temp = Values;
#endif
 
      // output
      for (unsigned i = 0; i < nrow; i++)
      {
        outfile << i << " ";
        for (unsigned v = 0; v < n_vector; v++)
        {
          outfile << temp[v][i] << " ";
        }
        outfile << "\n";
      }
 
      // clean up if required
#ifdef OOMPH_HAS_MPI
      if (this->distributed() &&
          this->distribution_pt()->communicator_pt()->nproc() > 1)
      {
        delete[] temp[0];
        delete[] temp;
      }
#endif
    }

References oomph::LinearAlgebraDistribution::communicator_pt(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::DistributableLinearAlgebraObject::first_row(), i, oomph::OomphCommunicator::nproc(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DistributableLinearAlgebraObject::nrow_local(), nvector(), p, v, and Values.

Referenced by Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvPrint(), and output().

output() [2/2]

void oomph::DoubleMultiVector::output ( std::string  filename )

inline

output the contents of the vector

    {
      // Open file
      std::ofstream some_file;
      some_file.open(filename.c_str());
      output(some_file);
      some_file.close();
    }

References MergeRestartFiles::filename, and output().

redistribute()

void oomph::DoubleMultiVector::redistribute

(

const LinearAlgebraDistribution *const &

dist_pt

)

Allows are external data to be used by this vector. WARNING: The size of the external data must correspond to the LinearAlgebraDistribution dist_pt argument.

1. When a rebuild method is called new internal values are created.
2. It is not possible to redistribute(...) a vector with external values .
3. External values are only deleted by this vector if delete_external_values = true. Allows are external data to be used by this vector. WARNING: The size of the external data must correspond to the distribution of this vector.

1. When a rebuild method is called new internal values are created.
2. It is not possible to redistribute(...) a vector with external values .
3. External values are only deleted by this vector if delete_external_values = true. The contents of the vector are redistributed to match the new distribution. In a non-MPI rebuild this method works, but does nothing. NOTE 1: The current distribution and the new distribution must have the same number of global rows. NOTE 2: The current distribution and the new distribution must have the same Communicator.

The contents of the vector are redistributed to match the new distribution. In a non-MPI rebuild this method works, but does nothing. NOTE 1: The current distribution and the new distribution must have the same number of global rows. NOTE 2: The current distribution and the new distribution must have the same Communicator.

  {
#ifdef OOMPH_HAS_MPI
#ifdef PARANOID
    if (!Internal_values)
    {
      // if this vector does not own the double* values then it cannot be
      // distributed.
      // note: this is not stictly necessary - would just need to be careful
      // with delete[] below.
      std::ostringstream error_message;
      error_message
        << "This multi vector does not own its data (i.e. data has been "
        << "passed in via set_external_values() and therefore "
        << "cannot be redistributed";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    // paranoid check that the nrows for both distributions is the
    // same
    if (dist_pt->nrow() != this->nrow())
    {
      std::ostringstream error_message;
      error_message << "The number of global rows in the new distribution ("
                    << dist_pt->nrow() << ") is not equal to the number"
                    << " of global rows in the current distribution ("
                    << this->nrow() << ").\n";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    // paranoid check that the current distribution and the new distribution
    // have the same Communicator
    OomphCommunicator temp_comm(*dist_pt->communicator_pt());
    if (!(temp_comm == *this->distribution_pt()->communicator_pt()))
    {
      std::ostringstream error_message;
      error_message << "The new distribution and the current distribution must "
                    << "have the same communicator.";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // check the distributions are not the same
    if (!((*this->distribution_pt()) == *dist_pt))
    {
      // Cache the number of vectors
      const unsigned n_vector = this->Nvector;
 
      // get the rank and the number of processors
      int my_rank = this->distribution_pt()->communicator_pt()->my_rank();
      int nproc = this->distribution_pt()->communicator_pt()->nproc();
 
      // if both vectors are distributed
      if (this->distributed() && dist_pt->distributed())
      {
        // new nrow_local and first_row data
        Vector<unsigned> new_first_row_data(nproc);
        Vector<unsigned> new_nrow_local_data(nproc);
        Vector<unsigned> current_first_row_data(nproc);
        Vector<unsigned> current_nrow_local_data(nproc);
        for (int i = 0; i < nproc; i++)
        {
          new_first_row_data[i] = dist_pt->first_row(i);
          new_nrow_local_data[i] = dist_pt->nrow_local(i);
          current_first_row_data[i] = this->first_row(i);
          current_nrow_local_data[i] = this->nrow_local(i);
        }
 
        // compute which local rows are expected to be received from each
        // processor / sent to each processor
        Vector<unsigned> new_first_row_for_proc(nproc);
        Vector<unsigned> new_nrow_local_for_proc(nproc);
        Vector<unsigned> new_first_row_from_proc(nproc);
        Vector<unsigned> new_nrow_local_from_proc(nproc);
 
        // for every processor compute first_row and nrow_local that will
        // will sent and received by this processor
        for (int p = 0; p < nproc; p++)
        {
          // start with data to be sent
          if ((new_first_row_data[p] < (current_first_row_data[my_rank] +
                                        current_nrow_local_data[my_rank])) &&
              (current_first_row_data[my_rank] <
               (new_first_row_data[p] + new_nrow_local_data[p])))
          {
            new_first_row_for_proc[p] =
              std::max(current_first_row_data[my_rank], new_first_row_data[p]);
            new_nrow_local_for_proc[p] =
              std::min((current_first_row_data[my_rank] +
                        current_nrow_local_data[my_rank]),
                       (new_first_row_data[p] + new_nrow_local_data[p])) -
              new_first_row_for_proc[p];
          }
 
          // and data to be received
          if ((new_first_row_data[my_rank] <
               (current_first_row_data[p] + current_nrow_local_data[p])) &&
              (current_first_row_data[p] <
               (new_first_row_data[my_rank] + new_nrow_local_data[my_rank])))
          {
            new_first_row_from_proc[p] =
              std::max(current_first_row_data[p], new_first_row_data[my_rank]);
            new_nrow_local_from_proc[p] =
              std::min(
                (current_first_row_data[p] + current_nrow_local_data[p]),
                (new_first_row_data[my_rank] + new_nrow_local_data[my_rank])) -
              new_first_row_from_proc[p];
          }
        }
 
        // Storage for the new data
        double** temp_data = new double*[n_vector];
        double* contiguous_temp_data =
          new double[n_vector * new_nrow_local_data[my_rank]];
        for (unsigned v = 0; v < n_vector; ++v)
        {
          temp_data[v] =
            &contiguous_temp_data[v * new_nrow_local_data[my_rank]];
        }
 
        // "send to self" or copy Data that does not need to be sent else where
        // to temp_data
        if (new_nrow_local_for_proc[my_rank] != 0)
        {
          unsigned j =
            new_first_row_for_proc[my_rank] - current_first_row_data[my_rank];
          unsigned k =
            new_first_row_for_proc[my_rank] - new_first_row_data[my_rank];
          for (unsigned i = 0; i < new_nrow_local_for_proc[my_rank]; i++)
          {
            for (unsigned v = 0; v < n_vector; ++v)
            {
              temp_data[v][k + i] = Values[v][j + i];
            }
          }
        }
 
        // send and receive circularly
        for (int p = 1; p < nproc; p++)
        {
          // next processor to send to
          unsigned dest_p = (my_rank + p) % nproc;
 
          // next processor to receive from
          unsigned source_p = (nproc + my_rank - p) % nproc;
 
          // send and receive the value
          MPI_Status status;
          for (unsigned v = 0; v < n_vector; v++)
          {
            MPI_Sendrecv(Values[v] + new_first_row_for_proc[dest_p] -
                           current_first_row_data[my_rank],
                         new_nrow_local_for_proc[dest_p],
                         MPI_DOUBLE,
                         dest_p,
                         1,
                         temp_data[v] + new_first_row_from_proc[source_p] -
                           new_first_row_data[my_rank],
                         new_nrow_local_from_proc[source_p],
                         MPI_DOUBLE,
                         source_p,
                         1,
                         this->distribution_pt()->communicator_pt()->mpi_comm(),
                         &status);
          }
        }
 
        // copy from temp data to Values_pt
        delete[] Values[0];
        delete[] Values;
        Values = temp_data;
      }
      // if this vector is distributed but the new distributed is global
      else if (this->distributed() && !dist_pt->distributed())
      {
        // copy existing Values_pt to temp_data
        unsigned n_local_data = this->nrow_local();
        double** temp_data = new double*[n_vector];
        // New continguous data
        double* contiguous_temp_data = new double[n_vector * n_local_data];
        for (unsigned v = 0; v < n_vector; ++v)
        {
          temp_data[v] = &contiguous_temp_data[v * n_local_data];
          for (unsigned i = 0; i < n_local_data; i++)
          {
            temp_data[v][i] = Values[v][i];
          }
        }
 
        // clear and resize Values_pt
        delete[] Values[0];
        double* values = new double[this->nrow() * n_vector];
        for (unsigned v = 0; v < n_vector; v++)
        {
          Values[v] = &values[v * this->nrow()];
        }
 
        // create a int vector of first rows
        int* dist_first_row = new int[nproc];
        int* dist_nrow_local = new int[nproc];
        for (int p = 0; p < nproc; p++)
        {
          dist_first_row[p] = this->first_row(p);
          dist_nrow_local[p] = this->nrow_local(p);
        }
 
        // gather the local vectors from all processors on all processors
        int my_local_data(this->nrow_local());
 
        // Loop over all vectors
        for (unsigned v = 0; v < n_vector; v++)
        {
          MPI_Allgatherv(
            temp_data[v],
            my_local_data,
            MPI_DOUBLE,
            Values[v],
            dist_nrow_local,
            dist_first_row,
            MPI_DOUBLE,
            this->distribution_pt()->communicator_pt()->mpi_comm());
        }
 
        // update the distribution
        this->build_distribution(dist_pt);
 
        // delete the temp_data
        delete[] temp_data[0];
        delete[] temp_data;
 
        // clean up
        delete[] dist_first_row;
        delete[] dist_nrow_local;
      }
 
      // if this vector is not distrubted but the target vector is
      else if (!this->distributed() && dist_pt->distributed())
      {
        // cache the new nrow_local
        unsigned nrow_local = dist_pt->nrow_local();
 
        // and first_row
        unsigned first_row = dist_pt->first_row();
 
        const unsigned n_local_data = nrow_local;
        double** temp_data = new double*[n_vector];
        double* contiguous_temp_data = new double[n_vector * n_local_data];
 
        // copy the data
        for (unsigned v = 0; v < n_vector; v++)
        {
          temp_data[v] = &contiguous_temp_data[v * n_local_data];
          for (unsigned i = 0; i < n_local_data; i++)
          {
            temp_data[v][i] = Values[v][first_row + i];
          }
        }
 
        // copy to Values_pt
        delete[] Values[0];
        delete[] Values;
        Values = temp_data;
 
        // update the distribution
        this->build_distribution(dist_pt);
      }
 
      // copy the Distribution
      this->build_distribution(dist_pt);
    }
#endif
 
    // Update the doublevector representation
    this->setup_doublevector_representation();
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearAlgebraDistribution::first_row(), oomph::DistributableLinearAlgebraObject::first_row(), i, Internal_values, j, k, max, min, oomph::OomphCommunicator::my_rank(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), oomph::DistributableLinearAlgebraObject::nrow_local(), Nvector, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, setup_doublevector_representation(), v, values(), and Values.

setup_doublevector_representation()

void oomph::DoubleMultiVector::setup_doublevector_representation ( )

inlineprivate

compute the A-norm using the matrix at matrix_pt

Setup the doublevector representation

    {
      const unsigned n_vector = this->nvector();
      Internal_doublevector.resize(n_vector);
      // Loop over all and set the external values of the DoubleVectors
      for (unsigned v = 0; v < n_vector; v++)
      {
        Internal_doublevector[v].set_external_values(
          this->distribution_pt(), this->values(v), false);
      }
    }

References oomph::DistributableLinearAlgebraObject::distribution_pt(), Internal_doublevector, nvector(), v, and values().

Referenced by DoubleMultiVector(), operator=(), and redistribute().

shallow_build() [1/3]

void oomph::DoubleMultiVector::shallow_build ( const DoubleMultiVector &  old_vector )

inline

Provide a (shallow) copy of the old vector.

    {
      // Only bother if the old_vector is not the same as current vector
      if (!(*this == old_vector))
      {
        // the vector does not own the internal data
        Internal_values = false;
 
        // Copy the number of vectors
        Nvector = old_vector.nvector();
        // Allocate storage for pointers to the values
        this->shallow_build(Nvector, old_vector.distribution_pt());
 
        // copy all the pointers accross
        if (this->distribution_built())
        {
          for (unsigned v = 0; v < Nvector; ++v)
          {
            Values[v] = old_vector.values(v);
          }
        }
      }
    }

References oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Internal_values, nvector(), Nvector, v, and values().

Referenced by DoubleMultiVector(), and shallow_build().

shallow_build() [2/3]

void oomph::DoubleMultiVector::shallow_build ( const unsigned &  n_vector, const LinearAlgebraDistribution &  dist  )

inline

Build the storage for pointers to vectors with a given distribution, but do not populate the pointers

    {
      this->shallow_build(n_vector, &dist);
    }

References shallow_build().

shallow_build() [3/3]

void oomph::DoubleMultiVector::shallow_build ( const unsigned &  n_vector, const LinearAlgebraDistribution *const &  dist_pt  )

inline

Build the storage for pointers to vectors with a given distribution, but do not populate the pointers

    {
      // clean the memory
      this->clear();
 
      // The vector does not own the data
      Internal_values = false;
 
      // Set the distribution
      this->build_distribution(dist_pt);
 
      // update the values
      if (dist_pt->built())
      {
        // Set the number of vectors
        Nvector = n_vector;
        // Build the array of pointers to each vector's data
        Values = new double*[n_vector];
        Built = true;
      }
      else
      {
        Built = false;
      }
    }

References oomph::DistributableLinearAlgebraObject::build_distribution(), Built, oomph::LinearAlgebraDistribution::built(), clear(), Internal_values, and Nvector.

values() [1/4]

double** oomph::DoubleMultiVector::values ( )

inline

access function to the underlying values

    {
      return Values;
    }

References Values.

Referenced by build(), dot(), DoubleMultiVector(), operator+=(), operator-=(), operator==(), redistribute(), setup_doublevector_representation(), and shallow_build().

values() [2/4]

double** oomph::DoubleMultiVector::values ( ) const

inline

access function to the underlying values (const version)

    {
      return Values;
    }

References Values.

values() [3/4]

double* oomph::DoubleMultiVector::values ( const unsigned &  i )

inline

access function to the i-th vector's data

    {
      return Values[i];
    }

References i.

values() [4/4]

double* oomph::DoubleMultiVector::values ( const unsigned &  i ) const

inline

access function to the i-th vector's data (const version)

    {
      return Values[i];
    }

References i.

Member Data Documentation

Built

bool oomph::DoubleMultiVector::Built

private

indicates that the vector has been built and is usable

Referenced by build(), built(), clear(), initialise(), and shallow_build().

Internal_doublevector

Vector<DoubleVector> oomph::DoubleMultiVector::Internal_doublevector

private

Need a vector of DoubleVectors to interface with our linear solvers.

Referenced by doublevector(), and setup_doublevector_representation().

Internal_values

bool oomph::DoubleMultiVector::Internal_values

private

Boolean flag to indicate whether the vector's data (values_pt) is owned by this vector.

Referenced by build(), clear(), redistribute(), and shallow_build().

Nvector

unsigned oomph::DoubleMultiVector::Nvector

private

The number of vectors.

Referenced by build(), initialise(), nvector(), operator()(), redistribute(), and shallow_build().

Values

double** oomph::DoubleMultiVector::Values

private

the local data, need a pointer to a pointer so that the individual vectors can be extracted

Referenced by clear(), output(), redistribute(), and values().

---

The documentation for this class was generated from the following files:

• double_multi_vector.h
• double_multi_vector.cc