matrix_concatenation.cc File Reference

#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	fill_in_mat_info (unsigned const nblock_row, unsigned const nblock_col, unsigned dimarray[], Vector< Vector< Vector< unsigned > > > &mat_info_vec)
void	create_matrix_ascend_col_row (unsigned const nrow, unsigned const ncol, const OomphCommunicator *const comm_pt, bool const distributed, CRDoubleMatrix &block)
void	fill_in_sub_matrices (const OomphCommunicator *const comm_pt, const bool distributed, Vector< Vector< Vector< unsigned > > > &mat_info, DenseMatrix< CRDoubleMatrix * > &mat_pt)
void	create_matrices_to_cat (const unsigned nblock_row, const unsigned nblock_col, unsigned dimarray[], const OomphCommunicator *const comm_pt, DenseMatrix< CRDoubleMatrix * > &mat_pt)
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 fill_in_mat_info().

create_matrices_to_cat()

void create_matrices_to_cat	(	const unsigned	nblock_row,
		const unsigned	nblock_col,
		unsigned	dimarray[],
		const OomphCommunicator *const	comm_pt,
		DenseMatrix< CRDoubleMatrix * > &	mat_pt
	)

{
  // We store the above array in a data structure such that
  // mat_info[0][0][0] gives us the number of rows in the block (0,0)
  // mat_info[0][0][1] gives us the number of columns in the block (0,0)
  Vector<Vector<Vector<unsigned> > > mat_info_vec;
 
  // Helper function to fill in mat_info given
  // nblock_row, nblock_col and dim_array.
  fill_in_mat_info(nblock_row,nblock_col,dimarray,mat_info_vec);
  
  // Fill in each sub matrix using create_matrix_ascend_col_row(..)
  bool distributed = true;
  fill_in_sub_matrices(comm_pt,distributed,mat_info_vec,mat_pt);
}

References fill_in_mat_info(), and fill_in_sub_matrices().

Referenced by main().

create_matrix_ascend_col_row()

void create_matrix_ascend_col_row	(	unsigned const	nrow,
		unsigned const	ncol,
		const OomphCommunicator *const	comm_pt,
		bool const	distributed,
		CRDoubleMatrix &	block
	)

{  
  // Clear the block
  block.clear();
  
  // Create the distribution.
  LinearAlgebraDistribution distri(comm_pt,nrow,distributed);
 
  // The number of rows this processor is responsible for.
  unsigned nrow_local = distri.nrow_local();
  
  // The number of values this processor will have to insert.
  unsigned nval = nrow_local*ncol;
  
  // The first_row will be used as an offset for the values to insert.
  unsigned first_row = distri.first_row();
 
  // Fill in values...
  Vector<double> values(nval,0);
  for (unsigned val_i = 0; val_i < nval; val_i++)
  {
    values[val_i] = (val_i+1) + (first_row)*ncol;
  }
  
  // Vectors for the column index and row_start.
  Vector<int> column_indicies(nval,0);
  Vector<int> row_start(nrow_local+1,0);
 
  unsigned column_indicies_i = 0;
  for (unsigned row_i = 0; row_i < nrow_local; row_i++)
  {
    for (unsigned col_i = 0; col_i < ncol; col_i++) 
    {
      column_indicies[column_indicies_i] = col_i;
      column_indicies_i++;
    }
    row_start[row_i] = ncol*row_i;
  }
 
  // Fill in the last row_start.
  row_start[nrow_local] = nval;
 
  block.build(&distri,ncol,values,column_indicies,row_start);
}

References block(), oomph::LinearAlgebraDistribution::first_row(), and oomph::LinearAlgebraDistribution::nrow_local().

Referenced by fill_in_sub_matrices().

fill_in_mat_info()

void fill_in_mat_info	(	unsigned const	nblock_row,
		unsigned const	nblock_col,
		unsigned	dimarray[],
		Vector< Vector< Vector< unsigned > > > &	mat_info_vec
	)

