adding methods to create maps (fuel consumption, loss maps, ...) from data...

adding methods to create maps (fuel consumption, loss maps, ...) from data table, further refactoring of input data, adapting data object adapter

VectoCore/InputData/FileIO/JSON/JSONEngineData.cs

+using System.Data;
+using Newtonsoft.Json.Linq;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	public class JSONEngineDataV3 : JSONFile, IEngineInputData
+	{
+		public JSONEngineDataV3(JObject data, string fileName) : base(data, fileName) {}
+
+		public string ModelName
+		{
+			get { return Body[JsonKeys.Engine_ModelName].Value<string>(); }
+		}
+
+		public CubicMeter Displacement
+		{
+			get { return Body[JsonKeys.Engine_Displacement].Value<double>().SI().Cubic.Centi.Meter.Cast<CubicMeter>(); }
+			// convert vom ccm to m^3}
+		}
+
+		public RoundsPerMinute IdleSpeed
+		{
+			get { return Body[JsonKeys.Engine_IdleSpeed].Value<double>().SI<RoundsPerMinute>(); }
+		}
+
+		public DataTable FuelConsumptionMap
+		{
+			get { return ReadTableData(Body[JsonKeys.Engine_FuelConsumptionMap].Value<string>(), "FuelConsumptionMap"); }
+		}
+
+		public DataTable FullLoadCurve
+		{
+			get { return ReadTableData(Body[JsonKeys.Engine_FullLoadCurveFile].Value<string>(), "FullLoadCurve"); }
+		}
+
+		public KilogramSquareMeter Inertia
+		{
+			get { return Body[JsonKeys.Engine_Inertia].Value<double>().SI<KilogramSquareMeter>(); }
+		}
+
+		public KilogramPerWattSecond WHTCMotorway
+		{
+			get { return Body[JsonKeys.Engine_WHTC_Motorway].Value<double>().SI<KilogramPerWattSecond>(); }
+		}
+
+		public KilogramPerWattSecond WHTCRural
+		{
+			get { return Body[JsonKeys.Engine_WHTC_Rural].Value<double>().SI<KilogramPerWattSecond>(); }
+		}
+
+		public KilogramPerWattSecond WHTCUrban
+		{
+			get { return Body[JsonKeys.Engine_WHTC_Urban].Value<double>().SI<KilogramPerWattSecond>(); }
+		}
+	}
+}
\ No newline at end of file

VectoCore/InputData/FileIO/JSON/JSONGearboxData.cs

+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	public class JSONGearboxDataV5 : JSONFile, IGearboxInputData, IAxleGearInputData, ITorqueConverterInputData
+	{
+		public JSONGearboxDataV5(JObject data, string filename) : base(data, filename) {}
+
+		#region IAxleGearInputData
+
+		public double Ratio
+		{
+			get { return Body[JsonKeys.Gearbox_Gears][0][JsonKeys.Gearbox_Gear_Ratio].Value<double>(); }
+		}
+
+		public DataTable LossMap
+		{
+			get
+			{
+				return ReadTableData(Body[JsonKeys.Gearbox_Gears][0][JsonKeys.Gearbox_Gear_LossMapFile].Value<string>(), "AxleGear");
+			}
+		}
+
+		#endregion
+
+		#region IGearboxInputData
+
+		public string ModelName
+		{
+			get { return Body[JsonKeys.Gearbox_ModelName].Value<string>(); }
+		}
+
+		public GearboxType Type
+		{
+			get { return Body[JsonKeys.Gearbox_GearboxType].Value<string>().Parse<GearboxType>(); }
+		}
+
+
+		public KilogramSquareMeter Inertia
+		{
+			get { return Body[JsonKeys.Gearbox_Inertia].Value<double>().SI<KilogramSquareMeter>(); }
+		}
+
+		public Second TractionInterruption
+		{
+			get { return Body[JsonKeys.Gearbox_TractionInterruption].Value<double>().SI<Second>(); }
+		}
+
+		public IList<ITransmissionInputData> Gears
+		{
+			get
+			{
+				var i = 0;
+				return (from gear in Body[JsonKeys.Gearbox_Gears]
+					where i++ != 0
+					let lossMap =
+						ReadTableData(gear[JsonKeys.Gearbox_Gear_LossMapFile].Value<string>(), string.Format("Gear {0} LossMap", i))
+					let fullLoadCurve =
+						ReadTableData(gear[JsonKeys.Gearbox_Gear_FullLoadCurveFile].Value<string>(),
+							string.Format("Gear {0} FLD", i), false)
+					let shiftPolygon =
+						ReadTableData(gear[JsonKeys.Gearbox_Gear_ShiftPolygonFile].Value<string>(),
+							string.Format("Gear {0} shiftPolygon", i), false)
+					select new JSONTransmissionInputData() {
+						Gear = i,
+						Ratio = gear[JsonKeys.Gearbox_Gear_Ratio].Value<double>(),
+						FullLoadCurve = fullLoadCurve,
+						LossMap = lossMap,
+						ShiftPolygon = shiftPolygon,
+						TorqueConverterActive = gear[JsonKeys.Gearbox_Gear_TCactive].Value<bool>()
+					}).Cast<ITransmissionInputData>().ToList();
+			}
+		}
+
+		public bool SkipGears
+		{
+			get { return Body[JsonKeys.Gearbox_SkipGears].Value<bool>(); }
+		}
+
+		public Second ShiftTime
+		{
+			get { return Body[JsonKeys.Gearbox_ShiftTime].Value<double>().SI<Second>(); }
+		}
+
+		public bool EarlyShiftUp
+		{
+			get { return Body[JsonKeys.Gearbox_EarlyShiftUp].Value<bool>(); }
+		}
+
+		public double TorqueReserve
+		{
+			get { return Body[JsonKeys.Gearbox_TorqueReserve].Value<double>() / 100.0; }
+		}
+
+		public MeterPerSecond StartSpeed
+		{
+			get { return Body[JsonKeys.Gearbox_StartSpeed].Value<double>().SI<MeterPerSecond>(); }
+		}
+
+		public MeterPerSquareSecond StartAcceleration
+		{
+			get { return Body[JsonKeys.Gearbox_StartAcceleration].Value<double>().SI<MeterPerSquareSecond>(); }
+		}
+
+		public double StartTorqueReserve
+		{
+			get { return Body[JsonKeys.Gearbox_StartTorqueReserve].Value<double>() / 100.0; }
+		}
+
+		public ITorqueConverterInputData TorqueConverter
+		{
+			get { return this; }
+		}
+
+		#endregion
+
+		#region ITorqueConverterInputData
+
+		public RoundsPerMinute ReferenceRPM
+		{
+			get
+			{
+				return
+					Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_ReferenceRPM].Value<double>()
+						.SI<RoundsPerMinute>();
+			}
+		}
+
+		public DataTable TCData
+		{
+			get
+			{
+				return ReadTableData(
+					Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_TCMap].Value<string>(),
+					"TorqueConverter Data");
+			}
+		}
+
+		KilogramSquareMeter ITorqueConverterInputData.Inertia
+		{
+			get
+			{
+				return
+					Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_Inertia].Value<double>()
+						.SI<KilogramSquareMeter>();
+			}
+		}
+
+		#endregion
+	}
+
+	public class JSONTransmissionInputData : ITransmissionInputData
+	{
+		public int Gear { get; internal set; }
+
+		public double Ratio { get; internal set; }
+
+		public DataTable LossMap { get; internal set; }
+
+		public DataTable FullLoadCurve { get; internal set; }
+
+		public DataTable ShiftPolygon { get; internal set; }
+
+		public bool TorqueConverterActive { get; internal set; }
+	}
+}
\ No newline at end of file

VectoCore/InputData/FileIO/JSON/JSONInputData.cs

@@ -5,7 +5,6 @@ using System.IO;
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using TUGraz.VectoCore.Exceptions;
-using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Utils;
 
@@ -40,6 +39,17 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 			get { return _basePath; }
 			set { _basePath = Path.GetDirectoryName(Path.GetFullPath(value)); }
 		}
+
+		protected DataTable ReadTableData(string filename, string tableType, bool required = true)
+		{
+			if (filename == null || !filename.Any() || filename.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
+				if (required) {
+					throw new VectoException("Invalid {0}: {1}", tableType, filename);
+				}
+				return null;
+			}
+			return VectoCSVFile.Read(Path.Combine(BasePath, filename));
+		}
 	}
 
 	public class JSONInputDataV2 : JSONFile, IInputDataProvider, IJobInputData, IDriverInputData
@@ -125,370 +135,111 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 		}
 
 		public IList<DataTable> Cycles
-		{
-			get
-			{
-				return Body["Cycles"].Select(cycle => VectoCSVFile.Read(Path.Combine(BasePath, cycle.Value<string>()))).ToList();
-			}
-		}
-
-		public bool EngineOnlyMode
-		{
-			get { return Body["EngineOnlyMode"].Value<bool>(); }
-		}
-
-		#endregion
-	}
-
-	public class JSONVehicleDataV7 : JSONFile, IVehicleInputData, IRetarderInputData
-	{
-		public JSONVehicleDataV7(JObject data, string fileName) : base(data, fileName) {}
-
-		#region IVehicleInputData
-
-		public VehicleCategory VehicleCategory
-		{
-			get
-			{
-				return
-					(VehicleCategory)Enum.Parse(typeof(VehicleCategory), Body[JsonKeys.Vehicle_VehicleCategory].Value<string>(), true);
-			}
-		}
-
-		public Kilogram CurbWeight
-		{
-			get { return Body[JsonKeys.Vehicle_CurbWeight].Value<double>().SI<Kilogram>(); }
-		}
-
-		public Kilogram GrossVehicleMassRating
-		{
-			get { return Body[JsonKeys.Vehicle_GrossVehicleMassRating].Value<double>().SI<Ton>().Cast<Kilogram>(); }
-		}
-
-		public SquareMeter DragCoefficient
-		{
-			get { return Body[JsonKeys.Vehicle_DragCoefficient].Value<double>().SI<SquareMeter>(); }
-		}
-
-		public SquareMeter DragCoefficientRigidTruck
-		{
-			get { return Body[JsonKeys.Vehicle_DragCoefficientRigidTruck].Value<double>().SI<SquareMeter>(); }
-		}
-
-		public string Rim
-		{
-			get { return Body[JsonKeys.Vehicle_Rim].Value<string>(); }
-		}
-
-		public AxleConfiguration AxleConfiguration
 		{
 			get
 			{
 				return
-					AxleConfigurationHelper.Parse(
-						Body[JsonKeys.Vehicle_AxleConfiguration][JsonKeys.Vehicle_AxleConfiguration_Type].Value<string>());
+					Body[JsonKeys.Job_Cycles].Select(cycle => VectoCSVFile.Read(Path.Combine(BasePath, cycle.Value<string>())))
+						.ToList();
 			}
 		}
 
-		public IList<IAxleInputData> Axles
-		{
-			get
+		public bool EngineOnlyMode
 		{
-				return
-					Body[JsonKeys.Vehicle_AxleConfiguration][JsonKeys.Vehicle_AxleConfiguration_Axles].Select(
-						axle => new JSONAxleInputData() {
-							Inertia = axle[JsonKeys.Vehicle_Axles_Inertia].Value<double>().SI<KilogramSquareMeter>(),
-							Wheels = axle[JsonKeys.Vehicle_Axles_Wheels].Value<string>(),
-							TwinTyres = axle[JsonKeys.Vehicle_Axles_TwinTyres].Value<bool>(),
-							RollResistanceCoefficient = axle[JsonKeys.Vehicle_Axles_RollResistanceCoefficient].Value<double>(),
-							TyreTestLoad = axle[JsonKeys.Vehicle_Axles_TyreTestLoad].Value<double>().SI<Newton>()
-						}).Cast<IAxleInputData>().ToList();
-			}
+			get { return Body[JsonKeys.Job_EngineOnlyMode].Value<bool>(); }
 		}
 
 		#endregion
 
-		#region IRetarderInputData
+		#region DriverInputData
 
-		public RetarderData.RetarderType Type
+		public IStartStopInputData StartStop
 		{
 			get
 			{
-				return
-					(RetarderData.RetarderType)
-						Enum.Parse(typeof(RetarderData.RetarderType),
-							Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_Type].Value<string>(), true);
-			}
+				return new JSONStartStop() {
+					Enabled = Body[JsonKeys.DriverData_StartStop][JsonKeys.DriverData_StartStop_Enabled].Value<bool>(),
+					Delay = Body[JsonKeys.DriverData_StartStop][JsonKeys.DriverData_StartStop_Delay].Value<double>().SI<Second>(),
+					MaxSpeed =
+						Body[JsonKeys.DriverData_StartStop][JsonKeys.DriverData_StartStop_MaxSpeed].Value<double>().KMPHtoMeterPerSecond(),
+					MinTime = Body[JsonKeys.DriverData_StartStop][JsonKeys.DriverData_StartStop_MinTime].Value<double>().SI<Second>(),
+				};
 			}
