Hack in an /accelerations/pilot-g property, for testing a new panel

[flightgear.git] / src / WeatherCM / FGPhysicalProperties.h

diff --git a/src/WeatherCM/FGPhysicalProperties.h b/src/WeatherCM/FGPhysicalProperties.h
index 0795d4d51b3a86a85e9163d3eb62023f65f34d7d..2e39d5b6b82d5d557eeba91d16fb5a41ab3915da 100644 (file)
--- a/src/WeatherCM/FGPhysicalProperties.h
+++ b/src/WeatherCM/FGPhysicalProperties.h
@@ -1,10 +1,10 @@
-/*******-*- Mode: C++ -*-************************************************************
+/*****************************************************************************

 
  Header:       FGPhysicalProperties.h  
  Author:       Christian Mayer
  Date started: 28.05.99
 
 
  Header:       FGPhysicalProperties.h  
  Author:       Christian Mayer
  Date started: 28.05.99
 

- ---------- Copyright (C) 1999  Christian Mayer (vader@t-online.de) ----------
+ -------- Copyright (C) 1999 Christian Mayer (fgfs@christianmayer.de) --------

 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software


@@ -34,6 +34,14 @@ HISTORY
 20.06.1999 Christian Mayer     Changed struct to class 
 20.06.1999 Christian Mayer     added lots of consts
 30.06.1999 Christian Mayer     STL portability
 20.06.1999 Christian Mayer     Changed struct to class 
 20.06.1999 Christian Mayer     added lots of consts
 30.06.1999 Christian Mayer     STL portability

+11.10.1999 Christian Mayer     changed set<> to map<> on Bernie Bright's 
+                               suggestion
+19.10.1999 Christian Mayer     change to use PLIB's sg instead of Point[2/3]D
+                               and lots of wee code cleaning
+15.12.1999 Christian Mayer     changed the air pressure calculation to a much
+                               more realistic formula. But as I need for that
+                               the temperature I moved the code to 
+                               FGPhysicalProperties

 *****************************************************************************/
 
 /****************************************************************************/
 *****************************************************************************/
 
 /****************************************************************************/


@@ -45,111 +53,130 @@ HISTORY
 /****************************************************************************/
 /* INCLUDES                                                                */
 /****************************************************************************/
 /****************************************************************************/
 /* INCLUDES                                                                */
 /****************************************************************************/

-#include <Include/compiler.h>
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <simgear/compiler.h>
+
+#ifdef HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+#include STL_IOSTREAM

 #include <vector>
 #include <vector>

-#include <set>
+#include <map>

 
 

-FG_USING_STD(vector);
-FG_USING_STD(set);
-FG_USING_NAMESPACE(std);
+#include <plib/sg.h>

 
 

-#include <Math/point3d.hxx>
-#include <Voronoi/point2d.h>

 #include "FGWeatherDefs.h"
 
 #include "FGWeatherDefs.h"
 

+#include "FGAirPressureItem.h"

 #include "FGWindItem.h"
 #include "FGTurbulenceItem.h"
 #include "FGWindItem.h"
 #include "FGTurbulenceItem.h"

-#include "FGTemperatureItem.h"
-#include "FGAirPressureItem.h"
-#include "FGVaporPressureItem.h"

 
 #include "FGCloudItem.h"
 #include "FGSnowRain.h"
 
 
 #include "FGCloudItem.h"
 #include "FGSnowRain.h"
 

