fsi_chan_seg_driver.cc File Reference

#include "generic.h"
#include "navier_stokes.h"
#include "beam.h"
#include "multi_physics.h"
#include "meshes/one_d_lagrangian_mesh.h"
#include "meshes/collapsible_channel_mesh.h"
#include "fsi_chan_problem.h"

Classes
class	SegregatedFSICollapsibleChannelProblem< ELEMENT >

Namespaces
	Flags
	Extend namespace for flags.

Functions
void	Flags::segregated_doc_flags ()
	Doc flags for extended namespace. More...
int	main (int argc, char *argv[])

Variables
unsigned	Flags::Use_segregated_solver =1
	Use Newton solver (0) or segregated solver (1)? More...
unsigned	Flags::Use_pointwise_aitken =0
	Use pointwise Aitken extrapolation (1) or not (0) More...
double	Flags::Omega_under_relax =1.0
	Under-relaxation parameter (1.0: no under-relaxation; 0.0: freeze) More...
unsigned	Flags::Use_irons_and_tuck_extrapolation =0
	Use Irons and Tuck extrapolation (1) or not (0) More...
unsigned	Flags::Convergence_criterion =0
	Convergence criterion: 0: global resmax; 1: abs. change; 2: rel. change. More...
double	Flags::Convergence_tolerance =1.0e-9
	Convergence tolerance. More...
double	Flags::Dt =0.1
	Timestep. More...

Function Documentation

main()

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

//////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// Driver code for a collapsible channel problem with FSI. Presence of command line arguments indicates validation run with coarse resolution and small number of steps.

Resolution factor

Use Newton solver (0) or segregated solver (1)?

Use pointwise Aitken extrapolation (1) or not (0)

Under-relaxation parameter

Use Irons and Tuck extrapolation

Use displacement control (1) or not (0)

Min. y coordinate for parameter study with displacement control

Steady (1) or unsteady (0) run

Convergence criterion: 0: global resmax; 1: abs. change; 2: rel. change

Convergence tolerance

Number of steps

Reynolds number

Womersley number

FSI parameter

Timestep

{
 
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 if (CommandLineArgs::Argc==1)
  {
   std::cout << "Using default settings for flags" << std::endl;
  }
 else if ((CommandLineArgs::Argc==15)||(CommandLineArgs::Argc==17))
  {
   Flags::Resolution_factor=atoi(argv[1]);
 
   Flags::Use_segregated_solver=atoi(argv[2]);
 
   Flags::Use_pointwise_aitken=atoi(argv[3]);
 
   Flags::Omega_under_relax=atof(argv[4]);
 
   Flags::Use_irons_and_tuck_extrapolation=atoi(argv[5]);
 
   Flags::Use_displ_control=atoi(argv[6]);
 
   Global_Physical_Variables::Yprescr_min=double(atof(argv[7]));
 
   Flags::Steady_flag=atoi(argv[8]);
 
   Flags::Convergence_criterion=atoi(argv[9]);
 
   Flags::Convergence_tolerance=atof(argv[10]);
 
   Flags::Nsteps=atoi(argv[11]);
 
   Global_Physical_Variables::Re=double(atof(argv[12]));
 
   Global_Physical_Variables::ReSt=Global_Physical_Variables::Re;
 
   Global_Physical_Variables::Q=double(atof(argv[13]));
 
   Flags::Dt=double(atof(argv[14]));
 
   // Restart?
   if (CommandLineArgs::Argc==17)
    {
     // Name of restart file
     Flags::Restart_file_name=argv[15];
     
     // Jump in pressure 
     Global_Physical_Variables::P_step=double(atof(argv[16]));
    }
  }
 else
  {
   std::cout 
    << "\n\n\n\n\n"
    << "Wrong number of command line args: Specify none, fourteen or sixteen:"
    << std::endl
    << "- resolution factor [1,2,...]" << std::endl
    << "- use_segregated_solver [0/1]"<< std::endl
    << "- use_pointwise_aitken [0/1]" << std::endl
    << "- under-relaxation parameter" << std::endl
    << "- use_irons_and_tuck_extrapolation [0/1]" << std::endl
    << "- use_displ_control [0/1]" << std::endl
    << "- min. y-coordinate of control point when using displ control" 
    <<    std::endl
    << "- steady_flag [0/1]" << std::endl
    << "- convergence criterion [0/1/2]" << std::endl
    << "- convergence tolerance " << std::endl
    << "- number of steps " << std::endl
    << "- Reynolds number" << std::endl
    << "- FSI parameter Q" << std::endl
    << "- Timestep dt" << std::endl
    << "- restart file name [optional] " << std::endl
    << "- jump in pressure P_step [optional] " << std::endl
    << "You specified " << CommandLineArgs::Argc-1 << " command line arg[s]" 
    << "\n\n\n\n\n" << std::endl;
   abort();
  }
 Flags::doc_flags();
 Flags::segregated_doc_flags();
 
 
 // Number of elements in the domain
 unsigned nup=4*Flags::Resolution_factor;
 unsigned ncollapsible=20*Flags::Resolution_factor;
 unsigned ndown=40*Flags::Resolution_factor;
 unsigned ny=4*Flags::Resolution_factor;
  
 
 // Length of the domain
 double lup=1.0;
 double lcollapsible=5.0;
 double ldown=10.0;
 double ly=1.0;
 
 
 // Use displacement control?
 bool displ_control=false;
 if (Flags::Use_displ_control==1) displ_control=true;
 
 // Steady run?
 bool steady_flag=false;
 if (Flags::Steady_flag==1) steady_flag=true;
 
 // Build the problem with QTaylorHoodElements
 SegregatedFSICollapsibleChannelProblem
  <AlgebraicElement<QTaylorHoodElement<2> > > 
 problem(nup, ncollapsible, ndown, ny, 
         lup, lcollapsible, ldown, ly, displ_control,
         steady_flag);
  
 if (Flags::Steady_flag)
  {
   problem.steady_run();
  }
 else
  {
   problem.unsteady_run();
  }
 
}//end of main

References oomph::CommandLineArgs::Argc, Flags::Convergence_criterion, Flags::Convergence_tolerance, Flags::doc_flags(), Flags::Dt, Mesh_Parameters::ly, Flags::Nsteps, Mesh_Parameters::ny, Flags::Omega_under_relax, Global_Physical_Variables::P_step, problem, Global_Physical_Variables::Q, Global_Physical_Variables::Re, Flags::Resolution_factor, Global_Physical_Variables::ReSt, Flags::Restart_file_name, Flags::segregated_doc_flags(), Flag_definition::setup(), Flags::Steady_flag, Flags::Use_displ_control, Flags::Use_irons_and_tuck_extrapolation, Flags::Use_pointwise_aitken, Flags::Use_segregated_solver, and Global_Physical_Variables::Yprescr_min.