oomph::DoubleVector Class Reference

#include <double_vector.h>

Inheritance diagram for oomph::DoubleVector:

Public Member Functions
	DoubleVector ()
	Constructor for an uninitialized DoubleVector. More...
	DoubleVector (const LinearAlgebraDistribution *const &dist_pt, const double &v=0.0)
	DoubleVector (const LinearAlgebraDistribution &dist, const double &v=0.0)
	~DoubleVector ()
	DoubleVector (const DoubleVector &new_vector)
	Copy constructor. More...
void	operator= (const DoubleVector &old_vector)
	assignment operator More...
void	build (const DoubleVector &old_vector)
	Just copys the argument DoubleVector. More...
void	build (const LinearAlgebraDistribution &dist, const double &v)
void	build (const LinearAlgebraDistribution *const &dist_pt, const double &v)
void	build (const LinearAlgebraDistribution &dist, const Vector< double > &v)
void	build (const LinearAlgebraDistribution *const &dist_pt, const Vector< double > &v)
void	initialise (const double &v)
	initialise the whole vector with value v More...
void	initialise (const Vector< double > v)
void	clear ()
	wipes the DoubleVector More...
bool	built () const
void	set_external_values (const LinearAlgebraDistribution *const &dist_pt, double *external_values, bool delete_external_values)
void	set_external_values (double *external_values, bool delete_external_values)
void	redistribute (const LinearAlgebraDistribution *const &dist_pt)
double &	operator[] (int i)
	[] access function to the (local) values of this vector More...
bool	operator== (const DoubleVector &v)
	== operator More...
void	operator+= (const DoubleVector &v)
	+= operator with another vector More...
void	operator-= (const DoubleVector &v)
	-= operator with another vector More...
void	operator*= (const double &d)
	multiply by a double More...
void	operator/= (const double &d)
	divide by a double More...
const double &	operator[] (int i) const
	[] access function to the (local) values of this vector More...
double	max () const
	returns the maximum coefficient More...
double *	values_pt ()
	access function to the underlying values More...
double *	values_pt () const
	access function to the underlying values (const version) More...
void	output (std::ostream &outfile, const int &output_precision=-1) const
	output the global contents of the vector More...
void	output (std::string filename, const int &output_precision=-1) const
	output the global contents of the vector More...
void	output_local_values (std::ostream &outfile, const int &output_precision=-1) const
	output the local contents of the vector More...
void	output_local_values (std::string filename, const int &output_precision=-1) const
	output the local contents of the vector More...
void	output_local_values_with_offset (std::ostream &outfile, const int &output_precision=-1) const
	output the local contents of the vector More...
void	output_local_values_with_offset (std::string filename, const int &output_precision=-1) const
	output the local contents of the vector More...
double	dot (const DoubleVector &vec) const
	compute the dot product of this vector with the vector vec. More...
double	norm () const
	compute the 2 norm of this vector More...
double	norm (const CRDoubleMatrix *matrix_pt) const
	compute the A-norm using the matrix at matrix_pt 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 Attributes
double *	Values_pt
	the local vector More...
bool	Internal_values
bool	Built
	indicates that the vector has been built and is usable More...

Friends
std::ostream &	operator<< (std::ostream &out, const DoubleVector &v)
	Ouput operator for DoubleVector. More...

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

Detailed Description

A vector in the mathematical sense, initially developed for linear algebra type applications. If MPI then this 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

DoubleVector() [1/4]

oomph::DoubleVector::DoubleVector ( )

inline

Constructor for an uninitialized DoubleVector.

: Values_pt(0), Internal_values(true), Built(false) {}

DoubleVector() [2/4]

oomph::DoubleVector::DoubleVector ( const LinearAlgebraDistribution *const &  dist_pt, const double &  v = 0.0  )

inline

Constructor. Assembles a DoubleVector with a prescribed distribution. Additionally every entry can be set (with argument v - defaults to 0).

      : Values_pt(0), Internal_values(true), Built(false)
    {
      this->build(dist_pt, v);
    }

References build(), and v.

DoubleVector() [3/4]

oomph::DoubleVector::DoubleVector ( const LinearAlgebraDistribution &  dist, const double &  v = 0.0  )

inline

Constructor. Assembles a DoubleVector with a prescribed distribution. Additionally every entry can be set (with argument v - defaults to 0).

      : Values_pt(0), Internal_values(true), Built(false)
    {
      this->build(dist, v);
    }

References build(), and v.

~DoubleVector()

oomph::DoubleVector::~DoubleVector ( )

inline

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

    {
      this->clear();
    }

References clear().

DoubleVector() [4/4]

oomph::DoubleVector::DoubleVector ( const DoubleVector &  new_vector )

inline

Copy constructor.

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

References build().

Member Function Documentation

build() [1/5]

void oomph::DoubleVector::build

(

const DoubleVector &

old_vector

)

Just copys the argument DoubleVector.

  {
    if (!(*this == old_vector))
    {
      // the vector owns the internal data
      Internal_values = true;
 
      // reset the distribution and resize the data
      this->build(old_vector.distribution_pt(), 0.0);
 
      // copy the data
      if (this->distribution_built())
      {
        unsigned nrow_local = this->nrow_local();
        const double* old_vector_values = old_vector.values_pt();
        std::copy(old_vector_values, old_vector_values + nrow_local, Values_pt);
      }
    }
  }

References copy(), oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), Internal_values, oomph::DistributableLinearAlgebraObject::nrow_local(), values_pt(), and Values_pt.

Referenced by oomph::OomphLibPreconditionerEpetraOperator::ApplyInverse(), build(), oomph::ComplexDampedJacobi< MATRIX >::complex_solve_helper(), oomph::DoubleVectorHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate_without_communication(), create_vector_ascend_row(), DoubleVector(), oomph::Problem::get_dofs(), oomph::Problem::get_inverse_mass_matrix_times_residuals(), oomph::Problem::get_jacobian(), oomph::Problem::get_residuals(), main(), oomph::TrilinosEpetraHelpers::multiply(), oomph::CRDoubleMatrix::multiply(), oomph::DenseDoubleMatrix::multiply(), oomph::CCDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), oomph::DenseDoubleMatrix::multiply_transpose(), oomph::CCDoubleMatrix::multiply_transpose(), operator=(), oomph::DoubleVectorWithHaloEntries::operator=(), oomph::PitchForkHandler::PitchForkHandler(), BoussinesqPreconditioner::preconditioner_solve(), oomph::BlockDiagonalPreconditioner< MATRIX >::preconditioner_solve(), oomph::DummyBlockPreconditioner< MATRIX >::preconditioner_solve(), oomph::MatrixBasedDiagPreconditioner::preconditioner_solve(), oomph::MatrixBasedLumpedPreconditioner< MATRIX >::preconditioner_solve(), oomph::TrilinosPreconditionerBase::preconditioner_solve(), oomph::FSIPreconditioner::preconditioner_solve(), oomph::PseudoElasticFSIPreconditioner::preconditioner_solve(), oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve(), oomph::NavierStokesSchurComplementPreconditioner::preconditioner_solve(), oomph::PressureBasedSolidLSCPreconditioner::preconditioner_solve(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::preconditioner_solve(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), oomph::HSL_MA42::resolve(), run_it(), oomph::Problem::setup_element_count_per_dof(), oomph::DenseLU::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::HSL_MA42::solve(), oomph::CG< MATRIX >::solve(), oomph::BiCGStab< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), oomph::GS< MATRIX >::solve_helper(), oomph::GS< CRDoubleMatrix >::solve_helper(), oomph::DampedJacobi< MATRIX >::solve_helper(), oomph::AugmentedProblemGMRES::solve_helper(), and oomph::SuperLUSolver::solve_transpose().

build() [2/5]

void oomph::DoubleVector::build ( const LinearAlgebraDistribution &  dist, const double &  v  )

inline

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

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

References build(), and v.

build() [3/5]

void oomph::DoubleVector::build ( const LinearAlgebraDistribution &  dist, const Vector< double > &  v  )

inline

Assembles a DoubleVector with a distribution dist and coefficients taken from the vector v. Note. The vector v MUST be of length nrow()

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

References build(), and v.

build() [4/5]

void oomph::DoubleVector::build	(	const LinearAlgebraDistribution *const &	dist_pt,
		const double &	v
	)

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

Assembles a DoubleVector with distribution dist, if v is specified each row is set to v

  {
    // 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())
    {
      unsigned nrow_local = this->nrow_local();
      Values_pt = new double[nrow_local];
 
      std::fill_n(Values_pt, nrow_local, v);
      Built = true;
    }
    else
    {
      Built = false;
    }
  }

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

build() [5/5]

void oomph::DoubleVector::build	(	const LinearAlgebraDistribution *const &	dist_pt,
		const Vector< double > &	v
	)

Assembles a DoubleVector with a distribution dist and coefficients taken from the vector v. Note. The vector v MUST be of length nrow()

  {
    // 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())
    {
      // re-allocate memory which was deleted by clear()
      unsigned nrow_local = this->nrow_local();
      Values_pt = new double[nrow_local];
 
      // use the initialise method to populate the vector
      this->initialise(v);
      Built = true;
    }
    else
    {
      Built = false;
    }
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), Built, oomph::LinearAlgebraDistribution::built(), clear(), initialise(), Internal_values, oomph::DistributableLinearAlgebraObject::nrow_local(), and Values_pt.

built()

bool oomph::DoubleVector::built ( ) const

inline

    {
      return Built;
    }

References Built.

Referenced by oomph::MumpsSolver::backsub(), oomph::SuperLUSolver::backsub_serial(), oomph::SuperLUSolver::backsub_transpose_serial(), oomph::Smoother::check_validity_of_solve_helper_inputs(), oomph::DoubleVectorHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::TrilinosEpetraHelpers::copy_to_oomphlib_vector(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_vector_view_data(), dot(), oomph::Problem::get_jacobian(), oomph::Problem::get_residuals(), oomph::CRDoubleMatrix::lubksub(), oomph::TrilinosEpetraHelpers::multiply(), oomph::CRDoubleMatrix::multiply(), oomph::DenseDoubleMatrix::multiply(), oomph::CCDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), oomph::DenseDoubleMatrix::multiply_transpose(), oomph::CCDoubleMatrix::multiply_transpose(), norm(), operator+=(), BoussinesqPreconditioner::preconditioner_solve(), oomph::BlockDiagonalPreconditioner< MATRIX >::preconditioner_solve(), oomph::MatrixBasedDiagPreconditioner::preconditioner_solve(), oomph::MatrixBasedLumpedPreconditioner< MATRIX >::preconditioner_solve(), oomph::ILUZeroPreconditioner< CCDoubleMatrix >::preconditioner_solve(), oomph::ILUZeroPreconditioner< CRDoubleMatrix >::preconditioner_solve(), oomph::HyprePreconditioner::preconditioner_solve(), oomph::IdentityPreconditioner::preconditioner_solve(), oomph::FSIPreconditioner::preconditioner_solve(), oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve(), oomph::NavierStokesSchurComplementPreconditioner::preconditioner_solve(), oomph::PressureBasedSolidLSCPreconditioner::preconditioner_solve(), oomph::AugmentedBlockFoldLinearSolver::resolve(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::AugmentedBlockPitchForkLinearSolver::resolve(), oomph::MumpsSolver::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::AugmentedBlockFoldLinearSolver::solve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::AugmentedBlockPitchForkLinearSolver::solve(), oomph::BlockHopfLinearSolver::solve(), oomph::BiCGStab< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::FD_LU::solve(), oomph::SuperLUSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), oomph::CG< MATRIX >::solve_helper(), oomph::BiCGStab< MATRIX >::solve_helper(), oomph::GMRES< MATRIX >::solve_helper(), oomph::AugmentedProblemGMRES::solve_helper(), oomph::HelmholtzGMRESMG< MATRIX >::solve_helper(), oomph::HelmholtzFGMRESMG< MATRIX >::solve_helper(), oomph::SuperLUSolver::solve_transpose(), oomph::DoubleVectorHelpers::split(), and oomph::DoubleVectorHelpers::split_without_communication().

clear()

void oomph::DoubleVector::clear ( )

inline

wipes the DoubleVector

    {
      if (Internal_values)
      {
        delete[] Values_pt;
      }
      Values_pt = 0;
      this->clear_distribution();
      Built = false;
    }

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

