refactorings for GearboxData

VectoCore/FileIO/Reader/DataObjectAdaper/AbstractSimulationDataAdapter.cs

@@ -71,7 +71,7 @@ namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
 			return new GearboxData() {
 				SavedInDeclarationMode = data.SavedInDeclarationMode,
 				ModelName = data.ModelName,
-				Type = (GearboxData.GearboxType)Enum.Parse(typeof(GearboxData.GearboxType), data.GearboxType, true),
+				Type = data.GearboxType.Parse<GearboxData.GearboxType>()
 			};
 		}
 

VectoCore/FileIO/Reader/DataObjectAdaper/DeclarationDataAdapter.cs

@@ -163,6 +163,11 @@ namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
 			if (retVal.Type == GearboxData.GearboxType.Custom) {
 				throw new VectoSimulationException("Custom Transmission not supported in DeclarationMode!");
 			}
+
+			if (gearbox.Body.Gears.Count < 2) {
+				throw new VectoSimulationException("At least two gears must be defined: 1 Axle-Gear and 1 Gearbox-Gear!");
+			}
+
 			retVal.Inertia = DeclarationData.Gearbox.Inertia.SI<KilogramSquareMeter>();
 			retVal.TractionInterruption = DeclarationData.Gearbox.TractionInterruption(retVal.Type);
 			retVal.SkipGears = DeclarationData.Gearbox.SkipGears(retVal.Type);
@@ -176,36 +181,35 @@ namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
 
 			retVal.HasTorqueConverter = false;
 
+			var axleGear = gearbox.Body.Gears.First();
+			var lossMap = TransmissionLossMap.ReadFromFile(Path.Combine(gearbox.BasePath, axleGear.LossMap), axleGear.Ratio);
+			retVal.AxleGearData = new GearData { LossMap = lossMap, Ratio = axleGear.Ratio, TorqueConverterActive = 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);
-				var lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
-
-
-				if (i == 0) {
-					retVal.AxleGearData = new GearData() {
-						LossMap = lossMap,
-						Ratio = gearSettings.Ratio,
-						TorqueConverterActive = false
-					};
+			retVal.Gears = gearbox.Body.Gears.Skip(1).Select((gear, i) => {
+				lossMap = TransmissionLossMap.ReadFromFile(Path.Combine(gearbox.BasePath, axleGear.LossMap), axleGear.Ratio);
+				EngineFullLoadCurve fullLoadCurve;
+				if (string.IsNullOrWhiteSpace(gear.FullLoadCurve) || gear.FullLoadCurve == "<NOFILE>") {
+					fullLoadCurve = engine.FullLoadCurve;
 				} else {
-					var fullLoad = !string.IsNullOrEmpty(gearSettings.FullLoadCurve) && !gearSettings.FullLoadCurve.Equals("<NOFILE>")
-						? GearFullLoadCurve.ReadFromFile(Path.Combine(gearbox.BasePath, gearSettings.FullLoadCurve))
-						: null;
-					var shiftPolygon = DeclarationData.Gearbox.ComputeShiftPolygon(fullLoad, engine);
-
-					retVal.Gears.Add(i, new GearData() {
-						LossMap = lossMap,
-						ShiftPolygon = shiftPolygon,
-						Ratio = gearSettings.Ratio,
-						TorqueConverterActive = false
-					});
+					var gearFullLoad = GearFullLoadCurve.ReadFromFile(Path.Combine(gearbox.BasePath, gear.FullLoadCurve));
+					fullLoadCurve = IntersectFullLoadCurves(gearFullLoad, engine.FullLoadCurve);
 				}
-			}
+
+				var shiftPolygon = DeclarationData.Gearbox.ComputeShiftPolygon(fullLoadCurve, engine.IdleSpeed);
+				return new KeyValuePair<uint, GearData>((uint)i,
+					new GearData { LossMap = lossMap, ShiftPolygon = shiftPolygon, Ratio = gear.Ratio, TorqueConverterActive = false });
+			}).ToDictionary(kv => kv.Key, kv => kv.Value);
 			return retVal;
 		}
 
