Design and implementation of a

virtual organization in Grid

Computing environment:
Implementation of Air Traffic
Control (ATC) system

Table of Contents
1.

Introduction............................................................................................................. 3

2.

ATC (Air Traffic Control) System.................................................................................. 4

3.

Modeling of ATC system............................................................................................. 4

Data flow modeling................................................................................................. 5

3.1
4.

Implementation of ATC System...................................................................................11

4.1

Grid resource and Grid users................................................................................ 11

4.2

Scheduling policies............................................................................................ 13

4.3

Statistics......................................................................................................... 17

4.4

GUI of the ATC System...................................................................................... 32

References................................................................................................................... 37

1. Introduction

Initial model of Air Traffic Control (ATC) was proposed in 1960s, where the popularity and
demand of the system has increased a lot against the security and safety in the sky. Air travel has
become a frequent routine over the human life and thus in this context, ATC system have become
more overloaded and strained. A continuous change and improvement over the ATC system are
noticed since a decade and the requirements are ever increasing, where the initial ATC system are
restricted to limited functionalities as there are only few air crafts flying. Due to the increased
volume of air traffic, respective controlling mechanism got ample priority and the main objective
of ATC systems is to reduce the human errors and avoid unsafe methodologies over the
traditional systems. Thus to reduce to the air traffic and aviation accidents, a fully automatic and
sophisticated ATC system is always required. Most of the todays Air Traffic Control (ATC)
systems is to maintain an aircraft separation mechanism automatically and thus impose the
required orderly and safe traffic flow against the wide number of aircraft safety guidelines. A
typical ATC system is responsible to handle vast number people, network and equipment and
thus a complex design and implementation is always required (Yam, 2003).
A typical ATC can be designed and simulated using many tools, still the quality plays the vital
role in this context and pre-simulation or implementation tasks like modeling, data flow analysis,
activity analysis and software development methodology has the top priority. Main objective of
the current system is to design and implement a typical ATC system using GridSim and Java
programming language and to accomplish a simple scenario is considered and is as explained.
Both the resource and schedule modeling is done over the current research against the demands
of distributed and parallel computing needs for virtualization of the machines and the
corresponding resource environments. Key activities of the ATC system implementation like preflight, takeoff, descent, en-route, landing and approach are considered over the current system,
where the communication among these activities are modeled using the UML standards (Hall,
2000). Application will be developed using the Java code, where a rich graphical user interface
(GUI) is developed with the required classes, sub-classes, methods and functionalities as well.

Detailed explanation to the ATC system and the modeling done to design and implement the
required system are as explained.

2. ATC (Air Traffic Control) System

Air Traffic Control (ATC) can be defined as the typical service provided by the base ground
controller and is used to pass the directions and guidelines to the aircrafts in the air and on the
ground. As mentioned due to the increased traffic and volume of aircrafts, role of ATC have
become crucial, where the entire system can be analyzed at primary and secondary level based
on the tasks involved over the control operations. Primary task of a typical ATC system is
considered to enable the controller to keep the aircraft at a safe distance both from the horizontal
and vertical point of reference and the secondary task is to ensure the sequence or orderly traffic
flow based on the information shared with the pilots which is in turn gathered from weather
advisors, radar advisors, navigation information base and flight guidelines (Brown, 2009).
There was lot of historic background and many versions and models of ATC were releases and
still the common goal resides the same. Irrespective of number of solutions proposed to design
and implement the ATC system, still the scope of developing new model is open and thus the
main aim of the current research is to model, design and implement the ATC system using typical
software modeling, database modeling and GridSim and Java simulations. GridSim is used for
simulation of ATC system as it provides wide range of functionalities and heterogeneous classes,
applications, resources, users and resource brokers and schedulers (Murray, 2003). Single and
multiple administrative tasks are also enabled with the GridSim simulation and thus variant
applications can be developed over the Grid and Parallel computing environment. Software, user
interface and data modeling for the required ATC system is developed and discussed in the below
section.

3. Modeling of ATC system

As mentioned modeling a typical ATC (Air Traffic Control) system, includes the design of data
flow modeling, user interface modeling and business logic modeling. To model the business
logic and user interface standards UML can be used and the overall flow of the ATC system and
the respective applications can be represented using the use cases, sequence diagrams, activity
and context diagrams (Meyn, 2010). Data flow modeling can be done using DFDs, where the
respective modeling is done from the level 0 to the detailed Level n modeling and the respective
representations are as given below

3.1 Data flow modeling

