DynIbex: ibex::simulation

Field Summary
`double`	`atol`
`ivp_dae_h1*`	`embedded_dae`
`ivp_ode*`	`embedded_ode`
`std::list< solution_g >`	`list_solution_g`
`std::list< solution_j >`	`list_solution_j`
`std::list< solution_j_dae >`	`list_solution_j_dae`
`Method`	`meth`
`bool`	`monotony_active`
`int`	`nb_var`
`int`	`process`
`int`	`test`
`double`	`time_T`

Constructor Summary
`simulation( ivp_ode* _ode, double T, Method _meth, double a )`
`simulation( ivp_ode* _ode, double T )`
`simulation( ivp_ode* _ode, double T, Method _meth )`
`simulation( ivp_ode* _ode, double T, double a )`
`simulation( ivp_dae_h1* _dae, double T, Method _meth, double a )`
`simulation( ivp_dae_h1* _dae, double T )`
`simulation( ivp_dae_h1* _dae, double T, Method _meth )`
`simulation( ivp_dae_h1* _dae, double T, double a )`
`~simulation()`

Method Summary
`void`	`active_monotony()`
`void`	`destructor()`
`void`	`export1d_yn( const char* filename, int x )`
`void`	`export2d_yn( const char* filename, int x, int y )`
`void`	`export3d_yn( const char* filename, int x, int y, int z )`
`IntervalVector`	`find_box( std::list< IntervalVector >* stack, IntervalVector y )`
`bool`	`finished_in( IntervalVector y_final )`
`bool`	`finished_in( std::list< IntervalVector >* stack )`
`IntervalVector`	`get( double t )`
`IntervalVector`	`get_attractor()`
`IntervalVector`	`get_domain()`
`IntervalVector`	`get_last()`
`IntervalVector`	`get_tight( double t )`
`bool`	`go_out( IntervalVector y_hull )`
`bool`	`has_crossed( IntervalVector y )`
`bool`	`has_reached( IntervalVector y_final )`
`bool`	`has_reached( std::list< IntervalVector >* stack )`
`void`	`inactive_monotony()`
`double`	`one_in( std::list< IntervalVector >* stack )`
`int`	`order_of_method( Method _meth )`
`double`	`pred_h( ivp_ode* _ode, double atol )`
`int`	`run_simulation()`
`void`	`sol_to_generic( std::list< solution_j > list_sol )`
`void`	`sol_to_generic( std::list< solution_j_dae > list_sol )`
`bool`	`stayed_in( IntervalVector y_hull )`
`bool`	`stayed_in_till( IntervalVector y_hull, double t )`

Field Detail

atol

public double atol;

Used to define the absolute tolerancy

embedded_dae

public ivp_dae_h1* embedded_dae;

IVP problem based on DAE solved with this simulation

embedded_ode

public ivp_ode* embedded_ode;

IVP problem based on ODE solved with this simulation

list_solution_g

public std::list< solution_g > list_solution_g;

List of solutions computed at each integration step used for methods, generic for ODE and DAE

list_solution_j

public std::list< solution_j > list_solution_j;

List of solutions computed at each integration step for ODE

list_solution_j_dae

public std::list< solution_j_dae > list_solution_j_dae;

List of solutions computed at each integration step for DAE

meth

public Method meth;

Method used to perform the integration

monotony_active

public bool monotony_active;

Set at true to use monotony tricks (sometimes better results but time consuming)

nb_var

public int nb_var;

Size of state vector

process

public int process;

State of simulation

time_T

public double time_T;

End time for simulation

Constructor Detail

simulation

public simulation( ivp_ode* _ode, double T, Method _meth, double a );

Constructor

simulation

public simulation( ivp_ode* _ode, double T );

Constructor

simulation

public simulation( ivp_ode* _ode, double T, Method _meth );

Constructor

simulation

public simulation( ivp_ode* _ode, double T, double a );

Constructor

simulation

public simulation( ivp_dae_h1* _dae, double T, Method _meth, double a );

Constructor

simulation

public simulation( ivp_dae_h1* _dae, double T );

Constructor

simulation

public simulation( ivp_dae_h1* _dae, double T, Method _meth );

Constructor

simulation

public simulation( ivp_dae_h1* _dae, double T, double a );

Constructor

~simulation

public ~simulation();

Destructor

Method Detail

active_monotony

public void active_monotony();

Active monotony tricks

destructor

public void destructor();

Clean the memory used to perform the simulation

export1d_yn

public void export1d_yn( const char* filename, int x );

Export in a file one given dimension of state variable w.r.t. time

export2d_yn

public void export2d_yn( const char* filename, int x, int y );

Export in a file two given dimensions of state variable

export3d_yn

public void export3d_yn( const char* filename, int x, int y, int z );

Export in a file three given dimensions of state variable

find_box

public IntervalVector find_box( std::list< IntervalVector >* stack, IntervalVector y );

Find the box of a stack which contains a sub-box

finished_in

public bool finished_in( IntervalVector y_final );

Final solution is include in a box

finished_in

public bool finished_in( std::list< IntervalVector >* stack );

Final solution is include in at least one box of a list

get

public IntervalVector get( double t );

Return a box containing y(t)

get_attractor

public IntervalVector get_attractor();

Return a box contained in the next box (possibly an attractor). Entire means no attractor found

get_domain

public IntervalVector get_domain();

Return the domain covered by the simulation (the hull of y)

get_last

public IntervalVector get_last();

Return the last box

get_tight

public IntervalVector get_tight( double t );

Return a tight box containing y(t), with new integration

go_out

public bool go_out( IntervalVector y_hull );

True if at least one y(t) outside a box

has_crossed

public bool has_crossed( IntervalVector y );

True if tube crosses a box

has_reached

public bool has_reached( IntervalVector y_final );

True if final solution crosses a box

has_reached

public bool has_reached( std::list< IntervalVector >* stack );

True if final solution crosses at least one box of a list

inactive_monotony

public void inactive_monotony();

Inactive monotony tricks

one_in

public double one_in( std::list< IntervalVector >* stack );

Return t if y(t) is inside at least one box of a list, else -1

order_of_method

public int order_of_method( Method _meth );

Return the order of an integration method

pred_h

public double pred_h( ivp_ode* _ode, double atol );

Method used to predict the best value for the initial step size

run_simulation

public int run_simulation();

Run the simulation stops when final time reached

sol_to_generic

public void sol_to_generic( std::list< solution_j > list_sol );

Create the generic list of solution (tube) from an ODE simulation

sol_to_generic

public void sol_to_generic( std::list< solution_j_dae > list_sol );

Create the generic list of solution (tube) from an DAE simulation

stayed_in

public bool stayed_in( IntervalVector y_hull );

True if tube stays in a box

stayed_in_till

public bool stayed_in_till( IntervalVector y_hull, double t );

True if tube stays in a box till t