refactoring reading input files - separate dataObjectAdapter

VectoCore/FileIO/DeclarationFile/VehicleFileDecl.cs

@@ -40,11 +40,6 @@ namespace TUGraz.VectoCore.FileIO.DeclarationFile
 
 			[JsonProperty(Required = Required.Always)] public AxleConfigData AxleConfig;
 
-			public AxleConfiguration AxleConfigurationType()
-			{
-				// TODO: @@@quam better use of enum-prefix
-				return (AxleConfiguration) Enum.Parse(typeof (AxleConfiguration), "AxleConfig_" + AxleConfig.TypeStr, true);
-			}
 
 			public class AxleConfigData
 			{
@@ -62,6 +57,9 @@ namespace TUGraz.VectoCore.FileIO.DeclarationFile
 				[JsonProperty(Required = Required.Always)] public bool TwinTyres;
 				[JsonProperty("RRCISO", Required = Required.Always)] public double RollResistanceCoefficient;
 				[JsonProperty("FzISO", Required = Required.Always)] public double TyreTestLoad;
+
+				[JsonProperty] public double Inertia;
+				[JsonProperty] public double AxleWeightShare;
 			}
 
 			public class RetarderData

VectoCore/FileIO/EngineeringFile/VehicleFileEng.cs

@@ -24,20 +24,20 @@ namespace TUGraz.VectoCore.FileIO.EngineeringFile
 			[JsonProperty("CdCorrFile")] public string CrossWindCorrectionFile;
 
 
-			[JsonProperty(Required = Required.Always)] public new AxleConfigData AxleConfig;
+			//[JsonProperty(Required = Required.Always)] public new AxleConfigData AxleConfig;
 
 
-			public new class AxleConfigData
-			{
-				[JsonProperty("Type", Required = Required.Always)] public string TypeStr;
-				[JsonProperty(Required = Required.Always)] public IList<AxleDataEng> Axles;
-			}
+			//public new class AxleConfigData
+			//{
+			//	[JsonProperty("Type", Required = Required.Always)] public string TypeStr;
+			//	[JsonProperty(Required = Required.Always)] public IList<AxleDataEng> Axles;
+			//}
 
-			public class AxleDataEng : AxleDataDecl
-			{
-				[JsonProperty] public double Inertia;
-				[JsonProperty] public double AxleWeightShare;
-			}
+			//public class AxleDataEng : AxleDataDecl
+			//{
+			//	[JsonProperty] public double Inertia;
+			//	[JsonProperty] public double AxleWeightShare;
+			//}
 		}
 	}
 }

VectoCore/FileIO/InputFileReader.cs