Prior to model the required ATC system, it is always required to consider the key elements of the
system and they are discussed in this section. In general Air Traffic Control is composed of
various components or elements which includes communication systems, navigation systems,
radios, computers, radars and other important instruments that guide the entire process of aircraft
flying. Air Traffic controllers are well trained to handle the entire ATC system and can monitor
the ground level activities based on the information obtained against the speed and location of
each and every aircraft. Main aspect considered in this context is that, controller can guide the
aircraft against either they should come vertically or horizontally or too close to each other,
where the additional safety conditions in terms of landing or takeoff are also imposed by the
controller (Bauer, 2011).
As the main goal of the ATC system is to reduce the risks associated with the collisions of
aircrafts against number of increased aircrafts they can fly safely simultaneously at the same
time. Thus by considering all these aspects into account, four important elements are identified
over the data flow modeling for the current ATC system and they are as listed below

Basic set of rules that guide the flying of the aircraft for the pilot who fly the aircraft in

the air
Second important element is to set the required magnitude and multitude for the
respective navigation system which can handle the entire instrumentation and landing
system
5

Third element is to surface division of airport and the air space against various control
areas. Other important elements considered in this level also include landing, takeoff and

aircraft tracking
Fourth element is establishing the communication among the controllers-controllers,
pilot-controllers and the respective equipment that is involved over the communication
(Rabner, 2006).

ARTCC (Air Route Traffic Control Center) is one of the largest components over the airspace
system and in general a typical ARTCC can cover up to thousands of square miles and a typical
geographical coverage snapshot of ARTCC is as shown below

Fig 3.1.1: ARTCC Geographical Coverage (Rabner, 2006)

Thus based on the key requirements and elements identified over the ATC system, now the
required ATC Data flow modeling is done. In general DFD can be considered as an important
technique to show and analyze the transformation of input data to output via a sequence of
functional transformations over the system boundaries and thus considered as postulated systems

as well. DFD modeled for the current ATC system will hold the key information and they are as
listed below

Data storage location

Data flow among the data objects
External devices that are used to send and receive the data
Data changing processes

Based on the key information related to data objects DFDs are modelled at Level 0, Level 1 and
Level 2 and they are as shown below

Level 0 DFD

Fig 3.1.2: ATC Level 0 DFD

Level 0 DFD as shown in the above figure it is clear that, high level data entities, connections
and relations are analyzed at this level. As a typical ATC system is complex to analyze, only one
entity is shown, where the Pilot entity is used to display overall ATC controller and data store
information. Pilot of the system can record the flight information and it includes flight plans and
the destination airports. Flight plan will be enabled by the controller and the respective
information will be tracked and stored across a file. Weather updates will be gathered and stored
over a separate file and thus can be used prior or during the aircraft flying. Using the tack
number a typical transponder code will be generated and thus in the emergency cases pilots can
send a request to the nearest TRACON (Terminal Radar Approach Control) system. Once the
track order update is received at the TRACON end, any changes in the order will be updated and
thus better safety can be ensured. Pilot can also impose alternative flight plan based on the order
of the tracking plan and the track number (Chen, 2008).

Level 1 DFD

Detailed explanation to the data flow of the ATC system is given in this section and all the
processes shown in the Level 0 DFD are elaborated at Level 1 DFD. ATC system generating the
required flight plan which will include the data like aircraft ID, ground speed, reported altitude
and assigned altitude against the flight information available. Both the destination and departure
airport information is also tracked at this level and if there are any airport transits then the flight
plan will be updated accordingly such that city of the airport will be updated (Esser, 2010).
Unique identifier is allocated to each and every new tracked created and the other important
attributes of the entity also include speed, latitude, heading and longitude and the level 1 DFD is
as shown below

Fig 3.1.3: Level 1 ATC DFD

Level 2 DFD

Much detailed explanation to the data object, data flow and transformation of all the entities
identified are given in the level 2 DFD of ATC system. Exact processes and the data flow among
are identified over this level and they are incorporated at each and every stage identified over the
previous levels. Alarm generation is enabled using the alarm process and can be used to track the
exact positioning of two aircrafts even at minute levels. Separate tracking of predicted area is
9

also model over the level 2 DFD of the proposed ATC system, which is used to exactly track the
prediction aspects of the flight information. Filtering process is also modeled at the level 2 DFD
and thus the modern ATC systems within a specific range will be filtered based on the respective
range values and thus the monitoring of the controller will be efficient against traffic analysis and
the respective processes are shown in the below level 2 DFD of ATC system (Greving, 2012)

Fig 3.1.4: Level 2 DFD of ATC system

From the above level 2 DFD of the proposed ATC system it is clear that, many detailed processes
are identified and the flow among them is also shown.
10

