X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FEnvironment%2Fenvironment_ctrl.cxx;h=c182f06250cf250e62993e3b77f726c02e9b3992;hb=808c4c635d9d07f812041169d4b30257fd80742f;hp=1c817277b8d86e15d754dca8a9ca14018bffde38;hpb=429a5067d8dd56a5050fc36080fc1f4fb163def5;p=flightgear.git diff --git a/src/Environment/environment_ctrl.cxx b/src/Environment/environment_ctrl.cxx index 1c817277b..c182f0625 100644 --- a/src/Environment/environment_ctrl.cxx +++ b/src/Environment/environment_ctrl.cxx @@ -1,6 +1,7 @@ // environment_ctrl.cxx -- manager for natural environment information. // // Written by David Megginson, started February 2002. +// Partly rewritten by Torsten Dreyer, August 2010. // // Copyright (C) 2002 David Megginson - david@megginson.com // @@ -16,291 +17,333 @@ // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software -// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // -// $Id$ -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif -#include #include #include
- #include "environment_ctrl.hxx" +#include "environment.hxx" + +namespace Environment { + +/** + * @brief Describes an element of a LayerTable. A defined environment at a given altitude. +*/ +struct LayerTableBucket { + double altitude_ft; + FGEnvironment environment; + inline bool operator< (const LayerTableBucket &b) const { + return (altitude_ft < b.altitude_ft); + } + /** + * @brief LessThan predicate for bucket pointers. + */ + static bool lessThan(LayerTableBucket *a, LayerTableBucket *b) { + return (a->altitude_ft) < (b->altitude_ft); + } +}; -SG_USING_STD(sort); - - - -//////////////////////////////////////////////////////////////////////// -// Implementation of FGEnvironmentCtrl abstract base class. -//////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// -FGEnvironmentCtrl::FGEnvironmentCtrl () - : _environment(0), - _lon_deg(0), - _lat_deg(0), - _elev_ft(0) +/** + * @brief Models a column of our atmosphere by stacking a number of environments above + * each other + */ +class LayerTable : public std::vector, public SGPropertyChangeListener { -} - -FGEnvironmentCtrl::~FGEnvironmentCtrl () +public: + LayerTable( SGPropertyNode_ptr rootNode ) : + _rootNode(rootNode) {} + + ~LayerTable(); + + /** + * @brief Read the environment column from properties relative to the given root node + * @param environment A template environment to copy values from, not given in the configuration + */ + void read( FGEnvironment * parent = NULL ); + + /** + *@brief Interpolate and write environment values for a given altitude + *@param altitude_ft The altitude for the desired environment + *@environment the destination to write the resulting environment properties to + */ + void interpolate(double altitude_ft, FGEnvironment * environment); + + /** + *@brief Bind all environments properties to property nodes and initialize the listeners + */ + void Bind(); + + /** + *@brief Unbind all environments properties from property nodes and deregister listeners + */ + void Unbind(); +private: + /** + * @brief Implementation of SGProertyChangeListener::valueChanged() + * Takes care of consitent sea level pressure for the entire column + */ + void valueChanged( SGPropertyNode * node ); + SGPropertyNode_ptr _rootNode; +}; + +////////////////////////////////////////////////////////////////////////////// + + +/** + *@brief Implementation of the LayerIterpolateController + */ +class LayerInterpolateControllerImplementation : public LayerInterpolateController { -} - -void -FGEnvironmentCtrl::setEnvironment (FGEnvironment * environment) +public: + LayerInterpolateControllerImplementation( SGPropertyNode_ptr rootNode ); + + virtual void init (); + virtual void reinit (); + virtual void postinit(); + virtual void bind(); + virtual void unbind(); + virtual void update (double delta_time_sec); + +private: + SGPropertyNode_ptr _rootNode; + bool _enabled; + double _boundary_transition; + SGPropertyNode_ptr _altitude_n; + SGPropertyNode_ptr _altitude_agl_n; + + LayerTable _boundary_table; + LayerTable _aloft_table; + + FGEnvironment _environment; + simgear::TiedPropertyList _tiedProperties; +}; + +////////////////////////////////////////////////////////////////////////////// + +LayerTable::~LayerTable() { - _environment = environment; + for( iterator it = begin(); it != end(); it++ ) + delete (*it); } -void -FGEnvironmentCtrl::setLongitudeDeg (double lon_deg) +void LayerTable::read(FGEnvironment * parent ) { - _lon_deg = lon_deg; + double last_altitude_ft = 0.0; + double sort_required = false; + size_t i; + + for (i = 0; i < (size_t)_rootNode->nChildren(); i++) { + const SGPropertyNode * child = _rootNode->getChild(i); + if ( child->getNameString() == "entry" + && child->getStringValue("elevation-ft", "")[0] != '\0' + && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) ) + { + LayerTableBucket * b; + if( i < size() ) { + // recycle existing bucket + b = at(i); + } else { + // more nodes than buckets in table, add a new one + b = new LayerTableBucket; + push_back(b); + } + if (i == 0 && parent != NULL ) + b->environment = *parent; + if (i > 0) + b->environment = at(i-1)->environment; + + b->environment.read(child); + b->altitude_ft = b->environment.get_elevation_ft(); + + // check, if altitudes are in ascending order + if( b->altitude_ft < last_altitude_ft ) + sort_required = true; + last_altitude_ft = b->altitude_ft; + } + } + // remove leftover buckets + while( size() > i ) { + LayerTableBucket * b = *(end() - 1); + delete b; + pop_back(); + } + + if( sort_required ) + sort(begin(), end(), LayerTableBucket::lessThan); + + // cleanup entries with (almost)same altitude + for( size_type n = 1; n < size(); n++ ) { + if( fabs(at(n)->altitude_ft - at(n-1)->altitude_ft ) < 1 ) { + SG_LOG( SG_GENERAL, SG_ALERT, "Removing duplicate altitude entry in environment config for altitude " << at(n)->altitude_ft ); + erase( begin() + n ); + } + } } -void -FGEnvironmentCtrl::setLatitudeDeg (double lat_deg) +void LayerTable::Bind() { - _lat_deg = lat_deg; + // tie all environments to ~/entry[n]/xxx + // register this as a changelistener of ~/entry[n]/pressure-sea-level-inhg + for( unsigned i = 0; i < size(); i++ ) { + SGPropertyNode_ptr baseNode = _rootNode->getChild("entry", i, true ); + at(i)->environment.Tie( baseNode ); + baseNode->getNode( "pressure-sea-level-inhg", true )->addChangeListener( this ); + } } -void -FGEnvironmentCtrl::setElevationFt (double elev_ft) +void LayerTable::Unbind() { - _elev_ft = elev_ft; + // untie all environments to ~/entry[n]/xxx + // deregister this as a changelistener of ~/entry[n]/pressure-sea-level-inhg + for( unsigned i = 0; i < size(); i++ ) { + SGPropertyNode_ptr baseNode = _rootNode->getChild("entry", i, true ); + at(i)->environment.Untie(); + baseNode->getNode( "pressure-sea-level-inhg", true )->removeChangeListener( this ); + } } -void -FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft) +void LayerTable::valueChanged( SGPropertyNode * node ) { - _lon_deg = lon_deg; - _lat_deg = lat_deg; - _elev_ft = elev_ft; + // Make sure all environments in our column use the same sea level pressure + double value = node->getDoubleValue(); + for( iterator it = begin(); it != end(); it++ ) + (*it)->environment.set_pressure_sea_level_inhg( value ); } - -//////////////////////////////////////////////////////////////////////// -// Implementation of FGUserDefEnvironmentCtrl. -//////////////////////////////////////////////////////////////////////// - -FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl () - : _base_wind_speed_node(0), - _gust_wind_speed_node(0), - _current_wind_speed_kt(0), - _delta_wind_speed_kt(0) +void LayerTable::interpolate( double altitude_ft, FGEnvironment * result ) { -} + int length = size(); + if (length == 0) + return; -FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl () -{ + // Boundary conditions + if ((length == 1) || (at(0)->altitude_ft >= altitude_ft)) { + *result = at(0)->environment; // below bottom of table + return; + } else if (at(length-1)->altitude_ft <= altitude_ft) { + *result = at(length-1)->environment; // above top of table + return; + } + + // Search the interpolation table + int layer; + for ( layer = 1; // can't be below bottom layer, handled above + layer < length && at(layer)->altitude_ft <= altitude_ft; + layer++); + FGEnvironment & env1 = (at(layer-1)->environment); + FGEnvironment & env2 = (at(layer)->environment); + // two layers of same altitude were sorted out in read_table + double fraction = ((altitude_ft - at(layer-1)->altitude_ft) / + (at(layer)->altitude_ft - at(layer-1)->altitude_ft)); + env1.interpolate(env2, fraction, result); } -void -FGUserDefEnvironmentCtrl::init () -{ - // Fill in some defaults. - if (!fgHasNode("/environment/params/base-wind-speed-kt")) - fgSetDouble("/environment/params/base-wind-speed-kt", - fgGetDouble("/environment/wind-speed-kt")); - if (!fgHasNode("/environment/params/gust-wind-speed-kt")) - fgSetDouble("/environment/params/gust-wind-speed-kt", - fgGetDouble("/environment/params/base-wind-speed-kt")); - - _base_wind_speed_node = - fgGetNode("/environment/params/base-wind-speed-kt", true); - _gust_wind_speed_node = - fgGetNode("/environment/params/gust-wind-speed-kt", true); - - _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue(); - _delta_wind_speed_kt = 0.1; -} +////////////////////////////////////////////////////////////////////////////// -void -FGUserDefEnvironmentCtrl::update (double dt) +LayerInterpolateControllerImplementation::LayerInterpolateControllerImplementation( SGPropertyNode_ptr rootNode ) : + _rootNode( rootNode ), + _enabled(true), + _boundary_transition(0.0), + _altitude_n( fgGetNode("/position/altitude-ft", true)), + _altitude_agl_n( fgGetNode("/position/altitude-agl-ft", true)), + _boundary_table( rootNode->getNode("boundary", true ) ), + _aloft_table( rootNode->getNode("aloft", true ) ) { - double base_wind_speed = _base_wind_speed_node->getDoubleValue(); - double gust_wind_speed = _gust_wind_speed_node->getDoubleValue(); - - if (gust_wind_speed < base_wind_speed) { - gust_wind_speed = base_wind_speed; - _gust_wind_speed_node->setDoubleValue(gust_wind_speed); - } - - if (base_wind_speed == gust_wind_speed) { - _current_wind_speed_kt = base_wind_speed; - } else { - int rn = rand() % 128; - int sign = (_delta_wind_speed_kt < 0 ? -1 : 1); - double gust = _current_wind_speed_kt - base_wind_speed; - double incr = gust / 50; - - if (rn == 0) - _delta_wind_speed_kt = - _delta_wind_speed_kt; - else if (rn < 4) - _delta_wind_speed_kt -= incr * sign; - else if (rn < 16) - _delta_wind_speed_kt += incr * sign; - - _current_wind_speed_kt += _delta_wind_speed_kt; - - if (_current_wind_speed_kt < base_wind_speed) { - _current_wind_speed_kt = base_wind_speed; - _delta_wind_speed_kt = 0.01; - } else if (_current_wind_speed_kt > gust_wind_speed) { - _current_wind_speed_kt = gust_wind_speed; - _delta_wind_speed_kt = -0.01; - } - } - - if (_environment != 0) - _environment->set_wind_speed_kt(_current_wind_speed_kt); } - - -//////////////////////////////////////////////////////////////////////// -// Implementation of FGInterpolateEnvironmentCtrl. -//////////////////////////////////////////////////////////////////////// - -FGInterpolateEnvironmentCtrl::FGInterpolateEnvironmentCtrl () +void LayerInterpolateControllerImplementation::init () { + _boundary_table.read(); + // pass in a pointer to the environment of the last bondary layer as + // a starting point + _aloft_table.read(&(*(_boundary_table.end()-1))->environment); } -FGInterpolateEnvironmentCtrl::~FGInterpolateEnvironmentCtrl () +void LayerInterpolateControllerImplementation::reinit () { - int i; - for (i = 0; i < _boundary_table.size(); i++) - delete _boundary_table[i]; - for (i = 0; i < _aloft_table.size(); i++) - delete _aloft_table[i]; + _boundary_table.Unbind(); + _aloft_table.Unbind(); + init(); + postinit(); } - - -void -FGInterpolateEnvironmentCtrl::init () +void LayerInterpolateControllerImplementation::postinit() { - read_table(fgGetNode("/environment/config/boundary", true), - _boundary_table); - read_table(fgGetNode("/environment/config/aloft", true), - _aloft_table); + // we get here after 1. bind() and 2. init() was called by fg_init + _boundary_table.Bind(); + _aloft_table.Bind(); } -void -FGInterpolateEnvironmentCtrl::reinit () +void LayerInterpolateControllerImplementation::bind() { - int i; - for (i = 0; i < _boundary_table.size(); i++) - delete _boundary_table[i]; - for (i = 0; i < _aloft_table.size(); i++) - delete _aloft_table[i]; - _boundary_table.clear(); - _aloft_table.clear(); - init(); + // don't bind the layer tables here, because they have not been read in yet. + _environment.Tie( _rootNode->getNode( "interpolated", true ) ); + _tiedProperties.Tie( _rootNode->getNode("enabled", true), &_enabled ); + _tiedProperties.Tie( _rootNode->getNode("boundary-transition-ft", true ), &_boundary_transition ); } -void -FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node, - vector &table) +void LayerInterpolateControllerImplementation::unbind() { - for (int i = 0; i < node->nChildren(); i++) { - const SGPropertyNode * child = node->getChild(i); - if ( strcmp(child->getName(), "entry") == 0 - && child->getStringValue("elevation-ft", "")[0] != '\0' - && ( child->getDoubleValue("elevation-ft") > 0.1 || i == 0 ) ) - { - bucket * b = new bucket; - if (i > 0) - b->environment.copy(table[i-1]->environment); - b->environment.read(child); - b->altitude_ft = b->environment.get_elevation_ft(); - table.push_back(b); - } - } - sort(table.begin(), table.end()); + _boundary_table.Unbind(); + _aloft_table.Unbind(); + _tiedProperties.Untie(); + _environment.Untie(); } -void -FGInterpolateEnvironmentCtrl::update (double delta_time_sec) +void LayerInterpolateControllerImplementation::update (double delta_time_sec) { - // FIXME - double altitude_ft = fgGetDouble("/position/altitude-ft"); - double altitude_agl_ft = fgGetDouble("/position/altitude-agl-ft"); - double boundary_transition = - fgGetDouble("/environment/config/boundary-transition-ft", 500); + if( !_enabled || delta_time_sec <= SGLimitsd::min() ) + return; + + double altitude_ft = _altitude_n->getDoubleValue(); + double altitude_agl_ft = _altitude_agl_n->getDoubleValue(); - double ground_elevation_ft = altitude_ft - altitude_agl_ft; + // avoid div by zero later on and init with a default value if not given + if( _boundary_transition <= SGLimitsd::min() ) + _boundary_transition = 500; int length = _boundary_table.size(); if (length > 0) { - // boundary table + // If a boundary table is defined, get the top of the boundary layer double boundary_limit = _boundary_table[length-1]->altitude_ft; if (boundary_limit >= altitude_agl_ft) { - do_interpolate(_boundary_table, altitude_agl_ft, - _environment); + // If current altitude is below top of boundary layer, interpolate + // only in boundary layer + _boundary_table.interpolate(altitude_agl_ft, &_environment); return; - } else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) { - // both tables - do_interpolate(_boundary_table, altitude_agl_ft, &env1); - do_interpolate(_aloft_table, altitude_ft, &env2); - double fraction = - (altitude_agl_ft - boundary_limit) / boundary_transition; - interpolate(&env1, &env2, fraction, _environment); + } else if ((boundary_limit + _boundary_transition) >= altitude_agl_ft) { + // If current altitude is above top of boundary layer and within the + // transition altitude, interpolate boundary and aloft layers + FGEnvironment env1, env2; + _boundary_table.interpolate( altitude_agl_ft, &env1); + _aloft_table.interpolate(altitude_ft, &env2); + double fraction = (altitude_agl_ft - boundary_limit) / _boundary_transition; + env1.interpolate(env2, fraction, &_environment); return; } - } - - // aloft table - do_interpolate(_aloft_table, altitude_ft, _environment); + } + // If no boundary layer is defined or altitude is above top boundary-layer plus boundary-transition + // altitude, use only the aloft table + _aloft_table.interpolate( altitude_ft, &_environment); } -void -FGInterpolateEnvironmentCtrl::do_interpolate (vector &table, - double altitude_ft, - FGEnvironment * environment) -{ - int length = table.size(); - if (length == 0) - return; - - // Boundary conditions - if ((length == 1) || (table[0]->altitude_ft >= altitude_ft)) { - environment->copy(table[0]->environment); - return; - } else if (table[length-1]->altitude_ft <= altitude_ft) { - environment->copy(table[length-1]->environment); - return; - } - - // Search the interpolation table - for (int i = 0; i < length - 1; i++) { - if ((i == length - 1) || (table[i]->altitude_ft <= altitude_ft)) { - FGEnvironment * env1 = &(table[i]->environment); - FGEnvironment * env2 = &(table[i+1]->environment); - double fraction; - if (table[i]->altitude_ft == table[i+1]->altitude_ft) - fraction = 1.0; - else - fraction = - ((altitude_ft - table[i]->altitude_ft) / - (table[i+1]->altitude_ft - table[i]->altitude_ft)); - interpolate(env1, env2, fraction, environment); - - return; - } - } -} +////////////////////////////////////////////////////////////////////////////// -bool -FGInterpolateEnvironmentCtrl::bucket::operator< (const bucket &b) const +LayerInterpolateController * LayerInterpolateController::createInstance( SGPropertyNode_ptr rootNode ) { - return (altitude_ft < b.altitude_ft); + return new LayerInterpolateControllerImplementation( rootNode ); } +////////////////////////////////////////////////////////////////////////////// -// end of environment_ctrl.cxx +} // namespace