+SG_USING_STD(vector);
+SG_USING_STD(map);
+SG_USING_NAMESPACE(std);
+
+/****************************************************************************/
+/* FOREWARD DEFINITIONS                                                            */
+/****************************************************************************/
+class FGPhysicalProperties2D;
+ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
+

 class FGPhysicalProperties
 {
 public:
 class FGPhysicalProperties
 {
 public:

-    set<FGWindItem> Wind;                  //all Wind vectors
-    set<FGTurbulenceItem> Turbulence;      //all Turbulence vectors
-    set<FGTemperatureItem> Temperature;            //in deg. Kelvin (I *only* accept SI!)
-    FGAirPressureItem AirPressure;         //in Pascal (I *only* accept SI!)
-    set<FGVaporPressureItem> VaporPressure; //in Pascal (I *only* accept SI!)
+    typedef WeatherPrecision Altitude;  
+
+    map<Altitude,FGWindItem>       Wind;           //all Wind vectors
+    map<Altitude,FGTurbulenceItem> Turbulence;     //all Turbulence vectors
+    map<Altitude,WeatherPrecision> Temperature;            //in deg. Kelvin (I *only* accept SI!)
+    FGAirPressureItem              AirPressure;            //in Pascal (I *only* accept SI!)
+    map<Altitude,WeatherPrecision> VaporPressure;   //in Pascal (I *only* accept SI!)
+
+    map<Altitude,FGCloudItem>      Clouds;         //amount of covering and type

 
 

-    set<FGCloudItem> Clouds;               //amount of covering and type
-    WeatherPrecition SnowRainIntensity;     //this also stands for hail, snow,...
-    SnowRainType     snowRainType;         
-    WeatherPrecition LightningProbability;
+    WeatherPrecision              SnowRainIntensity;       //this also stands for hail, snow,...
+    SnowRainType                  snowRainType;            
+    WeatherPrecision              LightningProbability;    //in lightnings per second   

 
     FGPhysicalProperties();   //consructor to fill it with FG standart weather
 
     //return values at specified altitudes
 
     FGPhysicalProperties();   //consructor to fill it with FG standart weather
 
     //return values at specified altitudes

-    Point3D WindAt(const WeatherPrecition& a) const;
-    Point3D TurbulenceAt(const WeatherPrecition& a) const;
-    WeatherPrecition TemperatureAt(const WeatherPrecition& a) const;
-    WeatherPrecition AirPressureAt(const WeatherPrecition& a) const;
-    WeatherPrecition VaporPressureAt(const WeatherPrecition& a) const;
+    void            WindAt         (sgVec3 ret, const WeatherPrecision a) const;
+    void            TurbulenceAt   (sgVec3 ret, const WeatherPrecision a) const;
+    WeatherPrecision TemperatureAt  (const WeatherPrecision a) const;
+    WeatherPrecision AirPressureAt  (const WeatherPrecision x) const;  //x is used here instead of a on purpose
+    WeatherPrecision VaporPressureAt(const WeatherPrecision a) const;
+
+    //for easier access to the cloud stuff:
+    unsigned int getNumberOfCloudLayers(void) const;
+    FGCloudItem  getCloudLayer(unsigned int nr) const;

     
     

-    FGPhysicalProperties& operator = ( const FGPhysicalProperties& p ); 
-    FGPhysicalProperties& operator *= ( const WeatherPrecition& d ); 
-    FGPhysicalProperties& operator += ( const FGPhysicalProperties& p); 
-    FGPhysicalProperties& operator -= ( const FGPhysicalProperties& p); 
+    FGPhysicalProperties& operator =  ( const FGPhysicalProperties& p ); 
+    FGPhysicalProperties& operator *= ( const WeatherPrecision      d ); 
+    FGPhysicalProperties& operator += ( const FGPhysicalProperties& p ); 
+    FGPhysicalProperties& operator -= ( const FGPhysicalProperties& p ); 
+
+    //for easy binding to the property system
+    WeatherPrecision getWind_x( int number ) const;
+    WeatherPrecision getWind_y( int number ) const;
+    WeatherPrecision getWind_z( int number ) const;
+    WeatherPrecision getWind_a( int number ) const;
+    void setWind_x( int number, WeatherPrecision x);
+    void setWind_y( int number, WeatherPrecision y);
+    void setWind_z( int number, WeatherPrecision z);
+    void setWind_a( int number, WeatherPrecision a);
+    WeatherPrecision getTurbulence_x( int number ) const;
+    WeatherPrecision getTurbulence_y( int number ) const;
+    WeatherPrecision getTurbulence_z( int number ) const;
+    WeatherPrecision getTurbulence_a( int number ) const;
+    void setTurbulence_x( int number, WeatherPrecision x);
+    void setTurbulence_y( int number, WeatherPrecision y);
+    void setTurbulence_z( int number, WeatherPrecision z);
+    void setTurbulence_a( int number, WeatherPrecision a);
+    WeatherPrecision getTemperature_x( int number ) const;
+    WeatherPrecision getTemperature_a( int number ) const;
+    void setTemperature_x( int number, WeatherPrecision x);
+    void setTemperature_a( int number, WeatherPrecision a);
+    WeatherPrecision getVaporPressure_x( int number ) const;
+    WeatherPrecision getVaporPressure_a( int number ) const;
+    void setVaporPressure_x( int number, WeatherPrecision x);
+    void setVaporPressure_a( int number, WeatherPrecision a);

 };
 
 };
 

