diff --git a/VECTO/GUI/GearboxForm.vb b/VECTO/GUI/GearboxForm.vb
index 3e3e89ec900952ab14c86b4eec290ae6d0b47b01..79b3af8bc444d2fb87d6816956ccd36c35223743 100644
--- a/VECTO/GUI/GearboxForm.vb
+++ b/VECTO/GUI/GearboxForm.vb
@@ -132,7 +132,7 @@ Public Class GearboxForm
 	Private Sub ToolStripBtOpen_Click(sender As Object, e As EventArgs) Handles ToolStripBtOpen.Click
 		If GearboxFileBrowser.OpenDialog(_gbxFile) Then
 			Try
-				OpenGbx(GearboxFileBrowser.Files(0))
+				OpenGbx(GearboxFileBrowser.Files(0), VehicleCategory.RigidTruck)
 			Catch ex As Exception
 				MsgBox("Failed to open Gearbox File: " + ex.Message)
 			End Try
@@ -234,7 +234,7 @@ Public Class GearboxForm
 	End Sub
 
 	'Open file
-	Public Sub OpenGbx(file As String)
+	Public Sub OpenGbx(file As String, vehicleCategory As VehicleCategory)
 
 		If ChangeCheckCancel() Then Exit Sub
 
@@ -243,6 +243,8 @@ Public Class GearboxForm
 		Dim gearbox As IGearboxEngineeringInputData = inputData.GearboxInputData
 		Dim axlegear As IAxleGearInputData = inputData.AxleGearInputData
 
+		_vehicleCategory = vehicleCategory
+
 		If Cfg.DeclMode <> gearbox.SavedInDeclarationMode Then
 			Select Case WrongMode()
 				Case 1
@@ -524,7 +526,8 @@ Public Class GearboxForm
 			If LvGears.Items.Count > 2 Then
 				Dim ratio1 As Double = LvGears.Items.Item(1).SubItems(GearboxTbl.Ratio).Text.ToDouble(0)
 				Dim ratio2 As Double = LvGears.Items.Item(2).SubItems(GearboxTbl.Ratio).Text.ToDouble(0)
-				If ratio1 / ratio2 >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold Then
+
+				If ratio1 / ratio2 >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold(_vehicleCategory) Then
 					text = "Torque converter is used in 1st and 2nd gear"
 				Else
 					text = "Torque converter is used in 1st gear only"
@@ -696,6 +699,7 @@ Public Class GearboxForm
 #Region "Open File Context Menu"
 
 	Private _contextMenuFiles As String()
+	Private _vehicleCategory As VehicleCategory
 
 	Private Sub OpenFiles(ParamArray files() As String)
 
diff --git a/VECTO/GUI/MainForm.vb b/VECTO/GUI/MainForm.vb
index 9b9b7d3b381dddfe6db2d36fb579d4b1bfd4cf76..68cdc222cacd816d3e24aeff9121a668878edd61 100644
--- a/VECTO/GUI/MainForm.vb
+++ b/VECTO/GUI/MainForm.vb
@@ -341,7 +341,7 @@ Imports TUGraz.VectoCore.OutputData.FileIO
 						GearboxForm.BringToFront()
 					End If
 					Try
-						GearboxForm.OpenGbx(file)
+						GearboxForm.OpenGbx(file, VehicleCategory.RigidTruck)
 					Catch ex As Exception
 						MsgBox("Failed to open Gearbox File: " + ex.Message)
 					End Try
diff --git a/VECTO/GUI/VectoJobForm.vb b/VECTO/GUI/VectoJobForm.vb
index ba1a4fc34c90668aba3c5713d010bb9b89658b17..18bd338ee58e8a67da2967b6ff8302c114d6b7bf 100644
--- a/VECTO/GUI/VectoJobForm.vb
+++ b/VECTO/GUI/VectoJobForm.vb
@@ -296,8 +296,20 @@ Public Class VectoJobForm
 			If GearboxForm.WindowState = FormWindowState.Minimized Then GearboxForm.WindowState = FormWindowState.Normal
 			GearboxForm.BringToFront()
 		End If
+		Dim vehicleType As VehicleCategory
 		Try
-			If Not Trim(f) = "" Then GearboxForm.OpenGbx(f)
+			If Not Trim(f) = "" Then
+				Dim vehInput As IVehicleDeclarationInputData =
+						CType(JSONInputDataFactory.ReadComponentData(FileRepl(TbVEH.Text, GetPath(VectoFile))), 
+							IEngineeringInputDataProvider).VehicleInputData
+				vehicleType = vehInput.VehicleCategory
+			End If
+
+		Catch ex As Exception
+			vehicleType = VehicleCategory.RigidTruck
+		End Try
+		Try
+			If Not Trim(f) = "" Then GearboxForm.OpenGbx(f, vehicleType)
 		Catch ex As Exception
 			MsgBox("Failed to open Gearbox File: " + ex.Message)
 		End Try
@@ -680,7 +692,8 @@ Public Class VectoJobForm
 
 		CbEngOnly.Checked = False
 
-		RdOff.Checked = True
+		'RdOff.Checked = True
+		RdOverspeed.Checked = True
 		CbLookAhead.Checked = True
 		'TbAlookahead.Text = "-0.5"
 		TbOverspeed.Text = DeclarationData.Driver.OverSpeedEcoRoll.OverSpeed.AsKmph.ToGUIFormat()
diff --git a/VECTO/Input Files/Gearbox.vb b/VECTO/Input Files/Gearbox.vb
index 4849eba590ffb2b27050f5aafbbf51b1a7165500..27d7c2eb797056d195173d955533e0415f81433a 100644
--- a/VECTO/Input Files/Gearbox.vb	
+++ b/VECTO/Input Files/Gearbox.vb	
@@ -22,6 +22,7 @@ Imports TUGraz.VectoCore.InputData.FileIO.JSON
 Imports TUGraz.VectoCore.InputData.Impl
 Imports TUGraz.VectoCore.InputData.Reader
 Imports TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
+Imports TUGraz.VectoCore.Models.Declaration
 Imports TUGraz.VectoCore.Models.SimulationComponent.Data
 Imports TUGraz.VectoCore.Models.SimulationComponent.Data.Engine
 Imports TUGraz.VectoCore.Utils
@@ -204,7 +205,13 @@ Public Class Gearbox
 							IEngineeringInputDataProvider)
 			'Dim vehicle As IVehicleEngineeringInputData = inputData.VehicleInputData
 			Dim engine As CombustionEngineData
+			Dim vehiclecategory As VehicleCategory
 			Dim rdyn As Meter = 0.5.SI(Of Meter)()
+			Try
+				vehiclecategory = inputData.VehicleInputData.VehicleCategory
+			Catch ex As Exception
+				vehiclecategory = vehiclecategory.RigidTruck
+			End Try
 			If mode = ExecutionMode.Declaration Then
 				Dim doa As DeclarationDataAdapter = New DeclarationDataAdapter()
 
@@ -214,9 +221,9 @@ Public Class Gearbox
 				Catch
 					engine = GetDefaultEngine(gearbox.Gears)
 				End Try
-
+				
 				axlegearData = doa.CreateAxleGearData(gearbox, False)
-				gearboxData = doa.CreateGearboxData(gearbox, engine, axlegearData.AxleGear.Ratio, rdyn, False)
+				gearboxData = doa.CreateGearboxData(gearbox, engine, axlegearData.AxleGear.Ratio, rdyn, vehiclecategory, False)
 			Else
 				Dim doa As EngineeringDataAdapter = New EngineeringDataAdapter()
 				Try
@@ -226,7 +233,7 @@ Public Class Gearbox
 				End Try
 
 				axlegearData = doa.CreateAxleGearData(gearbox, True)
-				gearboxData = doa.CreateGearboxData(gearbox, engine, axlegearData.AxleGear.Ratio, rdyn, True)
+				gearboxData = doa.CreateGearboxData(gearbox, engine, axlegearData.AxleGear.Ratio, rdyn, vehiclecategory, True)
 			End If
 
 			Dim result As IList(Of ValidationResult) =