-using System;
-using System.CodeDom;
-using Common.Logging;
+using Common.Logging;
 using Newtonsoft.Json;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
 
 namespace TUGraz.VectoCore.FileIO
 {

VectoCore/FileIO/Reader/DataObjectAdaper/AbstractSimulationDataAdapter.cs

+using System;
+using System.IO;
+using TUGraz.VectoCore.FileIO.DeclarationFile;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
+{
+	public abstract class AbstractSimulationDataAdapter
+	{
+		public abstract VehicleData CreateVehicleData(VectoVehicleFile vehicle, Mission segment, Kilogram loading);
+
+		public abstract VehicleData CreateVehicleData(VectoVehicleFile vehicle);
+
+		public abstract CombustionEngineData CreateEngineData(VectoEngineFile engine);
+
+		public abstract GearboxData CreateGearboxData(VectoGearboxFile gearbox, CombustionEngineData engine);
+
+		// =========================
+
+		internal VehicleData SetCommonVehicleData(VehicleFileV5Declaration.DataBodyDecl data, string basePath)
+		{
+			var retVal = new VehicleData {
+				SavedInDeclarationMode = data.SavedInDeclarationMode,
+				VehicleCategory = data.VehicleCategory(),
+				AxleConfiguration = EnumHelper.ParseAxleConfigurationType(data.AxleConfig.TypeStr),
+				CurbWeight = data.CurbWeight.SI<Kilogram>(),
+				//CurbWeigthExtra = data.CurbWeightExtra.SI<Kilogram>(),
+				//Loading = data.Loading.SI<Kilogram>(),
+				GrossVehicleMassRating = data.GrossVehicleMassRating.SI<Ton>().Cast<Kilogram>(),
+				DragCoefficient = data.DragCoefficient,
+				CrossSectionArea = data.CrossSectionArea.SI<SquareMeter>(),
+				DragCoefficientRigidTruck = data.DragCoefficientRigidTruck,
+				CrossSectionAreaRigidTruck = data.CrossSectionAreaRigidTruck.SI<SquareMeter>(),
+				//TyreRadius = data.TyreRadius.SI().Milli.Meter.Cast<Meter>(),
+				Rim = data.RimStr,
+			};
+
+			var retarder = new RetarderData() {
+				Type =
+					(RetarderData.RetarderType) Enum.Parse(typeof (RetarderData.RetarderType), data.Retarder.TypeStr.ToString(), true),
+			};
+			if (retarder.Type != RetarderData.RetarderType.None) {
+				retarder.LossMap = RetarderLossMap.ReadFromFile(Path.Combine(basePath, data.Retarder.File));
+				retarder.Ratio = data.Retarder.Ratio;
+			}
+			retVal.Retarder = retarder;
+
+			return retVal;
+		}
+
+		internal CombustionEngineData SetCommonCombustionEngineData(EngineFileV2Declaration.DataBodyDecl data, string basePath)
+		{
+			var retVal = new CombustionEngineData() {
+				SavedInDeclarationMode = data.SavedInDeclarationMode,
+				ModelName = data.ModelName,
+				Displacement = data.Displacement.SI().Cubic.Centi.Meter.Cast<CubicMeter>(), // convert vom ccm to m^3
+				IdleSpeed = data.IdleSpeed.RPMtoRad(),
+				ConsumptionMap = FuelConsumptionMap.ReadFromFile(Path.Combine(basePath, data.FuelMap)),
+				WHTCUrban = data.WHTCUrban.SI<KilogramPerWattSecond>(),
+				WHTCMotorway = data.WHTCMotorway.SI<KilogramPerWattSecond>(),
+				WHTCRural = data.WHTCRural.SI<KilogramPerWattSecond>(),
+			};
+			return retVal;
+		}
+
+		internal GearboxData SetCommonGearboxData(GearboxFileV4Declaration.DataBodyDecl data)
+		{
+			return new GearboxData() {
+				SavedInDeclarationMode = data.SavedInDeclarationMode,
+				ModelName = data.ModelName,
+				Type = (GearboxData.GearboxType) Enum.Parse(typeof (GearboxData.GearboxType), data.GearboxType, true),
+			};
+		}
+	}
+}
\ No newline at end of file

VectoCore/FileIO/Reader/DataObjectAdaper/DeclarationDataAdapter.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using TUGraz.VectoCore.Exceptions;
+using TUGraz.VectoCore.FileIO.DeclarationFile;
+using TUGraz.VectoCore.FileIO.EngineeringFile;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
+{
+	public class DeclarationDataAdapter : AbstractSimulationDataAdapter
+	{
+		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle, Mission segment, Kilogram loading)
+		{
+			var fileV5Decl = vehicle as VehicleFileV5Declaration;
+			if (fileV5Decl != null) {
+				return CreateVehicleData(fileV5Decl, segment, loading);
+			}
+			throw new VectoException("Unsupported VehicleData File Instance");
+		}
+
+		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle)
+		{
+			var fileV5Decl = vehicle as VehicleFileV5Declaration;
+			if (fileV5Decl != null) {
+				return SetCommonVehicleData(fileV5Decl.Body, fileV5Decl.BasePath);
+			}
+			throw new VectoException("Mission Data and loading required in DeclarationMode");
+		}
+
+		public override CombustionEngineData CreateEngineData(VectoEngineFile engine)
+		{
+			var fileV2Decl = engine as EngineFileV2Declaration;
+			if (fileV2Decl != null) {
+				return CreateEngineData(fileV2Decl);
+			}
+			throw new VectoException("Unsupported EngineData File Instance");
+		}
+
+		public override GearboxData CreateGearboxData(VectoGearboxFile gearbox, CombustionEngineData engine)
+		{
+			var fileV5Decl = gearbox as GearboxFileV4Declaration;
+			if (fileV5Decl != null) {
+				return CreateGearboxData(fileV5Decl, engine);
+			}
+			throw new VectoException("Unsupported GearboxData File Instance");
+		}
+
+		//==========================
+
+		internal VehicleData CreateVehicleData(VehicleFileV5Declaration vehicle, Mission mission, Kilogram loading)
+		{
+			var data = vehicle.Body;
+			var retVal = SetCommonVehicleData(data, vehicle.BasePath);
+
+			retVal.BasePath = vehicle.BasePath;
+
+			retVal.GrossVehicleMassRating = vehicle.Body.GrossVehicleMassRating.SI<Ton>().Cast<Kilogram>();
+
+			retVal.CurbWeigthExtra = mission.MassExtra;
+			retVal.Loading = loading;
+			retVal.DynamicTyreRadius =
+				DeclarationData.DynamicTyreRadius(data.AxleConfig.Axles[DeclarationData.PoweredAxle()].WheelsStr, data.RimStr);
+
+			if (data.AxleConfig.Axles.Count < mission.AxleWeightDistribution.Length) {
+				throw new VectoException(
+					String.Format("Vehicle does not contain sufficient axles. {0} axles defined, {1} axles required",
+						data.AxleConfig.Axles.Count, mission.AxleWeightDistribution.Count()));
+			}
+			retVal.AxleData = new List<Axle>();
+			for (var i = 0; i < mission.AxleWeightDistribution.Length; i++) {
+				var axleInput = data.AxleConfig.Axles[i];
+				var axle = new Axle {
+					AxleWeightShare = mission.AxleWeightDistribution[i],
+					TwinTyres = axleInput.TwinTyres,
+					RollResistanceCoefficient = axleInput.RollResistanceCoefficient,
+					TyreTestLoad = axleInput.TyreTestLoad.SI<Newton>(),
+					Inertia = DeclarationData.Wheels.Lookup(axleInput.WheelsStr).Inertia,
+				};
+				retVal.AxleData.Add(axle);
+			}
+
+			foreach (var tmp in mission.TrailerAxleWeightDistribution) {
+				retVal.AxleData.Add(new Axle() {
+					AxleWeightShare = tmp,
+					TwinTyres = DeclarationData.Trailer.TwinTyres,
+					RollResistanceCoefficient = DeclarationData.Trailer.RollResistanceCoefficient,
+					TyreTestLoad = DeclarationData.Trailer.TyreTestLoad.SI<Newton>(),
+					Inertia = DeclarationData.Wheels.Lookup(DeclarationData.Trailer.WheelsType).Inertia
+				});
+			}
+
+			return retVal;
+		}
+
+		internal CombustionEngineData CreateEngineData(EngineFileV2Declaration engine)
+		{
+			var retVal = SetCommonCombustionEngineData(engine.Body, engine.BasePath);
+			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement);
+			foreach (var entry in engine.Body.FullLoadCurves) {
+				retVal.AddFullLoadCurve(entry.Gears, FullLoadCurve.ReadFromFile(Path.Combine(engine.BasePath, entry.Path), true));
+			}
+
+			return retVal;
+		}
+
+		internal GearboxData CreateGearboxData(GearboxFileV4Declaration gearbox, CombustionEngineData engine)
+		{
+			var retVal = SetCommonGearboxData(gearbox.Body);
+
+			if (retVal.Type == GearboxData.GearboxType.AT) {
+				throw new VectoSimulationException("Automatic Transmission currently not supported in DeclarationMode!");
+			}
+			if (retVal.Type == GearboxData.GearboxType.Custom) {
+				throw new VectoSimulationException("Custom Transmission not supported in DeclarationMode!");
+			}
+			retVal.Inertia = DeclarationData.Gearbox.Inertia.SI<KilogramSquareMeter>();
+			retVal.TractionInterruption = DeclarationData.Gearbox.TractionInterruption(retVal.Type);
+			retVal.SkipGears = DeclarationData.Gearbox.SkipGears(retVal.Type);
+			retVal.EarlyShiftUp = DeclarationData.Gearbox.EarlyShiftGears((retVal.Type));
+
+			retVal.TorqueReserve = DeclarationData.Gearbox.TorqueReserve;
+			retVal.StartTorqueReserve = DeclarationData.Gearbox.TorqueReserveStart;
+			retVal.ShiftTime = DeclarationData.Gearbox.MinTimeBetweenGearshifts.SI<Second>();
+			retVal.StartSpeed = DeclarationData.Gearbox.StartSpeed.SI<MeterPerSecond>();
+			retVal.StartAcceleration = DeclarationData.Gearbox.StartAcceleration.SI<MeterPerSquareSecond>();
+
+			retVal.HasTorqueConverter = false;
+
+
+			for (uint i = 0; i < gearbox.Body.Gears.Count; i++) {
+				var gearSettings = gearbox.Body.Gears[(int) i];
+				var lossMapPath = Path.Combine(gearbox.BasePath, gearSettings.LossMap);
+				TransmissionLossMap lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
+
+
+				if (i == 0) {
+					retVal.AxleGearData = new GearData(lossMap, null, gearSettings.Ratio, false);
+				} else {
+					var shiftPolygon = DeclarationData.Gearbox.ComputeShiftPolygon(engine, i);
+					retVal._gearData.Add(i, new GearData(lossMap, shiftPolygon, gearSettings.Ratio, false));
+				}
+			}
+
+			return retVal;
+		}
+	}
+}
\ No newline at end of file

