EVPOrrSommerfeldEasy_lapack.cpp File Reference

Solves the following linear eigenvalue problem for values that satisfy : More...

#include <BVP_bundle.h>
#include <EVP_bundle.h>
#include "../Utils_Fill.h"

Go to the source code of this file.

Classes
class	CppNoddy::Example::OS_evp_equation
	Define the OS equation for the global QZ EVP. More...
class	CppNoddy::Example::OS_bvp_equation
	Define the OSE for the local refinement procedure. More...
class	CppNoddy::Example::OS_evp_both_BC
class	CppNoddy::Example::OS_bvp_left_BC
class	CppNoddy::Example::OS_bvp_right_BC

Namespaces
namespace	CppNoddy
	A collection of OO numerical routines aimed at simple (typical) applied problems in continuum mechanics.
namespace	CppNoddy::Example

Enumerations
enum	{   phi , phid , psi , psid ,   eval }

Functions
double	CppNoddy::Example::U (double y)
	Globally define the base flow. More...
double	CppNoddy::Example::Udd (double y)
	Globally define the base flow curvature. More...
int	main ()

Variables
double	CppNoddy::Example::Re
	Globally define the Reynolds number and wavenumber. More...
double	CppNoddy::Example::alpha

Detailed Description

Solves the following linear eigenvalue problem for values that satisfy :

subject to where , and . These values approximately correspond to the first neutral temporal mode in plane Poiseuille flow, therefore the test to be satisfied is that an eigenvalue exists with . Here we use the ODE_EVP class with a very low number of mesh points to get an approximation to the temporal spectrum of modes. The 'most dangerous' mode is then extracted from this set, interpolated onto a MUCH finer mesh, and used as the initial guess in a nonlinear boundary-value problem using the ODE_BVP class. This leads to a local refinement of the selected mode that could equally be applied to other eigenvalues very simply.

Definition in file EVPOrrSommerfeldEasy_lapack.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
phi
phid
psi
psid
eval

Definition at line 26 of file EVPOrrSommerfeldEasy_lapack.cpp.

{ phi, phid, psi, psid, eval };

Function Documentation

main()

int main

(

)

Definition at line 161 of file EVPOrrSommerfeldEasy_lapack.cpp.

{
  cout << "\n";
  cout << "=== EVP: Temporal OSE via the equation interface ====\n";
  cout << "===  followed by local refinement of the eigenvalue.\n";
  cout << "\n";
 
 
  // instantiate the eigenproblem
  Example::OS_evp_equation evp;
  // instantiate the boundary conditions -- same applies at both boundaries
  Example::OS_evp_both_BC BC_both;
  Example::Re = 5772.2;
  Example::alpha = 1.02;
  // domain is -1 to 1
  double left = -1.0;
  double right = 1.0;
  // number of nodal points
  int N = 32;
  // mesh
  DenseVector<double> nodes( Utility::uniform_node_vector( left, right, N ) );
 
  // pass it to the ode
  ODE_EVP<D_complex> ode_global( &evp, nodes, &BC_both, &BC_both );
  try
  {
    // solve the global eigenvalue problem on ropey mesh
    ode_global.eigensolve();
  }
  catch (const std::runtime_error &error )
  {
    cout << " \033[1;31;48m  * FAILED THROUGH EXCEPTION BEING RAISED \033[0m\n";
    return 1;
  }
  // get the eigenvalues near the origin
  ode_global.p_eigensystem() -> tag_eigenvalues_disc( + 1, 0.6 );
  // make a mesh of each tagged eigenmode in the ODE_EVP class
  ode_global.add_tagged_to_mesh();
 
  // instantiate the nonlinear BVP formulation
  Example::OS_bvp_equation bvp;
  // instantiate the BCs
  Example::OS_bvp_left_BC BC_left;
  Example::OS_bvp_right_BC BC_right;
  // pass it to the ode BVP solver
  ODE_BVP<D_complex> ode_local( &bvp, nodes, &BC_left, &BC_right );
  // use our not-great initial guess from QZ code to start the solver off
  // here we just use the first (0) tagged eigenvalue
  ode_local.solution() = ode_global.get_mesh( 0 );
  // interpolate onto a finer mesh
  ode_local.solution().remesh1( Utility::uniform_node_vector( left, right, 1024 ) );
  ode_local.set_monitor_det( false );
  // solve the nonlinear BVP
  ode_local.solve2();
  // check the eigenvalue
  const double tol = 1.e-4;
  if ( abs( ode_local.solution()( 0, eval ).imag() ) < tol )
  {
    cout << "\033[1;32;48m  * PASSED \033[0m\n";
    return 0;
  }
  cout << "\033[1;31;48m  * FAILED \033[0m\n";
  return 1;
}

References CppNoddy::ODE_EVP< _Type >::add_tagged_to_mesh(), CppNoddy::ODE_EVP< _Type >::eigensolve(), eval, CppNoddy::ODE_EVP< _Type >::get_mesh(), CppNoddy::ODE_EVP< _Type >::p_eigensystem(), CppNoddy::ODE_BVP< _Type, _Xtype >::set_monitor_det(), CppNoddy::ODE_BVP< _Type, _Xtype >::solution(), CppNoddy::ODE_BVP< _Type, _Xtype >::solve2(), and CppNoddy::Utility::uniform_node_vector().