Referenced by build(), create_vector_ascend_row(), main(), oomph::Problem::newton_solve(), oomph::Problem::newton_solve_continuation(), BoussinesqPreconditioner::preconditioner_solve(), oomph::BiharmonicPreconditioner::preconditioner_solve(), oomph::InexactSubBiharmonicPreconditioner::preconditioner_solve(), oomph::FSIPreconditioner::preconditioner_solve(), oomph::PseudoElasticFSIPreconditioner::preconditioner_solve(), oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve(), oomph::NavierStokesSchurComplementPreconditioner::preconditioner_solve(), oomph::PressureBasedSolidLSCPreconditioner::preconditioner_solve(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::preconditioner_solve(), oomph::LinearSolver::reset_gradient(), set_external_values(), oomph::ARPACK::solve_eigenproblem(), and ~DoubleVector().

dot()

double oomph::DoubleVector::dot

(

const DoubleVector &

vec

)

const

compute the dot product of this vector with the vector vec.

compute the dot product of this vector with the vector vec

  {
#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();
    double n = 0.0;
    const double* vec_values_pt = vec.values_pt();
    for (unsigned i = 0; i < nrow_local; i++)
    {
      n += Values_pt[i] * vec_values_pt[i];
    }
 
    // if this vector is distributed and on multiple processors then gather
#ifdef OOMPH_HAS_MPI
    double n2 = n;
    if (this->distributed() &&
        this->distribution_pt()->communicator_pt()->nproc() > 1)
    {
      MPI_Allreduce(&n,
                    &n2,
                    1,
                    MPI_DOUBLE,
                    MPI_SUM,
                    this->distribution_pt()->communicator_pt()->mpi_comm());
    }
    n = n2;
#endif
 
    // and return;
    return n;
  }

References built(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, n, oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, values_pt(), and Values_pt.

Referenced by oomph::AugmentedProblemGMRES::augmented_matrix_multiply(), oomph::Problem::calculate_continuation_derivatives_helper(), norm(), StabilityProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::perform_power_method(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::CG< MATRIX >::solve_helper(), oomph::BiCGStab< MATRIX >::solve_helper(), and oomph::AugmentedProblemGMRES::solve_helper().

initialise() [1/2]

void oomph::DoubleVector::initialise

(

const double &

v

)

initialise the whole vector with value v

  {
    if (Built)
    {
      // cache nrow local
      unsigned nrow_local = this->nrow_local();
 
      std::fill_n(Values_pt, nrow_local, v);
    }
  }

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

Referenced by build(), oomph::Problem::get_jacobian(), oomph::CRDoubleMatrix::multiply(), oomph::DenseDoubleMatrix::multiply(), oomph::CCDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), oomph::DenseDoubleMatrix::multiply_transpose(), oomph::CCDoubleMatrix::multiply_transpose(), oomph::BiharmonicPreconditioner::preconditioner_solve(), run_it(), oomph::GS< CRDoubleMatrix >::solve_helper(), and oomph::AugmentedProblemGMRES::solve_helper().

initialise() [2/2]

void oomph::DoubleVector::initialise

(

const Vector< double >

v

)

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

  {
#ifdef PARANOID
    if (v.size() != this->nrow())
    {
      std::ostringstream error_message;
      error_message << "The vector passed to initialise(...) must be of length "
                    << "nrow()";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
    unsigned begin_first_row = this->first_row();
    unsigned end = begin_first_row + this->nrow_local();
 
    std::copy(v.begin() + begin_first_row, v.begin() + end, Values_pt);
  }

References copy(), Eigen::placeholders::end, oomph::DistributableLinearAlgebraObject::first_row(), oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, v, and Values_pt.

max()

double oomph::DoubleVector::max

(

)

const

returns the maximum coefficient

  {
    // the number of local rows
    unsigned nrow = this->nrow_local();
 
    // get the local maximum
    double max = 0.0;
    for (unsigned i = 0; i < nrow; i++)
    {
      if (std::fabs(Values_pt[i]) > std::fabs(max))
      {
        max = std::fabs(Values_pt[i]);
      }
    }
 
    // now return the maximum
#ifdef OOMPH_HAS_MPI
    // if this vector is not distributed then the local maximum is the global
    // maximum
    if (!this->distributed())
    {
      return max;
    }
    // else if the vector is distributed but only on a single processor
    // then the local maximum is the global maximum
    else if (this->distribution_pt()->communicator_pt()->nproc() == 1)
    {
      return max;
    }
    // otherwise use MPI_Allreduce to find the global maximum
    else
    {
      double local_max = max;
      MPI_Allreduce(&local_max,
                    &max,
                    1,
                    MPI_DOUBLE,
                    MPI_MAX,
                    this->distribution_pt()->communicator_pt()->mpi_comm());
      return max;
    }
#else
    return max;
#endif
  }

References oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), boost::multiprecision::fabs(), i, oomph::DistributableLinearAlgebraObject::nrow(), oomph::DistributableLinearAlgebraObject::nrow_local(), and Values_pt.

Referenced by SegregatedFSICollapsibleChannelProblem< ELEMENT >::actions_before_newton_convergence_check(), SegregatedFSICollapsibleChannelProblem< ELEMENT >::actions_before_segregated_convergence_check(), BaseCoupling< M, O >::checkResidual(), oomph::Problem::newton_solve(), BrethertonProblem< ELEMENT >::parameter_study(), oomph::SegregatableFSIProblem::segregated_solve(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), and HomogenisationProblem< ELEMENT >::sub_solve().

norm() [1/2]

double oomph::DoubleVector::norm

(

)

const

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();
    double n = 0;
    for (unsigned i = 0; i < nrow_local; i++)
    {
      n += Values_pt[i] * Values_pt[i];
    }
 
    // if this vector is distributed and on multiple processors then gather
#ifdef OOMPH_HAS_MPI
    double n2 = n;
    if (this->distributed() &&
        this->distribution_pt()->communicator_pt()->nproc() > 1)
    {
      MPI_Allreduce(&n,
                    &n2,
                    1,
                    MPI_DOUBLE,
                    MPI_SUM,
                    this->distribution_pt()->communicator_pt()->mpi_comm());
    }
    n = n2;
#endif
 
    // sqrt the norm
    n = sqrt(n);
 
    // and return
    return n;
  }

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

Referenced by oomph::ComplexDampedJacobi< MATRIX >::complex_solve_helper(), BaseStateProblem< BASE_ELEMENT >::doc_solution(), PerturbedStateProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::doc_solution(), oomph::MyProblem::get_solution_norm(), oomph::HypreInterface::hypre_solve(), StabilityProblem< BASE_ELEMENT, PERTURBED_ELEMENT >::perform_power_method(), oomph::PitchForkHandler::PitchForkHandler(), oomph::CG< MATRIX >::solve_helper(), oomph::BiCGStab< MATRIX >::solve_helper(), oomph::GS< MATRIX >::solve_helper(), oomph::GS< CRDoubleMatrix >::solve_helper(), oomph::DampedJacobi< MATRIX >::solve_helper(), oomph::GMRES< MATRIX >::solve_helper(), and oomph::AugmentedProblemGMRES::solve_helper().

norm() [2/2]

double oomph::DoubleVector::norm

(

const CRDoubleMatrix *

matrix_pt

)

const

compute the A-norm using the matrix at matrix_pt

  {
#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 (!matrix_pt->built())
    {
      std::ostringstream error_message;
      error_message << "The input matrix be built.";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    if (*this->distribution_pt() != *matrix_pt->distribution_pt())
    {
      std::ostringstream error_message;
      error_message << "The distribution of this vector and the matrix at "
                    << "matrix_pt must be the same";
      throw OomphLibError(
        error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // compute the matrix norm
    DoubleVector x(this->distribution_pt(), 0.0);
    matrix_pt->multiply(*this, x);
    return sqrt(this->dot(x));
  }

References built(), oomph::CRDoubleMatrix::built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), dot(), oomph::CRDoubleMatrix::multiply(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, sqrt(), and plotDoE::x.

operator*=()

void oomph::DoubleVector::operator*=

(

const double &

d

)

multiply by a double

Multiply by double.

  {
#ifdef PARANOID
    if (!this->distribution_built())
    {
      std::ostringstream error_msg;
      error_msg << "DoubleVector must be set up.";
      throw OomphLibError(
        error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // Decided to keep this as a loop rather than use std::transform, because
    // this is a very simple loop and should compile to the same code.
    for (unsigned i = 0, ni = this->nrow_local(); i < ni; i++)
    {
      Values_pt[i] *= d;
    }
  }

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

Referenced by operator/=().

operator+=()

void oomph::DoubleVector::operator+=

(

const DoubleVector &

v

)

+= operator with another vector

+= 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 (!v.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 (!(*v.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 //
 
    // cache nrow_local
    double* v_values_pt = v.values_pt();
    unsigned nrow_local = this->nrow_local();
 
    // Decided to keep this as a loop rather than use std::transform, because
    // this is a very simple loop and should compile to the same code.
    for (unsigned i = 0; i < nrow_local; i++)
    {
      Values_pt[i] += v_values_pt[i];
    }
  }

References built(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, v, and Values_pt.

operator-=()

void oomph::DoubleVector::operator-=

(

const DoubleVector &

v

)

-= operator with another vector

-= 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 (!v.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 (!(*v.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
 
    // cache nrow_local
    double* v_values_pt = v.values_pt();
    unsigned nrow_local = this->nrow_local();
 
    // Decided to keep this as a loop rather than use std::transform, because
    // this is a very simple loop and should compile to the same code.
    for (unsigned i = 0; i < nrow_local; i++)
    {
      Values_pt[i] -= v_values_pt[i];
    }
  }

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

operator/=()

void oomph::DoubleVector::operator/=

(

const double &

d

)

divide by a double

Divide by double.

  {
    // PARANOID checks are done inside operator *=
 
    // Decided to keep this as a loop rather than use std::transform, because
    // this is a very simple loop and should compile to the same code.
    double divisor = (1.0 / d);
    this->operator*=(divisor);
  }

References operator*=().

operator=()

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

inline

assignment operator

    {
      this->build(old_vector);
    }

References build().

operator==()

bool oomph::DoubleVector::operator==

(

const DoubleVector &

v

)

== operator

  {
    // if v is not setup return false
    if (v.built() && !this->built())
    {
      return false;
    }
    else if (!v.built() && this->built())
    {
      return false;
    }
    else if (!v.built() && !this->built())
    {
      return true;
    }
    else
    {
      const double* v_values_pt = v.values_pt();
      unsigned nrow_local = this->nrow_local();
      for (unsigned i = 0; i < nrow_local; i++)
      {
        if (Values_pt[i] != v_values_pt[i])
        {
          return false;
        }
      }
      return true;
    }
  }

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

operator[]() [1/2]

double & oomph::DoubleVector::operator[]

(

int

i

)

[] access function to the (local) values of this vector

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

References i, oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Values_pt.

operator[]() [2/2]

const double & oomph::DoubleVector::operator[]

(

int

i

)

const

[] access function to the (local) values of this vector

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

References i, oomph::DistributableLinearAlgebraObject::nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Values_pt.

output() [1/2]

void oomph::DoubleVector::output	(	std::ostream &	outfile,
		const int &	output_precision = -1
	)		const

output the global contents of the vector

output the contents of the vector

  {
    // temp pointer to values
    double* temp;
 
    // 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[nrow];
      MPI_Allgatherv(Values_pt,
                     nrow_local,
                     MPI_DOUBLE,
                     temp,
                     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_pt;
    }
#else
    temp = Values_pt;
#endif
 
    // output
    // Store the precision so we can revert it.
    std::streamsize old_precision = 0;
    if (output_precision > 0)
    {
      old_precision = outfile.precision();
      outfile << std::setprecision(output_precision);
    }
 
    for (unsigned i = 0; i < nrow; i++)
    {
      outfile << i << " " << temp[i] << std::endl;
    }
 
    // Revert the precision.
    if (output_precision > 0)
    {
      outfile << std::setprecision(old_precision);
    }
 
    // clean up if requires
#ifdef OOMPH_HAS_MPI
    if (this->distributed() &&
        this->distribution_pt()->communicator_pt()->nproc() > 1)
    {
      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(), p, and Values_pt.

Referenced by output().

output() [2/2]

void oomph::DoubleVector::output ( std::string  filename, const int &  output_precision = -1  ) const

inline

output the global contents of the vector

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

References MergeRestartFiles::filename, and output().

output_local_values() [1/2]

void oomph::DoubleVector::output_local_values	(	std::ostream &	outfile,
		const int &	output_precision = -1
	)		const

output the local contents of the vector

  {
    // Number of local rows.
    unsigned nrow_local = this->nrow_local();
 
    // output
    // Store the precision so we can revert it.
    std::streamsize old_precision = 0;
    if (output_precision > 0)
    {
      old_precision = outfile.precision();
      outfile << std::setprecision(output_precision);
    }
 
    for (unsigned i = 0; i < nrow_local; i++)
    {
      outfile << i << " " << Values_pt[i] << std::endl;
    }
 
    // Revert the precision.
    if (output_precision > 0)
    {
      outfile << std::setprecision(old_precision);
    }
  }

References i, oomph::DistributableLinearAlgebraObject::nrow_local(), and Values_pt.

Referenced by output_local_values().

output_local_values() [2/2]

void oomph::DoubleVector::output_local_values ( std::string  filename, const int &  output_precision = -1  ) const

inline

output the local contents of the vector

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

References MergeRestartFiles::filename, and output_local_values().

output_local_values_with_offset() [1/2]

void oomph::DoubleVector::output_local_values_with_offset	(	std::ostream &	outfile,
		const int &	output_precision = -1
	)		const

output the local contents of the vector

output the local contents of the vector with the first row offset.

  {
    // Number of local rows.
    unsigned nrow_local = this->nrow_local();
 
    // First row on this processor.
    unsigned first_row = this->first_row();
 
    // output
    // Store the precision so we can revert it.
    std::streamsize old_precision = 0;
    if (output_precision > 0)
    {
      old_precision = outfile.precision();
      outfile << std::setprecision(output_precision);
    }
 
    for (unsigned i = 0; i < nrow_local; i++)
    {
      outfile << (i + first_row) << " " << Values_pt[i] << std::endl;
    }
 
    // Revert the precision.
    if (output_precision > 0)
    {
      outfile << std::setprecision(old_precision);
    }
  }

References oomph::DistributableLinearAlgebraObject::first_row(), i, oomph::DistributableLinearAlgebraObject::nrow_local(), and Values_pt.

Referenced by output_local_values_with_offset().

output_local_values_with_offset() [2/2]

void oomph::DoubleVector::output_local_values_with_offset ( std::string  filename, const int &  output_precision = -1  ) const

inline

output the local contents of the vector

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

References MergeRestartFiles::filename, and output_local_values_with_offset().

redistribute()

void oomph::DoubleVector::redistribute

(

const LinearAlgebraDistribution *const &

dist_pt

)

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 build 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 vector does not own its data (i.e. it 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))
    {
      // 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];
          }
        }
 
        // temporary storage for the new data
        double* temp_data = new double[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++)
          {
            temp_data[k + i] = Values_pt[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;
          MPI_Sendrecv(Values_pt + 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 + 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_pt;
        unsigned nrow_local = dist_pt->nrow_local();
        Values_pt = new double[nrow_local];
        for (unsigned i = 0; i < nrow_local; i++)
        {
          Values_pt[i] = temp_data[i];
        }
        delete[] 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 nrow_local = this->nrow_local();
        double* temp_data = new double[nrow_local];
        for (unsigned i = 0; i < nrow_local; i++)
        {
          temp_data[i] = Values_pt[i];
        }
 
        // clear and resize Values_pt
        delete[] Values_pt;
        Values_pt = new double[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_nrow_local(this->nrow_local());
        MPI_Allgatherv(temp_data,
                       my_nrow_local,
                       MPI_DOUBLE,
                       Values_pt,
                       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;
 
        // 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();
 
        // temp storage for the new data
        double* temp_data = new double[nrow_local];
 
        // copy the data
        for (unsigned i = 0; i < nrow_local; i++)
        {
          temp_data[i] = Values_pt[first_row + i];
        }
 
        // copy to Values_pt
        delete[] Values_pt;
        Values_pt = temp_data;
 
        // update the distribution
        this->build_distribution(dist_pt);
      }
 
      // copy the Distribution
      this->build_distribution(dist_pt);
    }
#endif
  }

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(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, and Values_pt.

Referenced by oomph::MumpsSolver::backsub(), oomph::Problem::calculate_continuation_derivatives_helper(), oomph::Problem::get_jacobian(), main(), oomph::Problem::newton_solve(), oomph::Problem::newton_solve_continuation(), oomph::ILUZeroPreconditioner< CCDoubleMatrix >::preconditioner_solve(), oomph::ILUZeroPreconditioner< CRDoubleMatrix >::preconditioner_solve(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::BlockPitchForkLinearSolver::solve(), oomph::CG< MATRIX >::solve(), oomph::BiCGStab< MATRIX >::solve(), oomph::GMRES< MATRIX >::solve(), oomph::AugmentedProblemGMRES::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), and oomph::SuperLUSolver::solve_transpose().

set_external_values() [1/2]

void oomph::DoubleVector::set_external_values ( const LinearAlgebraDistribution *const &  dist_pt, double *  external_values, bool  delete_external_values  )

inline

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.

    {
      // clean the memory
      this->clear();
 
      // Set the distribution
      this->build_distribution(dist_pt);
      // Say that it's built
      Built = true;
 
      // set the external values
      set_external_values(external_values, delete_external_values);
    }

References oomph::DistributableLinearAlgebraObject::build_distribution(), Built, and clear().

Referenced by oomph::OomphLibPreconditionerEpetraOperator::ApplyInverse(), oomph::Problem::get_jacobian(), and oomph::Problem::get_residuals().

set_external_values() [2/2]

void oomph::DoubleVector::set_external_values ( double *  external_values, bool  delete_external_values  )

inline

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.

    {
#ifdef PARANOID
      // check that this distribution is setup
      if (!this->distribution_built())
      {
        // 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 << "The distribution of the vector must be setup before "
                      << "external values can be set";
        throw OomphLibError(error_message.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      if (Internal_values)
      {
        delete[] Values_pt;
      }
      Values_pt = external_values;
      Internal_values = delete_external_values;
    }

References oomph::DistributableLinearAlgebraObject::distribution_built(), Internal_values, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and Values_pt.

values_pt() [1/2]

double* oomph::DoubleVector::values_pt ( )

inline

access function to the underlying values

    {
      return Values_pt;
    }

References Values_pt.

Referenced by oomph::DenseLU::backsub(), oomph::SuperLUSolver::backsub_serial(), oomph::SuperLUSolver::backsub_transpose_serial(), build(), oomph::Problem::calculate_continuation_derivatives_helper(), oomph::DoubleVectorHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::TrilinosEpetraHelpers::copy_to_oomphlib_vector(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_vector_view_data(), oomph::HypreHelpers::create_HYPRE_Vector(), dot(), main(), oomph::CRDoubleMatrix::multiply(), oomph::DenseDoubleMatrix::multiply(), oomph::CCDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), oomph::DenseDoubleMatrix::multiply_transpose(), oomph::CCDoubleMatrix::multiply_transpose(), oomph::Problem::newton_solve(), oomph::Problem::newton_solve_continuation(), oomph::MatrixBasedDiagPreconditioner::preconditioner_solve(), oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve(), oomph::DoubleMatrixBase::residual(), oomph::GMRES< MATRIX >::solve_helper(), oomph::AugmentedProblemGMRES::solve_helper(), oomph::DoubleVectorHelpers::split(), oomph::DoubleVectorHelpers::split_without_communication(), oomph::GMRESBlockPreconditioner::update(), oomph::GMRES< MATRIX >::update(), and oomph::AugmentedProblemGMRES::update().

values_pt() [2/2]

double* oomph::DoubleVector::values_pt ( ) const

inline

access function to the underlying values (const version)

    {
      return Values_pt;
    }

References Values_pt.

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const DoubleVector &  v  )

friend

Ouput operator for DoubleVector.

  {
    // Do the first value outside the loop to get the ", "s right.
    out << "[" << v[0];
 
    for (unsigned i = 1, ni = v.nrow_local(); i < ni; i++)
    {
      out << ", " << v[i];
    }
    out << "]";
 
    return out;
  }

Member Data Documentation

Built

bool oomph::DoubleVector::Built

private

indicates that the vector has been built and is usable

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

Internal_values

bool oomph::DoubleVector::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 set_external_values().

Values_pt

double* oomph::DoubleVector::Values_pt

private

the local vector

Referenced by build(), clear(), dot(), initialise(), max(), norm(), operator*=(), operator+=(), operator-=(), operator==(), operator[](), output(), output_local_values(), output_local_values_with_offset(), redistribute(), set_external_values(), and values_pt().

---

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

• double_vector.h
• double_vector.cc