VectoCore/FileIO/Reader/DataObjectAdaper/EngineeringDataAdapter.cs

+using System;
+using System.IO;
+using System.Linq;
+using TUGraz.VectoCore.Exceptions;
+using TUGraz.VectoCore.FileIO.EngineeringFile;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
+{
+	public class EngineeringDataAdapter : AbstractSimulationDataAdapter
+	{
+		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle, Models.Declaration.Mission segment,
+			Kilogram loading)
+		{
+			return CreateVehicleData(vehicle);
+		}
+
+		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle)
+		{
+			var fileV5Eng = vehicle as VehicleFileV5Engineering;
+			if (fileV5Eng != null) {
+				return CreateVehicleData(fileV5Eng);
+			}
+			throw new VectoException("Unsupported EngineData File Instance");
+		}
+
+		public override CombustionEngineData CreateEngineData(VectoEngineFile engine)
+		{
+			var fileV2Eng = engine as EngineFileV2Engineering;
+			if (fileV2Eng != null) {
+				return CreateEngineData(fileV2Eng);
+			}
+			throw new VectoException("Unsupported EngineData File Instance");
+		}
+
+		public override GearboxData CreateGearboxData(VectoGearboxFile gearbox, CombustionEngineData engine)
+		{
+			var fileV5Eng = gearbox as GearboxFileV4Engineering;
+			if (fileV5Eng != null) {
+				return CreateGearboxData(fileV5Eng);
+			}
+			throw new VectoException("Unsupported GearboxData File Instance");
+		}
+
+		//=================================
+
+
+		/// <summary>
+		/// convert datastructure representing file-contents into internal datastructure
+		/// Vehicle, file-format version 5
+		/// </summary>
+		/// <param name="vehicle">VehicleFileV5 container</param>
+		/// <returns>VehicleData instance</returns>
+		internal VehicleData CreateVehicleData(VehicleFileV5Engineering vehicle)
+		{
+			var data = vehicle.Body;
+
+			var retVal = SetCommonVehicleData(data, vehicle.BasePath);
+
+			retVal.BasePath = vehicle.BasePath;
+			retVal.CurbWeigthExtra = data.CurbWeightExtra.SI<Kilogram>();
+			retVal.Loading = data.Loading.SI<Kilogram>();
+			retVal.DynamicTyreRadius = data.DynamicTyreRadius.SI().Milli.Meter.Cast<Meter>();
+
+			retVal.AxleData = data.AxleConfig.Axles.Select(axle => new Axle {
+				Inertia = DoubleExtensionMethods.SI<KilogramSquareMeter>(axle.Inertia),
+				TwinTyres = axle.TwinTyres,
+				RollResistanceCoefficient = axle.RollResistanceCoefficient,
+				AxleWeightShare = axle.AxleWeightShare,
+				TyreTestLoad = axle.TyreTestLoad.SI<Newton>(),
+				//Wheels = axle.WheelsStr
+			}).ToList();
+			return retVal;
+		}
+
+
+		/// <summary>
+		/// convert datastructure representing the file-contents into internal data structure
+		/// Engine, file-format version 2
+		/// </summary>
+		/// <param name="engine">Engin-Data file (Engineering mode)</param>
+		/// <returns></returns>
+		internal CombustionEngineData CreateEngineData(EngineFileV2Engineering engine)
+		{
+			var retVal = SetCommonCombustionEngineData(engine.Body, engine.BasePath);
+			retVal.Inertia = engine.Body.Inertia.SI<KilogramSquareMeter>();
+			foreach (var entry in engine.Body.FullLoadCurves) {
+				retVal.AddFullLoadCurve(entry.Gears, FullLoadCurve.ReadFromFile(Path.Combine(engine.BasePath, entry.Path), false));
+			}
+
+			return retVal;
+		}
+
+
+		/// <summary>
+		/// convert datastructure representing the file-contents into internal data structure
+		/// Gearbox, File-format Version 4
+		/// </summary>
+		/// <param name="gearbox"></param>
+		/// <returns></returns>
+		internal GearboxData CreateGearboxData(GearboxFileV4Engineering gearbox)
+		{
+			var retVal = SetCommonGearboxData(gearbox.Body);
+
+			var data = gearbox.Body;
+
+			retVal.Inertia = data.Inertia.SI<KilogramSquareMeter>();
+			retVal.TractionInterruption = data.TractionInterruption.SI<Second>();
+			retVal.SkipGears = data.SkipGears;
+			retVal.EarlyShiftUp = data.EarlyShiftUp;
+			retVal.TorqueReserve = data.TorqueReserve;
+			retVal.StartTorqueReserve = data.StartTorqueReserve;
+			retVal.ShiftTime = data.ShiftTime.SI<Second>();
+			retVal.StartSpeed = data.StartSpeed.SI<MeterPerSecond>();
+			retVal.StartAcceleration = data.StartAcceleration.SI<MeterPerSquareSecond>();
+
+			retVal.HasTorqueConverter = data.TorqueConverter.Enabled;
+
+			for (uint i = 0; i < gearbox.Body.Gears.Count; i++) {
+				var gearSettings = gearbox.Body.Gears[(int) i];
+				var lossMapPath = Path.Combine(gearbox.BasePath, gearSettings.LossMap);
+				TransmissionLossMap lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
+
+				var shiftPolygon = !String.IsNullOrEmpty(gearSettings.ShiftPolygon)
+					? ShiftPolygon.ReadFromFile(Path.Combine(gearbox.BasePath, gearSettings.ShiftPolygon))
+					: null;
+
+				var gear = new GearData(lossMap, shiftPolygon, gearSettings.Ratio, gearSettings.TCactive);
+				if (i == 0) {
+					retVal.AxleGearData = gear;
+				} else {
+					retVal._gearData.Add(i, gear);
+				}
+			}
+			return retVal;
+		}
+	}
+}
\ No newline at end of file

VectoCore/FileIO/Reader/Impl/AbstractSimulationDataReader.cs

@@ -33,10 +33,7 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		public abstract IEnumerable<VectoRunData> NextRun();
 
 
-		protected virtual void ProcessJob(VectoJobFile job)
-		{
-			throw new VectoException("Invalid JobFile Container");
-		}
+		protected abstract void ProcessJob(VectoJobFile job);
 
 
 		// has to read the file string and create file-container
@@ -48,88 +45,5 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		protected abstract void ReadEngine(string file);
 
 		protected abstract void ReadGearbox(string file);
-
-
-		protected internal virtual Segment GetVehicleClassification(VectoVehicleFile vehicle)
-		{
-			throw new NotImplementedException("Vehicleclassification for base-class not possible!");
-		}
-
-		internal virtual VehicleData CreateVehicleData(VectoVehicleFile vehicle, Mission segment, Kilogram loading)
-		{
-			throw new NotImplementedException("CreateVehicleData for base-class not possible!");
-		}
-
-		internal virtual CombustionEngineData CreateEngineData(VectoEngineFile engine)
-		{
-			throw new NotImplementedException("CreateEngineData for base-class not possible!");
-		}
-
-		internal virtual GearboxData CreateGearboxData(VectoGearboxFile gearbox)
-		{
-			throw new NotImplementedException("CreateGearboxDataFromFile for base-class not possible!");
-		}
-
-		internal VehicleData SetCommonVehicleData(VehicleFileV5Declaration vehicle)
-		{
-			var data = ((dynamic) vehicle).Body;
-			var retVal = new VehicleData {
-				SavedInDeclarationMode = data.SavedInDeclarationMode,
-				VehicleCategory = data.VehicleCategory(),
-				AxleConfiguration = vehicle.Body.AxleConfigurationType(),
-				CurbWeight = SIConvert<Kilogram>(data.CurbWeight),
-				//CurbWeigthExtra = data.CurbWeightExtra.SI<Kilogram>(),
-				//Loading = data.Loading.SI<Kilogram>(),
-				GrossVehicleMassRating = SIConvert<Kilogram>(data.GrossVehicleMassRating * 1000),
-				DragCoefficient = data.DragCoefficient,
-				CrossSectionArea = SIConvert<SquareMeter>(data.CrossSectionArea),
-				DragCoefficientRigidTruck = data.DragCoefficientRigidTruck,
-				CrossSectionAreaRigidTruck = SIConvert<SquareMeter>(data.CrossSectionAreaRigidTruck),
-				//TyreRadius = data.TyreRadius.SI().Milli.Meter.Cast<Meter>(),
-				Rim = data.RimStr,
-			};
-
-			var retarder = new RetarderData() {
-				Type =
-					(RetarderData.RetarderType) Enum.Parse(typeof (RetarderData.RetarderType), data.Retarder.TypeStr.ToString(), true),
-			};
-			if (retarder.Type != RetarderData.RetarderType.None) {
-				retarder.LossMap = RetarderLossMap.ReadFromFile(Path.Combine(vehicle.BasePath, data.Retarder.File));
-				retarder.Ratio = data.Retarder.Ratio;
-			}
-			retVal.Retarder = retarder;
-
-			return retVal;
-		}
-
-		internal CombustionEngineData SetCommonCombustionEngineData(EngineFileV2Declaration engine)
-		{
-			var data = ((dynamic) engine).Body;
-			var retVal = new CombustionEngineData() {
-				SavedInDeclarationMode = data.SavedInDeclarationMode,
-				ModelName = data.ModelName,
-				Displacement = SIConvert<CubicMeter>(data.Displacement * 0.000001), // convert vom ccm to m^3
-				IdleSpeed = DoubleExtensionMethods.RPMtoRad(data.IdleSpeed),
-				ConsumptionMap = FuelConsumptionMap.ReadFromFile(Path.Combine(engine.BasePath, data.FuelMap)),
-				WHTCUrban = SIConvert<KilogramPerWattSecond>(data.WHTCUrban),
-				WHTCMotorway = SIConvert<KilogramPerWattSecond>(data.WHTCMotorway),
-				WHTCRural = SIConvert<KilogramPerWattSecond>(data.WHTCRural),
-			};
-			return retVal;
-		}
-
-		internal GearboxData SetCommonGearboxData(GearboxFileV4Declaration.DataBodyDecl data)
-		{
-			return new GearboxData() {
-				SavedInDeclarationMode = data.SavedInDeclarationMode,
-				ModelName = data.ModelName,
-				Type = (GearboxData.GearboxType) Enum.Parse(typeof (GearboxData.GearboxType), data.GearboxType, true),
-			};
-		}
-
-		protected T1 SIConvert<T1>(double val) where T1 : SIBase<T1>
-		{
-			return val.SI<T1>();
-		}
 	}
 }
