diff --git a/AirLib/include/common/AirSimSettings.hpp b/AirLib/include/common/AirSimSettings.hpp
index 2f01fb22c5..b70b289b0a 100644
--- a/AirLib/include/common/AirSimSettings.hpp
+++ b/AirLib/include/common/AirSimSettings.hpp
@@ -46,9 +46,9 @@ struct AirSimSettings {
         std::string camera_name;
         std::string vehicle_name;
 
-        SubwindowSetting(int window_index_val = 0, ImageType image_type_val = ImageType::Scene, 
+        SubwindowSetting(int window_index_val = 0, ImageType image_type_val = ImageType::Scene,
                 bool visible_val = false, const std::string& camera_name_val = "", const std::string& vehicle_name_val = "")
-            : window_index(window_index_val), image_type(image_type_val), 
+            : window_index(window_index_val), image_type(image_type_val),
               visible(visible_val), camera_name(camera_name_val), vehicle_name(vehicle_name_val)
         {
         }
@@ -197,28 +197,79 @@ struct AirSimSettings {
     };
 
     struct BarometerSetting : SensorSetting {
+        real_T qnh = EarthUtils::SeaLevelPressure / 100.0f; // hPa
+        real_T pressure_factor_sigma = 0.0365f / 20;
+        real_T pressure_factor_tau = 3600;
+        real_T unnorrelated_noise_sigma = 0.027f * 100;
+        real_T update_latency = 0.0f;    //sec
+        real_T update_frequency = 50;    //Hz
+        real_T startup_delay = 0;        //sec
     };
 
     struct ImuSetting : SensorSetting {
+        // Angular random walk (ARW)
+        real_T gyro_arw = 0.30f / sqrt(3600.0f) * M_PIf / 180; //deg/sqrt(hour) converted to rad/sqrt(sec)
+        // Bias Stability (tau = 500s)
+        real_T gyro_tau = 500;
+        real_T gyro_bias_stability = 4.6f / 3600 * M_PIf / 180; //deg/hr converted to rad/sec
+        Vector3r gyro_turn_on_bias = Vector3r::Zero(); //assume calibration is done
+
+        // Velocity random walk (VRW)
+        real_T accel_vrw = 0.24f * EarthUtils::Gravity / 1.0E3f; //mg converted to m/s^2
+        // Bias Stability (tau = 800s)
+        real_T accel_tau = 800;
+        real_T accel_bias_stability = 36.0f * 1E-6f * EarthUtils::Gravity; //ug converted to m/s^2
+        Vector3r accel_turn_on_bias = Vector3r::Zero(); //assume calibration is done
     };
 
     struct GpsSetting : SensorSetting {
+        real_T eph_time_constant = 0.9f;
+        real_T epv_time_constant = 0.9f;
+        real_T eph_initial = 100.0f;
+        real_T epv_initial = 100.0f;   //initially fully diluted positions
+        real_T eph_final = 0.3f;
+        real_T epv_final = 0.4f;
+        real_T eph_min_3d = 3.0f;
+        real_T eph_min_2d = 4.0f;
+
+        real_T update_latency = 0.2f;    //sec
+        real_T update_frequency = 50;    //Hz
+        real_T startup_delay = 1;        //sec
     };
 
     struct MagnetometerSetting : SensorSetting {
+        Vector3r noise_sigma{0.005f, 0.005f, 0.005f}; //5 mgauss as per specs sheet (RMS is same as stddev) https://goo.gl/UOz6FT
+        real_T scale_factor = 1.0f;
+        Vector3r noise_bias{0.0f, 0.0f, 0.0f}; //no offset as per specsheet (zero gauss level) https://goo.gl/UOz6FT
+        float ref_update_frequency = 0.2f;    //Hz
+
+        //use dipole model if there is enough compute power available
+        bool dynamic_reference_source = true;
+        // ref_source 0==ConstantModel; 1==DipoleModel
+        int ref_source = 1;
+
+        //see PX4 param reference for EKF: https://dev.px4.io/en/advanced/parameter_reference.html
+        real_T update_latency = 0.0f;    //sec: from PX4 doc
+        real_T update_frequency = 50;    //Hz
+        real_T startup_delay = 0;        //sec
     };
 
     struct DistanceSetting : SensorSetting {
-        // shared defaults
-        real_T min_distance = 20.0f / 100; //m
-        real_T max_distance = 4000.0f / 100; //m
+        // nan means keep the default values set in components
         Vector3r position = VectorMath::nanVector();
         Rotation rotation = Rotation::nanRotation();
+
+        real_T min_distance = 20.0f / 100; //m
+        real_T max_distance = 4000.0f / 100; //m
+        real_T unnorrelated_noise_sigma = 0.002f * 100;
+        real_T update_latency = 0.0f;    //sec
+        real_T update_frequency = 50;    //Hz
+        real_T startup_delay = 0;        //sec
+
         bool draw_debug_points = false;
     };
 
     struct LidarSetting : SensorSetting {
-
         // shared defaults
         uint number_of_channels = 16;
         real_T range = 10000.0f / 100;                    // meters
@@ -238,11 +289,11 @@ struct AirSimSettings {
     };
 
     struct VehicleSetting {
-        //required
+        // Required
         std::string vehicle_name;
         std::string vehicle_type;
 
-        //optional
+        // Optional
         std::string default_vehicle_state;
         std::string pawn_path;
         bool allow_api_always = true;
@@ -252,7 +303,7 @@ struct AirSimSettings {
         bool enable_collisions = true;
         bool is_fpv_vehicle = false;
 
-        //nan means use player start
+        // nan means use player start
         Vector3r position = VectorMath::nanVector(); //in global NED
         Rotation rotation = Rotation::nanRotation();
 
@@ -267,7 +318,7 @@ struct AirSimSettings {
 
         bool use_serial = true; // false means use UDP or TCP instead
 
-        //Used to connect via HITL: needed only if use_serial = true
+        // Used to connect via HITL: needed only if use_serial = true
         std::string serial_port = "*";
         int baud_rate = 115200;
 
@@ -295,7 +346,7 @@ struct AirSimSettings {
         int qgc_ip_port = 0;
         std::string qgc_ip_address = "";
 
-        // mavlink vehicle identifiers
+        // Mavlink vehicle identifiers
         uint8_t sim_sysid = 142;
         int sim_compid = 42;
         uint8_t offboard_sysid = 134;
@@ -303,9 +354,9 @@ struct AirSimSettings {
         uint8_t vehicle_sysid = 135;
         int vehicle_compid = 1;
 
-        // if you want to select a specific local network adapter so you can reach certain remote machines (e.g. wifi versus ethernet)
-        // then you will want to change the LocalHostIp accordingly.  This default only works when log viewer and QGC are also on the
-        // same machine.  Whatever network you choose it has to be the same one for external
+        // If you want to select a specific local network adapter so you can reach certain remote machines (e.g. wifi versus ethernet),
+        // then you will want to change the LocalHostIp accordingly. This default only works when log viewer and QGC are also on the
+        // same machine. Whatever network you choose, it has to be the same one for external.
         std::string local_host_ip = "127.0.0.1";
 
         std::string model = "Generic";
@@ -445,7 +496,7 @@ struct AirSimSettings {
         vehicle_setting->position = pose.position;
         vehicle_setting->pawn_path = pawn_path;
 
-        VectorMath::toEulerianAngle(pose.orientation, vehicle_setting->rotation.pitch, 
+        VectorMath::toEulerianAngle(pose.orientation, vehicle_setting->rotation.pitch,
                                     vehicle_setting->rotation.roll, vehicle_setting->rotation.yaw);
 
         vehicles[vehicle_name] = std::move(vehicle_setting);
@@ -550,7 +601,7 @@ struct AirSimSettings {
                 physics_engine_name = "PhysX"; //this value is only informational for now
         }
     }
-    
+
     void loadLevelSettings(const Settings& settings_json)
     {
         level_name = settings_json.getString("Default Environment", "");
@@ -753,6 +804,7 @@ struct AirSimSettings {
             settings_json.getFloat("Y", default_vec.y()),
             settings_json.getFloat("Z", default_vec.z()));
     }
+
     static Rotation createRotationSetting(const Settings& settings_json, const Rotation& default_rot)
     {
         return Rotation(settings_json.getFloat("Yaw", default_rot.yaw),
@@ -760,13 +812,41 @@ struct AirSimSettings {
             settings_json.getFloat("Roll", default_rot.roll));
     }
 
+    static Vector3r createGyroBiasSetting(const Settings& settings_json, const Vector3r& default_vec)
+    {
+        return Vector3r(settings_json.getFloat("GyroBias_X", default_vec.x()),
+            settings_json.getFloat("GyroBias_Y", default_vec.y()),
+            settings_json.getFloat("GyroBias_Z", default_vec.z()));
+    }
+
+    static Vector3r createAccelBiasSetting(const Settings& settings_json, const Vector3r& default_vec)
+    {
+        return Vector3r(settings_json.getFloat("AccelBias_X", default_vec.x()),
+            settings_json.getFloat("AccelBias_Y", default_vec.y()),
+            settings_json.getFloat("AccelBias_Z", default_vec.z()));
+    }
+
+    static Vector3r createNoiseSigmaSetting(const Settings& settings_json, const Vector3r& default_vec)
+    {
+        return Vector3r(settings_json.getFloat("NoiseSigma_X", default_vec.x()),
+            settings_json.getFloat("NoiseSigma_Y", default_vec.y()),
+            settings_json.getFloat("NoiseSigma_Z", default_vec.z()));
+    }
+
+    static Vector3r createNoiseBiasSetting(const Settings& settings_json, const Vector3r& default_vec)
+    {
+        return Vector3r(settings_json.getFloat("NoiseBias_X", default_vec.x()),
+            settings_json.getFloat("NoiseBias_Y", default_vec.y()),
+            settings_json.getFloat("NoiseBias_Z", default_vec.z()));
+    }
+
     static std::unique_ptr<VehicleSetting> createVehicleSetting(const std::string& simmode_name,  const Settings& settings_json,
         const std::string vehicle_name)
     {
         auto vehicle_type = Utils::toLower(settings_json.getString("VehicleType", ""));
 
         std::unique_ptr<VehicleSetting> vehicle_setting;
-        if (vehicle_type == kVehicleTypePX4 || vehicle_type == kVehicleTypeArduCopterSolo 
+        if (vehicle_type == kVehicleTypePX4 || vehicle_type == kVehicleTypeArduCopterSolo
             || vehicle_type == kVehicleTypeArduCopter || vehicle_type == kVehicleTypeArduRover)
             vehicle_setting = createMavLinkVehicleSetting(settings_json);
         //for everything else we don't need derived class yet
@@ -1197,34 +1277,54 @@ struct AirSimSettings {
 
     static void initializeBarometerSetting(BarometerSetting& barometer_setting, const Settings& settings_json)
     {
-        unused(barometer_setting);
-        unused(settings_json);
-
-        //TODO: set from json as needed
+        barometer_setting.qnh = settings_json.getFloat("SeaLevelPressure", barometer_setting.qnh);
+        barometer_setting.pressure_factor_sigma = settings_json.getFloat("PressureFactorSigma", barometer_setting.pressure_factor_sigma);
+        barometer_setting.pressure_factor_tau = settings_json.getFloat("PressureFactorTau", barometer_setting.pressure_factor_tau);
+        barometer_setting.unnorrelated_noise_sigma = settings_json.getFloat("NoiseSigma", barometer_setting.unnorrelated_noise_sigma);
+        barometer_setting.update_latency = settings_json.getFloat("UpdateLatency", barometer_setting.update_latency);
+        barometer_setting.update_frequency = settings_json.getFloat("UpdateFrequency", barometer_setting.update_frequency);
+        barometer_setting.startup_delay = settings_json.getFloat("StartupDelay", barometer_setting.startup_delay);
     }
 
     static void initializeImuSetting(ImuSetting& imu_setting, const Settings& settings_json)
     {
-        unused(imu_setting);
-        unused(settings_json);
-
-        //TODO: set from json as needed
+        imu_setting.gyro_arw = settings_json.getFloat("GyroAngleRandomWalk", imu_setting.gyro_arw);
+        imu_setting.gyro_tau = settings_json.getFloat("GyroBiasTau", imu_setting.gyro_tau);
+        imu_setting.gyro_bias_stability = settings_json.getFloat("GyroBiasStability", imu_setting.gyro_bias_stability);
+        imu_setting.gyro_turn_on_bias = createGyroBiasSetting(settings_json, imu_setting.gyro_turn_on_bias);
+
+        imu_setting.accel_vrw = settings_json.getFloat("AccelerometerVelocityRandomWalk", imu_setting.accel_vrw);
+        imu_setting.accel_tau = settings_json.getFloat("AccelerometerBiasTau", imu_setting.accel_tau);
+        imu_setting.accel_bias_stability = settings_json.getFloat("AccelerometerBiasStability", imu_setting.accel_bias_stability);
+        imu_setting.accel_turn_on_bias = createAccelBiasSetting(settings_json, imu_setting.accel_turn_on_bias);
     }
 
     static void initializeGpsSetting(GpsSetting& gps_setting, const Settings& settings_json)
     {
-        unused(gps_setting);
-        unused(settings_json);
+        gps_setting.eph_time_constant = settings_json.getFloat("EphTimeConstant", gps_setting.eph_time_constant);
+        gps_setting.epv_time_constant = settings_json.getFloat("EpvTimeConstant", gps_setting.epv_time_constant);
+        gps_setting.eph_initial = settings_json.getFloat("EphInitial", gps_setting.eph_initial);
+        gps_setting.epv_initial = settings_json.getFloat("EpvInitial", gps_setting.epv_initial);
+        gps_setting.eph_final = settings_json.getFloat("EphFinal", gps_setting.eph_final);
+        gps_setting.epv_final = settings_json.getFloat("EpvFinal", gps_setting.epv_final);
+        gps_setting.eph_min_3d = settings_json.getFloat("EphMin3d", gps_setting.eph_min_3d);
+        gps_setting.eph_min_2d = settings_json.getFloat("EphMin2d", gps_setting.eph_min_2d);
+        gps_setting.update_latency = settings_json.getFloat("UpdateLatency", gps_setting.update_latency);
+        gps_setting.update_frequency = settings_json.getFloat("UpdateFrequency", gps_setting.update_frequency);
+        gps_setting.startup_delay = settings_json.getFloat("StartupDelay", gps_setting.startup_delay);
 
-        //TODO: set from json as needed
     }
 
     static void initializeMagnetometerSetting(MagnetometerSetting& magnetometer_setting, const Settings& settings_json)
     {
-        unused(magnetometer_setting);
-        unused(settings_json);
-
-        //TODO: set from json as needed
+        magnetometer_setting.noise_sigma = createNoiseSigmaSetting(settings_json, magnetometer_setting.noise_sigma);
+        magnetometer_setting.scale_factor = settings_json.getFloat("ScaleFactor", magnetometer_setting.scale_factor);
+        magnetometer_setting.dynamic_reference_source = settings_json.getBool("DynamicReferenceSource", magnetometer_setting.dynamic_reference_source);
+        magnetometer_setting.update_frequency = settings_json.getFloat("UpdateFrequency", magnetometer_setting.update_frequency);
+        magnetometer_setting.ref_source = settings_json.getInt("ReferenceSource", magnetometer_setting.ref_source);
+        magnetometer_setting.update_latency = settings_json.getFloat("UpdateLatency", magnetometer_setting.update_latency);
+        magnetometer_setting.update_frequency = settings_json.getFloat("UpdateFrequency", magnetometer_setting.update_frequency);
+        magnetometer_setting.startup_delay = settings_json.getFloat("StartupDelay", magnetometer_setting.startup_delay);
     }
 
     static void initializeDistanceSetting(DistanceSetting& distance_setting, const Settings& settings_json)
@@ -1233,6 +1333,10 @@ struct AirSimSettings {
         distance_setting.max_distance = settings_json.getFloat("MaxDistance", distance_setting.max_distance);
         distance_setting.draw_debug_points = settings_json.getBool("DrawDebugPoints", distance_setting.draw_debug_points);
 
+        distance_setting.unnorrelated_noise_sigma = settings_json.getFloat("Noise", distance_setting.unnorrelated_noise_sigma);
+        distance_setting.update_latency = settings_json.getFloat("UpdateLatency", distance_setting.update_latency);
+        distance_setting.update_frequency = settings_json.getFloat("UpdateFrequency", distance_setting.update_frequency);
+        distance_setting.startup_delay = settings_json.getFloat("StartupDelay", distance_setting.startup_delay);
         distance_setting.position = createVectorSetting(settings_json, distance_setting.position);
         distance_setting.rotation = createRotationSetting(settings_json, distance_setting.rotation);
     }
diff --git a/AirLib/include/sensors/barometer/BarometerSimpleParams.hpp b/AirLib/include/sensors/barometer/BarometerSimpleParams.hpp
index 62082342dd..867d8d6ed8 100644
--- a/AirLib/include/sensors/barometer/BarometerSimpleParams.hpp
+++ b/AirLib/include/sensors/barometer/BarometerSimpleParams.hpp
@@ -49,7 +49,14 @@ struct BarometerSimpleParams {
 
     void initializeFromSettings(const AirSimSettings::BarometerSetting& settings)
     {
-        unused(settings);
+        qnh = settings.qnh;
+        pressure_factor_sigma = settings.pressure_factor_sigma;
+        pressure_factor_tau = settings.pressure_factor_tau;
+        unnorrelated_noise_sigma = settings.unnorrelated_noise_sigma;
+        update_latency = settings.update_latency;
+        update_frequency = settings.update_frequency;
+        startup_delay = settings.startup_delay;
+
     }
 };
 
diff --git a/AirLib/include/sensors/distance/DistanceSimpleParams.hpp b/AirLib/include/sensors/distance/DistanceSimpleParams.hpp
index 3af863297e..9cc1c152ba 100644
--- a/AirLib/include/sensors/distance/DistanceSimpleParams.hpp
+++ b/AirLib/include/sensors/distance/DistanceSimpleParams.hpp
@@ -50,6 +50,10 @@ struct DistanceSimpleParams {
 
         min_distance = settings.min_distance;
         max_distance = settings.max_distance;
+        unnorrelated_noise_sigma = settings.unnorrelated_noise_sigma;
+        update_latency = settings.update_latency;
+        update_frequency = settings.update_frequency;
+        startup_delay = settings.startup_delay;
 
         draw_debug_points = settings.draw_debug_points;
 
@@ -72,7 +76,8 @@ struct DistanceSimpleParams {
         relative_pose.orientation = VectorMath::toQuaternion(
             Utils::degreesToRadians(pitch),   //pitch - rotation around Y axis
             Utils::degreesToRadians(roll),    //roll  - rotation around X axis
-            Utils::degreesToRadians(yaw));    //yaw   - rotation around Z axis
+            Utils::degreesToRadians(yaw)      //yaw   - rotation around Z axis
+        );
     }
 };
 
diff --git a/AirLib/include/sensors/gps/GpsSimpleParams.hpp b/AirLib/include/sensors/gps/GpsSimpleParams.hpp
index 52d8cf88c8..86a4b1fa0c 100644
--- a/AirLib/include/sensors/gps/GpsSimpleParams.hpp
+++ b/AirLib/include/sensors/gps/GpsSimpleParams.hpp
@@ -5,15 +5,19 @@
 #define msr_airlib_GpsSimpleParams_hpp
 
 #include "common/Common.hpp"
-
+#include "common/AirSimSettings.hpp"
 
 namespace msr { namespace airlib {
 
 struct GpsSimpleParams {
-    real_T eph_time_constant = 0.9f, epv_time_constant = 0.9f;
-    real_T eph_initial = 100.0f, epv_initial = 100.0f;   //initially fully diluted positions
-    real_T eph_final = 0.3f, epv_final = 0.4f;
-    real_T eph_min_3d = 3.0f, eph_min_2d = 4.0f;
+    real_T eph_time_constant = 0.9f;
+    real_T epv_time_constant = 0.9f;
+    real_T eph_initial = 100.0f;
+    real_T epv_initial = 100.0f;   //initially fully diluted positions
+    real_T eph_final = 0.3f;
+    real_T epv_final = 0.4f;
+    real_T eph_min_3d = 3.0f;
+    real_T eph_min_2d = 4.0f;
 
     real_T update_latency = 0.2f;    //sec
     real_T update_frequency = 50;    //Hz
@@ -21,7 +25,18 @@ struct GpsSimpleParams {
 
     void initializeFromSettings(const AirSimSettings::GpsSetting& settings)
     {
-        unused(settings);
+        eph_time_constant = settings.eph_time_constant;
+        epv_time_constant = settings.epv_time_constant;
+        eph_initial = settings.eph_initial;
+        epv_initial = settings.epv_initial;
+        eph_final = settings.eph_final;
+        epv_final = settings.epv_final;
+        eph_min_3d = settings.eph_min_3d;
+        eph_min_2d = settings.eph_min_2d;
+
+        update_latency = settings.update_latency;
+        update_frequency = settings.update_frequency;
+        startup_delay = settings.startup_delay;
     }
 };
 
diff --git a/AirLib/include/sensors/imu/ImuSimpleParams.hpp b/AirLib/include/sensors/imu/ImuSimpleParams.hpp
index 6cbe166a4e..d3e9316190 100644
--- a/AirLib/include/sensors/imu/ImuSimpleParams.hpp
+++ b/AirLib/include/sensors/imu/ImuSimpleParams.hpp
@@ -16,7 +16,7 @@ namespace msr { namespace airlib {
 // A description of the parameters:
 // https://github.com/ethz-asl/kalibr/wiki/IMU-Noise-Model-and-Intrinsics
 struct ImuSimpleParams {
-    /* ref: Parameter values are for MPU 6000 IMU from InvenSense 
+    /* ref: Parameter values are for MPU 6000 IMU from InvenSense
     Design and Characterization of a Low Cost MEMS IMU Cluster for Precision Navigation
     Daniel R. Greenheck, 2009, sec 2.2, pp 17
     http://epublications.marquette.edu/cgi/viewcontent.cgi?article=1326&context=theses_open
@@ -24,8 +24,9 @@ struct ImuSimpleParams {
     https://www.invensense.com/wp-content/uploads/2015/02/MPU-6000-Datasheet1.pdf
     For Allan Variance/Deviation plots see http://www.invensense.com/wp-content/uploads/2015/02/MPU-3300-Datasheet.pdf
     */
+
     struct Gyroscope {
-        //angule random walk (ARW)
+        //angular random walk (ARW)
         real_T arw = 0.30f / sqrt(3600.0f) * M_PIf / 180; //deg/sqrt(hour) converted to rad/sqrt(sec)
         //Bias Stability (tau = 500s)
         real_T tau = 500;
@@ -34,8 +35,8 @@ struct ImuSimpleParams {
     } gyro;
 
     struct Accelerometer {
-        //velocity random walk (ARW)
-        real_T vrw = 0.24f * EarthUtils::Gravity / 1.0E3f; //mg converted to m/s^2 
+        //velocity random walk (VRW)
+        real_T vrw = 0.24f * EarthUtils::Gravity / 1.0E3f; //mg converted to m/s^2
         //Bias Stability (tau = 800s)
         real_T tau = 800;
         real_T bias_stability = 36.0f * 1E-6f * 9.80665f; //ug converted to m/s^2
@@ -46,7 +47,15 @@ struct ImuSimpleParams {
 
     void initializeFromSettings(const AirSimSettings::ImuSetting& settings)
     {
-        unused(settings);
+        gyro.arw = settings.gyro_arw;
+        gyro.tau = settings.gyro_tau;
+        gyro.bias_stability = settings.gyro_bias_stability;
+        gyro.turn_on_bias = settings.gyro_turn_on_bias;
+
+        accel.vrw = settings.accel_vrw;
+        accel.tau = settings.accel_tau;
+        accel.bias_stability = settings.accel_bias_stability;
+        accel.turn_on_bias = settings.accel_turn_on_bias;
     }
 };
 
diff --git a/AirLib/include/sensors/lidar/LidarSimpleParams.hpp b/AirLib/include/sensors/lidar/LidarSimpleParams.hpp
index c42bb59c7b..2d5d230803 100644
--- a/AirLib/include/sensors/lidar/LidarSimpleParams.hpp
+++ b/AirLib/include/sensors/lidar/LidarSimpleParams.hpp
@@ -17,9 +17,9 @@ struct LidarSimpleParams {
     // default settings
     // TODO: enable reading of these params from AirSim settings
 
-    uint number_of_channels = 16; 
+    uint number_of_channels = 16;
     real_T range = 10000.0f / 100;            // meters
-    uint points_per_second = 100000;  
+    uint points_per_second = 100000;
     uint horizontal_rotation_frequency = 10;  // rotations/sec
     real_T horizontal_FOV_start = 0;
     real_T horizontal_FOV_end = 359;
@@ -28,8 +28,8 @@ struct LidarSimpleParams {
 
     Pose relative_pose {
         Vector3r(0,0,-1),                     // position - a little above vehicle (especially for cars) or Vector3r::Zero()
-        Quaternionr::Identity()               // orientation - by default Quaternionr(1, 0, 0, 0) 
-        };                       
+        Quaternionr::Identity()               // orientation - by default Quaternionr(1, 0, 0, 0)
+    };
 
     bool draw_debug_points = false;
     std::string data_frame = AirSimSettings::kVehicleInertialFrame;
@@ -86,8 +86,8 @@ struct LidarSimpleParams {
         relative_pose.orientation = VectorMath::toQuaternion(
             Utils::degreesToRadians(pitch),   //pitch - rotation around Y axis
             Utils::degreesToRadians(roll),    //roll  - rotation around X axis
-            Utils::degreesToRadians(yaw));    //yaw   - rotation around Z axis
-           
+            Utils::degreesToRadians(yaw)      //yaw   - rotation around Z axis
+        );
         draw_debug_points = settings.draw_debug_points;
         data_frame = settings.data_frame;
     }
diff --git a/AirLib/include/sensors/magnetometer/MagnetometerSimpleParams.hpp b/AirLib/include/sensors/magnetometer/MagnetometerSimpleParams.hpp
index 652cb3257c..dd17f0d0c9 100644
--- a/AirLib/include/sensors/magnetometer/MagnetometerSimpleParams.hpp
+++ b/AirLib/include/sensors/magnetometer/MagnetometerSimpleParams.hpp
@@ -5,6 +5,7 @@
 #define msr_airlib_MagnetometerSimpleParams_hpp
 
 #include "common/Common.hpp"
+#include "common/AirSimSettings.hpp"
 
 
 namespace msr { namespace airlib {
@@ -34,7 +35,19 @@ struct MagnetometerSimpleParams {
 
     void initializeFromSettings(const AirSimSettings::MagnetometerSetting& settings)
     {
-        unused(settings);
+        noise_sigma = settings.noise_sigma;
+        noise_bias = settings.noise_bias;
+        scale_factor = settings.scale_factor;
+        dynamic_reference_source = settings.dynamic_reference_source;
+        ref_update_frequency = settings.update_frequency;
+
+        if (settings.ref_source == 0){
+            ref_source = ReferenceSource::ReferenceSource_Constant;
+        }
+
+        update_latency = settings.update_latency;
+        update_frequency = settings.update_frequency;
+        startup_delay = settings.startup_delay;
     }
 };
 
diff --git a/AirLib/src/vehicles/multirotor/api/MultirotorApiBase.cpp b/AirLib/src/vehicles/multirotor/api/MultirotorApiBase.cpp
index aa1002973d..62fe3be062 100644
--- a/AirLib/src/vehicles/multirotor/api/MultirotorApiBase.cpp
+++ b/AirLib/src/vehicles/multirotor/api/MultirotorApiBase.cpp
@@ -702,7 +702,7 @@ void MultirotorApiBase::moveToPathPosition(const Vector3r& dest, float velocity,
     }
 
     //send commands
-    //try to maintain altitude if path was in XY plan only, velocity based control is not as good
+    //try to maintain altitude if path was in XY plane only, velocity based control is not as good
     if (std::abs(cur.z() - dest.z()) <= getDistanceAccuracy()) //for paths in XY plan current code leaves z untouched, so we can compare with strict equality
         moveByVelocityInternal(velocity_vect.x(), velocity_vect.y(), 0, yaw_mode);
     else
diff --git a/PythonClient/airsim/types.py b/PythonClient/airsim/types.py
index dc3bff7e92..e60fd2715a 100644
--- a/PythonClient/airsim/types.py
+++ b/PythonClient/airsim/types.py
@@ -424,7 +424,7 @@ class PIDGains():
     """
     Struct to store values of PID gains. Used to transmit controller gain values while instantiating
     AngleLevel/AngleRate/Velocity/PositionControllerGains objects.
-    
+
     Attributes:
         kP (float): Proportional gain
         kI (float): Integrator gain
@@ -441,7 +441,7 @@ def to_list(self):
 class AngleRateControllerGains():
     """
     Struct to contain controller gains used by angle level PID controller
-    
+
     Attributes:
         roll_gains (PIDGains): kP, kI, kD for roll axis
         pitch_gains (PIDGains): kP, kI, kD for pitch axis
@@ -453,14 +453,14 @@ def __init__(self, roll_gains = PIDGains(0.25, 0, 0),
         self.roll_gains = roll_gains
         self.pitch_gains = pitch_gains
         self.yaw_gains = yaw_gains
-    
+
     def to_lists(self):
         return [self.roll_gains.kp, self.pitch_gains.kp, self.yaw_gains.kp], [self.roll_gains.ki, self.pitch_gains.ki, self.yaw_gains.ki], [self.roll_gains.kd, self.pitch_gains.kd, self.yaw_gains.kd]
 
 class AngleLevelControllerGains():
     """
     Struct to contain controller gains used by angle rate PID controller
-    
+
     Attributes:
         roll_gains (PIDGains): kP, kI, kD for roll axis
         pitch_gains (PIDGains): kP, kI, kD for pitch axis
@@ -472,14 +472,14 @@ def __init__(self, roll_gains = PIDGains(2.5, 0, 0),
         self.roll_gains = roll_gains
         self.pitch_gains = pitch_gains
         self.yaw_gains = yaw_gains
-    
+
     def to_lists(self):
         return [self.roll_gains.kp, self.pitch_gains.kp, self.yaw_gains.kp], [self.roll_gains.ki, self.pitch_gains.ki, self.yaw_gains.ki], [self.roll_gains.kd, self.pitch_gains.kd, self.yaw_gains.kd]
 
 class VelocityControllerGains():
     """
     Struct to contain controller gains used by velocity PID controller
-    
+
     Attributes:
         x_gains (PIDGains): kP, kI, kD for X axis
         y_gains (PIDGains): kP, kI, kD for Y axis
@@ -491,14 +491,14 @@ def __init__(self, x_gains = PIDGains(0.2, 0, 0),
         self.x_gains = x_gains
         self.y_gains = y_gains
         self.z_gains = z_gains
-    
+
     def to_lists(self):
         return [self.x_gains.kp, self.y_gains.kp, self.z_gains.kp], [self.x_gains.ki, self.y_gains.ki, self.z_gains.ki], [self.x_gains.kd, self.y_gains.kd, self.z_gains.kd]
 
 class PositionControllerGains():
     """
     Struct to contain controller gains used by position PID controller
-    
+
     Attributes:
         x_gains (PIDGains): kP, kI, kD for X axis
         y_gains (PIDGains): kP, kI, kD for Y axis
@@ -510,7 +510,7 @@ def __init__(self, x_gains = PIDGains(0.25, 0, 0),
         self.x_gains = x_gains
         self.y_gains = y_gains
         self.z_gains = z_gains
-    
+
     def to_lists(self):
         return [self.x_gains.kp, self.y_gains.kp, self.z_gains.kp], [self.x_gains.ki, self.y_gains.ki, self.z_gains.ki], [self.x_gains.kd, self.y_gains.kd, self.z_gains.kd]
 
diff --git a/docs/build_linux.md b/docs/build_linux.md
index 6afdf93bc8..8b433e75f4 100644
--- a/docs/build_linux.md
+++ b/docs/build_linux.md
@@ -100,6 +100,7 @@ Alternatively, you can use [APIs](apis.md) for programmatic control or use the s
 * If this is the case then look for *.gch file(s) that follows after that message, delete them and try again. Here's [relevant thread](https://answers.unrealengine.com/questions/412349/linux-ue4-build-precompiled-header-fatal-error.html) on Unreal Engine forums.
 
 * If you see other compile errors in console then open up those source files and see if it is due to changes you made. If not, then report it as issue on GitHub.
+* Additionally, if you are having trouble rebuilding the plugin in UE4 after making changes to the AirSim library, you may need to manually delete the binaries and intermediate folders in both your Unreal Project folder, and in the UnrealProject/Plugin/AirSim folder. This can be done by running [clean.sh](https://github.com/microsoft/AirSim/blob/master/Unreal/Environments/Blocks/clean.sh). This will force clang to recompile both the UE4 project and plugin and may resolve issues of "clang could not find file x".
 
 - Unreal crashed! How do I know what went wrong?
     * Go to the `MyUnrealProject/Saved/Crashes` folder and search for the file `MyProject.log` within its subdirectories. At the end of this file you will see the stack trace and messages.