BVPBlasius.cpp File Reference

Solving the Blasius equation. More...

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

Go to the source code of this file.

Classes
class	CppNoddy::Example::Blasius_equation
	Define the Blasius equation by inheriting Equation base class. More...
class	CppNoddy::Example::Blasius_left_BC
class	CppNoddy::Example::Blasius_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	{ f , fd , fdd }

Functions
int	main ()

Detailed Description

Solving the Blasius equation.

with and in the domain by applying the ODE_BVP class. The class constructs and solves the global matrix problem using 2nd-order finite differences over a finite domain of specified size.

Definition in file BVPBlasius.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
f
fd
fdd

Definition at line 18 of file BVPBlasius.cpp.

{ f, fd, fdd };

Function Documentation

main()

int main

(

)

Definition at line 77 of file BVPBlasius.cpp.

{
  cout << "\n";
  cout << "=== BVP: finite-difference solution of Blasius ======\n";
  cout << "\n";
 
  cout << " Number of points : approx. error \n";
 
  // equation
  Example::Blasius_equation problem;
  // boundary conditions
  Example::Blasius_left_BC BC_left;
  Example::Blasius_right_BC BC_right;
 
  double left = 0.0;        // from x=0
  double right = 20.0;      // to x=20
  bool failed = false;
 
  const double tol = 1.e-5; // pass/fail tolerance
  // let's repeat the computation for a sequence of N's
  // to check on convergence
  for ( int N = 32; N <= 2048; N *= 2 )
  {
    // mesh
    DenseVector<double> nodes( Utility::power_node_vector( left, right, N, 1.2 ) );
    // pass it to the ode
    ODE_BVP<double> ode( &problem, nodes, &BC_left, &BC_right );
    for ( int i = 0; i < N; ++i )
    {
      double y = ode.solution().coord( i );
      ode.solution()( i, f ) = y * ( 1.0 - exp( -y ) );
      ode.solution()( i, fd ) = ( 1.0 - exp( -y ) ) + y * exp( -y );
      ode.solution()( i, fdd ) = 2.0 * exp( -y ) - y * exp( -y );
    }
 
    try
    {
      ode.solve2();
    }
    catch ( const std::runtime_error &error )
    {
      cout << " \033[1;31;48m  * FAILED THROUGH EXCEPTION BEING RAISED \033[0m\n";
      return 1;
    }
 
    const double c = 1.65519036023e0;
    const double answer = 1. / pow( c, 1.5 );
    if ( abs( ode.solution()( 0, fdd ) - answer ) > tol )
    {
      failed = true;
    }
    else
    {
      failed = false;
    }
 
    // compare to the known stress value
    std::cout << " N=" << N << " error=" << abs( ode.solution()( 0, fdd ) - answer ) << " IVP answer=" << answer << "\n";
 
    std::string dirname("./DATA");
    mkdir( dirname.c_str(), S_IRWXU );
    ode.solution().dump_gnu("./DATA/blasius.data");
 
  }
 
  if ( failed )
  {
    cout << "\033[1;31;48m  * FAILED \033[0m\n";
    return 1;
  }
  else
  {
    cout << "\033[1;32;48m  * PASSED \033[0m\n";
    return 0;
  }
}

References f, fd, fdd, CppNoddy::Utility::power_node_vector(), CppNoddy::ODE_BVP< _Type, _Xtype >::solution(), and CppNoddy::ODE_BVP< _Type, _Xtype >::solve2().