\ No newline at end of file

VectoCore/FileIO/Reader/Impl/DeclarationModeSimulationDataReader.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using Newtonsoft.Json;
 using TUGraz.VectoCore.Exceptions;
 using TUGraz.VectoCore.FileIO.DeclarationFile;
+using TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
@@ -17,33 +18,8 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 {
 	public class DeclarationModeSimulationDataReader : AbstractSimulationDataReader
 	{
-		public const int PoweredAxle = 1;
-
 		internal DeclarationModeSimulationDataReader() {}
 
-		//public void SetJobFile(string fileName)
-		//{
-		//	var file = File.ReadAllText(fileName);
-		//	SetJobJson(file, Path.GetDirectoryName(fileName));
-		//}
-
-		//public void SetJobJson(string file, string basePath)
-		//{
-		//	var fileInfo = GetFileVersion(file);
-
-		//	if (!fileInfo.Item2) {
-		//		throw new VectoException("File not saved in Declaration Mode!");
-		//	}
-		//	switch (fileInfo.Item1) {
-		//		case 2:
-		//			break;
-		//		default:
-		//			throw new UnsupportedFileVersionException("Unsupported version of .vecto file/data. Got Version " + fileInfo.Item1);
-		//	}
-		//}
-
-		//protected RetarderData RetarderData;
-
 		protected void CheckForDeclarationMode(InputFileReader.VersionInfo info, string msg)
 		{
 			if (!info.SavedInDeclarationMode) {
@@ -54,17 +30,20 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 
 		public override IEnumerable<VectoRunData> NextRun()
 		{
-			var segment = GetVehicleClassification(((dynamic) Vehicle).Body);
+			var dao = new DeclarationDataAdapter();
+			var tmpVehicle = dao.CreateVehicleData(Vehicle);
+			var segment = GetVehicleClassification(tmpVehicle.VehicleCategory, tmpVehicle.AxleConfiguration,
+				tmpVehicle.GrossVehicleMassRating, tmpVehicle.CurbWeight);
 			foreach (var mission in segment.Missions) {
 				foreach (var loading in mission.Loadings) {
-					var engineData = CreateEngineData((dynamic) Engine);
+					var engineData = dao.CreateEngineData(Engine);
 					var parser = new DrivingCycleData.DistanceBasedDataParser();
-					DataTable data = VectoCSVFile.ReadStream(mission.CycleFile);
+					var data = VectoCSVFile.ReadStream(mission.CycleFile);
 					var cycleEntries = parser.Parse(data).ToList();
 					var simulationRunData = new VectoRunData() {
-						VehicleData = CreateVehicleData((dynamic) Vehicle, mission, loading),
+						VehicleData = dao.CreateVehicleData(Vehicle, mission, loading),
 						EngineData = engineData,
-						GearboxData = CreateGearboxData((dynamic) Gearbox, engineData),
+						GearboxData = dao.CreateGearboxData(Gearbox, engineData),
 						// @@@ TODO: auxiliaries
 						// @@@ TODO: ...
 						Cycle = new DrivingCycleData() {
@@ -76,10 +55,8 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 						JobFileName = Job.JobFile,
 					};
 					yield return simulationRunData;
-					//var builder = new SimulatorFactory.PowertrainBuilder();
 				}
 			}
-			//throw new NotImplementedException();
 		}
 
 		protected override void ProcessJob(VectoJobFile vectoJob)
@@ -164,140 +141,14 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		}
 
 
-		internal Segment GetVehicleClassification(VehicleFileV5Declaration.DataBodyDecl vehicle)
-		{
-			return new DeclarationSegments().Lookup(vehicle.VehicleCategory(), vehicle.AxleConfigurationType(),
-				vehicle.GrossVehicleMassRating.SI<Ton>().Cast<Kilogram>(), vehicle.CurbWeight.SI<Kilogram>());
-		}
-
-
-		internal VehicleData CreateVehicleData(VehicleFileV5Declaration vehicle, Mission mission, Kilogram loading)
-		{
-			var data = vehicle.Body;
-			var retVal = SetCommonVehicleData(vehicle);
-
-			retVal.BasePath = vehicle.BasePath;
-
-			retVal.GrossVehicleMassRating = vehicle.Body.GrossVehicleMassRating.SI<Ton>().Cast<Kilogram>();
-
-			retVal.CurbWeigthExtra = mission.MassExtra;
-			retVal.Loading = loading;
-			retVal.DynamicTyreRadius =
-				DeclarationData.DynamicTyreRadius(data.AxleConfig.Axles[PoweredAxle].WheelsStr, data.RimStr);
-
-			if (data.AxleConfig.Axles.Count < mission.AxleWeightDistribution.Length) {
-				throw new VectoException(
-					String.Format("Vehicle does not contain sufficient axles. {0} axles defined, {1} axles required",
-						data.AxleConfig.Axles.Count, mission.AxleWeightDistribution.Count()));
-			}
-			retVal.AxleData = new List<Axle>();
-			for (var i = 0; i < mission.AxleWeightDistribution.Length; i++) {
-				var axleInput = data.AxleConfig.Axles[i];
-				var axle = new Axle {
-					AxleWeightShare = mission.AxleWeightDistribution[i],
-					TwinTyres = axleInput.TwinTyres,
-					RollResistanceCoefficient = axleInput.RollResistanceCoefficient,
-					TyreTestLoad = DoubleExtensionMethods.SI<Newton>(axleInput.TyreTestLoad),
-					Inertia = DeclarationData.Wheels.Lookup(axleInput.WheelsStr).Inertia,
-				};
-				retVal.AxleData.Add(axle);
-			}
-
-			foreach (var tmp in mission.TrailerAxleWeightDistribution) {
-				retVal.AxleData.Add(new Axle() {
-					AxleWeightShare = tmp,
-					TwinTyres = DeclarationData.Trailer.TwinTyres,
-					RollResistanceCoefficient = DeclarationData.Trailer.RollResistanceCoefficient,
-					TyreTestLoad = DeclarationData.Trailer.TyreTestLoad.SI<Newton>(),
-					Inertia = DeclarationData.Wheels.Lookup(DeclarationData.Trailer.WheelsType).Inertia
-				});
-			}
-
-			return retVal;
-		}
-
-		internal CombustionEngineData CreateEngineData(EngineFileV2Declaration engine)
-		{
-			var retVal = SetCommonCombustionEngineData(engine);
-			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement);
-			foreach (var entry in engine.Body.FullLoadCurves) {
-				retVal.AddFullLoadCurve(entry.Gears, FullLoadCurve.ReadFromFile(Path.Combine(engine.BasePath, entry.Path), true));
-			}
-
-			return retVal;
-		}
-
-		internal GearboxData CreateGearboxData(GearboxFileV4Declaration gearbox, CombustionEngineData engine)
-		{
-			var retVal = SetCommonGearboxData(gearbox.Body);
-
-			if (retVal.Type == GearboxData.GearboxType.AT) {
-				throw new VectoSimulationException("Automatic Transmission currently not supported in DeclarationMode!");
-			}
-			if (retVal.Type == GearboxData.GearboxType.Custom) {
-				throw new VectoSimulationException("Custom Transmission not supported in DeclarationMode!");
-			}
-			retVal.Inertia = DeclarationData.Gearbox.Inertia.SI<KilogramSquareMeter>();
-			retVal.TractionInterruption = DeclarationData.Gearbox.TractionInterruption(retVal.Type);
-			retVal.SkipGears = DeclarationData.Gearbox.SkipGears(retVal.Type);
-			retVal.EarlyShiftUp = DeclarationData.Gearbox.EarlyShiftGears((retVal.Type));
-
-			retVal.TorqueReserve = DeclarationData.Gearbox.TorqueReserve;
-			retVal.StartTorqueReserve = DeclarationData.Gearbox.TorqueReserveStart;
-			retVal.ShiftTime = DeclarationData.Gearbox.MinTimeBetweenGearshifts.SI<Second>();
-			retVal.StartSpeed = DeclarationData.Gearbox.StartSpeed.SI<MeterPerSecond>();
-			retVal.StartAcceleration = DeclarationData.Gearbox.StartAcceleration.SI<MeterPerSquareSecond>();
-
-			retVal.HasTorqueConverter = false;
-
-
-			for (uint i = 0; i < gearbox.Body.Gears.Count; i++) {
-				var gearSettings = gearbox.Body.Gears[(int) i];
-				var lossMapPath = Path.Combine(gearbox.BasePath, gearSettings.LossMap);
-				TransmissionLossMap lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
-
-
-				if (i == 0) {
-					retVal.AxleGearData = new GearData(lossMap, null, gearSettings.Ratio, false);
-				} else {
-					var shiftPolygon = ComputeShiftPolygon(engine, i);
-					retVal._gearData.Add(i, new GearData(lossMap, shiftPolygon, gearSettings.Ratio, false));
-				}
-			}
-
-			return retVal;
-		}
-
-		internal ShiftPolygon ComputeShiftPolygon(CombustionEngineData engine, uint gear)
+		internal Segment GetVehicleClassification(VehicleCategory category, AxleConfiguration axles, Kilogram grossMassRating,
+			Kilogram curbWeight)
 		{
-			var fullLoadCurve = engine.GetFullLoadCurve(gear);
-			var idleSpeed = engine.IdleSpeed;
-
-			var maxTorque = fullLoadCurve.MaxLoadTorque;
-
-			var entriesDown = new List<ShiftPolygon.ShiftPolygonEntry>();
-			var entriesUp = new List<ShiftPolygon.ShiftPolygonEntry>();
-
-			entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = idleSpeed, Torque = 0.SI<NewtonMeter>() });
-
-			var tq1 = maxTorque * idleSpeed / (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed - idleSpeed);
-			entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = idleSpeed, Torque = tq1 });
-
-			var speed1 = (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed) / 2;
-			entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = speed1, Torque = maxTorque });
-
-
-			entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() {
-				AngularSpeed = fullLoadCurve.PreferredSpeed,
-				Torque = 0.SI<NewtonMeter>()
-			});
-
-			tq1 = maxTorque * (fullLoadCurve.PreferredSpeed - idleSpeed) / (fullLoadCurve.N95hSpeed - idleSpeed);
-			entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.PreferredSpeed, Torque = tq1 });
-
-			entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.N95hSpeed, Torque = maxTorque });
+			//return new DeclarationSegments().Lookup(vehicle.VehicleCategory(),
+			//	EnumHelper.ParseAxleConfigurationType(vehicle.AxleConfig.TypeStr),
+			//	vehicle.GrossVehicleMassRating.SI<Ton>().Cast<Kilogram>(), vehicle.CurbWeight.SI<Kilogram>());
 
