mpi/solvers/driven_cavity.cc File Reference

#include "generic.h"
#include "navier_stokes.h"
#include "meshes/simple_rectangular_quadmesh.h"

Classes
class	RectangularDrivenCavityProblem< ELEMENT >
	Driven cavity problem in rectangular domain. More...

Namespaces
	Global_Physical_Variables
	Global variables.

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int argc	,
		char **	argv
	)

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Driver for RectangularDrivenCavity test problem – test drive with two different types of element. Optional command line args specify multiplier for number of element rows/columns and flag to indicate if iterative solver is used. Multiplier and flag both default to 1.

{
 
 
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::init(argc,argv);
#endif
 
 
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 // Default assignemts for flags
 unsigned element_multiplier=1;
 bool use_iterative_solver=true;
 bool use_hypre_for_pressure=true;
 bool use_block_diagonal_for_momentum=false;
 bool use_hypre_for_momentum=true;
 bool do_cr=true;
 bool do_th=true;
 oomph_info << CommandLineArgs::Argc << std::endl;
 
 if (CommandLineArgs::Argc==1)
  {
   oomph_info << "No command line arguments; running self-test" 
              << std::endl;
  }
 else if (CommandLineArgs::Argc==7)
  {
   element_multiplier=unsigned(atoi(CommandLineArgs::Argv[1]));
   if (atoi(CommandLineArgs::Argv[2])==0)
    {
     use_iterative_solver=false;
    }
   else if (atoi(CommandLineArgs::Argv[2])==1)
    {
     use_iterative_solver=true;
    }
   else
    {
     oomph_info << "Second command line arg must be 0 or 1 for\n"
                << "don't/do use iterative solver, but is" 
                << CommandLineArgs::Argv[2] << std::endl;
     abort();
    }
   if (atoi(CommandLineArgs::Argv[3])==0)
    {
     use_hypre_for_momentum=false;
    }
   else if (atoi(CommandLineArgs::Argv[3])==1)
    {
     use_hypre_for_momentum=true;
    }
   else
    {
     oomph_info << "Third command line arg must be 0 or 1 for\n"
                << "don't/do use hypre for momentum block solver, but is" 
                << CommandLineArgs::Argv[3] << std::endl;
     abort();
    }
   if (atoi(CommandLineArgs::Argv[4])==0)
    {
     use_hypre_for_pressure=false;
    }
   else if (atoi(CommandLineArgs::Argv[4])==1)
    {
     use_hypre_for_pressure=true;
    }
   else
    {
     oomph_info << "Fourth command line arg must be 0 or 1 for\n"
                << "don't/do use hypre for pressure block solver, but is" 
                << CommandLineArgs::Argv[4] << std::endl;
     abort();
    }
   if (atoi(CommandLineArgs::Argv[5])==0)
    {
     do_cr=true;
     do_th=true;
    }
   else if (atoi(CommandLineArgs::Argv[5])==1)
    {
     do_cr=true;
     do_th=false;
    }
   else if (atoi(CommandLineArgs::Argv[5])==2)
    {
     do_cr=false;
     do_th=true;
    }
   else
    {
     oomph_info << "Fifth command line arg must be 0, 1 or 2 for\n"
                << "run both (0) or only CR (1) or TH (2) elements, but is" 
                << CommandLineArgs::Argv[5] << std::endl;
     abort();
    }
   if (atoi(CommandLineArgs::Argv[6])==0)
    {
     use_block_diagonal_for_momentum=false;
    }
   else if (atoi(CommandLineArgs::Argv[6])==1)
    {
     use_block_diagonal_for_momentum=true;
    }
   else
    {
     oomph_info << "Sixth command line arg must be 0 or 1 for\n"
                << "don't/do use block diagonal for pressure solver, but is" 
                << CommandLineArgs::Argv[6] << std::endl;
     abort();
    }
  }
 else
  {
   oomph_info << "Wrong number of command line arguments" << std::endl;
   oomph_info << "Enter none (for default) or six" << std::endl;
   oomph_info << "- multiplier for number of element rows/columns" 
              << std::endl;
   oomph_info << "- flag (0/1) for (don't/do) use iterative solver" 
              << std::endl;
   oomph_info << "- flag (0/1) for (don't/do) use hypre for pressure block" 
              << std::endl;
   oomph_info << "- flag (0/1) for (don't/do) use hypre for momentum block" 
              << std::endl;
   oomph_info << "- flag (0/1/2) run both (0) or only CR (1) or TH (2) "
              << "elements" << std::endl;
   oomph_info << "- flag (0/1) for (don't/do) use block diagonal for "
              << "momentum block" << std::endl;
   abort();
  } 
 
 oomph_info << "Running with element multiplier: " 
            <<  element_multiplier << std::endl;
 
 if (use_iterative_solver)
  {
   oomph_info << "Using iterative solver" << std::endl;
  }
 else
  {
   oomph_info << "Using direct solver" << std::endl;
  }
 
 if (use_hypre_for_pressure)
  {
   oomph_info << "Using hypre for pressure block" << std::endl;
  }
 else
  {
   oomph_info << "Using SuperLU for pressure block" << std::endl;
  }
 
 if (use_hypre_for_momentum)
  {
   oomph_info << "Using hypre for momentum block" << std::endl;
  }
 else
  {
   oomph_info << "Using SuperLU for momentum block" << std::endl;
  }
 
 if (use_block_diagonal_for_momentum)
  {
   oomph_info << "Using block diagonal for momentum block" << std::endl;
  }
 
 // Set up doc info
 // ---------------
 
 // Label for output
 DocInfo doc_info;
 
 // Set output directory
 doc_info.set_directory("RESLT");
 
 // Step number
 doc_info.number()=0;
 
 // ---------------
 // end of Set up doc info
 
 
 // Doing QCrouzeixRaviartElements
 if (do_cr)
 {
  // Build the problem with QCrouzeixRaviartElements
  RectangularDrivenCavityProblem<QCrouzeixRaviartElement<2> > 
   problem(element_multiplier,use_iterative_solver,
           use_hypre_for_pressure,use_hypre_for_momentum,
           use_block_diagonal_for_momentum);
  cout << "Doing QCrouzeixRaviartElement<2>" << std::endl;
  
  // Solve the problem
  problem.newton_solve();
  
  // Outpt the solution
  problem.doc_solution(doc_info);
 
  // Step number
  doc_info.number()++;
 
 } // end of QCrouzeixRaviartElements
 
 // Doing QTaylorHoodElements
 if (do_th)
  {
   
   // Build the problem with QTaylorHoodElements
   RectangularDrivenCavityProblem<QTaylorHoodElement<2> > 
    problem(element_multiplier,use_iterative_solver,
            use_hypre_for_pressure,use_hypre_for_momentum,
            use_block_diagonal_for_momentum);
   cout << "Doing QTaylorHoodElement<2>" << std::endl;
   
   // Solve the problem
   problem.newton_solve();
   
   // Outpt the solution
   problem.doc_solution(doc_info);
   
   // Step number
   doc_info.number()++;
   
  } // end of QTaylorHoodElements
 
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::finalize();
#endif
 
 
 
} // end_of_main

References oomph::CommandLineArgs::Argc, oomph::CommandLineArgs::Argv, oomph::DocInfo::number(), oomph::oomph_info, problem, oomph::DocInfo::set_directory(), and Flag_definition::setup().