OOP Project Report

DEPARTMENT OF COMPUTER & SOFTWARE
ENGINEERING
COLLEGE OF E&ME, NUST, RAWALPINDI
Subject Name
Object Oriented Programming
PROJECT REPORT
SUBMITTED TO:
Ma’am Anum
Ma’am Mahnoor
SUBMITTED BY:
Students Name
1. Muhammad Mussa Kazim -404047
2. Muhammad Taha -417609
3. Sohaib Afzal -411928
DE- 44 Dept C&SE

Syn-A
Submission Date:
16th Jan, 2023
Project Name:
Simulation of Airport Surface Traffic Control (ASTC) System
Software Used:
IntelliJ Idea
Eclipse
Language Used:
Java
Explanation:
The project, "Object Oriented Modeling and Simulation of Airport Surface Traffic Control
(ASTC) System," aims to create a computer-based simulation of the airport surface traffic
control operations. Airport Surface Traffic Control is a critical aspect of managing air traffic
movements on the ground at an airport, ensuring the safe and efficient flow of aircrafts.
Here's an explanation of the project:
1. Objective:
- The primary goal is to model and simulate the operations of the Airport Surface Traffic
Control system, which involves the coordination and management of various activities on the
airport surface, such as taxiing, runway operations, gate assignments, and air movements.
2. Need for the Project:
- Safety: Airport surface traffic control is crucial for ensuring the safety of aircraft and
passengers. Simulating these operations allows for the identification and avoidance of potential
safety risks.
- Efficiency: Efficient ground operations are vital to reducing taxi times, minimizing delays,
and optimizing airport capacity. A simulation helps in evaluating and improving the efficiency
of surface traffic control procedures.
- Training: The simulation can serve as a training tool for air traffic controllers, ground staff,
and other personnel involved in airport operations. It provides a realistic environment for
practicing coordination and decision-making.
3. Key Components and Features:
- Aircraft Movements: Simulate the taxiing of aircraft on the ground, including interactions
with runways, taxiways, and gates.
- Runway Operations: Simulate the takeoff and landing sequences on runways, including
sequencing and clearance management.
- Gate Assignments: Manage the allocation of gates for arriving and departing flights based
on availability and operational constraints.
- Communication: Model the communication protocols and coordination between air traffic
control, ground control, and various airport service providers.
4. Benefits:
- Risk Assessment: Identify and address potential safety risks in airport ground operations.
- Operational Efficiency: Optimize taxi routes, gate assignments, and other procedures to
improve overall efficiency.
- Training and Skill Development: Provide a realistic training environment for personnel
involved in surface traffic control.
- Decision Support: Evaluate the impact of different scenarios and operational changes on
airport performance.
In summary, the project addresses the need for a comprehensive simulation of airport surface
traffic control to enhance safety, efficiency, and training within airport operations. The
simulation allows for the analysis of various operational scenarios, contributing to the
improvement of real-world surface traffic control systems at airports.
Description and Methodology:

Classes Uses:
First of all, lets see the classes that we have made and each class’s function in the program:
TaskEngine.java: The `Task Engine` class is a central component in our airport simulation
system. It manages tasks assigned to airplanes, ensuring proper sequencing and execution. Key
functionalities include collecting tasks for airplanes, sorting them based on start time and
priority, dispatching tasks to relevant modules, and handling exceptions related to task
identifiers. Additionally, the class facilitates task deletion and provides a method to display the
ordered list of tasks for reporting and monitoring purposes. Overall, the `Task Engine` class
plays a pivotal role in coordinating and overseeing the execution of tasks in a simulated airport
environment.
Task.java: The `Task` class represents specific tasks assigned to airplanes in an airport
simulation. It includes attributes such as ID, priority, identifiers, and start/end times. The class
generates random IDs, sets task priorities based on identifiers, and executes tasks related to
airplane movement, runway operations, and traffic control. Additionally, it handles the
scheduling and execution of landing and departure tasks, contributing to the overall simulation
of airport surface traffic control. It also has 3 Derived Classes to it:
- AirplaneRelatedTasks.java: It contains functions related to the Airplane Tasks.
- TrafficControlRelatedTasks.java: It contains functions related to Traffic Control i.e.
moving, holding etc.
- TrafficNetworkRelatedTasks.java: It contains functions related to Traffic Network i.e.
related to Runways, Taxiways and Gateways etc.
TaskComparator.java: This class is a comparator for sorting `Task` objects. It compares tasks
based on their start times and, in case of equal start times, prioritizes tasks based on their
priority values.
Airplane.java: The Àirplane` class represents airplanes in an airport simulation, storing
information such as ID, orientation, current position, destination, and travel-related details. It
includes methods for setting random IDs, calculating travel costs, and displaying airplane
information. Additionally, it has attributes to manage holding and parking status during the
simulation.
AirplaneList.java: The Àirplane List` class manages a list of airplanes in the airport
simulation. It provides functionality to create airplanes, assign IDs (both random and specified),
add and remove airplanes from the list, send tasks to specific airplanes, retrieve airplanes by ID,
and display information about all airplanes in the list. This class acts as a central repository for
handling airplane-related operations in the simulation.
AirplaneScheduler.java: The Àirplane Scheduler` class is responsible for scheduling tasks for
airplanes in the airport simulation. It interacts with the ÀirplaneList.java` and
`TaskEngine.java` classes to create a new airplane, set its departure and destination locations,
gather departure time input, calculate the arrival time based on the shortest path, calculate the
cost, and then collect and prioritize the task for the airplane in the simulation. This class
facilitates the initiation of tasks for airplanes within the airport system.
AirportGroundNetwork.java: The Àirport Ground Network` class models the ground
network infrastructure of the airport, including runways, taxiways, and gates. It uses Array Lists
to keep track of the availability of each runway, taxiway, and gate. The class provides methods
to retrieve information about the current occupancy status of runways, taxiways, and gates,
indicating whether they are occupied by airplanes and, if so, which airplane is present. This
class is essential for managing the ground movements and allocations for airplanes within the
airport simulation.
ShortestPath.java: The `ShortestPath` class implements Dijkstra's algorithm to find the
shortest paths from a given starting node to all other nodes in a weighted graph. It calculates the
shortest path distances and constructs the shortest path structure. The class provides a method
`dijkstra` that takes the starting and ending nodes as input and returns the shortest path distance
between them. This functionality is crucial for determining the optimal path for airplanes within
the airport simulation. It also Implements an Interface which is:
- Path.java: This interface basically just contains a 2d Array forming a graph which acts
as a path in our Program.
Clock.java and Clock.form: These basically Implement the Home Page and Runs the Global
Clock using Threading.
Virtual Path Used:
Other Assumptions:
- Number of Runways are Assumed to be 4 in our Airport Numbered 0.
- Number of Taxiways are Assumed to be 12 in our Airport Numbered 0.
- Number of Gates are Assumed to be 24 in our Airport Numbered 0.
- Cost per 100 km Distance = 100 Units
-
Task Priorities have been assigned automatically in our code through Primary and
Secondary Identifiers.
UML Diagram:
Flow Chart:
This Flowchart explains all the basic flow of our program.

Results & Output Explanation:
Main Output: Home Screen and Clock Runs on GUI While Input and Output is Shown on the
Terminal in Colored Style.
Explanation:
First, we ask the User about how many planes he want to schedule. Then, the Airplane
Scheduler prompts the user to Tell the Current Location and Destination of the Plane. It also
asks the User about the Departure Time. The Landing Time is Set Automatically Via the
Dijkstra’s Algorithm in out Code. This Departure Task automatically Make a Series of Tasks
including Exit Gate, Exit Taxiway, Exit Runway, Move, Permission to Land, Land on Runway,
Move to Taxiway and Move to Gate etc. All these tasks are set with some time delay to the
other and sent to Collecting Tasks Function in the Task Engine. All the Tasks are Sorted. If there
is some Delay e.g. if all Runways are occupied, then the specific task is Delayed via the
Pending Task Function, at the end of their Completion, Tasks are Deleted from the List.
Code for 1 Flight Schedule is Given Below:
Delay and Pending Logic & Output:
If some task cannot be performed at a certain stage e.g. all runways are occupied then that task
is delayed and time can be set by the user for next permission:
Limitations:
- We have implemented half of our Program on GUI and other half on the terminal.
- Program does not give the full path to path simulation, rather just implements the
shortest path through shortest time taken using the Location graph and Dijkstra’s
Algorithm.
- Airfield Traffic Flow Animator is not implemented in our program
Other than this, program was running okay on our test runs, however there could be a few
corner cases that we might have missed as we are still in our learning years.
Mathematical Modeling:
Mathematical Modeling was mainly involved in Shortest Path Algorithm where we used the
Dijkstra’s Algorithm. Using this, we calculated the Shortest Path Time, Distance and Lowest
Cost as well. Other than this, basic logics are applied to Runways, Taxiways and Gateways as
well as for Flow of the Overall Program that we have developed.
Team Collaboration:
All 3 of us worked together on this Project. A private Github Repository was maintained to keep
up to date with all the changes that we were making simultaneously.
Conclusion:
In conclusion, the Airport Surface Traffic Control (ASTC) System project demonstrates a
comprehensive simulation and management system for efficiently handling airplane traffic
within an airport environment. The object-oriented modeling and simulation approach utilized
in the project facilitate a realistic representation of various components, including airplanes,
tasks, and the ground network. The incorporation of task scheduling, dynamic pathfinding
algorithms, and a well-structured object-oriented design allows for effective control and
coordination of airport surface traffic. The collaborative functioning of all our classes ensure a
seamless simulation experience, capturing the complexities of real-world airport operations.
This project not only provides a valuable tool for studying and optimizing airport traffic control
but also serves as a robust foundation for potential future expansions and enhancements in the
field of aviation systems.

OOP Project Report

Uploaded by

Copyright:

Available Formats

OOP Project Report

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

OOP Project Report

Uploaded by

Copyright:

Available Formats

DEPARTMENT OF COMPUTER & SOFTWARE

DE- 44 Dept C&SE

Description and Methodology:

Virtual Path Used:

This Flowchart explains all the basic flow of our program.

You might also like