-			return new ShiftPolygon(entriesDown, entriesUp);
+			return new DeclarationSegments().Lookup(category, axles, grossMassRating, curbWeight);
 		}
 	}
 }
\ No newline at end of file

VectoCore/FileIO/Reader/Impl/EngineOnlySimulationDataReader.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using TUGraz.VectoCore.Exceptions;
 using TUGraz.VectoCore.FileIO.EngineeringFile;
+using TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.Simulation.Impl;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
@@ -20,12 +21,12 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 				Log.Warn("Job-file is null or unsupported version");
 				yield break;
 			}
-
+			var dao = new EngineeringDataAdapter();
 			foreach (var cycle in job.Body.Cycles) {
 				var simulationRunData = new VectoRunData() {
 					BasePath = job.BasePath,
 					JobFileName = job.JobFile,
-					EngineData = CreateEngineData((dynamic) Engine),
+					EngineData = dao.CreateEngineData(Engine),
 					Cycle = DrivingCycleData.ReadFromFileEngineOnly(Path.Combine(job.BasePath, cycle)),
 					IsEngineOnly = true
 				};

VectoCore/FileIO/Reader/Impl/EngineeringModeSimulationDataReader.cs

@@ -7,6 +7,7 @@ using Common.Logging;
 using Newtonsoft.Json;
 using TUGraz.VectoCore.Exceptions;
 using TUGraz.VectoCore.FileIO.EngineeringFile;
+using TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
@@ -72,13 +73,14 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 				Log.Warn("Job-file is null or unsupported version");
 				yield break;
 			}
