cleaned up files,

implemented DataAdapter for Conventional Heavy Lorry

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/AbstractSimulationDataAdapter.cs

@@ -48,39 +48,20 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 	public abstract class AbstractSimulationDataAdapter : LoggingObject
 	{
 		// =========================
-
-		internal VehicleData SetCommonVehicleData(IVehicleDeclarationInputData data)
-		{
-			var retVal = new VehicleData {
-				InputData = data,
-				SavedInDeclarationMode = data.SavedInDeclarationMode,
-				Manufacturer = data.Manufacturer,
-				ModelName = data.Model,
-				Date = data.Date,
-				//CertificationNumber = data.CertificationNumber,
-				DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
-				VehicleCategory = data.VehicleCategory,
-				CurbMass = data.CurbMassChassis,
-				GrossVehicleMass = data.GrossVehicleMassRating,
-				AirDensity = Physics.AirDensity,
-			};
-
-			return retVal;
-		}
-
 		protected VehicleData.ADASData CreateADAS(IAdvancedDriverAssistantSystemDeclarationInputData adas)
 		{
-			return new VehicleData.ADASData {
+			return new VehicleData.ADASData
+			{
 				EngineStopStart = adas.EngineStopStart,
 				EcoRoll = adas.EcoRoll,
 				PredictiveCruiseControl = adas.PredictiveCruiseControl,
 				InputData = adas
 			};
 		}
-
 		internal AirdragData SetCommonAirdragData(IAirdragDeclarationInputData data)
 		{
-			var retVal = new AirdragData() {
+			var retVal = new AirdragData()
+			{
 				SavedInDeclarationMode = data.SavedInDeclarationMode,
 				Manufacturer = data.Manufacturer,
 				ModelName = data.Model,
@@ -91,61 +72,10 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			};
 			return retVal;
 		}
-
-		internal RetarderData SetCommonRetarderData(IRetarderInputData retarderInputData, 
-			PowertrainPosition position = PowertrainPosition.HybridPositionNotSet)
-		{
-			try {
-				var retarder = new RetarderData { Type = retarderInputData.Type };
-
-				switch (retarder.Type) {
-					case RetarderType.TransmissionInputRetarder:
-					case RetarderType.TransmissionOutputRetarder:
-						if (!(position.IsParallelHybrid() || position.IsOneOf(PowertrainPosition.HybridPositionNotSet, PowertrainPosition.BatteryElectricE2))) {
-							throw new ArgumentException("Transmission retarder is only allowed in powertrains that " +
-														"contain a gearbox: Conventional, HEV-P, and PEV-E2.", nameof(retarder));
-						}
-
-						retarder.LossMap = RetarderLossMapReader.Create(retarderInputData.LossMap);
-						retarder.Ratio = retarderInputData.Ratio;
-						break;
-					
-					case RetarderType.AxlegearInputRetarder:
-						if (position != PowertrainPosition.BatteryElectricE3)
-							throw new ArgumentException("AxlegearInputRetarder is only allowed for PEV-E3, HEV-S3, S-IEPC, E-IEPC. ", nameof(retarder));
-						retarder.LossMap = RetarderLossMapReader.Create(retarderInputData.LossMap);
-						retarder.Ratio = retarderInputData.Ratio;
-						break;
-					
-					case RetarderType.None:
-					case RetarderType.LossesIncludedInTransmission:
-					case RetarderType.EngineRetarder:
-						retarder.Ratio = 1;
-						break;
-					
-					default:
-						throw new ArgumentOutOfRangeException(nameof(retarder), retarder.Type, "RetarderType unknown");
-				}
-
-				if (retarder.Type.IsDedicatedComponent()) {
-					retarder.SavedInDeclarationMode = retarderInputData.SavedInDeclarationMode;
-					retarder.Manufacturer = retarderInputData.Manufacturer;
-					retarder.ModelName = retarderInputData.Model;
-					retarder.Date = retarderInputData.Date;
-					retarder.CertificationMethod = retarderInputData.CertificationMethod;
-					retarder.CertificationNumber = retarderInputData.CertificationNumber;
-					retarder.DigestValueInput = retarderInputData.DigestValue != null ? retarderInputData.DigestValue.DigestValue : "";
-				}
-
-				return retarder;
-			} catch (Exception e) {
-				throw new VectoException("Error while Reading Retarder Data: {0}", e.Message);
-			}
-		}
-
 		internal CombustionEngineData SetCommonCombustionEngineData(IEngineDeclarationInputData data, TankSystem? tankSystem)
 		{
-			var retVal = new CombustionEngineData {
+			var retVal = new CombustionEngineData
+			{
 				InputData = data,
 				SavedInDeclarationMode = data.SavedInDeclarationMode,
 				Manufacturer = data.Manufacturer,
@@ -166,71 +96,36 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			};
 			return retVal;
 		}
-
-		internal static GearboxData SetCommonGearboxData(IGearboxDeclarationInputData data)
-		{
-			return new GearboxData {
-				InputData = data,
-				SavedInDeclarationMode = data.SavedInDeclarationMode,
-				Manufacturer = data.Manufacturer,
-				ModelName = data.Model,
-				Date = data.Date,
-				CertificationMethod = data.CertificationMethod,
-				CertificationNumber = data.CertificationMethod != CertificationMethod.StandardValues ? 
-					data.CertificationNumber : "",
-				DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
-				Type = data.Type
-			};
-		}
-
 		protected virtual TransmissionLossMap CreateGearLossMap(ITransmissionInputData gear, uint i,
 			bool useEfficiencyFallback, VehicleCategory vehicleCategory, GearboxType gearboxType)
 		{
-			if (gear.LossMap != null) {
+			if (gear.LossMap != null)
+			{
 				return TransmissionLossMapReader.Create(gear.LossMap, gear.Ratio, $"Gear {i + 1}", true);
 			}
-			if (useEfficiencyFallback) {
+			if (useEfficiencyFallback)
+			{
 				return TransmissionLossMapReader.Create(gear.Efficiency, gear.Ratio, $"Gear {i + 1}");
 			}
 			throw new InvalidFileFormatException("Gear {0} LossMap missing.", i + 1);
 		}
-
-		protected static void CreateTCSecondGearATSerial(GearData gearData,
-			ShiftPolygon shiftPolygon)
+		internal TransmissionLossMap ReadAxleLossMap(IAxleGearInputData data, bool useEfficiencyFallback)
 		{
-			gearData.TorqueConverterRatio = gearData.Ratio;
-			gearData.TorqueConverterGearLossMap = gearData.LossMap;
-			gearData.TorqueConverterShiftPolygon = shiftPolygon;
-		}
-
-		protected static void CreateTCFirstGearATSerial(GearData gearData,
-			ShiftPolygon shiftPolygon)
+			TransmissionLossMap axleLossMap;
+			if (data.LossMap == null && useEfficiencyFallback)
 			{
-			gearData.TorqueConverterRatio = gearData.Ratio;
-			gearData.TorqueConverterGearLossMap = gearData.LossMap;
-			gearData.TorqueConverterShiftPolygon = shiftPolygon;
+				axleLossMap = TransmissionLossMapReader.Create(data.Efficiency, data.Ratio, "Axlegear");
 			}
-
-		protected virtual void CretateTCFirstGearATPowerSplit(GearData gearData, uint i, ShiftPolygon shiftPolygon)
+			else
 			{
-			gearData.TorqueConverterRatio = 1;
-			gearData.TorqueConverterGearLossMap = TransmissionLossMapReader.Create(1, 1, $"TCGear {i + 1}");
-			gearData.TorqueConverterShiftPolygon = shiftPolygon;
-		}
-
-		
-		internal TransmissionLossMap ReadAxleLossMap(IAxleGearInputData data, bool useEfficiencyFallback)
+				if (data.LossMap == null)
 				{
-			TransmissionLossMap axleLossMap;
-			if (data.LossMap == null && useEfficiencyFallback) {
-				axleLossMap = TransmissionLossMapReader.Create(data.Efficiency, data.Ratio, "Axlegear");
-			} else {
-				if (data.LossMap == null) {
 					throw new InvalidFileFormatException("LossMap for Axlegear is missing.");
 				}
 				axleLossMap = TransmissionLossMapReader.Create(data.LossMap, data.Ratio, "Axlegear", true);
 			}
-			if (axleLossMap == null) {
+			if (axleLossMap == null)
+			{
 				throw new InvalidFileFormatException("LossMap for Axlegear is missing.");
 			}
 			return axleLossMap;
@@ -238,7 +133,8 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 		internal AxleGearData SetCommonAxleGearData(IAxleGearInputData data)
 		{
-			return new AxleGearData {
+			return new AxleGearData
+			{
 				InputData = data,
 				SavedInDeclarationMode = data.SavedInDeclarationMode,
 				Manufacturer = data.Manufacturer,
@@ -252,56 +148,6 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			};
 		}
 
-		/// <summary>
-		/// Creates an AngledriveData or returns null if there is no anglegear.
-		/// </summary>
-		/// <param name="data"></param>
-		/// <param name="useEfficiencyFallback">if true, the Efficiency value is used if no LossMap is found.</param>
-		/// <returns></returns>
-		internal AngledriveData DoCreateAngledriveData(IAngledriveInputData data, bool useEfficiencyFallback)
-		{
-			try {
-				var type = data?.Type ?? AngledriveType.None;
-
-				switch (type) {
-					case AngledriveType.LossesIncludedInGearbox:
-					case AngledriveType.None:
-						return null;
-					case AngledriveType.SeparateAngledrive:
-						var angledriveData = new AngledriveData {
-							InputData = data,
-							SavedInDeclarationMode = data.SavedInDeclarationMode,
-							Manufacturer = data.Manufacturer,
-							ModelName = data.Model,
-							Date = data.Date,
-							CertificationMethod = data.CertificationMethod,
-							CertificationNumber = data.CertificationNumber,
-							DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
-							Type = type,
-							Angledrive = new TransmissionData { Ratio = data.Ratio }
-						};
-						try {
-							angledriveData.Angledrive.LossMap = TransmissionLossMapReader.Create(data.LossMap,
-								data.Ratio, "Angledrive", true);
-						} catch (VectoException ex) {
-							Log.Info("Angledrive Loss Map not found.");
-							if (useEfficiencyFallback) {
-								Log.Info("Angledrive Trying with Efficiency instead of Loss Map.");
-								angledriveData.Angledrive.LossMap = TransmissionLossMapReader.Create(data.Efficiency,
-									data.Ratio, "Angledrive");
-							} else {
-								throw new VectoException("Angledrive: LossMap not found.", ex);
-							}
-						}
-						return angledriveData;
-					default:
-						throw new ArgumentOutOfRangeException(nameof(data), "Unknown Angledrive Type.");
-				}
-			} catch (Exception e) {
-				throw new VectoException("Error while reading Angledrive data: {0}", e.Message, e);
-			}
-		}
-
 		internal static ElectricMotorFullLoadCurve IntersectEMFullLoadCurves(ElectricMotorFullLoadCurve fullLoadCurve,
 			ElectricMotorFullLoadCurve maxTorqueCurve)
 		{
@@ -310,31 +156,38 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				return fullLoadCurve;
 			}
 
-			if (maxTorqueCurve.MaxSpeed.IsSmaller(fullLoadCurve.MaxSpeed)) {
+			if (maxTorqueCurve.MaxSpeed.IsSmaller(fullLoadCurve.MaxSpeed))
+			{
 				throw new VectoException("EM Torque limitation has to cover the whole speed range");
 			}
 
 			var motorSpeeds = fullLoadCurve.FullLoadEntries.Select(x => x.MotorSpeed)
 				.Concat(maxTorqueCurve.FullLoadEntries.Select(x => x.MotorSpeed)).ToList();
 			// iterate over all segments in the full-load curve
-			foreach (var fldTuple in fullLoadCurve.FullLoadEntries.Pairwise()) {
+			foreach (var fldTuple in fullLoadCurve.FullLoadEntries.Pairwise())
+			{
 				// find all grid points of max torque curve within the current segment of fld
 				var maxPtsWithinSegment = maxTorqueCurve.FullLoadEntries.Where(x =>
 					x.MotorSpeed.IsGreaterOrEqual(fldTuple.Item1.MotorSpeed) &&
 					x.MotorSpeed.IsSmallerOrEqual(fldTuple.Item2.MotorSpeed)).OrderBy(x => x.MotorSpeed).ToList();
-				if (maxPtsWithinSegment.Count == 0) {
+				if (maxPtsWithinSegment.Count == 0)
+				{
 					// if grid pint is within, take the 'surrounding' segment
 					var segment =
 						maxTorqueCurve.FullLoadEntries.GetSection(x => x.MotorSpeed < fldTuple.Item1.MotorSpeed);
 					maxPtsWithinSegment = new[] { segment.Item1, segment.Item2 }.ToList();
-				} else {
+				}
+				else
+				{
 					// add the point just before and just after the current list of points 
-					if (maxPtsWithinSegment.Min(x => x.MotorSpeed).IsGreater(fldTuple.Item1.MotorSpeed)) {
+					if (maxPtsWithinSegment.Min(x => x.MotorSpeed).IsGreater(fldTuple.Item1.MotorSpeed))
+					{
 						maxPtsWithinSegment.Add(maxTorqueCurve.FullLoadEntries.Last(x =>
 							x.MotorSpeed.IsSmaller(fldTuple.Item1.MotorSpeed)));
 					}
 
-					if (maxPtsWithinSegment.Max(x => x.MotorSpeed).IsSmaller(fldTuple.Item2.MotorSpeed)) {
+					if (maxPtsWithinSegment.Max(x => x.MotorSpeed).IsSmaller(fldTuple.Item2.MotorSpeed))
+					{
 						maxPtsWithinSegment.Add(maxTorqueCurve.FullLoadEntries.First(x => x.MotorSpeed.IsGreater(fldTuple.Item2.MotorSpeed)));
 					}
 
@@ -347,16 +200,19 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				var fldEdgeGenerate =
 					Edge.Create(new Point(fldTuple.Item1.MotorSpeed.Value(), fldTuple.Item1.FullGenerationTorque.Value()),
 						new Point(fldTuple.Item2.MotorSpeed.Value(), fldTuple.Item2.FullGenerationTorque.Value()));
-				foreach (var maxTuple in maxPtsWithinSegment.Pairwise()) {
+				foreach (var maxTuple in maxPtsWithinSegment.Pairwise())
+				{
 					var maxEdgeDrive =
 						Edge.Create(new Point(maxTuple.Item1.MotorSpeed.Value(), maxTuple.Item1.FullDriveTorque.Value()),
 							new Point(maxTuple.Item2.MotorSpeed.Value(), maxTuple.Item2.FullDriveTorque.Value()));
-					if (!(maxEdgeDrive.SlopeXY - fldEdgeDrive.SlopeXY).IsEqual(0, 1e-12)) {
+					if (!(maxEdgeDrive.SlopeXY - fldEdgeDrive.SlopeXY).IsEqual(0, 1e-12))
+					{
 						// lines are not parallel
 						var nIntersectDrive =
 							((fldEdgeDrive.OffsetXY - maxEdgeDrive.OffsetXY) /
 							(maxEdgeDrive.SlopeXY - fldEdgeDrive.SlopeXY)).SI<PerSecond>();
-						if (nIntersectDrive.IsBetween(fldTuple.Item1.MotorSpeed, fldTuple.Item2.MotorSpeed)) {
+						if (nIntersectDrive.IsBetween(fldTuple.Item1.MotorSpeed, fldTuple.Item2.MotorSpeed))
+						{
 							motorSpeeds.Add(nIntersectDrive);
 						}
 					}
@@ -364,14 +220,16 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 					var maxEdgeGenerate =
 						Edge.Create(new Point(maxTuple.Item1.MotorSpeed.Value(), maxTuple.Item1.FullGenerationTorque.Value()),
 							new Point(maxTuple.Item2.MotorSpeed.Value(), maxTuple.Item2.FullGenerationTorque.Value()));
-					if (!((maxEdgeGenerate.SlopeXY - fldEdgeGenerate.SlopeXY).IsEqual(0, 1e-12))) {
+					if (!((maxEdgeGenerate.SlopeXY - fldEdgeGenerate.SlopeXY).IsEqual(0, 1e-12)))
+					{
 						// lines are not parallel
 						var nIntersectGenerate =
 							((fldEdgeGenerate.OffsetXY - maxEdgeGenerate.OffsetXY) /
 							(maxEdgeGenerate.SlopeXY - fldEdgeGenerate.SlopeXY)).SI<PerSecond>();
 
 
-						if (nIntersectGenerate.IsBetween(fldTuple.Item1.MotorSpeed, fldTuple.Item2.MotorSpeed)) {
+						if (nIntersectGenerate.IsBetween(fldTuple.Item1.MotorSpeed, fldTuple.Item2.MotorSpeed))
+						{
 							motorSpeeds.Add(nIntersectGenerate);
 						}
 					}
@@ -380,7 +238,8 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 			// create new full-load curve with values closest to zero.
 			return new ElectricMotorFullLoadCurve(motorSpeeds.OrderBy(x => x.Value()).Distinct().Select(x =>
-				new ElectricMotorFullLoadCurve.FullLoadEntry() {
+				new ElectricMotorFullLoadCurve.FullLoadEntry()
+				{
 					MotorSpeed = x,
 					FullDriveTorque = VectoMath.Max(fullLoadCurve.FullLoadDriveTorque(x),
 						maxTorqueCurve.FullLoadDriveTorque(x)),
@@ -388,11 +247,6 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 						maxTorqueCurve.FullGenerationTorque(x)),
 				}).ToList());
 		}
-
-		
-
-
-
 		/// <summary>
 		/// Intersects ICE full load curves.
 		/// </summary>
@@ -401,33 +255,45 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 		/// <returns>A combined EngineFullLoadCurve with the minimum full load torque over all inputs curves.</returns>
 		internal static EngineFullLoadCurve IntersectFullLoadCurves(EngineFullLoadCurve engineCurve, NewtonMeter maxTorque)
 		{
-			if (maxTorque == null) {
+			if (maxTorque == null)
+			{
 				return engineCurve;
 			}
 
 			var entries = new List<EngineFullLoadCurve.FullLoadCurveEntry>();
 			var firstEntry = engineCurve.FullLoadEntries.First();
-			if (firstEntry.TorqueFullLoad < maxTorque) {
+			if (firstEntry.TorqueFullLoad < maxTorque)
+			{
 				entries.Add(engineCurve.FullLoadEntries.First());
-			} else {
-				entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry {
+			}
+			else
+			{
+				entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry
+				{
 					EngineSpeed = firstEntry.EngineSpeed,
 					TorqueFullLoad = maxTorque,
 					TorqueDrag = firstEntry.TorqueDrag
 				});
 			}
-			foreach (var entry in engineCurve.FullLoadEntries.Pairwise(Tuple.Create)) {
-				if (entry.Item1.TorqueFullLoad <= maxTorque && entry.Item2.TorqueFullLoad <= maxTorque) {
+			foreach (var entry in engineCurve.FullLoadEntries.Pairwise(Tuple.Create))
+			{
+				if (entry.Item1.TorqueFullLoad <= maxTorque && entry.Item2.TorqueFullLoad <= maxTorque)
+				{
 					// segment is below maxTorque line -> use directly
 					entries.Add(entry.Item2);
-				} else if (entry.Item1.TorqueFullLoad > maxTorque && entry.Item2.TorqueFullLoad > maxTorque) {
+				}
+				else if (entry.Item1.TorqueFullLoad > maxTorque && entry.Item2.TorqueFullLoad > maxTorque)
+				{
 					// segment is above maxTorque line -> add limited entry
-					entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry {
+					entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry
+					{
 						EngineSpeed = entry.Item2.EngineSpeed,
 						TorqueFullLoad = maxTorque,
 						TorqueDrag = entry.Item2.TorqueDrag
 					});
-				} else {
+				}
+				else
+				{
 					// segment intersects maxTorque line -> add new entry at intersection
 					var edgeFull = Edge.Create(
 						new Point(entry.Item1.EngineSpeed.Value(), entry.Item1.TorqueFullLoad.Value()),
@@ -436,15 +302,18 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 						new Point(entry.Item1.EngineSpeed.Value(), entry.Item1.TorqueDrag.Value()),
 						new Point(entry.Item2.EngineSpeed.Value(), entry.Item2.TorqueDrag.Value()));
 					var intersectionX = (maxTorque.Value() - edgeFull.OffsetXY) / edgeFull.SlopeXY;
-                    if (!entries.Any(x => x.EngineSpeed.IsEqual(intersectionX)) && !intersectionX.IsEqual(entry.Item2.EngineSpeed.Value())) {
-                        entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry {
+					if (!entries.Any(x => x.EngineSpeed.IsEqual(intersectionX)) && !intersectionX.IsEqual(entry.Item2.EngineSpeed.Value()))
+					{
+						entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry
+						{
 							EngineSpeed = intersectionX.SI<PerSecond>(),
 							TorqueFullLoad = maxTorque,
 							TorqueDrag = VectoMath.Interpolate(edgeDrag.P1, edgeDrag.P2, intersectionX).SI<NewtonMeter>()
 						});
 					}
 
-                    entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry {
+					entries.Add(new EngineFullLoadCurve.FullLoadCurveEntry
+					{
 						EngineSpeed = entry.Item2.EngineSpeed,
 						TorqueFullLoad = entry.Item2.TorqueFullLoad > maxTorque ? maxTorque : entry.Item2.TorqueFullLoad,
 						TorqueDrag = entry.Item2.TorqueDrag
@@ -452,70 +321,12 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				}
 			}
 
-			var flc = new EngineFullLoadCurve(entries.ToList(), engineCurve.PT1Data) {
+			var flc = new EngineFullLoadCurve(entries.ToList(), engineCurve.PT1Data)
+			{
 				EngineData = engineCurve.EngineData,
 			};
 			return flc;
 		}
-
-
-		/// <summary>
-		/// Intersects max torque curve.
-		/// </summary>
-		/// <param name="maxTorqueEntries"></param>
-		/// <param name="maxTorque"></param>
-		/// <returns>A combined EngineFullLoadCurve with the minimum full load torque over all inputs curves.</returns>
-		internal static IList<VehicleMaxPropulsionTorque.FullLoadEntry> IntersectMaxPropulsionTorqueCurve(IList<VehicleMaxPropulsionTorque.FullLoadEntry> maxTorqueEntries, NewtonMeter maxTorque)
-		{
-			if (maxTorque == null) {
-				return maxTorqueEntries;
-			}
-
-			var entries = new List<VehicleMaxPropulsionTorque.FullLoadEntry>();
-			var firstEntry = maxTorqueEntries.First();
-			if (firstEntry.FullDriveTorque < maxTorque) {
-				entries.Add(maxTorqueEntries.First());
-			} else {
-				entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry {
-					MotorSpeed = firstEntry.MotorSpeed,
-					FullDriveTorque = maxTorque,
-				});
-			}
-			foreach (var entry in maxTorqueEntries.Pairwise(Tuple.Create)) {
-				if (entry.Item1.FullDriveTorque <= maxTorque && entry.Item2.FullDriveTorque <= maxTorque) {
-					// segment is below maxTorque line -> use directly
-					entries.Add(entry.Item2);
-				} else if (entry.Item1.FullDriveTorque > maxTorque && entry.Item2.FullDriveTorque > maxTorque) {
-					// segment is above maxTorque line -> add limited entry
-					entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry {
-						MotorSpeed = entry.Item2.MotorSpeed,
-						FullDriveTorque = maxTorque,
-					});
-				} else {
-					// segment intersects maxTorque line -> add new entry at intersection
-					var edgeFull = Edge.Create(
-						new Point(entry.Item1.MotorSpeed.Value(), entry.Item1.FullDriveTorque.Value()),
-						new Point(entry.Item2.MotorSpeed.Value(), entry.Item2.FullDriveTorque.Value()));
-					
-					var intersectionX = (maxTorque.Value() - edgeFull.OffsetXY) / edgeFull.SlopeXY;
-					if (!entries.Any(x => x.MotorSpeed.IsEqual(intersectionX)) && !intersectionX.IsEqual(entry.Item2.MotorSpeed.Value())) {
-						entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry {
-							MotorSpeed = intersectionX.SI<PerSecond>(),
-							FullDriveTorque = maxTorque,
-						});
-					}
-
-					entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry {
-						MotorSpeed = entry.Item2.MotorSpeed,
-						FullDriveTorque = entry.Item2.FullDriveTorque > maxTorque ? maxTorque : entry.Item2.FullDriveTorque,
-						
-					});
-				}
-			}
-
-			
-			return entries;
-		}
 	}
 }
 

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/CompletedBus/Generic/DeclarationDataAdapterGenericCompletedBus.cs

@@ -15,6 +15,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.CompletedBus.Gener
 	{
 		public abstract class CompletedBusBase : IGenericCompletedBusDataAdapter
 		{
+			private readonly IRetarderDataAdapter _retarderDataAdapter = new GenericRetarderDataAdapter();
             #region Implementation of IDeclarationDataAdapter
 
 			private readonly IDriverDataAdapter _driverDataAdapter = new CompletedBusGenericDriverDataAdapter();
@@ -63,7 +64,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.CompletedBus.Gener
 
             public RetarderData CreateRetarderData(IRetarderInputData retarderData)
 			{
-                throw new NotImplementedException();
+				return _retarderDataAdapter.CreateRetarderData(retarderData);
 			}
 
             public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapterCompletedBusGeneric.cs

@@ -58,18 +58,18 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 		#region Overrides of DeclarationDataAdapterHeavyLorry
 
-		public override AxleGearData CreateAxleGearData(IAxleGearInputData axlegearData)
+		public AxleGearData CreateAxleGearData(IAxleGearInputData axlegearData)
 		{
 			return _genericPowertrainData.CreateGenericBusAxlegearData(axlegearData);
 		}
 
-		public override AngledriveData CreateAngledriveData(IAngledriveInputData data)
+		public AngledriveData CreateAngledriveData(IAngledriveInputData data)
 		{
 			return _genericPowertrainData.CreateGenericBusAngledriveData(data);
 		}
 
 
-		public override RetarderData CreateRetarderData(IRetarderInputData retarder)
+		public RetarderData CreateRetarderData(IRetarderInputData retarder)
 		{
 			return _genericRetarderData.CreateGenericBusRetarderData(retarder);
 		}
@@ -87,7 +87,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				gear.Ratio.IsEqual(1) ? GearEfficiencyDirectGear : GearEfficiencyIndirectGear, gear.Ratio, $"Gear {i + 1}");
 		}
 
-		protected override void CretateTCFirstGearATPowerSplit(GearData gearData, uint i, ShiftPolygon shiftPolygon)
+		protected void CretateTCFirstGearATPowerSplit(GearData gearData, uint i, ShiftPolygon shiftPolygon)
 		{
 			gearData.TorqueConverterRatio = 1;
 			//gearData.TorqueConverterGearLossMap = TransmissionLossMapReader.Create(GearEfficiencyIndirectGear, 1, string.Format("TCGear {0}", i + 1));
@@ -102,6 +102,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 		protected override TorqueConverterData CreateTorqueConverterData(GearboxType gearboxType,
 			ITorqueConverterDeclarationInputData torqueConverter, double ratio, CombustionEngineData engineData)
 		{
+			
 			if (torqueConverter != null && torqueConverter.TCData != null) {
 				return TorqueConverterDataReader.Create(
 					torqueConverter.TCData,

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapterNinjectModule.cs

 using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.CompletedBus.Generic;
 using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.CompletedBus.Specific;
 using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.PrimaryBus;
-using TUGraz.VectoCore.InputData.Reader.Impl;
 using TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.CompletedBusRunDataFactory;
 using TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.HeavyLorryRunDataFactory;
 using TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDataFactory;
@@ -56,6 +55,9 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 			Bind<IDeclarationDataAdapter>().To<HeavyLorry.DeclarationDataAdapterHeavyLorry.PEV_E_IEPC>()
 				.WhenInjectedExactlyInto<DeclarationModeHeavyLorryRunDataFactory.PEV_E_IEPC>();
+
+			Bind<IDeclarationDataAdapter>().To<HeavyLorry.DeclarationDataAdapterHeavyLorry.Exempted>()
+				.WhenInjectedExactlyInto<DeclarationModeHeavyLorryRunDataFactory.Exempted>();
 			#endregion HeavyLorry
 
 			#region PrimaryBus
@@ -102,6 +104,9 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			Bind<IDeclarationDataAdapter>().To<DeclarationDataAdapterPrimaryBus.PEV_E_IEPC>()
 				.WhenInjectedExactlyInto<DeclarationModePrimaryBusRunDataFactory.PEV_E_IEPC>();
 
+			Bind<IDeclarationDataAdapter>().To<DeclarationDataAdapterPrimaryBus.Exempted>()
+				.WhenInjectedExactlyInto<DeclarationModePrimaryBusRunDataFactory.Exempted>();
+
 			#endregion
 
 			#region CompletedBus Generic

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapterSingleBus.cs

@@ -25,97 +25,98 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 	{
 		#region Implementation of IDeclarationDataAdapter
 
-		public override VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
-		{
-			var busFloorArea = DeclarationData.BusAuxiliaries.CalculateBusFloorSurfaceArea(
-				CompletedVehicle.Length,
-				CompletedVehicle.Width);
-			var passengerCountRef = busFloorArea * (loading.Key == LoadingType.LowLoading
-				? mission.BusParameter.PassengerDensityLow
-				: mission.BusParameter.PassengerDensityRef);
-			var passengerCountDecl = CompletedVehicle.NumberPassengerSeatsUpperDeck +
-									CompletedVehicle.NumberPassengerSeatsLowerDeck
-									+ (mission.MissionType == MissionType.Coach
-										? 0
-										: CompletedVehicle.NumberPassengersStandingLowerDeck +
-										CompletedVehicle.NumberPassengersStandingUpperDeck);
-
-			//var refLoad = passengerCount * mission.MissionType.GetAveragePassengerMass();
-			if (loading.Key != LoadingType.ReferenceLoad && loading.Key != LoadingType.LowLoading) {
-				throw new VectoException("Unhandled loading type: {0}", loading.Key);
-			}
-
-			var passengerCountCalc = loading.Key == LoadingType.ReferenceLoad
-				? VectoMath.Min(passengerCountRef, (int)passengerCountDecl)
-				: passengerCountRef * mission.MissionType.GetLowLoadFactorBus();
-			var payload = passengerCountCalc * mission.MissionType.GetAveragePassengerMass();
-
-			var retVal = CreateNonExemptedVehicleData(vehicle, segment, mission, payload, passengerCountCalc, allowVocational);
-			retVal.CurbMass = CompletedVehicle.CurbMassChassis;
-			return retVal;
-		}
+		//public override VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
+		//{
+		//	var busFloorArea = DeclarationData.BusAuxiliaries.CalculateBusFloorSurfaceArea(
+		//		CompletedVehicle.Length,
+		//		CompletedVehicle.Width);
+		//	var passengerCountRef = busFloorArea * (loading.Key == LoadingType.LowLoading
+		//		? mission.BusParameter.PassengerDensityLow
+		//		: mission.BusParameter.PassengerDensityRef);
+		//	var passengerCountDecl = CompletedVehicle.NumberPassengerSeatsUpperDeck +
+		//							CompletedVehicle.NumberPassengerSeatsLowerDeck
+		//							+ (mission.MissionType == MissionType.Coach
+		//								? 0
+		//								: CompletedVehicle.NumberPassengersStandingLowerDeck +
+		//								CompletedVehicle.NumberPassengersStandingUpperDeck);
+
+		//	//var refLoad = passengerCount * mission.MissionType.GetAveragePassengerMass();
+		//	if (loading.Key != LoadingType.ReferenceLoad && loading.Key != LoadingType.LowLoading) {
+		//		throw new VectoException("Unhandled loading type: {0}", loading.Key);
+		//	}
+
+		//	var passengerCountCalc = loading.Key == LoadingType.ReferenceLoad
+		//		? VectoMath.Min(passengerCountRef, (int)passengerCountDecl)
+		//		: passengerCountRef * mission.MissionType.GetLowLoadFactorBus();
+		//	var payload = passengerCountCalc * mission.MissionType.GetAveragePassengerMass();
+
+		//	var retVal = CreateNonExemptedVehicleData(vehicle, segment, mission, payload, passengerCountCalc, allowVocational);
+		//	retVal.CurbMass = CompletedVehicle.CurbMassChassis;
+		//	return retVal;
+		//}
 
 		#endregion
 
 
-		public override CombustionEngineData CreateEngineData(
-			IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData mode, Mission mission)
-		{
-			var engine = vehicle.Components.EngineInputData;
-			var gearbox = vehicle.Components.GearboxInputData;
-
-			if (!engine.SavedInDeclarationMode) {
-				WarnDeclarationMode("EngineData");
-			}
-
-			var retVal = SetCommonCombustionEngineData(engine, SingleBusInputData.CompletedVehicle.TankSystem);
-			retVal.IdleSpeed = VectoMath.Max(mode.IdleSpeed, vehicle.EngineIdleSpeed);
-
-			retVal.Fuels = new List<CombustionEngineFuelData>();
-			foreach (var fuel in mode.Fuels) {
-				retVal.Fuels.Add(
-					new CombustionEngineFuelData() {
-						WHTCUrban = fuel.WHTCUrban,
-						WHTCRural = fuel.WHTCRural,
-						WHTCMotorway = fuel.WHTCMotorway,
-						ColdHotCorrectionFactor = fuel.ColdHotBalancingFactor,
-						CorrectionFactorRegPer = fuel.CorrectionFactorRegPer,
-						FuelData = DeclarationData.FuelData.Lookup(fuel.FuelType, SingleBusInputData.CompletedVehicle.TankSystem),
-						ConsumptionMap = FuelConsumptionMapReader.Create(fuel.FuelConsumptionMap),
-						FuelConsumptionCorrectionFactor = DeclarationData.WHTCCorrection.Lookup(
-															mission.MissionType.GetNonEMSMissionType(), fuel.WHTCRural, fuel.WHTCUrban,
-															fuel.WHTCMotorway) * fuel.ColdHotBalancingFactor * fuel.CorrectionFactorRegPer,
-					});
-			}
-
-			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox.Type);
-			retVal.EngineStartTime = DeclarationData.Engine.DefaultEngineStartTime;
-			var limits = vehicle.TorqueLimits.ToDictionary(e => e.Gear);
-			var numGears = gearbox.Gears.Count;
-			var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
-			fullLoadCurves[0] = FullLoadCurveReader.Create(mode.FullLoadCurve, true);
-			fullLoadCurves[0].EngineData = retVal;
-			foreach (var gear in gearbox.Gears) {
-				var maxTorque = VectoMath.Min(
-					GbxMaxTorque(gear, numGears, fullLoadCurves[0].MaxTorque),
-					VehMaxTorque(gear, numGears, limits, fullLoadCurves[0].MaxTorque));
-				fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
-			}
-
-			retVal.FullLoadCurves = fullLoadCurves;
-
-			retVal.WHRType = engine.WHRType;
-			if ((retVal.WHRType & WHRType.ElectricalOutput) != 0) {
-				retVal.ElectricalWHR = CreateWHRData(
-					mode.WasteHeatRecoveryDataElectrical, mission.MissionType, WHRType.ElectricalOutput);
-			}
-			if ((retVal.WHRType & WHRType.MechanicalOutputDrivetrain) != 0) {
-				retVal.MechanicalWHR = CreateWHRData(
-					mode.WasteHeatRecoveryDataMechanical, mission.MissionType, WHRType.MechanicalOutputDrivetrain);
-			}
-
-			return retVal;
-		}
+		//public override CombustionEngineData CreateEngineData(
+		//	IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData mode, Mission mission)
+		//{
+		//	throw new NotImplementedException();
+		//	var engine = vehicle.Components.EngineInputData;
+		//	var gearbox = vehicle.Components.GearboxInputData;
+
+		//	if (!engine.SavedInDeclarationMode) {
+		//		WarnDeclarationMode("EngineData");
+		//	}
+
+		//	var retVal = SetCommonCombustionEngineData(engine, SingleBusInputData.CompletedVehicle.TankSystem);
+		//	retVal.IdleSpeed = VectoMath.Max(mode.IdleSpeed, vehicle.EngineIdleSpeed);
+
+		//	retVal.Fuels = new List<CombustionEngineFuelData>();
+		//	foreach (var fuel in mode.Fuels) {
+		//		retVal.Fuels.Add(
+		//			new CombustionEngineFuelData() {
+		//				WHTCUrban = fuel.WHTCUrban,
+		//				WHTCRural = fuel.WHTCRural,
+		//				WHTCMotorway = fuel.WHTCMotorway,
+		//				ColdHotCorrectionFactor = fuel.ColdHotBalancingFactor,
+		//				CorrectionFactorRegPer = fuel.CorrectionFactorRegPer,
+		//				FuelData = DeclarationData.FuelData.Lookup(fuel.FuelType, SingleBusInputData.CompletedVehicle.TankSystem),
+		//				ConsumptionMap = FuelConsumptionMapReader.Create(fuel.FuelConsumptionMap),
+		//				FuelConsumptionCorrectionFactor = DeclarationData.WHTCCorrection.Lookup(
+		//													mission.MissionType.GetNonEMSMissionType(), fuel.WHTCRural, fuel.WHTCUrban,
+		//													fuel.WHTCMotorway) * fuel.ColdHotBalancingFactor * fuel.CorrectionFactorRegPer,
+		//			});
+		//	}
+
+		//	retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox.Type);
+		//	retVal.EngineStartTime = DeclarationData.Engine.DefaultEngineStartTime;
+		//	var limits = vehicle.TorqueLimits.ToDictionary(e => e.Gear);
+		//	var numGears = gearbox.Gears.Count;
+		//	var fullLoadCurves = new Dictionary<uint, EngineFullLoadCurve>(numGears + 1);
+		//	fullLoadCurves[0] = FullLoadCurveReader.Create(mode.FullLoadCurve, true);
+		//	fullLoadCurves[0].EngineData = retVal;
+		//	foreach (var gear in gearbox.Gears) {
+		//		var maxTorque = VectoMath.Min(
+		//			GbxMaxTorque(gear, numGears, fullLoadCurves[0].MaxTorque),
+		//			VehMaxTorque(gear, numGears, limits, fullLoadCurves[0].MaxTorque));
+		//		fullLoadCurves[(uint)gear.Gear] = IntersectFullLoadCurves(fullLoadCurves[0], maxTorque);
+		//	}
+
+		//	retVal.FullLoadCurves = fullLoadCurves;
+
+		//	retVal.WHRType = engine.WHRType;
+		//	if ((retVal.WHRType & WHRType.ElectricalOutput) != 0) {
+		//		retVal.ElectricalWHR = CreateWHRData(
+		//			mode.WasteHeatRecoveryDataElectrical, mission.MissionType, WHRType.ElectricalOutput);
+		//	}
+		//	if ((retVal.WHRType & WHRType.MechanicalOutputDrivetrain) != 0) {
+		//		retVal.MechanicalWHR = CreateWHRData(
+		//			mode.WasteHeatRecoveryDataMechanical, mission.MissionType, WHRType.MechanicalOutputDrivetrain);
+		//	}
+
+		//	return retVal;
+		//}
 
 		protected override TransmissionLossMap CreateGearLossMap(ITransmissionInputData gear, uint i, bool useEfficiencyFallback, VehicleCategory vehicleCategory, GearboxType gearboxType)
 		{
@@ -144,10 +145,10 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 		#region Overrides of DeclarationDataAdapterCompletedBusGeneric
 
-		public override RetarderData CreateRetarderData(IRetarderInputData retarder)
-		{
-			return SetCommonRetarderData(retarder);
-		}
+		//public override RetarderData CreateRetarderData(IRetarderInputData retarder)
+		//{
+		//	return SetCommonRetarderData(retarder);
+		//}
 
 		#endregion
 

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/EngineeringDataAdapter.cs

@@ -42,6 +42,7 @@ using TUGraz.VectoCore.InputData.FileIO.JSON;
 using TUGraz.VectoCore.InputData.Impl;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
 using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.PrimaryBus;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents;
 using TUGraz.VectoCore.InputData.Reader.ShiftStrategy;
 using TUGraz.VectoCore.Models.BusAuxiliaries;
 using TUGraz.VectoCore.Models.BusAuxiliaries.DownstreamModules.Impl.Electrics;
@@ -62,6 +63,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 {
 	public class EngineeringDataAdapter : AbstractSimulationDataAdapter
 	{
+		private AirdragDataAdapter _airdragDataAdapter = new AirdragDataAdapter();
 		internal VehicleData CreateVehicleData(IVehicleEngineeringInputData data)
 		{
 			if (data.SavedInDeclarationMode) {
@@ -146,7 +148,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 									: 4.SI<Meter>());
 					retVal.CrossWindCorrectionCurve = new CrosswindCorrectionCdxALookup(
 						airDragArea,
-						HeavyLorry.DeclarationDataAdapterHeavyLorry.Conventional.GetDeclarationAirResistanceCurve(
+						_airdragDataAdapter.GetDeclarationAirResistanceCurve(
 							GetAirdragParameterSet(
 								data.VehicleCategory, data.AxleConfiguration, data.Components.AxleWheels.AxlesEngineering.Count, data.GrossVehicleMassRating), airDragArea,
 							height),
@@ -709,24 +711,24 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 		
 
-		private Dictionary<string, ElectricConsumerEntry> GetElectricConsumers(IBusAuxElectricSystemEngineeringData busAuxElectricSystem)
+		private Dictionary<string, AuxiliaryDataAdapter.ElectricConsumerEntry> GetElectricConsumers(IBusAuxElectricSystemEngineeringData busAuxElectricSystem)
 		{
-			var retVal = new Dictionary<string, ElectricConsumerEntry>();
+			var retVal = new Dictionary<string, AuxiliaryDataAdapter.ElectricConsumerEntry>();
 
 			var iBase = busAuxElectricSystem.CurrentDemandEngineOffStandstill;
 			var iSP = busAuxElectricSystem.CurrentDemandEngineOffDriving -
 					busAuxElectricSystem.CurrentDemandEngineOffStandstill;
 			var iFan = busAuxElectricSystem.CurrentDemand - busAuxElectricSystem.CurrentDemandEngineOffDriving;
 
-			retVal["BaseLoad"] = new ElectricConsumerEntry() {
+			retVal["BaseLoad"] = new AuxiliaryDataAdapter.ElectricConsumerEntry() {
 				Current = iBase,
 				BaseVehicle = true
 			};
-			retVal[Constants.Auxiliaries.IDs.SteeringPump] = new ElectricConsumerEntry() {
+			retVal[Constants.Auxiliaries.IDs.SteeringPump] = new AuxiliaryDataAdapter.ElectricConsumerEntry() {
 				Current = iSP,
 				ActiveDuringEngineStopStandstill = false,
 			};
-			retVal[Constants.Auxiliaries.IDs.Fan] = new ElectricConsumerEntry() {
+			retVal[Constants.Auxiliaries.IDs.Fan] = new AuxiliaryDataAdapter.ElectricConsumerEntry() {
 				Current = iFan,
 				ActiveDuringEngineStopStandstill = false,
 				ActiveDuringEngineStopDriving = false,
@@ -1306,6 +1308,257 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 			return null;
 		}
+
+		internal VehicleData SetCommonVehicleData(IVehicleDeclarationInputData data)
+		{
+			var retVal = new VehicleData
+			{
+				InputData = data,
+				SavedInDeclarationMode = data.SavedInDeclarationMode,
+				Manufacturer = data.Manufacturer,
+				ModelName = data.Model,
+				Date = data.Date,
+				//CertificationNumber = data.CertificationNumber,
+				DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
+				VehicleCategory = data.VehicleCategory,
+				CurbMass = data.CurbMassChassis,
+				GrossVehicleMass = data.GrossVehicleMassRating,
+				AirDensity = Physics.AirDensity,
+			};
+
+			return retVal;
+		}
+
+		internal RetarderData SetCommonRetarderData(IRetarderInputData retarderInputData,
+			PowertrainPosition position = PowertrainPosition.HybridPositionNotSet)
+		{
+			try
+			{
+				var retarder = new RetarderData { Type = retarderInputData.Type };
+
+				switch (retarder.Type)
+				{
+					case RetarderType.TransmissionInputRetarder:
+					case RetarderType.TransmissionOutputRetarder:
+						if (!(position.IsParallelHybrid() || position.IsOneOf(PowertrainPosition.HybridPositionNotSet, PowertrainPosition.BatteryElectricE2)))
+						{
+							throw new ArgumentException("Transmission retarder is only allowed in powertrains that " +
+														"contain a gearbox: Conventional, HEV-P, and PEV-E2.", nameof(retarder));
+						}
+
+						retarder.LossMap = RetarderLossMapReader.Create(retarderInputData.LossMap);
+						retarder.Ratio = retarderInputData.Ratio;
+						break;
+
+					case RetarderType.AxlegearInputRetarder:
+						if (position != PowertrainPosition.BatteryElectricE3)
+							throw new ArgumentException("AxlegearInputRetarder is only allowed for PEV-E3, HEV-S3, S-IEPC, E-IEPC. ", nameof(retarder));
+						retarder.LossMap = RetarderLossMapReader.Create(retarderInputData.LossMap);
+						retarder.Ratio = retarderInputData.Ratio;
+						break;
+
+					case RetarderType.None:
+					case RetarderType.LossesIncludedInTransmission:
+					case RetarderType.EngineRetarder:
+						retarder.Ratio = 1;
+						break;
+
+					default:
+						throw new ArgumentOutOfRangeException(nameof(retarder), retarder.Type, "RetarderType unknown");
+				}
+
+				if (retarder.Type.IsDedicatedComponent())
+				{
+					retarder.SavedInDeclarationMode = retarderInputData.SavedInDeclarationMode;
+					retarder.Manufacturer = retarderInputData.Manufacturer;
+					retarder.ModelName = retarderInputData.Model;
+					retarder.Date = retarderInputData.Date;
+					retarder.CertificationMethod = retarderInputData.CertificationMethod;
+					retarder.CertificationNumber = retarderInputData.CertificationNumber;
+					retarder.DigestValueInput = retarderInputData.DigestValue != null ? retarderInputData.DigestValue.DigestValue : "";
+				}
+
+				return retarder;
+			}
+			catch (Exception e)
+			{
+				throw new VectoException("Error while Reading Retarder Data: {0}", e.Message);
+			}
+		}
+
+		internal static GearboxData SetCommonGearboxData(IGearboxDeclarationInputData data)
+		{
+			return new GearboxData
+			{
+				InputData = data,
+				SavedInDeclarationMode = data.SavedInDeclarationMode,
+				Manufacturer = data.Manufacturer,
+				ModelName = data.Model,
+				Date = data.Date,
+				CertificationMethod = data.CertificationMethod,
+				CertificationNumber = data.CertificationMethod != CertificationMethod.StandardValues ?
+					data.CertificationNumber : "",
+				DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
+				Type = data.Type
+			};
+		}
+
+		protected static void CreateTCSecondGearATSerial(GearData gearData,
+			ShiftPolygon shiftPolygon)
+		{
+			gearData.TorqueConverterRatio = gearData.Ratio;
+			gearData.TorqueConverterGearLossMap = gearData.LossMap;
+			gearData.TorqueConverterShiftPolygon = shiftPolygon;
+		}
+
+		protected static void CreateTCFirstGearATSerial(GearData gearData,
+			ShiftPolygon shiftPolygon)
+		{
+			gearData.TorqueConverterRatio = gearData.Ratio;
+			gearData.TorqueConverterGearLossMap = gearData.LossMap;
+			gearData.TorqueConverterShiftPolygon = shiftPolygon;
+		}
+
+		protected virtual void CretateTCFirstGearATPowerSplit(GearData gearData, uint i, ShiftPolygon shiftPolygon)
+		{
+			gearData.TorqueConverterRatio = 1;
+			gearData.TorqueConverterGearLossMap = TransmissionLossMapReader.Create(1, 1, $"TCGear {i + 1}");
+			gearData.TorqueConverterShiftPolygon = shiftPolygon;
+		}
+
+		/// <summary>
+		/// Creates an AngledriveData or returns null if there is no anglegear.
+		/// </summary>
+		/// <param name="data"></param>
+		/// <param name="useEfficiencyFallback">if true, the Efficiency value is used if no LossMap is found.</param>
+		/// <returns></returns>
+		internal AngledriveData DoCreateAngledriveData(IAngledriveInputData data, bool useEfficiencyFallback)
+		{
+			try
+			{
+				var type = data?.Type ?? AngledriveType.None;
+
+				switch (type)
+				{
+					case AngledriveType.LossesIncludedInGearbox:
+					case AngledriveType.None:
+						return null;
+					case AngledriveType.SeparateAngledrive:
+						var angledriveData = new AngledriveData
+						{
+							InputData = data,
+							SavedInDeclarationMode = data.SavedInDeclarationMode,
+							Manufacturer = data.Manufacturer,
+							ModelName = data.Model,
+							Date = data.Date,
+							CertificationMethod = data.CertificationMethod,
+							CertificationNumber = data.CertificationNumber,
+							DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
+							Type = type,
+							Angledrive = new TransmissionData { Ratio = data.Ratio }
+						};
+						try
+						{
+							angledriveData.Angledrive.LossMap = TransmissionLossMapReader.Create(data.LossMap,
+								data.Ratio, "Angledrive", true);
+						}
+						catch (VectoException ex)
+						{
+							Log.Info("Angledrive Loss Map not found.");
+							if (useEfficiencyFallback)
+							{
+								Log.Info("Angledrive Trying with Efficiency instead of Loss Map.");
+								angledriveData.Angledrive.LossMap = TransmissionLossMapReader.Create(data.Efficiency,
+									data.Ratio, "Angledrive");
+							}
+							else
+							{
+								throw new VectoException("Angledrive: LossMap not found.", ex);
+							}
+						}
+						return angledriveData;
+					default:
+						throw new ArgumentOutOfRangeException(nameof(data), "Unknown Angledrive Type.");
+				}
+			}
+			catch (Exception e)
+			{
+				throw new VectoException("Error while reading Angledrive data: {0}", e.Message, e);
+			}
+		}
+
+		/// <summary>
+		/// Intersects max torque curve.
+		/// </summary>
+		/// <param name="maxTorqueEntries"></param>
+		/// <param name="maxTorque"></param>
+		/// <returns>A combined EngineFullLoadCurve with the minimum full load torque over all inputs curves.</returns>
+		internal static IList<VehicleMaxPropulsionTorque.FullLoadEntry> IntersectMaxPropulsionTorqueCurve(IList<VehicleMaxPropulsionTorque.FullLoadEntry> maxTorqueEntries, NewtonMeter maxTorque)
+		{
+			if (maxTorque == null)
+			{
+				return maxTorqueEntries;
+			}
+
+			var entries = new List<VehicleMaxPropulsionTorque.FullLoadEntry>();
+			var firstEntry = maxTorqueEntries.First();
+			if (firstEntry.FullDriveTorque < maxTorque)
+			{
+				entries.Add(maxTorqueEntries.First());
+			}
+			else
+			{
+				entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry
+				{
+					MotorSpeed = firstEntry.MotorSpeed,
+					FullDriveTorque = maxTorque,
+				});
+			}
+			foreach (var entry in maxTorqueEntries.Pairwise(Tuple.Create))
+			{
+				if (entry.Item1.FullDriveTorque <= maxTorque && entry.Item2.FullDriveTorque <= maxTorque)
+				{
+					// segment is below maxTorque line -> use directly
+					entries.Add(entry.Item2);
+				}
+				else if (entry.Item1.FullDriveTorque > maxTorque && entry.Item2.FullDriveTorque > maxTorque)
+				{
+					// segment is above maxTorque line -> add limited entry
+					entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry
+					{
+						MotorSpeed = entry.Item2.MotorSpeed,
+						FullDriveTorque = maxTorque,
+					});
+				}
+				else
+				{
+					// segment intersects maxTorque line -> add new entry at intersection
+					var edgeFull = Edge.Create(
+						new Point(entry.Item1.MotorSpeed.Value(), entry.Item1.FullDriveTorque.Value()),
+						new Point(entry.Item2.MotorSpeed.Value(), entry.Item2.FullDriveTorque.Value()));
+
+					var intersectionX = (maxTorque.Value() - edgeFull.OffsetXY) / edgeFull.SlopeXY;
+					if (!entries.Any(x => x.MotorSpeed.IsEqual(intersectionX)) && !intersectionX.IsEqual(entry.Item2.MotorSpeed.Value()))
+					{
+						entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry
+						{
+							MotorSpeed = intersectionX.SI<PerSecond>(),
+							FullDriveTorque = maxTorque,
+						});
+					}
+
+					entries.Add(new VehicleMaxPropulsionTorque.FullLoadEntry
+					{
+						MotorSpeed = entry.Item2.MotorSpeed,
+						FullDriveTorque = entry.Item2.FullDriveTorque > maxTorque ? maxTorque : entry.Item2.FullDriveTorque,
+
+					});
+				}
+			}
+
+
+			return entries;
+		}
 	}
 
 	public class IEPCGearboxInputData : IGearboxDeclarationInputData

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/DeclarationDataAdapterHeavyLorry.cs

@@ -31,98 +31,277 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using TUGraz.VectoCommon.Exceptions;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents;
+using TUGraz.VectoCore.InputData.Reader.ShiftStrategy;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.SimulationComponent;
 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.InputData.Reader.DataObjectAdapter.HeavyLorry
 {
-	
 	public partial class DeclarationDataAdapterHeavyLorry : AbstractSimulationDataAdapter, IDeclarationDataAdapter
 	{
-		[Obsolete("Use DeclarationDataAdapterHeavyLorry.Conventional instead, created automatically with NInject")]
-		public DeclarationDataAdapterHeavyLorry()
-		{
-			
-		}
-		private IDeclarationDataAdapter _declarationDataAdapterImplementation = new Conventional();
-		public static readonly GearboxType[] SupportedGearboxTypes = Conventional.SupportedGearboxTypes;
-		public static List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> GetDeclarationAirResistanceCurve(string parameterSet, SquareMeter si, Meter meter)
+		public abstract class LorryBase : AbstractSimulationDataAdapter, IDeclarationDataAdapter
 		{
-			return Conventional.GetDeclarationAirResistanceCurve(parameterSet, si, meter);
-		}
 			#region Implementation of IDeclarationDataAdapter
 
+			private readonly IDriverDataAdapter _driverDataAdapter = new LorryDriverDataAdapter();
+			protected readonly IVehicleDataAdapter _vehicleDataAdapter = new LorryVehicleDataAdapter();
+			private readonly IAxleGearDataAdapter _axleGearDataAdapter = new AxleGearDataAdapterBase();
+			private readonly IRetarderDataAdapter _retarderDataAdapter = new RetarderDataAdapter();
+			private readonly IAirdragDataAdapter _airdragDataAdapter = new AirdragDataAdapter();
+			private readonly IPTODataAdapter _ptoDataAdapter = new PTODataAdapterLorry();
 			public DriverData CreateDriverData()
 			{
-			return _declarationDataAdapterImplementation.CreateDriverData();
+				return _driverDataAdapter.CreateDriverData();
 			}
 
-		public VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission,
+			public virtual VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment,
+				Mission mission,
 				KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
 			{
-			return _declarationDataAdapterImplementation.CreateVehicleData(vehicle, segment, mission, loading, allowVocational);
+				return _vehicleDataAdapter.CreateVehicleData(vehicle, segment, mission, loading.Value.Item1,
+					loading.Value.Item2, allowVocational);
 			}
 
-		public AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragData, Mission mission, Segment segment)
+			public virtual AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragData, Mission mission,
+				Segment segment)
 			{
-			return _declarationDataAdapterImplementation.CreateAirdragData(airdragData, mission, segment);
+				return _airdragDataAdapter.CreateAirdragData(airdragData, mission, segment);
 			}
 
 			public AxleGearData CreateAxleGearData(IAxleGearInputData axlegearData)
 			{
-			return _declarationDataAdapterImplementation.CreateAxleGearData(axlegearData);
+				return _axleGearDataAdapter.CreateAxleGearData(axlegearData);
 			}
 
-		public AngledriveData CreateAngledriveData(IAngledriveInputData angledriveData)
+			public virtual AngledriveData CreateAngledriveData(IAngledriveInputData angledriveData)
 			{
-			return _declarationDataAdapterImplementation.CreateAngledriveData(angledriveData);
+				throw new NotImplementedException();
 			}
 
-		public CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData engineMode,
+			public virtual CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle,
+				IEngineModeDeclarationInputData engineMode,
 				Mission mission)
 			{
-			return _declarationDataAdapterImplementation.CreateEngineData(vehicle, engineMode, mission);
+				throw new NotImplementedException();
+			}
+
+			public virtual GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
+				IShiftPolygonCalculator shiftPolygonCalc)
+			{
+				throw new NotImplementedException();
+			}
+
+			public abstract ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio,
+				PerSecond engineIdlingSpeed);
+
+			public RetarderData CreateRetarderData(IRetarderInputData retarderData)
+			{
+				return _retarderDataAdapter.CreateRetarderData(retarderData);
 			}
 
+			public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)
+			{
+				return _ptoDataAdapter.CreatePTOTransmissionData(ptoData);
+			}
+
+			public abstract IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData,
+				IBusAuxiliariesDeclarationData busAuxData,
+				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles);
+
+			public AxleGearData CreateDummyAxleGearData(IGearboxDeclarationInputData gbxData)
+			{
+				return _axleGearDataAdapter.CreateDummyAxleGearData(gbxData);
+			}
+
+			#endregion
+		}
+
+		public class Conventional : LorryBase
+		{
+			public static readonly GearboxType[] SupportedGearboxTypes =
+				{ GearboxType.MT, GearboxType.AMT, GearboxType.ATPowerSplit, GearboxType.ATSerial };
+
+			private IEngineDataAdapter _engineDataAdapter = new CombustionEngineComponentDataAdapter();
+			private IGearboxDataAdapter _gearboxDataAdapter = new GearboxDataAdapter(new TorqueConverterDataAdapter());
+			private IAngledriveDataAdapter _angleDriveDataAdapter = new AngledriveDataAdapter();
+			private IAuxiliaryDataAdapter _auxAdapter = new HeavyLorryAuxiliaryDataAdapter();
+			public override CombustionEngineData CreateEngineData(
+				IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData mode, Mission mission)
+			{
+				return _engineDataAdapter.CreateEngineData(vehicle, mode, mission);
+			}
+
+
+
 			public GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
 				IShiftPolygonCalculator shiftPolygonCalc)
 			{
-			return _declarationDataAdapterImplementation.CreateGearboxData(inputData, runData, shiftPolygonCalc);
+				return _gearboxDataAdapter.CreateGearboxData(inputData, runData, shiftPolygonCalc, SupportedGearboxTypes);
 			}
 
-		public ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			protected virtual TorqueConverterData CreateTorqueConverterData(GearboxType gearboxType,
+				ITorqueConverterDeclarationInputData torqueConverter, double ratio,
+				CombustionEngineData componentsEngineInputData)
 			{
-			return _declarationDataAdapterImplementation.CreateGearshiftData(gbx, axleRatio, engineIdlingSpeed);
+				return TorqueConverterDataReader.Create(
+					torqueConverter.TCData,
+					DeclarationData.TorqueConverter.ReferenceRPM, DeclarationData.TorqueConverter.MaxInputSpeed,
+					ExecutionMode.Declaration, ratio,
+					DeclarationData.TorqueConverter.CLUpshiftMinAcceleration,
+					DeclarationData.TorqueConverter.CCUpshiftMinAcceleration);
 			}
 
-		public RetarderData CreateRetarderData(IRetarderInputData retarderData)
+			#region Overrides of LorryBase
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
 			{
-			return _declarationDataAdapterImplementation.CreateRetarderData(retarderData);
+				return _gearboxDataAdapter.CreateGearshiftData(gbx, axleRatio, engineIdlingSpeed);
 			}
 
-		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)
+			#endregion
+
+
+			public override AngledriveData CreateAngledriveData(IAngledriveInputData data)
 			{
-			return _declarationDataAdapterImplementation.CreatePTOTransmissionData(ptoData);
+				return _angleDriveDataAdapter.CreateAngledriveData(data, false);
 			}
 
-		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
+
+			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(
+				IAuxiliariesDeclarationInputData auxInputData,
+				IBusAuxiliariesDeclarationData busAuxData, MissionType mission, VehicleClass hvdClass,
+				Meter vehicleLength, int? numSteeredAxles)
+			{
+				return _auxAdapter.CreateAuxiliaryData(auxInputData, busAuxData, mission, hvdClass, vehicleLength,
+					numSteeredAxles);
+			}
+		}
+
+		public abstract class SerialHybrid : LorryBase
+		{
+			#region Overrides of LorryBase
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			{
+				throw new NotImplementedException();
+			}
+
+			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
 				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
 			{
-			return _declarationDataAdapterImplementation.CreateAuxiliaryData(auxData, busAuxData, missionType, vehicleClass, vehicleLength, numSteeredAxles);
+				throw new NotImplementedException();
 			}
 
-		public AxleGearData CreateDummyAxleGearData(IGearboxDeclarationInputData gbxData)
+			#endregion
+		}
+
+		public abstract class ParallelHybrid : LorryBase
+		{
+			#region Overrides of LorryBase
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
 			{
-			return _declarationDataAdapterImplementation.CreateDummyAxleGearData(gbxData);
+				throw new NotImplementedException();
+			}
+
+			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
+				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
+			{
+				throw new NotImplementedException();
+			}
+
+			#endregion
+		}
+
+		public abstract class BatteryElectric : LorryBase
+		{
+			#region Overrides of LorryBase
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			{
+				throw new NotImplementedException();
+			}
+
+			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
+				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
+			{
+				throw new NotImplementedException();
 			}
 
 			#endregion
+		}
+		public class HEV_S2 : SerialHybrid { }
+		public class HEV_S3 : SerialHybrid { }
+		public class HEV_S4 : SerialHybrid { }
+		public class HEV_S_IEPC : SerialHybrid { }
+		public class HEV_P1 : ParallelHybrid { }
+		public class HEV_P2 : ParallelHybrid { }
+		public class HEV_P2_5 : ParallelHybrid { }
+		public class HEV_P3 : ParallelHybrid { }
+		public class HEV_P4 : ParallelHybrid { }
+		public class PEV_E2 : BatteryElectric { }
+		public class PEV_E3 : BatteryElectric { }
+		public class PEV_E4 : BatteryElectric { }
+		public class PEV_E_IEPC : BatteryElectric { }
+		public class Exempted : LorryBase
+		{
+			#region Overrides of LorryBase
+
+			public override VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission,
+				KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
+			{
+				return _vehicleDataAdapter.CreateExemptedVehicleData(vehicle);
+			}
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			{
+				throw new NotImplementedException();
+			}
+
+			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
+				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
+			{
+				throw new NotImplementedException();
+			}
+
+			#endregion
+		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 	}

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/DeclarationDataAdapterHeavyLorry_old.cs

+using System;
+using System.Collections.Generic;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
+{
+
+
+
+	public partial class DeclarationDataAdapterHeavyLorry
+	{
+		[Obsolete("Use DeclarationDataAdapterHeavyLorry.Conventional instead, created automatically with NInject")]
+		public DeclarationDataAdapterHeavyLorry() { }
+
+		private IDeclarationDataAdapter _declarationDataAdapterImplementation = new Conventional();
+		public static readonly GearboxType[] SupportedGearboxTypes = Conventional.SupportedGearboxTypes;
+
+		//public static List<CrossWindCorrectionCurveReader.CrossWindCorrectionEntry> GetDeclarationAirResistanceCurve(
+		//	string parameterSet, SquareMeter si, Meter meter)
+		//{
+		//	//return Conventional.GetDeclarationAirResistanceCurve(parameterSet, si, meter);
+		//}
+
+		#region Implementation of IDeclarationDataAdapter
+
+		public DriverData CreateDriverData()
+		{
+			return _declarationDataAdapterImplementation.CreateDriverData();
+		}
+
+		public VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission,
+			KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
+		{
+			return _declarationDataAdapterImplementation.CreateVehicleData(vehicle, segment, mission, loading,
+				allowVocational);
+		}
+
+		public AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragData, Mission mission, Segment segment)
+		{
+			return _declarationDataAdapterImplementation.CreateAirdragData(airdragData, mission, segment);
+		}
+
+		public AxleGearData CreateAxleGearData(IAxleGearInputData axlegearData)
+		{
+			return _declarationDataAdapterImplementation.CreateAxleGearData(axlegearData);
+		}
+
+		public AngledriveData CreateAngledriveData(IAngledriveInputData angledriveData)
+		{
+			return _declarationDataAdapterImplementation.CreateAngledriveData(angledriveData);
+		}
+
+		public CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle,
+			IEngineModeDeclarationInputData engineMode,
+			Mission mission)
+		{
+			return _declarationDataAdapterImplementation.CreateEngineData(vehicle, engineMode, mission);
+		}
+
+		public GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
+			IShiftPolygonCalculator shiftPolygonCalc)
+		{
+			return _declarationDataAdapterImplementation.CreateGearboxData(inputData, runData, shiftPolygonCalc);
+		}
+
+		public ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio,
+			PerSecond engineIdlingSpeed)
+		{
+			return _declarationDataAdapterImplementation.CreateGearshiftData(gbx, axleRatio, engineIdlingSpeed);
+		}
+
+		public RetarderData CreateRetarderData(IRetarderInputData retarderData)
+		{
+			return _declarationDataAdapterImplementation.CreateRetarderData(retarderData);
+		}
+
+		public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)
+		{
+			return _declarationDataAdapterImplementation.CreatePTOTransmissionData(ptoData);
+		}
+
+		public IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData,
+			IBusAuxiliariesDeclarationData busAuxData,
+			MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
+		{
+			return _declarationDataAdapterImplementation.CreateAuxiliaryData(auxData, busAuxData, missionType,
+				vehicleClass, vehicleLength, numSteeredAxles);
+		}
+
+		public AxleGearData CreateDummyAxleGearData(IGearboxDeclarationInputData gbxData)
+		{
+			return _declarationDataAdapterImplementation.CreateDummyAxleGearData(gbxData);
+		}
+
+		#endregion
+	}
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_P1.cs

-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class HEV_P1 : LorryBase
-		{
-
-		}
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_P2.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class HEV_P2 : LorryBase
-		{
-
-		}
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_P2_5.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class HEV_P2_5 : LorryBase
-		{
-
-		}
-
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_P3.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class HEV_P3 : LorryBase
-		{
-
-		}
-
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_P4.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class HEV_P4 : LorryBase
-		{
-
-		}
-
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_S3.cs

-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-    public partial class DeclarationDataAdapterHeavyLorry
-    {
-		public class HEV_S3 : LorryBase
-		{
-
-		}
-    }
-}

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HEV_S4.cs

-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-    public partial class DeclarationDataAdapterHeavyLorry
-    {
-		public class HEV_S4 : LorryBase
-		{
-
-		}
-    }
-}

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/HeavyLorryDeclarationDataAdapter.cd

+<?xml version="1.0" encoding="utf-8"?>
+<ClassDiagram /> 
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/LorryBase.cs

-using System;
-using System.Collections.Generic;
-using TUGraz.VectoCommon.InputData;
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents;
-using TUGraz.VectoCore.Models.Declaration;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.SimulationComponent;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public abstract class LorryBase : AbstractSimulationDataAdapter, IDeclarationDataAdapter
-		{
-			#region Implementation of IDeclarationDataAdapter
-
-			private readonly IDriverDataAdapter _driverDataAdapter = new LorryDriverDataAdapter();
-
-			public DriverData CreateDriverData()
-			{
-				return _driverDataAdapter.CreateDriverData();
-			}
-
-			public virtual VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment,
-				Mission mission,
-				KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragData, Mission mission,
-				Segment segment)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual AxleGearData CreateAxleGearData(IAxleGearInputData axlegearData)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual AngledriveData CreateAngledriveData(IAngledriveInputData angledriveData)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle,
-				IEngineModeDeclarationInputData engineMode,
-				Mission mission)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
-				IShiftPolygonCalculator shiftPolygonCalc)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio,
-				PerSecond engineIdlingSpeed)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual RetarderData CreateRetarderData(IRetarderInputData retarderData)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData,
-				IBusAuxiliariesDeclarationData busAuxData,
-				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
-			{
-				throw new NotImplementedException();
-			}
-
-			public virtual AxleGearData CreateDummyAxleGearData(IGearboxDeclarationInputData gbxData)
-			{
-				throw new NotImplementedException();
-			}
-
-			#endregion
-		}
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/PEV_E2.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class PEV_E2 : LorryBase
-		{
-
-		}
-	}
-}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/HeavyLorry/PEV_E3.cs

-
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
-{
-	public partial class DeclarationDataAdapterHeavyLorry
-	{
-		public class PEV_E3 : LorryBase
-		{
-
-		}
-	}
-}
\ No newline at end of file