#include <linear_algebra_distribution.h>

Public Member Functions
	LinearAlgebraDistribution ()

	LinearAlgebraDistribution (const OomphCommunicator &comm, const unsigned &first_row_, const unsigned &n_row_local, const unsigned &n_row=0)

	LinearAlgebraDistribution (const OomphCommunicator &comm, const unsigned &n_row, const bool &distributed_=true)

	LinearAlgebraDistribution (const OomphCommunicator *const comm_pt, const unsigned &first_row_, const unsigned &n_row_local, const unsigned &n_row=0)

	LinearAlgebraDistribution (const OomphCommunicator *const comm_pt, const unsigned &n_row, const bool &distributed_=true)

	LinearAlgebraDistribution (const LinearAlgebraDistribution &old_dist)
	Copy Constructor. More...

	LinearAlgebraDistribution (const LinearAlgebraDistribution *old_dist_pt)
	pointer based copy constructor More...

	~LinearAlgebraDistribution ()
	Destructor. More...

void	operator= (const LinearAlgebraDistribution &old_dist)
	Assignment Operator. More...

void	build (const OomphCommunicator *const comm_pt, const unsigned &first_row, const unsigned &nrow_local, const unsigned &nrow=0)

void	build (const OomphCommunicator *const comm_pt, const unsigned &nrow, const bool &distributed=true)

void	build (const LinearAlgebraDistribution &new_dist)
	helper method for the =assignment operator and copy constructor More...

void	build (const LinearAlgebraDistribution *new_dist_pt)

void	clear ()
	clears the distribution More...

unsigned	nrow () const
	access function to the number of global rows. More...

unsigned	nrow_local () const

unsigned	nrow_local (const unsigned &p) const

unsigned	first_row () const

unsigned	first_row (const unsigned &p) const
	access function for the first row on the p-th processor More...

bool	distributed () const

OomphCommunicator *	communicator_pt () const
	const access to the communicator pointer More...

bool	built () const

bool	operator== (const LinearAlgebraDistribution &other_dist) const
	== Operator More...

bool	operator!= (const LinearAlgebraDistribution &other_dist) const
	!= operator More...

unsigned	global_to_local_row_map (const unsigned &global_i) const
	return the local index corresponding to the global index More...

unsigned	rank_of_global_row (const unsigned i) const
	return the processor rank of the global row number i More...

Vector< unsigned >	nrow_local_vector () const
	return the nrow_local Vector More...

Vector< unsigned >	first_row_vector () const
	return the first_row Vector More...

Private Attributes
unsigned	Nrow
	the number of global rows More...

Vector< unsigned >	Nrow_local
	the number of local rows on the processor More...

Vector< unsigned >	First_row
	the first row on this processor More...

bool	Distributed

OomphCommunicator *	Comm_pt
	the pointer to the MPI communicator object in this distribution More...

Friends
std::ostream &	operator<< (std::ostream &stream, LinearAlgebraDistribution &dist)
	<< operator More...

Detailed Description

Describes the distribution of a distributable linear algebra type object. Typically this is a container (such as a DoubleVector) or an operator (e.g Preconditioner or LinearSolver). This object is used in both serial and parallel implementations. In the serial context (no MPI) this just contains an integer indicating the number of rows. In parallel either each processor holds a subset of the set of global rows. (each processor contains only a single continuous block of rows - parametised with variables denoting the first row and the number of local rows) or, all rows are be duplicated across all processors. In parallel this object also contains an OomphCommunicator object which primarily contains the MPI_Comm communicator associated with this object.

Constructor & Destructor Documentation