+			var dao = new EngineeringDataAdapter();
 			foreach (var cycle in job.Body.Cycles) {
 				var simulationRunData = new VectoRunData() {
 					BasePath = job.BasePath,
 					JobFileName = job.JobFile,
-					EngineData = CreateEngineData((dynamic) Engine),
-					GearboxData = CreateGearboxData((dynamic) Gearbox),
-					VehicleData = CreateVehicleData((dynamic) Vehicle),
+					EngineData = dao.CreateEngineData(Engine),
+					GearboxData = dao.CreateGearboxData(Gearbox, null),
+					VehicleData = dao.CreateVehicleData(Vehicle),
 					//DriverData = new DriverData(),
 					//Aux = 
 					Cycle = DrivingCycleData.ReadFromFile(Path.Combine(job.BasePath, cycle), DrivingCycleData.CycleType.DistanceBased),
@@ -96,7 +98,7 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		public static VehicleData CreateVehicleDataFromFile(string file)
 		{
 			var data = DoReadVehicleFile(file);
-			return new EngineeringModeSimulationDataReader().CreateVehicleData((dynamic) data);
+			return new EngineeringDataAdapter().CreateVehicleData(data);
 		}
 
 		/// <summary>
@@ -107,7 +109,7 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		public static CombustionEngineData CreateEngineDataFromFile(string file)
 		{
 			var data = DoReadEngineFile(file);
-			return new EngineeringModeSimulationDataReader().CreateEngineData((dynamic) data);
+			return new EngineeringDataAdapter().CreateEngineData(data);
 		}
 
 		/// <summary>
@@ -118,7 +120,7 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 		public static GearboxData CreateGearboxDataFromFile(string file)
 		{
 			var data = DoReadGearboxFile(file);
-			return new EngineeringModeSimulationDataReader().CreateGearboxData((dynamic) data);
+			return new EngineeringDataAdapter().CreateGearboxData(data, null);
 		}
 
 		/// <summary>
@@ -222,94 +224,5 @@ namespace TUGraz.VectoCore.FileIO.Reader.Impl
 					throw new UnsupportedFileVersionException("Unsopported Version of vehicle-file. Got version " + fileInfo.Version);
 			}
 		}
-
-		/// <summary>
-		/// convert datastructure representing file-contents into internal datastructure
-		/// Vehicle, file-format version 5
-		/// </summary>
-		/// <param name="vehicle">VehicleFileV5 container</param>
-		/// <returns>VehicleData instance</returns>
-		internal VehicleData CreateVehicleData(VehicleFileV5Engineering vehicle)
-		{
-			var data = vehicle.Body;
-
-			var retVal = SetCommonVehicleData(vehicle);
-
-			retVal.BasePath = vehicle.BasePath;
-			retVal.CurbWeigthExtra = data.CurbWeightExtra.SI<Kilogram>();
-			retVal.Loading = data.Loading.SI<Kilogram>();
-			retVal.DynamicTyreRadius = data.DynamicTyreRadius.SI().Milli.Meter.Cast<Meter>();
-
-			retVal.AxleData = data.AxleConfig.Axles.Select(axle => new Axle {
-				Inertia = DoubleExtensionMethods.SI<KilogramSquareMeter>(axle.Inertia),
-				TwinTyres = axle.TwinTyres,
-				RollResistanceCoefficient = axle.RollResistanceCoefficient,
-				AxleWeightShare = axle.AxleWeightShare,
-				TyreTestLoad = DoubleExtensionMethods.SI<Newton>(axle.TyreTestLoad),
-				//Wheels = axle.WheelsStr
-			}).ToList();
-			return retVal;
-		}
-
-		/// <summary>
-		/// convert datastructure representing the file-contents into internal data structure
-		/// Engine, file-format version 2
-		/// </summary>
-		/// <param name="engine">Engin-Data file (Engineering mode)</param>
-		/// <returns></returns>
-		internal CombustionEngineData CreateEngineData(EngineFileV2Engineering engine)
-		{
-			var retVal = SetCommonCombustionEngineData(engine);
-			retVal.Inertia = engine.Body.Inertia.SI<KilogramSquareMeter>();
-			foreach (var entry in engine.Body.FullLoadCurves) {
-				retVal.AddFullLoadCurve(entry.Gears, FullLoadCurve.ReadFromFile(Path.Combine(engine.BasePath, entry.Path), false));
-			}
-
-			return retVal;
-		}
-
-
-		/// <summary>
-		/// convert datastructure representing the file-contents into internal data structure
-		/// Gearbox, File-format Version 4
-		/// </summary>
-		/// <param name="gearbox"></param>
-		/// <returns></returns>
-		internal GearboxData CreateGearboxData(GearboxFileV4Engineering gearbox)
-		{
-			var retVal = SetCommonGearboxData(gearbox.Body);
-
-			var data = gearbox.Body;
-
-			retVal.Inertia = data.Inertia.SI<KilogramSquareMeter>();
-			retVal.TractionInterruption = data.TractionInterruption.SI<Second>();
-			retVal.SkipGears = data.SkipGears;
-			retVal.EarlyShiftUp = data.EarlyShiftUp;
-			retVal.TorqueReserve = data.TorqueReserve;
-			retVal.StartTorqueReserve = data.StartTorqueReserve;
-			retVal.ShiftTime = data.ShiftTime.SI<Second>();
-			retVal.StartSpeed = data.StartSpeed.SI<MeterPerSecond>();
-			retVal.StartAcceleration = data.StartAcceleration.SI<MeterPerSquareSecond>();
-
-			retVal.HasTorqueConverter = data.TorqueConverter.Enabled;
-
-			for (uint i = 0; i < gearbox.Body.Gears.Count; i++) {
-				var gearSettings = gearbox.Body.Gears[(int) i];
-				var lossMapPath = Path.Combine(gearbox.BasePath, gearSettings.LossMap);
-				TransmissionLossMap lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
-
-				var shiftPolygon = !String.IsNullOrEmpty(gearSettings.ShiftPolygon)
-					? ShiftPolygon.ReadFromFile(Path.Combine(gearbox.BasePath, gearSettings.ShiftPolygon))
-					: null;
-
-				var gear = new GearData(lossMap, shiftPolygon, gearSettings.Ratio, gearSettings.TCactive);
-				if (i == 0) {
-					retVal.AxleGearData = gear;
-				} else {
-					retVal._gearData.Add(i, gear);
-				}
-			}
-			return retVal;
-		}
 	}
 }
