generic_mpi_test.cc File Reference

#include "generic.h"
#include "poisson.h"
#include "meshes/one_d_mesh.h"

Classes
class	OneDPoissonProblem< ELEMENT >
	1D Poisson problem in unit interval. More...

Namespaces
	FishSolnOneDPoisson
	Namespace for fish-shaped solution of 1D Poisson equation.

Functions
void	FishSolnOneDPoisson::get_exact_u (const Vector< double > &x, Vector< double > &u)
	Exact, fish-shaped solution as a 1D vector. More...
void	FishSolnOneDPoisson::source_function (const Vector< double > &x, double &source)
	Source function required to make the fish shape an exact solution. More...
int	main (int argc, char *argv[])
	Driver code for generic mpi stuff. More...

Function Documentation

main()

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

Driver code for generic mpi stuff.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

{
 
  // Initialise MPI
  MPI_Helpers::init(argc,argv);
 
  // Switch off output modifier
  oomph_info.output_modifier_pt() = &default_output_modifier;
  
  // Define processor-labeled output file for all on-screen stuff
  std::ofstream output_stream;
  char filename[100];
  sprintf(filename,"OUTPUT.%i",MPI_Helpers::communicator_pt()->my_rank());
  output_stream.open(filename);
  oomph_info.stream_pt() = &output_stream;
  OomphLibWarning::set_stream_pt(&output_stream);
  OomphLibError::set_stream_pt(&output_stream);  
  
  // Get the global oomph-lib communicator 
  const OomphCommunicator* const comm_pt = MPI_Helpers::communicator_pt();
 
  // Get rank and total number of processors. 
  unsigned my_rank = comm_pt->my_rank();
  unsigned nproc = comm_pt->nproc();
 
  // Tell us who you are...
  oomph_info << "I'm rank " << my_rank << " on a total of "
             << nproc << " processors" << std::endl;
 
 
 
  
  // Create a uniformly distributed LinearAlgebraDistribution
  // 100 global rows are uniformly distributed accross the processes of 
  // comm_pt
  unsigned nrow_global = 100;
  LinearAlgebraDistribution distributed_distribution(comm_pt,
                                                     nrow_global); 
 
  // Show us how many rows this processor holds
  oomph_info << "distributed distribution: first_row and nrow_local: "
             << distributed_distribution.first_row() << " " 
             << distributed_distribution.nrow_local() 
             << std::endl;
  
 
  // Construct an empty distribution object (does not specify a distribution)
  LinearAlgebraDistribution locally_replicated_distribution;
  
  // Build a locally replicated distribution such that every row is available
  // on every process
  bool distributed=false;
  locally_replicated_distribution.build(comm_pt,nrow_global,distributed);
  
  // Show us how many rows this processor holds
  oomph_info << "locally replicated distribution: first_row and nrow_local: "
             << locally_replicated_distribution.first_row() << " " 
             << locally_replicated_distribution.nrow_local() 
             << std::endl;
  
  // Get the number of local rows on this process
  unsigned nrow_local = distributed_distribution.nrow_local();
  
  // Get the first row on this process
  unsigned first_row = distributed_distribution.first_row();
  
  // Get the number of global rows
  nrow_global = distributed_distribution.nrow();
  
  // Is this distributed (true) or locally replicated (false)
  distributed = distributed_distribution.distributed();
  
  // Does this object specify a distribution
  bool built = distributed_distribution.built();
  
 
 
  // Construct a uniformly distributed DoubleVector with unit elements
  DoubleVector my_vector(distributed_distribution,1.0);
  
  // Increment every element of my_vector on this process by 1
  nrow_local = my_vector.distribution_pt()->nrow_local();
  for (unsigned i = 0; i < nrow_local; i++)
   {
    my_vector[i]+=1.0;
   }
  
  // Document elements on this process in my_vector
  nrow_local = my_vector.distribution_pt()->nrow_local();
  first_row = my_vector.distribution_pt()->first_row();
  for (unsigned i = 0; i < nrow_local; i++)
   {
    oomph_info << "local row " << i 
               << " is global row " << first_row+i 
               << " and has value " << my_vector[i] << std::endl; 
   }
 
  // Redistribute my_vector such that it is locally replicated on all processes
  my_vector.redistribute(&locally_replicated_distribution);
  
  // (Re)build my_vector such that it is uniformly distributed over all
  // processes
  my_vector.build(distributed_distribution,1.0);
 
  // Construct an empty DoubleVector
  DoubleVector another_vector;
  
  // Clear all data from an existing DoubleVector
  my_vector.clear();
 
  
  // Construct an empty CRDoubleMatrix
  CRDoubleMatrix my_matrix;
 
  // Specify that the rows be uniformly distributed
  my_matrix.build(&distributed_distribution);
 
  // Vector of coefficient of value 1.0
  Vector<double> values(nrow_local,1.0);
  
  // Column indices corresponding to values
  Vector<int> column_indices(nrow_local);
  
  // Index of vectors values and column_indices where the i-th row starts
  // (each row contains one coefficient)
  Vector<int> row_start(nrow_local+1);
  
  // populate column_indices and row_start
  for (unsigned i = 0; i < nrow_local; ++i)
   {
    column_indices[i]=first_row+nrow_local;
    row_start[i]=i;
   }
  row_start[nrow_local]=nrow_local;
  
  // Build the (square) matrix
  unsigned ncol = nrow_global;
  my_matrix.build(ncol,values,column_indices,row_start);
  
  CRDoubleMatrix my_matrix2(&distributed_distribution,ncol,values,
                           column_indices,row_start);
  
  // Get the first (global) row of my_matrix on this process
  first_row =  my_matrix2.distribution_pt()->first_row();
  
  // Get the first (global) row of my_matrix on this process
  first_row =  my_matrix2.first_row();
 
 
 
 
 
  // Set up a problem: 
  // Solve a 1D Poisson problem using a source function that generates
  // a fish shaped exact solution
  unsigned n_element=40; 
  OneDPoissonProblem<QPoissonElement<1,4> > 
   problem(n_element,FishSolnOneDPoisson::source_function);
    
  // Get the residual and Jacobian, by default both are uniformly distributed
  // over all available processes
  my_vector.clear();
  my_matrix.clear();
  
  // Get the Jacobian
  problem.get_jacobian(my_vector,my_matrix);
  
  oomph_info 
   << "Uniformly distributed residual vector: first_row and nrow_local: " 
   << my_vector.first_row() << " " 
   << my_vector.nrow_local() << std::endl
   << "Uniformly distributed jacobian matrix: first_row, nrow_local and nnz: " 
   << my_matrix.first_row() << " " 
   << my_matrix.nrow_local() << " " 
   << my_matrix.nnz() << " " 
   << std::endl;
 
 
  // Request locally replicated residual and Jacobian from the problem
  distributed=false;
  LinearAlgebraDistribution locally_replicated_distribution_for_jac(
   comm_pt,problem.ndof(),distributed);
  
  // Show us how many rows this processor holds
  oomph_info 
   << "locally replicated distribution_for_jac: first_row and nrow_local: "
   << locally_replicated_distribution_for_jac.first_row() << " " 
   << locally_replicated_distribution_for_jac.nrow_local() 
   << std::endl;
  
  my_vector.build(locally_replicated_distribution_for_jac);
  my_matrix.build(&locally_replicated_distribution_for_jac);
 
  // Get the Jacobian
  problem.get_jacobian(my_vector,my_matrix);
 
  oomph_info 
   << "Replicated residual vector: first_row and nrow_local: " 
   << my_vector.first_row() << " " 
   << my_vector.nrow_local() << std::endl
   << "Replicated jacobian matrix: first_row, nrow_local and nnz: " 
   << my_matrix.first_row() << " " 
   << my_matrix.nrow_local() << " " 
   << my_matrix.nnz() << " " 
   << std::endl;
 
  // Finalize MPI
  MPI_Helpers::finalize();
 
 
  // dummy line to suppress warning about unused built variable
  if (built)
   {
    built=false;
   }
  
} // end_of_main

References oomph::DoubleVector::build(), oomph::CRDoubleMatrix::build(), oomph::LinearAlgebraDistribution::build(), oomph::LinearAlgebraDistribution::built(), oomph::DoubleVector::clear(), oomph::CRDoubleMatrix::clear(), oomph::default_output_modifier, oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), MergeRestartFiles::filename, oomph::LinearAlgebraDistribution::first_row(), oomph::DistributableLinearAlgebraObject::first_row(), i, oomph::OomphCommunicator::my_rank(), oomph::CRDoubleMatrix::nnz(), oomph::OomphCommunicator::nproc(), oomph::LinearAlgebraDistribution::nrow(), oomph::LinearAlgebraDistribution::nrow_local(), oomph::DistributableLinearAlgebraObject::nrow_local(), oomph::oomph_info, oomph::OomphInfo::output_modifier_pt(), problem, oomph::DoubleVector::redistribute(), FishSolnOneDPoisson::source_function(), and oomph::OomphInfo::stream_pt().