{
  // The total number of dimensions is two times the number of blocks
  // Since matrices are squares. This should be the same number of elements in
  // dimarray.
  unsigned ndims = 2*nblock_row*nblock_col;
  
  // Put dimarray into dimvec_all, since Vectors are nicer to work with.
  Vector<unsigned> dimvec_all;
  construct_vector(dimarray,ndims,dimvec_all);
  
  // index for the dimvec_all array.
  unsigned dimvec_all_i = 0;
  for (unsigned block_row_i = 0; block_row_i < nblock_row; block_row_i++) 
  {
    // create the Vector for the columns for the current row.
    Vector<Vector<unsigned> > current_block_col_vec;    
     
    // loop through the block columns
    for (unsigned block_col_i = 0; block_col_i < nblock_col; block_col_i++) 
    {
      // loop through the dimensions for this block.
      Vector<unsigned> current_dim_vec;
       
      for (unsigned dim_i = 0; dim_i < 2; dim_i++) 
      {
        current_dim_vec.push_back(dimvec_all[dimvec_all_i]);
        dimvec_all_i++;
      } // for the individual block dimensions.
 
      // push current_dim_vec into the current entry...
      current_block_col_vec.push_back(current_dim_vec);
    } // for the columns in this block row.
 
    // push the current block column vec onto the current row vec.
    mat_info_vec.push_back(current_block_col_vec);
  }// for the number of block rows.
}

References construct_vector().

Referenced by create_matrices_to_cat().

fill_in_sub_matrices()

void fill_in_sub_matrices	(	const OomphCommunicator *const	comm_pt,
		const bool	distributed,
		Vector< Vector< Vector< unsigned > > > &	mat_info,
		DenseMatrix< CRDoubleMatrix * > &	mat_pt
	)

{
  unsigned nblock_row = mat_pt.nrow();
  unsigned nblock_col = mat_pt.ncol();
 
  for (unsigned block_row_i = 0; block_row_i < nblock_row; block_row_i++) 
  {
    for (unsigned block_col_i = 0; block_col_i < nblock_col; block_col_i++) 
    {
      unsigned nrow = mat_info[block_row_i][block_col_i][0];
      unsigned ncol = mat_info[block_row_i][block_col_i][1];
      
      mat_pt(block_row_i,block_col_i)=new CRDoubleMatrix;
 
      create_matrix_ascend_col_row(nrow,ncol,comm_pt,distributed,
                                   *mat_pt(block_row_i,block_col_i));
    }
  }
}

References create_matrix_ascend_col_row(), oomph::DenseMatrix< T >::ncol(), and oomph::DenseMatrix< T >::nrow().

Referenced by create_matrices_to_cat().

main()

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

Driver code: Testing CRDoubleMatrixHelpers::concatenation(...) We concatenate uniformly distributed matrices.

Let (x,y) be a matrix with x rows and y columns, with entries increasing along the columns, then along the rows. For example, (3,3) is [1 2 3 4 5 6 7 8 9].

We concatenate the following matrices: (7,7)(7,5)(7,3) (5,7)(5,5)(5,3) (3,7)(3,5)(3,3)

(7,7)(7,5) (5,7)(5,5) (3,7)(3,5)

(7,7)(7,5)(7,3) (5,7)(5,5)(5,3)

Communication is required and the block structure is maintained. Please see self_test/mpi/vector_concatenation/ for more details.

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

