Professional Documents
Culture Documents
Design and Implementation of A Virtual Organization in Grid Computing Environment: Implementation of Air Traffic Control (ATC) System
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.
3.
3.1
4.
4.2
Scheduling policies............................................................................................ 13
4.3
Statistics......................................................................................................... 17
4.4
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.
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.
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
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
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
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
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
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)
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
package atc;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
*
* @author OPC
*/
public class TrailComponent extends JLabel {
package atc;
import java.awt.*;
import javax.swing.*;
/**
*
* @author OPC
13
*/
public class Main {
//atcscreen.setSize(300,300);
//frame.pack();
frame.setVisible(true);
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
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
/* plane specs */
private String callsign; // tail number
private int climbrate;
/* clearance */
private int cl_heading;
private int cl_alt;
// degrees
// feet
// knots
/* current */
private int cu_heading;
private int cu_alt;
private int cu_speed;
// degrees
// feet
// knots
18
= 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;
cl_direct = fix;
}
// 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
}
// 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
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
posx+=delta_x;
posy-=delta_y;
System.currentTimeMillis() / 1000);
}
29
{
return cu_alt;
}
public int getClAlt()
{
return cl_alt;
}
// degrees
// feet
// knots
// degrees
// feet
// knots
*/
32
package atc;
import java.awt.*;
import javax.swing.*;
import java.util.*;
/**
*
* @author OPC
*/
public class AtcScreen extends JPanel {
33
setLayout( null );
}
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
}
}
}
Below are some of the important snapshots of the proposed ATC system
36
37
References
17-31
Esser, R. (2010). Moses-a tool suite for visual modeling of discrete-event
38
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