Airport Problem Simulation

Problem Statement: We have to simulate the average waiting time for an

aeroplane to land or takeoff from an airport. Here we assume that it is a Single
Server System i.e. the airport has only one runway shared for both landing and
takeoff. We also assume that upto three aeroplanes can wait for landing or
takeoff at an instance.

Entities: The following are the entities of the given system Airport Runway
Planes

Events: The following are the events that can occur in the given system Takeoff
Landing

System States: The states that can be changed by the given events are Number of Aeroplanes in the Landing queue
Number of Aeroplanes in the Takeoff queue
Status of the Runway (Busy/Idle)

State Variables: The following are the state variables for the given system

nplanes (Number of aeroplanes)

ntakeoff (Number of aeroplanes took off)
nland (Number of aeroplanes landed)
idle_time (Time for which the runway remains idle)

Start

Initialize Routine(initialize airport variables)

Current time <

Start Simulation Clock

simulation end time

Define next event

Call timing routine

Event occur ( fly or land)

Update the statistic counter

Update system state
Generate next event time

End

Flowcharts for Airplane Take-off and Landing Events:

Take-off Event- When the airplane arrives, check the runway status. If
the runway status is idle, then update the runway status to busy.
Otherwise, that airplane waits in the queue, so the number of airplane in
the queue increases one and store the arrival time to the list of arrival
time.

Start

Runway idle?

Set Runway to busy

Is take-off queue full?

Increase number of delay by 1

Add number in queue by 1

Add arrival time to last
arrival time

Get next take-off time

Next take-off time

is infinite?

Get next take-off time

Stop

Stop Simulation

Landing Event- When the airplane arrives, check the runway status. If
the runway status is idle, then update the runway status to busy.
Otherwise, that airplane waits in the queue, so the number of airplane in
the queue increases one and store the arrival time to the list of arrival
time.

Start

Runway idle?

Set Runway to busy

Is take-off queue full?

Increase number of delay by 1

Add number in queue by 1

Add arrival time to last
arrival time

Get next take-off time

Next take-off time

is infinite?

Get next take-off time

Stop
Stop Simulation

Flowcharts for various Routines:

Timing routine- It defines the simulation clock to the next event time.

 Event occur routine- Call the timing routine to move the clock to the
event. Update the area under Q(t), B(t), and time of last event. If the next
is arrival, call function take-off(), else call function landing().

Event Occur Routine

Call timing routine

Set Q(t) = Q(t)+(num

in queue)*(clock-last event)

Is runway busy?

Set B(t) = B(t)+(clock

-last event)

Set last event = clock

Event type = 0?

Call Take-off routine

Call Landing Routine

Stop

Generate next arrival time for airplane take-off routine- This routine
is to generate next arrival time randomly.

 Generate next arrival time for airplane landing routine- This routine
is to generate next departure time randomly.

Report routine- The report shows about time of simulation end, mean of
airplanes in queue, mean of delay time, and the percentage of runway
utilisation.

 Define next event routine- Define whether next event is take-off or

landing. To get the next event, we just look to the next arrival time and
next departure time for the airplane. If arrival time is infinite, it means
that the plane is departing, hence it is a Take-off event and the opposite
occurs for Landing Event.

C Program for the given Problem:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cmath>
#include <time.h>
#include <limits.h>
#define MAX 3
#define ARRIVE 0
#define DEPART 1

struct plane
{
int id ;
int tm ;
};

struct queue
{
int count ;
int front ;
int rear ;

struct plane p[MAX] ;

};

void initqueue ( struct queue * ) ;

void addqueue ( struct queue *, struct plane ) ;
plane delqueue ( struct queue * ) ;
int size ( struct queue ) ;
int empty ( struct queue ) ;
int full ( struct queue ) ;

void initqueue ( struct queue *pq )

{
pq -> count = 0 ;
pq -> front = 0 ;
pq -> rear = -1 ;
}

void addqueue ( queue *pq, plane item )

{
if ( pq -> count >= MAX )
{
printf ( "\nQueue is full.\n" ) ;
return ;

}
( pq -> count )++ ;

pq -> rear = ( pq -> rear + 1 ) % MAX ;

pq -> p[pq -> rear] = item ;
}

plane delqueue ( queue *pq )

