Struct ODEBVP 

pub struct ODEBVP<T> {
    pub max_iter: usize,
    pub tol: f64,
    pub delta: f64,
    pub solution: Mesh1D<T, f64>,
}

Fields

max_iter: usize

tol: f64

delta: f64

solution: Mesh1D<T, f64>

Implementations

impl<T: Clone + Number> ODEBVP<T>

pub fn new(nodes: Vector<f64>, order: usize) -> Self

Create a new ODEBVP solver

Examples found in repository

examples/blasius.rs (line 48)

fn main() {
    println!("----- Blasius equation -----");

    const ETA_INF: f64 = 20.0;
    const N: usize = 512;

    println!( " * Solving the Blasius equation f''' + f * f'' = 0 in the domain" );
    println!( " * \u{03B7}=[0,{}] subject to the boundary conditions", ETA_INF );
    println!( " * f(0) = 0, f'(0) = 0, f' -> 1 as \u{03B7} -> \u{03B7}_\u{221E} = {}.", ETA_INF );
    println!( " * The number of nodes in the discretisation is N = {}.", N );

    let nodes = Vec64::powspace( 0.0, ETA_INF, N, 1.2 ); // More nodes near eta=0
    let mut ode_bvp = ODEBVP::<f64>::new( nodes.clone(), 3 );
    ode_bvp.iterations( 20 );

    // Set the initial guess for the solution
    for i in 0..N {
        let eta = ode_bvp.solution.coord( i );
        let exp_minus_eta = (-eta).exp();
        ode_bvp.solution[i][0] = eta * ( 1.0 - exp_minus_eta ); 
        ode_bvp.solution[i][1] = 1.0 - exp_minus_eta + eta * exp_minus_eta; 
        ode_bvp.solution[i][2] = 2.0 * exp_minus_eta - eta * exp_minus_eta;
    }

    println!( " * Solving the Blasius equation using the finite difference method..." );
    let result = ode_bvp.solve( &blasius_eqn, &plate_bc, &free_bc, None );  
    assert!( result.is_ok() && !result.is_err() );

    let fdd_0 = ode_bvp.solution.get_interpolated_vars( 0.0 )[2];
    println!( " * The computed value of f''(0) is {:.8}.", fdd_0 ); 

    let c= 1.65519036023f64;
    let reference = 1. / c.powf( 1.5 );
    println!( " * The reference value of f''(0) is {:.8}.", reference );
    println!( " * The relative error is {:.8}%.", ( fdd_0 - reference ).abs() / reference * 100.0 );  

    println!( " * Finished solving the Blasius equation." );
    fs::create_dir_all( "DATA" ).expect( "Could not create DATA output directory" );
    let mut string = String::from( "DATA/Blasius_equation" );
    string.push_str( format!( "_N_{}.dat", N ).as_str() );
    ode_bvp.solution.output( &string, 6 ); 

    print!( " * For a plot of the solution run: " );
    println!( "python3 Plotting/Blasius_plot.py {}", N );
    println!( " * and view the resulting file DATA/Blasius_equation_N_{}.png", N );
    
    println!( "--- FINISHED ---" );
}

pub fn iterations(&mut self, iterations: usize)

Edit the maximum number of iterations

Examples found in repository

examples/blasius.rs (line 49)

