#include "generic.h"

Functions
template<typename myType >
void	construct_vector (myType given_array[], unsigned given_arraysize, Vector< myType > &result_vector)

template<typename myType >
void	output_vector (Vector< myType > &given_vector)

void	create_vector_ascend_row (unsigned const nrow, const OomphCommunicator *const comm_pt, bool const distributed, DoubleVector &my_vec)

void	fill_in_sub_vectors (const OomphCommunicator *const comm_pt, const bool distributed, Vector< unsigned > &dimvector, Vector< DoubleVector > &my_vecs)

void	create_vectors_to_cat (const unsigned nvectors, unsigned dimarray[], const OomphCommunicator *const comm_pt, Vector< DoubleVector > &my_vecs)

int	main (int argc, char *argv[])

Function Documentation

◆ construct_vector()

template<typename myType >

void construct_vector	(	myType	given_array[],
		unsigned	given_arraysize,
		Vector< myType > &	result_vector
	)

 {
   // Clear and reserve the required memory.
   result_vector.clear();
   result_vector.reserve(given_arraysize);
  
   for (unsigned i = 0; i < given_arraysize; i++) 
   {
     result_vector.push_back(given_array[i]);
   }
 }

References i.

Referenced by create_vectors_to_cat().

◆ create_vector_ascend_row()

void create_vector_ascend_row	(	unsigned const	nrow,
		const OomphCommunicator *const	comm_pt,
		bool const	distributed,
		DoubleVector &	my_vec
	)

 {  
   // Clear the block
   my_vec.clear();
   
   // Create the distribution.
   LinearAlgebraDistribution distri(comm_pt,nrow,distributed);
  
   // Build the vector
   my_vec.build(distri,0.0);
  
   // The number of rows this processor is responsible for.
   unsigned nrow_local = distri.nrow_local();
   
   // The first_row will be used as an offset for the values to insert.
   unsigned first_row = distri.first_row();
  
   // Fill in values...
   for (unsigned row_i = 0; row_i < nrow_local; row_i++)
   {
     my_vec[row_i] = first_row + row_i + 1; // Use natural numbers
   }
 }

References oomph::DoubleVector::build(), oomph::DoubleVector::clear(), oomph::LinearAlgebraDistribution::first_row(), and oomph::LinearAlgebraDistribution::nrow_local().

Referenced by fill_in_sub_vectors().

◆ create_vectors_to_cat()

void create_vectors_to_cat	(	const unsigned	nvectors,
		unsigned	dimarray[],
		const OomphCommunicator *const	comm_pt,
		Vector< DoubleVector > &	my_vecs
	)

 {
   // Convert dimarray into a Vector so it is easier to manage.
   Vector<unsigned> dimvector;
   construct_vector(dimarray,nvectors,dimvector);
   
   // Fill in each sub DoubleVector using create_double_vector_ascend_row(...)
   bool distributed = true;
   fill_in_sub_vectors(comm_pt,distributed,dimvector,my_vecs);
 }

References construct_vector(), and fill_in_sub_vectors().

Referenced by main().

◆ fill_in_sub_vectors()

void fill_in_sub_vectors	(	const OomphCommunicator *const	comm_pt,
		const bool	distributed,
		Vector< unsigned > &	dimvector,
		Vector< DoubleVector > &	my_vecs
	)

 {
   unsigned nvectors = my_vecs.size();
  
   for (unsigned vec_i = 0; vec_i < nvectors; vec_i++) 
   {
     unsigned vec_size = dimvector[vec_i];
     create_vector_ascend_row(vec_size,comm_pt,distributed,
                              my_vecs[vec_i]);
   }
 }

References create_vector_ascend_row().

Referenced by create_vectors_to_cat().

◆ main()

int main	(	int argc	,
		char *	argv[]
	)

Driver code: Testing DoubleVectorHelpers::concatenate(...)

We concatenate uniformly distributed DoubleVectors. The vectors v1, v2, and v3 have increasing entries with lengths 7, 5 and 3 as depicted below:

v1 v2 v3 [1 [1 [1 2 2 2 3 3 3] 4 4 5 5] 6 7]

The script validate.sh should run this driver on 1, 2, 3 and 4 cores.

Communication is required and the order of the entries is preserved. We demonstrate this on two cores, p0 and p1: v1 p0 p1 [1 [4 2 5 3] 6 7]

v2 p0 p1 [1 [3 2] 4 5]

v3 p0 p1 [1] [2 3]

Result vector: p0 p1 [1 [1 2 2 3 3 4 4 5 5 6 1 7] 2 3]

 {
 #ifdef OOMPH_HAS_MPI
   // Initialise MPI
   MPI_Helpers::init(argc,argv);
 #endif
  
   // Get the global oomph-lib communicator 
   const OomphCommunicator* const comm_pt = MPI_Helpers::communicator_pt();
   
   // How many vectors to concatenate?
   unsigned nvectors = 3;
  
   // Supply the length of the vectors
   unsigned dimarray[] = {7,5,3};
   
   // The data structure to store the DoubleVectors to concatenate
   Vector<DoubleVector> in_vector(nvectors);
   
   // Create the matrices to concatenate.
   create_vectors_to_cat(nvectors,dimarray,comm_pt,in_vector);
  
   // The result vector.
   DoubleVector out_vector;
   
   // Call the concatenate function.
   DoubleVectorHelpers::concatenate(in_vector,out_vector);
  
   // output the result matrix
   unsigned my_rank = comm_pt->my_rank();
   unsigned nproc = comm_pt->nproc();
  
   // Output data from out_vector:
   // nrow()
   // first_row
   // nrow_local()
   // distributed()
   // values()
   
   std::ostringstream out_stream;
   out_stream << "out_NP" << nproc << "R" << my_rank;
  
   std::ofstream out_file;
   out_file.open(out_stream.str().c_str());
  
   double* out_values = out_vector.values_pt();
   unsigned out_nrow_local = out_vector.nrow_local();
   
   out_file << out_vector.nrow() << "\n";
   out_file << out_vector.first_row() << "\n";
   out_file << out_nrow_local << "\n";
   out_file << out_vector.distributed() << "\n";
  
   for (unsigned val_i = 0; val_i < out_nrow_local; val_i++) 
   {
     out_file << out_values[val_i] << "\n";
   }
  
   out_file.close();
  
 #ifdef OOMPH_HAS_MPI
   // finalize MPI
   MPI_Helpers::finalize();
 #endif
   return(EXIT_SUCCESS);
 } // end_of_main

References oomph::MPI_Helpers::communicator_pt(), oomph::DoubleVectorHelpers::concatenate(), create_vectors_to_cat(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::MPI_Helpers::finalize(), oomph::DistributableLinearAlgebraObject::first_row(), oomph::MPI_Helpers::init(), oomph::OomphCommunicator::my_rank(), oomph::OomphCommunicator::nproc(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DistributableLinearAlgebraObject::nrow_local(), and oomph::DoubleVector::values_pt().

◆ output_vector()