{
struct plane p1 ;

if ( pq -> count <= 0 )

{
printf ( "\nQueue is empty.\n" ) ;
p1.id = 0 ;
p1.tm = 0 ;
}
else
{
( pq -> count )-- ;
p1 = pq -> p[pq -> front] ;
pq -> front = ( pq -> front + 1 ) % MAX ;
}
return p1 ;

int size ( queue q )

{
return q.count ;
}

int empty ( queue q )

{
return ( q.count <= 0 ) ;
}

int full ( queue q )

{
return ( q.count >= MAX ) ;
}

struct airport
{
struct queue landing ;
struct queue takeoff ;
struct queue *pl ;
struct queue *pt ;

int idletime ;
int landwait, takeoffwait ; // mean calculations
int nvarianceland , nvariancetakeoff; // variance calculations
int nland, nplanes, nrefuse, ntakeoff ;
struct plane pln ;
};

void initairport ( airport * ) ;

void start ( int *, double *, double * ) ;
void newplane ( airport *, int, int ) ;
void refuse ( airport *, int ) ;
void land ( airport *, struct plane, int ) ;
void fly ( airport *, struct plane, int ) ;
void idle ( airport *, int ) ;
void conclude ( airport *, int ) ;
int randomnumber ( double ) ;
void apaddqueue ( airport *, char ) ;
plane apdelqueue ( airport *, char ) ;
int apsize ( airport, char ) ;
int apfull ( airport, char ) ;
int apempty ( airport, char ) ;
void myrandomize ( ) ;

void initairport ( airport *ap )

{
initqueue ( &( ap-> landing ) ) ;
initqueue ( &( ap -> takeoff ) ) ;

ap -> pl = &( ap -> landing ) ;

ap -> pt = &( ap -> takeoff ) ;
ap -> nplanes = ap -> nland = ap -> ntakeoff = ap -> nrefuse = 0 ;
ap -> landwait = ap -> takeoffwait = ap -> idletime = 0 ;
}

void start ( int *endtime, double *expectarrive, double *expectdepart )

{
int flag = 0 ;
int wish ;

printf ( "\nProgram that simulates an airport with only one runway.\n" ) ;

printf ( "One plane can land or depart in each unit of time.\n" ) ;
printf ( "Up to %d planes can be waiting to land or take off at any time.\n",
MAX ) ;
printf ( "How many units of time will the simulation run?" ) ;
scanf ( "%d", endtime ) ;
myrandomize( ) ;
do
{

printf ( "\nExpected number of arrivals per unit time? " ) ;

scanf ( "%lf", expectarrive ) ;
printf ( "\nExpected number of departures per unit time? " ) ;
scanf ( "%lf", expectdepart ) ;

if ( *expectarrive < 0.0 || *expectdepart < 0.0 )

{
printf ( "These numbers must be nonnegative.\n" ) ;
flag = 0 ;
}
else
{
if ( *expectarrive + *expectdepart > 1.0 )
{
printf ( "The airport will become saturated. Read new numbers?(1-yes
2-no " ) ;

scanf ( "%d", &wish );

if ( wish == 1 )
flag = 0 ;
else
{
if( wish == 0 )
flag = 1 ;

}
}
else
flag = 1 ;
}
} while ( flag == 0 ) ;
}

void newplane ( airport *ap, int curtime, int action )

{
( ap -> nplanes )++ ;
ap -> pln.id = ap -> nplanes ;
ap -> pln.tm = curtime ;

switch ( action )
{
case ARRIVE :
printf ( "\n" ) ;
printf ( "Plane %d ready to land.\n", ap -> nplanes ) ;
break ;

case DEPART :
printf ( "\nPlane %d ready to take off.\n", ap -> nplanes ) ;
break ;

}
}

void refuse ( airport *ap, int action )

{
switch ( action )
{
case ARRIVE :

printf ( "\tplane %d directed to another airport.\n", ap -> pln.id ) ;

break ;

case DEPART :

printf ( "\tplane %d told to try later.\n", ap -> pln.id ) ;

break ;
}
( ap -> nrefuse )++ ;
}

void land ( airport *ap, plane pl, int curtime )

{
int wait ;

wait = curtime - pl.tm ;

printf ( "%d: Plane %d landed ", curtime, pl.id ) ;
printf ( "in queue %d units \n", wait ) ;
( ap -> nland ) ++ ;
( ap -> landwait ) += wait ;
( ap -> nvarianceland ) += pow(wait,2);
}

void fly ( airport *ap, plane pl, int curtime )

{
int wait ;

wait = curtime - pl.tm ;

printf ( "%d: Plane %d took off ", curtime, pl.id ) ;
printf ( "in queue %d units \n", wait ) ;
( ap -> ntakeoff )++ ;
( ap -> takeoffwait ) += wait ;
( ap -> nvariancetakeoff ) += pow(wait,2);

void idle ( struct airport *ap, int curtime )

{

printf ( "%d: Runway is idle.\n", curtime ) ;

ap -> idletime++ ;
}

void conclude ( struct airport *ap, int endtime )

{
double x = ( ( double ) ap -> landwait / ap -> nland );
double x2 = ( (double)ap -> nvarianceland / ap -> nland );
double variance_land = x2 - pow(x , 2);
double xt = ( ( double ) ap -> takeoffwait / ap -> ntakeoff);
double x2t =( (double ) ap -> nvariancetakeoff / ap -> ntakeoff);
double variance_takeoff = x2t - pow(xt , 2);

printf ( "\tSimulation has concluded after %d units.\n", endtime ) ;

printf ( "\tTotal number of planes processed: %d\n", ap -> nplanes ) ;
printf ( "\tNumber of planes landed: %d\n", ap -> nland ) ;
printf ( "\tNumber of planes taken off: %d\n", ap -> ntakeoff ) ;
printf ( "\tNumber of planes refused use: %d\n", ap -> nrefuse ) ;
printf ( "\tNumber left ready to land: %d\n", apsize ( *ap, 'l' ) ) ;
printf ( "\tNumber left ready to take off: %d\n", apsize ( *ap, 't' ) ) ;

printf("\n **** REPORT **** \n");

if ( endtime > 0 )
printf ( "\tPercentage of time runway idle: %lf \n", ( ( double ) ap ->
idletime / endtime ) * 100.0 ) ;

if ( ap -> nland > 0 )

{ printf ( "\tAverage wait time to land: %lf \n", x ) ;
printf("\t Vairance wait time to land: %lf \n",variance_land); }

if ( ap -> ntakeoff > 0 )

{ printf ( "\tAverage wait time to take off: %lf \n", xt ) ;
printf("\t Vairance wait time to take off: %lf \n",variance_takeoff); }

int randomnumber ( double expectedvalue )

{
int n = 0 ;
double em ;
double x ;

em = exp ( -expectedvalue ) ;
x = rand( ) / ( double ) INT_MAX ;

while ( x > em )
{

n++ ;
x *= rand( ) / ( double ) INT_MAX ;
}

return n ;
}

void apaddqueue ( struct airport *ap, char type )

{
switch ( tolower( type ) )
{
case'l' :
addqueue ( ap -> pl, ap -> pln ) ;
break ;

case't' :
addqueue ( ap -> pt, ap -> pln ) ;
break ;
}
}

plane apdelqueue ( airport *ap, char type )

{
struct plane p1 ;

switch ( tolower ( type ) )

{
case'l' :
p1 = delqueue ( ap -> pl ) ;
break ;

case't' :
p1 = delqueue ( ap -> pt ) ;
break ;
}

return p1 ;
}

int apsize ( airport ap, char type )

{
switch ( tolower ( type ) )
{
case'l' :
return ( size ( *( ap.pl ) ) ) ;

case't' :
return ( size ( *( ap.pt ) ) ) ;

return 0 ;
}

int apfull ( airport ap, char type )

{
switch ( tolower ( type ) )
{
case'l' :
return ( full ( *( ap.pl ) ) ) ;

case't' :
return ( full ( *( ap.pt ) ) ) ;
}

return 0 ;
}

int apempty ( airport ap, char type )

{
switch ( tolower ( type ) )
{
case'l' :

return ( empty ( *( ap.pl ) ) ) ;

case't' :
return ( empty ( *( ap.pt ) ) ) ;
}

return 0 ;
}

void myrandomize( )
{
srand ( ( unsigned int ) ( time ( NULL ) % 10000 ) ) ;
}

int main( )
{
airport a ;
int i, pri, curtime, endtime ;
double expectarrive, expectdepart ;
plane temp ;

initairport ( &a ); // Initialisation Routine

start ( &endtime, &expectarrive, &expectdepart ) ; // Input Parameters

for ( curtime = 1 ; curtime <= endtime ; curtime++ ) // Timing Routine

{
pri = randomnumber ( expectarrive ) ;

for ( i = 1 ; i <= pri ; i++ )

{
newplane ( &a, curtime, ARRIVE ) ;
if ( apfull ( a, 'l' ) )
refuse ( &a, ARRIVE ) ;
else
apaddqueue( &a, 'l' ) ;
}

pri = randomnumber ( expectdepart ) ;

for ( i = 1 ; i <= pri ; i++ )
{
newplane ( &a, curtime, DEPART ) ;
if ( apfull ( a, 't' ) )
refuse ( &a, DEPART ) ;
else
apaddqueue ( &a, 't' ) ;
}

if ( ! ( apempty ( a, 'l' ) ) )
{
temp = apdelqueue ( &a, 'l' ) ;
land ( &a, temp, curtime ) ;
}
else
{
if ( ! ( apempty ( a, 't' ) ) )
{
temp = apdelqueue ( &a, 't' ) ;
fly ( &a, temp, curtime ) ;
}
else
idle ( &a, curtime ) ;
}
}

conclude ( &a, endtime ) ; // Report Generator Routine

Output:

Line Graph for the Output: