1 // FGGround - a class to provide ground control at larger airports.
3 // Written by David Luff, started March 2002.
5 // Copyright (C) 2002 David C. Luff - david.luff@nottingham.ac.uk
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 // General Public License for more details.
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #ifndef _FG_GROUND_HXX
22 #define _FG_GROUND_HXX
33 #include <simgear/math/point3d.hxx>
34 #include <simgear/misc/sgstream.hxx>
35 #include <simgear/math/sg_geodesy.hxx>
38 #include "ATCProjection.hxx"
44 //////////////////////////////////////////////////////
45 // Types for the logical network data structure
46 typedef enum arc_type {
51 typedef enum node_type {
61 TRANSPORT_PASSENGER_NARROWBODY,
62 TRANSPORT_PASSENGER_WIDEBODY,
70 OTHER // ie. anything goes!!
73 typedef enum network_element_type {
78 struct ground_network_element {
79 network_element_type struct_type;
82 struct arc : public ground_network_element {
86 bool directed; //false if 2-way, true if 1-way.
87 //This is a can of worms since arcs might be one way in different directions under different circumstances
88 unsigned int n1; // The nodeID of the first node
89 unsigned int n2; // The nodeID of the second node
90 // If the arc is directed then flow is normally from n1 to n2. See the above can of worms comment though.
93 typedef vector <arc*> arc_array_type; // This was and may become again a list instead of vector
94 typedef arc_array_type::iterator arc_array_iterator;
95 typedef arc_array_type::const_iterator arc_array_const_iterator;
97 struct node : public ground_network_element {
101 unsigned int nodeID; //each node in an airport needs a unique ID number - this is ZERO-BASED to match array position
107 double max_turn_radius;
110 typedef vector <node*> node_array_type;
111 typedef node_array_type::iterator node_array_iterator;
112 typedef node_array_type::const_iterator node_array_const_iterator;
114 struct Gate : public node {
116 int max_weight; //units??
117 //airline_code airline; //For the future - we don't have any airline codes ATM
118 int id; // The gate number in the logical scheme of things
119 string name; // The real-world gate letter/number
122 double heading; // The direction the parked-up plane should point in degrees
125 typedef vector < Gate* > gate_vec_type;
126 typedef gate_vec_type::iterator gate_vec_iterator;
127 typedef gate_vec_type::const_iterator gate_vec_const_iterator;
129 // A map of gate vs. the logical (internal FGFS) gate ID
130 typedef map < int, Gate* > gate_map_type;
131 typedef gate_map_type::iterator gate_map_iterator;
132 typedef gate_map_type::const_iterator gate_map_const_iterator;
134 // Runways - all the runway stuff is likely to change in the future
136 int id; //note this is a very simplified scheme for now - R & L are not differentiated
137 //It should work for simple one rwy airports
138 node_array_type exits; //Array of available exits from runway
139 // should probably add an FGRunway structure here as well eventually
140 // Eventually we will also want some encoding of real-life preferred runways
141 // This will get us up and running for single runway airports though.
143 typedef vector < Rwy > runway_array_type;
144 typedef runway_array_type::iterator runway_array_iterator;
145 typedef runway_array_type::const_iterator runway_array_const_iterator;
147 // end logical network types
148 ///////////////////////////////////////////////////////
150 ///////////////////////////////////////////////////////
151 // Structures to use the network
153 // A path through the network
154 typedef vector < ground_network_element* > ground_network_path_type;
155 typedef ground_network_path_type::iterator ground_network_path_iterator;
156 typedef ground_network_path_type::const_iterator ground_network_path_const_iterator;
158 //////////////////////////////////////////////////////////////////////////////////////////
160 ////////////////////////////////////////////////
162 // Stuff for the shortest-path algorithms
166 ground_network_path_type path;
170 // Paths mapped by nodeID reached so-far
171 typedef map < unsigned int, a_path* > shortest_path_map_type;
172 typedef shortest_path_map_type::iterator shortest_path_map_iterator;
174 // Nodes mapped by their ID
175 //typedef map < unsigned int, node* > node_map_type;
176 //typedef node_map_type::iterator node_map_iterator;
177 ////////////////////////////////////////////////
179 // Planes active within the ground network.
180 // somewhere in the ATC/AI system we are going to have defined something like
181 // typedef struct plane_rec
182 // list <PlaneRec> plane_rec_list_type
184 // A more specialist plane rec to include ground information
185 typedef struct ground_rec {
190 bool cleared; // set true when the plane has been cleared to somewhere
191 bool incoming; //true for arrivals, false for departures
193 // Almost certainly need to add more here
196 typedef list<ground_rec*> ground_rec_list;
197 typedef ground_rec_list::iterator ground_rec_list_itr;
198 typedef ground_rec_list::const_iterator ground_rec_list_const_itr;
200 //////////////////////////////////////////////////////////////////////////////////////////
202 ///////////////////////////////////////////////////////////////////////////////
206 ///////////////////////////////////////////////////////////////////////////////
207 class FGGround : public FGATC {
216 inline string get_trans_ident() { return trans_ident; }
217 inline atc_type GetType() { return GROUND; }
218 inline void SetDisplay() {display = true;}
219 inline void SetNoDisplay() {display = false;}
221 // Its possible that NewArrival and NewDeparture should simply be rolled into Request.
223 // Contact ground control on arrival, assumed to request any gate
224 //void NewArrival(plane_rec plane);
226 // Contact ground control on departure, assumed to request currently active runway.
227 //void NewDeparture(plane_rec plane);
229 // Contact ground control when the calling routine doesn't know if arrival
230 // or departure is appropriate.
231 //void NewContact(plane_rec plane);
233 // Make a request of ground control.
234 //void Request(ground_request request);
236 // Randomly fill some of the available gates and GA parking spots with planes
237 void PopulateGates();
239 // Return a suitable gate (maybe this should be a list of suitable gates so the plane or controller can choose the closest one)
240 void ReturnGate(Gate &gate, GateType type);
242 // Return a pointer to an unused gate
245 // Runway stuff - this might change in the future.
246 // Get a list of exits from a given runway
247 // It is up to the calling function to check for non-zero size of returned array before use
248 node_array_type GetExits(int rwyID);
250 // Get a path from one node to another
251 ground_network_path_type GetPath(node* A, node* B);
253 // Get a path from a node to a runway threshold
254 ground_network_path_type GetPath(node* A, string rwyID);
258 // Need a data structure to hold details of the various active planes
259 // Need a data structure to hold details of the logical network
260 // including which gates are filled - or possibly another data structure
261 // with the positions of the inactive planes.
262 // Need a data structure to hold outstanding communications from aircraft.
263 // Possibly need a data structure to hold outstanding communications to aircraft.
265 // The logical network
266 // NODES WILL BE STORED IN THE NETWORK IN ORDER OF nodeID NUMBER
267 // ie. NODE 5 WILL BE AT network[5]
268 node_array_type network;
270 // A map of all the gates indexed against internal (FGFS) ID
272 gate_map_iterator gatesItr;
274 // Runway stuff - this might change in the future.
275 //runway_array_type runways; // STL way
276 Rwy runways[36]; // quick hack!
278 FGATCAlignedProjection ortho;
280 // Planes currently active
281 //ground_rec_list ground_traffic;
283 // Find the shortest route through the logical network between two points.
284 //FindShortestRoute(point a, point b);
286 // Project a point in WGS84 lat/lon onto the local gnomonic.
287 //ConvertWGS84ToXY(sgVec3 wgs84, point xy);
289 // Assign a gate or parking location to a new arrival
290 //AssignGate(ground_rec &g);
292 // Generate the next clearance for an airplane
293 //NextClearance(ground_rec &g);
295 bool display; // Flag to indicate whether we should be outputting to the ATC display.
296 bool displaying; // Flag to indicate whether we are outputting to the ATC display.
297 // for failure modeling
298 string trans_ident; // transmitted ident
299 bool ground_failed; // ground failed?
300 bool networkLoadOK; // Indicates whether LoadNetwork returned true or false at last attempt
302 // Load the logical ground network for this airport from file.
303 // Return true if successfull.
306 // Parse a runway exit string and push the supplied node pointer onto the runway exit list
307 void ParseRwyExits(node* np, char* es);
309 // Return a random gate ID of an unused gate.
310 // Two error values may be returned and must be checked for by the calling function:
311 // -2 signifies that no gates exist at this airport.
312 // -1 signifies that all gates are currently full.
313 // TODO - modify to return a suitable gate based on aircraft size/weight.
314 int GetRandomGateID();
316 // Return a pointer to the node at a runway threshold
317 // Returns NULL if unsuccessful.
318 node* GetThresholdNode(string rwyID);
320 // A shortest path algorithm sort of from memory (I can't find the bl&*dy book again!)
321 ground_network_path_type GetShortestPath(node* A, node* B);
324 #endif // _FG_GROUND_HXX