-typedef vector<FGPhysicalProperties> FGPhysicalPropertiesVector;
-typedef FGPhysicalPropertiesVector::iterator FGPhysicalPropertiesVectorIt;
-typedef FGPhysicalPropertiesVector::const_iterator FGPhysicalPropertiesVectorConstIt;
-
-class FGPhysicalProperties2D;
-ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
-

 class FGPhysicalProperties2D : public FGPhysicalProperties
 {
 public:
 class FGPhysicalProperties2D : public FGPhysicalProperties
 {
 public:

-    Point2D p;     //position of the property (lat/lon)
+    sgVec2 p;      //position of the property (lat/lon)

     friend ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
 
     FGPhysicalProperties2D() {}
 
     friend ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p );
 
     FGPhysicalProperties2D() {}
 

-    FGPhysicalProperties2D(const FGPhysicalProperties& prop, const Point2D& pos) 
+    FGPhysicalProperties2D(const FGPhysicalProperties& prop, const sgVec2& pos) 

     {
     {

-       Wind = prop.Wind; Turbulence = prop.Turbulence; Temperature = prop.Temperature;
-       AirPressure = prop.AirPressure; VaporPressure = prop.VaporPressure; p = pos;
+       Wind = prop.Wind; 
+       Turbulence = prop.Turbulence;
+       Temperature = prop.Temperature;
+       AirPressure = prop.AirPressure; 
+       VaporPressure = prop.VaporPressure; 
+       sgCopyVec2(p, pos);

     }
 };
 
     }
 };
 

-typedef vector<FGPhysicalProperties2D> FGPhysicalProperties2DVector;
-typedef FGPhysicalProperties2DVector::iterator FGPhysicalProperties2DVectorIt;
+typedef vector<FGPhysicalProperties>                 FGPhysicalPropertiesVector;
+typedef FGPhysicalPropertiesVector::iterator         FGPhysicalPropertiesVectorIt;
+typedef FGPhysicalPropertiesVector::const_iterator   FGPhysicalPropertiesVectorConstIt;
+
+typedef vector<FGPhysicalProperties2D>               FGPhysicalProperties2DVector;
+typedef FGPhysicalProperties2DVector::iterator       FGPhysicalProperties2DVectorIt;

 typedef FGPhysicalProperties2DVector::const_iterator FGPhysicalProperties2DVectorConstIt;
 
 typedef FGPhysicalProperties2DVector::const_iterator FGPhysicalProperties2DVectorConstIt;
 

