X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FEnvironment%2Fenvironment_ctrl.cxx;h=6efcbde3ee747f3eb69bc90e32afcbfb4339fa56;hb=386aefe69358ce41a11c9afeb8f56e26758fe56b;hp=c94cacb20051a771367cb9413b88bee86574ae4b;hpb=4aacda239089a7ef694ffd6d6acb35fe4ecc47a5;p=flightgear.git

diff --git a/src/Environment/environment_ctrl.cxx b/src/Environment/environment_ctrl.cxx
index c94cacb20..6efcbde3e 100644
--- a/src/Environment/environment_ctrl.cxx
+++ b/src/Environment/environment_ctrl.cxx
@@ -34,6 +34,7 @@
 #include <Main/fg_props.hxx>
 #include <Main/util.hxx>
 
+#include "atmosphere.hxx"
 #include "fgmetar.hxx"
 #include "environment_ctrl.hxx"
 
@@ -44,6 +45,10 @@ public:
 	virtual bool passAirport(FGAirport* aApt) const {
 		return aApt->getMetar();
 	}
+  
+  // permit heliports and seaports too
+  virtual FGPositioned::Type maxType() const
+  { return FGPositioned::SEAPORT; }
 };
 
 static AirportWithMetar airportWithMetarFilter;
@@ -133,35 +138,51 @@ FGInterpolateEnvironmentCtrl::init ()
 void
 FGInterpolateEnvironmentCtrl::reinit ()
 {
-// TODO: do we really need to throw away the old tables on reinit? Better recycle
-	unsigned 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();
 }
 
 void
 FGInterpolateEnvironmentCtrl::read_table (const SGPropertyNode * node, vector<bucket *> &table)
 {
-	for (int i = 0; i < node->nChildren(); i++) {
+	double last_altitude_ft = 0.0;
+	double sort_required = false;
+	size_t i;
+
+	for (i = 0; i < (size_t)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;
+			bucket * b;
+			if( i < table.size() ) {
+				// recycle existing bucket
+				b = table[i];
+			} else {
+				// more nodes than buckets in table, add a new one
+				b = new bucket;
+				table.push_back(b);
+			}
 			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);
+
+			// check, if altitudes are in ascending order
+			if( b->altitude_ft < last_altitude_ft )
+				sort_required = true;
+			last_altitude_ft = b->altitude_ft;
 		}
 	}
-	sort(table.begin(), table.end(), bucket::lessThan);
+	// remove leftover buckets
+	while( table.size() > i ) {
+		bucket * b = *(table.end() - 1);
+		delete b;
+		table.pop_back();
+	}
+
+	if( sort_required )
+		sort(table.begin(), table.end(), bucket::lessThan);
 }
 
 void