\ No newline at end of file

VectoCore/Models/Declaration/AxleConfiguration.cs

+using System;
+
 namespace TUGraz.VectoCore.Models.Declaration
 {
 	public enum AxleConfiguration
@@ -20,4 +22,12 @@ namespace TUGraz.VectoCore.Models.Declaration
 			return self.ToString().Substring(11);
 		}
 	}
+
+	public static class EnumHelper
+	{
+		public static AxleConfiguration ParseAxleConfigurationType(string typeString)
+		{
+			return (AxleConfiguration) Enum.Parse(typeof (AxleConfiguration), "AxleConfig_" + typeString, true);
+		}
+	}
 }
\ No newline at end of file

VectoCore/Models/Declaration/DeclarationData.cs

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
 using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.Models.Declaration
@@ -58,6 +60,12 @@ namespace TUGraz.VectoCore.Models.Declaration
 			_electricSystem = new ElectricSystem();
 		}
 
+		public static int PoweredAxle()
+		{
+			return 1;
+		}
+
+
 		private static DeclarationData Instance()
 		{
 			return _instance ?? (_instance = new DeclarationData());
@@ -147,6 +155,38 @@ namespace TUGraz.VectoCore.Models.Declaration
 				}
 				return false;
 			}
+
+			internal static ShiftPolygon ComputeShiftPolygon(CombustionEngineData engine, uint gear)
+			{
+				var fullLoadCurve = engine.GetFullLoadCurve(gear);
+				var idleSpeed = engine.IdleSpeed;
+
+				var maxTorque = fullLoadCurve.MaxLoadTorque;
+
+				var entriesDown = new List<ShiftPolygon.ShiftPolygonEntry>();
+				var entriesUp = new List<ShiftPolygon.ShiftPolygonEntry>();
+
+				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = idleSpeed, Torque = 0.SI<NewtonMeter>() });
+
+				var tq1 = maxTorque * idleSpeed / (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed - idleSpeed);
+				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = idleSpeed, Torque = tq1 });
+
+				var speed1 = (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed) / 2;
+				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = speed1, Torque = maxTorque });
+
+
+				entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() {
+					AngularSpeed = fullLoadCurve.PreferredSpeed,
+					Torque = 0.SI<NewtonMeter>()
+				});
+
+				tq1 = maxTorque * (fullLoadCurve.PreferredSpeed - idleSpeed) / (fullLoadCurve.N95hSpeed - idleSpeed);
+				entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.PreferredSpeed, Torque = tq1 });
+
+				entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.N95hSpeed, Torque = maxTorque });
+
+				return new ShiftPolygon(entriesDown, entriesUp);
+			}
 		}
 	}
 }
\ No newline at end of file

VectoCore/Models/SimulationComponent/Data/CombustionEngineData.cs

@@ -25,7 +25,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 		/// <summary>
 		///     [m^3]
 		/// </summary>
-		public SI Displacement { get; internal set; }
+		public CubicMeter Displacement { get; internal set; }
 
 		/// <summary>
 		///     [rad/s]

VectoCore/VectoCore.csproj

@@ -119,6 +119,9 @@
     <Compile Include="FileIO\EngineeringFile\VehicleFileEng.cs" />
     <Compile Include="FileIO\InputFileReader.cs" />
     <Compile Include="FileIO\JsonDataHeader.cs" />
+    <Compile Include="FileIO\Reader\DataObjectAdaper\AbstractSimulationDataAdapter.cs" />
+    <Compile Include="FileIO\Reader\DataObjectAdaper\DeclarationDataAdapter.cs" />
+    <Compile Include="FileIO\Reader\DataObjectAdaper\EngineeringDataAdapter.cs" />
     <Compile Include="FileIO\Reader\Impl\AbstractSimulationDataReader.cs" />
     <Compile Include="FileIO\Reader\Impl\DeclarationModeSimulationDataReader.cs" />
     <Compile Include="FileIO\Reader\Impl\EngineeringModeSimulationDataReader.cs" />