-inline ostream& operator<< ( ostream& out, const FGPhysicalProperties2D& p )
-{
-    out << "Position: " << p.p << "\nStored Wind: ";
-    for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin(); WindIt != p.Wind.end(); WindIt++)
-       out << "(" << WindIt->getValue() << ") at " << WindIt->getAlt() << "m; ";
-
-    out << "\nStored Turbulence: ";
-    for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin(); 
-                                              TurbulenceIt != p.Turbulence.end(); 
-                                              TurbulenceIt++)
-       out << "(" << TurbulenceIt->getValue() << ") at " << TurbulenceIt->getAlt() << "m; ";
-
-    out << "\nStored Temperature: ";
-    for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin(); 
-                                               TemperatureIt != p.Temperature.end(); 
-                                               TemperatureIt++)
-       out << TemperatureIt->getValue() << " at " << TemperatureIt->getAlt() << "m; ";
-
-    out << "\nStored AirPressure: ";
-    out << p.AirPressure.getValue(0) << " at " << 0 << "m; ";
-
-    out << "\nStored VaporPressure: ";
-    for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin(); 
-                                                 VaporPressureIt != p.VaporPressure.end(); 
-                                                 VaporPressureIt++)
-       out << VaporPressureIt->getValue() << " at " << VaporPressureIt->getAlt() << "m; ";
-
-    return out << "\n";
-}

 
 
 inline FGPhysicalProperties& FGPhysicalProperties::operator = ( const FGPhysicalProperties& p )
 
 
 inline FGPhysicalProperties& FGPhysicalProperties::operator = ( const FGPhysicalProperties& p )


@@ -162,183 +189,226 @@ inline FGPhysicalProperties& FGPhysicalProperties::operator = ( const FGPhysical
     return *this;
 }
 
     return *this;
 }
 

-inline FGPhysicalProperties& FGPhysicalProperties::operator *= ( const WeatherPrecition& d )
+inline FGPhysicalProperties& FGPhysicalProperties::operator *= ( const WeatherPrecision d )

 {
 {

+    typedef map<FGPhysicalProperties::Altitude, FGWindItem      >::iterator wind_iterator;
+    typedef map<FGPhysicalProperties::Altitude, FGTurbulenceItem>::iterator turbulence_iterator;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::iterator scalar_iterator;

 
 

-    for (set<FGWindItem>::iterator WindIt = Wind.begin(); 
-                                  WindIt != Wind.end(); 
-                                  WindIt++)
-       *WindIt *= d;
+    for (wind_iterator       WindIt = Wind.begin(); 
+                            WindIt != Wind.end(); 
+                            WindIt++)
+       WindIt->second*= d;

 
 

-    for (set<FGTurbulenceItem>::iterator TurbulenceIt = Turbulence.begin(); 
-                                         TurbulenceIt != Turbulence.end(); 
-                                         TurbulenceIt++)
-       *TurbulenceIt  *= d;
+    for (turbulence_iterator TurbulenceIt = Turbulence.begin(); 
+                            TurbulenceIt != Turbulence.end(); 
+                            TurbulenceIt++)
+       TurbulenceIt->second *= d;

 
 

-    for (set<FGTemperatureItem>::iterator TemperatureIt = Temperature.begin(); 
-                                          TemperatureIt != Temperature.end(); 
-                                          TemperatureIt++)
-       *TemperatureIt *= d;
+    for (scalar_iterator     TemperatureIt = Temperature.begin(); 
+                             TemperatureIt != Temperature.end(); 
+                             TemperatureIt++)
+       TemperatureIt->second *= d;

 
     AirPressure *= d;
 
 
     AirPressure *= d;
 

-    for (set<FGVaporPressureItem>::iterator VaporPressureIt = VaporPressure.begin(); 
-                                            VaporPressureIt != VaporPressure.end(); 
-                                            VaporPressureIt++)
-       *VaporPressureIt *= d;
+    for (scalar_iterator     VaporPressureIt = VaporPressure.begin(); 
+                             VaporPressureIt != VaporPressure.end(); 
+                             VaporPressureIt++)
+       VaporPressureIt->second *= d;

 
     return *this;
 }
 
 inline FGPhysicalProperties& FGPhysicalProperties::operator += (const FGPhysicalProperties& p)
 {
 
     return *this;
 }
 
 inline FGPhysicalProperties& FGPhysicalProperties::operator += (const FGPhysicalProperties& p)
 {

-    for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin(); 
-                                        WindIt != p.Wind.end(); 
-                                        WindIt++ )
-       if (WindIt != Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) ))
-           Wind.insert(*WindIt);
-       else
-           *(Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0))) ) += WindIt->getValue();
+    typedef map<FGPhysicalProperties::Altitude, FGWindItem      >::const_iterator wind_iterator;
+    typedef map<FGPhysicalProperties::Altitude, FGTurbulenceItem>::const_iterator turbulence_iterator;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::const_iterator scalar_iterator;
+
+    for (wind_iterator       WindIt = p.Wind.begin(); 
+                            WindIt != p.Wind.end(); 
+                            WindIt++)
+       if (!Wind.insert(*WindIt).second)           //when it's not inserted => it's already existing
+           Wind[WindIt->first] += WindIt->second;  //=> add the value

            
            

