fsi_driven_cavity_segregated_driver.cc File Reference

#include "fsi_driven_cavity_problem.h"
#include "multi_physics.h"

Classes
class	SegregatedFSIDrivenCavityProblem< ELEMENT >

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

Function Documentation

main()

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

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

{
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
  
 // Number of elements in the domain (W. Wall standard resolution)
 unsigned nx=16; //32;
 unsigned ny=16; //32;
 
 // Length of the domain
 double lx=1.0;
 double ly=1.0;
 
 // Fractional height of the gap next to the moving lid
 double gap_fraction=1.0/16.0;
   
 // Period of lid oscillation
 double period=5.0;
 
 // Build the problem
 SegregatedFSIDrivenCavityProblem<AlgebraicElement<QTaylorHoodElement<2> > > 
  problem(nx, ny, lx, ly, gap_fraction, period);
 
 // Timestep. 
 double dt=period/40.0; 
 
 // Maximum time for simulation
 double t_max=50.0; 
 
 // Initialise timestep 
 problem.initialise_dt(dt);
 
 // Apply initial condition
 problem.set_initial_condition();
 
 //Set output directory
 DocInfo doc_info;
 doc_info.set_directory("RESLT");
 
 // Open a trace file 
 ofstream trace_file;
 char filename[100];   
 sprintf(filename,"%s/trace.dat",doc_info.directory().c_str());
 trace_file.open(filename);
 
 // Output the initial solution
 problem.doc_solution(doc_info, trace_file);
 
 // Increment step number
 doc_info.number()++;
 
 // Find number of timesteps (reduced for validation)
 unsigned nstep = unsigned(t_max/dt);
 if (CommandLineArgs::Argc>1)
  {
   nstep=3;
  }
 
 // Timestepping loop
 for (unsigned istep=0;istep<nstep;istep++)
  {
   
   // Object that stores the convergence data for Picard iteration
   PicardConvergenceData conv_data;
   
   // Number iterations taken
   //unsigned niter=0; 
   
   // Setup segregated solver in either case
   problem.setup_segregated_solver();
   
   // Solve the problem
   //------------------
 
   conv_data=problem.unsteady_segregated_solve(dt);
 
   //niter=conv_data.niter();
   if (conv_data.cpu_total()!=0.0)
    {
     std::cout 
      << std::endl << std::endl << std::endl 
      << "PERCENTAGE OF CPU TIME SPENT IN COMPUTATION OF GLOBAL RESIDUAL="
      << double(conv_data.cpu_for_global_residual()/
                conv_data.cpu_total())*100.0
      << std::endl << std::endl << std::endl <<std::endl;
     
     std::cout 
      <<"PERCENTAGE OF CPU TIME SPENT IN COMPUTATION OF NON-ESSENTIAL BITS="
      << double((conv_data.cpu_total()-conv_data.essential_cpu_total())/
                conv_data.cpu_total())*100.0 << " " 
      << conv_data.cpu_total() << " " 
      << conv_data.essential_cpu_total() << " "
      << std::endl << std::endl << std::endl <<std::endl;
    }
  
   
 
   // Solve the problem
   // problem.unsteady_newton_solve(dt);
   
   // Outpt the solution
   problem.doc_solution(doc_info, trace_file);
   
   // Step number
   doc_info.number()++;
  }
 
 
 // Close trace file.
 trace_file.close();
 
 
 
}//end of main

References oomph::CommandLineArgs::Argc, oomph::PicardConvergenceData::cpu_for_global_residual(), oomph::PicardConvergenceData::cpu_total(), oomph::DocInfo::directory(), oomph::PicardConvergenceData::essential_cpu_total(), MergeRestartFiles::filename, Mesh_Parameters::lx, Mesh_Parameters::ly, oomph::DocInfo::number(), Mesh_Parameters::nx, Mesh_Parameters::ny, problem, oomph::DocInfo::set_directory(), and Flag_definition::setup().