@@ -181,6 +202,8 @@ FGInterpolateEnvironmentCtrl::update (double delta_time_sec)
 			do_interpolate(_boundary_table, altitude_agl_ft, _environment);
 			return;
 		} else if ((boundary_limit + boundary_transition) >= altitude_agl_ft) {
+			//TODO: this is 500ft above the top altitude of boundary layer
+			//shouldn't this be +/-250 ft off of the top altitude?
 								// both tables
 			do_interpolate(_boundary_table, altitude_agl_ft, &env1);
 			do_interpolate(_aloft_table, altitude_ft, &env2);
@@ -246,20 +269,25 @@ FGInterpolateEnvironmentCtrl::bucket::lessThan(bucket *a, bucket *b)
 ////////////////////////////////////////////////////////////////////////
 
 FGMetarCtrl::FGMetarCtrl( SGSubsystem * environmentCtrl )
-	: _environmentCtrl(environmentCtrl),
-	station_elevation_ft(0.0),
+	:
 	metar_valid(false),
 	setup_winds_aloft(true),
+	wind_interpolation_required(true),
+	metar_sealevel_temperature(15.0),
+	metar_sealevel_dewpoint(5.0),
 	// Interpolation constant definitions.
-	EnvironmentUpdatePeriodSec( 0.2 ),
 	MaxWindChangeKtsSec( 0.2 ),
 	MaxVisChangePercentSec( 0.05 ),
-	MaxPressureChangeInHgSec( 0.0033 ),
+	MaxPressureChangeInHgSec( 0.0005 ), // approx 1hpa/min
+	MaxTemperatureChangeDegcSec(10.0/60.0), // approx 10degc/min
 	MaxCloudAltitudeChangeFtSec( 20.0 ),
 	MaxCloudThicknessChangeFtSec( 50.0 ),
 	MaxCloudInterpolationHeightFt( 5000.0 ),
-	MaxCloudInterpolationDeltaFt( 4000.0 )
+	MaxCloudInterpolationDeltaFt( 4000.0 ),
+	_environmentCtrl(environmentCtrl)
 {
+	windModulator = new FGBasicWindModulator();
+
 	metar_base_n = fgGetNode( "/environment/metar", true );
 	station_id_n = metar_base_n->getNode("station-id", true );
 	station_elevation_n = metar_base_n->getNode("station-elevation-ft", true );
@@ -268,7 +296,7 @@ FGMetarCtrl::FGMetarCtrl( SGSubsystem * environmentCtrl )
 	base_wind_range_from_n = metar_base_n->getNode("base-wind-range-from", true );
 	base_wind_range_to_n = metar_base_n->getNode("base-wind-range-to", true );
 	base_wind_speed_n = metar_base_n->getNode("base-wind-speed-kt", true );
-	base_wind_dir_n   = metar_base_n->getNode("base-wind-dir-deg", true );
+	base_wind_dir_n = metar_base_n->getNode("base-wind-dir-deg", true );
 	gust_wind_speed_n = metar_base_n->getNode("gust-wind-speed-kt", true );
 	temperature_n = metar_base_n->getNode("temperature-degc", true );
 	dewpoint_n = metar_base_n->getNode("dewpoint-degc", true );
@@ -279,15 +307,18 @@ FGMetarCtrl::FGMetarCtrl( SGSubsystem * environmentCtrl )
 	hail_n = metar_base_n->getNode("hail-norm", true );
 	snow_n = metar_base_n->getNode("snow-norm", true );
 	snow_cover_n = metar_base_n->getNode("snow-cover", true );
+	magnetic_variation_n = fgGetNode( "/environment/magnetic-variation-deg", true );
 	ground_elevation_n = fgGetNode( "/position/ground-elev-m", true );
 	longitude_n = fgGetNode( "/position/longitude-deg", true );
 	latitude_n = fgGetNode( "/position/latitude-deg", true );
 	environment_clouds_n = fgGetNode("/environment/clouds");
 
-	boundary_wind_speed_n = fgGetNode("/environment/config/boundary/entry/wind-speed-kt");
-	boundary_wind_from_heading_n = fgGetNode("/environment/config/boundary/entry/wind-from-heading-deg");
-	boundary_visibility_n = fgGetNode("/environment/config/boundary/entry/visibility-m");
-	boundary_sea_level_pressure_n = fgGetNode("/environment/config/boundary/entry/pressure-sea-level-inhg");
+	boundary_wind_speed_n = fgGetNode("/environment/config/boundary/entry/wind-speed-kt", true );
+	boundary_wind_from_heading_n = fgGetNode("/environment/config/boundary/entry/wind-from-heading-deg", true );
+	boundary_visibility_n = fgGetNode("/environment/config/boundary/entry/visibility-m", true );
+	boundary_sea_level_pressure_n = fgGetNode("/environment/config/boundary/entry/pressure-sea-level-inhg", true );
+	boundary_sea_level_temperature_n = fgGetNode("/environment/config/boundary/entry/temperature-sea-level-degc", true );
+	boundary_sea_level_dewpoint_n = fgGetNode("/environment/config/boundary/entry/dewpoint-sea-level-degc", true );
 }
 
 FGMetarCtrl::~FGMetarCtrl ()
@@ -296,35 +327,39 @@ FGMetarCtrl::~FGMetarCtrl ()
 
 void FGMetarCtrl::bind ()
 {
-  fgTie("/environment/metar/valid", this, &FGMetarCtrl::get_valid );
-  fgTie("/environment/params/metar-updates-environment", this, &FGMetarCtrl::get_enabled, &FGMetarCtrl::set_enabled );
-  fgTie("/environment/params/metar-updates-winds-aloft", this, &FGMetarCtrl::get_setup_winds_aloft, &FGMetarCtrl::set_setup_winds_aloft );
+	fgTie("/environment/metar/valid", this, &FGMetarCtrl::get_valid );
+	fgTie("/environment/params/metar-updates-environment", this, &FGMetarCtrl::get_enabled, &FGMetarCtrl::set_enabled );
+	fgTie("/environment/params/metar-updates-winds-aloft", this, &FGMetarCtrl::get_setup_winds_aloft, &FGMetarCtrl::set_setup_winds_aloft );
 }
 
 void FGMetarCtrl::unbind ()
 {
-  fgUntie("/environment/metar/valid");
-  fgUntie("/environment/params/metar-updates-environment");
-  fgUntie("/environment/params/metar-updates-winds-aloft");
+	fgUntie("/environment/metar/valid");
+	fgUntie("/environment/params/metar-updates-environment");
+	fgUntie("/environment/params/metar-updates-winds-aloft");
 }
 
 // use a "command" to set station temp at station elevation
-static void set_temp_at_altitude( float temp_degc, float altitude_ft ) {
+static void set_temp_at_altitude( double temp_degc, double altitude_ft ) {
 	SGPropertyNode args;
 	SGPropertyNode *node = args.getNode("temp-degc", 0, true);
-	node->setFloatValue( temp_degc );
+	node->setDoubleValue( temp_degc );
 	node = args.getNode("altitude-ft", 0, true);
-	node->setFloatValue( altitude_ft );
-	globals->get_commands()->execute("set-outside-air-temp-degc", &args);
+	node->setDoubleValue( altitude_ft );
+	globals->get_commands()->execute( altitude_ft == 0.0 ? 
+		"set-sea-level-air-temp-degc" : 
+		"set-outside-air-temp-degc", &args);
 }
 
-static void set_dewpoint_at_altitude( float dewpoint_degc, float altitude_ft ) {
+static void set_dewpoint_at_altitude( double dewpoint_degc, double altitude_ft ) {
 	SGPropertyNode args;
 	SGPropertyNode *node = args.getNode("dewpoint-degc", 0, true);
-	node->setFloatValue( dewpoint_degc );
+	node->setDoubleValue( dewpoint_degc );
 	node = args.getNode("altitude-ft", 0, true);
-	node->setFloatValue( altitude_ft );
-	globals->get_commands()->execute("set-dewpoint-temp-degc", &args);
+	node->setDoubleValue( altitude_ft );
+	globals->get_commands()->execute( altitude_ft == 0.0 ?
+		"set-dewpoint-sea-level-air-temp-degc" :
+		"set-dewpoint-temp-degc", &args);
 }
 
 /*
@@ -376,10 +411,8 @@ static void setupWind( bool setup_aloft, double dir, double speed, double gust )
 		setupWindBranch( "aloft", dir, speed, gust );
 }
 
-double FGMetarCtrl::interpolate_val(double currentval, double requiredval, double dt)
+double FGMetarCtrl::interpolate_val(double currentval, double requiredval, double dval )
 {
-	double dval = EnvironmentUpdatePeriodSec * dt;
-
 	if (fabs(currentval - requiredval) < dval) return requiredval;
 	if (currentval < requiredval) return (currentval + dval);
 	if (currentval > requiredval) return (currentval - dval);
@@ -390,6 +423,7 @@ void
 FGMetarCtrl::init ()
 {
 	first_update = true;
+	wind_interpolation_required = true;
 }
 
 void
@@ -398,19 +432,51 @@ FGMetarCtrl::reinit ()
 	init();
 }
 
+static inline double convert_to_360( double d )
+{
+	if( d < 0.0 ) return d + 360.0;
+	if( d >= 360.0 ) return d - 360.0;
+	return d;
+}
+
+static inline double convert_to_180( double d )
+{
+	return d > 180.0 ? d - 360.0 : d;
+}
+
+// Return the sea level pressure for a metar observation, in inHg.
+// This is different from QNH because it accounts for the current
+// temperature at the observation point.
+// metarPressure in inHg
+// fieldHt in ft
+// fieldTemp in C
+
+static double reducePressureSl(double metarPressure, double fieldHt,
+                               double fieldTemp)
+{
+	double elev = fieldHt * SG_FEET_TO_METER;
+	double fieldPressure
+		= FGAtmo::fieldPressure(elev, metarPressure * atmodel::inHg);
+	double slPressure = P_layer(0, elev, fieldPressure,
+		fieldTemp + atmodel::freezing, atmodel::ISA::lam0);
+	return slPressure / atmodel::inHg;
+}
+
 void
 FGMetarCtrl::update(double dt)
 {
 	if( dt <= 0 || !metar_valid ||!enabled)
 		return;
 
+	windModulator->update(dt);
 	// Interpolate the current configuration closer to the actual METAR
 
 	bool reinit_required = false;
 	bool layer_rebuild_required = false;
+	double station_elevation_ft = station_elevation_n->getDoubleValue();
 
 	if (first_update) {
-		double dir = base_wind_dir_n->getDoubleValue();
+		double dir = base_wind_dir_n->getDoubleValue()+magnetic_variation_n->getDoubleValue();
 		double speed = base_wind_speed_n->getDoubleValue();
 		double gust = gust_wind_speed_n->getDoubleValue();
 		setupWind(setup_winds_aloft, dir, speed, gust);
@@ -418,8 +484,14 @@ FGMetarCtrl::update(double dt)
 		double metarvis = min_visibility_n->getDoubleValue();
 		fgDefaultWeatherValue("visibility-m", metarvis);
 
+		set_temp_at_altitude(temperature_n->getDoubleValue(), station_elevation_ft);
+		set_dewpoint_at_altitude(dewpoint_n->getDoubleValue(), station_elevation_ft);
+
 		double metarpressure = pressure_n->getDoubleValue();
-		fgDefaultWeatherValue("pressure-sea-level-inhg", metarpressure);
+		fgDefaultWeatherValue("pressure-sea-level-inhg",
+			reducePressureSl(metarpressure,
+			station_elevation_ft,
+			temperature_n->getDoubleValue()));
 
 		// We haven't already loaded a METAR, so apply it immediately.
 		vector<SGPropertyNode_ptr> layers = clouds_n->getChildren("layer");
@@ -444,62 +516,100 @@ FGMetarCtrl::update(double dt)
 		layer_rebuild_required = true;
 
 	} else {
-		// Generate interpolated values between the METAR and the current
-		// configuration.
-
-		// Pick up the METAR wind values and convert them into a vector.
-		double metar[2];
-		double metar_speed = base_wind_speed_n->getDoubleValue();
-		double metar_heading = base_wind_dir_n->getDoubleValue();
-
-		metar[0] = metar_speed * sin(metar_heading * SG_DEGREES_TO_RADIANS );
-		metar[1] = metar_speed * cos(metar_heading * SG_DEGREES_TO_RADIANS);
-
-		// Convert the current wind values and convert them into a vector
-		double current[2];
-		double speed = boundary_wind_speed_n->getDoubleValue();
-		double dir_from = boundary_wind_from_heading_n->getDoubleValue();;
-
-		current[0] = speed * sin(dir_from * SG_DEGREES_TO_RADIANS );
-		current[1] = speed * cos(dir_from * SG_DEGREES_TO_RADIANS );
-
-		// Determine the maximum component-wise value that the wind can change.
-		// First we determine the fraction in the X and Y component, then
-		// factor by the maximum wind change.
-		double x = fabs(current[0] - metar[0]);
-		double y = fabs(current[1] - metar[1]);
-
-		// only interpolate if we have a difference
-		if (x + y > 0) {
-			double dx = x / (x + y);
-			double dy = 1 - dx;
-
-			double maxdx = dx * MaxWindChangeKtsSec;
-			double maxdy = dy * MaxWindChangeKtsSec;
-
-			// Interpolate each component separately.
-			current[0] = interpolate_val(current[0], metar[0], maxdx);
-			current[1] = interpolate_val(current[1], metar[1], maxdy);
-
-			// Now convert back to polar coordinates.
-			if ((current[0] == 0.0) && (current[1] == 0.0)) {
-				// Special case where there is no wind (otherwise atan2 barfs)
-				speed = 0.0;
-			} else {
-				// Some real wind to convert back from. Work out the speed
-				// and direction value in degrees.
-				speed = sqrt((current[0] * current[0]) + (current[1] * current[1]));
-				dir_from = (atan2(current[0], current[1]) * SG_RADIANS_TO_DEGREES );
-
-				// Normalize the direction.
-				if (dir_from < 0.0)
-					dir_from += 360.0;
-
-				SG_LOG( SG_GENERAL, SG_DEBUG, "Wind : " << dir_from << "@" << speed);
+		if( wind_interpolation_required ) {
+			// Generate interpolated values between the METAR and the current
+			// configuration.
+
+			// Pick up the METAR wind values and convert them into a vector.
+			double metar[2];
+			double metar_speed = base_wind_speed_n->getDoubleValue();
+			double metar_heading = base_wind_dir_n->getDoubleValue()+magnetic_variation_n->getDoubleValue();
+
+			metar[0] = metar_speed * sin(metar_heading * SG_DEGREES_TO_RADIANS );
+			metar[1] = metar_speed * cos(metar_heading * SG_DEGREES_TO_RADIANS);
+
+			// Convert the current wind values and convert them into a vector
+			double current[2];
+			double speed = boundary_wind_speed_n->getDoubleValue();
+			double dir_from = boundary_wind_from_heading_n->getDoubleValue();;
+
+			current[0] = speed * sin(dir_from * SG_DEGREES_TO_RADIANS );
+			current[1] = speed * cos(dir_from * SG_DEGREES_TO_RADIANS );
+
+			// Determine the maximum component-wise value that the wind can change.
+			// First we determine the fraction in the X and Y component, then
+			// factor by the maximum wind change.
+			double x = fabs(current[0] - metar[0]);
+			double y = fabs(current[1] - metar[1]);
+
+			// only interpolate if we have a difference
+			if (x + y > 0.01 ) {
+				double dx = x / (x + y);
+				double dy = 1 - dx;
+
+				double maxdx = dx * MaxWindChangeKtsSec;
+				double maxdy = dy * MaxWindChangeKtsSec;
+
+				// Interpolate each component separately.
+				current[0] = interpolate_val(current[0], metar[0], maxdx*dt);
+				current[1] = interpolate_val(current[1], metar[1], maxdy*dt);
+
+				// Now convert back to polar coordinates.
+				if ((fabs(current[0]) > 0.1) || (fabs(current[1]) > 0.1)) {
+					// Some real wind to convert back from. Work out the speed
+					// and direction value in degrees.
+					speed = sqrt((current[0] * current[0]) + (current[1] * current[1]));
+					dir_from = (atan2(current[0], current[1]) * SG_RADIANS_TO_DEGREES );
+
+					// Normalize the direction.
+					if (dir_from < 0.0)
+						dir_from += 360.0;
+
+					SG_LOG( SG_GENERAL, SG_DEBUG, "Wind : " << dir_from << "@" << speed);
+				} else {
+					// Special case where there is no wind (otherwise atan2 barfs)
+					speed = 0.0;
+				}
+				double gust = gust_wind_speed_n->getDoubleValue();
+				setupWind(setup_winds_aloft, dir_from, speed, gust);
+				reinit_required = true;
+			} else { 
+				wind_interpolation_required = false;
+			}
+		} else { // if(wind_interpolation_required)
+			// interpolation of wind vector is finished, apply wind
+			// variations and gusts for the boundary layer only
+
+
+			bool wind_modulated = false;
+
+			// start with the main wind direction
+			double wind_dir = base_wind_dir_n->getDoubleValue()+magnetic_variation_n->getDoubleValue();
+			double min = convert_to_180(base_wind_range_from_n->getDoubleValue()+magnetic_variation_n->getDoubleValue());
+			double max = convert_to_180(base_wind_range_to_n->getDoubleValue()+magnetic_variation_n->getDoubleValue());
+			if( max > min ) {
+				// if variable winds configured, modulate the wind direction
+				double f = windModulator->get_direction_offset_norm();
+				wind_dir = min+(max-min)*f;
+				double old = convert_to_180(boundary_wind_from_heading_n->getDoubleValue());
+				wind_dir = convert_to_360(fgGetLowPass(old, wind_dir, dt ));
+				wind_modulated = true;
+			}
+			
+			// start with main wind speed
+			double wind_speed = base_wind_speed_n->getDoubleValue();
+			max = gust_wind_speed_n->getDoubleValue();
+			if( max > wind_speed ) {
+				// if gusts are configured, modulate wind magnitude
+				double f = windModulator->get_magnitude_factor_norm();
+				wind_speed = wind_speed+(max-wind_speed)*f;
+				wind_speed = fgGetLowPass(boundary_wind_speed_n->getDoubleValue(), wind_speed, dt );
+				wind_modulated = true;
+			}
+			if( wind_modulated ) {
+				setupWind(false, wind_dir, wind_speed, max);
+				reinit_required = true;
 			}
-			double gust = gust_wind_speed_n->getDoubleValue();
-			setupWind(setup_winds_aloft, dir_from, speed, gust);
-			reinit_required = true;
 		}
 
 		// Now handle the visibility. We convert both visibility values
@@ -513,7 +623,7 @@ FGMetarCtrl::update(double dt)
 			double currentxval = log(1000.0 + vis);
 			double metarxval = log(1000.0 + metarvis);
 
-			currentxval = interpolate_val(currentxval, metarxval, MaxVisChangePercentSec);
+			currentxval = interpolate_val(currentxval, metarxval, MaxVisChangePercentSec*dt);
 
 			// Now convert back from an X-value to a straightforward visibility.
 			vis = exp(currentxval) - 1000.0;
@@ -523,12 +633,28 @@ FGMetarCtrl::update(double dt)
 
 		double pressure = boundary_sea_level_pressure_n->getDoubleValue();
 		double metarpressure = pressure_n->getDoubleValue();
-		if( pressure != metarpressure ) {
-			pressure = interpolate_val( pressure, metarpressure, MaxPressureChangeInHgSec );
+		double newpressure = reducePressureSl(metarpressure,
+			station_elevation_ft,
+			temperature_n->getDoubleValue());
+		if( pressure != newpressure ) {
+			pressure = interpolate_val( pressure, newpressure, MaxPressureChangeInHgSec*dt );
 			fgDefaultWeatherValue("pressure-sea-level-inhg", pressure);
 			reinit_required = true;
 		}
 
+		{
+			double temperature = boundary_sea_level_temperature_n->getDoubleValue();
+			double dewpoint = boundary_sea_level_dewpoint_n->getDoubleValue();
+			if( metar_sealevel_temperature != temperature ) {
+				temperature = interpolate_val( temperature, metar_sealevel_temperature, MaxTemperatureChangeDegcSec*dt );
+				set_temp_at_altitude( temperature, 0.0 );
+			}
+			if( metar_sealevel_dewpoint != dewpoint ) {
+				dewpoint = interpolate_val( dewpoint, metar_sealevel_dewpoint, MaxTemperatureChangeDegcSec*dt );
+				set_dewpoint_at_altitude( dewpoint, 0.0 );
+			}
+		}
+
 		// Set the cloud layers by interpolating over the METAR versions.
 		vector<SGPropertyNode_ptr> layers = clouds_n->getChildren("layer");
 		vector<SGPropertyNode_ptr>::const_iterator layer;
@@ -577,7 +703,7 @@ FGMetarCtrl::update(double dt)
 			} else {
 				// Interpolate the other values in the usual way
 				if (current_alt != required_alt) {
-					current_alt = interpolate_val(current_alt, required_alt, MaxCloudAltitudeChangeFtSec);
+					current_alt = interpolate_val(current_alt, required_alt, MaxCloudAltitudeChangeFtSec*dt);
 					target->setDoubleValue("elevation-ft", current_alt);
 				}
 
@@ -586,16 +712,13 @@ FGMetarCtrl::update(double dt)
 				if (current_thickness != required_thickness) {
 					current_thickness = interpolate_val(current_thickness,
 												 required_thickness,
-												 MaxCloudThicknessChangeFtSec);
+												 MaxCloudThicknessChangeFtSec*dt);
 					thickness->setDoubleValue(current_thickness);
 				}
 			}
 		}
 	}
 
-	set_temp_at_altitude(temperature_n->getDoubleValue(), station_elevation_ft);
-	set_dewpoint_at_altitude(dewpoint_n->getDoubleValue(), station_elevation_ft);
-
 	// Force an update of the 3D clouds
 	if( layer_rebuild_required )
 		fgSetInt("/environment/rebuild-layers", 1 );
@@ -629,6 +752,8 @@ void FGMetarCtrl::set_metar( const char * metar_string )
 		return;
 	}
 
+	wind_interpolation_required = true;
+
 	min_visibility_n->setDoubleValue( m->getMinVisibility().getVisibility_m() );
 	max_visibility_n->setDoubleValue( m->getMaxVisibility().getVisibility_m() );
 
@@ -676,6 +801,15 @@ void FGMetarCtrl::set_metar( const char * metar_string )
 
 	station_elevation_n->setDoubleValue( station_elevation_ft );
 
+	{	// calculate sea level temperature and dewpoint
+		FGEnvironment dummy; // instantiate a dummy so we can leech a method
+		dummy.set_elevation_ft( station_elevation_ft );
+		dummy.set_temperature_degc( temperature_n->getDoubleValue() );
+		dummy.set_dewpoint_degc( dewpoint_n->getDoubleValue() );
+		metar_sealevel_temperature = dummy.get_temperature_sea_level_degc();
+		metar_sealevel_dewpoint = dummy.get_dewpoint_sea_level_degc();
+	}
+
 	vector<SGMetarCloud> cv = m->getClouds();
 	vector<SGMetarCloud>::const_iterator cloud, cloud_end = cv.end();
 
@@ -746,13 +880,12 @@ void MetarThread::run()
 			break;
 		}
 
-			metar_fetcher->fetch( airport_id );
+		metar_fetcher->fetch( airport_id );
 	}
 }
 #endif
 
-FGMetarFetcher::FGMetarFetcher()
-  : 
+FGMetarFetcher::FGMetarFetcher() : 
 #if defined(ENABLE_THREADS)
 	metar_thread(NULL),
 #endif
@@ -760,16 +893,17 @@ FGMetarFetcher::FGMetarFetcher()
 	search_timer(0.0),
 	error_timer(0.0),
 	_stale_count(0),
-	_error_count(0)
+	_error_count(0),
+	enabled(false)
 {
 	longitude_n = fgGetNode( "/position/longitude-deg", true );
 	latitude_n  = fgGetNode( "/position/latitude-deg", true );
-	enable_n = fgGetNode( "/environment/params/real-world-weather-fetch", true );
+	enable_n    = fgGetNode( "/environment/params/real-world-weather-fetch", true );
 
 	proxy_host_n = fgGetNode("/sim/presets/proxy/host", true);
 	proxy_port_n = fgGetNode("/sim/presets/proxy/port", true);
 	proxy_auth_n = fgGetNode("/sim/presets/proxy/authentication", true);
-	max_age_n	= fgGetNode("/environment/params/metar-max-age-min", true);
+	max_age_n    = fgGetNode("/environment/params/metar-max-age-min", true);
 
 	output_n	 = fgGetNode("/environment/metar/data", true );
 #if defined(ENABLE_THREADS)
@@ -798,6 +932,22 @@ void FGMetarFetcher::init ()
 	_stale_count = 0;
 	_error_count = 0;
 	current_airport_id.clear();
+	/* Torsten Dreyer:
+	   hack to stop startup.nas complaining if metar arrives after nasal-dir-initialized
+	   is fired. Immediately fetch and wait for the METAR before continuing. This gets the
+	   /environment/metar/xxx properties filled before nasal-dir is initialized.
+	   Maybe the runway selection should happen here to make startup.nas obsolete?
+	*/
+	const char * startup_airport = fgGetString("/sim/startup/options/airport");
+	if( *startup_airport ) {
+		FGAirport * a = FGAirport::getByIdent( startup_airport );
+		if( a ) {
+			SGGeod pos = SGGeod::fromDeg(a->getLongitude(), a->getLatitude());
+			a = FGAirport::findClosest(pos, 10000.0, &airportWithMetarFilter);
+			current_airport_id = a->getId();
+			fetch( current_airport_id );
+		}
+	}
 }
 
 void FGMetarFetcher::reinit ()
@@ -825,8 +975,19 @@ void FGMetarFetcher::update (double delta_time_sec)
 		_error_count = 0;
 	}
 
-	if( enable_n->getBoolValue() == false ) 
+	if( enable_n->getBoolValue() == false ) {
+		enabled = false;
 		return;
+	}
+
+	// we were just enabled, reset all timers to 
+	// trigger immediate metar fetch
+	if( !enabled ) {
+		search_timer = 0.0;
+		fetch_timer = 0.0;
+		error_timer = error_timer_sec;
+		enabled = true;
+	}
 
 	FGAirport * a = NULL;
 
@@ -857,6 +1018,9 @@ void FGMetarFetcher::update (double delta_time_sec)
 
 void FGMetarFetcher::fetch( const string & id )
 {
+	if( enable_n->getBoolValue() == false ) 
+		return;
+
 	SGSharedPtr<FGMetar> result = NULL;
 
 	// fetch current metar data
@@ -878,11 +1042,16 @@ void FGMetarFetcher::fetch( const string & id )
 			}
 		} else {
 			_stale_count = 0;
-			}
+		}
 
 	} catch (const sg_io_exception& e) {
 		SG_LOG( SG_GENERAL, SG_WARN, "Error fetching live weather data: " << e.getFormattedMessage().c_str() );
 		result = NULL;
+		// remove METAR flag from the airport
+		FGAirport * a = FGAirport::findByIdent( id );
+		if( a ) a->setMetar( false );
+		// immediately schedule a new search
+		search_timer = 0.0;
 	}
 
 	// write the metar to the property node, the rest is done by the methods tied to this property