-    for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin(); 
-                                              TurbulenceIt != p.Turbulence.end(); 
-                                               TurbulenceIt++)
-       if (TurbulenceIt != Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) ))
-           Turbulence.insert(*TurbulenceIt);
-       else
-           *(Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) )) += TurbulenceIt->getValue();
+    for (turbulence_iterator TurbulenceIt = p.Turbulence.begin(); 
+                            TurbulenceIt != p.Turbulence.end(); 
+                            TurbulenceIt++)
+       if (!Turbulence.insert(*TurbulenceIt).second)   
+           Turbulence[TurbulenceIt->first] += TurbulenceIt->second;
+
+    for (scalar_iterator     TemperatureIt = p.Temperature.begin(); 
+                             TemperatureIt != p.Temperature.end(); 
+                             TemperatureIt++)
+       if (!Temperature.insert(*TemperatureIt).second) 
+           Temperature[TemperatureIt->first] += TemperatureIt->second;

            
            

-    for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin(); 
-                                                TemperatureIt != p.Temperature.end(); 
-                                                TemperatureIt++)
-       if (TemperatureIt != Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) ))
-           Temperature.insert(*TemperatureIt);
-       else
-           *(Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) )) += TemperatureIt->getValue();
+    AirPressure += p.AirPressure.getValue();

            
            

-    AirPressure += p.AirPressure.getValue(0.0);
-           
-    for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin(); 
-                                                  VaporPressureIt != p.VaporPressure.end(); 
-                                                  VaporPressureIt++)
-       if (VaporPressureIt != VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) ))
-           VaporPressure.insert(*VaporPressureIt);
-       else
-           *(VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) )) += VaporPressureIt->getValue();
+    for (scalar_iterator     VaporPressureIt = p.VaporPressure.begin(); 
+                             VaporPressureIt != p.VaporPressure.end(); 
+                             VaporPressureIt++)
+       if (!VaporPressure.insert(*VaporPressureIt).second)     
+           VaporPressure[VaporPressureIt->first] += VaporPressureIt->second;

 
     return *this;
 }
 
 
     return *this;
 }
 