-
-		public double Ratio
-		{
-			get { return Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_Ratio].Value<double>(); }
 		}
 
-		public DataTable LossMap
+		public ILookaheadCoastingInputData Lookahead
 		{
 			get
 			{
-				var filename = Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_LossMapFile].Value<string>();
-				if (filename == null || !filename.Any() || filename.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
-					throw new VectoException("Invalid Lossmap: {0}", filename);
+				return new JSONLookaheadCoasting() {
+					Enabled = Body[JsonKeys.DriverData_LookaheadCoasting][JsonKeys.DriverData_Lookahead_Enabled].Value<bool>(),
+					Deceleration =
+						Body[JsonKeys.DriverData_LookaheadCoasting][JsonKeys.DriverData_Lookahead_Deceleration].Value<double>()
+							.SI<MeterPerSquareSecond>(),
+					MinSpeed =
+						Body[JsonKeys.DriverData_LookaheadCoasting][JsonKeys.DriverData_Lookahead_MinSpeed].Value<double>()
+							.KMPHtoMeterPerSecond(),
+				};
 			}
-				return VectoCSVFile.Read(Path.Combine(BasePath, filename));
 		}
-		}
-
-		#endregion
-	}
-
-	public class JSONEngineDataV3 : JSONFile, IEngineInputData
-	{
-		public JSONEngineDataV3(JObject data, string fileName) : base(data, fileName) {}
 
-		public string ModelName
-		{
-			get { return Body[JsonKeys.Engine_ModelName].Value<string>(); }
-		}
-
-		public CubicMeter Displacement
-		{
-			get { return Body[JsonKeys.Engine_Displacement].Value<double>().SI().Cubic.Centi.Meter.Cast<CubicMeter>(); }
-		}
-
-		public RoundsPerMinute IdleSpeed
-		{
-			get { return Body[JsonKeys.Engine_IdleSpeed].Value<double>().SI<RoundsPerMinute>(); }
-		}
-
-		public DataTable FullLoadCurve
+		public IOverspeedEcoRollInputData OverspeedEcoRoll
 		{
 			get
 			{
-				var filename = Body[JsonKeys.Engine_FullLoadCurveFile].Value<string>();
-				if (filename == null || !filename.Any() || filename.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
-					throw new VectoException("Invalid FullLoadCurve: {0}", filename);
-				}
-				return VectoCSVFile.Read(Path.Combine(BasePath, filename));
-			}
-		}
-
-		public KilogramSquareMeter Inertia
-		{
-			get { return Body[JsonKeys.Engine_Inertia].Value<double>().SI<KilogramSquareMeter>(); }
+				return new JSONOverSpeedEcoRoll() {
+					Mode =
+						DriverData.ParseDriverMode(
+							Body[JsonKeys.DriverData_OverspeedEcoRoll][JsonKeys.DriverData_OverspeedEcoRoll_Mode].Value<string>()),
+					MinSpeed =
+						Body[JsonKeys.DriverData_OverspeedEcoRoll][JsonKeys.DriverData_OverspeedEcoRoll_MinSpeed].Value<double>()
+							.KMPHtoMeterPerSecond(),
+					OverSpeed =
+						Body[JsonKeys.DriverData_OverspeedEcoRoll][JsonKeys.DriverData_OverspeedEcoRoll_OverSpeed].Value<double>()
+							.KMPHtoMeterPerSecond(),
+					UnderSpeed =
+						Body[JsonKeys.DriverData_OverspeedEcoRoll][JsonKeys.DriverData_OverspeedEcoRoll_UnderSpeed].Value<double>()
+							.KMPHtoMeterPerSecond()
+				};
 			}
-
-		public KilogramPerWattSecond WHTCMotorway
-		{
-			get { return Body[JsonKeys.Engine_WHTC_Motorway].Value<double>().SI<KilogramPerWattSecond>(); }
-		}
-
-		public KilogramPerWattSecond WHTCRural
-		{
-			get { return Body[JsonKeys.Engine_WHTC_Rural].Value<double>().SI<KilogramPerWattSecond>(); }
-		}
-
-		public KilogramPerWattSecond WHTCUrban
-		{
-			get { return Body[JsonKeys.Engine_WHTC_Urban].Value<double>().SI<KilogramPerWattSecond>(); }
-		}
-	}
-
-	public class JSONGearboxDataV5 : JSONFile, IGearboxInputData, IAxleGearInputData, ITorqueConverterInputData
-	{
-		public JSONGearboxDataV5(JObject data, string filename) : base(data, filename) {}
-
-		#region IAxleGearInputData
-
-		public double Ratio
-		{
-			get { return Body[JsonKeys.Gearbox_Gears][0][JsonKeys.Gearbox_Gear_Ratio].Value<double>(); }
 		}
 
-		public DataTable LossMap
-		{
-			get
+		public DataTable AccelerationCurve
 		{
-				var filename = Body[JsonKeys.Gearbox_Gears][0][JsonKeys.Gearbox_Gear_LossMapFile].Value<string>();
-				if (filename == null || !filename.Any() || filename.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
-					throw new VectoException("Invalid AxleGear LossMap: {0}", filename);
-				}
-				return VectoCSVFile.Read(Path.Combine(BasePath, filename));
-			}
+			get { return ReadTableData(Body[JsonKeys.DriverData_AccelerationCurve].Value<string>(), "DriverAccelerationCurve"); }
 		}
 
 		#endregion
-
-		#region IGearboxInputData
-
-		public string ModelName
-		{
-			get { return Body[JsonKeys.Gearbox_ModelName].Value<string>(); }
-		}
-
-		public GearboxType Type
-		{
-			get { return Body[JsonKeys.Gearbox_GearboxType].Value<string>().Parse<GearboxType>(); }
-		}
-
-
-		public KilogramSquareMeter Inertia
-		{
-			get { return Body[JsonKeys.Gearbox_Inertia].Value<double>().SI<KilogramSquareMeter>(); }
-		}
-
-		public Second TractionInterruption
-		{
-			get { return Body[JsonKeys.Gearbox_TractionInterruption].Value<double>().SI<Second>(); }
-		}
-
-		public IList<ITransmissionInputData> Gears
-		{
-			get
-			{
-				var retVal = new List<ITransmissionInputData>();
-				var i = 0;
-				foreach (var gear in Body[JsonKeys.Gearbox_Gears]) {
-					if (i++ == 0) {
-						continue;
-					}
-					var lossMapFile = gear[JsonKeys.Gearbox_Gear_LossMapFile].Value<string>();
-					if (lossMapFile == null || !lossMapFile.Any() ||
-						lossMapFile.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
-						throw new VectoException("Invalid AxleGear LossMap: {0}", lossMapFile);
-					}
-					var lossMap = VectoCSVFile.Read(Path.Combine(BasePath, lossMapFile));
-
-					var fullLoadCurveFile = gear[JsonKeys.Gearbox_Gear_FullLoadCurveFile].Value<string>();
-					DataTable fullLoadCurve = null;
-					if (fullLoadCurveFile != null && fullLoadCurveFile.Any()) {
-						fullLoadCurve = VectoCSVFile.Read(Path.Combine(BasePath, fullLoadCurveFile));
-					}
-
-					var shiftPolygonFile = gear[JsonKeys.Gearbox_Gear_ShiftPolygonFile].Value<string>();
-					DataTable shiftPolygon = null;
-					if (shiftPolygonFile != null && shiftPolygonFile.Any() && !shiftPolygonFile.Equals("-")) {
-						shiftPolygon = VectoCSVFile.Read(Path.Combine(BasePath, shiftPolygonFile));
-					}
-
-					retVal.Add(new JSONTransmissionInputData() {
-						Gear = i,
-						Ratio = gear[JsonKeys.Gearbox_Gear_Ratio].Value<double>(),
-						FullLoadCurve = fullLoadCurve,
-						LossMap = lossMap,
-						ShiftPolygon = shiftPolygon,
-						TorqueConverterActive = gear[JsonKeys.Gearbox_Gear_TCactive].Value<bool>()
-					});
-				}
-				return retVal;
-			}
-		}
-
-		public bool SkipGears
-		{
-			get { return Body[JsonKeys.Gearbox_SkipGears].Value<bool>(); }
-		}
-
-		public Second ShiftTime
-		{
-			get { return Body[JsonKeys.Gearbox_ShiftTime].Value<double>().SI<Second>(); }
-		}
-
-		public bool EarlyShiftUp
-		{
-			get { return Body[JsonKeys.Gearbox_EarlyShiftUp].Value<bool>(); }
 	}
 
-		public double TorqueReserve
+	public class JSONStartStop : IStartStopInputData
 	{
-			get { return Body[JsonKeys.Gearbox_TorqueReserve].Value<double>() / 100.0; }
-		}
+		public bool Enabled { get; internal set; }
 
-		public MeterPerSecond StartSpeed
-		{
-			get { return Body[JsonKeys.Gearbox_StartSpeed].Value<double>().SI<MeterPerSecond>(); }
-		}
+		public MeterPerSecond MaxSpeed { get; internal set; }
 
-		public MeterPerSquareSecond StartAcceleration
-		{
-			get { return Body[JsonKeys.Gearbox_StartAcceleration].Value<double>().SI<MeterPerSquareSecond>(); }
-		}
+		public Second MinTime { get; internal set; }
 
-		public double StartTorqueReserve
-		{
-			get { return Body[JsonKeys.Gearbox_StartTorqueReserve].Value<double>() / 100.0; }
+		public Second Delay { get; internal set; }
 	}
 
-		public ITorqueConverterInputData TorqueConverter
+	public class JSONLookaheadCoasting : ILookaheadCoastingInputData
 	{
-			get { return this; }
-		}
+		public bool Enabled { get; internal set; }
 
-		#endregion
-
-		#region ITorqueConverterInputData
+		public MeterPerSquareSecond Deceleration { get; internal set; }
 
-		public RoundsPerMinute ReferenceRPM
-		{
-			get
-			{
-				return
-					Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_ReferenceRPM].Value<double>()
-						.SI<RoundsPerMinute>();
-			}
+		public MeterPerSecond MinSpeed { get; internal set; }
 	}
 
-		public DataTable TCData
-		{
-			get
+	public class JSONOverSpeedEcoRoll : IOverspeedEcoRollInputData
 	{
-				var filename = Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_TCMap].Value<string>();
-				if (filename == null || !filename.Any() || filename.Equals("<NOFILE>", StringComparison.InvariantCultureIgnoreCase)) {
-					throw new VectoException("Invalid TroqueConverter Curve: {0}", filename);
-				}
-				return VectoCSVFile.Read(Path.Combine(BasePath, filename));
-			}
-		}
-
-		KilogramSquareMeter ITorqueConverterInputData.Inertia
-		{
-			get
-			{
-				return
-					Body[JsonKeys.Gearbox_TorqueConverter][JsonKeys.Gearbox_TorqueConverter_Inertia].Value<double>()
-						.SI<KilogramSquareMeter>();
-			}
-		}
-
-		#endregion
-	}
-
-	public class JSONTransmissionInputData : ITransmissionInputData
-	{
-		public int Gear { get; internal set; }
-
-		public double Ratio { get; internal set; }
-
-		public DataTable LossMap { get; internal set; }
-
-		public DataTable FullLoadCurve { get; internal set; }
-
-		public DataTable ShiftPolygon { get; internal set; }
-
-		public bool TorqueConverterActive { get; internal set; }
-	}
-
-	public class JSONAxleInputData : IAxleInputData
-	{
-		public string Wheels { get; internal set; }
-
-		public bool TwinTyres { get; internal set; }
-
-		public double RollResistanceCoefficient { get; internal set; }
+		public DriverData.DriverMode Mode { get; internal set; }
 
-		public Newton TyreTestLoad { get; internal set; }
+		public MeterPerSecond MinSpeed { get; internal set; }
 
-		public double AxleWeightShare { get; internal set; }
+		public MeterPerSecond OverSpeed { get; internal set; }
 
-		public KilogramSquareMeter Inertia { get; internal set; }
+		public MeterPerSecond UnderSpeed { get; internal set; }
 	}
 }
