1 // environment_ctrl.cxx -- manager for natural environment information.
3 // Written by David Megginson, started February 2002.
5 // Copyright (C) 2002 David Megginson - david@megginson.com
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.
23 #include <simgear/debug/logstream.hxx>
28 #include <simgear/structure/commands.hxx>
29 #include <simgear/structure/exception.hxx>
31 #include <Airports/simple.hxx>
32 #include <Main/fg_props.hxx>
33 #include <Main/util.hxx>
35 #include "environment_mgr.hxx"
36 #include "environment_ctrl.hxx"
42 ////////////////////////////////////////////////////////////////////////
43 // Implementation of FGEnvironmentCtrl abstract base class.
44 ////////////////////////////////////////////////////////////////////////
46 FGEnvironmentCtrl::FGEnvironmentCtrl ()
54 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
59 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
61 _environment = environment;
65 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
71 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
77 FGEnvironmentCtrl::setElevationFt (double elev_ft)
83 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
92 ////////////////////////////////////////////////////////////////////////
93 // Implementation of FGUserDefEnvironmentCtrl.
94 ////////////////////////////////////////////////////////////////////////
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)
104 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
109 FGUserDefEnvironmentCtrl::init ()
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"));
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);
124 _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
125 _delta_wind_speed_kt = 0.1;
129 FGUserDefEnvironmentCtrl::update (double dt)
131 double base_wind_speed = _base_wind_speed_node->getDoubleValue();
132 double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
134 if (gust_wind_speed < base_wind_speed) {
135 gust_wind_speed = base_wind_speed;
136 _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
139 if (base_wind_speed == gust_wind_speed) {
140 _current_wind_speed_kt = base_wind_speed;
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;
148 _delta_wind_speed_kt = - _delta_wind_speed_kt;
150 _delta_wind_speed_kt -= incr * sign;
152 _delta_wind_speed_kt += incr * sign;
154 _current_wind_speed_kt += _delta_wind_speed_kt;
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;
165 if (_environment != 0)
166 _environment->set_wind_speed_kt(_current_wind_speed_kt);
171 ////////////////////////////////////////////////////////////////////////
172 // Implementation of FGInterpolateEnvironmentCtrl.
173 ////////////////////////////////////////////////////////////////////////
175 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
179 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
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];
191 FGInterpolateEnvironmentCtrl::init ()
193 read_table(fgGetNode("/environment/config/boundary", true),
195 read_table(fgGetNode("/environment/config/aloft", true),
200 FGInterpolateEnvironmentCtrl::reinit ()
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();
213 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
214 vector<bucket *> &table)
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 ) )
222 bucket * b = new bucket;
224 b->environment.copy(table[i-1]->environment);
225 b->environment.read(child);
226 b->altitude_ft = b->environment.get_elevation_ft();
230 sort(table.begin(), table.end());
234 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
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);
242 // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
244 int length = _boundary_table.size();
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,
253 } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
255 do_interpolate(_boundary_table, altitude_agl_ft, &env1);
256 do_interpolate(_aloft_table, altitude_ft, &env2);
258 (altitude_agl_ft - boundary_limit) / boundary_transition;
259 interpolate(&env1, &env2, fraction, _environment);
265 do_interpolate(_aloft_table, altitude_ft, _environment);
269 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
271 FGEnvironment * environment)
273 int length = table.size();
277 // Boundary conditions
278 if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
279 environment->copy(table[0]->environment);
281 } else if (table[length-1]->altitude_ft <= altitude_ft) {
282 environment->copy(table[length-1]->environment);
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);
292 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
296 ((altitude_ft - table[i]->altitude_ft) /
297 (table[i+1]->altitude_ft - table[i]->altitude_ft));
298 interpolate(env1, env2, fraction, environment);
306 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
308 return (altitude_ft < b.altitude_ft);
313 ////////////////////////////////////////////////////////////////////////
314 // Implementation of FGMetarEnvironmentCtrl.
315 ////////////////////////////////////////////////////////////////////////
317 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
318 : env( new FGInterpolateEnvironmentCtrl ),
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) ),
332 #if defined(ENABLE_THREADS) && ENABLE_THREADS
333 thread = new MetarThread(this);
335 #endif // ENABLE_THREADS
338 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
340 #if defined(ENABLE_THREADS) && ENABLE_THREADS
343 #endif // ENABLE_THREADS
350 // use a "command" to set station temp at station elevation
351 static void set_temp_at_altitude( float temp_degc, float altitude_ft ) {
353 SGPropertyNode *node = args.getNode("temp-degc", 0, true);
354 node->setFloatValue( temp_degc );
355 node = args.getNode("altitude-ft", 0, true);
356 node->setFloatValue( altitude_ft );
357 globals->get_commands()->execute("set-outside-air-temp-degc", &args);
361 static void set_dewpoint_at_altitude( float dewpoint_degc, float altitude_ft ) {
363 SGPropertyNode *node = args.getNode("dewpoint-degc", 0, true);
364 node->setFloatValue( dewpoint_degc );
365 node = args.getNode("altitude-ft", 0, true);
366 node->setFloatValue( altitude_ft );
367 globals->get_commands()->execute("set-dewpoint-temp-degc", &args);
372 FGMetarEnvironmentCtrl::update_env_config ()
374 fgSetupWind( fgGetDouble("/environment/metar/base-wind-range-from"),
375 fgGetDouble("/environment/metar/base-wind-range-to"),
376 fgGetDouble("/environment/metar/base-wind-speed-kt"),
377 fgGetDouble("/environment/metar/gust-wind-speed-kt") );
379 fgDefaultWeatherValue( "visibility-m",
380 fgGetDouble("/environment/metar/min-visibility-m") );
381 set_temp_at_altitude( fgGetDouble("/environment/metar/temperature-degc"),
382 station_elevation_ft );
383 set_dewpoint_at_altitude( fgGetDouble("/environment/metar/dewpoint-degc"),
384 station_elevation_ft );
385 fgDefaultWeatherValue( "pressure-sea-level-inhg",
386 fgGetDouble("/environment/metar/pressure-inhg") );
390 FGMetarEnvironmentCtrl::init ()
392 const SGPropertyNode *longitude
393 = fgGetNode( "/position/longitude-deg", true );
394 const SGPropertyNode *latitude
395 = fgGetNode( "/position/latitude-deg", true );
397 bool found_metar = false;
398 long max_age = metar_max_age->getLongValue();
399 // Don't check max age during init so that we don't loop over a lot
400 // of airports metar if there is a problem.
401 // The update() calls will find a correct metar if things went wrong here
402 metar_max_age->setLongValue(60 * 24 * 7);
404 while ( !found_metar && (_error_count < 3) ) {
405 const FGAirport* a = globals->get_airports()
406 ->search( longitude->getDoubleValue(),
407 latitude->getDoubleValue(),
410 FGMetarResult result = fetch_data( a->getId() );
411 if ( result.m != NULL ) {
412 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
416 search_elapsed = 0.0;
418 update_metar_properties( result.m );
423 // mark as no metar so it doesn't show up in subsequent
425 SG_LOG( SG_GENERAL, SG_INFO, "no metar at metar = "
427 globals->get_airports()->no_metar( a->getId() );
431 metar_max_age->setLongValue(max_age);
435 FGMetarEnvironmentCtrl::reinit ()
448 FGMetarEnvironmentCtrl::update(double delta_time_sec)
451 _dt += delta_time_sec;
452 if (_error_count >= 3)
455 FGMetarResult result;
457 static const SGPropertyNode *longitude
458 = fgGetNode( "/position/longitude-deg", true );
459 static const SGPropertyNode *latitude
460 = fgGetNode( "/position/latitude-deg", true );
461 search_elapsed += delta_time_sec;
462 fetch_elapsed += delta_time_sec;
464 // if time for a new search request, push it onto the request
466 if ( search_elapsed > search_interval_sec ) {
467 const FGAirport* a = globals->get_airports()
468 ->search( longitude->getDoubleValue(),
469 latitude->getDoubleValue(),
472 if ( last_apt.getId() != a->getId()
473 || fetch_elapsed > same_station_interval_sec )
475 SG_LOG( SG_GENERAL, SG_INFO, "closest station w/ metar = "
477 request_queue.push( a->getId() );
480 search_elapsed = 0.0;
483 search_elapsed = 0.0;
484 SG_LOG( SG_GENERAL, SG_INFO, "same station, waiting = "
485 << same_station_interval_sec - fetch_elapsed );
488 SG_LOG( SG_GENERAL, SG_WARN,
489 "Unable to find any airports with metar" );
493 #if defined(ENABLE_THREADS) && ENABLE_THREADS
494 // No loader thread running so manually fetch the data
496 while ( !request_queue.empty() ) {
497 id = request_queue.front();
502 SG_LOG( SG_GENERAL, SG_INFO, "inline fetching = " << id );
503 result = fetch_data( id );
504 result_queue.push( result );
506 #endif // ENABLE_THREADS
508 // process any results from the loader.
509 while ( !result_queue.empty() ) {
510 result = result_queue.front();
512 if ( result.m != NULL ) {
513 update_metar_properties( result.m );
518 // mark as no metar so it doesn't show up in subsequent
519 // searches, and signal an immediate re-search.
520 SG_LOG( SG_GENERAL, SG_WARN,
521 "no metar at station = " << result.icao );
522 globals->get_airports()->no_metar( result.icao );
523 search_elapsed = 9999.0;
527 env->update(delta_time_sec);
532 FGMetarEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
534 env->setEnvironment(environment);
538 FGMetarEnvironmentCtrl::fetch_data( const string &icao )
540 FGMetarResult result;
543 // if the last error was more than three seconds ago,
544 // then pretent nothing happened.
553 // fetch station elevation if exists
554 const FGAirport* a = globals->get_airports()->search( icao );
556 station_elevation_ft = a->getElevation();
559 // fetch current metar data
561 string host = proxy_host->getStringValue();
562 string auth = proxy_auth->getStringValue();
563 string port = proxy_port->getStringValue();
564 result.m = new FGMetar( icao, host, port, auth);
566 long max_age = metar_max_age->getLongValue();
567 if (max_age && result.m->getAge_min() > max_age) {
568 SG_LOG( SG_GENERAL, SG_WARN, "METAR data too old");
573 } catch (const sg_io_exception& e) {
574 SG_LOG( SG_GENERAL, SG_WARN, "Error fetching live weather data: "
575 << e.getFormattedMessage().c_str() );
576 #if defined(ENABLE_THREADS) && ENABLE_THREADS
577 if (_error_count++ >= 3) {
578 SG_LOG( SG_GENERAL, SG_WARN, "Stop fetching data permanently.");
594 FGMetarEnvironmentCtrl::update_metar_properties( const FGMetar *m )
600 fgSetString("/environment/metar/real-metar", m->getData());
601 // don't update with real weather when we use a custom weather scenario
602 const char *current_scenario = fgGetString("/environment/weather-scenario", "METAR");
603 if( strcmp(current_scenario, "METAR") && strcmp(current_scenario, "none"))
605 fgSetString("/environment/metar/last-metar", m->getData());
606 fgSetString("/environment/metar/station-id", m->getId());
607 fgSetDouble("/environment/metar/min-visibility-m",
608 m->getMinVisibility().getVisibility_m() );
609 fgSetDouble("/environment/metar/max-visibility-m",
610 m->getMaxVisibility().getVisibility_m() );
612 const SGMetarVisibility *dirvis = m->getDirVisibility();
613 for (i = 0; i < 8; i++, dirvis++) {
614 const char *min = "/environment/metar/visibility[%d]/min-m";
615 const char *max = "/environment/metar/visibility[%d]/max-m";
617 d = dirvis->getVisibility_m();
619 snprintf(s, 128, min, i);
621 snprintf(s, 128, max, i);
625 fgSetInt("/environment/metar/base-wind-range-from",
626 m->getWindRangeFrom() );
627 fgSetInt("/environment/metar/base-wind-range-to",
628 m->getWindRangeTo() );
629 fgSetDouble("/environment/metar/base-wind-speed-kt",
630 m->getWindSpeed_kt() );
631 fgSetDouble("/environment/metar/gust-wind-speed-kt",
632 m->getGustSpeed_kt() );
633 fgSetDouble("/environment/metar/temperature-degc",
634 m->getTemperature_C() );
635 fgSetDouble("/environment/metar/dewpoint-degc",
636 m->getDewpoint_C() );
637 fgSetDouble("/environment/metar/rel-humidity-norm",
638 m->getRelHumidity() );
639 fgSetDouble("/environment/metar/pressure-inhg",
640 m->getPressure_inHg() );
642 vector<SGMetarCloud> cv = m->getClouds();
643 vector<SGMetarCloud>::const_iterator cloud;
645 const char *cl = "/environment/clouds/layer[%i]";
646 for (i = 0, cloud = cv.begin(); cloud != cv.end(); cloud++, i++) {
647 const char *coverage_string[5] =
648 { "clear", "few", "scattered", "broken", "overcast" };
649 const double thickness[5] = { 0, 65, 600,750, 1000};
652 snprintf(s, 128, cl, i);
653 strncat(s, "/coverage", 128);
654 q = cloud->getCoverage();
655 fgSetString(s, coverage_string[q] );
657 snprintf(s, 128, cl, i);
658 strncat(s, "/elevation-ft", 128);
659 fgSetDouble(s, cloud->getAltitude_ft() + station_elevation_ft);
661 snprintf(s, 128, cl, i);
662 strncat(s, "/thickness-ft", 128);
663 fgSetDouble(s, thickness[q]);
665 snprintf(s, 128, cl, i);
666 strncat(s, "/span-m", 128);
667 fgSetDouble(s, 40000.0);
670 for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
671 snprintf(s, 128, cl, i);
672 strncat(s, "/coverage", 128);
673 fgSetString(s, "clear");
675 snprintf(s, 128, cl, i);
676 strncat(s, "/elevation-ft", 128);
677 fgSetDouble(s, -9999);
679 snprintf(s, 128, cl, i);
680 strncat(s, "/thickness-ft", 128);
683 snprintf(s, 128, cl, i);
684 strncat(s, "/span-m", 128);
685 fgSetDouble(s, 40000.0);
688 fgSetDouble("/environment/metar/rain-norm", m->getRain());
689 fgSetDouble("/environment/metar/hail-norm", m->getHail());
690 fgSetDouble("/environment/metar/snow-norm", m->getSnow());
691 fgSetBool("/environment/metar/snow-cover", m->getSnowCover());
695 #if defined(ENABLE_THREADS) && ENABLE_THREADS
700 FGMetarEnvironmentCtrl::MetarThread::run()
702 pthread_cleanup_push( metar_cleanup_handler, fetcher );
705 set_cancel( SGThread::CANCEL_DISABLE );
707 string icao = fetcher->request_queue.pop();
708 SG_LOG( SG_GENERAL, SG_INFO, "Thread: fetch metar data = " << icao );
709 FGMetarResult result = fetcher->fetch_data( icao );
711 set_cancel( SGThread::CANCEL_DEFERRED );
713 fetcher->result_queue.push( result );
715 pthread_cleanup_pop(1);
719 * Ensure mutex is unlocked.
722 metar_cleanup_handler( void* arg )
724 FGMetarEnvironmentCtrl* fetcher = (FGMetarEnvironmentCtrl*) arg;
725 fetcher->mutex.unlock();
727 #endif // ENABLE_THREADS
730 // end of environment_ctrl.cxx