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 <Main/fg_props.hxx>
30 #include "environment_mgr.hxx"
31 #include "environment_ctrl.hxx"
37 ////////////////////////////////////////////////////////////////////////
38 // Implementation of FGEnvironmentCtrl abstract base class.
39 ////////////////////////////////////////////////////////////////////////
41 FGEnvironmentCtrl::FGEnvironmentCtrl ()
49 FGEnvironmentCtrl::~FGEnvironmentCtrl ()
54 FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment)
56 _environment = environment;
60 FGEnvironmentCtrl::setLongitudeDeg (double lon_deg)
66 FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
72 FGEnvironmentCtrl::setElevationFt (double elev_ft)
78 FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
87 ////////////////////////////////////////////////////////////////////////
88 // Implementation of FGUserDefEnvironmentCtrl.
89 ////////////////////////////////////////////////////////////////////////
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)
99 FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
104 FGUserDefEnvironmentCtrl::init ()
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"));
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);
119 _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
120 _delta_wind_speed_kt = 0.1;
124 FGUserDefEnvironmentCtrl::update (double dt)
126 double base_wind_speed = _base_wind_speed_node->getDoubleValue();
127 double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
129 if (gust_wind_speed < base_wind_speed) {
130 gust_wind_speed = base_wind_speed;
131 _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
134 if (base_wind_speed == gust_wind_speed) {
135 _current_wind_speed_kt = base_wind_speed;
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;
143 _delta_wind_speed_kt = - _delta_wind_speed_kt;
145 _delta_wind_speed_kt -= incr * sign;
147 _delta_wind_speed_kt += incr * sign;
149 _current_wind_speed_kt += _delta_wind_speed_kt;
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;
160 if (_environment != 0)
161 _environment->set_wind_speed_kt(_current_wind_speed_kt);
166 ////////////////////////////////////////////////////////////////////////
167 // Implementation of FGInterpolateEnvironmentCtrl.
168 ////////////////////////////////////////////////////////////////////////
170 FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl ()
174 FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl ()
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];
186 FGInterpolateEnvironmentCtrl::init ()
188 read_table(fgGetNode("/environment/config/boundary", true),
190 read_table(fgGetNode("/environment/config/aloft", true),
195 FGInterpolateEnvironmentCtrl::reinit ()
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();
208 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node,
209 vector<bucket *> &table)
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 ) )
217 bucket * b = new bucket;
219 b->environment.copy(table[i-1]->environment);
220 b->environment.read(child);
221 b->altitude_ft = b->environment.get_elevation_ft();
225 sort(table.begin(), table.end());
229 FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
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);
237 // double ground_elevation_ft = altitude_ft - altitude_agl_ft;
239 int length = _boundary_table.size();
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,
248 } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
250 do_interpolate(_boundary_table, altitude_agl_ft, &env1);
251 do_interpolate(_aloft_table, altitude_ft, &env2);
253 (altitude_agl_ft - boundary_limit) / boundary_transition;
254 interpolate(&env1, &env2, fraction, _environment);
260 do_interpolate(_aloft_table, altitude_ft, _environment);
264 FGInterpolateEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
266 FGEnvironment * environment)
268 int length = table.size();
272 // Boundary conditions
273 if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) {
274 environment->copy(table[0]->environment);
276 } else if (table[length-1]->altitude_ft <= altitude_ft) {
277 environment->copy(table[length-1]->environment);
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);
287 if (table[i]->altitude_ft == table[i+1]->altitude_ft)
291 ((altitude_ft - table[i]->altitude_ft) /
292 (table[i+1]->altitude_ft - table[i]->altitude_ft));
293 interpolate(env1, env2, fraction, environment);
301 FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const
303 return (altitude_ft < b.altitude_ft);
308 ////////////////////////////////////////////////////////////////////////
309 // Implementation of FGMetarEnvironmentCtrl.
310 ////////////////////////////////////////////////////////////////////////
312 FGMetarEnvironmentCtrl::FGMetarEnvironmentCtrl ()
313 : _icao( strdup( fgGetString("/sim/presets/airport-id") ) )
317 FGMetarEnvironmentCtrl::~FGMetarEnvironmentCtrl ()
327 FGMetarEnvironmentCtrl::init ()
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);
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"));
351 FGMetarEnvironmentCtrl::reinit ()
357 FGMetarEnvironmentCtrl::read_table (const char *icao)
363 if ((icao == NULL) && (_icao == NULL)) {
364 _icao = strdup( fgGetString("/sim/presets/airport-id") );
366 } else if (icao != NULL) {
370 _icao = strdup(icao);
372 SGMetar *m = new SGMetar(_icao);
374 d = m->getMinVisibility().getVisibility_m();
375 d = (d != SGMetarNaN) ? d : 10000;
376 fgSetDouble("/environment/metar/min-visibility-m", d);
378 dt = m->getMaxVisibility().getVisibility_m();
379 d = (dt != SGMetarNaN) ? dt : d;
380 fgSetDouble("/environment/metar/max-visibility-m", d);
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";
388 d = dirvis->getVisibility_m();
389 d = (d != SGMetarNaN) ? d : 10000;
391 snprintf(s, 128, min, i);
393 snprintf(s, 128, max, i);
399 fgSetInt("/environment/metar/base-wind-range-from",
400 m->getWindRangeFrom() );
401 fgSetInt("/environment/metar/base-wind-range-to",
402 m->getWindRangeTo() );
404 fgSetInt("/environment/metar/base-wind-range-from", i);
405 fgSetInt("/environment/metar/base-wind-range-to", i);
407 fgSetDouble("/environment/metar/base-wind-speed-kt",
408 m->getWindSpeed_kt() );
410 d = m->getGustSpeed_kt();
411 d = (d != SGMetarNaN) ? d : 0.0;
412 fgSetDouble("/environment/metar/gust-wind-speed-kt", d);
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() );
422 d = (d != SGMetarNaN) ? d : 15.0;
423 fgSetDouble("/environment/metar/temperature_degc", d);
425 d = m->getPressure_inHg();
426 d = (d != SGMetarNaN) ? d : 30.0;
427 fgSetDouble("/environment/metar/pressure-inhg", d);
429 vector<SGMetarCloud> cv = m->getClouds();
430 vector<SGMetarCloud>::iterator cloud;
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};
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] );
445 snprintf(s, 128, cl, i);
446 strncat(s, "/elevation-ft", 128);
447 d = cloud->getAltitude_ft();
448 d = (d != SGMetarNaN) ? d : -9999;
451 snprintf(s, 128, cl, i);
452 strncat(s, "/thickness-ft", 128);
453 fgSetDouble(s, thickness[q]);
455 snprintf(s, 128, cl, i);
456 strncat(s, "/span-m", 128);
457 fgSetDouble(s, 40000.0);
459 for (; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
460 snprintf(s, 128, cl, i);
461 strncat(s, "/coverage", 128);
462 fgSetString(s, "clear");
464 snprintf(s, 128, cl, i);
465 strncat(s, "/elevation-ft", 128);
466 fgSetDouble(s, -9999);
468 snprintf(s, 128, cl, i);
469 strncat(s, "/thickness-ft", 128);
472 snprintf(s, 128, cl, i);
473 strncat(s, "/span-m", 128);
474 fgSetDouble(s, 40000.0);
481 FGMetarEnvironmentCtrl::update (double delta_time_sec)
483 double base_wind_speed = _base_wind_speed_node->getDoubleValue();
484 double gust_wind_speed = _gust_wind_speed_node->getDoubleValue();
486 if (gust_wind_speed < base_wind_speed) {
487 gust_wind_speed = base_wind_speed;
488 _gust_wind_speed_node->setDoubleValue(gust_wind_speed);
491 if (base_wind_speed == gust_wind_speed) {
492 _current_wind_speed_kt = base_wind_speed;
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;
500 _delta_wind_speed_kt = - _delta_wind_speed_kt;
502 _delta_wind_speed_kt -= incr * sign;
504 _delta_wind_speed_kt += incr * sign;
506 _current_wind_speed_kt += _delta_wind_speed_kt;
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;
517 if (_environment != 0)
518 _environment->set_wind_speed_kt(_current_wind_speed_kt);
522 FGMetarEnvironmentCtrl::do_interpolate (vector<bucket *> &table,
524 FGEnvironment * environment)
529 FGMetarEnvironmentCtrl::bucket::operator< (const bucket &b) const
531 return (altitude_ft < b.altitude_ft);
534 // end of environment_ctrl.cxx