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