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 <simgear/structure/commands.hxx>
  29 #include <simgear/structure/exception.hxx>
  30
  31 #include <Airports/simple.hxx>
  32 #include <Main/fg_props.hxx>
  33 #include <Main/util.hxx>
  34
  35 #include "environment_mgr.hxx"
  36 #include "environment_ctrl.hxx"
  37
  38 SG_USING_STD(sort);
  39
  40
  41 \f
  42 ////////////////////////////////////////////////////////////////////////
  43 // Implementation of FGEnvironmentCtrl abstract base class.
  44 ////////////////////////////////////////////////////////////////////////
  45
  46 FGEnvironmentCtrl::FGEnvironmentCtrl ()
  47   : _environment(0),
  48     _lon_deg(0),
  49     _lat_deg(0),
  50     _elev_ft(0)
  51 {
  52 }
  53
  54 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
  55 {
  56 }
  57
  58 void
  59 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
  60 {
  61   _environment = environment;
  62 }
  63
  64 void
  65 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
  66 {
  67   _lon_deg = lon_deg;
  68 }
  69
  70 void
  71 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
  72 {
  73   _lat_deg = lat_deg;
  74 }
  75
  76 void
  77 FGEnvironmentCtrl::setElevationFt (double elev_ft)
  78 {
  79   _elev_ft = elev_ft;
  80 }
  81
  82 void
  83 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
  84 {
  85   _lon_deg = lon_deg;
  86   _lat_deg = lat_deg;
  87   _elev_ft = elev_ft;
  88 }
  89
  90
  91 \f
  92 ////////////////////////////////////////////////////////////////////////
  93 // Implementation of FGUserDefEnvironmentCtrl.
  94 ////////////////////////////////////////////////////////////////////////
  95
  96 FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl ()
  97   : _base_wind_speed_node(0),
  98     _gust_wind_speed_node(0),
  99     _current_wind_speed_kt(0),
 100     _delta_wind_speed_kt(0)
 101 {
 102 }
 103
 104 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
 105 {
 106 }
 107
 108 void
 109 FGUserDefEnvironmentCtrl::init ()
 110 {
 111                                 // Fill in some defaults.
 112   if (!fgHasNode("/environment/params/base-wind-speed-kt"))
 113     fgSetDouble("/environment/params/base-wind-speed-kt",
 114                 fgGetDouble("/environment/wind-speed-kt"));
 115   if (!fgHasNode("/environment/params/gust-wind-speed-kt"))
 116     fgSetDouble("/environment/params/gust-wind-speed-kt",
 117                 fgGetDouble("/environment/params/base-wind-speed-kt"));
 118
 119   _base_wind_speed_node =
 120     fgGetNode("/environment/params/base-wind-speed-kt", true);
 121   _gust_wind_speed_node =
 122     fgGetNode("/environment/params/gust-wind-speed-kt", true);
 123
 124   _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
 125   _delta_wind_speed_kt = 0.1;
 126 }
 127
 128 void
 129 FGUserDefEnvironmentCtrl::update (double dt)
 130 {
 131   double base_wind_speed = _base_wind_speed_node->getDoubleValue();
 132   double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
 133
 134   if (gust_wind_speed < base_wind_speed) {
 135       gust_wind_speed = base_wind_speed;
 136       _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
 137   }
 138
 139   if (base_wind_speed == gust_wind_speed) {
 140     _current_wind_speed_kt = base_wind_speed;
 141   } else {
 142     int rn = rand() % 128;
 143     int sign = (_delta_wind_speed_kt < 0 ? -1 : 1);
 144     double gust = _current_wind_speed_kt - base_wind_speed;
 145     double incr = gust / 50;
 146
 147     if (rn == 0)
 148       _delta_wind_speed_kt = - _delta_wind_speed_kt;
 149     else if (rn < 4)
 150       _delta_wind_speed_kt -= incr * sign;
 151     else if (rn < 16)
 152       _delta_wind_speed_kt += incr * sign;
 153
 154     _current_wind_speed_kt += _delta_wind_speed_kt;
 155
 156     if (_current_wind_speed_kt < base_wind_speed) {
 157       _current_wind_speed_kt = base_wind_speed;
 158       _delta_wind_speed_kt = 0.01;
 159     } else if (_current_wind_speed_kt > gust_wind_speed) {
 160       _current_wind_speed_kt = gust_wind_speed;
 161       _delta_wind_speed_kt = -0.01;
 162     }
 163   }
 164
 165   if (_environment != 0)
 166     _environment->set_wind_speed_kt(_current_wind_speed_kt);
 167 }
 168
 169
 170 \f
 171 ////////////////////////////////////////////////////////////////////////
 172 // Implementation of FGInterpolateEnvironmentCtrl.
 173 ////////////////////////////////////////////////////////////////////////
 174
 175 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
 176 {
 177 }
 178
 179 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
 180 {
 181     unsigned int i;
 182     for (i = 0; i < _boundary_table.size(); i++)
 183         delete _boundary_table[i];
 184     for (i = 0; i < _aloft_table.size(); i++)
 185         delete _aloft_table[i];
 186 }
 187
 188
 189
 190 void
 191 FGInterpolateEnvironmentCtrl::init ()
 192 {
 193     read_table(fgGetNode("/environment/config/boundary", true),
 194                _boundary_table);
 195     read_table(fgGetNode("/environment/config/aloft", true),
 196                _aloft_table);
 197 }
 198
 199 void
 200 FGInterpolateEnvironmentCtrl::reinit ()
 201 {
 202     unsigned int i;
 203     for (i = 0; i < _boundary_table.size(); i++)
 204         delete _boundary_table[i];
 205     for (i = 0; i < _aloft_table.size(); i++)
 206         delete _aloft_table[i];
 207     _boundary_table.clear();
 208     _aloft_table.clear();
 209     init();
 210 }
 211
 212 void
 213 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
 214                                           vector<bucket *> &table)
 215 {
 216     for (int i = 0; i < node->nChildren(); i++) {
 217         const SGPropertyNode * child = node->getChild(i);
 218         if ( strcmp(child->getName(), "entry") == 0
 219              && child->getStringValue("elevation-ft", "")[0] != '\0'
 220              && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) )
 221         {
 222             bucket * b = new bucket;
 223             if (i > 0)
 224                 b->environment.copy(table[i-1]->environment);
 225             b->environment.read(child);
 226             b->altitude_ft = b->environment.get_elevation_ft();
 227             table.push_back(b);
 228         }
 229     }
 230     sort(table.begin(), table.end());
 231 }
 232
 233 void
 234 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
 235 {
 236                                 // FIXME
 237     double altitude_ft = fgGetDouble("/position/altitude-ft");
 238     double altitude_agl_ft = fgGetDouble("/position/altitude-agl-ft");
 239     double boundary_transition =
 240         fgGetDouble("/environment/config/boundary-transition-ft", 500);
 241
 242     // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
 243
 244     int length = _boundary_table.size();
 245
 246     if (length > 0) {
 247                                 // boundary table
 248         double boundary_limit = _boundary_table[length-1]->altitude_ft;
 249         if (boundary_limit >= altitude_agl_ft) {
 250             do_interpolate(_boundary_table, altitude_agl_ft,
 251                            _environment);
 252             return;
 253         } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
 254                                 // both tables
 255             do_interpolate(_boundary_table, altitude_agl_ft, &env1);
 256             do_interpolate(_aloft_table, altitude_ft, &env2);
 257             double fraction =
 258                 (altitude_agl_ft - boundary_limit) / boundary_transition;
 259             interpolate(&env1, &env2, fraction, _environment);
 260             return;
 261         }
 262     }
 263
 264                                 // aloft table
 265     do_interpolate(_aloft_table, altitude_ft, _environment);
 266 }
 267
 268 void
 269 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
 270                                               double altitude_ft,
 271                                               FGEnvironment * environment)
 272 {
 273     int length = table.size();
 274     if (length == 0)
 275         return;
 276
 277                                 // Boundary conditions
 278     if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
 279         environment->copy(table[0]->environment);
 280         return;
 281     } else if (table[length-1]->altitude_ft <= altitude_ft) {
 282         environment->copy(table[length-1]->environment);
 283         return;
 284     }
 285
 286                                 // Search the interpolation table
 287     for (int i = 0; i < length - 1; i++) {
 288         if ((i == length - 1) || (table[i]->altitude_ft <= altitude_ft)) {
 289                 FGEnvironment * env1 = &(table[i]->environment);
 290                 FGEnvironment * env2 = &(table[i+1]->environment);
 291                 double fraction;
 292                 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
 293                     fraction = 1.0;
 294                 else
 295                     fraction =
 296                         ((altitude_ft - table[i]->altitude_ft) /
 297                          (table[i+1]->altitude_ft - table[i]->altitude_ft));
 298                 interpolate(env1, env2, fraction, environment);
 299
 300                 return;
 301         }
 302     }
 303 }
 304
 305 bool
 306 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
 307 {
 308     return (altitude_ft < b.altitude_ft);
 309 }
 310
 311
 312 \f
 313 ////////////////////////////////////////////////////////////////////////
 314 // Implementation of FGMetarEnvironmentCtrl.
 315 ////////////////////////////////////////////////////////////////////////
 316
 317 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
 318     : env( new FGInterpolateEnvironmentCtrl ),
 319       _icao( "" ),
 320       search_interval_sec( 60.0 ),        // 1 minute
 321       same_station_interval_sec( 900.0 ), // 15 minutes
 322       search_elapsed( 9999.0 ),
 323       fetch_elapsed( 9999.0 ),
 324       proxy_host( fgGetNode("/sim/presets/proxy/host", true) ),
 325       proxy_port( fgGetNode("/sim/presets/proxy/port", true) ),
 326       proxy_auth( fgGetNode("/sim/presets/proxy/authentication", true) ),
 327       metar_max_age( fgGetNode("/environment/params/metar-max-age-min", true) ),
 328       _error_count( 0 ),
 329       _stale_count( 0 ),
 330       _dt( 0.0 ),
 331       _error_dt( 0.0 )
 332 {
 333 #if defined(ENABLE_THREADS) && ENABLE_THREADS
 334     thread = new MetarThread(this);
 335     thread->start( 1 );
 336 #endif // ENABLE_THREADS
 337 }
 338
 339 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
 340 {
 341 #if defined(ENABLE_THREADS) && ENABLE_THREADS
 342    thread->cancel();
 343    thread->join();
 344 #endif // ENABLE_THREADS
 345
 346    delete env;
 347    env = NULL;
 348 }
 349
 350
 351 // use a "command" to set station temp at station elevation
 352 static void set_temp_at_altitude( float temp_degc, float altitude_ft ) {
 353     SGPropertyNode args;
 354     SGPropertyNode *node = args.getNode("temp-degc", 0, true);
 355     node->setFloatValue( temp_degc );
 356     node = args.getNode("altitude-ft", 0, true);
 357     node->setFloatValue( altitude_ft );
 358     globals->get_commands()->execute("set-outside-air-temp-degc", &args);
 359 }
 360
 361
 362 static void set_dewpoint_at_altitude( float dewpoint_degc, float altitude_ft ) {
 363     SGPropertyNode args;
 364     SGPropertyNode *node = args.getNode("dewpoint-degc", 0, true);
 365     node->setFloatValue( dewpoint_degc );
 366     node = args.getNode("altitude-ft", 0, true);
 367     node->setFloatValue( altitude_ft );
 368     globals->get_commands()->execute("set-dewpoint-temp-degc", &args);
 369 }
 370
 371
 372 void
 373 FGMetarEnvironmentCtrl::update_env_config ()
 374 {
 375     fgSetupWind( fgGetDouble("/environment/metar/base-wind-range-from"),
 376                  fgGetDouble("/environment/metar/base-wind-range-to"),
 377                  fgGetDouble("/environment/metar/base-wind-speed-kt"),
 378                  fgGetDouble("/environment/metar/gust-wind-speed-kt") );
 379
 380     fgDefaultWeatherValue( "visibility-m",
 381                            fgGetDouble("/environment/metar/min-visibility-m") );
 382     set_temp_at_altitude( fgGetDouble("/environment/metar/temperature-degc"),
 383                           station_elevation_ft );
 384     set_dewpoint_at_altitude( fgGetDouble("/environment/metar/dewpoint-degc"),
 385                               station_elevation_ft );
 386     fgDefaultWeatherValue( "pressure-sea-level-inhg",
 387                            fgGetDouble("/environment/metar/pressure-inhg") );
 388 }
 389
 390 void
 391 FGMetarEnvironmentCtrl::init ()
 392 {
 393     const SGPropertyNode *longitude
 394         = fgGetNode( "/position/longitude-deg", true );
 395     const SGPropertyNode *latitude
 396         = fgGetNode( "/position/latitude-deg", true );
 397
 398     bool found_metar = false;
 399     long max_age = metar_max_age->getLongValue();
 400     // Don't check max age during init so that we don't loop over a lot
 401     // of airports metar if there is a problem.
 402     // The update() calls will find a correct metar if things went wrong here
 403     metar_max_age->setLongValue(0);
 404
 405     while ( !found_metar && (_error_count < 3) ) {
 406         const FGAirport* a = globals->get_airports()
 407                    ->search( longitude->getDoubleValue(),
 408                              latitude->getDoubleValue(),
 409                              true );
 410         if ( a ) {
 411             FGMetarResult result = fetch_data( a->getId() );
 412             if ( result.m != NULL ) {
 413                 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
 414                         << a->getId());
 415                 last_apt = *a;
 416                 _icao = a->getId();
 417                 search_elapsed = 0.0;
 418                 fetch_elapsed = 0.0;
 419                 update_metar_properties( result.m );
 420                 update_env_config();
 421                 env->init();
 422                 found_metar = true;
 423             } else {
 424                 // mark as no metar so it doesn't show up in subsequent
 425                 // searches.
 426                 SG_LOG( SG_GENERAL, SG_INFO, "no metar at metar = "
 427                         << a->getId() );
 428                 globals->get_airports()->no_metar( a->getId() );
 429             }
 430         }
 431     }
 432     metar_max_age->setLongValue(max_age);
 433 }
 434
 435 void
 436 FGMetarEnvironmentCtrl::reinit ()
 437 {
 438     _error_count = 0;
 439     _error_dt = 0.0;
 440
 441 #if 0
 442     update_env_config();
 443 #endif
 444
 445     env->reinit();
 446 }
 447
 448 void
 449 FGMetarEnvironmentCtrl::update(double delta_time_sec)
 450 {
 451
 452     _dt += delta_time_sec;
 453     if (_error_count >= 3)
 454        return;
 455
 456     FGMetarResult result;
 457
 458     static const SGPropertyNode *longitude
 459         = fgGetNode( "/position/longitude-deg", true );
 460     static const SGPropertyNode *latitude
 461         = fgGetNode( "/position/latitude-deg", true );
 462     search_elapsed += delta_time_sec;
 463     fetch_elapsed += delta_time_sec;
 464
 465     // if time for a new search request, push it onto the request
 466     // queue
 467     if ( search_elapsed > search_interval_sec ) {
 468         const FGAirport* a = globals->get_airports()
 469                    ->search( longitude->getDoubleValue(),
 470                              latitude->getDoubleValue(),
 471                              true );
 472         if ( a ) {
 473             if ( last_apt.getId() != a->getId()
 474                  || fetch_elapsed > same_station_interval_sec )
 475             {
 476                 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
 477                         << a->getId());
 478                 request_queue.push( a->getId() );
 479                 last_apt = *a;
 480                 _icao = a->getId();
 481                 search_elapsed = 0.0;
 482                 fetch_elapsed = 0.0;
 483             } else {
 484                 search_elapsed = 0.0;
 485                 SG_LOG( SG_GENERAL, SG_INFO, "same station, waiting = "
 486                         << same_station_interval_sec - fetch_elapsed );
 487             }
 488         } else {
 489             SG_LOG( SG_GENERAL, SG_WARN,
 490                     "Unable to find any airports with metar" );
 491         }
 492     }
 493
 494 #if defined(ENABLE_THREADS) && ENABLE_THREADS
 495     // No loader thread running so manually fetch the data
 496     string id = "";
 497     while ( !request_queue.empty() ) {
 498         id = request_queue.front();
 499         request_queue.pop();
 500     }
 501
 502     if ( !id.empty() ) {
 503         SG_LOG( SG_GENERAL, SG_INFO, "inline fetching = " << id );
 504         result = fetch_data( id );
 505         result_queue.push( result );
 506     }
 507 #endif // ENABLE_THREADS
 508
 509     // process any results from the loader.
 510     while ( !result_queue.empty() ) {
 511         result = result_queue.front();
 512         result_queue.pop();
 513         if ( result.m != NULL ) {
 514             update_metar_properties( result.m );
 515             delete result.m;
 516             update_env_config();
 517             env->reinit();
 518         } else {
 519             // mark as no metar so it doesn't show up in subsequent
 520             // searches, and signal an immediate re-search.
 521             SG_LOG( SG_GENERAL, SG_WARN,
 522                     "no metar at station = " << result.icao );
 523             globals->get_airports()->no_metar( result.icao );
 524             search_elapsed = 9999.0;
 525         }
 526     }
 527
 528     env->update(delta_time_sec);
 529 }
 530
 531
 532 void
 533 FGMetarEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
 534 {
 535     env->setEnvironment(environment);
 536 }
 537
 538 FGMetarResult
 539 FGMetarEnvironmentCtrl::fetch_data( const string &icao )
 540 {
 541     FGMetarResult result;
 542     result.icao = icao;
 543
 544     // if the last error was more than three seconds ago,
 545     // then pretent nothing happened.
 546     if (_error_dt < 3) {
 547         _error_dt += _dt;
 548
 549     } else {
 550         _error_dt = 0.0;
 551         _error_count = 0;
 552     }
 553
 554     // fetch station elevation if exists
 555     const FGAirport* a = globals->get_airports()->search( icao );
 556     if ( a ) {
 557         station_elevation_ft = a->getElevation();
 558     }
 559
 560     // fetch current metar data
 561     try {
 562         string host = proxy_host->getStringValue();
 563         string auth = proxy_auth->getStringValue();
 564         string port = proxy_port->getStringValue();
 565         result.m = new FGMetar( icao, host, port, auth);
 566
 567         long max_age = metar_max_age->getLongValue();
 568         long age = result.m->getAge_min();
 569         if (max_age &&  age > max_age) {
 570             SG_LOG( SG_GENERAL, SG_WARN, "METAR data too old (" << age << " min).");
 571             delete result.m;
 572             result.m = NULL;
 573
 574             if (++_stale_count > 10) {
 575                 _error_count = 1000;
 576                 throw sg_io_exception("More than 10 stale METAR messages in a row.");
 577             }
 578         } else
 579             _stale_count = 0;
 580
 581     } catch (const sg_io_exception& e) {
 582         SG_LOG( SG_GENERAL, SG_WARN, "Error fetching live weather data: "
 583                 << e.getFormattedMessage().c_str() );
 584 #if defined(ENABLE_THREADS) && ENABLE_THREADS
 585         if (_error_count++ >= 3) {
 586            SG_LOG( SG_GENERAL, SG_WARN, "Stop fetching data permanently.");
 587            thread->cancel();
 588            thread->join();
 589         }
 590 #endif
 591
 592         result.m = NULL;
 593     }
 594
 595     _dt = 0;
 596
 597     return result;
 598 }
 599
 600
 601 void
 602 FGMetarEnvironmentCtrl::update_metar_properties( const FGMetar *m )
 603 {
 604     int i;
 605     double d;
 606     char s[128];
 607
 608     fgSetString("/environment/metar/real-metar", m->getData());
 609         // don't update with real weather when we use a custom weather scenario
 610         const char *current_scenario = fgGetString("/environment/weather-scenario", "METAR");
 611         if( strcmp(current_scenario, "METAR") && strcmp(current_scenario, "none"))
 612                 return;
 613     fgSetString("/environment/metar/last-metar", m->getData());
 614     fgSetString("/environment/metar/station-id", m->getId());
 615     fgSetDouble("/environment/metar/min-visibility-m",
 616                 m->getMinVisibility().getVisibility_m() );
 617     fgSetDouble("/environment/metar/max-visibility-m",
 618                 m->getMaxVisibility().getVisibility_m() );
 619
 620     const SGMetarVisibility *dirvis = m->getDirVisibility();
 621     for (i = 0; i < 8; i++, dirvis++) {
 622         const char *min = "/environment/metar/visibility[%d]/min-m";
 623         const char *max = "/environment/metar/visibility[%d]/max-m";
 624
 625         d = dirvis->getVisibility_m();
 626
 627         snprintf(s, 128, min, i);
 628         fgSetDouble(s, d);
 629         snprintf(s, 128, max, i);
 630         fgSetDouble(s, d);
 631     }
 632
 633     fgSetInt("/environment/metar/base-wind-range-from",
 634              m->getWindRangeFrom() );
 635     fgSetInt("/environment/metar/base-wind-range-to",
 636              m->getWindRangeTo() );
 637     fgSetDouble("/environment/metar/base-wind-speed-kt",
 638                 m->getWindSpeed_kt() );
 639     fgSetDouble("/environment/metar/gust-wind-speed-kt",
 640                 m->getGustSpeed_kt() );
 641     fgSetDouble("/environment/metar/temperature-degc",
 642                 m->getTemperature_C() );
 643     fgSetDouble("/environment/metar/dewpoint-degc",
 644                 m->getDewpoint_C() );
 645     fgSetDouble("/environment/metar/rel-humidity-norm",
 646                 m->getRelHumidity() );
 647     fgSetDouble("/environment/metar/pressure-inhg",
 648                 m->getPressure_inHg() );
 649
 650     vector<SGMetarCloud> cv = m->getClouds();
 651     vector<SGMetarCloud>::const_iterator cloud;
 652
 653     const char *cl = "/environment/clouds/layer[%i]";
 654     for (i = 0, cloud = cv.begin(); cloud != cv.end(); cloud++, i++) {
 655         const char *coverage_string[5] =
 656             { "clear", "few", "scattered", "broken", "overcast" };
 657         const double thickness[5] = { 0, 65, 600,750, 1000};
 658         int q;
 659
 660         snprintf(s, 128, cl, i);
 661         strncat(s, "/coverage", 128);
 662         q = cloud->getCoverage();
 663         fgSetString(s, coverage_string[q] );
 664
 665         snprintf(s, 128, cl, i);
 666         strncat(s, "/elevation-ft", 128);
 667         fgSetDouble(s, cloud->getAltitude_ft() + station_elevation_ft);
 668
 669         snprintf(s, 128, cl, i);
 670         strncat(s, "/thickness-ft", 128);
 671         fgSetDouble(s, thickness[q]);
 672
 673         snprintf(s, 128, cl, i);
 674         strncat(s, "/span-m", 128);
 675         fgSetDouble(s, 40000.0);
 676     }
 677
 678     for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
 679         snprintf(s, 128, cl, i);
 680         strncat(s, "/coverage", 128);
 681         fgSetString(s, "clear");
 682
 683         snprintf(s, 128, cl, i);
 684         strncat(s, "/elevation-ft", 128);
 685         fgSetDouble(s, -9999);
 686
 687         snprintf(s, 128, cl, i);
 688         strncat(s, "/thickness-ft", 128);
 689         fgSetDouble(s, 0);
 690
 691         snprintf(s, 128, cl, i);
 692         strncat(s, "/span-m", 128);
 693         fgSetDouble(s, 40000.0);
 694     }
 695
 696     fgSetDouble("/environment/metar/rain-norm", m->getRain());
 697     fgSetDouble("/environment/metar/hail-norm", m->getHail());
 698     fgSetDouble("/environment/metar/snow-norm", m->getSnow());
 699     fgSetBool("/environment/metar/snow-cover", m->getSnowCover());
 700 }
 701
 702
 703 #if defined(ENABLE_THREADS) && ENABLE_THREADS
 704 /**
 705  *
 706  */
 707 void
 708 FGMetarEnvironmentCtrl::MetarThread::run()
 709 {
 710     pthread_cleanup_push( metar_cleanup_handler, fetcher );
 711     while ( true )
 712     {
 713         set_cancel( SGThread::CANCEL_DISABLE );
 714
 715         string icao = fetcher->request_queue.pop();
 716         SG_LOG( SG_GENERAL, SG_INFO, "Thread: fetch metar data = " << icao );
 717         FGMetarResult result = fetcher->fetch_data( icao );
 718
 719         set_cancel( SGThread::CANCEL_DEFERRED );
 720
 721         fetcher->result_queue.push( result );
 722     }
 723     pthread_cleanup_pop(1);
 724 }
 725
 726 /**
 727  * Ensure mutex is unlocked.
 728  */
 729 void
 730 metar_cleanup_handler( void* arg )
 731 {
 732     FGMetarEnvironmentCtrl* fetcher = (FGMetarEnvironmentCtrl*) arg;
 733     fetcher->mutex.unlock();
 734 }
 735 #endif // ENABLE_THREADS
 736
 737
 738 // end of environment_ctrl.cxx