+// slightly modified version that also makes the Mac happy

 inline FGPhysicalProperties& FGPhysicalProperties::operator -= (const FGPhysicalProperties& p)
 {
 inline FGPhysicalProperties& FGPhysicalProperties::operator -= (const FGPhysicalProperties& p)
 {

+    typedef map<FGPhysicalProperties::Altitude, FGWindItem>::const_iterator wind_iterator;
+    typedef map<FGPhysicalProperties::Altitude, FGTurbulenceItem>::const_iterator turbulence_iterator;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::const_iterator scalar_iterator;
+    
+    // types to replace make_pair
+    typedef map<FGPhysicalProperties::Altitude, FGWindItem>::value_type wind_type;
+    typedef map<FGPhysicalProperties::Altitude,        FGTurbulenceItem>::value_type turb_type;
+    typedef map<FGPhysicalProperties::Altitude,        WeatherPrecision>::value_type weather_type;
+    
+    for (wind_iterator WindIt = p.Wind.begin();
+        WindIt != p.Wind.end();
+        WindIt++)
+       if (!Wind.insert( wind_type(WindIt->first, -WindIt->second) ).second)
+           // when it's not inserted => it's already existing
+           Wind[WindIt->first] -= WindIt->second; //=> substract the value
+
+    for (turbulence_iterator TurbulenceIt = p.Turbulence.begin();
+        TurbulenceIt != p.Turbulence.end();
+        TurbulenceIt++)
+       if (!Turbulence.insert( turb_type(TurbulenceIt->first, -TurbulenceIt->second) ).second)
+           Turbulence[TurbulenceIt->first] -= TurbulenceIt->second;
+    
+    for (scalar_iterator TemperatureIt = p.Temperature.begin();
+        TemperatureIt != p.Temperature.end();
+        TemperatureIt++)
+       if (!Temperature.insert( weather_type(TemperatureIt->first, -TemperatureIt->second) ).second)
+           Temperature[TemperatureIt->first] -= TemperatureIt->second;
+    
+    AirPressure -= p.AirPressure.getValue();
+    
+    for (scalar_iterator VaporPressureIt = p.VaporPressure.begin();
+        VaporPressureIt != p.VaporPressure.end();
+        VaporPressureIt++)
+       if (!VaporPressure.insert( weather_type(VaporPressureIt->first, -VaporPressureIt->second) ).second)
+           VaporPressure[VaporPressureIt->first] -= VaporPressureIt->second;

 
 

-    for (set<FGWindItem>::const_iterator WindIt = p.Wind.begin(); 
-                                        WindIt != p.Wind.end(); 
-                                        WindIt++)
-       if (WindIt != Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) ))
-           Wind.insert(-(*WindIt));
-       else
-           *(Wind.upper_bound( FGWindItem(WindIt->getAlt(), Point3D(0)) ))  -= WindIt->getValue();
+    return *this;
+}
+
+#if 0 // old version
+inline FGPhysicalProperties& FGPhysicalProperties::operator -= (const FGPhysicalProperties& p)
+{
+    typedef map<FGPhysicalProperties::Altitude, FGWindItem      >::const_iterator wind_iterator;
+    typedef map<FGPhysicalProperties::Altitude, FGTurbulenceItem>::const_iterator turbulence_iterator;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::const_iterator scalar_iterator;
+
+    for (wind_iterator       WindIt = p.Wind.begin(); 
+                            WindIt != p.Wind.end(); 
+                            WindIt++)
+       if (!Wind.insert( make_pair(WindIt->first, -WindIt->second) ).second)   //when it's not inserted => it's already existing
+           Wind[WindIt->first] -= WindIt->second;                              //=> substract the value

            
            

-    for (set<FGTurbulenceItem>::const_iterator TurbulenceIt = p.Turbulence.begin(); 
-                                               TurbulenceIt != p.Turbulence.end(); 
-                                               TurbulenceIt++)
-       if (TurbulenceIt != Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) ))
-           Turbulence.insert(-(*TurbulenceIt));
-       else
-           *(Turbulence.upper_bound( FGTurbulenceItem(TurbulenceIt->getAlt(), Point3D(0)) )) -= TurbulenceIt->getValue();
+    for (turbulence_iterator TurbulenceIt = p.Turbulence.begin(); 
+                            TurbulenceIt != p.Turbulence.end(); 
+                            TurbulenceIt++)
+       if (!Turbulence.insert( make_pair(TurbulenceIt->first, -TurbulenceIt->second) ).second) 
+           Turbulence[TurbulenceIt->first] -= TurbulenceIt->second;

            
            

