-/*******-*- Mode: C++ -*-************************************************************
+/*****************************************************************************
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
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
*****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/* 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 <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 "FGAirPressureItem.h"
#include "FGWindItem.h"
#include "FGTurbulenceItem.h"
-#include "FGTemperatureItem.h"
-#include "FGAirPressureItem.h"
-#include "FGVaporPressureItem.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:
- 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
- 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:
- 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() {}
- 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;
-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 )
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;
- 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)
{
- 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;
}
+// slightly modified version that also makes the Mac happy
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;
}
+#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
- 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
- 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
- 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
- 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;
}
/****************************************************************************/
projects / flightgear.git / blobdiff