4. Implementation of ATC System

As mentioned at the design level and based on the DFD modeling of the proposed ATC system, a
complex simulation model is developed using GridSim and Java and the corresponding code is
as given below

4.1 Grid resource and Grid users

package atc;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
*
* @author OPC
*/
public class TrailComponent extends JLabel {

private int posx;

private int posy;
11

/** Creates a new instance of ComponentTest */

public TrailComponent(int x, int y)
{
posx = x; posy = y;
}

public int getPosX()

{
return posx;
}
public int getPosY()
{
return posy;
}
public void setPosX(int x)
{
posx=x;
}
public void setPosY(int y)
{
posy=y;
12

public void paint(Graphics g) {

Graphics2D g2d = (Graphics2D)g;

g2d.setColor(Color.LIGHT_GRAY);
g2d.drawRect(0,0, 5, 5);
g2d.dispose();
}

4.2 Scheduling policies

package atc;

import java.awt.*;
import javax.swing.*;
/**
*
* @author OPC
13

*/
public class Main {

private static AtcScreen atcscreen;

private static JFrame frame;
/** Creates a new instance of Main */
public Main() {
}

private static void createAndShowGUI() {

//Make sure we have nice window decorations.
JFrame.setDefaultLookAndFeelDecorated(true);

//Create and set up the window.

frame = new JFrame("ATC simulator");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

atcscreen = new AtcScreen();

atcscreen.setOpaque(true);
frame.setContentPane(atcscreen);

//Display the window.

frame.setSize(600,600);
14

//atcscreen.setSize(300,300);
//frame.pack();
frame.setVisible(true);
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

//Schedule a job for the event-dispatching thread:

//creating and showing this application's GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});

AirPlane ap1 = new AirPlane("a1", 50, 5, 100, 50000, "bogus1", 200, 200, 200, 10);
15

AirPlane ap2 = new AirPlane("a2", 50, 5, 100, 10000, "bogus2", 200, 300, 250, 10);

ap1.SetClearAlt(1000);
ap1.SetClearHeading(1);
ap1.SetClearSpeed(75);

try
{
Thread.sleep(2000);
}
catch(Exception e)
{
System.out.println("insomnia!");
}

atcscreen.addplane(ap1);
atcscreen.addplane(ap2);

while(true)
{
try
{
16

Thread.sleep(4000);
}
catch(Exception e)
{
System.out.println("insomnia!");
}
atcscreen.update(); // this will update the "radar" screen
frame.repaint();
}
}
}

4.3 Statistics

package atc;

import java.util.*;

/**
*
* @author OPC
*/
17

public class AirPlane {

/* plane specs */
private String callsign; // tail number
private int climbrate;

// feet per second

private int turnrate;

// degree per second

/* clearance */
private int cl_heading;
private int cl_alt;

// degrees
// feet

private String cl_direct; //

private int cl_speed;

// knots

/* current */
private int cu_heading;
private int cu_alt;
private int cu_speed;

// degrees
// feet
// knots

private double cu_speed_pix; // speed in pixels

private int posx;
private int posy;
private int accel;

// knots per second

private int deccel;

// knots per second

18

private long IterTimeStamp; // time stamp of last iteration in seconds

public LabelComponent apLabel;

public TrailComponent[] trailarray = new TrailComponent[4];

/** Creates a new instance of AirPlane */

public AirPlane( String call_sign, int climb_rate, int turn_rate, int heading,
int alt, String direct, int speed, int pos_x, int pos_y , int accel_rate) {
cu_heading = cl_heading
cu_alt
cu_speed

= cl_alt

= heading;

= alt;

= cl_speed

= speed;

cu_speed_pix= cu_speed*0.1;
cl_direct = direct;

callsign

= call_sign;

climbrate = climb_rate;
turnrate = turn_rate;
accel

= accel_rate;

posx

= pos_x;

posy

= pos_y;

IterTimeStamp = System.currentTimeMillis() / 1000;

19

apLabel = new LabelComponent(this);

trailarray[0] = new TrailComponent(posx,posy);

trailarray[1] = new TrailComponent(posx,posy);
trailarray[2] = new TrailComponent(posx,posy);
trailarray[3] = new TrailComponent(posx,posy);

public void SetClearHeading(int heading)

{
cl_heading = heading;
}

public void SetClearAlt(int alt)

{
cl_alt = alt;
}

public void SetClearDirect(String fix)

{
20

cl_direct = fix;
}

public void SetClearSpeed(int speed)

{
cl_speed = speed;
}

public void PlaneProcess()

{
// get time
// compare time with previous process iteration
long TimeDiff = System.currentTimeMillis() / 1000 - IterTimeStamp;

// boundary check. >360 and <0

if(cl_heading>360)
{
cl_heading -=360;
}
if(cl_heading<0)
{
cl_heading +=360;
}
21

// calculate heading
if (cl_heading != cu_heading)
{
if(cu_heading > cl_heading)
{
if((cu_heading - cl_heading) <= 180) // turn left
{
int delta = (int)TimeDiff * turnrate;
if (delta > (cu_heading - cl_heading))
{
delta = cu_heading - cl_heading;
}
cu_heading = cu_heading - delta;
}
else // turn right
{
int delta = (int)TimeDiff * turnrate;
if (delta > (cu_heading - cl_heading))
{
delta = cu_heading - cl_heading;
}
cu_heading = cu_heading + delta;
}
22

}
else
{
if((cl_heading - cu_heading) <= 180) // turn right
{
int delta = (int)TimeDiff * turnrate;
if (delta > (cl_heading - cu_heading))
{
delta = cl_heading - cu_heading;
}
cu_heading = cu_heading + delta;
}
else // turn left
{
int delta = (int)TimeDiff * turnrate;
if (delta > (cl_heading - cu_heading))
{
delta = cl_heading - cu_heading;
}
cu_heading = cu_heading - delta;
}
}
if(cu_heading>360)
23

{
cu_heading -=360;
}
if(cu_heading<0)
{
cu_heading +=360;
}
}

// calculate alt
if (cl_alt != cu_alt)
{
//System.out.println("adjusting alt by " + (int)TimeDiff * climbrate);
if (cl_alt > cu_alt)
{
cu_alt = cu_alt + (int)TimeDiff * climbrate;
//check for overshoot
if (cl_alt < cu_alt)
cu_alt = cl_alt;

}
else
{
24

cu_alt = cu_alt - (int)TimeDiff * climbrate;

// check for overshoot
if (cl_alt > cu_alt)
cu_alt = cl_alt;

}
// calculate speed
if (cl_speed != cu_speed)
{
//System.out.println("adjusting accel by " + (int)TimeDiff * accel);
if (cl_speed > cu_speed)
{
cu_speed = cu_speed + (int)TimeDiff * accel;
//check for overshoot
if (cl_speed < cu_speed)
cu_speed = cl_speed;

}
else
{
cu_speed = cu_speed - (int)TimeDiff * accel;
25

// check for overshoot

if (cl_speed > cu_speed)
cu_speed = cl_speed;

cu_speed_pix = cu_speed * 0.1;

}

for(int i=2; i>=0; i--)

{
trailarray[i+1].setPosX(trailarray[i].getPosX());
trailarray[i+1].setPosY(trailarray[i].getPosY());
}
trailarray[0].setPosX(posx);
trailarray[0].setPosY(posy);

// calculate pos x and y

//get angle with x axis

int tempheading;
if (cu_heading - 270 >= 0)
26

{
tempheading = cu_heading - 270;
// 2nd quadrant
double delta_y =0;
double delta_x =0;
delta_y = cu_speed_pix * java.lang.Math.sin(java.lang.Math.toRadians(tempheading));
delta_x = cu_speed_pix * java.lang.Math.cos(java.lang.Math.toRadians(tempheading));

posx-=delta_x;
posy-=delta_y;

}
else if (cu_heading - 180 >=0)
{
tempheading = 270 - cu_heading;
// 3rd quadrant
double delta_y =0;
double delta_x =0;
delta_y = cu_speed_pix * java.lang.Math.sin(java.lang.Math.toRadians(tempheading));
delta_x = cu_speed_pix * java.lang.Math.cos(java.lang.Math.toRadians(tempheading));

posx-=delta_x;
posy+=delta_y;
27

}
else if (cu_heading - 90 >= 0)
{
tempheading = cu_heading - 90;
// 4th quadrant
double delta_y =0;
double delta_x =0;

delta_y = java.lang.Math.sin(java.lang.Math.toRadians(tempheading));
delta_x = java.lang.Math.cos(java.lang.Math.toRadians(tempheading));

delta_y *= cu_speed_pix;
delta_x *= cu_speed_pix;

posx+=delta_x;
posy+=delta_y;

}
else
{
// 1st quadrant
tempheading = 90 - cu_heading;
28

double delta_y =0;

double delta_x =0;
delta_y = cu_speed_pix * java.lang.Math.sin(java.lang.Math.toRadians(tempheading));
delta_x = cu_speed_pix * java.lang.Math.cos(java.lang.Math.toRadians(tempheading));

posx+=delta_x;
posy-=delta_y;

IterTimeStamp = System.currentTimeMillis() / 1000;

}

public void printPlane()

{
System.out.println("current speed = "+cu_speed + " cleared to "+cl_speed);
System.out.println("current alt = "+cu_alt + " cleared to "+cl_alt);
System.out.println("current heading = "+cu_heading + " cleared to "+cl_heading);
System.out.println("**************************************"

System.currentTimeMillis() / 1000);
}

29

public int getPosX()

{
return posx;
}
public int getPosY()
{
return posy;
}
public String getCallSign()
{
return callsign;
}
public int getCuHeading()
{
return cu_heading;
}

public int getClHeading()

{
return cl_heading;
}

public int getCuAlt()

30

{
return cu_alt;
}
public int getClAlt()
{
return cl_alt;
}

public int getCuSpeed()

{
return cu_speed;
}

public int getClSpeed()

{
return cl_speed;
}
/*

private String callsign; // tail number

private int climbrate;

// feet per second

31

private int turnrate;

// degree per second

private int cl_heading;

private int cl_alt;

// degrees
// feet

private String cl_direct; //

private int cl_speed;

// knots

private int cu_heading;

private int cu_alt;
private int cu_speed;

// degrees
// feet
// knots

private int posx;

private int posy;
private int accel;

// knots per second

private int deccel;

// knots per second

*/

4.4 GUI of the ATC System

32

package atc;

import java.awt.*;
import javax.swing.*;
import java.util.*;

/**
*
* @author OPC
*/
public class AtcScreen extends JPanel {

// Create the list

java.util.List<AirPlane> planelist;

public AirPlane ap = null;

/** Creates new form AtcScreen */
public AtcScreen()
{

33

planelist = new ArrayList();

// List implemented as growable array

setLayout( null );
}

public void addplane(AirPlane airplane)

{
// add plane to a list for paint

planelist.add(airplane);

add(airplane.apLabel);
airplane.apLabel.setLocation(airplane.getPosX(), airplane.getPosY());
airplane.apLabel.setSize(75,40);
for(int i=0; i<4; i++)
{
add(airplane.trailarray[i]);
airplane.trailarray[i].setLocation(airplane.trailarray[i].getPosX(),airplane.trailarray[i].get
PosY());
airplane.trailarray[i].setSize(7,7);
}

34

public void updateLabelLocation(AirPlane airplane)

{
airplane.apLabel.setLocation(airplane.getPosX(), airplane.getPosY());
for(int i=0; i<4; i++)
{
airplane.trailarray[i].setLocation(airplane.trailarray[i].getPosX(),airplane.trailarray[i].get
PosY());
}

public void update()

{
Iterator<AirPlane> it = planelist.iterator();
while (it.hasNext())
{
AirPlane ap = it.next();
ap.PlaneProcess();
updateLabelLocation(ap);
35

}
}
}

Below are some of the important snapshots of the proposed ATC system

36

37

References

Bauer, J. (2011). Identification and Modeling of Contexts for Different Information

Scenarios in Air Traffic. Eurocontrol Experimental Centre Bretigny, 41(2), 41-59.

Brown, T. (2009). Networking Issues for Small Unmanned Aircraft Systems. Journal of

Intelligent and Robotic Systems, 1(3), 67-90.

Chen, B. (2008). A Review of the Applications of Agent Technology in Traffic and
Transportation Systems. Intelligent Transportation Systems, IEEE Transactions, 11(2),

17-31
Esser, R. (2010). Moses-a tool suite for visual modeling of discrete-event

systems. Human-Centric Computing Languages and Environments, 11(2), 32-29

Greving, G. (2012). Status and Progress of ATC Simulations. Journal of Grid
Computing,89(27), 10-22.

38

Hall, A. (2000). Using Formal Methods to Develop an ATC Information

System. Industrial-Strength Formal Methods in Practice Formal Approaches to

Computing and Information Technology, 7(2), 89-93.

Meyn, L. (2010). Build 4 of the Airspace Concept Evaluation System. AIAA MODELING

AND SIMULATION TECHNOLOGIES CONFERENCE AND EXHIBIT, 38(4), 100-119.

Murray, R. (2003). Future directions in control in an information-rich world. Control

Systems, IEEE, 23(2), 12-19.

Rabner, K. (2006). A Real-Time Probabilistic Traffic Flow Management Evaluation

Tool. 25th Digital Avionics Systems Conference, 2006 IEEE/AIAA, 25(2), 32-28
Yam, B. (2003). When systems engineering fails-toward complex systems
engineering.Systems, Man and Cybernetics, 2003. IEEE International Conference, 2(1),
16-23.

39