navier_stokes/osc_ring/osc_ring_alg.cc File Reference

#include "generic.h"
#include "navier_stokes.h"
#include "meshes/quarter_circle_sector_mesh.h"
#include <math.h>

Classes
class	OscRingNStProblem< ELEMENT >

Namespaces
	Global_Physical_Variables
	Global variables.
	SarahBL
	Sarah's boundary layer solution for flow in oscillating ring.

Functions
double	SarahBL::Diss_sarah (double rho, double zeta, double t)
double	SarahBL::Kin_energy_sarah (double t)
double	SarahBL::P_sarah (double rho, double zeta, double t)
double	SarahBL::Total_Diss_lead_sarah (double t)
double	SarahBL::Total_Diss_sarah (double t)
double	SarahBL::U_sarah (double rho, double zeta, double t)
double	SarahBL::V_sarah (double rho, double zeta, double t)
double	SarahBL::X_sarah (double rho, double zeta, double t)
double	SarahBL::Y_sarah (double rho, double zeta, double t)
void	SarahBL::buckled_ring_residual (const Vector< double > &params, const Vector< double > &unknowns, Vector< double > &residuals)
	Residual function for buckled ring. More...
void	SarahBL::exact_soln (const double &time, const Vector< double > &x, Vector< double > &soln)
	Exact solution: x,y,u,v,p. More...
void	SarahBL::full_exact_soln (const double &time, const Vector< double > &x, Vector< double > &soln)
	Full exact solution: x,y,u,v,p,du/dt,dv/dt,diss. More...
int	main (int argc, char *argv[])

Variables
double	SarahBL::epsilon
double	SarahBL::alpha
double	SarahBL::A
double	SarahBL::Omega
double	SarahBL::N

Function Documentation

main()

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

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Demonstrate how to solve OscRingNSt problem in deformable domain with mesh adaptation

{
 
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 //Do a certain number of timesteps per period
 unsigned nstep_per_period=40; // 80;  // ADJUST_PRIORITY
 unsigned nperiod=3;
 
 // Work out total number of steps and timestep
 unsigned nstep=nstep_per_period*nperiod;  
 double dt=1.0/double(nstep_per_period);
 
 // Set up the problem: Pass timestep and Sarah's asymptotic solution for
 // generation of initial condition
 OscRingNStProblem<AlgebraicElement<RefineableQCrouzeixRaviartElement<2> >,
  BDF<4> > problem(dt,&SarahBL::full_exact_soln);
 
 
 // Restart?
 //---------
 bool restarted=false;
 
 // Pointer to restart file
 ifstream* restart_file_pt=0;
 
 // No restart
 //-----------
 if (CommandLineArgs::Argc!=2)
  {
   cout << "No restart" << std::endl;
   restarted=false;
 
   // Refine uniformly
   problem.refine_uniformly();
   problem.refine_uniformly();
   problem.refine_uniformly();
 
   // Set initial condition on uniformly refined domain (if this isn't done
   // then the mesh contains the interpolation of the initial guess
   // on the original coarse mesh -- if the nodal values were zero in
   // the interior and nonzero on the boundary, then the the waviness of
   // of the interpolated i.g. between the nodes on the coarse mesh
   // gets transferred onto the fine mesh where we can do better
   problem.set_initial_condition();
  }
 
 // Restart
 //--------
 else if (CommandLineArgs::Argc==2)
  {
   restarted=true;
 
   // Open restart file
   restart_file_pt=new ifstream(CommandLineArgs::Argv[1],ios_base::in);
   if (restart_file_pt!=0)
    {
     cout << "Have opened " << CommandLineArgs::Argv[1] << 
      " for restart. " << std::endl;
    }
   else
    {
     std::ostringstream error_stream;
     error_stream 
      << "ERROR while trying to open " << CommandLineArgs::Argv[1] << 
      " for restart." << std::endl;
 
     throw OomphLibError(error_stream.str(),
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
    }
   // Do the actual restart
   problem.restart(*restart_file_pt);
  }
 
 
 // Two command line arguments: do validation run
 if (CommandLineArgs::Argc==3)
  {
    nstep=3;
    cout << "Only doing nstep steps for validation: " << nstep << std::endl;
  }
 
 
 
 
 // Setup labels for output
 DocInfo doc_info;
 
 // Output directory
 doc_info.set_directory("RESLT"); 
 
 // Do unsteady run of the problem for nstep steps
 //-----------------------------------------------
 problem.unsteady_run(nstep,restarted,doc_info);
 
 
 // Validate the restart procedure
 //-------------------------------
 if (CommandLineArgs::Argc==3)
  {
   
   // Build coarser problem
   
   // Set up the problem: Pass timestep and Sarah's asymptotic solution for
   // generation of initial condition
   OscRingNStProblem<AlgebraicElement<RefineableQCrouzeixRaviartElement<2> >,
    BDF<4> > restarted_problem(dt,&SarahBL::full_exact_soln);
   
   // Setup labels for output
   DocInfo restarted_doc_info;
   
   // Output directory
   restarted_doc_info.set_directory("RESLT_restarted"); 
   
   // Step number
   restarted_doc_info.number()=0;
   
   // Copy by performing a restart from old problem
   restart_file_pt=new ifstream("RESLT/restart2.dat");
   
   // Do the actual restart
   restarted_problem.restart(*restart_file_pt);
   
   // Do unsteady run of the problem for one step
   unsigned nstep=2;
   bool restarted=true;
   restarted_problem.unsteady_run(nstep,restarted,restarted_doc_info);
 
  }
 
}

References oomph::CommandLineArgs::Argc, oomph::CommandLineArgs::Argv, SarahBL::full_exact_soln(), oomph::DocInfo::number(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, problem, OscRingNStProblem< ELEMENT >::restart(), oomph::DocInfo::set_directory(), Flag_definition::setup(), and OscRingNStProblem< ELEMENT >::unsteady_run().