◆ LinearAlgebraDistribution() [1/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution ( )

inline

Default Constructor - creates a Distribution that has not been setup

68 : Comm_pt(0) {}

oomph::LinearAlgebraDistribution::Comm_pt

OomphCommunicator * Comm_pt

the pointer to the MPI communicator object in this distribution

Definition: linear_algebra_distribution.h:425

◆ LinearAlgebraDistribution() [2/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution	(	const OomphCommunicator &	comm,
		const unsigned &	first_row_,
		const unsigned &	n_row_local,
		const unsigned &	n_row = `0`
	)

inline

Constructor. Takes the first_row, nrow_local (both for this processor) and nrow as arguments. If nrow is not provided or equal to 0 then it will be computed automatically

       : Comm_pt(0)
     {
       this->build(&comm, first_row_, n_row_local, n_row);
     };

References build().

◆ LinearAlgebraDistribution() [3/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution	(	const OomphCommunicator &	comm,
		const unsigned &	n_row,
		const bool &	distributed_ = `true`
	)

inline

Constructor. Takes the number of global rows and uniformly distributes them over the processors if distributed = true (default), if distributed = false then every row is duplicated on every processor

       : Comm_pt(0)
     {
       this->build(&comm, n_row, distributed_);
     };

References build().

◆ LinearAlgebraDistribution() [4/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution	(	const OomphCommunicator *const	comm_pt,
		const unsigned &	first_row_,
		const unsigned &	n_row_local,
		const unsigned &	n_row = `0`
	)

inline

Constructor. Takes the first_row, nrow_local (both for this processor) and nrow as arguments. If nrow is not provided or equal to 0 then it will be computed automatically

       : Comm_pt(0)
     {
       this->build(comm_pt, first_row_, n_row_local, n_row);
     };

References build().

◆ LinearAlgebraDistribution() [5/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution	(	const OomphCommunicator *const	comm_pt,
		const unsigned &	n_row,
		const bool &	distributed_ = `true`
	)

inline

Constructor. Takes the number of global rows and uniformly distributes them over the processors if distributed = true (default), if distributed = false then every row is duplicated on every processor

       : Comm_pt(0)
     {
       this->build(comm_pt, n_row, distributed_);
     };

References build().

◆ LinearAlgebraDistribution() [6/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution ( const LinearAlgebraDistribution & old_dist )

inline

Copy Constructor.

       : Comm_pt(0)
     {
       this->build(old_dist);
     }

References build().

◆ LinearAlgebraDistribution() [7/7]

oomph::LinearAlgebraDistribution::LinearAlgebraDistribution ( const LinearAlgebraDistribution * old_dist_pt )

inline

pointer based copy constructor

       : Comm_pt(0)
     {
       this->build(old_dist_pt);
     }

References build().

◆ ~LinearAlgebraDistribution()

oomph::LinearAlgebraDistribution::~LinearAlgebraDistribution ( )

inline

Destructor.

     {
       delete Comm_pt;
     }

References Comm_pt.

Member Function Documentation

◆ build() [1/4]

void oomph::LinearAlgebraDistribution::build ( const LinearAlgebraDistribution & new_dist )

helper method for the =assignment operator and copy constructor

Copy the argument distribution. Also a helper method for the =assignment operator and copy constructor

   {
     // delete the existing storage
     First_row.clear();
     Nrow_local.clear();
  
     // if new_dist is not setup
     if (new_dist.communicator_pt() == 0)
     {
       delete Comm_pt;
       Comm_pt = 0;
       Distributed = true;
       Nrow = 0;
     }
     else
     {
       // copy the communicator
       delete Comm_pt;
       Comm_pt = new OomphCommunicator(*new_dist.communicator_pt());
  
       // the new distribution is distributed
       if (new_dist.distributed())
       {
         First_row = new_dist.first_row_vector();
         Nrow_local = new_dist.nrow_local_vector();
  
         Distributed = true;
       }
       // else if the new ditribution is not distributed
       else
       {
         Distributed = false;
       }
       Nrow = new_dist.nrow();
     }
   }

References Comm_pt, communicator_pt(), distributed(), Distributed, First_row, first_row_vector(), nrow(), Nrow, Nrow_local, and nrow_local_vector().

◆ build() [2/4]

void oomph::LinearAlgebraDistribution::build ( const LinearAlgebraDistribution * new_dist_pt )

inline

Copy the argument distribution. Also a helper method for the =assignment operator and copy constructor

     {
       this->build(*new_dist_pt);
     }

References build().

◆ build() [3/4]

void oomph::LinearAlgebraDistribution::build	(	const OomphCommunicator *const	comm_pt,
		const unsigned &	first_row,
		const unsigned &	local_nrow,
		const unsigned &	global_nrow = `0`
	)

Sets the distribution. Takes first_row, nrow_local and nrow as arguments. If nrow is not provided or equal to 0 then it is computed automatically

Sets the distribution. Takes first_row, local_nrow and global_nrow as arguments. If global_nrow is not provided or equal to 0 then it is computed automatically

   {
     // copy the communicator
     delete Comm_pt;
     Comm_pt = new OomphCommunicator(*comm_pt);
  
     // get the rank and the number of processors
     int my_rank = Comm_pt->my_rank();
     int nproc = Comm_pt->nproc();
  
     // resize the storage
     First_row.clear();
     First_row.resize(nproc);
     Nrow_local.clear();
     Nrow_local.resize(nproc);
  
     // set first row and local nrow for this processor
     First_row[my_rank] = first_row;
     Nrow_local[my_rank] = local_nrow;
  
 #ifdef OOMPH_HAS_MPI
     // gather the First_row vector
     unsigned my_nrow_local = Nrow_local[my_rank];
     MPI_Allgather(&my_nrow_local,
                   1,
                   MPI_UNSIGNED,
                   &Nrow_local[0],
                   1,
                   MPI_UNSIGNED,
                   Comm_pt->mpi_comm());
  
     // gather the Nrow_local vector
     unsigned my_first_row = First_row[my_rank];
     MPI_Allgather(&my_first_row,
                   1,
                   MPI_UNSIGNED,
                   &First_row[0],
                   1,
                   MPI_UNSIGNED,
                   Comm_pt->mpi_comm());
 #endif
  
     // if global nrow is not provided then compute by summing local_nrow over
     // all processors
     if (global_nrow == 0)
     {
       if (nproc == 1)
       {
         Nrow = local_nrow;
       }
       else
       {
         Nrow = 0;
         for (int p = 0; p < nproc; p++)
         {
           Nrow += Nrow_local[p];
         }
       }
     }
     else
     {
       Nrow = global_nrow;
     }
  
     // the distribution is true, unless we only have 1 processor
     if (nproc != 1)
     {
       Distributed = true;
     }
     else
     {
       Distributed = false;
     }
  
 #ifdef OOMPH_HAS_MPI
 #ifdef PARANOID
     // paranoid check that the distribution works
  
  
     // check that none of the processors partition overlap
     for (int p = 0; p < nproc; p++)
     {
       if (Nrow_local[p] > 0)
       {
         for (int pp = p + 1; pp < nproc; pp++)
         {
           if (Nrow_local[pp] > 0)
           {
             if ((First_row[p] >= First_row[pp] &&
                  First_row[p] < First_row[pp] + Nrow_local[pp]) ||
                 (First_row[p] + Nrow_local[p] - 1 >= First_row[pp] &&
                  First_row[p] + Nrow_local[p] - 1 <
                    First_row[pp] + Nrow_local[pp]))
             {
               std::ostringstream error_message;
               error_message
                 << "The distributed rows on processor " << p
                 << " and processor " << pp << " overlap.\n"
                 << "Processor " << p << " : first_row = " << First_row[p]
                 << ", nrow = " << Nrow_local[p] << ".\n"
                 << "Processor " << pp << " : first_row = " << First_row[pp]
                 << ", nrow = " << Nrow_local[pp] << ".\n";
               throw OomphLibWarning(
                 error_message.str(),
                 "LinearAlgebraDistribution::distribute(...)",
                 OOMPH_EXCEPTION_LOCATION);
             }
           }
         }
       }
     }
  
     // check that no processor has a row with a global row index greater than
     // the number of global rows
     for (int p = 0; p < nproc; p++)
     {
       if (First_row[p] + Nrow_local[p] > Nrow)
       {
         std::ostringstream error_message;
         error_message << "Processor " << p << " contains rows " << First_row[p]
                       << " to " << First_row[p] + Nrow_local[p] - 1
                       << " but there are only " << Nrow << " to be distributed."
                       << std::endl;
         throw OomphLibWarning(error_message.str(),
                               "LinearAlgebraDistribution::distribute(...)",
                               OOMPH_EXCEPTION_LOCATION);
       }
     }
 #endif
 #endif
   }

References Comm_pt, Distributed, first_row(), First_row, oomph::OomphCommunicator::my_rank(), oomph::OomphCommunicator::nproc(), Nrow, Nrow_local, OOMPH_EXCEPTION_LOCATION, and p.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::Problem::assign_eqn_numbers(), build(), oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::LinearAlgebraDistributionHelpers::concatenate(), oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::FoldHandler::FoldHandler(), oomph::CRDoubleMatrix::get_matrix_transpose(), oomph::HopfHandler::HopfHandler(), LinearAlgebraDistribution(), main(), oomph::SumOfMatrices::multiply(), operator=(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::BlockHopfLinearSolver::solve(), oomph::MumpsSolver::solve(), oomph::FoldHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_block_system(), oomph::HopfHandler::solve_complex_system(), oomph::BlockHopfLinearSolver::solve_for_two_rhs(), oomph::FoldHandler::solve_full_system(), oomph::HopfHandler::solve_full_system(), oomph::HopfHandler::solve_standard_system(), oomph::FoldHandler::~FoldHandler(), and oomph::HopfHandler::~HopfHandler().

◆ build() [4/4]

void oomph::LinearAlgebraDistribution::build	(	const OomphCommunicator *const	comm_pt,
		const unsigned &	global_nrow,
		const bool &	distribute = `true`
	)

Build the LinearAlgebraDistribution. if distributed = true (default) then uniformly distribute nrow over all processors where processors 0 holds approximately the first nrow/n_proc, processor 1 holds the next nrow/n_proc and so on... or if distributed = false then every row is held on every processor

Uniformly distribute global_nrow over all processors where processors 0 holds approximately the first global_nrow/n_proc, processor 1 holds the next global_nrow/n_proc and so on...

   {
     // copy the communicator
     delete Comm_pt;
     Comm_pt = new OomphCommunicator(*comm_pt);
  
     // delete existing storage
     First_row.clear();
     Nrow_local.clear();
  
     // set global nrow
     Nrow = global_nrow;
  
     // store the distributed flag
     Distributed = distribute;
  
 #ifdef OOMPH_HAS_MPI
  
     // if distributed object then compute uniform distribution
     if (distribute == true)
     {
       // get the number of processors
       int nproc = Comm_pt->nproc();
  
       // resize the storage
       First_row.resize(nproc);
       Nrow_local.resize(nproc);
  
       // compute first row
       for (int p = 0; p < nproc; p++)
       {
         First_row[p] =
           unsigned((double(p) / double(nproc)) * double(global_nrow));
       }
  
       // compute local nrow
       for (int p = 0; p < nproc - 1; p++)
       {
         Nrow_local[p] = First_row[p + 1] - First_row[p];
       }
       Nrow_local[nproc - 1] = global_nrow - First_row[nproc - 1];
     }
 #endif
   }

References Comm_pt, Distributed, First_row, oomph::OomphCommunicator::nproc(), Nrow, Nrow_local, and p.

◆ built()

bool oomph::LinearAlgebraDistribution::built ( ) const

inline

if the communicator_pt is null then the distribution is not setup then false is returned, otherwise return true

     {
       if (Comm_pt == 0)
       {
         return false;
       }
       return true;
     }

References Comm_pt.

Referenced by oomph::CRDoubleMatrix::add(), oomph::MumpsSolver::backsub(), oomph::DoubleVector::build(), oomph::DoubleMultiVector::build(), oomph::CRDoubleMatrixHelpers::concatenate(), oomph::LinearAlgebraDistributionHelpers::concatenate(), oomph::CRDoubleMatrixHelpers::concatenate_without_communication(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::DistributableLinearAlgebraObject::distribution_built(), main(), oomph::TrilinosEpetraHelpers::multiply(), oomph::LagrangeEnforcedFlowPreconditioner::preconditioner_solve(), oomph::NavierStokesSchurComplementPreconditioner::preconditioner_solve(), oomph::SpaceTimeNavierStokesSubsidiaryPreconditioner::preconditioner_solve(), oomph::BlockPitchForkLinearSolver::resolve(), oomph::DoubleMultiVector::shallow_build(), oomph::MumpsSolver::solve(), and oomph::CG< MATRIX >::solve().

◆ clear()

void oomph::LinearAlgebraDistribution::clear ( )

inline

clears the distribution

     {
       // delete the communicator
       delete Comm_pt;
       Comm_pt = 0;
  
       // delete first_row and nrow_local
       First_row.clear();
       Nrow_local.clear();
  
       // zero Nrow
       Nrow = 0;
     }

References Comm_pt, First_row, Nrow, and Nrow_local.

Referenced by oomph::DistributableLinearAlgebraObject::clear_distribution(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::MGSolver< DIM >::setup_mg_structures(), and oomph::DoubleVectorHelpers::split_without_communication().

◆ communicator_pt()

OomphCommunicator* oomph::LinearAlgebraDistribution::communicator_pt ( ) const

inline

const access to the communicator pointer

     {
       return Comm_pt;
     }

References Comm_pt.

Referenced by build(), oomph::Problem::calculate_continuation_derivatives_fd_helper(), oomph::Problem::calculate_continuation_derivatives_helper(), oomph::CRDoubleMatrixHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate_without_communication(), oomph::CRDoubleMatrixHelpers::concatenate_without_communication(), oomph::TrilinosEpetraHelpers::copy_to_oomphlib_vector(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix_for_aztecoo(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_map(), oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::HypreHelpers::create_HYPRE_Vector(), oomph::DoubleVectorHaloScheme::DoubleVectorHaloScheme(), oomph::SuperLUSolver::factorise(), oomph::MumpsSolver::factorise(), oomph::Problem::get_jacobian(), oomph::CRDoubleMatrix::global_matrix(), oomph::HypreInterface::hypre_matrix_setup(), oomph::HypreInterface::hypre_solver_setup(), oomph::BlockPreconditioner< MATRIX >::internal_get_block(), oomph::MGSolver< DIM >::interpolation_matrix_set(), oomph::HelmholtzMGPreconditioner< DIM >::interpolation_matrix_set(), oomph::TrilinosEpetraHelpers::multiply(), oomph::DenseDoubleMatrix::multiply(), oomph::CCDoubleMatrix::multiply(), oomph::DenseDoubleMatrix::multiply_transpose(), oomph::CCDoubleMatrix::multiply_transpose(), oomph::Problem::newton_solve_continuation(), operator==(), oomph::DoubleMultiVector::output(), oomph::DoubleVector::output(), oomph::DoubleMultiVector::redistribute(), oomph::DoubleVector::redistribute(), oomph::CRDoubleMatrix::redistribute(), oomph::MGSolver< DIM >::self_test(), oomph::MatrixVectorProduct::setup(), oomph::Preconditioner::setup(), oomph::MGSolver< DIM >::setup_mg_structures(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures(), oomph::MGSolver< DIM >::setup_smoothers(), oomph::HelmholtzMGPreconditioner< DIM >::setup_smoothers(), oomph::DenseLU::solve(), oomph::TrilinosAztecOOSolver::solve(), oomph::MumpsSolver::solve(), oomph::AugmentedProblemGMRES::solve_helper(), oomph::DoubleVectorHelpers::split(), and oomph::DoubleVectorHelpers::split_without_communication().

◆ distributed()

bool oomph::LinearAlgebraDistribution::distributed ( ) const

inline

access function to the distributed - indicates whether the distribution is serial or distributed

     {
       return Distributed;
     }

References Distributed.

Referenced by oomph::SuperLUSolver::backsub_serial(), oomph::SuperLUSolver::backsub_transpose_serial(), build(), oomph::Problem::calculate_continuation_derivatives_fd_helper(), oomph::Problem::calculate_continuation_derivatives_helper(), oomph::Smoother::check_validity_of_solve_helper_inputs(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_map(), oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::HypreHelpers::create_HYPRE_Vector(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DoubleVectorHaloScheme::DoubleVectorHaloScheme(), oomph::Problem::get_eigenproblem_matrices(), oomph::Problem::get_jacobian(), oomph::BlockPreconditioner< MATRIX >::internal_get_block(), main(), oomph::Problem::newton_solve_continuation(), operator==(), oomph::DoubleMultiVector::redistribute(), oomph::DoubleVector::redistribute(), oomph::CRDoubleMatrix::redistribute(), oomph::MatrixVectorProduct::setup(), oomph::DenseLU::solve(), oomph::SuperLUSolver::solve(), oomph::MumpsSolver::solve(), 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(), and oomph::SuperLUSolver::solve_transpose().

◆ first_row() [1/2]

unsigned oomph::LinearAlgebraDistribution::first_row ( ) const

inline

access function for the first row on this processor. If not distributed then this is just zero.

     {
       // return the first row
 #ifdef OOMPH_HAS_MPI
       if (Distributed)
       {
 #ifdef PARANOID
         if (Comm_pt == 0)
         {
           throw OomphLibError(
             "LinearAlgebraDistribution has not been built : Comm_pt == 0.",
             OOMPH_CURRENT_FUNCTION,
             OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         return First_row[Comm_pt->my_rank()];
       }
       else
       {
         return 0;
       }
 #else
       return 0;
 #endif
     }

References Comm_pt, Distributed, First_row, oomph::OomphCommunicator::my_rank(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::NavierStokesSchurComplementPreconditioner::assemble_inv_press_and_veloc_mass_matrix_diagonal(), oomph::PressureBasedSolidLSCPreconditioner::assemble_mass_matrix_diagonal(), build(), oomph::CRDoubleMatrixHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix_for_aztecoo(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_map(), oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::HypreHelpers::create_HYPRE_Vector(), create_matrix_ascend_col_row(), create_vector_ascend_row(), oomph::DoubleVectorHaloScheme::DoubleVectorHaloScheme(), oomph::DistributableLinearAlgebraObject::first_row(), oomph::Problem::global_dof_pt(), oomph::HypreInterface::hypre_solve(), oomph::BlockPreconditioner< MATRIX >::index_in_block(), oomph::BlockPreconditioner< MATRIX >::internal_dof_number(), oomph::BlockPreconditioner< MATRIX >::internal_index_in_dof(), main(), operator==(), oomph::PitchForkHandler::PitchForkHandler(), rank_of_global_row(), oomph::DoubleMultiVector::redistribute(), oomph::DoubleVector::redistribute(), oomph::CRDoubleMatrix::redistribute(), and oomph::CRDoubleMatrix::sparse_indexed_output_with_offset().

◆ first_row() [2/2]

unsigned oomph::LinearAlgebraDistribution::first_row ( const unsigned & p ) const

inline

access function for the first row on the p-th processor

     {
 #ifdef PARANOID
       if (Comm_pt == 0)
       {
         throw OomphLibError(
           "LinearAlgebraDistribution has not been built : Comm_pt == 0.",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
       if (p >= unsigned(Comm_pt->nproc()))
       {
         std::ostringstream error_message;
         error_message << "Requested first_row(" << p
                       << "), but this distribution is defined "
                       << "on " << Comm_pt->nproc() << "processors.";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
  
 #endif
  
       // return the first row
 #ifdef OOMPH_HAS_MPI
       if (Distributed)
       {
         return First_row[p];
       }
       else
       {
         return 0;
       }
 #else
       return 0;
 #endif
     }

References Comm_pt, Distributed, First_row, oomph::OomphCommunicator::nproc(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

◆ first_row_vector()

Vector<unsigned> oomph::LinearAlgebraDistribution::first_row_vector ( ) const

inline

return the first_row Vector

     {
       return First_row;
     }

References First_row.

Referenced by build().

◆ global_to_local_row_map()

unsigned oomph::LinearAlgebraDistribution::global_to_local_row_map ( const unsigned & global_i ) const

inline

return the local index corresponding to the global index

     {
 #ifdef PARANOID
       if (global_i >= Nrow)
       {
         throw OomphLibError(
           "Requested global row outside the number of global rows",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
 #endif
       int local_i = static_cast<int>(global_i);
       int p = 0;
       while ((int)(local_i - (int)nrow_local(p)) >= 0)
       {
         local_i -= (int)nrow_local(p);
         p++;
       }
       return (unsigned)local_i;
     }

References int(), Nrow, nrow_local(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

◆ nrow()

unsigned oomph::LinearAlgebraDistribution::nrow ( ) const

inline

access function to the number of global rows.

     {
       return Nrow;
     }

References Nrow.

Referenced by oomph::AugmentedProblemGMRES::apply_schur_complement_preconditioner(), oomph::NavierStokesSchurComplementPreconditioner::assemble_inv_press_and_veloc_mass_matrix_diagonal(), oomph::PressureBasedSolidLSCPreconditioner::assemble_mass_matrix_diagonal(), oomph::MumpsSolver::backsub(), build(), oomph::SuperLUSolver::clean_up_memory(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_matrix(), oomph::TrilinosEpetraHelpers::create_distributed_epetra_vector(), oomph::TrilinosEpetraHelpers::create_epetra_map(), oomph::BlockPreconditioner< MATRIX >::get_concatenated_block(), oomph::Problem::get_eigenproblem_matrices(), oomph::Problem::get_jacobian(), oomph::Problem::get_residuals(), main(), oomph::CRDoubleMatrix::multiply(), oomph::CRDoubleMatrix::multiply_transpose(), oomph::Problem::ndof(), oomph::DistributableLinearAlgebraObject::nrow(), operator==(), oomph::DoubleMultiVector::redistribute(), oomph::DoubleVector::redistribute(), oomph::CRDoubleMatrix::redistribute(), and oomph::BlockPreconditioner< MATRIX >::set_replacement_dof_block().

◆ nrow_local() [1/2]

unsigned oomph::LinearAlgebraDistribution::nrow_local ( ) const

inline

access function for the num of local rows on this processor. If no MPI then Nrow is returned.

     {
       // return the nrow_local
 #ifdef OOMPH_HAS_MPI
       if (Distributed)
       {
 #ifdef PARANOID
         if (Comm_pt == 0)
         {
           throw OomphLibError(
             "LinearAlgebraDistribution has not been built : Comm_pt == 0.",
             "LinearAlgebraDistribution::nrow_local()",
             OOMPH_EXCEPTION_LOCATION);
         }
 #endif
  
         return Nrow_local[Comm_pt->my_rank()];
       }
       else
       {
         return Nrow;
       }
 #else
       return Nrow;
 #endif
     }

References Comm_pt, Distributed, oomph::OomphCommunicator::my_rank(), Nrow, Nrow_local, and OOMPH_EXCEPTION_LOCATION.

◆ nrow_local() [2/2]

unsigned oomph::LinearAlgebraDistribution::nrow_local ( const unsigned & p ) const

inline

access function for the num of local rows on this processor. If no MPI the nrow is returned

     {
 #ifdef PARANOID
       if (Comm_pt == 0)
       {
         throw OomphLibError(
           "LinearAlgebraDistribution has not been built : Comm_pt == 0.",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
       if (p >= unsigned(Comm_pt->nproc()))
       {
         std::ostringstream error_message;
         error_message << "Requested nrow_local(" << p
                       << "), but this distribution is defined "
                       << "on " << Comm_pt->nproc() << "processors.";
         throw OomphLibError(error_message.str(),
                             OOMPH_CURRENT_FUNCTION,
                             OOMPH_EXCEPTION_LOCATION);
       }
 #endif
  
       // return the nrow_local
 #ifdef OOMPH_HAS_MPI
       if (Distributed)
       {
         return Nrow_local[p];
       }
       else
       {
         return Nrow;
       }
 #else
       return Nrow;
 #endif
     }

References Comm_pt, Distributed, oomph::OomphCommunicator::nproc(), Nrow, Nrow_local, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and p.

◆ nrow_local_vector()

Vector<unsigned> oomph::LinearAlgebraDistribution::nrow_local_vector ( ) const

inline

return the nrow_local Vector

     {
       return Nrow_local;
     }

References Nrow_local.

Referenced by build().

◆ operator!=()

bool oomph::LinearAlgebraDistribution::operator!= ( const LinearAlgebraDistribution & other_dist ) const

inline

!= operator

     {
       return !(*this == other_dist);
     }

◆ operator=()

void oomph::LinearAlgebraDistribution::operator= ( const LinearAlgebraDistribution & old_dist )

inline

Assignment Operator.

     {
       this->build(old_dist);
     }

References build().

◆ operator==()

bool oomph::LinearAlgebraDistribution::operator== ( const LinearAlgebraDistribution & other_dist ) const

== Operator

operator==

   {
 #ifdef OOMPH_HAS_MPI
     // compare the communicators
     if (!((*Comm_pt) == (*other_dist.communicator_pt())))
     {
       return false;
     }
  
     // compare Distributed
     if (Distributed != other_dist.distributed())
     {
       return false;
     }
  
     // if not distributed compare nrow
     if (!Distributed)
     {
       if (other_dist.nrow() == Nrow)
       {
         return true;
       }
       return false;
     }
  
     // compare
     bool flag = true;
     int nproc = Comm_pt->nproc();
     for (int i = 0; i < nproc && flag == true; i++)
     {
       if (other_dist.first_row(i) != First_row[i] ||
           other_dist.nrow_local(i) != Nrow_local[i])
       {
         flag = false;
       }
     }
     return flag;
 #else
     if (other_dist.nrow() == Nrow)
     {
       return true;
     }
     return false;
 #endif
   }

References Comm_pt, communicator_pt(), distributed(), Distributed, first_row(), First_row, i, oomph::OomphCommunicator::nproc(), nrow(), Nrow, nrow_local(), and Nrow_local.

◆ rank_of_global_row()

unsigned oomph::LinearAlgebraDistribution::rank_of_global_row ( const unsigned i ) const

inline

return the processor rank of the global row number i

     {
       unsigned p = 0;
       while (i < first_row(p) || i >= first_row(p) + nrow_local(p))
       {
         p++;
       }
       return p;
     }

References first_row(), i, nrow_local(), and p.

Referenced by oomph::CRDoubleMatrixHelpers::concatenate(), oomph::DoubleVectorHelpers::concatenate(), oomph::DoubleVectorHaloScheme::DoubleVectorHaloScheme(), and oomph::BlockPreconditioner< MATRIX >::index_in_block().

Friends And Related Function Documentation

◆ operator<<

std::ostream& operator<<	(	std::ostream &	stream,
		LinearAlgebraDistribution &	dist
	)

friend

<< operator

   {
     stream << "nrow()=" << dist.nrow() << ", first_row()=" << dist.first_row()
            << ", nrow_local()=" << dist.nrow_local()
            << ", distributed()=" << dist.distributed() << std::endl;
     return stream;
   }

Member Data Documentation

◆ Comm_pt

OomphCommunicator* oomph::LinearAlgebraDistribution::Comm_pt

private

the pointer to the MPI communicator object in this distribution

Referenced by build(), built(), clear(), communicator_pt(), first_row(), nrow_local(), operator==(), and ~LinearAlgebraDistribution().

◆ Distributed

bool oomph::LinearAlgebraDistribution::Distributed

private

flag to indicate whether this distribution describes an object that is distributed over the processors of Comm_pt (true) or duplicated over the processors of Comm_pt (false)

Referenced by build(), distributed(), first_row(), nrow_local(), and operator==().

◆ First_row

Vector<unsigned> oomph::LinearAlgebraDistribution::First_row

private

the first row on this processor

Referenced by build(), clear(), first_row(), first_row_vector(), and operator==().

◆ Nrow

unsigned oomph::LinearAlgebraDistribution::Nrow

private

the number of global rows

Referenced by build(), clear(), global_to_local_row_map(), nrow(), nrow_local(), and operator==().

◆ Nrow_local

Vector<unsigned> oomph::LinearAlgebraDistribution::Nrow_local

private

the number of local rows on the processor

Referenced by build(), clear(), nrow_local(), nrow_local_vector(), and operator==().

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

Public Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ LinearAlgebraDistribution() [1/7]

◆ LinearAlgebraDistribution() [2/7]

◆ LinearAlgebraDistribution() [3/7]

◆ LinearAlgebraDistribution() [4/7]

◆ LinearAlgebraDistribution() [5/7]

◆ LinearAlgebraDistribution() [6/7]

◆ LinearAlgebraDistribution() [7/7]

◆ ~LinearAlgebraDistribution()

Member Function Documentation

◆ build() [1/4]

◆ build() [2/4]

◆ build() [3/4]

◆ build() [4/4]

◆ built()

◆ clear()

◆ communicator_pt()

◆ distributed()

◆ first_row() [1/2]

◆ first_row() [2/2]

◆ first_row_vector()

◆ global_to_local_row_map()

◆ nrow()

◆ nrow_local() [1/2]

◆ nrow_local() [2/2]

◆ nrow_local_vector()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ rank_of_global_row()

Friends And Related Function Documentation

◆ operator<<

Member Data Documentation

◆ Comm_pt

◆ Distributed

◆ First_row

◆ Nrow

◆ Nrow_local