\ No newline at end of file

VectoCore/InputData/FileIO/JSONInputDataFactory.cs → VectoCore/InputData/FileIO/JSON/JSONInputDataFactory.cs

@@ -2,9 +2,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using TUGraz.VectoCore.Exceptions;
-using TUGraz.VectoCore.InputData.FileIO.JSON;
 
-namespace TUGraz.VectoCore.InputData.FileIO
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
 {
 	public class JSONInputDataFactory
 	{

VectoCore/InputData/FileIO/JSON/JSONVehicleData.cs

+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.InputData.FileIO.JSON
+{
+	public class JSONVehicleDataV7 : JSONFile, IVehicleInputData, IRetarderInputData
+	{
+		public JSONVehicleDataV7(JObject data, string fileName) : base(data, fileName) {}
+
+		#region IVehicleInputData
+
+		public VehicleCategory VehicleCategory
+		{
+			get
+			{
+				return
+					(VehicleCategory)Enum.Parse(typeof(VehicleCategory), Body[JsonKeys.Vehicle_VehicleCategory].Value<string>(), true);
+			}
+		}
+
+		public Kilogram CurbWeight
+		{
+			get { return Body[JsonKeys.Vehicle_CurbWeight].Value<double>().SI<Kilogram>(); }
+		}
+
+		public Kilogram GrossVehicleMassRating
+		{
+			get { return Body[JsonKeys.Vehicle_GrossVehicleMassRating].Value<double>().SI<Ton>().Cast<Kilogram>(); }
+		}
+
+		public SquareMeter DragCoefficient
+		{
+			get { return Body[JsonKeys.Vehicle_DragCoefficient].Value<double>().SI<SquareMeter>(); }
+		}
+
+		public SquareMeter DragCoefficientRigidTruck
+		{
+			get { return Body[JsonKeys.Vehicle_DragCoefficientRigidTruck].Value<double>().SI<SquareMeter>(); }
+		}
+
+		public string Rim
+		{
+			get { return Body[JsonKeys.Vehicle_Rim].Value<string>(); }
+		}
+
+		public AxleConfiguration AxleConfiguration
+		{
+			get
+			{
+				return
+					AxleConfigurationHelper.Parse(
+						Body[JsonKeys.Vehicle_AxleConfiguration][JsonKeys.Vehicle_AxleConfiguration_Type].Value<string>());
+			}
+		}
+
+		public IList<IAxleInputData> Axles
+		{
+			get
+			{
+				return
+					Body[JsonKeys.Vehicle_AxleConfiguration][JsonKeys.Vehicle_AxleConfiguration_Axles].Select(
+						axle => new JSONAxleInputData() {
+							Inertia = Extensions.Value<double>(axle[JsonKeys.Vehicle_Axles_Inertia]).SI<KilogramSquareMeter>(),
+							Wheels = Extensions.Value<string>(axle[JsonKeys.Vehicle_Axles_Wheels]),
+							TwinTyres = Extensions.Value<bool>(axle[JsonKeys.Vehicle_Axles_TwinTyres]),
+							RollResistanceCoefficient = Extensions.Value<double>(axle[JsonKeys.Vehicle_Axles_RollResistanceCoefficient]),
+							TyreTestLoad = Extensions.Value<double>(axle[JsonKeys.Vehicle_Axles_TyreTestLoad]).SI<Newton>()
+						}).Cast<IAxleInputData>().ToList();
+			}
+		}
+
+		#endregion
+
+		#region IRetarderInputData
+
+		public RetarderData.RetarderType Type
+		{
+			get
+			{
+				return
+					(RetarderData.RetarderType)
+						Enum.Parse(typeof(RetarderData.RetarderType),
+							Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_Type].Value<string>(), true);
+			}
+		}
+
+		public double Ratio
+		{
+			get { return Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_Ratio].Value<double>(); }
+		}
+
+		public DataTable LossMap
+		{
+			get
+			{
+				return ReadTableData(Body[JsonKeys.Vehicle_Retarder][JsonKeys.Vehicle_Retarder_LossMapFile].Value<string>(),
+					"LossMap");
+			}
+		}
+
+		#endregion
+	}
+
+
+	public class JSONAxleInputData : IAxleInputData
+	{
+		public string Wheels { get; internal set; }
+
+		public bool TwinTyres { get; internal set; }
+
+		public double RollResistanceCoefficient { get; internal set; }
+
+		public Newton TyreTestLoad { get; internal set; }
+
+		public double AxleWeightShare { get; internal set; }
+
+		public KilogramSquareMeter Inertia { get; internal set; }
+	}
+}
\ No newline at end of file

VectoCore/InputData/InputData.cs