fn main() {
    println!("----- Blasius equation -----");

    const ETA_INF: f64 = 20.0;
    const N: usize = 512;

    println!( " * Solving the Blasius equation f''' + f * f'' = 0 in the domain" );
    println!( " * \u{03B7}=[0,{}] subject to the boundary conditions", ETA_INF );
    println!( " * f(0) = 0, f'(0) = 0, f' -> 1 as \u{03B7} -> \u{03B7}_\u{221E} = {}.", ETA_INF );
    println!( " * The number of nodes in the discretisation is N = {}.", N );

    let nodes = Vec64::powspace( 0.0, ETA_INF, N, 1.2 ); // More nodes near eta=0
    let mut ode_bvp = ODEBVP::<f64>::new( nodes.clone(), 3 );
    ode_bvp.iterations( 20 );

    // Set the initial guess for the solution
    for i in 0..N {
        let eta = ode_bvp.solution.coord( i );
        let exp_minus_eta = (-eta).exp();
        ode_bvp.solution[i][0] = eta * ( 1.0 - exp_minus_eta ); 
        ode_bvp.solution[i][1] = 1.0 - exp_minus_eta + eta * exp_minus_eta; 
        ode_bvp.solution[i][2] = 2.0 * exp_minus_eta - eta * exp_minus_eta;
    }

    println!( " * Solving the Blasius equation using the finite difference method..." );
    let result = ode_bvp.solve( &blasius_eqn, &plate_bc, &free_bc, None );  
    assert!( result.is_ok() && !result.is_err() );

    let fdd_0 = ode_bvp.solution.get_interpolated_vars( 0.0 )[2];
    println!( " * The computed value of f''(0) is {:.8}.", fdd_0 ); 

    let c= 1.65519036023f64;
    let reference = 1. / c.powf( 1.5 );
    println!( " * The reference value of f''(0) is {:.8}.", reference );
    println!( " * The relative error is {:.8}%.", ( fdd_0 - reference ).abs() / reference * 100.0 );  

    println!( " * Finished solving the Blasius equation." );
    fs::create_dir_all( "DATA" ).expect( "Could not create DATA output directory" );
    let mut string = String::from( "DATA/Blasius_equation" );
    string.push_str( format!( "_N_{}.dat", N ).as_str() );
    ode_bvp.solution.output( &string, 6 ); 

    print!( " * For a plot of the solution run: " );
    println!( "python3 Plotting/Blasius_plot.py {}", N );
    println!( " * and view the resulting file DATA/Blasius_equation_N_{}.png", N );
    
    println!( "--- FINISHED ---" );
}

pub fn tolerance(&mut self, tolerance: f64)

Edit the convergence tolerance

pub fn delta(&mut self, delta: f64)

Edit the finite difference derivative step

impl ODEBVP<f64>

pub fn solve( &mut self, eqn: &dyn Fn(&Vec64, &f64) -> Vec64, bc_left: &dyn Fn(&Vec64) -> Vector<Option<f64>>, bc_right: &dyn Fn(&Vec64) -> Vector<Option<f64>>, jacobian: Option<&dyn Fn(&Vec64, &f64) -> Mat64>, ) -> Result<(), f64>

Examples found in repository

examples/blasius.rs (line 61)

fn main() {
    println!("----- Blasius equation -----");

    const ETA_INF: f64 = 20.0;
    const N: usize = 512;

    println!( " * Solving the Blasius equation f''' + f * f'' = 0 in the domain" );
    println!( " * \u{03B7}=[0,{}] subject to the boundary conditions", ETA_INF );
    println!( " * f(0) = 0, f'(0) = 0, f' -> 1 as \u{03B7} -> \u{03B7}_\u{221E} = {}.", ETA_INF );
    println!( " * The number of nodes in the discretisation is N = {}.", N );

    let nodes = Vec64::powspace( 0.0, ETA_INF, N, 1.2 ); // More nodes near eta=0
    let mut ode_bvp = ODEBVP::<f64>::new( nodes.clone(), 3 );
    ode_bvp.iterations( 20 );

    // Set the initial guess for the solution
    for i in 0..N {
        let eta = ode_bvp.solution.coord( i );
        let exp_minus_eta = (-eta).exp();
        ode_bvp.solution[i][0] = eta * ( 1.0 - exp_minus_eta ); 
        ode_bvp.solution[i][1] = 1.0 - exp_minus_eta + eta * exp_minus_eta; 
        ode_bvp.solution[i][2] = 2.0 * exp_minus_eta - eta * exp_minus_eta;
    }

    println!( " * Solving the Blasius equation using the finite difference method..." );
    let result = ode_bvp.solve( &blasius_eqn, &plate_bc, &free_bc, None );  
    assert!( result.is_ok() && !result.is_err() );

    let fdd_0 = ode_bvp.solution.get_interpolated_vars( 0.0 )[2];
    println!( " * The computed value of f''(0) is {:.8}.", fdd_0 ); 

    let c= 1.65519036023f64;
    let reference = 1. / c.powf( 1.5 );
    println!( " * The reference value of f''(0) is {:.8}.", reference );
    println!( " * The relative error is {:.8}%.", ( fdd_0 - reference ).abs() / reference * 100.0 );  

    println!( " * Finished solving the Blasius equation." );
    fs::create_dir_all( "DATA" ).expect( "Could not create DATA output directory" );
    let mut string = String::from( "DATA/Blasius_equation" );
    string.push_str( format!( "_N_{}.dat", N ).as_str() );
    ode_bvp.solution.output( &string, 6 ); 

    print!( " * For a plot of the solution run: " );
    println!( "python3 Plotting/Blasius_plot.py {}", N );
    println!( " * and view the resulting file DATA/Blasius_equation_N_{}.png", N );
    
    println!( "--- FINISHED ---" );
}