{
#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();
  
  // my rank and number of processors. This is used later for putting the data.
  unsigned my_rank = comm_pt->my_rank();
  unsigned nproc = comm_pt->nproc();
 
  // The number of block rows and columns, these will be set to the correct
  // value per test below.
  unsigned nblock_row = 0;
  unsigned nblock_col = 0;
 
  // Supply the dimensions of the matrices to concatenate.
  // The matrices must be in the order: top row, then along the columns,
  // then second row, et cetera...
  // The number of elements in this must be 2*nblock_row*nblock_col.
  unsigned dimarray[] = {7,7,7,5,7,3,5,7,5,5,5,3,3,7,3,5,3,3};
 
  // Test 0: Concatenate the sub matrices with the sizes
  // (7,7)(7,5)(7,3)
  // (5,7)(5,5)(5,3)
  // (3,7)(3,5)(3,3)
  
  // This is a 3 by 3 block matrix.
  nblock_row = 3;
  nblock_col = 3;
 
  // The data structure to store the pointers to matrices.
  DenseMatrix<CRDoubleMatrix*> mat0_pt(nblock_row,nblock_col,0);
 
  // Create the matrice to concatenate.
  create_matrices_to_cat(nblock_row,nblock_col,dimarray,
                         comm_pt,mat0_pt);
  
  // The result matrix.
  CRDoubleMatrix result_matrix0;
 
  // Call the concatenate function.
  CRDoubleMatrixHelpers::concatenate(mat0_pt,result_matrix0);
 
  // output the result matrix
  std::ostringstream result_mat0_stream;
  result_mat0_stream << "out0_NP" << nproc << "R" << my_rank;
  result_matrix0.sparse_indexed_output(result_mat0_stream.str().c_str());
 
  // No longer need the result matrix.
  result_matrix0.clear();
 
  // Test 1: Concatenate the sub matrices with the sizes
  // (7,7)(7,5)
  // (5,7)(5,5)
  // (3,7)(3,5)
  
  // This is a 3 by 3 block matrix.
  nblock_row = 3;
  nblock_col = 2;
 
  // The data structure to store the pointers to matrices.
  DenseMatrix<CRDoubleMatrix*> mat1_pt(nblock_row,nblock_col,0);
  
  // Get the matrices from mat0_pt
  for(unsigned block_row_i = 0; block_row_i < nblock_row; block_row_i++) 
  {
    for (unsigned block_col_i = 0; block_col_i < nblock_col; block_col_i++) 
    {
      mat1_pt(block_row_i,block_col_i) = mat0_pt(block_row_i,block_col_i);
    }
  }
 
  // The result matrix.
  CRDoubleMatrix result_matrix1;
 
  // Call the concatenate function.
  CRDoubleMatrixHelpers::concatenate(mat1_pt,result_matrix1);
 
  // output the result matrix
  std::ostringstream result_mat1_stream;
  result_mat1_stream << "out1_NP" << nproc << "R" << my_rank;
  result_matrix1.sparse_indexed_output(result_mat1_stream.str().c_str());
 
  // No longer need the result matrix.
  result_matrix1.clear();
 
  // Test 2: Concatenate the sub matrices with the sizes
  // (7,7)(7,5)(7,3)
  // (5,7)(5,5)(5,3)
  
  // This is a 3 by 3 block matrix.
  nblock_row = 2;
  nblock_col = 3;
 
  // The data structure to store the pointers to matrices.
  DenseMatrix<CRDoubleMatrix*> mat2_pt(nblock_row,nblock_col,0);
  
  // Get the matrices from mat0_pt
  for(unsigned block_row_i = 0; block_row_i < nblock_row; block_row_i++) 
  {
    for (unsigned block_col_i = 0; block_col_i < nblock_col; block_col_i++) 
    {
      mat2_pt(block_row_i,block_col_i) = mat0_pt(block_row_i,block_col_i);
    }
  }
 
  // The result matrix.
  CRDoubleMatrix result_matrix2;
 
  // Call the concatenate function.
  CRDoubleMatrixHelpers::concatenate(mat2_pt,result_matrix2);
 
  // output the result matrix
  std::ostringstream result_mat2_stream;
  result_mat2_stream << "out2_NP" << nproc << "R" << my_rank;
  result_matrix2.sparse_indexed_output(result_mat2_stream.str().c_str());
 
  // No longer need the result matrix.
  result_matrix2.clear();
 
  // Delete the sub block matrices, we only need to delete them from mat0_pt.
  nblock_row = mat0_pt.nrow();
  nblock_col = mat0_pt.ncol();
  for (unsigned block_row_i = 0; block_row_i < nblock_row; block_row_i++) 
  {
    for (unsigned block_col_i = 0; block_col_i < nblock_col; block_col_i++) 
    {
      delete mat0_pt(block_row_i,block_col_i);
    } // for col_i
  } // for row_i
 
#ifdef OOMPH_HAS_MPI
  // finalize MPI
  MPI_Helpers::finalize();
#endif
  return(EXIT_SUCCESS);
} // end_of_main

References oomph::CRDoubleMatrix::clear(), oomph::MPI_Helpers::communicator_pt(), oomph::CRDoubleMatrixHelpers::concatenate(), create_matrices_to_cat(), oomph::MPI_Helpers::finalize(), oomph::MPI_Helpers::init(), oomph::OomphCommunicator::my_rank(), oomph::DenseMatrix< T >::ncol(), oomph::OomphCommunicator::nproc(), oomph::DenseMatrix< T >::nrow(), and oomph::Matrix< T, MATRIX_TYPE >::sparse_indexed_output().

output_vector()

template<typename myType >

void output_vector

(

Vector< myType > &

given_vector

)

{
  typename Vector<myType>::iterator it;
 
  for(it = given_vector.begin(); it != given_vector.end(); ++it)
  {
    oomph_info << *it << std::endl; 
  }
}

References oomph::oomph_info.