@@ -140,6 +140,8 @@ namespace TUGraz.VectoCore.InputData
 		/// <summary>
 		/// engine speed in rpm, torque in NM, fuel consumption in g/h
 		/// </summary>
+		DataTable FuelConsumptionMap { get; }
+
 		DataTable FullLoadCurve { get; }
 
 		KilogramSquareMeter Inertia { get; }
@@ -149,7 +151,38 @@ namespace TUGraz.VectoCore.InputData
 		KilogramPerWattSecond WHTCUrban { get; }
 	}
 
-	public interface IDriverInputData {}
+	public interface IDriverInputData
+	{
+		IStartStopInputData StartStop { get; }
+		ILookaheadCoastingInputData Lookahead { get; }
+		IOverspeedEcoRollInputData OverspeedEcoRoll { get; }
+
+		DataTable AccelerationCurve { get; }
+	}
+
+	public interface IOverspeedEcoRollInputData
+	{
+		DriverData.DriverMode Mode { get; }
+		MeterPerSecond MinSpeed { get; }
+		MeterPerSecond OverSpeed { get; }
+		MeterPerSecond UnderSpeed { get; }
+	}
+
+	public interface ILookaheadCoastingInputData
+	{
+		bool Enabled { get; }
+		MeterPerSquareSecond Deceleration { get; }
+		MeterPerSecond MinSpeed { get; }
+	}
+
+	public interface IStartStopInputData
+	{
+		bool Enabled { get; }
+		MeterPerSecond MaxSpeed { get; }
+		Second MinTime { get; }
+		Second Delay { get; }
+	}
+
 
 	public interface IAuxiliaryInputData
 	{

VectoCore/JsonKeys.Designer.cs

@@ -60,6 +60,141 @@ namespace TUGraz.VectoCore {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to VACC.
+        /// </summary>
+        internal static string DriverData_AccelerationCurve {
+            get {
+                return ResourceManager.GetString("DriverData_AccelerationCurve", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Dec.
+        /// </summary>
+        internal static string DriverData_Lookahead_Deceleration {
+            get {
+                return ResourceManager.GetString("DriverData_Lookahead_Deceleration", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Enabled.
+        /// </summary>
+        internal static string DriverData_Lookahead_Enabled {
+            get {
+                return ResourceManager.GetString("DriverData_Lookahead_Enabled", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to MinSpeed.
+        /// </summary>
+        internal static string DriverData_Lookahead_MinSpeed {
+            get {
+                return ResourceManager.GetString("DriverData_Lookahead_MinSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to LAC.
+        /// </summary>
+        internal static string DriverData_LookaheadCoasting {
+            get {
+                return ResourceManager.GetString("DriverData_LookaheadCoasting", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to OverspeedEcoRoll.
+        /// </summary>
+        internal static string DriverData_OverspeedEcoRoll {
+            get {
+                return ResourceManager.GetString("DriverData_OverspeedEcoRoll", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to MinSpeed.
+        /// </summary>
+        internal static string DriverData_OverspeedEcoRoll_MinSpeed {
+            get {
+                return ResourceManager.GetString("DriverData_OverspeedEcoRoll_MinSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Mode.
+        /// </summary>
+        internal static string DriverData_OverspeedEcoRoll_Mode {
+            get {
+                return ResourceManager.GetString("DriverData_OverspeedEcoRoll_Mode", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to OverSpeed.
+        /// </summary>
+        internal static string DriverData_OverspeedEcoRoll_OverSpeed {
+            get {
+                return ResourceManager.GetString("DriverData_OverspeedEcoRoll_OverSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to UnderSpeed.
+        /// </summary>
+        internal static string DriverData_OverspeedEcoRoll_UnderSpeed {
+            get {
+                return ResourceManager.GetString("DriverData_OverspeedEcoRoll_UnderSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to StartStop.
+        /// </summary>
+        internal static string DriverData_StartStop {
+            get {
+                return ResourceManager.GetString("DriverData_StartStop", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Delay.
+        /// </summary>
+        internal static string DriverData_StartStop_Delay {
+            get {
+                return ResourceManager.GetString("DriverData_StartStop_Delay", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Enabled.
+        /// </summary>
+        internal static string DriverData_StartStop_Enabled {
+            get {
+                return ResourceManager.GetString("DriverData_StartStop_Enabled", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to MaxSpeed.
+        /// </summary>
+        internal static string DriverData_StartStop_MaxSpeed {
+            get {
+                return ResourceManager.GetString("DriverData_StartStop_MaxSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to MinTime.
+        /// </summary>
+        internal static string DriverData_StartStop_MinTime {
+            get {
+                return ResourceManager.GetString("DriverData_StartStop_MinTime", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Displacement.
         /// </summary>
@@ -69,6 +204,15 @@ namespace TUGraz.VectoCore {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to FuelMap.
+        /// </summary>
+        internal static string Engine_FuelConsumptionMap {
+            get {
+                return ResourceManager.GetString("Engine_FuelConsumptionMap", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to FullLoadCurve.
         /// </summary>
@@ -321,6 +465,24 @@ namespace TUGraz.VectoCore {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Cycles.
+        /// </summary>
+        internal static string Job_Cycles {
+            get {
+                return ResourceManager.GetString("Job_Cycles", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EngineOnlyMode.
+        /// </summary>
+        internal static string Job_EngineOnlyMode {
+            get {
+                return ResourceManager.GetString("Job_EngineOnlyMode", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Body.
         /// </summary>

VectoCore/JsonKeys.resx

@@ -112,5 +112,155 @@
   </data>
 	<data name="Vehicle_VehicleFile" xml:space="preserve">
     <value>VehicleFile</value>
+  </data>
+	<data name="SavedInDeclMode" xml:space="preserve">
+    <value>SavedInDeclMode</value>
+  </data>
+	<data name="Vehicle_VehicleCategory" xml:space="preserve">
+    <value>VehCat</value>
+  </data>
+	<data name="Vehicle_CurbWeight" xml:space="preserve">
+    <value>CurbWeight</value>
+  </data>
+	<data name="Vehicle_GrossVehicleMassRating" xml:space="preserve">
+    <value>MassMax</value>
+  </data>
+	<data name="JsonBody" xml:space="preserve">
+    <value>Body</value>
+  </data>
+	<data name="Vehicle_DragCoefficient" xml:space="preserve">
+    <value>CdA</value>
+  </data>
+	<data name="Vehicle_DragCoefficientRigidTruck" xml:space="preserve">
+    <value>CdA2</value>
+  </data>
+	<data name="Vehicle_Rim" xml:space="preserve">
+    <value>Rim</value>
+  </data>
+	<data name="Vehicle_AxleConfiguration" xml:space="preserve">
+    <value>AxleConfig</value>
+  </data>
+	<data name="Vehicle_AxleConfiguration_Type" xml:space="preserve">
+    <value>Type</value>
+  </data>
+	<data name="Vehicle_AxleConfiguration_Axles" xml:space="preserve">
+    <value>Axles</value>
+  </data>
+	<data name="Vehicle_Axles_Inertia" xml:space="preserve">
+    <value>Inertia</value>
+  </data>
+	<data name="Vehicle_Axles_Wheels" xml:space="preserve">
+    <value>Wheels</value>
+  </data>
+	<data name="Vehicle_Axles_TwinTyres" xml:space="preserve">
+    <value>TwinTyres</value>
+  </data>
+	<data name="Vehicle_Axles_RollResistanceCoefficient" xml:space="preserve">
+    <value>RRCISO</value>
+  </data>
+	<data name="Vehicle_Axles_TyreTestLoad" xml:space="preserve">
+    <value>FzISO</value>
+  </data>
+	<data name="Vehicle_Retarder" xml:space="preserve">
+    <value>Retarder</value>
+  </data>
+	<data name="Vehicle_Retarder_Type" xml:space="preserve">
+    <value>Type</value>
+  </data>
+	<data name="Vehicle_Retarder_Ratio" xml:space="preserve">
+    <value>Ratio</value>
+  </data>
+	<data name="Vehicle_Retarder_LossMapFile" xml:space="preserve">
+    <value>File</value>
+  </data>
+	<data name="Engine_ModelName" xml:space="preserve">
+    <value>ModelName</value>
+  </data>
+	<data name="Engine_Displacement" xml:space="preserve">
+    <value>Displacement</value>
+  </data>
+	<data name="Engine_IdleSpeed" xml:space="preserve">
+    <value>IdlingSpeed</value>
+  </data>
+	<data name="Engine_FullLoadCurveFile" xml:space="preserve">
+    <value>FullLoadCurve</value>
+  </data>
+	<data name="Engine_Inertia" xml:space="preserve">
+    <value>Inertia</value>
+  </data>
+	<data name="Engine_WHTC_Motorway" xml:space="preserve">
+    <value>WHTC-Motorway</value>
+  </data>
+	<data name="Engine_WHTC_Rural" xml:space="preserve">
+    <value>WHTC-Rural</value>
+  </data>
+	<data name="Engine_WHTC_Urban" xml:space="preserve">
+    <value>WHTC-Urban</value>
+  </data>
+	<data name="Gearbox_Gears" xml:space="preserve">
+    <value>Gears</value>
+  </data>
+	<data name="Gearbox_Gear_Ratio" xml:space="preserve">
+    <value>Ratio</value>
+  </data>
+	<data name="Gearbox_Gear_LossMapFile" xml:space="preserve">
+    <value>LossMap</value>
+  </data>
+	<data name="Gearbox_ModelName" xml:space="preserve">
+    <value>ModelName</value>
+  </data>
+	<data name="Gearbox_GearboxType" xml:space="preserve">
+    <value>GearboxType</value>
+  </data>
+	<data name="Gearbox_Inertia" xml:space="preserve">
+    <value>Inertia</value>
+  </data>
+	<data name="Gearbox_TractionInterruption" xml:space="preserve">
+    <value>TracInt</value>
+  </data>
+	<data name="Gearbox_Gear_FullLoadCurveFile" xml:space="preserve">
+    <value>FullLoadCurve</value>
+  </data>
+	<data name="Gearbox_Gear_ShiftPolygonFile" xml:space="preserve">
+    <value>ShiftPolygon</value>
+  </data>
+	<data name="Gearbox_Gear_TCactive" xml:space="preserve">
+    <value>TCactive</value>
+  </data>
+	<data name="Gearbox_SkipGears" xml:space="preserve">
+    <value>SkipGears</value>
+  </data>
+	<data name="Gearbox_ShiftTime" xml:space="preserve">
+    <value>ShiftTime</value>
+  </data>
+	<data name="Gearbox_EarlyShiftUp" xml:space="preserve">
+    <value>EarlyShiftUp</value>
+  </data>
+	<data name="Gearbox_TorqueReserve" xml:space="preserve">
+    <value>TqReserve</value>
+  </data>
+	<data name="Gearbox_StartSpeed" xml:space="preserve">
+    <value>StartSpeed</value>
+  </data>
+	<data name="Gearbox_StartAcceleration" xml:space="preserve">
+    <value>StartAcc</value>
+  </data>
+	<data name="Gearbox_StartTorqueReserve" xml:space="preserve">
+    <value>StartTqReserve</value>
+  </data>
+	<data name="Gearbox_TorqueConverter" xml:space="preserve">
+    <value>TorqueConverter</value>
+  </data>
+	<data name="Gearbox_TorqueConverter_ReferenceRPM" xml:space="preserve">
+    <value>RefRPM</value>
+  </data>
+	<data name="Gearbox_TorqueConverter_TCMap" xml:space="preserve">
+    <value>File</value>
+  </data>
+	<data name="Gearbox_TorqueConverter_Inertia" xml:space="preserve">
+    <value>Inertia</value>
+  </data>
+	<data name="Engine_FuelConsumptionMap" xml:space="preserve">
+    <value>FuelMap</value>
   </data>
 </root>
\ No newline at end of file

VectoCore/Models/Simulation/Data/VectoRunData.cs

@@ -21,6 +21,8 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 
 		public string AccelerationLimitingFile { get; internal set; }
 
+		public RetarderData Retarder { get; internal set; }
+
 		public DriverData DriverData { get; internal set; }
 
 		public bool IsEngineOnly { get; internal set; }

VectoCore/Models/Simulation/Impl/SimulatorFactory.cs

@@ -4,6 +4,7 @@ using System.Reflection;
 using System.Threading;
 using TUGraz.VectoCore.Configuration;
 using TUGraz.VectoCore.Exceptions;
+using TUGraz.VectoCore.InputData;
 using TUGraz.VectoCore.InputData.FileIO.Reader;
 using TUGraz.VectoCore.InputData.FileIO.Reader.Impl;
 using TUGraz.VectoCore.Models.Simulation.Data;
@@ -30,13 +31,13 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			_mode = mode;
 			switch (mode) {
 				case FactoryMode.DeclarationMode:
-					DataReader = new DeclarationModeSimulationDataReader();
+					DataReader = new DeclarationModeVectoRunDataFactory();
 					break;
 				case FactoryMode.EngineeringMode:
-					DataReader = new EngineeringModeSimulationDataReader();
+					DataReader = new EngineeringModeVectoRunDataFactory();
 					break;
 				case FactoryMode.EngineOnlyMode:
-					DataReader = new EngineOnlySimulationDataReader();
+					DataReader = new EngineOnlyVectoRunDataFactory();
 					break;
 				default:
 					throw new VectoException("Unkown factory mode in SimulatorFactory: {0}", mode);
@@ -44,7 +45,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			DataReader.SetJobFile(jobFile);
 		}
 
-		public ISimulationDataReader DataReader { get; private set; }
+		public IVectoRunDataFactory DataReader { get; private set; }
 
 		public SummaryFileWriter SumWriter { get; set; }
 

VectoCore/Models/SimulationComponent/Data/Engine/FuelConsumptionMap.cs

@@ -18,9 +18,16 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Engine
 
 		public static FuelConsumptionMap ReadFromFile(string fileName)
 		{
-            var fuelConsumptionMap = new FuelConsumptionMap();
+			try {
 				var data = VectoCSVFile.Read(fileName);
+				return Create(data);
+			} catch (Exception e) {
+				throw new VectoException(string.Format("File {0}: {1}", fileName, e.Message), e);
+			}
+		}
 
+		public static FuelConsumptionMap Create(DataTable data)
+		{
 			var headerValid = HeaderIsValid(data.Columns);
 			if (!headerValid) {
 				Logger<FuelConsumptionMap>().Warn(
@@ -28,7 +35,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Engine
 					Fields.EngineSpeed, Fields.Torque, Fields.FuelConsumption,
 					string.Join(", ", data.Columns.Cast<DataColumn>().Select(c => c.ColumnName)));
 			}
-            try {
+
+			var fuelConsumptionMap = new FuelConsumptionMap();
+
 			foreach (DataRow row in data.Rows) {
 				try {
 					var entry = headerValid ? CreateFromColumNames(row) : CreateFromColumnIndizes(row);
@@ -47,9 +56,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Engine
 					throw new VectoException(string.Format("Line {0}: {1}", data.Rows.IndexOf(row), e.Message), e);
 				}
 			}
-            } catch (Exception e) {
-                throw new VectoException(string.Format("File {0}: {1}", fileName, e.Message), e);
-            }
 
 			fuelConsumptionMap._fuelMap.Triangulate();
 			return fuelConsumptionMap;

VectoCore/Models/SimulationComponent/Data/Engine/PT1Curve.cs

@@ -16,6 +16,16 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Engine
 			return new PT1Curve(fileName);
 		}
 
+		public static PT1Curve Create(DataTable data)
+		{
+			return new PT1Curve(data);
+		}
+
+		protected PT1Curve(DataTable data)
+		{
+			ParseData(data);
+		}
+
 		protected PT1Curve(string file)
 		{
 			ParseData(ReadCsvFile(file));

VectoCore/Models/SimulationComponent/Data/FullLoadCurve.cs

@@ -21,7 +21,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 		public static FullLoadCurve ReadFromFile(string fileName, bool declarationMode = false)
 		{
 			var data = VectoCSVFile.Read(fileName);
+			return Create(data, declarationMode);
+		}
 
+		public static FullLoadCurve Create(DataTable data, bool declarationMode = false)
+		{
 			if (data.Columns.Count < 3) {
 				throw new VectoException("FullLoadCurve Data File must consist of at least 3 columns.");
 			}
@@ -48,7 +52,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 			if (declarationMode) {
 				tmp = new PT1();
 			} else {
-				tmp = PT1Curve.ReadFromFile(fileName);
+				tmp = PT1Curve.Create(data);
 			}
 
 			return new FullLoadCurve { FullLoadEntries = entriesFld, PT1Data = tmp };

VectoCore/Models/SimulationComponent/Data/Gearbox/ShiftPolygon.cs

@@ -19,10 +19,15 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox
 			_downShiftPolygon = downshift;
 		}
 
+
 		public static ShiftPolygon ReadFromFile(string fileName)
 		{
 			var data = VectoCSVFile.Read(fileName);
+			return Create(data);
+		}
 
+		public static ShiftPolygon Create(DataTable data)
+		{
 			if (data.Columns.Count != 3) {
 				throw new VectoException("ShiftPolygon Data File must contain exactly 3 columns.");
 			}

VectoCore/Models/SimulationComponent/Data/RetarderLossMap.cs

@@ -10,11 +10,14 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 	{
 		private List<RetarderLossEntry> _entries;
 
-
 		public static RetarderLossMap ReadFromFile(string fileName)
 		{
 			var data = VectoCSVFile.Read(fileName);
+			return Create(data);
+		}
 
+		public static RetarderLossMap Create(DataTable data)
+		{
 			if (data.Columns.Count != 2) {
 				throw new VectoException("RetarderLossMap Data File must consist of 2 columns.");
 			}