+		private EngineFullLoadCurve IntersectFullLoadCurves(GearFullLoadCurve fullLoadCurve,
+			EngineFullLoadCurve engineFullLoadCurve)
+		{
+			//create new entries
+
+			throw new NotImplementedException();
+		}
+
 		public IEnumerable<VectoRunData.AuxData> CreateAuxiliaryData(IEnumerable<VectoRunData.AuxData> auxList,
 			MissionType mission, VehicleClass hvdClass)
 		{

VectoCore/Models/Declaration/DeclarationData.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using NLog.Targets.Wrappers;
 using TUGraz.VectoCore.Configuration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
 using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 using TUGraz.VectoCore.Utils;
@@ -224,21 +225,24 @@ namespace TUGraz.VectoCore.Models.Declaration
 				return false;
 			}
 
-			internal static ShiftPolygon ComputeShiftPolygon(GearFullLoadCurve gear, CombustionEngineData engine)
+			internal static ShiftPolygon ComputeShiftPolygon(EngineFullLoadCurve fullLoadCurve, PerSecond engineIdleSpeed)
 			{
 				// TODO: How to compute shift-polygons exactly? (merge with engine full load?)
-				var fullLoadCurve = engine.FullLoadCurve;
-				var idleSpeed = engine.IdleSpeed;
+				//var fullLoadCurve = engine.FullLoadCurve;
+				//var engineIdleSpeed = 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>() });
+				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() {
+					AngularSpeed = engineIdleSpeed,
+					Torque = 0.SI<NewtonMeter>()
+				});
 
-				var tq1 = maxTorque * idleSpeed / (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed - idleSpeed);
-				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = idleSpeed, Torque = tq1 });
+				var tq1 = maxTorque * engineIdleSpeed / (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed - engineIdleSpeed);
+				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = engineIdleSpeed, Torque = tq1 });
 
 				var speed1 = (fullLoadCurve.PreferredSpeed + fullLoadCurve.LoSpeed) / 2;
 				entriesDown.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = speed1, Torque = maxTorque });
@@ -249,7 +253,7 @@ namespace TUGraz.VectoCore.Models.Declaration
 					Torque = 0.SI<NewtonMeter>()
 				});
 
-				tq1 = maxTorque * (fullLoadCurve.PreferredSpeed - idleSpeed) / (fullLoadCurve.N95hSpeed - idleSpeed);
+				tq1 = maxTorque * (fullLoadCurve.PreferredSpeed - engineIdleSpeed) / (fullLoadCurve.N95hSpeed - engineIdleSpeed);
 				entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.PreferredSpeed, Torque = tq1 });
 
 				entriesUp.Add(new ShiftPolygon.ShiftPolygonEntry() { AngularSpeed = fullLoadCurve.N95hSpeed, Torque = maxTorque });

VectoCore/Models/SimulationComponent/Data/GearboxData.cs

@@ -26,7 +26,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 
 		public GearData AxleGearData { get; internal set; }
 
-		public readonly Dictionary<uint, GearData> Gears = new Dictionary<uint, GearData>();
+		public Dictionary<uint, GearData> Gears = new Dictionary<uint, GearData>();
 
 		public GearboxType Type { get; internal set; }
 

VectoCoreTest/Models/SimulationComponent/GearboxTest.cs

@@ -55,6 +55,12 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			return ((60 * v) / (2 * r * Math.PI / 1000)).RPMtoRad();
 		}
 
+		[TestMethod]
+		public void Gearbox_IntersectFullLoadCurves()
+		{
+			Assert.Inconclusive("Test if the intersection of two fullloadcurves is correct");
+		}
+
 		[TestMethod]
 		public void Gearbox_Request()
 		{