diff --git a/VectoCommon/VectoCommon/InputData/IInputDataProvider.cs b/VectoCommon/VectoCommon/InputData/IInputDataProvider.cs
index 16cd627535b02621b2ef2a626409cdbcf3b095fa..836135d05d95e69cacff2f26dde7ec2169d3743a 100644
--- a/VectoCommon/VectoCommon/InputData/IInputDataProvider.cs
+++ b/VectoCommon/VectoCommon/InputData/IInputDataProvider.cs
@@ -29,65 +29,65 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System.Xml.Linq;
-
-namespace TUGraz.VectoCommon.InputData
-{
-	public interface IInputDataProvider {}
-
-	public interface IDeclarationInputDataProvider : IInputDataProvider
-	{
-		IDeclarationJobInputData JobInputData();
-
-		IVehicleDeclarationInputData VehicleInputData { get; }
-
-		IAirdragDeclarationInputData AirdragInputData { get; }
-
-		IGearboxDeclarationInputData GearboxInputData { get; }
-
-		ITorqueConverterDeclarationInputData TorqueConverterInputData { get; }
-
-		IAxleGearInputData AxleGearInputData { get; }
-
-		IAngledriveInputData AngledriveInputData { get; }
-
-		IEngineDeclarationInputData EngineInputData { get; }
-
-		IAuxiliariesDeclarationInputData AuxiliaryInputData();
-
-		IRetarderInputData RetarderInputData { get; }
-
-		IDriverDeclarationInputData DriverInputData { get; }
-
-		IPTOTransmissionInputData PTOTransmissionInputData { get; }
-
-		XElement XMLHash { get; }
-	}
-
-	public interface IEngineeringInputDataProvider : IInputDataProvider
-	{
-		IEngineeringJobInputData JobInputData();
-
-		IVehicleEngineeringInputData VehicleInputData { get; }
-
-		IAirdragEngineeringInputData AirdragInputData { get; }
-
-		IGearboxEngineeringInputData GearboxInputData { get; }
-
-		ITorqueConverterEngineeringInputData TorqueConverterInputData { get; }
-
-		IAxleGearInputData AxleGearInputData { get; }
-
-		IAngledriveInputData AngledriveInputData { get; }
-
-		IEngineEngineeringInputData EngineInputData { get; }
-
-		IAuxiliariesEngineeringInputData AuxiliaryInputData();
-
-		IRetarderInputData RetarderInputData { get; }
-
-		IDriverEngineeringInputData DriverInputData { get; }
-
-		IPTOTransmissionInputData PTOTransmissionInputData { get; }
-	}
+using System.Xml.Linq;
+
+namespace TUGraz.VectoCommon.InputData
+{
+	public interface IInputDataProvider {}
+
+	public interface IDeclarationInputDataProvider : IInputDataProvider
+	{
+		IDeclarationJobInputData JobInputData();
+
+		IVehicleDeclarationInputData VehicleInputData { get; }
+
+		IAirdragDeclarationInputData AirdragInputData { get; }
+
+		IGearboxDeclarationInputData GearboxInputData { get; }
+
+		ITorqueConverterDeclarationInputData TorqueConverterInputData { get; }
+
+		IAxleGearInputData AxleGearInputData { get; }
+
+		IAngledriveInputData AngledriveInputData { get; }
+
+		IEngineDeclarationInputData EngineInputData { get; }
+
+		IAuxiliariesDeclarationInputData AuxiliaryInputData();
+
+		IRetarderInputData RetarderInputData { get; }
+
+		IDriverDeclarationInputData DriverInputData { get; }
+
+		IPTOTransmissionInputData PTOTransmissionInputData { get; }
+
+		XElement XMLHash { get; }
+	}
+
+	public interface IEngineeringInputDataProvider : IInputDataProvider
+	{
+		IEngineeringJobInputData JobInputData();
+
+		IVehicleEngineeringInputData VehicleInputData { get; }
+
+		IAirdragEngineeringInputData AirdragInputData { get; }
+
+		IGearboxEngineeringInputData GearboxInputData { get; }
+
+		ITorqueConverterEngineeringInputData TorqueConverterInputData { get; }
+
+		IAxleGearInputData AxleGearInputData { get; }
+
+		IAngledriveInputData AngledriveInputData { get; }
+
+		IEngineEngineeringInputData EngineInputData { get; }
+
+		IAuxiliariesEngineeringInputData AuxiliaryInputData();
+
+		IRetarderInputData RetarderInputData { get; }
+
+		IDriverEngineeringInputData DriverInputData { get; }
+
+		IPTOTransmissionInputData PTOTransmissionInputData { get; }
+	}
 }
\ No newline at end of file
diff --git a/VectoCommon/VectoCommon/Models/VehicleCategory.cs b/VectoCommon/VectoCommon/Models/VehicleCategory.cs
index af6baf04d0637013b03aae01d733db3a9bf0817f..8c59130ffc0d0278926eca1996c539f866c14062 100644
--- a/VectoCommon/VectoCommon/Models/VehicleCategory.cs
+++ b/VectoCommon/VectoCommon/Models/VehicleCategory.cs
@@ -29,72 +29,87 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-
-namespace TUGraz.VectoCommon.Models
-{
-	public enum VehicleCategory
-	{
-		RigidTruck,
-		Tractor,
-		CityBus,
-		InterurbanBus,
-		Coach
-	}
-
-	public static class VehicleCategoryHelper
-	{
-		public static string GetLabel(this VehicleCategory category)
-		{
-			switch (category)
-			{
-				case VehicleCategory.RigidTruck:
-					return "Rigid Truck";
-				case VehicleCategory.Tractor:
-					return "Tractor";
-				case VehicleCategory.CityBus:
-					return "City Bus";
-				case VehicleCategory.InterurbanBus:
-					return "Interurban Bus";
-				case VehicleCategory.Coach:
-					return "Coach";
-				default:
-					return category.ToString();
-			}
-		}
-		public static string GetCategoryName(this VehicleCategory category)
-		{
-			switch (category) {
-				case VehicleCategory.RigidTruck:
-					return "Rigid Truck";
-				case VehicleCategory.Tractor:
-					return "Semitrailer Truck";
-				case VehicleCategory.CityBus:
-					return "Citybus";
-				case VehicleCategory.InterurbanBus:
-					return "Interurban Bus";
-				case VehicleCategory.Coach:
-					return "Coach";
-				default:
-					return category.ToString();
-			}
-		}
-
-		public static string ToXMLFormat(this VehicleCategory vehicleCategory)
-		{
-			switch (vehicleCategory) {
-				case VehicleCategory.Coach:
-				case VehicleCategory.Tractor:
-					return vehicleCategory.ToString();
-				case VehicleCategory.CityBus:
-					return "City Bus";
-				case VehicleCategory.InterurbanBus:
-					return "Interurban Bus";
-				case VehicleCategory.RigidTruck:
-					return "Rigid Truck";
-				default:
-					throw new ArgumentOutOfRangeException("vehicleCategory", vehicleCategory, null);
-			}
-		}
-	}
+using System;
+
+namespace TUGraz.VectoCommon.Models
+{
+	public enum VehicleCategory
+	{
+		RigidTruck,
+		Tractor,
+		CityBus,
+		InterurbanBus,
+		Coach
+	}
+
+	public static class VehicleCategoryHelper
+	{
+		public static string GetLabel(this VehicleCategory category)
+		{
+			switch (category) {
+				case VehicleCategory.RigidTruck:
+					return "Rigid Truck";
+				case VehicleCategory.Tractor:
+					return "Tractor";
+				case VehicleCategory.CityBus:
+					return "City Bus";
+				case VehicleCategory.InterurbanBus:
+					return "Interurban Bus";
+				case VehicleCategory.Coach:
+					return "Coach";
+				default:
+					return category.ToString();
+			}
+		}
+
+		public static string GetCategoryName(this VehicleCategory category)
+		{
+			switch (category) {
+				case VehicleCategory.RigidTruck:
+					return "Rigid Truck";
+				case VehicleCategory.Tractor:
+					return "Semitrailer Truck";
+				case VehicleCategory.CityBus:
+					return "Citybus";
+				case VehicleCategory.InterurbanBus:
+					return "Interurban Bus";
+				case VehicleCategory.Coach:
+					return "Coach";
+				default:
+					return category.ToString();
+			}
+		}
+
+		public static string ToXMLFormat(this VehicleCategory vehicleCategory)
+		{
+			switch (vehicleCategory) {
+				case VehicleCategory.Coach:
+				case VehicleCategory.Tractor:
+					return vehicleCategory.ToString();
+				case VehicleCategory.CityBus:
+					return "City Bus";
+				case VehicleCategory.InterurbanBus:
+					return "Interurban Bus";
+				case VehicleCategory.RigidTruck:
+					return "Rigid Truck";
+				default:
+					throw new ArgumentOutOfRangeException("vehicleCategory", vehicleCategory, null);
+			}
+		}
+
+		public static bool IsTruck(this VehicleCategory category)
+		{
+			switch (category) {
+				case VehicleCategory.RigidTruck:
+				case VehicleCategory.Tractor:
+					return true;
+				case VehicleCategory.CityBus:
+				case VehicleCategory.InterurbanBus:
+				case VehicleCategory.Coach:
+					return false;
+				default:
+					throw new ArgumentOutOfRangeException("VehicleCategory", category, null);
+			}
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONComponentInputData.cs b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONComponentInputData.cs
index c31323bed471769f058132d46d28ceb7114923e3..53f64fc8c4ea957001a627be8194ec63a575b602 100644
--- a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONComponentInputData.cs
+++ b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONComponentInputData.cs
@@ -29,160 +29,160 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using System.IO;
-using System.Xml.Linq;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.Utils;
-
-namespace TUGraz.VectoCore.InputData.FileIO.JSON
-{
-	public class JSONComponentInputData : IEngineeringInputDataProvider, IDeclarationInputDataProvider
-	{
-		protected IGearboxEngineeringInputData Gearbox;
-		protected IAxleGearInputData AxleGear;
-		protected ITorqueConverterEngineeringInputData TorqueConverter;
-		protected IAngledriveInputData Angledrive;
-		protected IEngineEngineeringInputData Engine;
-		protected IVehicleEngineeringInputData VehicleData;
-		protected IRetarderInputData Retarder;
-		protected IPTOTransmissionInputData PTOTransmission;
-		private IAirdragEngineeringInputData AirdragData;
-
-
-		public JSONComponentInputData(string filename, bool tolerateMissing = false)
-		{
-			var extension = Path.GetExtension(filename);
-			object tmp = null;
-			switch (extension) {
-				case Constants.FileExtensions.VehicleDataFile:
-					tmp = JSONInputDataFactory.ReadJsonVehicle(filename, tolerateMissing);
-					break;
-				case Constants.FileExtensions.EngineDataFile:
-					tmp = JSONInputDataFactory.ReadEngine(filename, tolerateMissing);
-					break;
-				case Constants.FileExtensions.GearboxDataFile:
-					tmp = JSONInputDataFactory.ReadGearbox(filename, tolerateMissing);
-					break;
-			}
-			tmp.Switch()
-				.If<IVehicleEngineeringInputData>(c => VehicleData = c)
-				.If<IAirdragEngineeringInputData>(c => AirdragData = c)
-				.If<IEngineEngineeringInputData>(c => Engine = c)
-				.If<IGearboxEngineeringInputData>(c => Gearbox = c)
-				.If<IAxleGearInputData>(c => AxleGear = c)
-				.If<IRetarderInputData>(c => Retarder = c)
-				.If<ITorqueConverterEngineeringInputData>(c => TorqueConverter = c)
-				.If<IAngledriveInputData>(c => Angledrive = c)
-				.If<IPTOTransmissionInputData>(c => PTOTransmission = c);
-		}
-
-
-		public IEngineeringJobInputData JobInputData()
-		{
-			throw new NotImplementedException();
-		}
-
-
-		IVehicleDeclarationInputData IDeclarationInputDataProvider.VehicleInputData
-		{
-			get { return VehicleData; }
-		}
-
-		IAirdragDeclarationInputData IDeclarationInputDataProvider.AirdragInputData
-		{
-			get { return AirdragInputData; }
-		}
-
-		public IAirdragEngineeringInputData AirdragInputData
-		{
-			get { return AirdragData; }
-		}
-
-		IGearboxDeclarationInputData IDeclarationInputDataProvider.GearboxInputData
-		{
-			get { return GearboxInputData; }
-		}
-
-		ITorqueConverterDeclarationInputData IDeclarationInputDataProvider.TorqueConverterInputData
-		{
-			get { return TorqueConverterInputData; }
-		}
-
-		IDeclarationJobInputData IDeclarationInputDataProvider.JobInputData()
-		{
-			throw new NotImplementedException();
-		}
-
-		public IVehicleEngineeringInputData VehicleInputData
-		{
-			get { return VehicleData; }
-		}
-
-		public IGearboxEngineeringInputData GearboxInputData
-		{
-			get { return Gearbox; }
-		}
-
-		public ITorqueConverterEngineeringInputData TorqueConverterInputData
-		{
-			get { return TorqueConverter; }
-		}
-
-		public IAxleGearInputData AxleGearInputData
-		{
-			get { return AxleGear; }
-		}
-
-		public IAngledriveInputData AngledriveInputData
-		{
-			get { return Angledrive; }
-		}
-
-		IEngineDeclarationInputData IDeclarationInputDataProvider.EngineInputData
-		{
-			get { return EngineInputData; }
-		}
-
-		public IEngineEngineeringInputData EngineInputData
-		{
-			get { return Engine; }
-		}
-
-		public IAuxiliariesEngineeringInputData AuxiliaryInputData()
-		{
-			throw new NotImplementedException();
-		}
-
-		IAuxiliariesDeclarationInputData IDeclarationInputDataProvider.AuxiliaryInputData()
-		{
-			throw new NotImplementedException();
-		}
-
-		public IRetarderInputData RetarderInputData
-		{
-			get { return Retarder; }
-		}
-
-		IDriverDeclarationInputData IDeclarationInputDataProvider.DriverInputData
-		{
-			get { throw new NotImplementedException(); }
-		}
-
-		public IDriverEngineeringInputData DriverInputData
-		{
-			get { throw new NotImplementedException(); }
-		}
-
-		public IPTOTransmissionInputData PTOTransmissionInputData
-		{
-			get { return PTOTransmission; }
-		}
-
-		public XElement XMLHash
-		{
-			get { return null; }
-		}
-	}
+using System;
+using System.IO;
+using System.Xml.Linq;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	public class JSONComponentInputData : IEngineeringInputDataProvider, IDeclarationInputDataProvider
+	{
+		protected IGearboxEngineeringInputData Gearbox;
+		protected IAxleGearInputData AxleGear;
+		protected ITorqueConverterEngineeringInputData TorqueConverter;
+		protected IAngledriveInputData Angledrive;
+		protected IEngineEngineeringInputData Engine;
+		protected IVehicleEngineeringInputData VehicleData;
+		protected IRetarderInputData Retarder;
+		protected IPTOTransmissionInputData PTOTransmission;
+		private IAirdragEngineeringInputData AirdragData;
+
+
+		public JSONComponentInputData(string filename, bool tolerateMissing = false)
+		{
+			var extension = Path.GetExtension(filename);
+			object tmp = null;
+			switch (extension) {
+				case Constants.FileExtensions.VehicleDataFile:
+					tmp = JSONInputDataFactory.ReadJsonVehicle(filename, tolerateMissing);
+					break;
+				case Constants.FileExtensions.EngineDataFile:
+					tmp = JSONInputDataFactory.ReadEngine(filename, tolerateMissing);
+					break;
+				case Constants.FileExtensions.GearboxDataFile:
+					tmp = JSONInputDataFactory.ReadGearbox(filename, tolerateMissing);
+					break;
+			}
+			tmp.Switch()
+				.If<IVehicleEngineeringInputData>(c => VehicleData = c)
+				.If<IAirdragEngineeringInputData>(c => AirdragData = c)
+				.If<IEngineEngineeringInputData>(c => Engine = c)
+				.If<IGearboxEngineeringInputData>(c => Gearbox = c)
+				.If<IAxleGearInputData>(c => AxleGear = c)
+				.If<IRetarderInputData>(c => Retarder = c)
+				.If<ITorqueConverterEngineeringInputData>(c => TorqueConverter = c)
+				.If<IAngledriveInputData>(c => Angledrive = c)
+				.If<IPTOTransmissionInputData>(c => PTOTransmission = c);
+		}
+
+
+		public IEngineeringJobInputData JobInputData()
+		{
+			throw new NotImplementedException();
+		}
+
+
+		IVehicleDeclarationInputData IDeclarationInputDataProvider.VehicleInputData
+		{
+			get { return VehicleData; }
+		}
+
+		IAirdragDeclarationInputData IDeclarationInputDataProvider.AirdragInputData
+		{
+			get { return AirdragInputData; }
+		}
+
+		public IAirdragEngineeringInputData AirdragInputData
+		{
+			get { return AirdragData; }
+		}
+
+		IGearboxDeclarationInputData IDeclarationInputDataProvider.GearboxInputData
+		{
+			get { return GearboxInputData; }
+		}
+
+		ITorqueConverterDeclarationInputData IDeclarationInputDataProvider.TorqueConverterInputData
+		{
+			get { return TorqueConverterInputData; }
+		}
+
+		IDeclarationJobInputData IDeclarationInputDataProvider.JobInputData()
+		{
+			throw new NotImplementedException();
+		}
+
+		public IVehicleEngineeringInputData VehicleInputData
+		{
+			get { return VehicleData; }
+		}
+
+		public IGearboxEngineeringInputData GearboxInputData
+		{
+			get { return Gearbox; }
+		}
+
+		public ITorqueConverterEngineeringInputData TorqueConverterInputData
+		{
+			get { return TorqueConverter; }
+		}
+
+		public IAxleGearInputData AxleGearInputData
+		{
+			get { return AxleGear; }
+		}
+
+		public IAngledriveInputData AngledriveInputData
+		{
+			get { return Angledrive; }
+		}
+
+		IEngineDeclarationInputData IDeclarationInputDataProvider.EngineInputData
+		{
+			get { return EngineInputData; }
+		}
+
+		public IEngineEngineeringInputData EngineInputData
+		{
+			get { return Engine; }
+		}
+
+		public IAuxiliariesEngineeringInputData AuxiliaryInputData()
+		{
+			throw new NotImplementedException();
+		}
+
+		IAuxiliariesDeclarationInputData IDeclarationInputDataProvider.AuxiliaryInputData()
+		{
+			throw new NotImplementedException();
+		}
+
+		public IRetarderInputData RetarderInputData
+		{
+			get { return Retarder; }
+		}
+
+		IDriverDeclarationInputData IDeclarationInputDataProvider.DriverInputData
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		public IDriverEngineeringInputData DriverInputData
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		public IPTOTransmissionInputData PTOTransmissionInputData
+		{
+			get { return PTOTransmission; }
+		}
+
+		public XElement XMLHash
+		{
+			get { return null; }
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONEngineData.cs b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONEngineData.cs
index bf8d8e57a5c19e2e4b8aaed3ac557377677a299c..d1cb4311b329be30216f3717c71a7d936d68dbfe 100644
--- a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONEngineData.cs
+++ b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONEngineData.cs
@@ -29,231 +29,231 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using System.IO;
-using Newtonsoft.Json.Linq;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-
-namespace TUGraz.VectoCore.InputData.FileIO.JSON
-{
-	/// <summary>
-	///     Represents the CombustionEngineData. Fileformat: .veng
-	/// </summary>
-	/// <code>
-	/// {
-	///  "Header": {
-	///    "CreatedBy": " ()",
-	///    "Date": "3/4/2015 12:26:24 PM",
-	///    "AppVersion": "2.0.4-beta3",
-	///    "FileVersion": 2
-	///  },
-	///  "Body": {
-	///    "SavedInDeclMode": false,
-	///    "ModelName": "Generic 24t Coach",
-	///    "Displacement": 12730.0,
-	///    "IdlingSpeed": 560.0,
-	///    "Inertia": 3.8,
-	///    "FullLoadCurves": [
-	///      {
-	///        "Path": "24t Coach.vfld",
-	///        "Gears": "0 - 99"
-	///      }
-	///    ],
-	///    "FuelMap": "24t Coach.vmap",
-	///    "WHTC-Urban": 0.0,
-	///    "WHTC-Rural": 0.0,
-	///    "WHTC-Motorway": 0.0
-	///  }
-	/// }
-	/// </code>
-	public class JSONEngineDataV4 : JSONEngineDataV3
-	{
-		public JSONEngineDataV4(JObject data, string fileName, bool tolerateMissing = false)
-			: base(data, fileName, tolerateMissing) {}
-
-		public override Watt RatedPowerDeclared
-		{
-			get { return Body.GetEx<double>("RatedPower").SI<Watt>(); }
-		}
-
-		public override PerSecond RatedSpeedDeclared
-		{
-			get { return Body.GetEx<double>("RatedSpeed").RPMtoRad(); }
-		}
-
-		public override NewtonMeter MaxTorqueDeclared
-		{
-			get { return Body.GetEx<double>("MaxTorque").SI<NewtonMeter>(); }
-		}
-
-		public override double CorrectionFactorRegPer
-		{
-			get { return Body.GetEx<double>("CFRegPer"); }
-		}
-
-
-		public override double CorrectionFactorNCV
-		{
-			get { return Body.GetEx<double>("CFNCV"); }
-		}
-
-		public override FuelType FuelType
-		{
-			get { return Body.GetEx<string>("FuelType").ParseEnum<FuelType>(); }
-		}
-	}
-
-
-	public class JSONEngineDataV3 : JSONFile, IEngineEngineeringInputData
-	{
-		public JSONEngineDataV3(JObject data, string fileName, bool tolerateMissing = false)
-			: base(data, fileName, tolerateMissing) {}
-
-		public virtual CubicMeter Displacement
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_Displacement).SI().Cubic.Centi.Meter.Cast<CubicMeter>(); }
-			// convert vom ccm to m^3}
-		}
-
-		public virtual PerSecond IdleSpeed
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_IdleSpeed).RPMtoRad(); }
-		}
-
-
-		public virtual FuelType FuelType
-		{
-			get { return FuelType.DieselCI; }
-		}
-
-		public virtual TableData FuelConsumptionMap
-		{
-			get {
-				try {
-					return ReadTableData(Body.GetEx<string>(JsonKeys.Engine_FuelConsumptionMap), "FuelConsumptionMap");
-				} catch (Exception) {
-					if (!TolerateMissing) {
-						throw;
-					}
-					return
-						new TableData(Path.Combine(BasePath, Body[JsonKeys.Engine_FuelConsumptionMap].ToString()) + MissingFileSuffix,
-							DataSourceType.Missing);
-				}
-			}
-		}
-
-		public virtual TableData FullLoadCurve
-		{
-			get {
-				try {
-					return ReadTableData(Body.GetEx<string>(JsonKeys.Engine_FullLoadCurveFile), "FullLoadCurve");
-				} catch (Exception) {
-					if (!TolerateMissing) {
-						throw;
-					}
-					return new TableData(
-						Path.Combine(BasePath, Body[JsonKeys.Engine_FullLoadCurveFile].ToString()) + MissingFileSuffix,
-						DataSourceType.Missing);
-				}
-			}
-		}
-
-		public virtual Watt RatedPowerDeclared
-		{
-			get { return 0.SI<Watt>(); }
-		}
-
-		public virtual PerSecond RatedSpeedDeclared
-		{
-			get { return 0.RPMtoRad(); }
-		}
-
-		public virtual NewtonMeter MaxTorqueDeclared
-		{
-			get { return 0.SI<NewtonMeter>(); }
-		}
-
-		public virtual KilogramSquareMeter Inertia
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_Inertia).SI<KilogramSquareMeter>(); }
-		}
-
-		public virtual double WHTCEngineering
-		{
-			get {
-				if (Body["WHTC-Engineering"] == null) {
-					return 1;
-				}
-				return Body.GetEx<double>("WHTC-Engineering");
-			}
-		}
-
-		public virtual double WHTCMotorway
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Motorway); }
-		}
-
-		public virtual double WHTCRural
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Rural); }
-		}
-
-		public virtual double WHTCUrban
-		{
-			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Urban); }
-		}
-
-		public double ColdHotBalancingFactor
-		{
-			get {
-				if (Body["ColdHotBalancingFactor"] == null) {
-					return 1.0;
-				}
-				return Body.GetEx<double>("ColdHotBalancingFactor");
-			}
-		}
-
-		public virtual double CorrectionFactorRegPer
-		{
-			get { return 1; }
-		}
-
-		public virtual double CorrectionFactorNCV
-		{
-			get { return 1; }
-		}
-
-		public string Manufacturer
-		{
-			get { return "N/A"; }
-		}
-
-		public string Model
-		{
-			get { return Body.GetEx<string>(JsonKeys.Engine_ModelName); }
-		}
-
-
-		public string Date
-		{
-			get { return "N/A"; }
-		}
-
-		public CertificationMethod CertificationMethod
-		{
-			get { return CertificationMethod.NotCertified; }
-		}
-
-		public string CertificationNumber
-		{
-			get { return "N/A"; }
-		}
-
-		public string DigestValue
-		{
-			get { return "N/A"; }
-		}
-	}
+using System;
+using System.IO;
+using Newtonsoft.Json.Linq;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	/// <summary>
+	///     Represents the CombustionEngineData. Fileformat: .veng
+	/// </summary>
+	/// <code>
+	/// {
+	///  "Header": {
+	///    "CreatedBy": " ()",
+	///    "Date": "3/4/2015 12:26:24 PM",
+	///    "AppVersion": "2.0.4-beta3",
+	///    "FileVersion": 2
+	///  },
+	///  "Body": {
+	///    "SavedInDeclMode": false,
+	///    "ModelName": "Generic 24t Coach",
+	///    "Displacement": 12730.0,
+	///    "IdlingSpeed": 560.0,
+	///    "Inertia": 3.8,
+	///    "FullLoadCurves": [
+	///      {
+	///        "Path": "24t Coach.vfld",
+	///        "Gears": "0 - 99"
+	///      }
+	///    ],
+	///    "FuelMap": "24t Coach.vmap",
+	///    "WHTC-Urban": 0.0,
+	///    "WHTC-Rural": 0.0,
+	///    "WHTC-Motorway": 0.0
+	///  }
+	/// }
+	/// </code>
+	public class JSONEngineDataV4 : JSONEngineDataV3
+	{
+		public JSONEngineDataV4(JObject data, string fileName, bool tolerateMissing = false)
+			: base(data, fileName, tolerateMissing) {}
+
+		public override Watt RatedPowerDeclared
+		{
+			get { return Body.GetEx<double>("RatedPower").SI<Watt>(); }
+		}
+
+		public override PerSecond RatedSpeedDeclared
+		{
+			get { return Body.GetEx<double>("RatedSpeed").RPMtoRad(); }
+		}
+
+		public override NewtonMeter MaxTorqueDeclared
+		{
+			get { return Body.GetEx<double>("MaxTorque").SI<NewtonMeter>(); }
+		}
+
+		public override double CorrectionFactorRegPer
+		{
+			get { return Body.GetEx<double>("CFRegPer"); }
+		}
+
+
+		public override double CorrectionFactorNCV
+		{
+			get { return Body.GetEx<double>("CFNCV"); }
+		}
+
+		public override FuelType FuelType
+		{
+			get { return Body.GetEx<string>("FuelType").ParseEnum<FuelType>(); }
+		}
+	}
+
+
+	public class JSONEngineDataV3 : JSONFile, IEngineEngineeringInputData
+	{
+		public JSONEngineDataV3(JObject data, string fileName, bool tolerateMissing = false)
+			: base(data, fileName, tolerateMissing) {}
+
+		public virtual CubicMeter Displacement
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_Displacement).SI().Cubic.Centi.Meter.Cast<CubicMeter>(); }
+			// convert vom ccm to m^3}
+		}
+
+		public virtual PerSecond IdleSpeed
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_IdleSpeed).RPMtoRad(); }
+		}
+
+
+		public virtual FuelType FuelType
+		{
+			get { return FuelType.DieselCI; }
+		}
+
+		public virtual TableData FuelConsumptionMap
+		{
+			get {
+				try {
+					return ReadTableData(Body.GetEx<string>(JsonKeys.Engine_FuelConsumptionMap), "FuelConsumptionMap");
+				} catch (Exception) {
+					if (!TolerateMissing) {
+						throw;
+					}
+					return
+						new TableData(Path.Combine(BasePath, Body[JsonKeys.Engine_FuelConsumptionMap].ToString()) + MissingFileSuffix,
+							DataSourceType.Missing);
+				}
+			}
+		}
+
+		public virtual TableData FullLoadCurve
+		{
+			get {
+				try {
+					return ReadTableData(Body.GetEx<string>(JsonKeys.Engine_FullLoadCurveFile), "FullLoadCurve");
+				} catch (Exception) {
+					if (!TolerateMissing) {
+						throw;
+					}
+					return new TableData(
+						Path.Combine(BasePath, Body[JsonKeys.Engine_FullLoadCurveFile].ToString()) + MissingFileSuffix,
+						DataSourceType.Missing);
+				}
+			}
+		}
+
+		public virtual Watt RatedPowerDeclared
+		{
+			get { return 0.SI<Watt>(); }
+		}
+
+		public virtual PerSecond RatedSpeedDeclared
+		{
+			get { return 0.RPMtoRad(); }
+		}
+
+		public virtual NewtonMeter MaxTorqueDeclared
+		{
+			get { return 0.SI<NewtonMeter>(); }
+		}
+
+		public virtual KilogramSquareMeter Inertia
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_Inertia).SI<KilogramSquareMeter>(); }
+		}
+
+		public virtual double WHTCEngineering
+		{
+			get {
+				if (Body["WHTC-Engineering"] == null) {
+					return 1;
+				}
+				return Body.GetEx<double>("WHTC-Engineering");
+			}
+		}
+
+		public virtual double WHTCMotorway
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Motorway); }
+		}
+
+		public virtual double WHTCRural
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Rural); }
+		}
+
+		public virtual double WHTCUrban
+		{
+			get { return Body.GetEx<double>(JsonKeys.Engine_WHTC_Urban); }
+		}
+
+		public double ColdHotBalancingFactor
+		{
+			get {
+				if (Body["ColdHotBalancingFactor"] == null) {
+					return 1.0;
+				}
+				return Body.GetEx<double>("ColdHotBalancingFactor");
+			}
+		}
+
+		public virtual double CorrectionFactorRegPer
+		{
+			get { return 1; }
+		}
+
+		public virtual double CorrectionFactorNCV
+		{
+			get { return 1; }
+		}
+
+		public string Manufacturer
+		{
+			get { return "N/A"; }
+		}
+
+		public string Model
+		{
+			get { return Body.GetEx<string>(JsonKeys.Engine_ModelName); }
+		}
+
+
+		public string Date
+		{
+			get { return "N/A"; }
+		}
+
+		public CertificationMethod CertificationMethod
+		{
+			get { return CertificationMethod.NotCertified; }
+		}
+
+		public string CertificationNumber
+		{
+			get { return "N/A"; }
+		}
+
+		public string DigestValue
+		{
+			get { return "N/A"; }
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputDataFactory.cs b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputDataFactory.cs
index c406af6f577cce116208b59668c8b6012643e388..84520f0a606ea9de508fb2a5a096b860c97d0320 100644
--- a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputDataFactory.cs
+++ b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputDataFactory.cs
@@ -29,96 +29,96 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using System.IO;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCore.Configuration;
-
-namespace TUGraz.VectoCore.InputData.FileIO.JSON
-{
-	// ReSharper disable once InconsistentNaming
-	public static class JSONInputDataFactory
-	{
-		internal static JObject ReadFile(string fileName)
-		{
-			if (!File.Exists(fileName)) {
-				throw new FileNotFoundException("failed to load file: " + fileName, fileName);
-			}
-			using (var reader = File.OpenText(fileName)) {
-				return (JObject)JToken.ReadFrom(new JsonTextReader(reader));
-			}
-		}
-
-		public static IInputDataProvider ReadComponentData(string filename)
-		{
-			if (Constants.FileExtensions.VectoJobFile.Equals(Path.GetExtension(filename), StringComparison.OrdinalIgnoreCase)) {
-				return ReadJsonJob(filename, true);
-			}
-			return new JSONComponentInputData(filename, true);
-		}
-
-		public static IInputDataProvider ReadJsonJob(string filename, bool tolerateMissing = false)
-		{
-			var json = ReadFile(filename);
-			var version = ReadVersion(json);
-
-			switch (version) {
-				case 2:
-					return new JSONInputDataV2(json, filename, tolerateMissing);
-				case 3:
-					return new JSONInputDataV3(json, filename, tolerateMissing);
-				default:
-					throw new VectoException("Job-File: Unsupported FileVersion. Got: {0} ", version);
-			}
-		}
-
-		public static IVehicleEngineeringInputData ReadJsonVehicle(string filename, bool tolerateMissing = false)
-		{
-			var json = ReadFile(filename);
-			var version = ReadVersion(json);
-			switch (version) {
-				case 7:
-					return new JSONVehicleDataV7(json, filename, tolerateMissing);
-				default:
-					throw new VectoException("Vehicle-File: Unsupported FileVersion. Got {0}", version);
-			}
-		}
-
-		public static IGearboxEngineeringInputData ReadGearbox(string filename, bool tolerateMissing = false)
-		{
-			var json = ReadFile(filename);
-			var version = ReadVersion(json);
-			switch (version) {
-				case 5:
-					return new JSONGearboxDataV5(json, filename, tolerateMissing);
-				case 6:
-					return new JSONGearboxDataV6(json, filename, tolerateMissing);
-				default:
-					throw new VectoException("Gearbox-File: Unsupported FileVersion. Got {0}", version);
-			}
-		}
-
-		public static IEngineEngineeringInputData ReadEngine(string filename, bool tolerateMissing = false)
-		{
-			var json = ReadFile(filename);
-			var version = ReadVersion(json);
-			switch (version) {
-				case 3:
-					return new JSONEngineDataV3(json, filename, tolerateMissing);
-				case 4:
-					return new JSONEngineDataV4(json, filename, tolerateMissing);
-				default:
-					throw new VectoException("Engine-File: Unsupported FileVersion. Got {0}", version);
-			}
-		}
-
-		private static int ReadVersion(JObject json)
-		{
-			var value = json.GetEx(JsonKeys.JsonHeader).GetEx<string>(JsonKeys.JsonHeader_FileVersion);
-			return (int)double.Parse(value.Trim('"'));
-		}
-	}
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.IO;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Configuration;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	// ReSharper disable once InconsistentNaming
+	public static class JSONInputDataFactory
+	{
+		internal static JObject ReadFile(string fileName)
+		{
+			if (!File.Exists(fileName)) {
+				throw new FileNotFoundException("failed to load file: " + fileName, fileName);
+			}
+			using (var reader = File.OpenText(fileName)) {
+				return (JObject)JToken.ReadFrom(new JsonTextReader(reader));
+			}
+		}
+
+		public static IInputDataProvider ReadComponentData(string filename)
+		{
+			if (Constants.FileExtensions.VectoJobFile.Equals(Path.GetExtension(filename), StringComparison.OrdinalIgnoreCase)) {
+				return ReadJsonJob(filename, true);
+			}
+			return new JSONComponentInputData(filename, true);
+		}
+
+		public static IInputDataProvider ReadJsonJob(string filename, bool tolerateMissing = false)
+		{
+			var json = ReadFile(filename);
+			var version = ReadVersion(json);
+
+			switch (version) {
+				case 2:
+					return new JSONInputDataV2(json, filename, tolerateMissing);
+				case 3:
+					return new JSONInputDataV3(json, filename, tolerateMissing);
+				default:
+					throw new VectoException("Job-File: Unsupported FileVersion. Got: {0} ", version);
+			}
+		}
+
+		public static IVehicleEngineeringInputData ReadJsonVehicle(string filename, bool tolerateMissing = false)
+		{
+			var json = ReadFile(filename);
+			var version = ReadVersion(json);
+			switch (version) {
+				case 7:
+					return new JSONVehicleDataV7(json, filename, tolerateMissing);
+				default:
+					throw new VectoException("Vehicle-File: Unsupported FileVersion. Got {0}", version);
+			}
+		}
+
+		public static IGearboxEngineeringInputData ReadGearbox(string filename, bool tolerateMissing = false)
+		{
+			var json = ReadFile(filename);
+			var version = ReadVersion(json);
+			switch (version) {
+				case 5:
+					return new JSONGearboxDataV5(json, filename, tolerateMissing);
+				case 6:
+					return new JSONGearboxDataV6(json, filename, tolerateMissing);
+				default:
+					throw new VectoException("Gearbox-File: Unsupported FileVersion. Got {0}", version);
+			}
+		}
+
+		public static IEngineEngineeringInputData ReadEngine(string filename, bool tolerateMissing = false)
+		{
+			var json = ReadFile(filename);
+			var version = ReadVersion(json);
+			switch (version) {
+				case 3:
+					return new JSONEngineDataV3(json, filename, tolerateMissing);
+				case 4:
+					return new JSONEngineDataV4(json, filename, tolerateMissing);
+				default:
+					throw new VectoException("Engine-File: Unsupported FileVersion. Got {0}", version);
+			}
+		}
+
+		private static int ReadVersion(JObject json)
+		{
+			var value = json.GetEx(JsonKeys.JsonHeader).GetEx<string>(JsonKeys.JsonHeader_FileVersion);
+			return (int)double.Parse(value.Trim('"'));
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
index df3cc851b0f88cd2f4cdf8f25c335d2f749a7280..fb3702ba23ee5b202ef6ddbbf0bfbf8bc5d45f19 100644
--- a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
+++ b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
@@ -29,450 +29,450 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.InputData.Reader.ComponentData;
-using TUGraz.VectoCore.Models.Declaration;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
-using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
-using TUGraz.VectoCore.OutputData;
-using TUGraz.VectoCore.Utils;
-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
-{
-	public class DeclarationDataAdapter : AbstractSimulationDataAdapter
-	{
-		public DriverData CreateDriverData(IDriverDeclarationInputData data)
-		{
-			if (!data.SavedInDeclarationMode) {
-				WarnDeclarationMode("DriverData");
-			}
-			var lookAheadData = new DriverData.LACData {
-				Enabled = DeclarationData.Driver.LookAhead.Enabled,
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+using TUGraz.VectoCore.OutputData;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
+{
+	public class DeclarationDataAdapter : AbstractSimulationDataAdapter
+	{
+		public DriverData CreateDriverData(IDriverDeclarationInputData data)
+		{
+			if (!data.SavedInDeclarationMode) {
+				WarnDeclarationMode("DriverData");
+			}
+			var lookAheadData = new DriverData.LACData {
+				Enabled = DeclarationData.Driver.LookAhead.Enabled,
 				//Deceleration = DeclarationData.Driver.LookAhead.Deceleration,
-				MinSpeed = DeclarationData.Driver.LookAhead.MinimumSpeed,
-				LookAheadDecisionFactor = new LACDecisionFactor(),
-				LookAheadDistanceFactor = DeclarationData.Driver.LookAhead.LookAheadDistanceFactor,
-			};
-			var overspeedData = new DriverData.OverSpeedEcoRollData {
-				Mode = data.OverSpeedEcoRoll.Mode,
-				MinSpeed = DeclarationData.Driver.OverSpeedEcoRoll.MinSpeed,
-				OverSpeed = DeclarationData.Driver.OverSpeedEcoRoll.OverSpeed,
-				UnderSpeed = DeclarationData.Driver.OverSpeedEcoRoll.UnderSpeed
-			};
-			if (!DeclarationData.Driver.OverSpeedEcoRoll.AllowedModes.Contains(overspeedData.Mode)) {
-				throw new VectoSimulationException(
-					"Specified Overspeed/EcoRoll Mode not allowed in declaration mode! {0}",
-					overspeedData.Mode);
-			}
-			var retVal = new DriverData {
-				LookAheadCoasting = lookAheadData,
-				OverSpeedEcoRoll = overspeedData,
-			};
-			return retVal;
-		}
-
-		internal VehicleData CreateVehicleData(IVehicleDeclarationInputData data, Mission mission, Kilogram loading,
-			Kilogram municipalBodyWeight)
-		{
-			if (!data.SavedInDeclarationMode) {
-				WarnDeclarationMode("VehicleData");
-			}
-
-			var retVal = SetCommonVehicleData(data);
-			retVal.VIN = data.VIN;
-			retVal.ManufacturerAddress = data.ManufacturerAddress;
-			retVal.LegislativeClass = data.LegislativeClass;
-			retVal.TrailerGrossVehicleWeight = mission.Trailer.Sum(t => t.TrailerGrossVehicleWeight).DefaultIfNull(0);
-
-			retVal.BodyAndTrailerWeight = (mission.MissionType == MissionType.MunicipalUtility
-				? municipalBodyWeight
-				: mission.BodyCurbWeight) + mission.Trailer.Sum(t => t.TrailerCurbWeight).DefaultIfNull(0);
-			//retVal.CurbWeight += retVal.BodyAndTrailerWeight;
-
-			retVal.Loading = loading;
-			var drivenIndex = DrivenAxleIndex(data.Axles);
-			retVal.DynamicTyreRadius =
-				DeclarationData.Wheels.Lookup(data.Axles[drivenIndex].Wheels).DynamicTyreRadius;
-			retVal.CargoVolume = mission.MissionType != MissionType.Construction ? mission.TotalCargoVolume : 0.SI<CubicMeter>();
-
-
-			var axles = data.Axles;
-			if (axles.Count < mission.AxleWeightDistribution.Length) {
-				throw new VectoException("Vehicle does not contain sufficient axles. {0} axles defined, {1} axles required",
-					data.Axles.Count, mission.AxleWeightDistribution.Length);
-			}
-			var axleData = new List<Axle>();
-			for (var i = 0; i < mission.AxleWeightDistribution.Length; i++) {
-				var axleInput = axles[i];
-				var axle = new Axle {
-					WheelsDimension = axleInput.Wheels,
-					AxleType = axleInput.AxleType,
-					AxleWeightShare = mission.AxleWeightDistribution[i],
-					TwinTyres = axleInput.TwinTyres,
-					RollResistanceCoefficient = axleInput.RollResistanceCoefficient,
-					TyreTestLoad = axleInput.TyreTestLoad,
-					Inertia = DeclarationData.Wheels.Lookup(axleInput.Wheels.RemoveWhitespace()).Inertia,
-				};
-				axleData.Add(axle);
-			}
-
-			foreach (var trailer in mission.Trailer) {
-				axleData.AddRange(trailer.TrailerWheels.Select(trailerWheel => new Axle {
-					AxleType = AxleType.Trailer,
-					AxleWeightShare = trailer.TrailerAxleWeightShare / trailer.TrailerWheels.Count,
-					TwinTyres = DeclarationData.Trailer.TwinTyres,
-					RollResistanceCoefficient = DeclarationData.Trailer.RollResistanceCoefficient,
-					TyreTestLoad = DeclarationData.Trailer.TyreTestLoad.SI<Newton>(),
-					Inertia = trailerWheel.Inertia
-				}));
-			}
-			retVal.AxleData = axleData;
-			return retVal;
-		}
-
-		private static int DrivenAxleIndex(IList<IAxleDeclarationInputData> axles)
-		{
-			for (var i = 0; i < axles.Count; i++) {
-				if (axles[i].AxleType != AxleType.VehicleDriven) {
-					continue;
-				}
-				return i;
-			}
-			return DeclarationData.PoweredAxle();
-		}
-
-		internal CombustionEngineData CreateEngineData(IEngineDeclarationInputData engine, PerSecond vehicleEngineIdleSpeed,
-			IGearboxDeclarationInputData gearbox, IEnumerable<ITorqueLimitInputData> torqueLimits)
-		{
-			if (!engine.SavedInDeclarationMode) {
-				WarnDeclarationMode("EngineData");
-			}
-
-			var retVal = SetCommonCombustionEngineData(engine);
-			retVal.IdleSpeed = VectoMath.Max(engine.IdleSpeed, vehicleEngineIdleSpeed);
-			retVal.WHTCUrban = engine.WHTCUrban;
-			retVal.WHTCMotorway = engine.WHTCMotorway;
-			retVal.WHTCRural = engine.WHTCRural;
-			retVal.ColdHotCorrectionFactor = engine.ColdHotBalancingFactor;
-			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox.Type);
-			var limits = torqueLimits.ToDictionary(e => e.Gear);
-			var numGears = gearbox.Gears.Count;
-			var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
-			fullLoadCurves[0] = FullLoadCurveReader.Create(engine.FullLoadCurve, true);
-			fullLoadCurves[0].EngineData = retVal;
-			foreach (var gear in gearbox.Gears) {
-				var maxTorque = VectoMath.Min(
-					GbxMaxTorque(gear, numGears, fullLoadCurves[0].MaxTorque),
-					VehMaxTorque(gear, numGears, limits, fullLoadCurves[0].MaxTorque));
-				fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
-			}
-			retVal.FullLoadCurves = fullLoadCurves;
-			return retVal;
-		}
-
-		private static NewtonMeter VehMaxTorque(ITransmissionInputData gear, int numGears,
-			Dictionary<int, ITorqueLimitInputData> limits,
-			NewtonMeter maxEngineTorque)
-		{
-			if (gear.Gear - 1 >= numGears / 2) {
-				// only upper half of gears can limit if max-torque <= 0.95 of engine max torque
-				if (limits.ContainsKey(gear.Gear) &&
-					limits[gear.Gear].MaxTorque <= DeclarationData.Engine.TorqueLimitVehicleFactor * maxEngineTorque) {
-					return limits[gear.Gear].MaxTorque;
-				}
-			}
-			return null;
-		}
-
-		private static NewtonMeter GbxMaxTorque(ITransmissionInputData gear, int numGears, NewtonMeter maxEngineTorque
-			)
-		{
-			if (gear.Gear - 1 < numGears / 2) {
-				// gears count from 1 to n, -> n entries, lower half can always limit
-				if (gear.MaxTorque != null) {
-					return gear.MaxTorque;
-				}
-			} else {
-				// upper half can only limit if max-torque <= 90% of engine max torque
-				if (gear.MaxTorque != null && gear.MaxTorque <= DeclarationData.Engine.TorqueLimitGearboxFactor * maxEngineTorque) {
-					return gear.MaxTorque;
-				}
-			}
-			return null;
-		}
-
-		internal GearboxData CreateGearboxData(IGearboxDeclarationInputData gearbox, CombustionEngineData engine,
-			double axlegearRatio, Meter dynamicTyreRadius, bool useEfficiencyFallback)
-		{
-			if (!gearbox.SavedInDeclarationMode) {
-				WarnDeclarationMode("GearboxData");
-			}
-			var retVal = SetCommonGearboxData(gearbox);
-			switch (gearbox.Type) {
-				case GearboxType.DrivingCycle:
-				case GearboxType.ATPowerSplit:
-					throw new VectoSimulationException(
-						"Unsupported gearbox type: {0}!", retVal.Type);
-				//case GearboxType.Custom:
-				//	throw new VectoSimulationException("Custom Transmission not supported in DeclarationMode!");
-			}
-			var gearsInput = gearbox.Gears;
-			if (gearsInput.Count < 1) {
-				throw new VectoSimulationException(
-					"At least one Gear-Entry must be defined in Gearbox!");
-			}
-
-			SetDeclarationData(retVal);
-
-			var gearDifferenceRatio = gearbox.Type.AutomaticTransmission() && gearbox.Gears.Count > 2
-				? gearbox.Gears[0].Ratio / gearbox.Gears[1].Ratio
-				: 1.0;
-
-			var gears = new Dictionary<uint, GearData>();
-			var tcShiftPolygon = DeclarationData.TorqueConverter.ComputeShiftPolygon(engine.FullLoadCurves[0]);
-			for (uint i = 0; i < gearsInput.Count; i++) {
-				var gear = gearsInput[(int)i];
-				var lossMap = CreateGearLossMap(gear, i, useEfficiencyFallback, true);
-
-				var shiftPolygon = DeclarationData.Gearbox.ComputeShiftPolygon(gearbox.Type, (int)i, engine.FullLoadCurves[i + 1],
-					gearsInput, engine,
-					axlegearRatio, dynamicTyreRadius);
-
-				var gearData = new GearData {
-					ShiftPolygon = shiftPolygon,
-					MaxSpeed = gear.MaxInputSpeed,
-					Ratio = gear.Ratio,
-					LossMap = lossMap,
-				};
-
-				if (gearbox.Type == GearboxType.ATPowerSplit && i == 0) {
-					// powersplit transmission: torque converter already contains ratio and losses
-					CretateTCFirstGearATPowerSplit(gearData, i, tcShiftPolygon);
-				}
-				if (gearbox.Type == GearboxType.ATSerial) {
-					if (i == 0) {
-						// torqueconverter is active in first gear - duplicate ratio and lossmap for torque converter mode
-						CreateTCFirstGearATSerial(gearData, tcShiftPolygon);
-					}
-					if (i == 1 && gearDifferenceRatio >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold) {
-						// ratio between first and second gear is above threshold, torqueconverter is active in second gear as well
-						// -> duplicate ratio and lossmap for torque converter mode, remove locked transmission for previous gear
-						CreateTCSecondGearATSerial(gearData, tcShiftPolygon);
-						// NOTE: the lower gear in 'gears' dictionary has index i !!
-						gears[i].Ratio = double.NaN;
-						gears[i].LossMap = null;
-					}
-				}
-				gears.Add(i + 1, gearData);
-			}
-			retVal.Gears = gears;
-			if (retVal.Type.AutomaticTransmission()) {
-				var ratio = double.IsNaN(retVal.Gears[1].Ratio) ? 1 : retVal.Gears[1].TorqueConverterRatio / retVal.Gears[1].Ratio;
-				retVal.PowershiftShiftTime = DeclarationData.Gearbox.PowershiftShiftTime;
-				retVal.TorqueConverterData = TorqueConverterDataReader.Create(gearbox.TorqueConverter.TCData,
-					DeclarationData.TorqueConverter.ReferenceRPM, DeclarationData.TorqueConverter.MaxInputSpeed,
-					ExecutionMode.Declaration, ratio,
-					DeclarationData.TorqueConverter.CLUpshiftMinAcceleration, DeclarationData.TorqueConverter.CCUpshiftMinAcceleration);
-			}
-
-			return retVal;
-		}
-
-		private static void SetDeclarationData(GearboxData retVal)
-		{
-			retVal.Inertia = DeclarationData.Gearbox.Inertia;
-			retVal.TractionInterruption = retVal.Type.TractionInterruption();
-			retVal.TorqueReserve = DeclarationData.Gearbox.TorqueReserve;
-			retVal.StartTorqueReserve = DeclarationData.Gearbox.TorqueReserveStart;
-			retVal.ShiftTime = DeclarationData.Gearbox.MinTimeBetweenGearshifts;
-			retVal.StartSpeed = DeclarationData.Gearbox.StartSpeed;
-			retVal.StartAcceleration = DeclarationData.Gearbox.StartAcceleration;
-			retVal.DownshiftAfterUpshiftDelay = DeclarationData.Gearbox.DownshiftAfterUpshiftDelay;
-			retVal.UpshiftAfterDownshiftDelay = DeclarationData.Gearbox.UpshiftAfterDownshiftDelay;
-			retVal.UpshiftMinAcceleration = DeclarationData.Gearbox.UpshiftMinAcceleration;
-		}
-
-		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxInputData,
-			MissionType mission, VehicleClass hvdClass)
-		{
-			if (!auxInputData.SavedInDeclarationMode) {
-				WarnDeclarationMode("AuxiliariesData");
-			}
-			var retVal = new List<VectoRunData.AuxData>();
-
-			if (auxInputData.Auxiliaries.Count != 5) {
-				Log.Error(
-					"In Declaration Mode exactly 5 Auxiliaries must be defined: Fan, Steering pump, HVAC, Electric System, Pneumatic System.");
-				throw new VectoException(
-					"In Declaration Mode exactly 5 Auxiliaries must be defined: Fan, Steering pump, HVAC, Electric System, Pneumatic System.");
-			}
-
-			foreach (var auxType in EnumHelper.GetValues<AuxiliaryType>()) {
-				var auxData = auxInputData.Auxiliaries.FirstOrDefault(a => a.Type == auxType);
-				if (auxData == null) {
-					throw new VectoException("Auxiliary {0} not found.", auxType);
-				}
-				var aux = new VectoRunData.AuxData {
-					DemandType = AuxiliaryDemandType.Constant,
-					Technology = auxData.Technology
-				};
-
-				mission = mission.GetNonEMSMissionType();
-				switch (auxType) {
-					case AuxiliaryType.Fan:
-						aux.PowerDemand = DeclarationData.Fan.Lookup(mission, auxData.Technology.FirstOrDefault());
-						aux.ID = Constants.Auxiliaries.IDs.Fan;
-						break;
-					case AuxiliaryType.SteeringPump:
-						aux.PowerDemand = DeclarationData.SteeringPump.Lookup(mission, hvdClass, auxData.Technology);
-						aux.ID = Constants.Auxiliaries.IDs.SteeringPump;
-						break;
-					case AuxiliaryType.HVAC:
-						aux.PowerDemand = DeclarationData.HeatingVentilationAirConditioning.Lookup(mission,
-							auxData.Technology.FirstOrDefault(), hvdClass);
-						aux.ID = Constants.Auxiliaries.IDs.HeatingVentilationAirCondition;
-						break;
-					case AuxiliaryType.PneumaticSystem:
-						aux.PowerDemand = DeclarationData.PneumaticSystem.Lookup(mission, auxData.Technology.FirstOrDefault());
-						aux.ID = Constants.Auxiliaries.IDs.PneumaticSystem;
-						break;
-					case AuxiliaryType.ElectricSystem:
-						aux.PowerDemand = DeclarationData.ElectricSystem.Lookup(mission, auxData.Technology.FirstOrDefault());
-						aux.ID = Constants.Auxiliaries.IDs.ElectricSystem;
-						break;
-					default:
-						continue;
-				}
-				retVal.Add(aux);
-			}
-			return retVal;
-		}
-
-		private void WarnDeclarationMode(string inputData)
-		{
-			Log.Warn("{0} not in Declaration Mode!", inputData);
-		}
-
-		public RetarderData CreateRetarderData(IRetarderInputData retarder)
-		{
-			return SetCommonRetarderData(retarder);
-		}
-
-		public static List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> GetDeclarationAirResistanceCurve(
-			string crosswindCorrectionParameters, SquareMeter aerodynamicDragAera, Meter vehicleHeight)
-		{
-			const int startSpeed = 60;
-			const int maxSpeed = 130;
-			const int speedStep = 5;
-
-			const int maxAlpha = 180;
-			const int alphaStep = 10;
-
-			const int startHeightPercent = 5;
-			const int maxHeightPercent = 100;
-			const int heightPercentStep = 10;
-			const double heightShare = (double)heightPercentStep / maxHeightPercent;
-
-			var values = DeclarationData.AirDrag.Lookup(crosswindCorrectionParameters);
-
-			// first entry (0m/s) will get CdxA of second entry.
-			var points = new List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> {
-				new CrossWindCorrectionCurveReader.CrossWindCorrectionEntry {
-					Velocity = 0.SI<MeterPerSecond>(),
-					EffectiveCrossSectionArea = 0.SI<SquareMeter>()
-				}
-			};
-
-			for (var speed = startSpeed; speed <= maxSpeed; speed += speedStep) {
-				var vVeh = speed.KMPHtoMeterPerSecond();
-
-				var cdASum = 0.SI<SquareMeter>();
-
-				for (var heightPercent = startHeightPercent; heightPercent < maxHeightPercent; heightPercent += heightPercentStep) {
-					var height = heightPercent / 100.0 * vehicleHeight;
-					var vWind = Physics.BaseWindSpeed * Math.Pow(height / Physics.BaseWindHeight, Physics.HellmannExponent);
-
-					for (var alpha = 0; alpha <= maxAlpha; alpha += alphaStep) {
-						var vAirX = vVeh + vWind * Math.Cos(alpha.ToRadian());
-						var vAirY = vWind * Math.Sin(alpha.ToRadian());
-
-						var beta = Math.Atan(vAirY / vAirX).ToDegree();
-
-						// ΔCdxA = A1β + A2β² + A3β³
-						var deltaCdA = values.A1 * beta + values.A2 * beta * beta + values.A3 * beta * beta * beta;
-
-						// CdxA(β) = CdxA(0) + ΔCdxA(β)
-						var cdA = aerodynamicDragAera + deltaCdA;
-
-						var share = (alpha == 0 || alpha == maxAlpha ? alphaStep / 2.0 : alphaStep) / maxAlpha;
-
-						// v_air = sqrt(v_airX²+vAirY²)
-						// cdASum = CdxA(β) * v_air²/v_veh²
-						cdASum += heightShare * share * cdA * (vAirX * vAirX + vAirY * vAirY) / (vVeh * vVeh);
-					}
-				}
-				points.Add(new CrossWindCorrectionCurveReader.CrossWindCorrectionEntry {
-					Velocity = vVeh,
-					EffectiveCrossSectionArea = cdASum
-				});
-			}
-
-			points[0].EffectiveCrossSectionArea = points[1].EffectiveCrossSectionArea;
-			return points;
-		}
-
-		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto)
-		{
-			if (pto.PTOTransmissionType != "None") {
-				return new PTOData {
-					TransmissionType = pto.PTOTransmissionType,
-					LossMap = PTOIdleLossMapReader.GetZeroLossMap(),
-				};
-			}
-
-			return null;
-		}
-
-		public AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragInputData, Mission mission,
-			Segment segment)
-		{
-			if (airdragInputData == null || airdragInputData.AirDragArea == null) {
-				return DefaultAirdragData(mission, segment);
-			}
-
-			var retVal = SetCommonAirdragData(airdragInputData);
-			var aerodynamicDragArea = airdragInputData.AirDragArea + mission.Trailer.Sum(t => t.DeltaCdA).DefaultIfNull(0);
-
-			retVal.DeclaredAirdragArea = airdragInputData.AirDragArea;
-			retVal.CrossWindCorrectionCurve =
-				new CrosswindCorrectionCdxALookup(aerodynamicDragArea,
-					GetDeclarationAirResistanceCurve(mission.CrossWindCorrectionParameters, aerodynamicDragArea, segment.VehicleHeight),
-					CrossWindCorrectionMode.DeclarationModeCorrection);
-			return retVal;
-		}
-
-		private AirdragData DefaultAirdragData(Mission mission, Segment segment)
-		{
-			var aerodynamicDragArea = mission.MissionType == MissionType.Construction
-				? segment.CdAConstruction
-				: segment.CdADefault + mission.Trailer.Sum(t => t.DeltaCdA).DefaultIfNull(0);
-
-			return new AirdragData() {
-				CertificationMethod = CertificationMethod.StandardValues,
-				DeclaredAirdragArea = mission.MissionType == MissionType.Construction ? segment.CdAConstruction : segment.CdADefault,
-				CrossWindCorrectionCurve = new CrosswindCorrectionCdxALookup(aerodynamicDragArea,
-					GetDeclarationAirResistanceCurve(mission.CrossWindCorrectionParameters, aerodynamicDragArea, segment.VehicleHeight),
-					CrossWindCorrectionMode.DeclarationModeCorrection)
-			};
-		}
-	}
+				MinSpeed = DeclarationData.Driver.LookAhead.MinimumSpeed,
+				LookAheadDecisionFactor = new LACDecisionFactor(),
+				LookAheadDistanceFactor = DeclarationData.Driver.LookAhead.LookAheadDistanceFactor,
+			};
+			var overspeedData = new DriverData.OverSpeedEcoRollData {
+				Mode = data.OverSpeedEcoRoll.Mode,
+				MinSpeed = DeclarationData.Driver.OverSpeedEcoRoll.MinSpeed,
+				OverSpeed = DeclarationData.Driver.OverSpeedEcoRoll.OverSpeed,
+				UnderSpeed = DeclarationData.Driver.OverSpeedEcoRoll.UnderSpeed
+			};
+			if (!DeclarationData.Driver.OverSpeedEcoRoll.AllowedModes.Contains(overspeedData.Mode)) {
+				throw new VectoSimulationException(
+					"Specified Overspeed/EcoRoll Mode not allowed in declaration mode! {0}",
+					overspeedData.Mode);
+			}
+			var retVal = new DriverData {
+				LookAheadCoasting = lookAheadData,
+				OverSpeedEcoRoll = overspeedData,
+			};
+			return retVal;
+		}
+
+		internal VehicleData CreateVehicleData(IVehicleDeclarationInputData data, Mission mission, Kilogram loading,
+			Kilogram municipalBodyWeight)
+		{
+			if (!data.SavedInDeclarationMode) {
+				WarnDeclarationMode("VehicleData");
+			}
+
+			var retVal = SetCommonVehicleData(data);
+			retVal.VIN = data.VIN;
+			retVal.ManufacturerAddress = data.ManufacturerAddress;
+			retVal.LegislativeClass = data.LegislativeClass;
+			retVal.TrailerGrossVehicleWeight = mission.Trailer.Sum(t => t.TrailerGrossVehicleWeight).DefaultIfNull(0);
+
+			retVal.BodyAndTrailerWeight = (mission.MissionType == MissionType.MunicipalUtility
+				? municipalBodyWeight
+				: mission.BodyCurbWeight) + mission.Trailer.Sum(t => t.TrailerCurbWeight).DefaultIfNull(0);
+			//retVal.CurbWeight += retVal.BodyAndTrailerWeight;
+
+			retVal.Loading = loading;
+			var drivenIndex = DrivenAxleIndex(data.Axles);
+			retVal.DynamicTyreRadius =
+				DeclarationData.Wheels.Lookup(data.Axles[drivenIndex].Wheels).DynamicTyreRadius;
+			retVal.CargoVolume = mission.MissionType != MissionType.Construction ? mission.TotalCargoVolume : 0.SI<CubicMeter>();
+
+
+			var axles = data.Axles;
+			if (axles.Count < mission.AxleWeightDistribution.Length) {
+				throw new VectoException("Vehicle does not contain sufficient axles. {0} axles defined, {1} axles required",
+					data.Axles.Count, mission.AxleWeightDistribution.Length);
+			}
+			var axleData = new List<Axle>();
+			for (var i = 0; i < mission.AxleWeightDistribution.Length; i++) {
+				var axleInput = axles[i];
+				var axle = new Axle {
+					WheelsDimension = axleInput.Wheels,
+					AxleType = axleInput.AxleType,
+					AxleWeightShare = mission.AxleWeightDistribution[i],
+					TwinTyres = axleInput.TwinTyres,
+					RollResistanceCoefficient = axleInput.RollResistanceCoefficient,
+					TyreTestLoad = axleInput.TyreTestLoad,
+					Inertia = DeclarationData.Wheels.Lookup(axleInput.Wheels.RemoveWhitespace()).Inertia,
+				};
+				axleData.Add(axle);
+			}
+
+			foreach (var trailer in mission.Trailer) {
+				axleData.AddRange(trailer.TrailerWheels.Select(trailerWheel => new Axle {
+					AxleType = AxleType.Trailer,
+					AxleWeightShare = trailer.TrailerAxleWeightShare / trailer.TrailerWheels.Count,
+					TwinTyres = DeclarationData.Trailer.TwinTyres,
+					RollResistanceCoefficient = DeclarationData.Trailer.RollResistanceCoefficient,
+					TyreTestLoad = DeclarationData.Trailer.TyreTestLoad.SI<Newton>(),
+					Inertia = trailerWheel.Inertia
+				}));
+			}
+			retVal.AxleData = axleData;
+			return retVal;
+		}
+
+		private static int DrivenAxleIndex(IList<IAxleDeclarationInputData> axles)
+		{
+			for (var i = 0; i < axles.Count; i++) {
+				if (axles[i].AxleType != AxleType.VehicleDriven) {
+					continue;
+				}
+				return i;
+			}
+			return DeclarationData.PoweredAxle();
+		}
+
+		internal CombustionEngineData CreateEngineData(IEngineDeclarationInputData engine, PerSecond vehicleEngineIdleSpeed,
+			IGearboxDeclarationInputData gearbox, IEnumerable<ITorqueLimitInputData> torqueLimits)
+		{
+			if (!engine.SavedInDeclarationMode) {
+				WarnDeclarationMode("EngineData");
+			}
+
+			var retVal = SetCommonCombustionEngineData(engine);
+			retVal.IdleSpeed = VectoMath.Max(engine.IdleSpeed, vehicleEngineIdleSpeed);
+			retVal.WHTCUrban = engine.WHTCUrban;
+			retVal.WHTCMotorway = engine.WHTCMotorway;
+			retVal.WHTCRural = engine.WHTCRural;
+			retVal.ColdHotCorrectionFactor = engine.ColdHotBalancingFactor;
+			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox.Type);
+			var limits = torqueLimits.ToDictionary(e => e.Gear);
+			var numGears = gearbox.Gears.Count;
+			var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
+			fullLoadCurves[0] = FullLoadCurveReader.Create(engine.FullLoadCurve, true);
+			fullLoadCurves[0].EngineData = retVal;
+			foreach (var gear in gearbox.Gears) {
+				var maxTorque = VectoMath.Min(
+					GbxMaxTorque(gear, numGears, fullLoadCurves[0].MaxTorque),
+					VehMaxTorque(gear, numGears, limits, fullLoadCurves[0].MaxTorque));
+				fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
+			}
+			retVal.FullLoadCurves = fullLoadCurves;
+			return retVal;
+		}
+
+		private static NewtonMeter VehMaxTorque(ITransmissionInputData gear, int numGears,
+			Dictionary<int, ITorqueLimitInputData> limits,
+			NewtonMeter maxEngineTorque)
+		{
+			if (gear.Gear - 1 >= numGears / 2) {
+				// only upper half of gears can limit if max-torque <= 0.95 of engine max torque
+				if (limits.ContainsKey(gear.Gear) &&
+					limits[gear.Gear].MaxTorque <= DeclarationData.Engine.TorqueLimitVehicleFactor * maxEngineTorque) {
+					return limits[gear.Gear].MaxTorque;
+				}
+			}
+			return null;
+		}
+
+		private static NewtonMeter GbxMaxTorque(ITransmissionInputData gear, int numGears, NewtonMeter maxEngineTorque
+			)
+		{
+			if (gear.Gear - 1 < numGears / 2) {
+				// gears count from 1 to n, -> n entries, lower half can always limit
+				if (gear.MaxTorque != null) {
+					return gear.MaxTorque;
+				}
+			} else {
+				// upper half can only limit if max-torque <= 90% of engine max torque
+				if (gear.MaxTorque != null && gear.MaxTorque <= DeclarationData.Engine.TorqueLimitGearboxFactor * maxEngineTorque) {
+					return gear.MaxTorque;
+				}
+			}
+			return null;
+		}
+
+		internal GearboxData CreateGearboxData(IGearboxDeclarationInputData gearbox, CombustionEngineData engine,
+			double axlegearRatio, Meter dynamicTyreRadius, VehicleCategory vehicleCategory, bool useEfficiencyFallback)
+		{
+			if (!gearbox.SavedInDeclarationMode) {
+				WarnDeclarationMode("GearboxData");
+			}
+			var retVal = SetCommonGearboxData(gearbox);
+			switch (gearbox.Type) {
+				case GearboxType.DrivingCycle:
+				case GearboxType.ATPowerSplit:
+					throw new VectoSimulationException(
+						"Unsupported gearbox type: {0}!", retVal.Type);
+				//case GearboxType.Custom:
+				//	throw new VectoSimulationException("Custom Transmission not supported in DeclarationMode!");
+			}
+			var gearsInput = gearbox.Gears;
+			if (gearsInput.Count < 1) {
+				throw new VectoSimulationException(
+					"At least one Gear-Entry must be defined in Gearbox!");
+			}
+
+			SetDeclarationData(retVal);
+
+			var gearDifferenceRatio = gearbox.Type.AutomaticTransmission() && gearbox.Gears.Count > 2
+				? gearbox.Gears[0].Ratio / gearbox.Gears[1].Ratio
+				: 1.0;
+
+			var gears = new Dictionary<uint, GearData>();
+			var tcShiftPolygon = DeclarationData.TorqueConverter.ComputeShiftPolygon(engine.FullLoadCurves[0]);
+			for (uint i = 0; i < gearsInput.Count; i++) {
+				var gear = gearsInput[(int)i];
+				var lossMap = CreateGearLossMap(gear, i, useEfficiencyFallback, true);
+
+				var shiftPolygon = DeclarationData.Gearbox.ComputeShiftPolygon(gearbox.Type, (int)i, engine.FullLoadCurves[i + 1],
+					gearsInput, engine,
+					axlegearRatio, dynamicTyreRadius);
+
+				var gearData = new GearData {
+					ShiftPolygon = shiftPolygon,
+					MaxSpeed = gear.MaxInputSpeed,
+					Ratio = gear.Ratio,
+					LossMap = lossMap,
+				};
+
+				if (gearbox.Type == GearboxType.ATPowerSplit && i == 0) {
+					// powersplit transmission: torque converter already contains ratio and losses
+					CretateTCFirstGearATPowerSplit(gearData, i, tcShiftPolygon);
+				}
+				if (gearbox.Type == GearboxType.ATSerial) {
+					if (i == 0) {
+						// torqueconverter is active in first gear - duplicate ratio and lossmap for torque converter mode
+						CreateTCFirstGearATSerial(gearData, tcShiftPolygon);
+					}
+					if (i == 1 && gearDifferenceRatio >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold(vehicleCategory)) {
+						// ratio between first and second gear is above threshold, torqueconverter is active in second gear as well
+						// -> duplicate ratio and lossmap for torque converter mode, remove locked transmission for previous gear
+						CreateTCSecondGearATSerial(gearData, tcShiftPolygon);
+						// NOTE: the lower gear in 'gears' dictionary has index i !!
+						gears[i].Ratio = double.NaN;
+						gears[i].LossMap = null;
+					}
+				}
+				gears.Add(i + 1, gearData);
+			}
+			retVal.Gears = gears;
+			if (retVal.Type.AutomaticTransmission()) {
+				var ratio = double.IsNaN(retVal.Gears[1].Ratio) ? 1 : retVal.Gears[1].TorqueConverterRatio / retVal.Gears[1].Ratio;
+				retVal.PowershiftShiftTime = DeclarationData.Gearbox.PowershiftShiftTime;
+				retVal.TorqueConverterData = TorqueConverterDataReader.Create(gearbox.TorqueConverter.TCData,
+					DeclarationData.TorqueConverter.ReferenceRPM, DeclarationData.TorqueConverter.MaxInputSpeed,
+					ExecutionMode.Declaration, ratio,
+					DeclarationData.TorqueConverter.CLUpshiftMinAcceleration, DeclarationData.TorqueConverter.CCUpshiftMinAcceleration);
+			}
+
+			return retVal;
+		}
+
+		private static void SetDeclarationData(GearboxData retVal)
+		{
+			retVal.Inertia = DeclarationData.Gearbox.Inertia;
+			retVal.TractionInterruption = retVal.Type.TractionInterruption();
+			retVal.TorqueReserve = DeclarationData.Gearbox.TorqueReserve;
+			retVal.StartTorqueReserve = DeclarationData.Gearbox.TorqueReserveStart;
+			retVal.ShiftTime = DeclarationData.Gearbox.MinTimeBetweenGearshifts;
+			retVal.StartSpeed = DeclarationData.Gearbox.StartSpeed;
+			retVal.StartAcceleration = DeclarationData.Gearbox.StartAcceleration;
+			retVal.DownshiftAfterUpshiftDelay = DeclarationData.Gearbox.DownshiftAfterUpshiftDelay;
+			retVal.UpshiftAfterDownshiftDelay = DeclarationData.Gearbox.UpshiftAfterDownshiftDelay;
+			retVal.UpshiftMinAcceleration = DeclarationData.Gearbox.UpshiftMinAcceleration;
+		}
+
+		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxInputData,
+			MissionType mission, VehicleClass hvdClass)
+		{
+			if (!auxInputData.SavedInDeclarationMode) {
+				WarnDeclarationMode("AuxiliariesData");
+			}
+			var retVal = new List<VectoRunData.AuxData>();
+
+			if (auxInputData.Auxiliaries.Count != 5) {
+				Log.Error(
+					"In Declaration Mode exactly 5 Auxiliaries must be defined: Fan, Steering pump, HVAC, Electric System, Pneumatic System.");
+				throw new VectoException(
+					"In Declaration Mode exactly 5 Auxiliaries must be defined: Fan, Steering pump, HVAC, Electric System, Pneumatic System.");
+			}
+
+			foreach (var auxType in EnumHelper.GetValues<AuxiliaryType>()) {
+				var auxData = auxInputData.Auxiliaries.FirstOrDefault(a => a.Type == auxType);
+				if (auxData == null) {
+					throw new VectoException("Auxiliary {0} not found.", auxType);
+				}
+				var aux = new VectoRunData.AuxData {
+					DemandType = AuxiliaryDemandType.Constant,
+					Technology = auxData.Technology
+				};
+
+				mission = mission.GetNonEMSMissionType();
+				switch (auxType) {
+					case AuxiliaryType.Fan:
+						aux.PowerDemand = DeclarationData.Fan.Lookup(mission, auxData.Technology.FirstOrDefault());
+						aux.ID = Constants.Auxiliaries.IDs.Fan;
+						break;
+					case AuxiliaryType.SteeringPump:
+						aux.PowerDemand = DeclarationData.SteeringPump.Lookup(mission, hvdClass, auxData.Technology);
+						aux.ID = Constants.Auxiliaries.IDs.SteeringPump;
+						break;
+					case AuxiliaryType.HVAC:
+						aux.PowerDemand = DeclarationData.HeatingVentilationAirConditioning.Lookup(mission,
+							auxData.Technology.FirstOrDefault(), hvdClass);
+						aux.ID = Constants.Auxiliaries.IDs.HeatingVentilationAirCondition;
+						break;
+					case AuxiliaryType.PneumaticSystem:
+						aux.PowerDemand = DeclarationData.PneumaticSystem.Lookup(mission, auxData.Technology.FirstOrDefault());
+						aux.ID = Constants.Auxiliaries.IDs.PneumaticSystem;
+						break;
+					case AuxiliaryType.ElectricSystem:
+						aux.PowerDemand = DeclarationData.ElectricSystem.Lookup(mission, auxData.Technology.FirstOrDefault());
+						aux.ID = Constants.Auxiliaries.IDs.ElectricSystem;
+						break;
+					default:
+						continue;
+				}
+				retVal.Add(aux);
+			}
+			return retVal;
+		}
+
+		private void WarnDeclarationMode(string inputData)
+		{
+			Log.Warn("{0} not in Declaration Mode!", inputData);
+		}
+
+		public RetarderData CreateRetarderData(IRetarderInputData retarder)
+		{
+			return SetCommonRetarderData(retarder);
+		}
+
+		public static List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> GetDeclarationAirResistanceCurve(
+			string crosswindCorrectionParameters, SquareMeter aerodynamicDragAera, Meter vehicleHeight)
+		{
+			const int startSpeed = 60;
+			const int maxSpeed = 130;
+			const int speedStep = 5;
+
+			const int maxAlpha = 180;
+			const int alphaStep = 10;
+
+			const int startHeightPercent = 5;
+			const int maxHeightPercent = 100;
+			const int heightPercentStep = 10;
+			const double heightShare = (double)heightPercentStep / maxHeightPercent;
+
+			var values = DeclarationData.AirDrag.Lookup(crosswindCorrectionParameters);
+
+			// first entry (0m/s) will get CdxA of second entry.
+			var points = new List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> {
+				new CrossWindCorrectionCurveReader.CrossWindCorrectionEntry {
+					Velocity = 0.SI<MeterPerSecond>(),
+					EffectiveCrossSectionArea = 0.SI<SquareMeter>()
+				}
+			};
+
+			for (var speed = startSpeed; speed <= maxSpeed; speed += speedStep) {
+				var vVeh = speed.KMPHtoMeterPerSecond();
+
+				var cdASum = 0.SI<SquareMeter>();
+
+				for (var heightPercent = startHeightPercent; heightPercent < maxHeightPercent; heightPercent += heightPercentStep) {
+					var height = heightPercent / 100.0 * vehicleHeight;
+					var vWind = Physics.BaseWindSpeed * Math.Pow(height / Physics.BaseWindHeight, Physics.HellmannExponent);
+
+					for (var alpha = 0; alpha <= maxAlpha; alpha += alphaStep) {
+						var vAirX = vVeh + vWind * Math.Cos(alpha.ToRadian());
+						var vAirY = vWind * Math.Sin(alpha.ToRadian());
+
+						var beta = Math.Atan(vAirY / vAirX).ToDegree();
+
+						// ΔCdxA = A1β + A2β² + A3β³
+						var deltaCdA = values.A1 * beta + values.A2 * beta * beta + values.A3 * beta * beta * beta;
+
+						// CdxA(β) = CdxA(0) + ΔCdxA(β)
+						var cdA = aerodynamicDragAera + deltaCdA;
+
+						var share = (alpha == 0 || alpha == maxAlpha ? alphaStep / 2.0 : alphaStep) / maxAlpha;
+
+						// v_air = sqrt(v_airX²+vAirY²)
+						// cdASum = CdxA(β) * v_air²/v_veh²
+						cdASum += heightShare * share * cdA * (vAirX * vAirX + vAirY * vAirY) / (vVeh * vVeh);
+					}
+				}
+				points.Add(new CrossWindCorrectionCurveReader.CrossWindCorrectionEntry {
+					Velocity = vVeh,
+					EffectiveCrossSectionArea = cdASum
+				});
+			}
+
+			points[0].EffectiveCrossSectionArea = points[1].EffectiveCrossSectionArea;
+			return points;
+		}
+
+		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto)
+		{
+			if (pto.PTOTransmissionType != "None") {
+				return new PTOData {
+					TransmissionType = pto.PTOTransmissionType,
+					LossMap = PTOIdleLossMapReader.GetZeroLossMap(),
+				};
+			}
+
+			return null;
+		}
+
+		public AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragInputData, Mission mission,
+			Segment segment)
+		{
+			if (airdragInputData == null || airdragInputData.AirDragArea == null) {
+				return DefaultAirdragData(mission, segment);
+			}
+
+			var retVal = SetCommonAirdragData(airdragInputData);
+			var aerodynamicDragArea = airdragInputData.AirDragArea + mission.Trailer.Sum(t => t.DeltaCdA).DefaultIfNull(0);
+
+			retVal.DeclaredAirdragArea = airdragInputData.AirDragArea;
+			retVal.CrossWindCorrectionCurve =
+				new CrosswindCorrectionCdxALookup(aerodynamicDragArea,
+					GetDeclarationAirResistanceCurve(mission.CrossWindCorrectionParameters, aerodynamicDragArea, segment.VehicleHeight),
+					CrossWindCorrectionMode.DeclarationModeCorrection);
+			return retVal;
+		}
+
+		private AirdragData DefaultAirdragData(Mission mission, Segment segment)
+		{
+			var aerodynamicDragArea = mission.MissionType == MissionType.Construction
+				? segment.CdAConstruction
+				: segment.CdADefault + mission.Trailer.Sum(t => t.DeltaCdA).DefaultIfNull(0);
+
+			return new AirdragData() {
+				CertificationMethod = CertificationMethod.StandardValues,
+				DeclaredAirdragArea = mission.MissionType == MissionType.Construction ? segment.CdAConstruction : segment.CdADefault,
+				CrossWindCorrectionCurve = new CrosswindCorrectionCdxALookup(aerodynamicDragArea,
+					GetDeclarationAirResistanceCurve(mission.CrossWindCorrectionParameters, aerodynamicDragArea, segment.VehicleHeight),
+					CrossWindCorrectionMode.DeclarationModeCorrection)
+			};
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/EngineeringDataAdapter.cs b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/EngineeringDataAdapter.cs
index 50c771198b3326f4d8956c1f7f706ec0dc98b286..8ce7e9175f58652ba8e8788ddb441a43bee6e7b9 100644
--- a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/EngineeringDataAdapter.cs
+++ b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/EngineeringDataAdapter.cs
@@ -29,340 +29,340 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.InputData.Reader.ComponentData;
-using TUGraz.VectoCore.Models.Declaration;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
-using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
-{
-	public class EngineeringDataAdapter : AbstractSimulationDataAdapter
-	{
-		internal VehicleData CreateVehicleData(IVehicleEngineeringInputData data)
-		{
-			if (data.SavedInDeclarationMode) {
-				WarnEngineeringMode("VehicleData");
-			}
-
-			var retVal = SetCommonVehicleData(data);
-			retVal.BodyAndTrailerWeight = data.CurbMassExtra;
-			//retVal.CurbWeight += data.CurbMassExtra;
-			retVal.TrailerGrossVehicleWeight = 0.SI<Kilogram>();
-			retVal.Loading = data.Loading;
-			retVal.DynamicTyreRadius = data.DynamicTyreRadius;
-			var axles = data.Axles;
-
-
-			retVal.AxleData = axles.Select(axle => new Axle {
-				WheelsDimension = axle.Wheels,
-				Inertia = axle.Inertia,
-				TwinTyres = axle.TwinTyres,
-				RollResistanceCoefficient = axle.RollResistanceCoefficient,
-				AxleWeightShare = axle.AxleWeightShare,
-				TyreTestLoad = axle.TyreTestLoad,
-				//Wheels = axle.WheelsStr
-			}).ToList();
-			return retVal;
-		}
-
-		public AirdragData CreateAirdragData(IAirdragEngineeringInputData airdragData, IVehicleEngineeringInputData data)
-		{
-			var retVal = SetCommonAirdragData(airdragData);
-			retVal.CrossWindCorrectionMode = airdragData.CrossWindCorrectionMode;
-
-			switch (airdragData.CrossWindCorrectionMode) {
-				case CrossWindCorrectionMode.NoCorrection:
-					retVal.CrossWindCorrectionCurve =
-						new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
-							CrossWindCorrectionCurveReader.GetNoCorrectionCurve(airdragData.AirDragArea),
-							CrossWindCorrectionMode.NoCorrection);
-					break;
-				case CrossWindCorrectionMode.SpeedDependentCorrectionFactor:
-					retVal.CrossWindCorrectionCurve = new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
-						CrossWindCorrectionCurveReader.ReadSpeedDependentCorrectionCurve(airdragData.CrosswindCorrectionMap,
-							airdragData.AirDragArea), CrossWindCorrectionMode.SpeedDependentCorrectionFactor);
-					break;
-				case CrossWindCorrectionMode.VAirBetaLookupTable:
-					retVal.CrossWindCorrectionCurve = new CrosswindCorrectionVAirBeta(airdragData.AirDragArea,
-						CrossWindCorrectionCurveReader.ReadCdxABetaTable(airdragData.CrosswindCorrectionMap));
-					break;
-				case CrossWindCorrectionMode.DeclarationModeCorrection:
-					var height = DeclarationData.Segments.LookupHeight(data.VehicleCategory, data.AxleConfiguration,
-						data.GrossVehicleMassRating);
-					retVal.CrossWindCorrectionCurve =
-						new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
-							DeclarationDataAdapter.GetDeclarationAirResistanceCurve(
-								GetAirdragParameterSet(data.VehicleCategory, data.AxleConfiguration, data.Axles.Count),
-								airdragData.AirDragArea, height), CrossWindCorrectionMode.DeclarationModeCorrection);
-					break;
-				default:
-					throw new ArgumentOutOfRangeException("CrosswindCorrection", airdragData.CrossWindCorrectionMode.ToString());
-			}
-			return retVal;
-		}
-
-		private string GetAirdragParameterSet(VehicleCategory vehicleCategory, AxleConfiguration axles, int numAxles)
-		{
-			switch (vehicleCategory) {
-				case VehicleCategory.RigidTruck:
-					return numAxles > axles.NumAxles() ? "RigidTrailer" : "RigidSolo";
-				case VehicleCategory.Tractor:
-					return "TractorSemitrailer";
-				case VehicleCategory.CityBus:
-				case VehicleCategory.InterurbanBus:
-				case VehicleCategory.Coach:
-					return "CoachBus";
-				default:
-					throw new ArgumentOutOfRangeException("vehicleCategory", vehicleCategory, null);
-			}
-		}
-
-		private void WarnEngineeringMode(string msg)
-		{
-			Log.Error("{0} is in Declaration Mode but is used for Engineering Mode!", msg);
-		}
-
-		internal CombustionEngineData CreateEngineData(IEngineEngineeringInputData engine, IGearboxEngineeringInputData gbx,
-			IEnumerable<ITorqueLimitInputData> torqueLimits)
-		{
-			if (engine.SavedInDeclarationMode) {
-				WarnEngineeringMode("EngineData");
-			}
-
-			var retVal = SetCommonCombustionEngineData(engine);
-			retVal.Inertia = engine.Inertia +
-							(gbx != null && gbx.Type.AutomaticTransmission() ? gbx.TorqueConverter.Inertia : 0.SI<KilogramSquareMeter>());
-			var limits = torqueLimits.ToDictionary(e => e.Gear);
-			var numGears = gbx == null ? 0 : gbx.Gears.Count;
-			var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
-			fullLoadCurves[0] = FullLoadCurveReader.Create(engine.FullLoadCurve);
-			fullLoadCurves[0].EngineData = retVal;
-			if (gbx != null) {
-				foreach (var gear in gbx.Gears) {
-					var maxTorque = VectoMath.Min(gear.MaxTorque, limits.ContainsKey(gear.Gear) ? limits[gear.Gear].MaxTorque : null);
-					fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
-				}
-			}
-			retVal.FullLoadCurves = fullLoadCurves;
-			retVal.FuelConsumptionCorrectionFactor = engine.WHTCEngineering;
-			return retVal;
-		}
-
-		internal GearboxData CreateGearboxData(IGearboxEngineeringInputData gearbox, CombustionEngineData engineData,
-			double axlegearRatio, Meter dynamicTyreRadius, bool useEfficiencyFallback)
-		{
-			if (gearbox.SavedInDeclarationMode) {
-				WarnEngineeringMode("GearboxData");
-			}
-
-			var retVal = SetCommonGearboxData(gearbox);
-
-			//var gears = gearbox.Gears;
-			if (gearbox.Gears.Count < 2) {
-				throw new VectoSimulationException("At least two Gear-Entries must be defined in Gearbox!");
-			}
-
-			SetEngineeringData(gearbox, retVal);
-
-			var gearDifferenceRatio = gearbox.Type.AutomaticTransmission() && gearbox.Gears.Count > 2
-				? gearbox.Gears[0].Ratio / gearbox.Gears[1].Ratio
-				: 1.0;
-
-			var gears = new Dictionary<uint, GearData>();
-			ShiftPolygon tcShiftPolygon = null;
-			if (gearbox.Type.AutomaticTransmission()) {
-				tcShiftPolygon = gearbox.TorqueConverter.ShiftPolygon != null
-					? ShiftPolygonReader.Create(gearbox.TorqueConverter.ShiftPolygon)
-					: DeclarationData.TorqueConverter.ComputeShiftPolygon(engineData.FullLoadCurves[0]);
-			}
-			for (uint i = 0; i < gearbox.Gears.Count; i++) {
-				var gear = gearbox.Gears[(int)i];
-				var lossMap = CreateGearLossMap(gear, i, useEfficiencyFallback, false);
-
-				var shiftPolygon = gear.ShiftPolygon != null && gear.ShiftPolygon.SourceType != DataSourceType.Missing
-					? ShiftPolygonReader.Create(gear.ShiftPolygon)
-					: DeclarationData.Gearbox.ComputeShiftPolygon(gearbox.Type, (int)i, engineData.FullLoadCurves[i + 1], gearbox.Gears,
-						engineData,
-						axlegearRatio, dynamicTyreRadius);
-				var gearData = new GearData {
-					ShiftPolygon = shiftPolygon,
-					MaxSpeed = gear.MaxInputSpeed,
-					Ratio = gear.Ratio,
-					LossMap = lossMap,
-				};
-
-				if (gearbox.Type == GearboxType.ATPowerSplit && i == 0) {
-					// powersplit transmission: torque converter already contains ratio and losses
-					CretateTCFirstGearATPowerSplit(gearData, i, tcShiftPolygon);
-				}
-				if (gearbox.Type == GearboxType.ATSerial) {
-					if (i == 0) {
-						// torqueconverter is active in first gear - duplicate ratio and lossmap for torque converter mode
-						CreateTCFirstGearATSerial(gearData, tcShiftPolygon);
-					}
-					if (i == 1 && gearDifferenceRatio >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold) {
-						// ratio between first and second gear is above threshold, torqueconverter is active in second gear as well
-						// -> duplicate ratio and lossmap for torque converter mode, remove locked transmission for previous gear
-						CreateTCSecondGearATSerial(gearData, tcShiftPolygon);
-						// NOTE: the lower gear in 'gears' dictionary has index i !!
-						gears[i].Ratio = double.NaN;
-						gears[i].LossMap = null;
-					}
-				}
-				gears.Add(i + 1, gearData);
-			}
-			retVal.Gears = gears;
-
-			if (retVal.Type.AutomaticTransmission()) {
-				var ratio = double.IsNaN(retVal.Gears[1].Ratio) ? 1 : retVal.Gears[1].TorqueConverterRatio / retVal.Gears[1].Ratio;
-				retVal.PowershiftShiftTime = gearbox.PowershiftShiftTime;
-				retVal.TorqueConverterData = TorqueConverterDataReader.Create(gearbox.TorqueConverter.TCData,
-					gearbox.TorqueConverter.ReferenceRPM, gearbox.TorqueConverter.MaxInputSpeed, ExecutionMode.Engineering, ratio,
-					gearbox.TorqueConverter.CLUpshiftMinAcceleration, gearbox.TorqueConverter.CCUpshiftMinAcceleration);
-			}
-
-
-			return retVal;
-		}
-
-		private static void SetEngineeringData(IGearboxEngineeringInputData gearbox, GearboxData retVal)
-		{
-			retVal.Inertia = gearbox.Type.ManualTransmission() ? gearbox.Inertia : 0.SI<KilogramSquareMeter>();
-			retVal.TractionInterruption = gearbox.TractionInterruption;
-			retVal.TorqueReserve = gearbox.TorqueReserve;
-			retVal.StartTorqueReserve = gearbox.StartTorqueReserve;
-			retVal.ShiftTime = gearbox.MinTimeBetweenGearshift;
-			retVal.StartSpeed = gearbox.StartSpeed;
-			retVal.StartAcceleration = gearbox.StartAcceleration;
-			retVal.DownshiftAfterUpshiftDelay = gearbox.DownshiftAfterUpshiftDelay;
-			retVal.UpshiftAfterDownshiftDelay = gearbox.UpshiftAfterDownshiftDelay;
-			retVal.UpshiftMinAcceleration = gearbox.UpshiftMinAcceleration;
-		}
-
-
-		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesEngineeringInputData auxInputData)
-		{
-			var auxList = new List<VectoRunData.AuxData>(auxInputData.Auxiliaries.Count + 1) {
-				new VectoRunData.AuxData { ID = Constants.Auxiliaries.Cycle, DemandType = AuxiliaryDemandType.Direct }
-			};
-
-			foreach (var a in auxInputData.Auxiliaries) {
-				switch (a.AuxiliaryType) {
-					case AuxiliaryDemandType.Mapping:
-						auxList.Add(CreateMappingAuxiliary(a));
-						break;
-					case AuxiliaryDemandType.Constant:
-						auxList.Add(CreateConstantAuxiliary(a));
-						break;
-					default:
-						throw new VectoException("Auxiliary type {0} not supported!", a.AuxiliaryType);
-				}
-			}
-			return auxList;
-		}
-
-		private static VectoRunData.AuxData CreateMappingAuxiliary(IAuxiliaryEngineeringInputData a)
-		{
-			if (a.DemandMap == null) {
-				throw new VectoSimulationException("Demand Map for auxiliary {0} required", a.ID);
-			}
-			if (a.DemandMap.Columns.Count != 3 || a.DemandMap.Rows.Count < 4) {
-				throw new VectoSimulationException(
-					"Demand Map for auxiliary {0} has to contain exactly 3 columns and at least 4 rows", a.ID);
-			}
-			return new VectoRunData.AuxData {
-				ID = a.ID,
-				DemandType = AuxiliaryDemandType.Mapping,
-				Data = AuxiliaryDataReader.Create(a)
-			};
-		}
-
-		private static VectoRunData.AuxData CreateConstantAuxiliary(IAuxiliaryEngineeringInputData a)
-		{
-			return new VectoRunData.AuxData {
-				ID = a.ID,
-				DemandType = AuxiliaryDemandType.Constant,
-				PowerDemand = a.ConstantPowerDemand
-			};
-		}
-
-		internal DriverData CreateDriverData(IDriverEngineeringInputData driver)
-		{
-			if (driver.SavedInDeclarationMode) {
-				WarnEngineeringMode("DriverData");
-			}
-
-			AccelerationCurveData accelerationData = null;
-			if (driver.AccelerationCurve != null) {
-				accelerationData = AccelerationCurveReader.Create(driver.AccelerationCurve);
-			}
-
-			if (driver.Lookahead == null) {
-				throw new VectoSimulationException("Error: Lookahead Data is missing.");
-			}
-			var lookAheadData = new DriverData.LACData {
-				Enabled = driver.Lookahead.Enabled,
-				//Deceleration = driver.Lookahead.Deceleration,
-				MinSpeed = driver.Lookahead.MinSpeed,
-				LookAheadDecisionFactor =
-					new LACDecisionFactor(driver.Lookahead.CoastingDecisionFactorOffset, driver.Lookahead.CoastingDecisionFactorScaling,
-						driver.Lookahead.CoastingDecisionFactorTargetSpeedLookup,
-						driver.Lookahead.CoastingDecisionFactorVelocityDropLookup),
-				LookAheadDistanceFactor = driver.Lookahead.LookaheadDistanceFactor
-			};
-			var overspeedData = new DriverData.OverSpeedEcoRollData {
-				Mode = driver.OverSpeedEcoRoll.Mode,
-				MinSpeed = driver.OverSpeedEcoRoll.MinSpeed,
-				OverSpeed = driver.OverSpeedEcoRoll.OverSpeed,
-				UnderSpeed = driver.OverSpeedEcoRoll.UnderSpeed,
-			};
-			var retVal = new DriverData {
-				AccelerationCurve = accelerationData,
-				LookAheadCoasting = lookAheadData,
-				OverSpeedEcoRoll = overspeedData,
-			};
-			return retVal;
-		}
-
-		//=================================
-		public RetarderData CreateRetarderData(IRetarderInputData retarder)
-		{
-			return SetCommonRetarderData(retarder);
-		}
-
-		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto)
-		{
-			if (pto.PTOTransmissionType != "None") {
-				var ptoData = new PTOData {
-					TransmissionType = pto.PTOTransmissionType,
-					LossMap = PTOIdleLossMapReader.Create(pto.PTOLossMap),
-				};
-				if (pto.PTOCycle != null) {
-					ptoData.PTOCycle = DrivingCycleDataReader.ReadFromDataTable(pto.PTOCycle, CycleType.PTO, "PTO", false);
-				}
-				return ptoData;
-			}
-
-			return null;
-		}
-
-		public AdvancedAuxData CreateAdvancedAuxData(IAuxiliariesEngineeringInputData auxInputData)
-		{
-			return new AdvancedAuxData() {
-				AdvancedAuxiliaryFilePath = auxInputData.AdvancedAuxiliaryFilePath,
-				AuxiliaryAssembly = auxInputData.AuxiliaryAssembly,
-				AuxiliaryVersion = auxInputData.AuxiliaryVersion
-			};
-		}
-	}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
+{
+	public class EngineeringDataAdapter : AbstractSimulationDataAdapter
+	{
+		internal VehicleData CreateVehicleData(IVehicleEngineeringInputData data)
+		{
+			if (data.SavedInDeclarationMode) {
+				WarnEngineeringMode("VehicleData");
+			}
+
+			var retVal = SetCommonVehicleData(data);
+			retVal.BodyAndTrailerWeight = data.CurbMassExtra;
+			//retVal.CurbWeight += data.CurbMassExtra;
+			retVal.TrailerGrossVehicleWeight = 0.SI<Kilogram>();
+			retVal.Loading = data.Loading;
+			retVal.DynamicTyreRadius = data.DynamicTyreRadius;
+			var axles = data.Axles;
+
+
+			retVal.AxleData = axles.Select(axle => new Axle {
+				WheelsDimension = axle.Wheels,
+				Inertia = axle.Inertia,
+				TwinTyres = axle.TwinTyres,
+				RollResistanceCoefficient = axle.RollResistanceCoefficient,
+				AxleWeightShare = axle.AxleWeightShare,
+				TyreTestLoad = axle.TyreTestLoad,
+				//Wheels = axle.WheelsStr
+			}).ToList();
+			return retVal;
+		}
+
+		public AirdragData CreateAirdragData(IAirdragEngineeringInputData airdragData, IVehicleEngineeringInputData data)
+		{
+			var retVal = SetCommonAirdragData(airdragData);
+			retVal.CrossWindCorrectionMode = airdragData.CrossWindCorrectionMode;
+
+			switch (airdragData.CrossWindCorrectionMode) {
+				case CrossWindCorrectionMode.NoCorrection:
+					retVal.CrossWindCorrectionCurve =
+						new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
+							CrossWindCorrectionCurveReader.GetNoCorrectionCurve(airdragData.AirDragArea),
+							CrossWindCorrectionMode.NoCorrection);
+					break;
+				case CrossWindCorrectionMode.SpeedDependentCorrectionFactor:
+					retVal.CrossWindCorrectionCurve = new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
+						CrossWindCorrectionCurveReader.ReadSpeedDependentCorrectionCurve(airdragData.CrosswindCorrectionMap,
+							airdragData.AirDragArea), CrossWindCorrectionMode.SpeedDependentCorrectionFactor);
+					break;
+				case CrossWindCorrectionMode.VAirBetaLookupTable:
+					retVal.CrossWindCorrectionCurve = new CrosswindCorrectionVAirBeta(airdragData.AirDragArea,
+						CrossWindCorrectionCurveReader.ReadCdxABetaTable(airdragData.CrosswindCorrectionMap));
+					break;
+				case CrossWindCorrectionMode.DeclarationModeCorrection:
+					var height = DeclarationData.Segments.LookupHeight(data.VehicleCategory, data.AxleConfiguration,
+						data.GrossVehicleMassRating);
+					retVal.CrossWindCorrectionCurve =
+						new CrosswindCorrectionCdxALookup(airdragData.AirDragArea,
+							DeclarationDataAdapter.GetDeclarationAirResistanceCurve(
+								GetAirdragParameterSet(data.VehicleCategory, data.AxleConfiguration, data.Axles.Count),
+								airdragData.AirDragArea, height), CrossWindCorrectionMode.DeclarationModeCorrection);
+					break;
+				default:
+					throw new ArgumentOutOfRangeException("CrosswindCorrection", airdragData.CrossWindCorrectionMode.ToString());
+			}
+			return retVal;
+		}
+
+		private string GetAirdragParameterSet(VehicleCategory vehicleCategory, AxleConfiguration axles, int numAxles)
+		{
+			switch (vehicleCategory) {
+				case VehicleCategory.RigidTruck:
+					return numAxles > axles.NumAxles() ? "RigidTrailer" : "RigidSolo";
+				case VehicleCategory.Tractor:
+					return "TractorSemitrailer";
+				case VehicleCategory.CityBus:
+				case VehicleCategory.InterurbanBus:
+				case VehicleCategory.Coach:
+					return "CoachBus";
+				default:
+					throw new ArgumentOutOfRangeException("vehicleCategory", vehicleCategory, null);
+			}
+		}
+
+		private void WarnEngineeringMode(string msg)
+		{
+			Log.Error("{0} is in Declaration Mode but is used for Engineering Mode!", msg);
+		}
+
+		internal CombustionEngineData CreateEngineData(IEngineEngineeringInputData engine, IGearboxEngineeringInputData gbx,
+			IEnumerable<ITorqueLimitInputData> torqueLimits)
+		{
+			if (engine.SavedInDeclarationMode) {
+				WarnEngineeringMode("EngineData");
+			}
+
+			var retVal = SetCommonCombustionEngineData(engine);
+			retVal.Inertia = engine.Inertia +
+							(gbx != null && gbx.Type.AutomaticTransmission() ? gbx.TorqueConverter.Inertia : 0.SI<KilogramSquareMeter>());
+			var limits = torqueLimits.ToDictionary(e => e.Gear);
+			var numGears = gbx == null ? 0 : gbx.Gears.Count;
+			var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
+			fullLoadCurves[0] = FullLoadCurveReader.Create(engine.FullLoadCurve);
+			fullLoadCurves[0].EngineData = retVal;
+			if (gbx != null) {
+				foreach (var gear in gbx.Gears) {
+					var maxTorque = VectoMath.Min(gear.MaxTorque, limits.ContainsKey(gear.Gear) ? limits[gear.Gear].MaxTorque : null);
+					fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
+				}
+			}
+			retVal.FullLoadCurves = fullLoadCurves;
+			retVal.FuelConsumptionCorrectionFactor = engine.WHTCEngineering;
+			return retVal;
+		}
+
+		internal GearboxData CreateGearboxData(IGearboxEngineeringInputData gearbox, CombustionEngineData engineData,
+			double axlegearRatio, Meter dynamicTyreRadius, VehicleCategory vehicleCategory, bool useEfficiencyFallback)
+		{
+			if (gearbox.SavedInDeclarationMode) {
+				WarnEngineeringMode("GearboxData");
+			}
+
+			var retVal = SetCommonGearboxData(gearbox);
+
+			//var gears = gearbox.Gears;
+			if (gearbox.Gears.Count < 2) {
+				throw new VectoSimulationException("At least two Gear-Entries must be defined in Gearbox!");
+			}
+
+			SetEngineeringData(gearbox, retVal);
+
+			var gearDifferenceRatio = gearbox.Type.AutomaticTransmission() && gearbox.Gears.Count > 2
+				? gearbox.Gears[0].Ratio / gearbox.Gears[1].Ratio
+				: 1.0;
+
+			var gears = new Dictionary<uint, GearData>();
+			ShiftPolygon tcShiftPolygon = null;
+			if (gearbox.Type.AutomaticTransmission()) {
+				tcShiftPolygon = gearbox.TorqueConverter.ShiftPolygon != null
+					? ShiftPolygonReader.Create(gearbox.TorqueConverter.ShiftPolygon)
+					: DeclarationData.TorqueConverter.ComputeShiftPolygon(engineData.FullLoadCurves[0]);
+			}
+			for (uint i = 0; i < gearbox.Gears.Count; i++) {
+				var gear = gearbox.Gears[(int)i];
+				var lossMap = CreateGearLossMap(gear, i, useEfficiencyFallback, false);
+
+				var shiftPolygon = gear.ShiftPolygon != null && gear.ShiftPolygon.SourceType != DataSourceType.Missing
+					? ShiftPolygonReader.Create(gear.ShiftPolygon)
+					: DeclarationData.Gearbox.ComputeShiftPolygon(gearbox.Type, (int)i, engineData.FullLoadCurves[i + 1], gearbox.Gears,
+						engineData,
+						axlegearRatio, dynamicTyreRadius);
+				var gearData = new GearData {
+					ShiftPolygon = shiftPolygon,
+					MaxSpeed = gear.MaxInputSpeed,
+					Ratio = gear.Ratio,
+					LossMap = lossMap,
+				};
+
+				if (gearbox.Type == GearboxType.ATPowerSplit && i == 0) {
+					// powersplit transmission: torque converter already contains ratio and losses
+					CretateTCFirstGearATPowerSplit(gearData, i, tcShiftPolygon);
+				}
+				if (gearbox.Type == GearboxType.ATSerial) {
+					if (i == 0) {
+						// torqueconverter is active in first gear - duplicate ratio and lossmap for torque converter mode
+						CreateTCFirstGearATSerial(gearData, tcShiftPolygon);
+					}
+					if (i == 1 && gearDifferenceRatio >= DeclarationData.Gearbox.TorqueConverterSecondGearThreshold(vehicleCategory)) {
+						// ratio between first and second gear is above threshold, torqueconverter is active in second gear as well
+						// -> duplicate ratio and lossmap for torque converter mode, remove locked transmission for previous gear
+						CreateTCSecondGearATSerial(gearData, tcShiftPolygon);
+						// NOTE: the lower gear in 'gears' dictionary has index i !!
+						gears[i].Ratio = double.NaN;
+						gears[i].LossMap = null;
+					}
+				}
+				gears.Add(i + 1, gearData);
+			}
+			retVal.Gears = gears;
+
+			if (retVal.Type.AutomaticTransmission()) {
+				var ratio = double.IsNaN(retVal.Gears[1].Ratio) ? 1 : retVal.Gears[1].TorqueConverterRatio / retVal.Gears[1].Ratio;
+				retVal.PowershiftShiftTime = gearbox.PowershiftShiftTime;
+				retVal.TorqueConverterData = TorqueConverterDataReader.Create(gearbox.TorqueConverter.TCData,
+					gearbox.TorqueConverter.ReferenceRPM, gearbox.TorqueConverter.MaxInputSpeed, ExecutionMode.Engineering, ratio,
+					gearbox.TorqueConverter.CLUpshiftMinAcceleration, gearbox.TorqueConverter.CCUpshiftMinAcceleration);
+			}
+
+
+			return retVal;
+		}
+
+		private static void SetEngineeringData(IGearboxEngineeringInputData gearbox, GearboxData retVal)
+		{
+			retVal.Inertia = gearbox.Type.ManualTransmission() ? gearbox.Inertia : 0.SI<KilogramSquareMeter>();
+			retVal.TractionInterruption = gearbox.TractionInterruption;
+			retVal.TorqueReserve = gearbox.TorqueReserve;
+			retVal.StartTorqueReserve = gearbox.StartTorqueReserve;
+			retVal.ShiftTime = gearbox.MinTimeBetweenGearshift;
+			retVal.StartSpeed = gearbox.StartSpeed;
+			retVal.StartAcceleration = gearbox.StartAcceleration;
+			retVal.DownshiftAfterUpshiftDelay = gearbox.DownshiftAfterUpshiftDelay;
+			retVal.UpshiftAfterDownshiftDelay = gearbox.UpshiftAfterDownshiftDelay;
+			retVal.UpshiftMinAcceleration = gearbox.UpshiftMinAcceleration;
+		}
+
+
+		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesEngineeringInputData auxInputData)
+		{
+			var auxList = new List<VectoRunData.AuxData>(auxInputData.Auxiliaries.Count + 1) {
+				new VectoRunData.AuxData { ID = Constants.Auxiliaries.Cycle, DemandType = AuxiliaryDemandType.Direct }
+			};
+
+			foreach (var a in auxInputData.Auxiliaries) {
+				switch (a.AuxiliaryType) {
+					case AuxiliaryDemandType.Mapping:
+						auxList.Add(CreateMappingAuxiliary(a));
+						break;
+					case AuxiliaryDemandType.Constant:
+						auxList.Add(CreateConstantAuxiliary(a));
+						break;
+					default:
+						throw new VectoException("Auxiliary type {0} not supported!", a.AuxiliaryType);
+				}
+			}
+			return auxList;
+		}
+
+		private static VectoRunData.AuxData CreateMappingAuxiliary(IAuxiliaryEngineeringInputData a)
+		{
+			if (a.DemandMap == null) {
+				throw new VectoSimulationException("Demand Map for auxiliary {0} required", a.ID);
+			}
+			if (a.DemandMap.Columns.Count != 3 || a.DemandMap.Rows.Count < 4) {
+				throw new VectoSimulationException(
+					"Demand Map for auxiliary {0} has to contain exactly 3 columns and at least 4 rows", a.ID);
+			}
+			return new VectoRunData.AuxData {
+				ID = a.ID,
+				DemandType = AuxiliaryDemandType.Mapping,
+				Data = AuxiliaryDataReader.Create(a)
+			};
+		}
+
+		private static VectoRunData.AuxData CreateConstantAuxiliary(IAuxiliaryEngineeringInputData a)
+		{
+			return new VectoRunData.AuxData {
+				ID = a.ID,
+				DemandType = AuxiliaryDemandType.Constant,
+				PowerDemand = a.ConstantPowerDemand
+			};
+		}
+
+		internal DriverData CreateDriverData(IDriverEngineeringInputData driver)
+		{
+			if (driver.SavedInDeclarationMode) {
+				WarnEngineeringMode("DriverData");
+			}
+
+			AccelerationCurveData accelerationData = null;
+			if (driver.AccelerationCurve != null) {
+				accelerationData = AccelerationCurveReader.Create(driver.AccelerationCurve);
+			}
+
+			if (driver.Lookahead == null) {
+				throw new VectoSimulationException("Error: Lookahead Data is missing.");
+			}
+			var lookAheadData = new DriverData.LACData {
+				Enabled = driver.Lookahead.Enabled,
+				//Deceleration = driver.Lookahead.Deceleration,
+				MinSpeed = driver.Lookahead.MinSpeed,
+				LookAheadDecisionFactor =
+					new LACDecisionFactor(driver.Lookahead.CoastingDecisionFactorOffset, driver.Lookahead.CoastingDecisionFactorScaling,
+						driver.Lookahead.CoastingDecisionFactorTargetSpeedLookup,
+						driver.Lookahead.CoastingDecisionFactorVelocityDropLookup),
+				LookAheadDistanceFactor = driver.Lookahead.LookaheadDistanceFactor
+			};
+			var overspeedData = new DriverData.OverSpeedEcoRollData {
+				Mode = driver.OverSpeedEcoRoll.Mode,
+				MinSpeed = driver.OverSpeedEcoRoll.MinSpeed,
+				OverSpeed = driver.OverSpeedEcoRoll.OverSpeed,
+				UnderSpeed = driver.OverSpeedEcoRoll.UnderSpeed,
+			};
+			var retVal = new DriverData {
+				AccelerationCurve = accelerationData,
+				LookAheadCoasting = lookAheadData,
+				OverSpeedEcoRoll = overspeedData,
+			};
+			return retVal;
+		}
+
+		//=================================
+		public RetarderData CreateRetarderData(IRetarderInputData retarder)
+		{
+			return SetCommonRetarderData(retarder);
+		}
+
+		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto)
+		{
+			if (pto.PTOTransmissionType != "None") {
+				var ptoData = new PTOData {
+					TransmissionType = pto.PTOTransmissionType,
+					LossMap = PTOIdleLossMapReader.Create(pto.PTOLossMap),
+				};
+				if (pto.PTOCycle != null) {
+					ptoData.PTOCycle = DrivingCycleDataReader.ReadFromDataTable(pto.PTOCycle, CycleType.PTO, "PTO", false);
+				}
+				return ptoData;
+			}
+
+			return null;
+		}
+
+		public AdvancedAuxData CreateAdvancedAuxData(IAuxiliariesEngineeringInputData auxInputData)
+		{
+			return new AdvancedAuxData() {
+				AdvancedAuxiliaryFilePath = auxInputData.AdvancedAuxiliaryFilePath,
+				AuxiliaryAssembly = auxInputData.AuxiliaryAssembly,
+				AuxiliaryVersion = auxInputData.AuxiliaryVersion
+			};
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/Reader/Impl/DeclarationModeVectoRunDataFactory.cs b/VectoCore/VectoCore/InputData/Reader/Impl/DeclarationModeVectoRunDataFactory.cs
index 99b9a05a567f7fdae998099264f16f84e5a7ae94..8a61d30f9378869da8e4711a1e544f2c475383d3 100644
--- a/VectoCore/VectoCore/InputData/Reader/Impl/DeclarationModeVectoRunDataFactory.cs
+++ b/VectoCore/VectoCore/InputData/Reader/Impl/DeclarationModeVectoRunDataFactory.cs
@@ -29,174 +29,174 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.InputData.Reader.ComponentData;
-using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
-using TUGraz.VectoCore.Models.Declaration;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-using TUGraz.VectoCore.OutputData;
-using TUGraz.VectoCore.Utils;
-
-
-namespace TUGraz.VectoCore.InputData.Reader.Impl
-{
-	public class DeclarationModeVectoRunDataFactory : LoggingObject, IVectoRunDataFactory
-	{
-		private static readonly object CyclesCacheLock = new object();
-
-		private static readonly Dictionary<MissionType, DrivingCycleData> CyclesCache =
-			new Dictionary<MissionType, DrivingCycleData>();
-
-		protected readonly IDeclarationInputDataProvider InputDataProvider;
-
-		protected IDeclarationReport Report;
-		private DeclarationDataAdapter _dao;
-		private Segment _segment;
-		private DriverData _driverdata;
-		private AirdragData _airdragData;
-		private CombustionEngineData _engineData;
-		private AxleGearData _axlegearData;
-		private AngledriveData _angledriveData;
-		private GearboxData _gearboxData;
-		private RetarderData _retarderData;
-		private PTOData _ptoTransmissionData;
-		private PTOData _municipalPtoTransmissionData;
-		private Exception InitException;
-
-		internal DeclarationModeVectoRunDataFactory(IDeclarationInputDataProvider dataProvider, IDeclarationReport report)
-		{
-			InputDataProvider = dataProvider;
-			Report = report;
-
-			try {
-				Initialize();
-				if (Report != null) {
-					InitializeReport();
-				}
-			} catch (Exception e) {
-				InitException = e;
-			}
-		}
-
-		private void Initialize()
-		{
-			_dao = new DeclarationDataAdapter();
-			_segment = GetVehicleClassification(InputDataProvider.VehicleInputData.VehicleCategory,
-				InputDataProvider.VehicleInputData.AxleConfiguration,
-				InputDataProvider.VehicleInputData.GrossVehicleMassRating, InputDataProvider.VehicleInputData.CurbMassChassis);
-			_driverdata = _dao.CreateDriverData(InputDataProvider.DriverInputData);
-			_driverdata.AccelerationCurve = AccelerationCurveReader.ReadFromStream(_segment.AccelerationFile);
-
-			var tempVehicle = _dao.CreateVehicleData(InputDataProvider.VehicleInputData, _segment.Missions.First(),
-				_segment.Missions.First().Loadings.First().Value, _segment.MunicipalBodyWeight);
-			_airdragData = _dao.CreateAirdragData(InputDataProvider.AirdragInputData, _segment.Missions.First(), _segment);
-			_engineData = _dao.CreateEngineData(InputDataProvider.EngineInputData,
-				InputDataProvider.VehicleInputData.EngineIdleSpeed,
-				InputDataProvider.GearboxInputData, InputDataProvider.VehicleInputData.TorqueLimits);
-			_axlegearData = _dao.CreateAxleGearData(InputDataProvider.AxleGearInputData, false);
-			_angledriveData = _dao.CreateAngledriveData(InputDataProvider.AngledriveInputData, false);
-			_gearboxData = _dao.CreateGearboxData(InputDataProvider.GearboxInputData, _engineData, _axlegearData.AxleGear.Ratio,
-				tempVehicle.DynamicTyreRadius, false);
-			_retarderData = _dao.CreateRetarderData(InputDataProvider.RetarderInputData);
-
-			_ptoTransmissionData = _dao.CreatePTOTransmissionData(InputDataProvider.PTOTransmissionInputData);
-
-			_municipalPtoTransmissionData = CreateDefaultPTOData();
-		}
-
-		private void InitializeReport()
-		{
-			var powertrainConfig = new VectoRunData() {
-				VehicleData =
-					_dao.CreateVehicleData(InputDataProvider.VehicleInputData, _segment.Missions.First(),
-						_segment.Missions.First().Loadings.First().Value, _segment.MunicipalBodyWeight),
-				AirdragData = _airdragData,
-				EngineData = _engineData,
-				GearboxData = _gearboxData,
-				AxleGearData = _axlegearData,
-				Retarder = _retarderData,
-				Aux = _dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData(), _segment.Missions.First().MissionType,
-					_segment.VehicleClass),
-				InputDataHash = InputDataProvider.XMLHash
-			};
-			Report.InitializeReport(powertrainConfig, _segment);
-		}
-
-		public IEnumerable<VectoRunData> NextRun()
-		{
-			if (InitException != null) {
-				throw InitException;
-			}
-
-			foreach (var mission in _segment.Missions) {
-				if (mission.MissionType.IsEMS() &&
-					_engineData.RatedPowerDeclared.IsSmaller(DeclarationData.MinEnginePowerForEMS)) {
-					continue;
-				}
-				DrivingCycleData cycle;
-				lock (CyclesCacheLock) {
-					if (CyclesCache.ContainsKey(mission.MissionType)) {
-						cycle = CyclesCache[mission.MissionType];
-					} else {
-						cycle = DrivingCycleDataReader.ReadFromStream(mission.CycleFile, CycleType.DistanceBased, "", false);
-						CyclesCache.Add(mission.MissionType, cycle);
-					}
-				}
-				foreach (var loading in mission.Loadings) {
-					var simulationRunData = new VectoRunData {
-						Loading = loading.Key,
-						VehicleData =
-							_dao.CreateVehicleData(InputDataProvider.VehicleInputData, mission, loading.Value, _segment.MunicipalBodyWeight),
-						AirdragData = _dao.CreateAirdragData(InputDataProvider.AirdragInputData, mission, _segment),
-						EngineData = _engineData.Copy(),
-						GearboxData = _gearboxData,
-						AxleGearData = _axlegearData,
-						AngledriveData = _angledriveData,
-						Aux = _dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData(), mission.MissionType,
-							_segment.VehicleClass),
-						Cycle = new DrivingCycleProxy(cycle, mission.MissionType.ToString()),
-						Retarder = _retarderData,
-						DriverData = _driverdata,
-						ExecutionMode = ExecutionMode.Declaration,
-						JobName = InputDataProvider.JobInputData().JobName,
-						ModFileSuffix = loading.Key.ToString(),
-						Report = Report,
-						Mission = mission,
-						PTO = mission.MissionType == MissionType.MunicipalUtility
-							? _municipalPtoTransmissionData
-							: _ptoTransmissionData,
-						InputDataHash = InputDataProvider.XMLHash
-					};
-					simulationRunData.EngineData.FuelConsumptionCorrectionFactor = DeclarationData.WHTCCorrection.Lookup(
-						mission.MissionType.GetNonEMSMissionType(), _engineData.WHTCRural, _engineData.WHTCUrban, _engineData.WHTCMotorway) *
-																					_engineData.ColdHotCorrectionFactor;
-					simulationRunData.VehicleData.VehicleClass = _segment.VehicleClass;
-					yield return simulationRunData;
-				}
-			}
-		}
-
-		private PTOData CreateDefaultPTOData()
-		{
-			return new PTOData() {
-				TransmissionType = DeclarationData.PTO.DefaultPTOTechnology,
-				LossMap = PTOIdleLossMapReader.ReadFromStream(RessourceHelper.ReadStream(DeclarationData.PTO.DefaultPTOIdleLosses)),
-				PTOCycle =
-					DrivingCycleDataReader.ReadFromStream(RessourceHelper.ReadStream(DeclarationData.PTO.DefaultPTOActivationCycle),
-						CycleType.PTO, "PTO", false)
-			};
-		}
-
-		internal Segment GetVehicleClassification(VehicleCategory category, AxleConfiguration axles, Kilogram grossMassRating,
-			Kilogram curbWeight)
-		{
-			return DeclarationData.Segments.Lookup(category, axles, grossMassRating, curbWeight);
-		}
-	}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.OutputData;
+using TUGraz.VectoCore.Utils;
+
+
+namespace TUGraz.VectoCore.InputData.Reader.Impl
+{
+	public class DeclarationModeVectoRunDataFactory : LoggingObject, IVectoRunDataFactory
+	{
+		private static readonly object CyclesCacheLock = new object();
+
+		private static readonly Dictionary<MissionType, DrivingCycleData> CyclesCache =
+			new Dictionary<MissionType, DrivingCycleData>();
+
+		protected readonly IDeclarationInputDataProvider InputDataProvider;
+
+		protected IDeclarationReport Report;
+		private DeclarationDataAdapter _dao;
+		private Segment _segment;
+		private DriverData _driverdata;
+		private AirdragData _airdragData;
+		private CombustionEngineData _engineData;
+		private AxleGearData _axlegearData;
+		private AngledriveData _angledriveData;
+		private GearboxData _gearboxData;
+		private RetarderData _retarderData;
+		private PTOData _ptoTransmissionData;
+		private PTOData _municipalPtoTransmissionData;
+		private Exception InitException;
+
+		internal DeclarationModeVectoRunDataFactory(IDeclarationInputDataProvider dataProvider, IDeclarationReport report)
+		{
+			InputDataProvider = dataProvider;
+			Report = report;
+
+			try {
+				Initialize();
+				if (Report != null) {
+					InitializeReport();
+				}
+			} catch (Exception e) {
+				InitException = e;
+			}
+		}
+
+		private void Initialize()
+		{
+			_dao = new DeclarationDataAdapter();
+			_segment = GetVehicleClassification(InputDataProvider.VehicleInputData.VehicleCategory,
+				InputDataProvider.VehicleInputData.AxleConfiguration,
+				InputDataProvider.VehicleInputData.GrossVehicleMassRating, InputDataProvider.VehicleInputData.CurbMassChassis);
+			_driverdata = _dao.CreateDriverData(InputDataProvider.DriverInputData);
+			_driverdata.AccelerationCurve = AccelerationCurveReader.ReadFromStream(_segment.AccelerationFile);
+
+			var tempVehicle = _dao.CreateVehicleData(InputDataProvider.VehicleInputData, _segment.Missions.First(),
+				_segment.Missions.First().Loadings.First().Value, _segment.MunicipalBodyWeight);
+			_airdragData = _dao.CreateAirdragData(InputDataProvider.AirdragInputData, _segment.Missions.First(), _segment);
+			_engineData = _dao.CreateEngineData(InputDataProvider.EngineInputData,
+				InputDataProvider.VehicleInputData.EngineIdleSpeed,
+				InputDataProvider.GearboxInputData, InputDataProvider.VehicleInputData.TorqueLimits);
+			_axlegearData = _dao.CreateAxleGearData(InputDataProvider.AxleGearInputData, false);
+			_angledriveData = _dao.CreateAngledriveData(InputDataProvider.AngledriveInputData, false);
+			_gearboxData = _dao.CreateGearboxData(InputDataProvider.GearboxInputData, _engineData, _axlegearData.AxleGear.Ratio,
+				tempVehicle.DynamicTyreRadius, tempVehicle.VehicleCategory, false);
+			_retarderData = _dao.CreateRetarderData(InputDataProvider.RetarderInputData);
+
+			_ptoTransmissionData = _dao.CreatePTOTransmissionData(InputDataProvider.PTOTransmissionInputData);
+
+			_municipalPtoTransmissionData = CreateDefaultPTOData();
+		}
+
+		private void InitializeReport()
+		{
+			var powertrainConfig = new VectoRunData() {
+				VehicleData =
+					_dao.CreateVehicleData(InputDataProvider.VehicleInputData, _segment.Missions.First(),
+						_segment.Missions.First().Loadings.First().Value, _segment.MunicipalBodyWeight),
+				AirdragData = _airdragData,
+				EngineData = _engineData,
+				GearboxData = _gearboxData,
+				AxleGearData = _axlegearData,
+				Retarder = _retarderData,
+				Aux = _dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData(), _segment.Missions.First().MissionType,
+					_segment.VehicleClass),
+				InputDataHash = InputDataProvider.XMLHash
+			};
+			Report.InitializeReport(powertrainConfig, _segment);
+		}
+
+		public IEnumerable<VectoRunData> NextRun()
+		{
+			if (InitException != null) {
+				throw InitException;
+			}
+
+			foreach (var mission in _segment.Missions) {
+				if (mission.MissionType.IsEMS() &&
+					_engineData.RatedPowerDeclared.IsSmaller(DeclarationData.MinEnginePowerForEMS)) {
+					continue;
+				}
+				DrivingCycleData cycle;
+				lock (CyclesCacheLock) {
+					if (CyclesCache.ContainsKey(mission.MissionType)) {
+						cycle = CyclesCache[mission.MissionType];
+					} else {
+						cycle = DrivingCycleDataReader.ReadFromStream(mission.CycleFile, CycleType.DistanceBased, "", false);
+						CyclesCache.Add(mission.MissionType, cycle);
+					}
+				}
+				foreach (var loading in mission.Loadings) {
+					var simulationRunData = new VectoRunData {
+						Loading = loading.Key,
+						VehicleData =
+							_dao.CreateVehicleData(InputDataProvider.VehicleInputData, mission, loading.Value, _segment.MunicipalBodyWeight),
+						AirdragData = _dao.CreateAirdragData(InputDataProvider.AirdragInputData, mission, _segment),
+						EngineData = _engineData.Copy(),
+						GearboxData = _gearboxData,
+						AxleGearData = _axlegearData,
+						AngledriveData = _angledriveData,
+						Aux = _dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData(), mission.MissionType,
+							_segment.VehicleClass),
+						Cycle = new DrivingCycleProxy(cycle, mission.MissionType.ToString()),
+						Retarder = _retarderData,
+						DriverData = _driverdata,
+						ExecutionMode = ExecutionMode.Declaration,
+						JobName = InputDataProvider.JobInputData().JobName,
+						ModFileSuffix = loading.Key.ToString(),
+						Report = Report,
+						Mission = mission,
+						PTO = mission.MissionType == MissionType.MunicipalUtility
+							? _municipalPtoTransmissionData
+							: _ptoTransmissionData,
+						InputDataHash = InputDataProvider.XMLHash
+					};
+					simulationRunData.EngineData.FuelConsumptionCorrectionFactor = DeclarationData.WHTCCorrection.Lookup(
+						mission.MissionType.GetNonEMSMissionType(), _engineData.WHTCRural, _engineData.WHTCUrban, _engineData.WHTCMotorway) *
+																					_engineData.ColdHotCorrectionFactor;
+					simulationRunData.VehicleData.VehicleClass = _segment.VehicleClass;
+					yield return simulationRunData;
+				}
+			}
+		}
+
+		private PTOData CreateDefaultPTOData()
+		{
+			return new PTOData() {
+				TransmissionType = DeclarationData.PTO.DefaultPTOTechnology,
+				LossMap = PTOIdleLossMapReader.ReadFromStream(RessourceHelper.ReadStream(DeclarationData.PTO.DefaultPTOIdleLosses)),
+				PTOCycle =
+					DrivingCycleDataReader.ReadFromStream(RessourceHelper.ReadStream(DeclarationData.PTO.DefaultPTOActivationCycle),
+						CycleType.PTO, "PTO", false)
+			};
+		}
+
+		internal Segment GetVehicleClassification(VehicleCategory category, AxleConfiguration axles, Kilogram grossMassRating,
+			Kilogram curbWeight)
+		{
+			return DeclarationData.Segments.Lookup(category, axles, grossMassRating, curbWeight);
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/Reader/Impl/EngineeringModeVectoRunDataFactory.cs b/VectoCore/VectoCore/InputData/Reader/Impl/EngineeringModeVectoRunDataFactory.cs
index 9a1a7935dbb04f8c4b24252b2334b0d3601559bb..dfcd0c3c747e29c04e293b8c6fff25400f979587 100644
--- a/VectoCore/VectoCore/InputData/Reader/Impl/EngineeringModeVectoRunDataFactory.cs
+++ b/VectoCore/VectoCore/InputData/Reader/Impl/EngineeringModeVectoRunDataFactory.cs
@@ -29,72 +29,72 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-
-[assembly: InternalsVisibleTo("VectoCoreTest")]
-
-namespace TUGraz.VectoCore.InputData.Reader.Impl
-{
-	public class EngineeringModeVectoRunDataFactory : LoggingObject, IVectoRunDataFactory
-	{
-		private static readonly Dictionary<string, DrivingCycleData> CyclesCache = new Dictionary<string, DrivingCycleData>();
-
-		protected readonly IEngineeringInputDataProvider InputDataProvider;
-
-		internal EngineeringModeVectoRunDataFactory(IEngineeringInputDataProvider dataProvider)
-		{
-			InputDataProvider = dataProvider;
-		}
-
-		/// <summary>
-		/// Iterate over all cycles defined in the JobFile and create a container with all data required for creating a simulation run
-		/// </summary>
-		/// <returns>VectoRunData instance for initializing the powertrain.</returns>
-		public virtual IEnumerable<VectoRunData> NextRun()
-		{
-			var dao = new EngineeringDataAdapter();
-			var driver = dao.CreateDriverData(InputDataProvider.DriverInputData);
-			var engineData = dao.CreateEngineData(InputDataProvider.EngineInputData, InputDataProvider.GearboxInputData,
-				InputDataProvider.VehicleInputData.TorqueLimits);
-
-			var tempVehicle = dao.CreateVehicleData(InputDataProvider.VehicleInputData);
-
-			var axlegearData = dao.CreateAxleGearData(InputDataProvider.AxleGearInputData, useEfficiencyFallback: true);
-			var gearboxData = dao.CreateGearboxData(InputDataProvider.GearboxInputData, engineData, axlegearData.AxleGear.Ratio,
-				tempVehicle.DynamicTyreRadius, useEfficiencyFallback: true);
-			var crossWindRequired = InputDataProvider.AirdragInputData.CrossWindCorrectionMode ==
-									CrossWindCorrectionMode.VAirBetaLookupTable;
-			var angledriveData = dao.CreateAngledriveData(InputDataProvider.AngledriveInputData, useEfficiencyFallback: true);
-			var ptoTransmissionData = dao.CreatePTOTransmissionData(InputDataProvider.PTOTransmissionInputData);
-
-			return InputDataProvider.JobInputData().Cycles.Select(cycle => {
-				var drivingCycle = CyclesCache.ContainsKey(cycle.CycleData.Source)
-					? CyclesCache[cycle.CycleData.Source]
-					: DrivingCycleDataReader.ReadFromDataTable(cycle.CycleData, cycle.Name, crossWindRequired);
-				return new VectoRunData {
-					JobName = InputDataProvider.JobInputData().JobName,
-					EngineData = engineData,
-					GearboxData = gearboxData,
-					AxleGearData = axlegearData,
-					AngledriveData = angledriveData,
-					VehicleData = dao.CreateVehicleData(InputDataProvider.VehicleInputData),
-					AirdragData = dao.CreateAirdragData(InputDataProvider.AirdragInputData, InputDataProvider.VehicleInputData),
-					DriverData = driver,
-					Aux = dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData()),
-					AdvancedAux = dao.CreateAdvancedAuxData(InputDataProvider.AuxiliaryInputData()),
-					Retarder = dao.CreateRetarderData(InputDataProvider.RetarderInputData),
-					PTO = ptoTransmissionData,
-					Cycle = new DrivingCycleProxy(drivingCycle, cycle.Name),
-					ExecutionMode = ExecutionMode.Engineering
-				};
-			});
-		}
-	}
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+[assembly: InternalsVisibleTo("VectoCoreTest")]
+
+namespace TUGraz.VectoCore.InputData.Reader.Impl
+{
+	public class EngineeringModeVectoRunDataFactory : LoggingObject, IVectoRunDataFactory
+	{
+		private static readonly Dictionary<string, DrivingCycleData> CyclesCache = new Dictionary<string, DrivingCycleData>();
+
+		protected readonly IEngineeringInputDataProvider InputDataProvider;
+
+		internal EngineeringModeVectoRunDataFactory(IEngineeringInputDataProvider dataProvider)
+		{
+			InputDataProvider = dataProvider;
+		}
+
+		/// <summary>
+		/// Iterate over all cycles defined in the JobFile and create a container with all data required for creating a simulation run
+		/// </summary>
+		/// <returns>VectoRunData instance for initializing the powertrain.</returns>
+		public virtual IEnumerable<VectoRunData> NextRun()
+		{
+			var dao = new EngineeringDataAdapter();
+			var driver = dao.CreateDriverData(InputDataProvider.DriverInputData);
+			var engineData = dao.CreateEngineData(InputDataProvider.EngineInputData, InputDataProvider.GearboxInputData,
+				InputDataProvider.VehicleInputData.TorqueLimits);
+
+			var tempVehicle = dao.CreateVehicleData(InputDataProvider.VehicleInputData);
+
+			var axlegearData = dao.CreateAxleGearData(InputDataProvider.AxleGearInputData, useEfficiencyFallback: true);
+			var gearboxData = dao.CreateGearboxData(InputDataProvider.GearboxInputData, engineData, axlegearData.AxleGear.Ratio,
+				tempVehicle.DynamicTyreRadius,tempVehicle.VehicleCategory, useEfficiencyFallback: true);
+			var crossWindRequired = InputDataProvider.AirdragInputData.CrossWindCorrectionMode ==
+									CrossWindCorrectionMode.VAirBetaLookupTable;
+			var angledriveData = dao.CreateAngledriveData(InputDataProvider.AngledriveInputData, useEfficiencyFallback: true);
+			var ptoTransmissionData = dao.CreatePTOTransmissionData(InputDataProvider.PTOTransmissionInputData);
+
+			return InputDataProvider.JobInputData().Cycles.Select(cycle => {
+				var drivingCycle = CyclesCache.ContainsKey(cycle.CycleData.Source)
+					? CyclesCache[cycle.CycleData.Source]
+					: DrivingCycleDataReader.ReadFromDataTable(cycle.CycleData, cycle.Name, crossWindRequired);
+				return new VectoRunData {
+					JobName = InputDataProvider.JobInputData().JobName,
+					EngineData = engineData,
+					GearboxData = gearboxData,
+					AxleGearData = axlegearData,
+					AngledriveData = angledriveData,
+					VehicleData = dao.CreateVehicleData(InputDataProvider.VehicleInputData),
+					AirdragData = dao.CreateAirdragData(InputDataProvider.AirdragInputData, InputDataProvider.VehicleInputData),
+					DriverData = driver,
+					Aux = dao.CreateAuxiliaryData(InputDataProvider.AuxiliaryInputData()),
+					AdvancedAux = dao.CreateAdvancedAuxData(InputDataProvider.AuxiliaryInputData()),
+					Retarder = dao.CreateRetarderData(InputDataProvider.RetarderInputData),
+					PTO = ptoTransmissionData,
+					Cycle = new DrivingCycleProxy(drivingCycle, cycle.Name),
+					ExecutionMode = ExecutionMode.Engineering
+				};
+			});
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
index 25b74b9bef713ecce1e6622284c721da5e8a4819..ea3022adb098538243405eca1eef263087ba8440 100644
--- a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
+++ b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
@@ -175,7 +175,10 @@ namespace TUGraz.VectoCore.Models.Declaration
 			public static readonly MeterPerSquareSecond UpshiftMinAcceleration = 0.1.SI<MeterPerSquareSecond>();
 
 			//public static readonly PerSecond TorqueConverterSpeedLimit = 1600.RPMtoRad();
-			public static readonly double TorqueConverterSecondGearThreshold = 1.8;
+			public static double TorqueConverterSecondGearThreshold(VehicleCategory category)
+			{
+				return category.IsTruck() ? 1.8 : 1.9;
+			}
 
 			public static readonly Second PowershiftShiftTime = 0.8.SI<Second>();
 
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategy.cs
index d70578e50ffec17b881e327011aab48b359559a8..af2e454f5b6bd98c43436456f99bd9e805dae830 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategy.cs
@@ -29,326 +29,326 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.Models.Simulation.DataBus;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-
-namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
-{
-	public class ATShiftStrategy : BaseShiftStrategy
-	{
-		private ATGearbox _gearbox;
-		private readonly NextGearState _nextGear = new NextGearState();
-
-		public override IGearbox Gearbox
-		{
-			get { return _gearbox; }
-			set {
-				_gearbox = value as ATGearbox;
-				if (_gearbox == null) {
-					throw new VectoException("AT Shift strategy can only handle AT gearboxes, given: {0}", value.GetType());
-				}
-			}
-		}
-
-		public override GearInfo NextGear
-		{
-			get { return new GearInfo(_nextGear.Gear, _nextGear.TorqueConverterLocked); }
-		}
-
-		public ATShiftStrategy(GearboxData data, IDataBus dataBus) : base(data, dataBus) {}
-
-		public override uint InitGear(Second absTime, Second dt, NewtonMeter torque, PerSecond outAngularVelocity)
-		{
-			if (DataBus.VehicleSpeed.IsEqual(0)) {
-				// AT always starts in first gear and TC active!
-				_gearbox.TorqueConverterLocked = false;
-				_gearbox.Disengaged = true;
-				return 1;
-			}
-			var torqueConverterLocked = true;
-			for (var gear = ModelData.Gears.Keys.Max(); gear > 1; gear--) {
-				if (_gearbox.ModelData.Gears[gear].HasTorqueConverter) {
-					torqueConverterLocked = false;
-				}
-				var response = _gearbox.Initialize(gear, torqueConverterLocked, torque, outAngularVelocity);
-
-				if (response.EngineSpeed > DataBus.EngineRatedSpeed || response.EngineSpeed < DataBus.EngineIdleSpeed) {
-					continue;
-				}
-
-				if (!IsBelowDownShiftCurve(gear, response.EnginePowerRequest / response.EngineSpeed, response.EngineSpeed)) {
-					_gearbox.TorqueConverterLocked = torqueConverterLocked;
-					_gearbox.Disengaged = false;
-					return gear;
-				}
-			}
-			// fallback: start with first gear;
-			_gearbox.TorqueConverterLocked = false;
-			_gearbox.Disengaged = false;
-			return 1;
-		}
-
-		public override uint Engage(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity)
-		{
-			if (_nextGear.AbsTime != null && _nextGear.AbsTime.IsEqual(absTime)) {
-				_gearbox.TorqueConverterLocked = _nextGear.TorqueConverterLocked;
-				_gearbox.Disengaged = _nextGear.Disengaged;
-				_nextGear.AbsTime = null;
-				return _nextGear.Gear;
-			}
-			_nextGear.AbsTime = null;
-			return _gearbox.Gear;
-		}
-
-		public override void Disengage(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outEngineSpeed)
-		{
-			throw new System.NotImplementedException("AT Shift Strategy does not support disengaging.");
-		}
-
-		public override bool ShiftRequired(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
-			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
-		{
-			// ENGAGE ---------------------------------------------------------
-			// 0 -> 1C: drive off after disengaged - engage first gear
-			if (_gearbox.Disengaged && outAngularVelocity.IsGreater(0.SI<PerSecond>())) {
-				Log.Debug("shift required: drive off after vehicle stopped");
-				_nextGear.SetState(absTime, disengaged: false, gear: 1, tcLocked: false);
-				return true;
-			}
-
-			// DISENGAGE ------------------------------------------------------
-			// 1) _ -> 0: disengage before halting
-			var braking = DataBus.DriverBehavior == DrivingBehavior.Braking;
-			var torqueNegative = outTorque.IsSmaller(0);
-			var slowerThanDisengageSpeed =
-				DataBus.VehicleSpeed.IsSmaller(Constants.SimulationSettings.ATGearboxDisengageWhenHaltingSpeed);
-			var disengageBeforeHalting = braking && torqueNegative && slowerThanDisengageSpeed;
-
-			// 2) L -> 0: disengage if inAngularVelocity == 0
-			var disengageAngularVelocityZero = _gearbox.TorqueConverterLocked && inAngularVelocity.IsEqual(0.SI<PerSecond>());
-
-			// 3) 1C -> 0: disengange when negative T_out and positive T_in
-			var gear1C = gear == 1 && !_gearbox.TorqueConverterLocked;
-			var disengageTOutNegativeAndTInPositive = DataBus.DriverAcceleration <= 0 && gear1C && outTorque.IsSmaller(0) &&
-													inTorque.IsGreater(0);
-
-			var disengageTCEngineSpeedLowerIdle = braking && torqueNegative && gear1C &&
-												inAngularVelocity.IsSmallerOrEqual(DataBus.EngineIdleSpeed);
-
-			if (disengageBeforeHalting || disengageTCEngineSpeedLowerIdle || disengageAngularVelocityZero ||
-				disengageTOutNegativeAndTInPositive) {
-				_nextGear.SetState(absTime, disengaged: true, gear: 1, tcLocked: false);
-				return true;
-			}
-
-			// EMERGENCY SHIFTS ---------------------------------------
-			// Emergency Downshift: if lower than engine idle speed
-			if (inAngularVelocity.IsSmaller(DataBus.EngineIdleSpeed)) {
-				Log.Debug("engine speed would fall below idle speed - shift down");
-				Downshift(absTime, gear);
-				return true;
-			}
-			// Emergency Upshift: if higher than engine rated speed
-			if (inAngularVelocity.IsGreaterOrEqual(ModelData.Gears[gear].MaxSpeed ?? DataBus.EngineRatedSpeed)) {
-				// check if upshift is possible
-				if (!ModelData.Gears.ContainsKey(gear + 1)) {
-					return false;
-				}
-				Log.Debug("engine speed would be above max speed / rated speed - shift up");
-				Upshift(absTime, gear);
-				return true;
-			}
-
-			// UPSHIFT --------------------------------------------------------
-			if (CheckUpshift(absTime, dt, outTorque, outAngularVelocity, inTorque, inAngularVelocity, gear,
-				lastShiftTime)) {
-				return true;
-			}
-
-			// DOWNSHIFT ------------------------------------------------------
-			if (CheckDownshift(absTime, dt, outTorque, outAngularVelocity, inTorque, inAngularVelocity, gear,
-				lastShiftTime)) {
-				return true;
-			}
-
-			return false;
-		}
-
-		[SuppressMessage("ReSharper", "UnusedParameter.Local")]
-		private bool CheckUpshift(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
-			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
-		{
-			var shiftTimeReached = (absTime - lastShiftTime).IsGreaterOrEqual(ModelData.ShiftTime);
-			if (!shiftTimeReached) {
-				return false;
-			}
-
-			var currentGear = ModelData.Gears[gear];
-
-			if (_gearbox.TorqueConverterLocked || currentGear.HasLockedGear) {
-				// UPSHIFT - General Rule
-				// L -> L+1 
-				// C -> L
-				var nextGear = _gearbox.TorqueConverterLocked ? gear + 1 : gear;
-				if (!ModelData.Gears.ContainsKey(nextGear)) {
-					return false;
-				}
-
-				var nextEngineSpeed = outAngularVelocity * ModelData.Gears[nextGear].Ratio;
-				if (nextEngineSpeed.IsEqual(0)) {
-					return false;
-				}
-
-				var currentEnginePower = inTorque * inAngularVelocity;
-				var nextEngineTorque = currentEnginePower / nextEngineSpeed;
-				var isAboveUpShift = IsAboveUpShiftCurve(gear, nextEngineTorque, nextEngineSpeed, _gearbox.TorqueConverterLocked);
-
-				var minAccelerationReachable = true;
-				if (!DataBus.VehicleSpeed.IsEqual(0)) {
-					var reachableAcceleration = EstimateAccelerationForGear(nextGear, outAngularVelocity);
-					var minAcceleration = _gearbox.TorqueConverterLocked
-						? ModelData.UpshiftMinAcceleration
-						: ModelData.TorqueConverterData.CLUpshiftMinAcceleration;
-					minAcceleration = VectoMath.Min(minAcceleration, DataBus.DriverAcceleration);
-					minAccelerationReachable = reachableAcceleration.IsGreaterOrEqual(minAcceleration);
-				}
-
-				if (isAboveUpShift && minAccelerationReachable) {
-					Upshift(absTime, gear);
-					return true;
-				}
-			}
-
-			// UPSHIFT - Special rule for 1C -> 2C
-			if (!_gearbox.TorqueConverterLocked && ModelData.Gears.ContainsKey(gear + 1) &&
-				ModelData.Gears[gear + 1].HasTorqueConverter && outAngularVelocity.IsGreater(0)) {
-				// C -> C+1
-				var nextGear = ModelData.Gears[gear + 1];
-				var gearRatio = nextGear.TorqueConverterRatio / currentGear.TorqueConverterRatio;
-				var minEngineSpeed = VectoMath.Min(700.RPMtoRad(), gearRatio * (DataBus.EngineN80hSpeed - 150.RPMtoRad()));
-
-				var nextGearboxInSpeed = outAngularVelocity * nextGear.TorqueConverterRatio;
-				var nextGearboxInTorque = outTorque / nextGear.TorqueConverterRatio;
-				var tcOperatingPoint = _gearbox.TorqueConverter.FindOperatingPoint(nextGearboxInTorque, nextGearboxInSpeed);
-
-				var engineSpeedOverMin = tcOperatingPoint.InAngularVelocity.IsGreater(minEngineSpeed);
-
-				var reachableAcceleration = EstimateAccelerationForGear(gear + 1, outAngularVelocity);
-				var minAcceleration = VectoMath.Min(ModelData.TorqueConverterData.CCUpshiftMinAcceleration,
-					DataBus.DriverAcceleration);
-				var minAccelerationReachable = reachableAcceleration.IsGreaterOrEqual(minAcceleration);
-
-				if (engineSpeedOverMin && minAccelerationReachable) {
-					Upshift(absTime, gear);
-					return true;
-				}
-			}
-			return false;
-		}
-
-		/// <summary>
-		/// Tests if the operating point is above (right of) the up-shift curve.
-		/// </summary>
-		/// <param name="gear">The gear.</param>
-		/// <param name="inTorque">The in torque.</param>
-		/// <param name="inEngineSpeed">The in engine speed.</param>
-		/// <param name="torqueConverterLocked">if true, the regular shift polygon is used, otherwise the shift polygon for the torque converter is used</param>
-		/// <returns><c>true</c> if the operating point is above the up-shift curve; otherwise, <c>false</c>.</returns>
-		private bool IsAboveUpShiftCurve(uint gear, NewtonMeter inTorque, PerSecond inEngineSpeed,
-			bool torqueConverterLocked)
-		{
-			var shiftPolygon = torqueConverterLocked
-				? ModelData.Gears[gear].ShiftPolygon
-				: ModelData.Gears[gear].TorqueConverterShiftPolygon;
-
-			return gear < ModelData.Gears.Keys.Max() && shiftPolygon.IsAboveUpshiftCurve(inTorque, inEngineSpeed);
-		}
-
-		private void Upshift(Second absTime, uint gear)
-		{
-			// C -> L: switch from torque converter to locked gear
-			if (!_gearbox.TorqueConverterLocked && ModelData.Gears[gear].HasLockedGear) {
-				_nextGear.SetState(absTime, disengaged: false, gear: gear, tcLocked: true);
-				return;
-			}
-
-			// L -> L+1
-			// C -> C+1
-			if (ModelData.Gears.ContainsKey(gear + 1)) {
-				_nextGear.SetState(absTime, disengaged: false, gear: gear + 1, tcLocked: _gearbox.TorqueConverterLocked);
-				return;
-			}
-
-			// C -> L+1 -- not allowed!!
-			throw new VectoSimulationException(
-				"ShiftStrategy wanted to shift up, but current gear has active torque converter (C) but no locked gear (no L) and shifting directly to (L) is not allowed.");
-		}
-
-		[SuppressMessage("ReSharper", "UnusedParameter.Local")]
-		private bool CheckDownshift(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
-			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
-		{
-			var shiftTimeReached = (absTime - lastShiftTime).IsGreaterOrEqual(ModelData.ShiftTime);
-
-			if (shiftTimeReached && IsBelowDownShiftCurve(gear, inTorque, inAngularVelocity)) {
-				Downshift(absTime, gear);
-				return true;
-			}
-
-			return false;
-		}
-
-		/// <summary>
-		/// Tests if the operating point is below (left of) the down-shift curve.
-		/// </summary>
-		/// <param name="gear">The gear.</param>
-		/// <param name="inTorque">The in torque.</param>
-		/// <param name="inEngineSpeed">The in engine speed.</param>
-		/// <returns><c>true</c> if the operating point is below the down-shift curv; otherwise, <c>false</c>.</returns>
-		private bool IsBelowDownShiftCurve(uint gear, NewtonMeter inTorque, PerSecond inEngineSpeed)
-		{
-			return gear > 1 && ModelData.Gears[gear].ShiftPolygon.IsBelowDownshiftCurve(inTorque, inEngineSpeed);
-		}
-
-		private void Downshift(Second absTime, uint gear)
-		{
-			// L -> C
-			if (_gearbox.TorqueConverterLocked && ModelData.Gears[gear].HasTorqueConverter) {
-				_nextGear.SetState(absTime, disengaged: false, gear: gear, tcLocked: false);
-				return;
-			}
-
-			// L -> L-1
-			// C -> C-1
-			if (ModelData.Gears.ContainsKey(gear - 1)) {
-				_nextGear.SetState(absTime, disengaged: false, gear: gear - 1, tcLocked: _gearbox.TorqueConverterLocked);
-				return;
-			}
-
-			// L -> 0 -- not allowed!!
-			throw new VectoSimulationException(
-				"ShiftStrategy wanted to shift down but current gear is locked (L) and has no torque converter (C) and disenganging directly from (L) is not allowed.");
-		}
-
-		private class NextGearState
-		{
-			public Second AbsTime;
-			public bool Disengaged;
-			public uint Gear;
-			public bool TorqueConverterLocked;
-
-			public void SetState(Second absTime, bool disengaged, uint gear, bool tcLocked)
-			{
-				AbsTime = absTime;
-				Disengaged = disengaged;
-				Gear = gear;
-				TorqueConverterLocked = tcLocked;
-			}
-		}
-	}
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.Models.Simulation.DataBus;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
+{
+	public class ATShiftStrategy : BaseShiftStrategy
+	{
+		private ATGearbox _gearbox;
+		private readonly NextGearState _nextGear = new NextGearState();
+
+		public override IGearbox Gearbox
+		{
+			get { return _gearbox; }
+			set {
+				_gearbox = value as ATGearbox;
+				if (_gearbox == null) {
+					throw new VectoException("AT Shift strategy can only handle AT gearboxes, given: {0}", value.GetType());
+				}
+			}
+		}
+
+		public override GearInfo NextGear
+		{
+			get { return new GearInfo(_nextGear.Gear, _nextGear.TorqueConverterLocked); }
+		}
+
+		public ATShiftStrategy(GearboxData data, IDataBus dataBus) : base(data, dataBus) {}
+
+		public override uint InitGear(Second absTime, Second dt, NewtonMeter torque, PerSecond outAngularVelocity)
+		{
+			if (DataBus.VehicleSpeed.IsEqual(0)) {
+				// AT always starts in first gear and TC active!
+				_gearbox.TorqueConverterLocked = false;
+				_gearbox.Disengaged = true;
+				return 1;
+			}
+			var torqueConverterLocked = true;
+			for (var gear = ModelData.Gears.Keys.Max(); gear > 1; gear--) {
+				if (_gearbox.ModelData.Gears[gear].HasTorqueConverter) {
+					torqueConverterLocked = false;
+				}
+				var response = _gearbox.Initialize(gear, torqueConverterLocked, torque, outAngularVelocity);
+
+				if (response.EngineSpeed > DataBus.EngineRatedSpeed || response.EngineSpeed < DataBus.EngineIdleSpeed) {
+					continue;
+				}
+
+				if (!IsBelowDownShiftCurve(gear, response.EnginePowerRequest / response.EngineSpeed, response.EngineSpeed)) {
+					_gearbox.TorqueConverterLocked = torqueConverterLocked;
+					_gearbox.Disengaged = false;
+					return gear;
+				}
+			}
+			// fallback: start with first gear;
+			_gearbox.TorqueConverterLocked = false;
+			_gearbox.Disengaged = false;
+			return 1;
+		}
+
+		public override uint Engage(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity)
+		{
+			if (_nextGear.AbsTime != null && _nextGear.AbsTime.IsEqual(absTime)) {
+				_gearbox.TorqueConverterLocked = _nextGear.TorqueConverterLocked;
+				_gearbox.Disengaged = _nextGear.Disengaged;
+				_nextGear.AbsTime = null;
+				return _nextGear.Gear;
+			}
+			_nextGear.AbsTime = null;
+			return _gearbox.Gear;
+		}
+
+		public override void Disengage(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outEngineSpeed)
+		{
+			throw new System.NotImplementedException("AT Shift Strategy does not support disengaging.");
+		}
+
+		public override bool ShiftRequired(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
+			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
+		{
+			// ENGAGE ---------------------------------------------------------
+			// 0 -> 1C: drive off after disengaged - engage first gear
+			if (_gearbox.Disengaged && outAngularVelocity.IsGreater(0.SI<PerSecond>())) {
+				Log.Debug("shift required: drive off after vehicle stopped");
+				_nextGear.SetState(absTime, disengaged: false, gear: 1, tcLocked: false);
+				return true;
+			}
+
+			// DISENGAGE ------------------------------------------------------
+			// 1) _ -> 0: disengage before halting
+			var braking = DataBus.DriverBehavior == DrivingBehavior.Braking;
+			var torqueNegative = outTorque.IsSmaller(0);
+			var slowerThanDisengageSpeed =
+				DataBus.VehicleSpeed.IsSmaller(Constants.SimulationSettings.ATGearboxDisengageWhenHaltingSpeed);
+			var disengageBeforeHalting = braking && torqueNegative && slowerThanDisengageSpeed;
+
+			// 2) L -> 0: disengage if inAngularVelocity == 0
+			var disengageAngularVelocityZero = _gearbox.TorqueConverterLocked && inAngularVelocity.IsEqual(0.SI<PerSecond>());
+
+			// 3) 1C -> 0: disengange when negative T_out and positive T_in
+			var gear1C = gear == 1 && !_gearbox.TorqueConverterLocked;
+			var disengageTOutNegativeAndTInPositive = DataBus.DriverAcceleration <= 0 && gear1C && outTorque.IsSmaller(0) &&
+													inTorque.IsGreater(0);
+
+			var disengageTCEngineSpeedLowerIdle = braking && torqueNegative && gear1C &&
+												inAngularVelocity.IsSmallerOrEqual(DataBus.EngineIdleSpeed);
+
+			if (disengageBeforeHalting || disengageTCEngineSpeedLowerIdle || disengageAngularVelocityZero ||
+				disengageTOutNegativeAndTInPositive) {
+				_nextGear.SetState(absTime, disengaged: true, gear: 1, tcLocked: false);
+				return true;
+			}
+
+			// EMERGENCY SHIFTS ---------------------------------------
+			// Emergency Downshift: if lower than engine idle speed
+			if (inAngularVelocity.IsSmaller(DataBus.EngineIdleSpeed)) {
+				Log.Debug("engine speed would fall below idle speed - shift down");
+				Downshift(absTime, gear);
+				return true;
+			}
+			// Emergency Upshift: if higher than engine rated speed
+			if (inAngularVelocity.IsGreaterOrEqual(ModelData.Gears[gear].MaxSpeed ?? DataBus.EngineRatedSpeed)) {
+				// check if upshift is possible
+				if (!ModelData.Gears.ContainsKey(gear + 1)) {
+					return false;
+				}
+				Log.Debug("engine speed would be above max speed / rated speed - shift up");
+				Upshift(absTime, gear);
+				return true;
+			}
+
+			// UPSHIFT --------------------------------------------------------
+			if (CheckUpshift(absTime, dt, outTorque, outAngularVelocity, inTorque, inAngularVelocity, gear,
+				lastShiftTime)) {
+				return true;
+			}
+
+			// DOWNSHIFT ------------------------------------------------------
+			if (CheckDownshift(absTime, dt, outTorque, outAngularVelocity, inTorque, inAngularVelocity, gear,
+				lastShiftTime)) {
+				return true;
+			}
+
+			return false;
+		}
+
+		[SuppressMessage("ReSharper", "UnusedParameter.Local")]
+		private bool CheckUpshift(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
+			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
+		{
+			var shiftTimeReached = (absTime - lastShiftTime).IsGreaterOrEqual(ModelData.ShiftTime);
+			if (!shiftTimeReached) {
+				return false;
+			}
+
+			var currentGear = ModelData.Gears[gear];
+
+			if (_gearbox.TorqueConverterLocked || currentGear.HasLockedGear) {
+				// UPSHIFT - General Rule
+				// L -> L+1 
+				// C -> L
+				var nextGear = _gearbox.TorqueConverterLocked ? gear + 1 : gear;
+				if (!ModelData.Gears.ContainsKey(nextGear)) {
+					return false;
+				}
+
+				var nextEngineSpeed = outAngularVelocity * ModelData.Gears[nextGear].Ratio;
+				if (nextEngineSpeed.IsEqual(0)) {
+					return false;
+				}
+
+				var currentEnginePower = inTorque * inAngularVelocity;
+				var nextEngineTorque = currentEnginePower / nextEngineSpeed;
+				var isAboveUpShift = IsAboveUpShiftCurve(gear, nextEngineTorque, nextEngineSpeed, _gearbox.TorqueConverterLocked);
+
+				var minAccelerationReachable = true;
+				if (!DataBus.VehicleSpeed.IsEqual(0)) {
+					var reachableAcceleration = EstimateAccelerationForGear(nextGear, outAngularVelocity);
+					var minAcceleration = _gearbox.TorqueConverterLocked
+						? ModelData.UpshiftMinAcceleration
+						: ModelData.TorqueConverterData.CLUpshiftMinAcceleration;
+					minAcceleration = VectoMath.Min(minAcceleration, DataBus.DriverAcceleration);
+					minAccelerationReachable = reachableAcceleration.IsGreaterOrEqual(minAcceleration);
+				}
+
+				if (isAboveUpShift && minAccelerationReachable) {
+					Upshift(absTime, gear);
+					return true;
+				}
+			}
+
+			// UPSHIFT - Special rule for 1C -> 2C
+			if (!_gearbox.TorqueConverterLocked && ModelData.Gears.ContainsKey(gear + 1) &&
+				ModelData.Gears[gear + 1].HasTorqueConverter && outAngularVelocity.IsGreater(0)) {
+				// C -> C+1
+				var nextGear = ModelData.Gears[gear + 1];
+				var gearRatio = nextGear.TorqueConverterRatio / currentGear.TorqueConverterRatio;
+				var minEngineSpeed = VectoMath.Min(700.RPMtoRad(), gearRatio * (DataBus.EngineN80hSpeed - 150.RPMtoRad()));
+
+				var nextGearboxInSpeed = outAngularVelocity * nextGear.TorqueConverterRatio;
+				var nextGearboxInTorque = outTorque / nextGear.TorqueConverterRatio;
+				var tcOperatingPoint = _gearbox.TorqueConverter.FindOperatingPoint(nextGearboxInTorque, nextGearboxInSpeed);
+
+				var engineSpeedOverMin = tcOperatingPoint.InAngularVelocity.IsGreater(minEngineSpeed);
+
+				var reachableAcceleration = EstimateAccelerationForGear(gear + 1, outAngularVelocity);
+				var minAcceleration = VectoMath.Min(ModelData.TorqueConverterData.CCUpshiftMinAcceleration,
+					DataBus.DriverAcceleration);
+				var minAccelerationReachable = reachableAcceleration.IsGreaterOrEqual(minAcceleration);
+
+				if (engineSpeedOverMin && minAccelerationReachable) {
+					Upshift(absTime, gear);
+					return true;
+				}
+			}
+			return false;
+		}
+
+		/// <summary>
+		/// Tests if the operating point is above (right of) the up-shift curve.
+		/// </summary>
+		/// <param name="gear">The gear.</param>
+		/// <param name="inTorque">The in torque.</param>
+		/// <param name="inEngineSpeed">The in engine speed.</param>
+		/// <param name="torqueConverterLocked">if true, the regular shift polygon is used, otherwise the shift polygon for the torque converter is used</param>
+		/// <returns><c>true</c> if the operating point is above the up-shift curve; otherwise, <c>false</c>.</returns>
+		private bool IsAboveUpShiftCurve(uint gear, NewtonMeter inTorque, PerSecond inEngineSpeed,
+			bool torqueConverterLocked)
+		{
+			var shiftPolygon = torqueConverterLocked
+				? ModelData.Gears[gear].ShiftPolygon
+				: ModelData.Gears[gear].TorqueConverterShiftPolygon;
+
+			return gear < ModelData.Gears.Keys.Max() && shiftPolygon.IsAboveUpshiftCurve(inTorque, inEngineSpeed);
+		}
+
+		private void Upshift(Second absTime, uint gear)
+		{
+			// C -> L: switch from torque converter to locked gear
+			if (!_gearbox.TorqueConverterLocked && ModelData.Gears[gear].HasLockedGear) {
+				_nextGear.SetState(absTime, disengaged: false, gear: gear, tcLocked: true);
+				return;
+			}
+
+			// L -> L+1
+			// C -> C+1
+			if (ModelData.Gears.ContainsKey(gear + 1)) {
+				_nextGear.SetState(absTime, disengaged: false, gear: gear + 1, tcLocked: _gearbox.TorqueConverterLocked);
+				return;
+			}
+
+			// C -> L+1 -- not allowed!!
+			throw new VectoSimulationException(
+				"ShiftStrategy wanted to shift up, but current gear has active torque converter (C) but no locked gear (no L) and shifting directly to (L) is not allowed.");
+		}
+
+		[SuppressMessage("ReSharper", "UnusedParameter.Local")]
+		private bool CheckDownshift(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
+			NewtonMeter inTorque, PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
+		{
+			var shiftTimeReached = (absTime - lastShiftTime).IsGreaterOrEqual(ModelData.ShiftTime);
+
+			if (shiftTimeReached && IsBelowDownShiftCurve(gear, inTorque, inAngularVelocity)) {
+				Downshift(absTime, gear);
+				return true;
+			}
+
+			return false;
+		}
+
+		/// <summary>
+		/// Tests if the operating point is below (left of) the down-shift curve.
+		/// </summary>
+		/// <param name="gear">The gear.</param>
+		/// <param name="inTorque">The in torque.</param>
+		/// <param name="inEngineSpeed">The in engine speed.</param>
+		/// <returns><c>true</c> if the operating point is below the down-shift curv; otherwise, <c>false</c>.</returns>
+		private bool IsBelowDownShiftCurve(uint gear, NewtonMeter inTorque, PerSecond inEngineSpeed)
+		{
+			return gear > 1 && ModelData.Gears[gear].ShiftPolygon.IsBelowDownshiftCurve(inTorque, inEngineSpeed);
+		}
+
+		private void Downshift(Second absTime, uint gear)
+		{
+			// L -> C
+			if (_gearbox.TorqueConverterLocked && ModelData.Gears[gear].HasTorqueConverter) {
+				_nextGear.SetState(absTime, disengaged: false, gear: gear, tcLocked: false);
+				return;
+			}
+
+			// L -> L-1
+			// C -> C-1
+			if (ModelData.Gears.ContainsKey(gear - 1)) {
+				_nextGear.SetState(absTime, disengaged: false, gear: gear - 1, tcLocked: _gearbox.TorqueConverterLocked);
+				return;
+			}
+
+			// L -> 0 -- not allowed!!
+			throw new VectoSimulationException(
+				"ShiftStrategy wanted to shift down but current gear is locked (L) and has no torque converter (C) and disenganging directly from (L) is not allowed.");
+		}
+
+		private class NextGearState
+		{
+			public Second AbsTime;
+			public bool Disengaged;
+			public uint Gear;
+			public bool TorqueConverterLocked;
+
+			public void SetState(Second absTime, bool disengaged, uint gear, bool tcLocked)
+			{
+				AbsTime = absTime;
+				Disengaged = disengaged;
+				Gear = gear;
+				TorqueConverterLocked = tcLocked;
+			}
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/FileIO/JsonTest.cs b/VectoCore/VectoCoreTest/FileIO/JsonTest.cs
index 25bd9dda532352fcec1dd26b0776a82f9fb0d67c..c33efbd250ff758d48976aeeab3d394d1e937870 100644
--- a/VectoCore/VectoCoreTest/FileIO/JsonTest.cs
+++ b/VectoCore/VectoCoreTest/FileIO/JsonTest.cs
@@ -29,420 +29,476 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using System.IO;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.InputData.FileIO.JSON;
-using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
-using TUGraz.VectoCore.Tests.Utils;
-
-namespace TUGraz.VectoCore.Tests.FileIO
-{
-	[TestClass]
-	public class JsonTest
-	{
-		private const string TestJobFile = @"Testdata\Jobs\40t_Long_Haul_Truck.vecto";
-		private const string TestVehicleFile = @"Testdata\Components\24t Coach.vveh";
-
-		[TestMethod]
-		public void ReadJobTest()
-		{
-			var job = JSONInputDataFactory.ReadJsonJob(TestJobFile);
-
-			Assert.IsNotNull(job);
-			//			AssertHelper.Exception<InvalidFileFormatException>(() => );
-		}
-
-		[TestMethod]
-		public void NoEngineFileTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("EngineFile").Remove();
-
-			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
-				"JobFile: Failed to read Engine file '': Key EngineFile not found");
-		}
-
-		[TestMethod]
-		public void NoGearboxFileTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("GearboxFile").Remove();
-
-			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
-				"JobFile: Failed to read Gearbox file '': Key GearboxFile not found");
-		}
-
-		[TestMethod]
-		public void NoVehicleFileTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("VehicleFile").Remove();
-
-			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
-				"JobFile: Failed to read Vehicle file '': Key VehicleFile not found");
-		}
-
-		[TestMethod]
-		public void NoCyclesTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("Cycles").Remove();
-
-			var tmp = new JSONInputDataV2(json, TestJobFile).Cycles;
-			Assert.AreEqual(0, tmp.Count);
-		}
-
-		[TestMethod]
-		public void NoAuxTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("Aux").Remove();
-
-			// MK,2016-01-20: Changed for PWheel: aux entry may be missing, and that is ok.
-			var tmp = new JSONInputDataV2(json, TestJobFile).AuxiliaryInputData().Auxiliaries;
-			Assert.IsTrue(tmp.Count == 0);
-		}
-
-		[TestMethod]
-		public void NoDriverAccCurveTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("VACC").Remove();
-
-			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
-			var tmp = input.DriverInputData.AccelerationCurve;
-			Assert.IsNull(tmp);
-		}
-
-		[TestMethod]
-		public void UseDeclarationDriverAccCurveTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			json["Body"]["VACC"] = "Truck";
-
-			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
-			var tmp = input.DriverInputData.AccelerationCurve;
-			Assert.IsNotNull(tmp);
-		}
-
-		[TestMethod]
-		public void NoLookaheadCoastingTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("LAC").Remove();
-
-			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
-			var tmp = input.DriverInputData.Lookahead;
-			Assert.IsNull(tmp);
-		}
-
-		[TestMethod]
-		public void NoOverspeedEcoRollTest()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-			((JObject)json["Body"]).Property("OverSpeedEcoRoll").Remove();
-
-			AssertHelper.Exception<VectoException>(
-				() => { var tmp = new JSONInputDataV2(json, TestJobFile).DriverInputData.OverSpeedEcoRoll; },
-				"Key OverSpeedEcoRoll not found");
-		}
-
-		[TestMethod]
-		public void ReadGearboxV5()
-		{
-			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\Gearbox_v5.vgbx");
-
-			var ratios = new[] { 3.0, 1.0, 0.8 };
-			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
-			for (int i = 0; i < ratios.Length; i++) {
-				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
-			}
-			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
-				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
-				0.5.SI<Meter>(),
-				true);
-			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
-
-			// interpreted as gearbox with first and second gear using TC (due to gear ratios)
-			Assert.IsFalse(gbxData.Gears[1].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[2].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
-		}
-
-		[TestMethod]
-		public void ReadGearboxSerialTC()
-		{
-			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerial.vgbx");
-
-			var ratios = new[] { 3.4, 1.9, 1.42, 1.0, 0.7, 0.62 };
-			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
-			for (int i = 0; i < ratios.Length; i++) {
-				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
-			}
-			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
-				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
-				0.5.SI<Meter>(),
-				true);
-			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
-
-			Assert.IsTrue(gbxData.Gears[1].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[2].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
-
-			var gear = gbxData.Gears[1];
-			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
-		}
-
-		[TestMethod]
-		public void ReadGearboxPowersplitTC()
-		{
-			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxPowerSplit.vgbx");
-
-			var ratios = new[] { 1.35, 1.0, 0.73 };
-			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
-			for (int i = 0; i < ratios.Length; i++) {
-				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
-			}
-			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
-				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
-				0.5.SI<Meter>(),
-				true);
-			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
-
-			Assert.IsTrue(gbxData.Gears[1].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[2].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
-
-			Assert.AreEqual(1, gbxData.Gears[1].TorqueConverterRatio);
-		}
-
-		[TestMethod]
-		public void ReadGearboxDualTC()
-		{
-			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerialDualTC.vgbx");
-
-			var ratios = new[] { 4.35, 2.4, 1.8, 1.3, 1.0 };
-			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
-			for (int i = 0; i < ratios.Length; i++) {
-				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
-			}
-			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
-				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
-				0.5.SI<Meter>(),
-				true);
-			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
-
-			Assert.IsFalse(gbxData.Gears[1].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
-			Assert.IsTrue(gbxData.Gears[2].HasTorqueConverter);
-			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
-			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
-
-
-			var gear = gbxData.Gears[2];
-			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
-		}
-
-		//[TestMethod]
-		//public void TestReadingElectricTechlist()
-		//{
-		//	var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
-		//	((JArray)json["Body"]["Aux"][3]["TechList"]).Add("LED lights");
-
-		//	var job = new JSONInputDataV2(json, TestJobFile);
-		//	foreach (var aux in job.Auxiliaries) {
-		//		if (aux.ID == "ES") {
-		//			Assert.AreEqual(1, aux.TechList.Count);
-		//			Assert.AreEqual("LED lights", aux.TechList.First());
-		//		}
-		//	}
-		//}
-
-		[TestMethod]
-		public void JSON_Read_AngleGear()
-		{
-			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestVehicleFile)));
-			var angleGear = json["Body"]["Angledrive"];
-
-			Assert.AreEqual(AngledriveType.SeparateAngledrive,
-				angleGear["Type"].Value<string>().ParseEnum<AngledriveType>());
-			Assert.AreEqual(3.5, angleGear["Ratio"].Value<double>());
-			Assert.AreEqual("AngleGear.vtlm", angleGear["LossMap"].Value<string>());
-		}
-	}
-
-	//	[TestClass]
-	//	public class JsonTest
-	//	{
-	//		private const string jsonExpected = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""2015-11-17T11:49:03Z"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-
-	//		private const string jsonExpected2 = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""2015-01-07T11:49:03Z"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-
-	//		[TestMethod]
-	//		public void TestJsonHeaderEquality()
-	//		{
-	//			var h1 = new JsonDataHeader {
-	//				AppVersion = "MyVecto3",
-	//				CreatedBy = "UnitTest",
-	//				Date = new DateTime(1970, 1, 1),
-	//				FileVersion = 3
-	//			};
-	//			var h2 = new JsonDataHeader {
-	//				AppVersion = "MyVecto3",
-	//				CreatedBy = "UnitTest",
-	//				Date = new DateTime(1970, 1, 1),
-	//				FileVersion = 3
-	//			};
-	//			Assert.AreEqual(h1, h1);
-	//			Assert.AreEqual(h1, h2);
-	//			Assert.AreNotEqual(h1, null);
-	//			Assert.AreNotEqual(h1, "hello world");
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_German()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""17.11.2015 11:49:03"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(jsonExpected, jsonCompare);
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_German2()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""7.1.2015 11:49:03"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 1, 7, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(jsonExpected2, jsonCompare);
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_English()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""11/17/2015 11:49:03 AM"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(jsonExpected, jsonCompare);
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_English2()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""1/7/2015 11:49:03 AM"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 1, 7, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(jsonExpected2, jsonCompare);
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_ISO8601()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""2015-11-17T11:49:03Z"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(json, jsonCompare);
-	//		}
-
-	//		[TestMethod]
-	//		public void Test_Json_DateFormat_ISO8601_CET()
-	//		{
-	//			var json = @"{
-	//  ""CreatedBy"": ""Michael Krisper"",
-	//  ""Date"": ""2015-11-17T11:49:03+01:00"",
-	//  ""AppVersion"": ""3.0.1.320"",
-	//  ""FileVersion"": 7
-	//}";
-	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
-
-	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
-	//			Assert.AreEqual(7u, header.FileVersion);
-	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
-	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
-
-	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
-	//			Assert.AreEqual(json, jsonCompare);
-	//		}
-	//	}
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.IO;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.FileIO.JSON;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
+using TUGraz.VectoCore.Tests.Utils;
+
+namespace TUGraz.VectoCore.Tests.FileIO
+{
+	[TestClass]
+	public class JsonTest
+	{
+		private const string TestJobFile = @"Testdata\Jobs\40t_Long_Haul_Truck.vecto";
+		private const string TestVehicleFile = @"Testdata\Components\24t Coach.vveh";
+
+		[TestMethod]
+		public void ReadJobTest()
+		{
+			var job = JSONInputDataFactory.ReadJsonJob(TestJobFile);
+
+			Assert.IsNotNull(job);
+			//			AssertHelper.Exception<InvalidFileFormatException>(() => );
+		}
+
+		[TestMethod]
+		public void NoEngineFileTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("EngineFile").Remove();
+
+			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
+				"JobFile: Failed to read Engine file '': Key EngineFile not found");
+		}
+
+		[TestMethod]
+		public void NoGearboxFileTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("GearboxFile").Remove();
+
+			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
+				"JobFile: Failed to read Gearbox file '': Key GearboxFile not found");
+		}
+
+		[TestMethod]
+		public void NoVehicleFileTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("VehicleFile").Remove();
+
+			AssertHelper.Exception<VectoException>(() => new JSONInputDataV2(json, TestJobFile),
+				"JobFile: Failed to read Vehicle file '': Key VehicleFile not found");
+		}
+
+		[TestMethod]
+		public void NoCyclesTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("Cycles").Remove();
+
+			var tmp = new JSONInputDataV2(json, TestJobFile).Cycles;
+			Assert.AreEqual(0, tmp.Count);
+		}
+
+		[TestMethod]
+		public void NoAuxTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("Aux").Remove();
+
+			// MK,2016-01-20: Changed for PWheel: aux entry may be missing, and that is ok.
+			var tmp = new JSONInputDataV2(json, TestJobFile).AuxiliaryInputData().Auxiliaries;
+			Assert.IsTrue(tmp.Count == 0);
+		}
+
+		[TestMethod]
+		public void NoDriverAccCurveTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("VACC").Remove();
+
+			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
+			var tmp = input.DriverInputData.AccelerationCurve;
+			Assert.IsNull(tmp);
+		}
+
+		[TestMethod]
+		public void UseDeclarationDriverAccCurveTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			json["Body"]["VACC"] = "Truck";
+
+			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
+			var tmp = input.DriverInputData.AccelerationCurve;
+			Assert.IsNotNull(tmp);
+		}
+
+		[TestMethod]
+		public void NoLookaheadCoastingTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("LAC").Remove();
+
+			IEngineeringInputDataProvider input = new JSONInputDataV2(json, TestJobFile);
+			var tmp = input.DriverInputData.Lookahead;
+			Assert.IsNull(tmp);
+		}
+
+		[TestMethod]
+		public void NoOverspeedEcoRollTest()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+			((JObject)json["Body"]).Property("OverSpeedEcoRoll").Remove();
+
+			AssertHelper.Exception<VectoException>(
+				() => { var tmp = new JSONInputDataV2(json, TestJobFile).DriverInputData.OverSpeedEcoRoll; },
+				"Key OverSpeedEcoRoll not found");
+		}
+
+		[TestMethod]
+		public void ReadGearboxV5()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\Gearbox_v5.vgbx");
+
+			var ratios = new[] { 3.0, 1.0, 0.8 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.RigidTruck,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			// interpreted as gearbox with first and second gear using TC (due to gear ratios)
+			Assert.IsFalse(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+		}
+
+		[TestMethod]
+		public void ReadGearboxSerialTC()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerial.vgbx");
+
+			var ratios = new[] { 3.4, 1.9, 1.42, 1.0, 0.7, 0.62 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.RigidTruck,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			Assert.IsTrue(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+
+			var gear = gbxData.Gears[1];
+			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
+		}
+
+		[TestMethod]
+		public void ReadGearboxPowersplitTC()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxPowerSplit.vgbx");
+
+			var ratios = new[] { 1.35, 1.0, 0.73 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.RigidTruck,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			Assert.IsTrue(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+
+			Assert.AreEqual(1, gbxData.Gears[1].TorqueConverterRatio);
+		}
+
+		[TestMethod]
+		public void ReadGearboxDualTCTruck()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerialDualTC.vgbx");
+
+			var ratios = new[] { 4.35, 2.4, 1.8, 1.3, 1.0 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.RigidTruck,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			Assert.IsFalse(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+
+
+			var gear = gbxData.Gears[2];
+			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
+		}
+
+		[TestMethod]
+		public void ReadGearboxSingleTCBus()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerialDualTC.vgbx");
+
+			var ratios = new[] { 4.35, 2.4, 1.8, 1.3, 1.0 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.InterurbanBus,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			Assert.IsTrue(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+
+
+			var gear = gbxData.Gears[1];
+			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
+		}
+
+		[TestMethod]
+		public void ReadGearboxDualTCBus()
+		{
+			var inputProvider = JSONInputDataFactory.ReadGearbox(@"TestData\Components\AT_GBX\GearboxSerialDualTCBus.vgbx");
+
+			var ratios = new[] { 4.58, 2.4, 1.8, 1.3, 1.0 };
+			Assert.AreEqual(ratios.Length, inputProvider.Gears.Count);
+			for (int i = 0; i < ratios.Length; i++) {
+				Assert.AreEqual(ratios[i], inputProvider.Gears[i].Ratio);
+			}
+			var gbxData = new EngineeringDataAdapter().CreateGearboxData(inputProvider,
+				MockSimulationDataFactory.CreateEngineDataFromFile(@"TestData\Components\AT_GBX\Engine.veng", 0), 2.1,
+				0.5.SI<Meter>(), VehicleCategory.InterurbanBus,
+				true);
+			Assert.AreEqual(ratios.Length, gbxData.Gears.Count);
+
+			Assert.IsFalse(gbxData.Gears[1].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[1].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[2].HasLockedGear);
+			Assert.IsTrue(gbxData.Gears[2].HasTorqueConverter);
+			Assert.IsTrue(gbxData.Gears[3].HasLockedGear);
+			Assert.IsFalse(gbxData.Gears[3].HasTorqueConverter);
+
+
+			var gear = gbxData.Gears[2];
+			Assert.AreEqual(gear.Ratio, gear.TorqueConverterRatio);
+		}
+
+		//[TestMethod]
+		//public void TestReadingElectricTechlist()
+		//{
+		//	var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestJobFile)));
+		//	((JArray)json["Body"]["Aux"][3]["TechList"]).Add("LED lights");
+
+		//	var job = new JSONInputDataV2(json, TestJobFile);
+		//	foreach (var aux in job.Auxiliaries) {
+		//		if (aux.ID == "ES") {
+		//			Assert.AreEqual(1, aux.TechList.Count);
+		//			Assert.AreEqual("LED lights", aux.TechList.First());
+		//		}
+		//	}
+		//}
+
+		[TestMethod]
+		public void JSON_Read_AngleGear()
+		{
+			var json = (JObject)JToken.ReadFrom(new JsonTextReader(File.OpenText(TestVehicleFile)));
+			var angleGear = json["Body"]["Angledrive"];
+
+			Assert.AreEqual(AngledriveType.SeparateAngledrive,
+				angleGear["Type"].Value<string>().ParseEnum<AngledriveType>());
+			Assert.AreEqual(3.5, angleGear["Ratio"].Value<double>());
+			Assert.AreEqual("AngleGear.vtlm", angleGear["LossMap"].Value<string>());
+		}
+	}
+
+	//	[TestClass]
+	//	public class JsonTest
+	//	{
+	//		private const string jsonExpected = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""2015-11-17T11:49:03Z"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+
+	//		private const string jsonExpected2 = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""2015-01-07T11:49:03Z"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+
+	//		[TestMethod]
+	//		public void TestJsonHeaderEquality()
+	//		{
+	//			var h1 = new JsonDataHeader {
+	//				AppVersion = "MyVecto3",
+	//				CreatedBy = "UnitTest",
+	//				Date = new DateTime(1970, 1, 1),
+	//				FileVersion = 3
+	//			};
+	//			var h2 = new JsonDataHeader {
+	//				AppVersion = "MyVecto3",
+	//				CreatedBy = "UnitTest",
+	//				Date = new DateTime(1970, 1, 1),
+	//				FileVersion = 3
+	//			};
+	//			Assert.AreEqual(h1, h1);
+	//			Assert.AreEqual(h1, h2);
+	//			Assert.AreNotEqual(h1, null);
+	//			Assert.AreNotEqual(h1, "hello world");
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_German()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""17.11.2015 11:49:03"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(jsonExpected, jsonCompare);
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_German2()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""7.1.2015 11:49:03"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 1, 7, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(jsonExpected2, jsonCompare);
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_English()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""11/17/2015 11:49:03 AM"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(jsonExpected, jsonCompare);
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_English2()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""1/7/2015 11:49:03 AM"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 1, 7, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(jsonExpected2, jsonCompare);
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_ISO8601()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""2015-11-17T11:49:03Z"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(json, jsonCompare);
+	//		}
+
+	//		[TestMethod]
+	//		public void Test_Json_DateFormat_ISO8601_CET()
+	//		{
+	//			var json = @"{
+	//  ""CreatedBy"": ""Michael Krisper"",
+	//  ""Date"": ""2015-11-17T11:49:03+01:00"",
+	//  ""AppVersion"": ""3.0.1.320"",
+	//  ""FileVersion"": 7
+	//}";
+	//			var header = JsonConvert.DeserializeObject<JsonDataHeader>(json);
+
+	//			Assert.AreEqual("3.0.1.320", header.AppVersion);
+	//			Assert.AreEqual(7u, header.FileVersion);
+	//			Assert.AreEqual("Michael Krisper", header.CreatedBy);
+	//			Assert.AreEqual(new DateTime(2015, 11, 17, 11, 49, 3, DateTimeKind.Utc), header.Date);
+
+	//			var jsonCompare = JsonConvert.SerializeObject(header, Formatting.Indented);
+	//			Assert.AreEqual(json, jsonCompare);
+	//		}
+	//	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs b/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
index f0c12bd791d2c05813804a0ec23572c6f94fed24..a93409ff24f34a6922b33b23fa94139e533f9b6a 100644
--- a/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
+++ b/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
@@ -29,140 +29,140 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using NUnit.Framework;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.Models.Connector.Ports.Impl;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.Simulation.Impl;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-using TUGraz.VectoCore.Models.SimulationComponent.Impl;
-using TUGraz.VectoCore.OutputData;
-using TUGraz.VectoCore.OutputData.FileIO;
-using TUGraz.VectoCore.Tests.Integration;
-using TUGraz.VectoCore.Tests.Utils;
-
-namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
-{
-	[TestFixture]
-	public class ATGearboxTest
-	{
-		public const string EngineDataFile = @"TestData\Components\AT_GBX\Engine.veng";
-		public const string GearboxDataFile = @"TestData\Components\AT_GBX\GearboxSerial.vgbx";
-
-		[Test,
-		TestCase(0, 100, 1),
-		TestCase(0, 200, 1),
-		TestCase(5, 100, 1),
-		TestCase(5, 300, 1),
-		TestCase(5, 600, 1),
-		TestCase(15, 100, 3),
-		TestCase(15, 300, 3),
-		TestCase(15, 600, 3),
-		TestCase(40, 100, 6),
-		TestCase(40, 300, 6),
-		TestCase(40, 600, 6),
-		TestCase(70, 100, 6),
-		TestCase(70, 300, 6),
-		TestCase(70, 600, 6),
-		]
-		public void TestATGearInitialize(double vehicleSpeed, double torque, int expectedGear)
-		{
-			var gearboxData = MockSimulationDataFactory.CreateGearboxDataFromFile(GearboxDataFile, EngineDataFile, false);
-			var vehicleContainer = new MockVehicleContainer(); //(ExecutionMode.Engineering);
-			var engineData = MockSimulationDataFactory.CreateEngineDataFromFile(EngineDataFile, gearboxData.Gears.Count);
-			vehicleContainer.Engine = new CombustionEngine(vehicleContainer, engineData);
-			var runData = new VectoRunData() { GearboxData = gearboxData };
-			var gearbox = new ATGearbox(vehicleContainer, new ATShiftStrategy(gearboxData, vehicleContainer), runData);
-
-			vehicleContainer.VehicleSpeed = vehicleSpeed.KMPHtoMeterPerSecond();
-
-			var tnPort = new MockTnOutPort();
-			gearbox.Connect(tnPort);
-
-			// r_dyn = 0.465m, i_axle = 6.2
-			var angularVelocity = vehicleSpeed.KMPHtoMeterPerSecond() / 0.465.SI<Meter>() * 6.2;
-			var response = gearbox.Initialize(torque.SI<NewtonMeter>(), angularVelocity);
-
-			Assert.IsInstanceOf(typeof(ResponseSuccess), response);
-			Assert.AreEqual(expectedGear, gearbox.Gear);
-			Assert.AreEqual(vehicleSpeed.IsEqual(0), gearbox.Disengaged);
-		}
-
-		[Test,
-		TestCase(GearboxType.ATSerial, TestName = "Drive TorqueConverter - Serial"),
-		TestCase(GearboxType.ATPowerSplit, TestName = "Drive TorqueConverter - PowerSplit")]
-		public void TestATGearboxDriveTorqueConverter(GearboxType gbxType)
-		{
-			var cycleData = @"   0,  0, 0,    2
-								20,  8, 0,    0
-							   200,  0, 0,    2";
-			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
-			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
-				string.Format("AT_Vehicle_Drive-TC-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
-
-			run.Run();
-			Assert.IsTrue(run.FinishedWithoutErrors);
-		}
-
-		[Test,
-		TestCase(GearboxType.ATSerial, TestName = "ShiftUp TorqueConverter - Serial"),
-		TestCase(GearboxType.ATPowerSplit, TestName = "ShiftUp TorqueConverter - PowerSplit")]
-		public void TestATGearboxShiftUp(GearboxType gbxType)
-		{
-			var cycleData = @"  0,  0, 0,    2
-							  500, 40, 0,    0";
-			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
-			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
-				string.Format("AT_Vehicle_Drive-TC_shiftup-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
-
-			run.Run();
-			Assert.IsTrue(run.FinishedWithoutErrors);
-		}
-
-		[Test,
-		TestCase(GearboxType.ATSerial, TestName = "ShiftDown TorqueConverter - Serial"),
-		TestCase(GearboxType.ATPowerSplit, TestName = "ShiftDown TorqueConverter - PowerSplit")]
-		public void TestATGearboxShiftDown(GearboxType gbxType)
-		{
-			var cycleData = @"  0, 70, 0,    0
-							  500,  0, 0,    2";
-			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
-			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
-				string.Format("AT_Vehicle_Drive-TC_shiftdown-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
-
-			run.Run();
-			Assert.IsTrue(run.FinishedWithoutErrors);
-		}
-
-
-		[Test,
-		TestCase("Urban", GearboxType.ATSerial),
-		TestCase("Suburban", GearboxType.ATSerial),
-		TestCase("Interurban", GearboxType.ATSerial),
-		TestCase("HeavyUrban", GearboxType.ATSerial),
-		TestCase("Urban", GearboxType.ATPowerSplit),
-		TestCase("Suburban", GearboxType.ATPowerSplit),
-		TestCase("Interurban", GearboxType.ATPowerSplit),
-		TestCase("HeavyUrban", GearboxType.ATPowerSplit)
-		]
-		public void TestATGearboxDriveCycle(string cycleName, GearboxType gbxType)
-		{
-			Assert.IsTrue(gbxType.AutomaticTransmission());
-			var cycle = SimpleDrivingCycles.ReadDeclarationCycle(cycleName);
-			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
-				string.Format("AT_Vehicle_Drive-TC_{0}-{1}.vmod", cycleName, gbxType == GearboxType.ATSerial ? "ser" : "ps"));
-
-			var sumWriter =
-				new SummaryDataContainer(
-					new FileOutputWriter(string.Format("AT_Vehicle_Drive-TC_{0}-{1}", cycleName,
-						gbxType == GearboxType.ATSerial ? "ser" : "ps")));
-			((VehicleContainer)run.GetContainer()).WriteSumData = (modData) =>
-				sumWriter.Write(run.GetContainer().ModalData, 0, 0, run.GetContainer().RunData);
-			run.Run();
-			sumWriter.Finish();
-			Assert.IsTrue(run.FinishedWithoutErrors);
-		}
-	}
+using NUnit.Framework;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.Models.Connector.Ports.Impl;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.Simulation.Impl;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+using TUGraz.VectoCore.OutputData;
+using TUGraz.VectoCore.OutputData.FileIO;
+using TUGraz.VectoCore.Tests.Integration;
+using TUGraz.VectoCore.Tests.Utils;
+
+namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
+{
+	[TestFixture]
+	public class ATGearboxTest
+	{
+		public const string EngineDataFile = @"TestData\Components\AT_GBX\Engine.veng";
+		public const string GearboxDataFile = @"TestData\Components\AT_GBX\GearboxSerial.vgbx";
+
+		[Test,
+		TestCase(0, 100, 1),
+		TestCase(0, 200, 1),
+		TestCase(5, 100, 1),
+		TestCase(5, 300, 1),
+		TestCase(5, 600, 1),
+		TestCase(15, 100, 3),
+		TestCase(15, 300, 3),
+		TestCase(15, 600, 3),
+		TestCase(40, 100, 6),
+		TestCase(40, 300, 6),
+		TestCase(40, 600, 6),
+		TestCase(70, 100, 6),
+		TestCase(70, 300, 6),
+		TestCase(70, 600, 6),
+		]
+		public void TestATGearInitialize(double vehicleSpeed, double torque, int expectedGear)
+		{
+			var gearboxData = MockSimulationDataFactory.CreateGearboxDataFromFile(GearboxDataFile, EngineDataFile, false);
+			var vehicleContainer = new MockVehicleContainer(); //(ExecutionMode.Engineering);
+			var engineData = MockSimulationDataFactory.CreateEngineDataFromFile(EngineDataFile, gearboxData.Gears.Count);
+			vehicleContainer.Engine = new CombustionEngine(vehicleContainer, engineData);
+			var runData = new VectoRunData() { GearboxData = gearboxData };
+			var gearbox = new ATGearbox(vehicleContainer, new ATShiftStrategy(gearboxData, vehicleContainer), runData);
+
+			vehicleContainer.VehicleSpeed = vehicleSpeed.KMPHtoMeterPerSecond();
+
+			var tnPort = new MockTnOutPort();
+			gearbox.Connect(tnPort);
+
+			// r_dyn = 0.465m, i_axle = 6.2
+			var angularVelocity = vehicleSpeed.KMPHtoMeterPerSecond() / 0.465.SI<Meter>() * 6.2;
+			var response = gearbox.Initialize(torque.SI<NewtonMeter>(), angularVelocity);
+
+			Assert.IsInstanceOf(typeof(ResponseSuccess), response);
+			Assert.AreEqual(expectedGear, gearbox.Gear);
+			Assert.AreEqual(vehicleSpeed.IsEqual(0), gearbox.Disengaged);
+		}
+
+		[Test,
+		TestCase(GearboxType.ATSerial, TestName = "Drive TorqueConverter - Serial"),
+		TestCase(GearboxType.ATPowerSplit, TestName = "Drive TorqueConverter - PowerSplit")]
+		public void TestATGearboxDriveTorqueConverter(GearboxType gbxType)
+		{
+			var cycleData = @"   0,  0, 0,    2
+								20,  8, 0,    0
+							   200,  0, 0,    2";
+			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
+			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
+				string.Format("AT_Vehicle_Drive-TC-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
+
+			run.Run();
+			Assert.IsTrue(run.FinishedWithoutErrors);
+		}
+
+		[Test,
+		TestCase(GearboxType.ATSerial, TestName = "ShiftUp TorqueConverter - Serial"),
+		TestCase(GearboxType.ATPowerSplit, TestName = "ShiftUp TorqueConverter - PowerSplit")]
+		public void TestATGearboxShiftUp(GearboxType gbxType)
+		{
+			var cycleData = @"  0,  0, 0,    2
+							  500, 40, 0,    0";
+			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
+			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
+				string.Format("AT_Vehicle_Drive-TC_shiftup-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
+
+			run.Run();
+			Assert.IsTrue(run.FinishedWithoutErrors);
+		}
+
+		[Test,
+		TestCase(GearboxType.ATSerial, TestName = "ShiftDown TorqueConverter - Serial"),
+		TestCase(GearboxType.ATPowerSplit, TestName = "ShiftDown TorqueConverter - PowerSplit")]
+		public void TestATGearboxShiftDown(GearboxType gbxType)
+		{
+			var cycleData = @"  0, 70, 0,    0
+							  500,  0, 0,    2";
+			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
+			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
+				string.Format("AT_Vehicle_Drive-TC_shiftdown-{0}.vmod", gbxType == GearboxType.ATSerial ? "ser" : "ps"));
+
+			run.Run();
+			Assert.IsTrue(run.FinishedWithoutErrors);
+		}
+
+
+		[Test,
+		TestCase("Urban", GearboxType.ATSerial),
+		TestCase("Suburban", GearboxType.ATSerial),
+		TestCase("Interurban", GearboxType.ATSerial),
+		TestCase("HeavyUrban", GearboxType.ATSerial),
+		TestCase("Urban", GearboxType.ATPowerSplit),
+		TestCase("Suburban", GearboxType.ATPowerSplit),
+		TestCase("Interurban", GearboxType.ATPowerSplit),
+		TestCase("HeavyUrban", GearboxType.ATPowerSplit)
+		]
+		public void TestATGearboxDriveCycle(string cycleName, GearboxType gbxType)
+		{
+			Assert.IsTrue(gbxType.AutomaticTransmission());
+			var cycle = SimpleDrivingCycles.ReadDeclarationCycle(cycleName);
+			var run = ATPowerTrain.CreateEngineeringRun(cycle, gbxType,
+				string.Format("AT_Vehicle_Drive-TC_{0}-{1}.vmod", cycleName, gbxType == GearboxType.ATSerial ? "ser" : "ps"));
+
+			var sumWriter =
+				new SummaryDataContainer(
+					new FileOutputWriter(string.Format("AT_Vehicle_Drive-TC_{0}-{1}", cycleName,
+						gbxType == GearboxType.ATSerial ? "ser" : "ps")));
+			((VehicleContainer)run.GetContainer()).WriteSumData = (modData) =>
+				sumWriter.Write(run.GetContainer().ModalData, 0, 0, run.GetContainer().RunData);
+			run.Run();
+			sumWriter.Finish();
+			Assert.IsTrue(run.FinishedWithoutErrors);
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/TestData/Components/AT_GBX/GearboxSerialDualTCBus.vgbx b/VectoCore/VectoCoreTest/TestData/Components/AT_GBX/GearboxSerialDualTCBus.vgbx
new file mode 100644
index 0000000000000000000000000000000000000000..cf00163cc28aa4f96ce9e8e2f8c5e96c2f41a9d7
--- /dev/null
+++ b/VectoCore/VectoCoreTest/TestData/Components/AT_GBX/GearboxSerialDualTCBus.vgbx
@@ -0,0 +1,68 @@
+{
+  "Header": {
+    "CreatedBy": " ()",
+    "Date": "03.08.2016 14:22:48",
+    "AppVersion": "2.2",
+    "FileVersion": 6
+  },
+  "Body": {
+    "SavedInDeclMode": false,
+    "ModelName": "AT Serial",
+    "Inertia": 0.0,
+    "TracInt": 0.0,
+    "Gears": [
+      {
+        "Ratio": 2.1,
+        "Efficiency": "0.98"
+      },
+      {
+        "Ratio": 4.58,
+        "Efficiency": "0.98",
+        "ShiftPolygon": "AT-Shift.vgbs",
+        "FullLoadCurve": "<NOFILE>"
+      },
+      {
+        "Ratio": 2.4,
+        "Efficiency": "0.98",
+        "ShiftPolygon": "AT-Shift.vgbs",
+        "FullLoadCurve": "<NOFILE>"
+      },
+      {
+        "Ratio": 1.8,
+        "Efficiency": "0.98",
+        "ShiftPolygon": "AT-Shift.vgbs",
+        "FullLoadCurve": "<NOFILE>"
+      },
+      {
+        "Ratio": 1.3,
+        "Efficiency": "0.98",
+        "ShiftPolygon": "AT-Shift.vgbs",
+        "FullLoadCurve": "<NOFILE>"
+      },
+      {
+        "Ratio": 1.0,
+        "Efficiency": "0.98",
+        "ShiftPolygon": "AT-Shift.vgbs",
+        "FullLoadCurve": "<NOFILE>"
+      }
+    ],
+    "TqReserve": 0.0,
+    "SkipGears": false,
+    "ShiftTime": 0,
+    "EaryShiftUp": false,
+    "StartTqReserve": 0.0,
+    "StartSpeed": 0.0,
+    "StartAcc": 0.0,
+    "GearboxType": "ATSerial",
+    "TorqueConverter": {
+      "Enabled": true,
+      "File": "TorqueConverter.vtcc",
+	  "ShiftPolygon": "AT-Shift.vgbs",
+      "RefRPM": 1000.0,
+      "Inertia": 0.0
+    },
+    "DownshiftAferUpshiftDelay": 0.0,
+    "UpshiftAfterDownshiftDelay": 0.0,
+    "UpshiftMinAcceleration": 0.0
+  }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/Utils/MockSimulationDataFactory.cs b/VectoCore/VectoCoreTest/Utils/MockSimulationDataFactory.cs
index 0531a6625ca38aa9f5da975d5bcec5b9b2a2f68e..675a82b958dfce5b28dde0ecebee4a215dafdce5 100644
--- a/VectoCore/VectoCoreTest/Utils/MockSimulationDataFactory.cs
+++ b/VectoCore/VectoCoreTest/Utils/MockSimulationDataFactory.cs
@@ -29,85 +29,88 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using System.Collections.Generic;
-using TUGraz.VectoCommon.Exceptions;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.InputData.FileIO.JSON;
-using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-
-namespace TUGraz.VectoCore.Tests.Utils
-{
-	public class MockSimulationDataFactory
-	{
-		/// <summary>
-		/// Create gearboxdata instance directly from a file
-		/// </summary>
-		/// <param name="gearBoxFile"></param>
-		/// <param name="engineFile"></param>
-		/// <param name="declarationMode"></param>
-		/// <returns>GearboxData instance</returns>
-		public static GearboxData CreateGearboxDataFromFile(string gearBoxFile, string engineFile, bool declarationMode = true)
-		{
-			var gearboxInput = JSONInputDataFactory.ReadGearbox(gearBoxFile);
-			var engineInput = JSONInputDataFactory.ReadEngine(engineFile);
-			if (declarationMode) {
-				var dao = new DeclarationDataAdapter();
-				var engineData = dao.CreateEngineData(engineInput, null, gearboxInput, new List<ITorqueLimitInputData>());
-				return dao.CreateGearboxData(gearboxInput, engineData, ((IAxleGearInputData)gearboxInput).Ratio, 0.5.SI<Meter>(),
-					false);
-			} else {
-				var dao = new EngineeringDataAdapter();
-				var engineData = dao.CreateEngineData(engineInput, gearboxInput, new List<ITorqueLimitInputData>());
-				return dao.CreateGearboxData(gearboxInput, engineData, ((IAxleGearInputData)gearboxInput).Ratio, 0.5.SI<Meter>(),
-					true);
-			}
-		}
-
-		public static AxleGearData CreateAxleGearDataFromFile(string axleGearFile)
-		{
-			var dao = new DeclarationDataAdapter();
-			var axleGearInput = JSONInputDataFactory.ReadGearbox(axleGearFile);
-			return dao.CreateAxleGearData((IAxleGearInputData)axleGearInput, false);
-		}
-
-		public static CombustionEngineData CreateEngineDataFromFile(string engineFile, int numGears)
-		{
-			var dao = new EngineeringDataAdapter();
-			var engineInput = JSONInputDataFactory.ReadEngine(engineFile);
-			var engineData = dao.CreateEngineData(engineInput, null, new List<ITorqueLimitInputData>());
-			for (uint i = 1; i <= numGears; i++) {
-				engineData.FullLoadCurves[i] = engineData.FullLoadCurves[0];
-			}
-			return engineData;
-		}
-
-		public static VehicleData CreateVehicleDataFromFile(string vehicleDataFile)
-		{
-			var dao = new EngineeringDataAdapter();
-			var vehicleInput = JSONInputDataFactory.ReadJsonVehicle(vehicleDataFile);
-			var airdragData = vehicleInput as IAirdragEngineeringInputData;
-			return dao.CreateVehicleData(vehicleInput);
-		}
-
-		public static AirdragData CreateAirdragDataFromFile(string vehicleDataFile)
-		{
-			var dao = new EngineeringDataAdapter();
-			var vehicleInput = JSONInputDataFactory.ReadJsonVehicle(vehicleDataFile);
-			var airdragData = vehicleInput as IAirdragEngineeringInputData;
-			return dao.CreateAirdragData(airdragData, vehicleInput);
-		}
-
-		public static DriverData CreateDriverDataFromFile(string driverDataFile)
-		{
-			var jobInput = JSONInputDataFactory.ReadJsonJob(driverDataFile);
-			var engineeringJob = jobInput as IEngineeringInputDataProvider;
-			if (engineeringJob == null) {
-				throw new VectoException("Failed to cas to Engineering InputDataProvider");
-			}
-			var dao = new EngineeringDataAdapter();
-			return dao.CreateDriverData(engineeringJob.DriverInputData);
-		}
-	}
+using System.Collections.Generic;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.FileIO.JSON;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.Tests.Utils
+{
+	public class MockSimulationDataFactory
+	{
+		/// <summary>
+		/// Create gearboxdata instance directly from a file
+		/// </summary>
+		/// <param name="gearBoxFile"></param>
+		/// <param name="engineFile"></param>
+		/// <param name="declarationMode"></param>
+		/// <returns>GearboxData instance</returns>
+		public static GearboxData CreateGearboxDataFromFile(string gearBoxFile, string engineFile, bool declarationMode = true)
+		{
+			var gearboxInput = JSONInputDataFactory.ReadGearbox(gearBoxFile);
+			var engineInput = JSONInputDataFactory.ReadEngine(engineFile);
+			if (declarationMode) {
+				var dao = new DeclarationDataAdapter();
+				var engineData = dao.CreateEngineData(engineInput, null, gearboxInput, new List<ITorqueLimitInputData>());
+				return dao.CreateGearboxData(gearboxInput, engineData, ((IAxleGearInputData)gearboxInput).Ratio, 0.5.SI<Meter>(),
+					VehicleCategory.RigidTruck,
+					false);
+			} else {
+				var dao = new EngineeringDataAdapter();
+				var engineData = dao.CreateEngineData(engineInput, gearboxInput, new List<ITorqueLimitInputData>());
+				return dao.CreateGearboxData(gearboxInput, engineData, ((IAxleGearInputData)gearboxInput).Ratio, 0.5.SI<Meter>(),
+					VehicleCategory.RigidTruck,
+					true);
+			}
+		}
+
+		public static AxleGearData CreateAxleGearDataFromFile(string axleGearFile)
+		{
+			var dao = new DeclarationDataAdapter();
+			var axleGearInput = JSONInputDataFactory.ReadGearbox(axleGearFile);
+			return dao.CreateAxleGearData((IAxleGearInputData)axleGearInput, false);
+		}
+
+		public static CombustionEngineData CreateEngineDataFromFile(string engineFile, int numGears)
+		{
+			var dao = new EngineeringDataAdapter();
+			var engineInput = JSONInputDataFactory.ReadEngine(engineFile);
+			var engineData = dao.CreateEngineData(engineInput, null, new List<ITorqueLimitInputData>());
+			for (uint i = 1; i <= numGears; i++) {
+				engineData.FullLoadCurves[i] = engineData.FullLoadCurves[0];
+			}
+			return engineData;
+		}
+
+		public static VehicleData CreateVehicleDataFromFile(string vehicleDataFile)
+		{
+			var dao = new EngineeringDataAdapter();
+			var vehicleInput = JSONInputDataFactory.ReadJsonVehicle(vehicleDataFile);
+			var airdragData = vehicleInput as IAirdragEngineeringInputData;
+			return dao.CreateVehicleData(vehicleInput);
+		}
+
+		public static AirdragData CreateAirdragDataFromFile(string vehicleDataFile)
+		{
+			var dao = new EngineeringDataAdapter();
+			var vehicleInput = JSONInputDataFactory.ReadJsonVehicle(vehicleDataFile);
+			var airdragData = vehicleInput as IAirdragEngineeringInputData;
+			return dao.CreateAirdragData(airdragData, vehicleInput);
+		}
+
+		public static DriverData CreateDriverDataFromFile(string driverDataFile)
+		{
+			var jobInput = JSONInputDataFactory.ReadJsonJob(driverDataFile);
+			var engineeringJob = jobInput as IEngineeringInputDataProvider;
+			if (engineeringJob == null) {
+				throw new VectoException("Failed to cas to Engineering InputDataProvider");
+			}
+			var dao = new EngineeringDataAdapter();
+			return dao.CreateDriverData(engineeringJob.DriverInputData);
+		}
+	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/VectoCoreTest.csproj b/VectoCore/VectoCoreTest/VectoCoreTest.csproj
index 11a4c5a1abdaf69bdc8a960b7bf3c5e063e42dab..fcf0b2932db38f99aa99b37f27fa1852fb44d309 100644
--- a/VectoCore/VectoCoreTest/VectoCoreTest.csproj
+++ b/VectoCore/VectoCoreTest/VectoCoreTest.csproj
@@ -261,6 +261,9 @@
     <None Include="TestData\Components\AT_GBX\GearboxSerial.vgbx">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Components\AT_GBX\GearboxSerialDualTCBus.vgbx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Components\AT_GBX\GearboxSerialDualTC.vgbx">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>