src/Environment/environment_ctrl.cxx

   1 // environment_ctrl.cxx -- manager for natural environment information.
   2 //
   3 // Written by David Megginson, started February 2002.
   4 //
   5 // Copyright (C) 2002  David Megginson - david@megginson.com
   6 //
   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.
  11 //
  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.
  16 //
  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.
  20 //
  21 // $Id$
  22
  23 #include <simgear/debug/logstream.hxx>
  24
  25 #include <stdlib.h>
  26 #include <algorithm>
  27
  28 #include <Main/fg_props.hxx>
  29
  30 #include "environment_mgr.hxx"
  31 #include "environment_ctrl.hxx"
  32
  33 SG_USING_STD(sort);
  34
  35
  36 \f
  37 ////////////////////////////////////////////////////////////////////////
  38 // Implementation of FGEnvironmentCtrl abstract base class.
  39 ////////////////////////////////////////////////////////////////////////
  40
  41 FGEnvironmentCtrl::FGEnvironmentCtrl ()
  42   : _environment(0),
  43     _lon_deg(0),
  44     _lat_deg(0),
  45     _elev_ft(0)
  46 {
  47 }
  48
  49 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
  50 {
  51 }
  52
  53 void
  54 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
  55 {
  56   _environment = environment;
  57 }
  58
  59 void
  60 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
  61 {
  62   _lon_deg = lon_deg;
  63 }
  64
  65 void
  66 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
  67 {
  68   _lat_deg = lat_deg;
  69 }
  70
  71 void
  72 FGEnvironmentCtrl::setElevationFt (double elev_ft)
  73 {
  74   _elev_ft = elev_ft;
  75 }
  76
  77 void
  78 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
  79 {
  80   _lon_deg = lon_deg;
  81   _lat_deg = lat_deg;
  82   _elev_ft = elev_ft;
  83 }
  84
  85
  86 \f
  87 ////////////////////////////////////////////////////////////////////////
  88 // Implementation of FGUserDefEnvironmentCtrl.
  89 ////////////////////////////////////////////////////////////////////////
  90
  91 FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl ()
  92   : _base_wind_speed_node(0),
  93     _gust_wind_speed_node(0),
  94     _current_wind_speed_kt(0),
  95     _delta_wind_speed_kt(0)
  96 {
  97 }
  98
  99 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
 100 {
 101 }
 102
 103 void
 104 FGUserDefEnvironmentCtrl::init ()
 105 {
 106                                 // Fill in some defaults.
 107   if (!fgHasNode("/environment/params/base-wind-speed-kt"))
 108     fgSetDouble("/environment/params/base-wind-speed-kt",
 109                 fgGetDouble("/environment/wind-speed-kt"));
 110   if (!fgHasNode("/environment/params/gust-wind-speed-kt"))
 111     fgSetDouble("/environment/params/gust-wind-speed-kt",
 112                 fgGetDouble("/environment/params/base-wind-speed-kt"));
 113
 114   _base_wind_speed_node =
 115     fgGetNode("/environment/params/base-wind-speed-kt", true);
 116   _gust_wind_speed_node =
 117     fgGetNode("/environment/params/gust-wind-speed-kt", true);
 118
 119   _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
 120   _delta_wind_speed_kt = 0.1;
 121 }
 122
 123 void
 124 FGUserDefEnvironmentCtrl::update (double dt)
 125 {
 126   double base_wind_speed = _base_wind_speed_node->getDoubleValue();
 127   double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
 128
 129   if (gust_wind_speed < base_wind_speed) {
 130       gust_wind_speed = base_wind_speed;
 131       _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
 132   }
 133
 134   if (base_wind_speed == gust_wind_speed) {
 135     _current_wind_speed_kt = base_wind_speed;
 136   } else {
 137     int rn = rand() % 128;
 138     int sign = (_delta_wind_speed_kt < 0 ? -1 : 1);
 139     double gust = _current_wind_speed_kt - base_wind_speed;
 140     double incr = gust / 50;
 141
 142     if (rn == 0)
 143       _delta_wind_speed_kt = - _delta_wind_speed_kt;
 144     else if (rn < 4)
 145       _delta_wind_speed_kt -= incr * sign;
 146     else if (rn < 16)
 147       _delta_wind_speed_kt += incr * sign;
 148
 149     _current_wind_speed_kt += _delta_wind_speed_kt;
 150
 151     if (_current_wind_speed_kt < base_wind_speed) {
 152       _current_wind_speed_kt = base_wind_speed;
 153       _delta_wind_speed_kt = 0.01;
 154     } else if (_current_wind_speed_kt > gust_wind_speed) {
 155       _current_wind_speed_kt = gust_wind_speed;
 156       _delta_wind_speed_kt = -0.01;
 157     }
 158   }
 159
 160   if (_environment != 0)
 161     _environment->set_wind_speed_kt(_current_wind_speed_kt);
 162 }
 163
 164
 165 \f
 166 ////////////////////////////////////////////////////////////////////////
 167 // Implementation of FGInterpolateEnvironmentCtrl.
 168 ////////////////////////////////////////////////////////////////////////
 169
 170 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
 171 {
 172 }
 173
 174 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
 175 {
 176     unsigned int i;
 177     for (i = 0; i < _boundary_table.size(); i++)
 178         delete _boundary_table[i];
 179     for (i = 0; i < _aloft_table.size(); i++)
 180         delete _aloft_table[i];
 181 }
 182
 183
 184
 185 void
 186 FGInterpolateEnvironmentCtrl::init ()
 187 {
 188     read_table(fgGetNode("/environment/config/boundary", true),
 189                _boundary_table);
 190     read_table(fgGetNode("/environment/config/aloft", true),
 191                _aloft_table);
 192 }
 193
 194 void
 195 FGInterpolateEnvironmentCtrl::reinit ()
 196 {
 197     unsigned int i;
 198     for (i = 0; i < _boundary_table.size(); i++)
 199         delete _boundary_table[i];
 200     for (i = 0; i < _aloft_table.size(); i++)
 201         delete _aloft_table[i];
 202     _boundary_table.clear();
 203     _aloft_table.clear();
 204     init();
 205 }
 206
 207 void
 208 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
 209                                           vector<bucket *> &table)
 210 {
 211     for (int i = 0; i < node->nChildren(); i++) {
 212         const SGPropertyNode * child = node->getChild(i);
 213         if ( strcmp(child->getName(), "entry") == 0
 214              && child->getStringValue("elevation-ft", "")[0] != '\0'
 215              && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) )
 216         {
 217             bucket * b = new bucket;
 218             if (i > 0)
 219                 b->environment.copy(table[i-1]->environment);
 220             b->environment.read(child);
 221             b->altitude_ft = b->environment.get_elevation_ft();
 222             table.push_back(b);
 223         }
 224     }
 225     sort(table.begin(), table.end());
 226 }
 227
 228 void
 229 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
 230 {
 231                                 // FIXME
 232     double altitude_ft = fgGetDouble("/position/altitude-ft");
 233     double altitude_agl_ft = fgGetDouble("/position/altitude-agl-ft");
 234     double boundary_transition =
 235         fgGetDouble("/environment/config/boundary-transition-ft", 500);
 236
 237     // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
 238
 239     int length = _boundary_table.size();
 240
 241     if (length > 0) {
 242                                 // boundary table
 243         double boundary_limit = _boundary_table[length-1]->altitude_ft;
 244         if (boundary_limit >= altitude_agl_ft) {
 245             do_interpolate(_boundary_table, altitude_agl_ft,
 246                            _environment);
 247             return;
 248         } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
 249                                 // both tables
 250             do_interpolate(_boundary_table, altitude_agl_ft, &env1);
 251             do_interpolate(_aloft_table, altitude_ft, &env2);
 252             double fraction =
 253                 (altitude_agl_ft - boundary_limit) / boundary_transition;
 254             interpolate(&env1, &env2, fraction, _environment);
 255             return;
 256         }
 257     }
 258
 259                                 // aloft table
 260     do_interpolate(_aloft_table, altitude_ft, _environment);
 261 }
 262
 263 void
 264 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
 265                                               double altitude_ft,
 266                                               FGEnvironment * environment)
 267 {
 268     int length = table.size();
 269     if (length == 0)
 270         return;
 271
 272                                 // Boundary conditions
 273     if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
 274         environment->copy(table[0]->environment);
 275         return;
 276     } else if (table[length-1]->altitude_ft <= altitude_ft) {
 277         environment->copy(table[length-1]->environment);
 278         return;
 279     }
 280
 281                                 // Search the interpolation table
 282     for (int i = 0; i < length - 1; i++) {
 283         if ((i == length - 1) || (table[i]->altitude_ft <= altitude_ft)) {
 284                 FGEnvironment * env1 = &(table[i]->environment);
 285                 FGEnvironment * env2 = &(table[i+1]->environment);
 286                 double fraction;
 287                 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
 288                     fraction = 1.0;
 289                 else
 290                     fraction =
 291                         ((altitude_ft - table[i]->altitude_ft) /
 292                          (table[i+1]->altitude_ft - table[i]->altitude_ft));
 293                 interpolate(env1, env2, fraction, environment);
 294
 295                 return;
 296         }
 297     }
 298 }
 299
 300 bool
 301 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
 302 {
 303     return (altitude_ft < b.altitude_ft);
 304 }
 305
 306
 307 \f
 308 ////////////////////////////////////////////////////////////////////////
 309 // Implementation of FGMetarEnvironmentCtrl.
 310 ////////////////////////////////////////////////////////////////////////
 311
 312 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
 313     : _icao( strdup( fgGetString("/sim/presets/airport-id") ) )
 314 {
 315 }
 316
 317 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
 318 {
 319     if (_icao) {
 320       free(_icao);
 321       _icao = NULL;
 322     }
 323 }
 324
 325
 326 void
 327 FGMetarEnvironmentCtrl::init ()
 328 {
 329     if (_icao != NULL) {
 330         free(_icao);
 331         _icao = NULL;
 332     }
 333
 334     read_table(_icao);
 335     _base_wind_speed_node =
 336         fgGetNode("/environment/metar/base-wind-range-from", true);
 337     _gust_wind_speed_node =
 338         fgGetNode("/environment/metar/gust-wind-speed-kt", true);
 339
 340     fgSetDouble("/environment/visibility-m",
 341         fgGetDouble("/environment/metar/min-visibility-m"));
 342     fgSetDouble("/environment/temperature-degc",
 343         fgGetDouble("/environment/metar/temperature_degc"));
 344     fgSetDouble("/environment/dewpoint-degc",
 345         fgGetDouble("/environment/metar/dewpoint-degc"));
 346     fgSetDouble("/environment/pressure-inhg",
 347         fgGetDouble("/environment/metar/pressure-inhg"));
 348 }
 349
 350 void
 351 FGMetarEnvironmentCtrl::reinit ()
 352 {
 353     init();
 354 }
 355
 356 void
 357 FGMetarEnvironmentCtrl::read_table (const char *icao)
 358 {
 359     char s[128];
 360     double d, dt;
 361     int i;
 362
 363     if ((icao == NULL) && (_icao == NULL)) {
 364         _icao = strdup( fgGetString("/sim/presets/airport-id") );
 365
 366     } else if (icao != NULL) {
 367         if (_icao != NULL)
 368             free(_icao);
 369
 370         _icao = strdup(icao);
 371     }
 372     SGMetar *m = new SGMetar(_icao);
 373
 374     d = m->getMinVisibility().getVisibility_m();
 375     d = (d != SGMetarNaN) ? d : 10000;
 376     fgSetDouble("/environment/metar/min-visibility-m", d);
 377
 378     dt =  m->getMaxVisibility().getVisibility_m();
 379     d = (dt != SGMetarNaN) ? dt : d;
 380     fgSetDouble("/environment/metar/max-visibility-m", d);
 381
 382     SGMetarVisibility *dirvis = m->getDirVisibility();
 383     for (i = 0; i < 8; i++, dirvis++) {
 384         const char *min = "/environment/metar/visibility[%]/min-m";
 385         const char *max = "/environment/metar/visibility[%]/max-m";
 386         char s[128];
 387
 388         d = dirvis->getVisibility_m();
 389         d = (d != SGMetarNaN) ? d : 10000;
 390
 391         snprintf(s, 128, min, i);
 392         fgSetDouble(s, d);
 393         snprintf(s, 128, max, i);
 394         fgSetDouble(s, d);
 395     }
 396
 397     i = m->getWindDir();
 398     if ( i == -1 ) {
 399         fgSetInt("/environment/metar/base-wind-range-from",
 400                     m->getWindRangeFrom() );
 401         fgSetInt("/environment/metar/base-wind-range-to",
 402                     m->getWindRangeTo() );
 403     } else {
 404         fgSetInt("/environment/metar/base-wind-range-from", i);
 405         fgSetInt("/environment/metar/base-wind-range-to", i);
 406     }
 407     fgSetDouble("/environment/metar/base-wind-speed-kt",
 408                 m->getWindSpeed_kt() );
 409
 410     d = m->getGustSpeed_kt();
 411     d = (d != SGMetarNaN) ? d : 0.0;
 412     fgSetDouble("/environment/metar/gust-wind-speed-kt", d);
 413
 414     d = m->getTemperature_C();
 415     if (d != SGMetarNaN) {
 416         dt = m->getDewpoint_C();
 417         dt = (dt != SGMetarNaN) ? dt : 0.0;
 418         fgSetDouble("/environment/metar/dewpoint-degc", dt);
 419         fgSetDouble("/environment/metar/rel-humidity-norm",
 420                     m->getRelHumidity() );
 421     }
 422     d = (d != SGMetarNaN) ? d : 15.0;
 423     fgSetDouble("/environment/metar/temperature_degc", d);
 424
 425     d = m->getPressure_inHg();
 426     d = (d != SGMetarNaN) ? d : 30.0;
 427     fgSetDouble("/environment/metar/pressure-inhg", d);
 428
 429     vector<SGMetarCloud> cv = m->getClouds();
 430     vector<SGMetarCloud>::iterator cloud;
 431
 432     const char *cl = "/environment/clouds/layer[%i]";
 433     for (i = 0, cloud = cv.begin(); cloud != cv.end(); cloud++, i++) {
 434         const char *coverage_string[5] =
 435             { "clear", "few", "scattered", "broken", "overcast" };
 436         const double thickness[5] = { 0, 65, 600,750, 1000};
 437         int q;
 438
 439         snprintf(s, 128, cl, i);
 440         strncat(s, "/coverage", 128);
 441         q = cloud->getCoverage();
 442         q = (q != -1 ) ? q : 0;
 443         fgSetString(s, coverage_string[q] );
 444
 445         snprintf(s, 128, cl, i);
 446         strncat(s, "/elevation-ft", 128);
 447         d = cloud->getAltitude_ft();
 448         d = (d != SGMetarNaN) ? d : -9999;
 449         fgSetDouble(s, d);
 450
 451         snprintf(s, 128, cl, i);
 452         strncat(s, "/thickness-ft", 128);
 453         fgSetDouble(s, thickness[q]);
 454
 455         snprintf(s, 128, cl, i);
 456         strncat(s, "/span-m", 128);
 457         fgSetDouble(s, 40000.0);
 458     }
 459     for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
 460         snprintf(s, 128, cl, i);
 461         strncat(s, "/coverage", 128);
 462         fgSetString(s, "clear");
 463
 464         snprintf(s, 128, cl, i);
 465         strncat(s, "/elevation-ft", 128);
 466         fgSetDouble(s, -9999);
 467
 468         snprintf(s, 128, cl, i);
 469         strncat(s, "/thickness-ft", 128);
 470         fgSetDouble(s, 0);
 471
 472         snprintf(s, 128, cl, i);
 473         strncat(s, "/span-m", 128);
 474         fgSetDouble(s, 40000.0);
 475     }
 476
 477     delete m;
 478 }
 479
 480 void
 481 FGMetarEnvironmentCtrl::update (double delta_time_sec)
 482 {
 483   double base_wind_speed = _base_wind_speed_node->getDoubleValue();
 484   double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
 485
 486   if (gust_wind_speed < base_wind_speed) {
 487       gust_wind_speed = base_wind_speed;
 488       _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
 489   }
 490
 491   if (base_wind_speed == gust_wind_speed) {
 492     _current_wind_speed_kt = base_wind_speed;
 493   } else {
 494     int rn = rand() % 128;
 495     int sign = (_delta_wind_speed_kt < 0 ? -1 : 1);
 496     double gust = _current_wind_speed_kt - base_wind_speed;
 497     double incr = gust / 50;
 498
 499     if (rn == 0)
 500       _delta_wind_speed_kt = - _delta_wind_speed_kt;
 501     else if (rn < 4)
 502       _delta_wind_speed_kt -= incr * sign;
 503     else if (rn < 16)
 504       _delta_wind_speed_kt += incr * sign;
 505
 506     _current_wind_speed_kt += _delta_wind_speed_kt;
 507
 508     if (_current_wind_speed_kt < base_wind_speed) {
 509       _current_wind_speed_kt = base_wind_speed;
 510       _delta_wind_speed_kt = 0.01;
 511     } else if (_current_wind_speed_kt > gust_wind_speed) {
 512       _current_wind_speed_kt = gust_wind_speed;
 513       _delta_wind_speed_kt = -0.01;
 514     }
 515   }
 516
 517   if (_environment != 0)
 518     _environment->set_wind_speed_kt(_current_wind_speed_kt);
 519 }
 520
 521 void
 522 FGMetarEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
 523                                               double altitude_ft,
 524                                               FGEnvironment * environment)
 525 {
 526 }
 527
 528 bool
 529 FGMetarEnvironmentCtrl::bucket::operator< (const bucket &b) const
 530 {
 531     return (altitude_ft < b.altitude_ft);
 532 }
 533
 534 // end of environment_ctrl.cxx