src/Traffic/TrafficMgr.cxx

   1 /******************************************************************************
   2  * TrafficMGr.cxx
   3  * Written by Durk Talsma, started May 5, 2004.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  *
  20  **************************************************************************/
  21
  22 /* This a prototype version of a top-level flight plan manager for Flightgear.
  23  * It parses the fgtraffic.txt file and determine for a specific time/date,
  24  * where each aircraft listed in this file is at the current time.
  25  *
  26  * I'm currently assuming the following simplifications:
  27  * 1) The earth is a perfect sphere
  28  * 2) Each aircraft flies a perfect great circle route.
  29  * 3) Each aircraft flies at a constant speed (with infinite accelerations and
  30  *    decelerations)
  31  * 4) Each aircraft leaves at exactly the departure time.
  32  * 5) Each aircraft arrives at exactly the specified arrival time.
  33  *
  34  *
  35  *****************************************************************************/
  36
  37 #ifdef HAVE_CONFIG_H
  38 #  include "config.h"
  39 #endif
  40
  41 #include <stdlib.h>
  42 #include <time.h>
  43 #include <iostream>
  44 #include <fstream>
  45
  46
  47 #include <string>
  48 #include <vector>
  49 #include <algorithm>
  50
  51 #include <plib/sg.h>
  52 #include <plib/ul.h>
  53
  54 #include <simgear/compiler.h>
  55 #include <simgear/math/polar3d.hxx>
  56 #include <simgear/math/sg_geodesy.hxx>
  57 #include <simgear/misc/sg_path.hxx>
  58 #include <simgear/props/props.hxx>
  59 #include <simgear/route/waypoint.hxx>
  60 #include <simgear/structure/subsystem_mgr.hxx>
  61 #include <simgear/xml/easyxml.hxx>
  62
  63 #include <AIModel/AIAircraft.hxx>
  64 #include <AIModel/AIFlightPlan.hxx>
  65 #include <AIModel/AIBase.hxx>
  66 #include <Airports/simple.hxx>
  67 #include <Main/fg_init.hxx>
  68
  69
  70
  71 #include "TrafficMgr.hxx"
  72
  73 SG_USING_STD(sort);
  74
  75 /******************************************************************************
  76  * TrafficManager
  77  *****************************************************************************/
  78 FGTrafficManager::FGTrafficManager()
  79 {
  80   score = 0;
  81   runCount = 0;
  82 }
  83
  84 FGTrafficManager:: ~FGTrafficManager()
  85 {
  86   for (ScheduleVectorIterator sched = scheduledAircraft.begin(); sched != scheduledAircraft.end(); sched++)
  87     {
  88       delete (*sched);
  89     }
  90   scheduledAircraft.clear();
  91   // for (FGScheduledFlightVecIterator flt = flights.begin(); flt != flights.end(); flt++)
  92 //     {
  93 //       delete (*flt);
  94 //     }
  95 //   flights.clear();
  96 }
  97
  98
  99 void FGTrafficManager::init()
 100 {
 101   //cerr << "Initializing Schedules" << endl;
 102   //time_t now = time(NULL) + fgGetLong("/sim/time/warp");
 103   //currAircraft = scheduledAircraft.begin();
 104   //while (currAircraft != scheduledAircraft.end())
 105   //  {
 106   //    if (!(currAircraft->init()))
 107   //    {
 108   //      currAircraft=scheduledAircraft.erase(currAircraft);
 109   //      //cerr << "Erasing " << currAircraft->getRegistration() << endl;
 110   //    }
 111   //   else
 112   //    {
 113   //      currAircraft++;
 114   //    }
 115   //   }
 116   // Sort by points: Aircraft with frequent visits to the
 117   // startup airport will be processed first
 118   ulDir* d, *d2;
 119   ulDirEnt* dent, *dent2;
 120   SGPath aircraftDir = globals->get_fg_root();
 121
 122   /* keep the following three lines (which mimicks the old "fixed path" behavior)
 123    * until we have some AI models with traffic in the base package
 124    */
 125   SGPath path = aircraftDir;
 126   path.append("Traffic/fgtraffic.xml");
 127   readXML(path.str(),*this);
 128
 129   aircraftDir.append("AI/Aircraft");
 130   if (aircraftDir.exists())
 131     {
 132       if((d = ulOpenDir(aircraftDir.c_str())) == NULL)
 133         return;
 134       while((dent = ulReadDir(d)) != NULL) {
 135         //cerr << "Scanning : " << dent->d_name << endl;
 136         if (string(dent->d_name) != string(".")  &&
 137             string(dent->d_name) != string("..") &&
 138             dent->d_isdir)
 139           {
 140             SGPath currACDir = aircraftDir;
 141             currACDir.append(dent->d_name);
 142             if ((d2 = ulOpenDir(currACDir.c_str())) == NULL)
 143               return;
 144             while ((dent2 = ulReadDir(d2)) != NULL) {
 145               SGPath currFile = currACDir;
 146               currFile.append(dent2->d_name);
 147               if (currFile.extension() == string("xml"))
 148                 {
 149                   //cerr << "found " << dent2->d_name << " for parsing" << endl;
 150                   SGPath currFile = currACDir;
 151                   currFile.append(dent2->d_name);
 152                   SG_LOG(SG_GENERAL, SG_INFO, "Scanning " << currFile.str() << " for traffic");
 153                   readXML(currFile.str(),*this);
 154                 }
 155             }
 156             ulCloseDir(d2);
 157           }
 158       }
 159       ulCloseDir(d);
 160     }
 161   // Sort by points: Aircraft with frequent visits to the
 162   // startup airport will be processed first
 163   sort(scheduledAircraft.begin(), scheduledAircraft.end(), compareSchedules);
 164   currAircraft = scheduledAircraft.begin();
 165   currAircraftClosest = scheduledAircraft.begin();
 166   //cerr << "Done initializing schedules" << endl;
 167 }
 168
 169 void FGTrafficManager::update(double /*dt*/)
 170 {
 171   //SG_LOG( SG_GENERAL, SG_INFO, "Running TrafficManager::Update() ");
 172   if (runCount < 1000)
 173     {
 174       runCount++;
 175       return;
 176     }
 177   //runCount = 0;
 178   time_t now = time(NULL) + fgGetLong("/sim/time/warp");
 179   if (scheduledAircraft.size() == 0) {
 180     //SG_LOG( SG_GENERAL, SG_INFO, "Returned Running TrafficManager::Update() ");
 181     return;
 182   }
 183   if(currAircraft == scheduledAircraft.end())
 184     {
 185       //cerr << "resetting schedule " << endl;
 186       currAircraft = scheduledAircraft.begin();
 187     }
 188   if (!((*currAircraft)->update(now)))
 189     {
 190       // after proper initialization, we shouldnt get here.
 191       // But let's make sure
 192       SG_LOG( SG_GENERAL, SG_ALERT, "Failed to update aircraft schedule in traffic manager");
 193     }
 194   currAircraft++;
 195   //SG_LOG( SG_GENERAL, SG_INFO, "Done Running TrafficManager::Update() ");
 196 }
 197
 198 void FGTrafficManager::release(int id)
 199 {
 200   releaseList.push_back(id);
 201 }
 202
 203 bool FGTrafficManager::isReleased(int id)
 204 {
 205   IdListIterator i = releaseList.begin();
 206   while (i != releaseList.end())
 207     {
 208       if ((*i) == id)
 209         {
 210           releaseList.erase(i);
 211           return true;
 212         }
 213       i++;
 214     }
 215   return false;
 216 }
 217
 218 void  FGTrafficManager::startXML () {
 219   //cout << "Start XML" << endl;
 220 }
 221
 222 void  FGTrafficManager::endXML () {
 223   //cout << "End XML" << endl;
 224 }
 225
 226 void  FGTrafficManager::startElement (const char * name, const XMLAttributes &atts) {
 227   const char * attval;
 228   //cout << "Start element " << name << endl;
 229   //FGTrafficManager temp;
 230   //for (int i = 0; i < atts.size(); i++)
 231   //  if (string(atts.getName(i)) == string("include"))
 232   attval = atts.getValue("include");
 233   if (attval != 0)
 234       {
 235         //cout << "including " << attval << endl;
 236         SGPath path =
 237           globals->get_fg_root();
 238         path.append("/Traffic/");
 239         path.append(attval);
 240         readXML(path.str(), *this);
 241       }
 242   //  cout << "  " << atts.getName(i) << '=' << atts.getValue(i) << endl;
 243 }
 244
 245 void  FGTrafficManager::endElement (const char * name) {
 246   //cout << "End element " << name << endl;
 247   string element(name);
 248   if (element == string("model"))
 249     mdl = value;
 250   else if (element == string("livery"))
 251     livery = value;
 252   else if (element == string("registration"))
 253     registration = value;
 254   else if (element == string("airline"))
 255     airline = value;
 256   else if (element == string("actype"))
 257     acType = value;
 258   else if (element == string("flighttype"))
 259     flighttype = value;
 260   else if (element == string("radius"))
 261     radius = atoi(value.c_str());
 262   else if (element == string("offset"))
 263     offset = atoi(value.c_str());
 264   else if (element == string("performance-class"))
 265     m_class = value;
 266   else if (element == string("heavy"))
 267     {
 268       if(value == string("true"))
 269         heavy = true;
 270       else
 271         heavy = false;
 272     }
 273   else if (element == string("callsign"))
 274     callsign = value;
 275   else if (element == string("fltrules"))
 276     fltrules = value;
 277   else if (element == string("port"))
 278     port = value;
 279   else if (element == string("time"))
 280     timeString = value;
 281   else if (element == string("departure"))
 282     {
 283       departurePort = port;
 284       departureTime = timeString;
 285     }
 286   else if (element == string("cruise-alt"))
 287     cruiseAlt = atoi(value.c_str());
 288   else if (element == string("arrival"))
 289     {
 290       arrivalPort = port;
 291       arrivalTime = timeString;
 292     }
 293   else if (element == string("repeat"))
 294     repeat = value;
 295   else if (element == string("flight"))
 296     {
 297       // We have loaded and parsed all the information belonging to this flight
 298       // so we temporarily store it.
 299       //cerr << "Pusing back flight " << callsign << endl;
 300       //cerr << callsign  <<  " " << fltrules     << " "<< departurePort << " " <<  arrivalPort << " "
 301       //   << cruiseAlt <<  " " << departureTime<< " "<< arrivalTime   << " " << repeat << endl;
 302
 303       //Prioritize aircraft
 304       string apt = fgGetString("/sim/presets/airport-id");
 305       //cerr << "Airport information: " << apt << " " << departurePort << " " << arrivalPort << endl;
 306       if (departurePort == apt) score++;
 307       flights.push_back(new FGScheduledFlight(callsign,
 308                                           fltrules,
 309                                           departurePort,
 310                                           arrivalPort,
 311                                           cruiseAlt,
 312                                           departureTime,
 313                                           arrivalTime,
 314                                           repeat));
 315     }
 316   else if (element == string("aircraft"))
 317     {
 318       //cerr << "Pushing back aircraft " << registration << endl;
 319       scheduledAircraft.push_back(new FGAISchedule(mdl,
 320                                                livery,
 321                                                registration,
 322                                                heavy,
 323                                                acType,
 324                                                airline,
 325                                                m_class,
 326                                                flighttype,
 327                                                radius,
 328                                                offset,
 329                                                score,
 330                                                flights));
 331      //  while(flights.begin() != flights.end()) {
 332 //      flights.pop_back();
 333 //       }
 334       for (FGScheduledFlightVecIterator flt = flights.begin(); flt != flights.end(); flt++)
 335     {
 336       delete (*flt);
 337     }
 338   flights.clear();
 339       SG_LOG( SG_GENERAL, SG_BULK, "Reading aircraft : "
 340               << registration
 341               << " with prioritization score "
 342               << score);
 343       score = 0;
 344     }
 345 }
 346
 347 void  FGTrafficManager::data (const char * s, int len) {
 348   string token = string(s,len);
 349   //cout << "Character data " << string(s,len) << endl;
 350   if ((token.find(" ") == string::npos && (token.find('\n')) == string::npos))
 351       value += token;
 352   else
 353     value = string("");
 354 }
 355
 356 void  FGTrafficManager::pi (const char * target, const char * data) {
 357   //cout << "Processing instruction " << target << ' ' << data << endl;
 358 }
 359
 360 void  FGTrafficManager::warning (const char * message, int line, int column) {
 361   SG_LOG(SG_IO, SG_WARN, "Warning: " << message << " (" << line << ',' << column << ')');
 362 }
 363
 364 void  FGTrafficManager::error (const char * message, int line, int column) {
 365   SG_LOG(SG_IO, SG_ALERT, "Error: " << message << " (" << line << ',' << column << ')');
 366 }