// 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
//
//
// 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 <simgear/debug/logstream.hxx>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
-#include <stdlib.h>
-#include <Main/fg_props.hxx>
+#include <algorithm>
+#include <Main/fg_props.hxx>
#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);
+ }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief Models a column of our atmosphere by stacking a number of environments above
+ * each other
+ */
+class LayerTable : public std::vector<LayerTableBucket *>, public SGPropertyChangeListener
+{
+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();
-\f
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGEnvironmentCtrl abstract base class.
-////////////////////////////////////////////////////////////////////////
+ /**
+ *@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
+{
+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()
+{
+ for( iterator it = begin(); it != end(); it++ )
+ delete (*it);
+}
-FGEnvironmentCtrl::FGEnvironmentCtrl ()
- : _environment(0),
- _lon_deg(0),
- _lat_deg(0),
- _elev_ft(0)
+void LayerTable::read(FGEnvironment * parent )
{
+ 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 );
+ }
+ }
}
-FGEnvironmentCtrl::~FGEnvironmentCtrl ()
+void LayerTable::Bind()
{
+ // 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::setEnvironment (FGEnvironment * environment)
+void LayerTable::Unbind()
{
- _environment = environment;
+ // 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::setLongitudeDeg (double lon_deg)
+void LayerTable::valueChanged( SGPropertyNode * node )
{
- _lon_deg = lon_deg;
+ // 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 );
}
-void
-FGEnvironmentCtrl::setLatitudeDeg (double lat_deg)
+
+void LayerTable::interpolate( double altitude_ft, FGEnvironment * result )
{
- _lat_deg = lat_deg;
+ int length = size();
+ if (length == 0)
+ return;
+
+ // 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
-FGEnvironmentCtrl::setElevationFt (double elev_ft)
+//////////////////////////////////////////////////////////////////////////////
+
+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 ) )
{
- _elev_ft = elev_ft;
}
-void
-FGEnvironmentCtrl::setPosition (double lon_deg, double lat_deg, double elev_ft)
+void LayerInterpolateControllerImplementation::init ()
{
- _lon_deg = lon_deg;
- _lat_deg = lat_deg;
- _elev_ft = elev_ft;
+ _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);
}
+void LayerInterpolateControllerImplementation::reinit ()
+{
+ _boundary_table.Unbind();
+ _aloft_table.Unbind();
+ init();
+ postinit();
+}
-\f
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGUserDefEnvironmentCtrl.
-////////////////////////////////////////////////////////////////////////
+void LayerInterpolateControllerImplementation::postinit()
+{
+ // we get here after 1. bind() and 2. init() was called by fg_init
+ _boundary_table.Bind();
+ _aloft_table.Bind();
+}
-FGUserDefEnvironmentCtrl::FGUserDefEnvironmentCtrl ()
- : _base_wind_speed_node(0),
- _gust_wind_speed_node(0),
- _current_wind_speed_kt(0),
- _delta_wind_speed_kt(0)
+void LayerInterpolateControllerImplementation::bind()
{
+ // 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 );
}
-FGUserDefEnvironmentCtrl::~FGUserDefEnvironmentCtrl ()
+void LayerInterpolateControllerImplementation::unbind()
{
+ _boundary_table.Unbind();
+ _aloft_table.Unbind();
+ _tiedProperties.Untie();
+ _environment.Untie();
}
-void
-FGUserDefEnvironmentCtrl::init ()
+void LayerInterpolateControllerImplementation::update (double delta_time_sec)
{
- // 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"));
+ if( !_enabled || delta_time_sec <= SGLimitsd::min() )
+ return;
+
+ double altitude_ft = _altitude_n->getDoubleValue();
+ double altitude_agl_ft = _altitude_agl_n->getDoubleValue();
- _base_wind_speed_node =
- fgGetNode("/environment/params/base-wind-speed-kt", true);
- _gust_wind_speed_node =
- fgGetNode("/environment/params/gust-wind-speed-kt", true);
+ // avoid div by zero later on and init with a default value if not given
+ if( _boundary_transition <= SGLimitsd::min() )
+ _boundary_transition = 500;
- _current_wind_speed_kt = _base_wind_speed_node->getDoubleValue();
- _delta_wind_speed_kt = 0.1;
+ int length = _boundary_table.size();
+
+ if (length > 0) {
+ // 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) {
+ // 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) {
+ // 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;
+ }
+ }
+ // 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
-FGUserDefEnvironmentCtrl::update (double dt)
-{
- 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);
+//////////////////////////////////////////////////////////////////////////////
+
+LayerInterpolateController * LayerInterpolateController::createInstance( SGPropertyNode_ptr rootNode )
+{
+ return new LayerInterpolateControllerImplementation( rootNode );
}
-// end of environment_ctrl.cxx
+//////////////////////////////////////////////////////////////////////////////
+
+} // namespace
projects / flightgear.git / blobdiff