-    for (set<FGTemperatureItem>::const_iterator TemperatureIt = p.Temperature.begin(); 
-                                               TemperatureIt != p.Temperature.end(); 
-                                                TemperatureIt++)
-       if (TemperatureIt != Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) ))
-           Temperature.insert(-(*TemperatureIt));
-       else
-           *(Temperature.upper_bound( FGTemperatureItem(TemperatureIt->getAlt(), 0.0) )) -= TemperatureIt->getValue();
+    for (scalar_iterator     TemperatureIt = p.Temperature.begin(); 
+                             TemperatureIt != p.Temperature.end(); 
+                             TemperatureIt++)
+       if (!Temperature.insert( make_pair(TemperatureIt->first, -TemperatureIt->second) ).second)      
+           Temperature[TemperatureIt->first] -= TemperatureIt->second;

            
            

-    AirPressure -= p.AirPressure.getValue(0.0);
+    AirPressure -= p.AirPressure.getValue();

            
            

-    for (set<FGVaporPressureItem>::const_iterator VaporPressureIt = p.VaporPressure.begin(); 
-                                                  VaporPressureIt != p.VaporPressure.end(); 
-                                                  VaporPressureIt++)
-       if (VaporPressureIt != VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) ))
-           VaporPressure.insert(-(*VaporPressureIt));
-       else
-           *(VaporPressure.upper_bound( FGVaporPressureItem(VaporPressureIt->getAlt(), 0.0) )) -= VaporPressureIt->getValue();
+    for (scalar_iterator     VaporPressureIt = p.VaporPressure.begin(); 
+                             VaporPressureIt != p.VaporPressure.end(); 
+                             VaporPressureIt++)
+       if (!VaporPressure.insert( make_pair(VaporPressureIt->first, -VaporPressureIt->second) ).second)        
+           VaporPressure[VaporPressureIt->first] -= VaporPressureIt->second;
+

 
     return *this;
 }
 
     return *this;
 }

+#endif

 
 

-
-inline Point3D FGPhysicalProperties::WindAt(const WeatherPrecition& a) const
+inline void FGPhysicalProperties::WindAt(sgVec3 ret, const WeatherPrecision a) const

 {
 {

-    set<FGWindItem>::const_iterator it = Wind.lower_bound(FGWindItem(a, Point3D(0)));
-    set<FGWindItem>::const_iterator it2 = it;
+    typedef map<FGPhysicalProperties::Altitude, FGWindItem>::const_iterator vector_iterator;
+
+    vector_iterator it = Wind.lower_bound(a);
+    vector_iterator it2 = it;

     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate
     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate

-    return ( (it2->getValue() - it->getValue())/(it2->getAlt() - it->getAlt()) )*
-             (a - it2->getAlt()) + 
-              it2->getValue(); 
+    sgSubVec3(ret, *it2->second.getValue(), *it->second.getValue());
+    sgScaleVec3(ret, (a - it2->first) / (it2->first - it->first));
+    sgAddVec3(ret, *it2->second.getValue());

 }
 
 }
 

-inline Point3D FGPhysicalProperties::TurbulenceAt(const WeatherPrecition& a) const
+inline void FGPhysicalProperties::TurbulenceAt(sgVec3 ret, const WeatherPrecision a) const

 {
 {

-    set<FGTurbulenceItem>::const_iterator it = Turbulence.lower_bound(FGTurbulenceItem(a, Point3D(0)));
-    set<FGTurbulenceItem>::const_iterator it2 = it;
+    typedef map<FGPhysicalProperties::Altitude, FGTurbulenceItem>::const_iterator vector_iterator;
+
+    vector_iterator it = Turbulence.lower_bound(a);
+    vector_iterator it2 = it;

     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate
     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate

-    return ( (it2->getValue() - it->getValue() )/(it2->getAlt() - it->getAlt()) )*
-           (a - it2->getAlt())+ it2->getValue(); 
+    sgSubVec3(ret, *it2->second.getValue(), *it->second.getValue());
+    sgScaleVec3(ret, (a - it2->first) / (it2->first - it->first));
+    sgAddVec3(ret, *it2->second.getValue());

 }
 
 }
 

-inline WeatherPrecition FGPhysicalProperties::TemperatureAt(const WeatherPrecition& a) const
+inline WeatherPrecision FGPhysicalProperties::TemperatureAt(const WeatherPrecision a) const

 {
 {

-    set<FGTemperatureItem>::const_iterator it = Temperature.lower_bound(FGTemperatureItem(a, 0));
-    set<FGTemperatureItem>::const_iterator it2 = it;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::const_iterator scalar_iterator;
+
+    scalar_iterator it = Temperature.lower_bound(a);
+    scalar_iterator it2 = it;

     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate
     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate

-    return ( (it2->getValue() - it->getValue()) / (it2->getAlt() - it->getAlt()) )* 
-           (a - it2->getAlt() )+ it2->getValue(); 
+    return ( (it2->second - it->second)/(it2->first - it->first) ) * (a - it2->first) + it2->second; 

 }
 
 }
 

-inline WeatherPrecition FGPhysicalProperties::AirPressureAt(const WeatherPrecition& a) const
-{
-    return AirPressure.getValue(a);
-}
+//inline WeatherPrecision FGPhysicalProperties::AirPressureAt(const WeatherPrecision x) const
+//moved to FGPhysicalProperties.cpp as it got too complex to inline

 
 

-inline WeatherPrecition FGPhysicalProperties::VaporPressureAt(const WeatherPrecition& a) const
+inline WeatherPrecision FGPhysicalProperties::VaporPressureAt(const WeatherPrecision a) const

 {
 {

-    set<FGVaporPressureItem>::const_iterator it = VaporPressure.lower_bound(FGVaporPressureItem(a, 0));
-    set<FGVaporPressureItem>::const_iterator it2 = it;
+    typedef map<FGPhysicalProperties::Altitude, WeatherPrecision>::const_iterator scalar_iterator;
+
+    scalar_iterator it = VaporPressure.lower_bound(a);
+    scalar_iterator it2 = it;

     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate
     it--;
 
     //now I've got it->alt < a < it2->alt so I can interpolate

-    return ( (it2->getValue() - it->getValue() ) / (it2->getAlt() - it->getAlt() ) ) *
-           (a - it2->getAlt() )+ it2->getValue(); 
+    return ( (it2->second - it->second)/(it2->first - it->first) ) * (a - it2->first) + it2->second; 

 }
 
 
 }
 
 

-inline FGPhysicalProperties operator * (const FGPhysicalProperties& a, const WeatherPrecition& b)
+inline FGPhysicalProperties operator * (FGPhysicalProperties a, const WeatherPrecision b)

 {
 {

-    return FGPhysicalProperties(a) *= b;
+    return a *= b;

 }
 
 }
 

-inline FGPhysicalProperties operator * (const WeatherPrecition& b, const FGPhysicalProperties& a)
+inline FGPhysicalProperties operator * (const WeatherPrecision b, FGPhysicalProperties a)

 {
 {

-    return FGPhysicalProperties(a) *= b;
+    return a *= b;

 }
 
 }
 

-inline FGPhysicalProperties operator + (const FGPhysicalProperties& a, const FGPhysicalProperties& b)
+inline FGPhysicalProperties operator + (FGPhysicalProperties a, const FGPhysicalProperties& b)

 {
 {

-    return FGPhysicalProperties(a) += (FGPhysicalProperties)b;
+    return a += b;

 }
 
 }
 

-inline FGPhysicalProperties operator - (const FGPhysicalProperties& a, const FGPhysicalProperties& b)
+inline FGPhysicalProperties operator - (FGPhysicalProperties a, const FGPhysicalProperties& b)

 {
 {

-    return FGPhysicalProperties(a) -= (FGPhysicalProperties)b;
+    return a -= b;

 }
 
 /****************************************************************************/
 }
 
 /****************************************************************************/