added HybridStrategyParameterDataAdapter, BatteryDataAdapter, ElectricMachinesDataAdapter

VectoCommon/VectoCommon/InputData/DeclarationInputData.cs

@@ -196,7 +196,7 @@ namespace TUGraz.VectoCommon.InputData
 
 		VehicleDeclarationType VehicleDeclarationType { get; }
 
-		Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits { get; }
+		IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits { get; }
 		
 		TableData BoostingLimitations { get; }
 

VectoCommon/VectoCommon/Models/VehicleCategory.cs

@@ -73,6 +73,7 @@ namespace TUGraz.VectoCommon.Models
 			switch (category) {
 				case VehicleCategory.RigidTruck:
 				case VehicleCategory.Tractor:
+				case VehicleCategory.Van:
 					return Lorry;
 					break;
 				case VehicleCategory.HeavyBusPrimaryVehicle:
@@ -81,8 +82,8 @@ namespace TUGraz.VectoCommon.Models
 				case VehicleCategory.HeavyBusCompletedVehicle:
 					return CompletedBus;
 					break;
-				case VehicleCategory.Van:
-					return Van;
+				//case VehicleCategory.Van:
+				//	return Van;
 				default:
 					return category.GetLabel();
 			}

VectoCore/VectoCore/InputData/FileIO/JSON/JSONComponentInputData.cs

@@ -261,7 +261,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 
 		public VehicleDeclarationType VehicleDeclarationType { get; }
 
-		public Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => Vehicle.ElectricMotorTorqueLimits;
+		public IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => Vehicle.ElectricMotorTorqueLimits;
 		public TableData BoostingLimitations => Vehicle.BoostingLimitations;
 		
 

VectoCore/VectoCore/InputData/FileIO/JSON/JSONVehicleData.cs

@@ -181,10 +181,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 
 		//public override Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits =>
 		//	throw new NotImplementedException();
-		public override Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits =>
+		public override IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits =>
 			Body["EMTorqueLimits"] == null
 				? null
-				: new Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>>() {
+				: new Dictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>>() {
 					{
 						GetElectricMachines().Entries.First().Position,
 						new List<Tuple<Volt, TableData>>() {
@@ -322,7 +322,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 
 		public virtual Meter Height => Body["VehicleHeight"] == null ? null : Body.GetEx<double>("VehicleHeight").SI<Meter>();
 		
-		public virtual Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
+		public virtual IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
 		
 		public virtual TableData BoostingLimitations => null;
 		

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLDeclarationVehicleDataProvider.cs

@@ -229,7 +229,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
 		public virtual ConsumerTechnology? DoorDriveTechnology => ConsumerTechnology.Unknown;
 		public virtual VehicleDeclarationType VehicleDeclarationType { get; }
-		public virtual Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
+		public virtual IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
 		public virtual TableData BoostingLimitations => null;
 
 
@@ -551,7 +551,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 		public virtual ConsumerTechnology? DoorDriveTechnology => ConsumerTechnology.Unknown;
 
 		public virtual VehicleDeclarationType VehicleDeclarationType { get; }
-		public virtual Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits { get; }
+		public virtual IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits { get; }
 		public virtual TableData BoostingLimitations { get; }
 		public virtual string VehicleTypeApprovalNumber { get; }
 		public virtual IVehicleComponentsDeclaration Components => _components ?? (_components = ComponentReader.ComponentInputData);
@@ -808,7 +808,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
 		#endregion
 
-		public override Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits
+		public override IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits
 			=> ElementExists(XMLNames.ElectricMotorTorqueLimits) ? ReadElectricMotorTorqueLimits() : null;
 
 		#region Overrides of XMLDeclarationVehicleDataProviderV20
@@ -820,10 +820,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
 		#endregion
 
-		private Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ReadElectricMotorTorqueLimits()
+		private IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ReadElectricMotorTorqueLimits()
 		{
 			var torqueLimitNodes = GetNodes(XMLNames.ElectricMotorTorqueLimits);
-			var motorTorqueLimits = new Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>>();
+			var motorTorqueLimits = new Dictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>>();
 
 			foreach (XmlNode torqueLimitNode in torqueLimitNodes)
 			{

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLElectricStorageSystemDeclarationInputData.cs

@@ -7,6 +7,7 @@ using TUGraz.VectoCommon.Resources;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces;
 using TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
 using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
@@ -106,10 +107,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 		#region Implementation of IBatteryPackDeclarationInputData
 
 		public virtual double? MinSOC  => 
-			ElementExists(XMLNames.Battery_SOCmin) ? GetDouble(XMLNames.Battery_SOCmin) : (double?)null;
+			ElementExists(XMLNames.Battery_SOCmin) ? GetDouble(XMLNames.Battery_SOCmin) / 100 : (double?)null;
 
 		public virtual double? MaxSOC => 
-			ElementExists(XMLNames.Battery_SOCmax) ? GetDouble(XMLNames.Battery_SOCmax) : (double?)null;
+			ElementExists(XMLNames.Battery_SOCmax) ? GetDouble(XMLNames.Battery_SOCmax) / 100 : (double?)null;
 
 		public virtual BatteryType BatteryType => GetString(XMLNames.REESS_BatteryType).ParseEnum<BatteryType>();
 		public virtual AmpereSecond Capacity => GetDouble(XMLNames.REESS_RatedCapacity).SI(Unit.SI.Ampere.Hour).Cast<AmpereSecond>();
@@ -122,11 +123,11 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
 		public virtual TableData InternalResistanceCurve => ReadTableData(XMLNames.REESS_InternalResistanceCurve, XMLNames.REESS_MapEntry,
 			new Dictionary<string, string> {
-				{XMLNames.REESS_InternalResistanceCurve_SoC, XMLNames.REESS_InternalResistanceCurve_SoC},
-				{XMLNames.REESS_InternalResistanceCurve_R2, XMLNames.REESS_InternalResistanceCurve_R2},
-				{XMLNames.REESS_InternalResistanceCurve_R10, XMLNames.REESS_InternalResistanceCurve_R10},
-				{XMLNames.REESS_InternalResistanceCurve_R20, XMLNames.REESS_InternalResistanceCurve_R20},
-				{XMLNames.REESS_InternalResistanceCurve_R120, XMLNames.REESS_InternalResistanceCurve_R120}
+				{BatteryInternalResistanceReader.Fields.StateOfCharge, XMLNames.REESS_InternalResistanceCurve_SoC},
+				{BatteryInternalResistanceReader.Fields.InternalResistance_2, XMLNames.REESS_InternalResistanceCurve_R2},
+				{BatteryInternalResistanceReader.Fields.InternalResistance_10, XMLNames.REESS_InternalResistanceCurve_R10},
+				{BatteryInternalResistanceReader.Fields.InternalResistance_20, XMLNames.REESS_InternalResistanceCurve_R20},
+				{BatteryInternalResistanceReader.Fields.InternalResistance_120, XMLNames.REESS_InternalResistanceCurve_R120}
 			});
 		
 		public virtual TableData VoltageCurve => ReadTableData(XMLNames.REESS_OCV, XMLNames.REESS_MapEntry, 

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/v24/XMLDeclarationHeavyLorryVehicleDataProvider.cs

@@ -232,7 +232,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider.v24
 
 		public override IList<ITorqueLimitInputData> TorqueLimits => null;
 
-		public override Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
+		public override IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
 		public override TableData BoostingLimitations => null;
 
 		#endregion

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Reader/Impl/XMLDeclarationMultistageInputReader.cs

@@ -502,7 +502,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader.Impl
 		public VehicleDeclarationType VehicleDeclarationType => _manufacturingStages?.First().Vehicle.VehicleDeclarationType ?? default(VehicleDeclarationType);
 
 
-		public Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => throw new NotImplementedException();
+		public IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => throw new NotImplementedException();
 		public TableData BoostingLimitations => throw new NotImplementedException();
 
 		#endregion

VectoCore/VectoCore/InputData/FileIO/XML/Engineering/DataProvider/XMLEngineeringVehicleDataProvider.cs

@@ -148,7 +148,7 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Engineering.DataProvider
 		public ConsumerTechnology? DoorDriveTechnology => ConsumerTechnology.Unknown;
 		public virtual VehicleDeclarationType VehicleDeclarationType { get; }
 
-		public Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
+		public IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> ElectricMotorTorqueLimits => null;
 
 		public TableData BoostingLimitations => null;
 

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

@@ -897,9 +897,9 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			};
 		}
 
-		public List<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
+		public IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
 			IElectricMachinesEngineeringInputData electricMachines,
-			Dictionary<PowertrainPosition, List<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage,
+			IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage,
 			GearList gearlist = null)
 		{
 			if (electricMachines == null) {
@@ -923,7 +923,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 		private ElectricMotorData CreateElectricMachine(PowertrainPosition powertrainPosition,
 			IElectricMotorEngineeringInputData motorData, int count,
 			double ratio, double[] ratioPerGear, double efficiency, TableData adcLossMap,
-			List<Tuple<Volt, TableData>> torqueLimits, Volt averageVoltage, GearList gearList)
+			IList<Tuple<Volt, TableData>> torqueLimits, Volt averageVoltage, GearList gearList)
 		{
 			var voltageLevels = new List<ElectricMotorVoltageLevelData>();
 
@@ -958,7 +958,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				EfficiencyData = new VoltageLevelData() { VoltageLevels = voltageLevels},
 				EMDragCurve = ElectricMotorDragCurveReader.Create(motorData.DragCurve, count),
 				Inertia = motorData.Inertia * count,
-				OverloadRegenerationFactor = motorData.OverloadRecoveryFactor,
+				OverloadRecoveryFactor = motorData.OverloadRecoveryFactor,
 				RatioADC = ratio,
 				RatioPerGear = ratioPerGear,
 				TransmissionLossMap = lossMap,
@@ -1218,7 +1218,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 				EfficiencyData = new VoltageLevelData() { VoltageLevels = voltageLevels },
 				IEPCDragCurves = dragCurves,
 				Inertia = iepc.Inertia * count,
-				OverloadRegenerationFactor = iepc.OverloadRecoveryFactor,
+				OverloadRecoveryFactor = iepc.OverloadRecoveryFactor,
 				RatioADC = 1,
 				RatioPerGear = null,
 				TransmissionLossMap = TransmissionLossMapReader.CreateEmADCLossMap(1.0, 1.0, "EM ADC LossMap Eff"),

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

@@ -39,13 +39,16 @@ 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.DataObjectAdapter.SimulationComponents.StrategyDataAdapter;
 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.Battery;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
@@ -62,6 +65,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 			private readonly IRetarderDataAdapter _retarderDataAdapter = new RetarderDataAdapter();
 			private readonly IAirdragDataAdapter _airdragDataAdapter = new AirdragDataAdapter();
 			private readonly IPTODataAdapter _ptoDataAdapter = new PTODataAdapterLorry();
+			private IAngledriveDataAdapter _angleDriveDataAdapter = new AngledriveDataAdapter();
 			public DriverData CreateDriverData()
 			{
 				return _driverDataAdapter.CreateDriverData();
@@ -75,6 +79,29 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 					loading.Value.Item2, allowVocational);
 			}
 
+			public virtual IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
+				IElectricMachinesDeclarationInputData electricMachines,
+				IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage,
+				GearList gears = null)
+			{
+				throw new NotImplementedException();
+			}
+
+			public virtual BatterySystemData CreateBatteryData(IElectricStorageSystemDeclarationInputData componentsElectricStorage)
+			{
+				throw new NotImplementedException();
+			}
+
+			public virtual SuperCapData CreateSuperCapData(IElectricStorageSystemDeclarationInputData componentsElectricStorage)
+			{
+				throw new NotImplementedException();
+			}
+
+			public virtual HybridStrategyParameters CreateHybridStrategy(BatterySystemData runDataBatteryData, SuperCapData runDataSuperCapData)
+			{
+				throw new NotImplementedException();
+			}
+
 			public virtual AirdragData CreateAirdragData(IAirdragDeclarationInputData airdragData, Mission mission,
 				Segment segment)
 			{
@@ -86,9 +113,10 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 				return _axleGearDataAdapter.CreateAxleGearData(axlegearData);
 			}
 
-			public virtual AngledriveData CreateAngledriveData(IAngledriveInputData angledriveData)
+
+			public AngledriveData CreateAngledriveData(IAngledriveInputData data)
 			{
-				throw new NotImplementedException();
+				return _angleDriveDataAdapter.CreateAngledriveData(data, false);
 			}
 
 			public virtual CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle,
@@ -104,12 +132,15 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 				throw new NotImplementedException();
 			}
 
-			public abstract ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio,
-				PerSecond engineIdlingSpeed);
+			public virtual ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio,
+				PerSecond engineIdlingSpeed)
+			{
+				throw new NotImplementedException();
+			}
 
-			public RetarderData CreateRetarderData(IRetarderInputData retarderData)
+			public RetarderData CreateRetarderData(IRetarderInputData retarderData, PowertrainPosition position)
 			{
-				return _retarderDataAdapter.CreateRetarderData(retarderData);
+				return _retarderDataAdapter.CreateRetarderData(retarderData, position);
 			}
 
 			public PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData)
@@ -136,7 +167,6 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 
 			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)
@@ -161,10 +191,6 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 			#endregion
 
 
-			public override AngledriveData CreateAngledriveData(IAngledriveInputData data)
-			{
-				return _angleDriveDataAdapter.CreateAngledriveData(data, false);
-			}
 
 
 			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(
@@ -177,15 +203,49 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 			}
 		}
 
-		public abstract class SerialHybrid : LorryBase
+		public abstract class Hybrid : LorryBase
 		{
+			private IEngineDataAdapter _engineDataAdapter = new CombustionEngineComponentDataAdapter();
+			private ElectricMachinesDataAdapter _electricMachinesDataAdapter = new ElectricMachinesDataAdapter();
+			private ElectricStorageAdapter _eletricStorageAdapter = new ElectricStorageAdapter();
+			public override CombustionEngineData CreateEngineData(
+				IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData mode, Mission mission)
+			{
+				return _engineDataAdapter.CreateEngineData(vehicle, mode, mission);
+			}
+
 			#region Overrides of LorryBase
 
-			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			public override IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
+				IElectricMachinesDeclarationInputData electricMachines,
+				IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage,
+				GearList gears = null)
 			{
-				throw new NotImplementedException();
+				return _electricMachinesDataAdapter.CreateElectricMachines(electricMachines, torqueLimits, averageVoltage,
+					gears);
 			}
 
+			public override BatterySystemData CreateBatteryData(IElectricStorageSystemDeclarationInputData batteryInputData)
+			{
+				return _eletricStorageAdapter.CreateBatteryData(batteryInputData);
+			}
+
+			public override SuperCapData CreateSuperCapData(IElectricStorageSystemDeclarationInputData reessInputData)
+			{
+				return _eletricStorageAdapter.CreateSuperCapData(reessInputData);
+			}
+
+			//public RetarderData CreateRetarderData 
+
+			#endregion
+		}
+
+		public abstract class SerialHybrid : Hybrid
+		{
+			#region Overrides of LorryBase
+
+			
+
 			public override IList<VectoRunData.AuxData> CreateAuxiliaryData(IAuxiliariesDeclarationInputData auxData, IBusAuxiliariesDeclarationData busAuxData,
 				MissionType missionType, VehicleClass vehicleClass, Meter vehicleLength, int? numSteeredAxles)
 			{
@@ -195,8 +255,10 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 			#endregion
 		}
 
-		public abstract class ParallelHybrid : LorryBase
+		public abstract class ParallelHybrid : Hybrid
 		{
+			private ParallelHybridStrategyParameterDataAdapter _hybridStrategyDataAdapter =
+				new ParallelHybridStrategyParameterDataAdapter();
 			#region Overrides of LorryBase
 
 			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
@@ -210,6 +272,11 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 				throw new NotImplementedException();
 			}
 
+			public override HybridStrategyParameters CreateHybridStrategy(BatterySystemData runDataBatteryData, SuperCapData runDataSuperCapData)
+			{
+				return _hybridStrategyDataAdapter.CreateHybridStrategyParameters(runDataBatteryData, runDataSuperCapData);
+			}
+
 			#endregion
 		}
 
@@ -230,7 +297,26 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry
 
 			#endregion
 		}
-		public class HEV_S2 : SerialHybrid { }
+
+		public class HEV_S2 : SerialHybrid
+		{
+			#region Overrides of LorryBase
+			public static readonly GearboxType[] SupportedGearboxTypes =
+				{ GearboxType.AMT, GearboxType.ATPowerSplit, GearboxType.ATSerial, GearboxType.APTN };
+			private GearboxDataAdapter _gearBoxDataAdaper = new GearboxDataAdapter(new TorqueConverterDataAdapter());
+			public override GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
+				IShiftPolygonCalculator shiftPolygonCalc)
+			{
+				return _gearBoxDataAdaper.CreateGearboxData(inputData, runData, shiftPolygonCalc, SupportedGearboxTypes);
+			}
+
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			{
+				return _gearBoxDataAdaper.CreateGearshiftData(gbx, axleRatio, engineIdlingSpeed);
+			}
+
+			#endregion
+		}
 		public class HEV_S3 : SerialHybrid { }
 		public class HEV_S4 : SerialHybrid { }
 		public class HEV_S_IEPC : SerialHybrid { }

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/IDeclarationDataAdapter.cs

@@ -8,6 +8,8 @@ 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.Battery;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 {
@@ -45,7 +47,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 
 		PTOData CreatePTOTransmissionData(IPTOTransmissionInputData ptoData);
 
-		RetarderData CreateRetarderData(IRetarderInputData retarderData);
+		RetarderData CreateRetarderData(IRetarderInputData retarderData, PowertrainPosition position = PowertrainPosition.HybridPositionNotSet);
 
 		ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed);
 
@@ -61,7 +63,11 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
 			IBusAuxiliariesDeclarationData busAuxData, MissionType missionType, VehicleClass vehicleClass,
 			Meter vehicleLength, int? numSteeredAxles);
 		
-		VehicleData CreateVehicleData(IVehicleDeclarationInputData vehicle, Segment segment, Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, bool allowVocational);
+		
+		IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(IElectricMachinesDeclarationInputData electricMachines, IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage, GearList gears = null);
+		BatterySystemData CreateBatteryData(IElectricStorageSystemDeclarationInputData componentsElectricStorage);
+		SuperCapData CreateSuperCapData(IElectricStorageSystemDeclarationInputData componentsElectricStorage);
+		HybridStrategyParameters CreateHybridStrategy(BatterySystemData runDataBatteryData, SuperCapData runDataSuperCapData);
 	}
 
 	public interface IPrimaryBusDeclarationDataAdapter : IDeclarationDataAdapter

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/PrimaryBus/DeclarationDataAdapterPrimaryBus.cs

@@ -140,63 +140,107 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.PrimaryBus
 			#endregion
 		}
 
-		public class HEV_S2 : PrimaryBusBase
+		public abstract class Hybrid : PrimaryBusBase
+		{
+			private CombustionEngineComponentDataAdapter _engineDataAdapter = new CombustionEngineComponentDataAdapter();
+
+			#region Overrides of PrimaryBusBase
+
+			public override CombustionEngineData CreateEngineData(IVehicleDeclarationInputData vehicle, IEngineModeDeclarationInputData engineMode,
+				Mission mission)
+			{
+				return _engineDataAdapter.CreateEngineData(vehicle, engineMode, mission);
+			}
+
+			
+
+			#endregion
+		}
+
+		public abstract class SerialHybrid : Hybrid
+		{
+
+		}
+
+		public class HEV_S2 : SerialHybrid
+		{
+
+		}
+
+		public class HEV_S3 : SerialHybrid
+		{
+
+		}
+
+		public class HEV_S4 : SerialHybrid
 		{
 
 		}
 
-		public class HEV_S3 : PrimaryBusBase
+		public class HEV_S_IEPC : SerialHybrid
 		{
 
 		}
 
-		public class HEV_S4 : PrimaryBusBase
+		public abstract class ParallelHybrid : Hybrid
 		{
+			private GearboxDataAdapter _gearboxDataAdapter = new GearboxDataAdapter(new TorqueConverterDataAdapter());
+			public override GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
+				IShiftPolygonCalculator shiftPolygonCalc)
+			{
+				return _gearboxDataAdapter.CreateGearboxData(inputData, runData, shiftPolygonCalc,
+					supportedGearboxTypes: SupportedGearboxTypes);
+			}
 
+			public override ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
+			{
+				return _gearboxDataAdapter.CreateGearshiftData(gbx, axleRatio, engineIdlingSpeed);
+			}
 		}
 
-		public class HEV_S_IEPC : PrimaryBusBase
+		public class HEV_P1 : ParallelHybrid
 		{
 
 		}
 
-		public class HEV_P1 : PrimaryBusBase
+		public class HEV_P2 : ParallelHybrid
 		{
 
 		}
 
-		public class HEV_P2 : PrimaryBusBase
+		public class HEV_P2_5 : ParallelHybrid
 		{
 
 		}
 
-		public class HEV_P2_5 : PrimaryBusBase
+		public class HEV_P3 : ParallelHybrid
 		{
 
 		}
 
-		public class HEV_P3 : PrimaryBusBase
+		public class HEV_P4 : ParallelHybrid
 		{
 
 		}
 
-		public class HEV_P4 : PrimaryBusBase
+		public abstract class BatteryElectric : PrimaryBusBase
 		{
 
 		}
 
-		public class PEV_E2 : PrimaryBusBase
+
+		public class PEV_E2 : BatteryElectric
 		{
 
 		}
 
-		public class PEV_E3 : PrimaryBusBase
+		public class PEV_E3 : BatteryElectric
 		{
 
 		}
 
 
-		public class PEV_E4 : PrimaryBusBase
+		public class PEV_E4 : BatteryElectric
 		{
 
 		}

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/AuxiliaryDataAdapter.cs

@@ -42,6 +42,9 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 		TechnologyBenefits SelectBenefitForFloorType(FloorType floorType, List<SSMTechnology> onVehicle);
 	}
 
+
+	
+
 	public abstract class AuxiliaryDataAdapter : ComponentDataAdapterBase, IAuxiliaryDataAdapter
 	{
 		public class ElectricConsumerEntry

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/BatteryDataAdapter.cs

+using System;
+using System.Linq;
+using System.Security.Policy;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Battery;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
+{
+	public class ElectricStorageAdapter
+	{
+		public BatterySystemData CreateBatteryData(IElectricStorageSystemDeclarationInputData batteryInputData)
+		{
+			if (batteryInputData == null)
+			{
+				return null;
+			}
+
+			var bat = batteryInputData.ElectricStorageElements.Where(x => x.REESSPack.StorageType == REESSType.Battery).ToArray();
+
+			if (bat.Length == 0)
+			{
+				return null;
+			}
+
+			var retVal = new BatterySystemData();
+			foreach (var entry in bat)
+			{
+				var b = entry.REESSPack as IBatteryPackDeclarationInputData;
+				if (b == null)
+				{
+					continue;
+				}
+
+				//for (var i = 0; i < entry.Count; i++) {
+					var minSoc = DeclarationData.Battery.GetMinSoc(b.BatteryType);
+					if (b.MinSOC != null && b.MinSOC > minSoc) {
+						minSoc = b.MinSOC.Value;
+					}
+					var maxSoc = DeclarationData.Battery.GetMaxSoc(b.BatteryType);
+					if (b.MaxSOC != null && b.MaxSOC < maxSoc) {
+						maxSoc = b.MaxSOC.Value;
+					}
+				
+					var batteryData = new BatteryData() {
+						MinSOC = minSoc,
+						MaxSOC = maxSoc,
+						MaxCurrent = BatteryMaxCurrentReader.Create(b.MaxCurrentMap),
+						Capacity = b.Capacity,
+						InternalResistance =
+							BatteryInternalResistanceReader.Create(b.InternalResistanceCurve, false),
+						SOCMap = BatterySOCReader.Create(b.VoltageCurve),
+					};
+
+					retVal.Batteries.Add(Tuple.Create(entry.StringId, batteryData));
+				//}
+			}
+
+
+
+			retVal.InitialSoC = CalculateInitialSoc(retVal);
+			return retVal;
+		}
+
+		private double CalculateInitialSoc(BatterySystemData battery)
+		{
+			var socLimits = battery.GetSocLimits();
+			return (socLimits.MaxSoc - socLimits.MinSoc) / 2;
+		}
+
+		public SuperCapData CreateSuperCapData(IElectricStorageSystemDeclarationInputData reessInputData)
+		{
+			if (reessInputData == null)
+			{
+				return null;
+			}
+
+			var superCaps = reessInputData.ElectricStorageElements.Where(x => x.REESSPack.StorageType == REESSType.SuperCap).ToArray();
+
+			var superCap = superCaps.FirstOrDefault()?.REESSPack as ISuperCapDeclarationInputData;
+
+			if (superCap == null)
+			{
+				return null;
+			}
+
+			return new SuperCapData()
+			{
+				Capacity = superCaps.First().Count * superCap.Capacity,
+				InternalResistance = superCap.InternalResistance / superCaps.First().Count,
+				MinVoltage = superCap.MinVoltage * DeclarationData.SuperCap.SocMin, //Überschreiben prozent beziehen sich auf max voltage
+				MaxVoltage = superCap.MaxVoltage,
+				MaxCurrentCharge = superCap.MaxCurrentCharge,
+				MaxCurrentDischarge = -superCap.MaxCurrentDischarge,
+				InitialSoC = Math.Sqrt(Math.Pow(superCap.MaxVoltage.Value(), 2) - Math.Pow(superCap.MaxVoltage.Value(), 2)) /
+							superCap.MaxVoltage.Value()
+			};
+		}
+
+
+		
+	}
+
+	public static class BatterySystemHelper
+	{
+		public static Volt CalculateAverageVoltage(this BatterySystemData battery)
+		{
+			if (battery == null)
+			{
+				return null;
+			}
+			var tmpBattery = new BatterySystem(null, battery);
+			var min = tmpBattery.MinSoC;
+			var max = tmpBattery.MaxSoC;
+			var averageSoC = (min + max) / 2.0;
+
+			tmpBattery.Initialize(averageSoC);
+			return tmpBattery.InternalVoltage;
+		}
+
+
+		public static (double MinSoc, double MaxSoc) GetSocLimits(this BatterySystemData battery)
+		{
+			if (battery == null) {
+				throw new ArgumentNullException();
+			}
+
+			var tmpBattery = new BatterySystem(null, battery);
+			return (tmpBattery.MinSoC, tmpBattery.MaxSoC);
+		}
+	}
+	
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/ElectricMachinesDataAdapter.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricMotor;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
+{
+	public class ElectricMachinesDataAdapter
+	{
+		public IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
+			IElectricMachinesDeclarationInputData electricMachines,
+			IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage, GearList gearlist = null)
+		{
+			var result = new List<Tuple<PowertrainPosition, ElectricMotorData>>();
+			if (electricMachines == null) {
+				return null;
+			}
+			if (electricMachines.Entries.Select(x => x.Position).Where(x => x != PowertrainPosition.GEN).Distinct().Count() > 1)
+			{
+				throw new VectoException("multiple electric propulsion motors are not supported at the moment");
+			}
+
+			return electricMachines.Entries
+				.Select(x => Tuple.Create(x.Position,
+					CreateElectricMachine(x.Position, x.ElectricMachine, x.Count, x.RatioADC, x.RatioPerGear, x.MechanicalTransmissionEfficiency,
+						x.MechanicalTransmissionLossMap, torqueLimits?.First(t => t.Key == x.Position).Value, averageVoltage, gearlist))).ToList();
+
+			return result;
+		}
+
+		private ElectricMotorData CreateElectricMachine(PowertrainPosition powertrainPosition, 
+			IElectricMotorDeclarationInputData motorData,
+			int count, 
+			double ratio,
+			double[] ratioPerGear,
+			double efficiency,
+			TableData adcLossMap,
+			IList<Tuple<Volt, TableData>> torqueLimits,
+			Volt averageVoltage, GearList gearList)
+		{
+
+			var voltageLevels = new List<ElectricMotorVoltageLevelData>();
+
+			foreach (var entry in motorData.VoltageLevels.OrderBy(x => x.VoltageLevel))
+			{
+				var fullLoadCurve = ElectricFullLoadCurveReader.Create(entry.FullLoadCurve, count);
+				var maxTorqueCurve = torqueLimits == null
+					? null
+					: ElectricFullLoadCurveReader.Create(
+						torqueLimits.FirstOrDefault(x => x.Item1 == null || x.Item1.IsEqual(entry.VoltageLevel))?.Item2, count);
+
+				var fullLoadCurveCombined = IntersectEMFullLoadCurves(fullLoadCurve, maxTorqueCurve);
+
+				var vLevelData = powertrainPosition == PowertrainPosition.IHPC
+					? CreateIHPCVoltageLevelData(count, entry, fullLoadCurveCombined, gearList)
+					: CreateEmVoltageLevelData(count, entry, fullLoadCurveCombined);
+				voltageLevels.Add(vLevelData);
+
+			}
+
+			if (averageVoltage == null)
+			{
+				// if no average voltage is provided (e.g. for supercap) use mean value of measured voltage maps
+				averageVoltage = (voltageLevels.Min(x => x.Voltage) + voltageLevels.Max(x => x.Voltage)) / 2.0;
+			}
+
+			var lossMap = powertrainPosition == PowertrainPosition.IHPC
+				? TransmissionLossMapReader.CreateEmADCLossMap(1.0, 1.0, "EM ADC IHPC LossMap Eff")
+				: adcLossMap != null
+					? TransmissionLossMapReader.CreateEmADCLossMap(adcLossMap, ratio, "EM ADC LossMap")
+					: TransmissionLossMapReader.CreateEmADCLossMap(efficiency, ratio, "EM ADC LossMap Eff");
+
+			var retVal = new ElectricMotorData()
+			{
+				EfficiencyData = new VoltageLevelData() { VoltageLevels = voltageLevels },
+				EMDragCurve = ElectricMotorDragCurveReader.Create(motorData.DragCurve, count),
+				Inertia = motorData.Inertia * count,
+				OverloadRecoveryFactor = DeclarationData.OverloadRecoveryFactor,
+				RatioADC = ratio,
+				RatioPerGear = ratioPerGear,
+				TransmissionLossMap = lossMap,
+			};
+			retVal.Overload = CalculateOverloadData(motorData, count, retVal.EfficiencyData, averageVoltage);
+			return retVal;
+		}
+
+		private static ElectricMotorFullLoadCurve IntersectEMFullLoadCurves(ElectricMotorFullLoadCurve fullLoadCurve,
+			ElectricMotorFullLoadCurve maxTorqueCurve)
+		{
+			if (maxTorqueCurve == null)
+			{
+				return fullLoadCurve;
+			}
+
+			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())
+			{
+				// 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 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
+				{
+					// add the point just before and just after the current list of points 
+					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))
+					{
+						maxPtsWithinSegment.Add(maxTorqueCurve.FullLoadEntries.First(x => x.MotorSpeed.IsGreater(fldTuple.Item2.MotorSpeed)));
+					}
+
+					maxPtsWithinSegment = maxPtsWithinSegment.OrderBy(x => x.MotorSpeed).ToList();
+				}
+
+				var fldEdgeDrive =
+					Edge.Create(new Point(fldTuple.Item1.MotorSpeed.Value(), fldTuple.Item1.FullDriveTorque.Value()),
+						new Point(fldTuple.Item2.MotorSpeed.Value(), fldTuple.Item2.FullDriveTorque.Value()));
+				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())
+				{
+					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))
+					{
+						// 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))
+						{
+							motorSpeeds.Add(nIntersectDrive);
+						}
+					}
+
+					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)))
+					{
+						// 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))
+						{
+							motorSpeeds.Add(nIntersectGenerate);
+						}
+					}
+				}
+			}
+
+			// create new full-load curve with values closest to zero.
+			return new ElectricMotorFullLoadCurve(motorSpeeds.OrderBy(x => x.Value()).Distinct().Select(x =>
+				new ElectricMotorFullLoadCurve.FullLoadEntry()
+				{
+					MotorSpeed = x,
+					FullDriveTorque = VectoMath.Max(fullLoadCurve.FullLoadDriveTorque(x),
+						maxTorqueCurve.FullLoadDriveTorque(x)),
+					FullGenerationTorque = VectoMath.Min(fullLoadCurve.FullGenerationTorque(x),
+						maxTorqueCurve.FullGenerationTorque(x)),
+				}).ToList());
+		}
+
+		private ElectricMotorVoltageLevelData CreateIHPCVoltageLevelData(int count, IElectricMotorVoltageLevel entry, ElectricMotorFullLoadCurve fullLoadCurveCombined, GearList gearList)
+		{
+			if (gearList == null)
+			{
+				throw new VectoException("no gears provided for IHPC EM");
+			}
+
+			if (gearList.Count() != entry.PowerMap.Count)
+			{
+				throw new VectoException(
+					$"number of gears in transmission does not match gears in electric motor (IHPC) - {gearList.Count()}/{entry.PowerMap.Count}");
+			}
+			var effMap = new Dictionary<uint, EfficiencyMap>();
+			foreach (var gear in gearList)
+			{
+				effMap.Add(gear.Gear, ElectricMotorMapReader.Create(entry.PowerMap[(int)gear.Gear - 1].PowerMap, count));
+			}
+			return new IEPCVoltageLevelData()
+			{
+				Voltage = entry.VoltageLevel,
+				FullLoadCurve = fullLoadCurveCombined,
+				EfficiencyMaps = effMap,
+			};
+		}
+
+		private static ElectricMotorVoltageLevelData CreateEmVoltageLevelData(int count, IElectricMotorVoltageLevel entry, ElectricMotorFullLoadCurve fullLoadCurveCombined)
+		{
+			return new ElectricMotorVoltageLevelData()
+			{
+				Voltage = entry.VoltageLevel,
+
+				FullLoadCurve = fullLoadCurveCombined,
+				// DragCurve = ElectricMotorDragCurveReader.Create(entry.DragCurve, count),
+				EfficiencyMap = ElectricMotorMapReader.Create(entry.PowerMap.First().PowerMap, count), //PowerMap
+			};
+		}
+
+		private OverloadData CalculateOverloadData(IElectricMotorDeclarationInputData motorData, int count, VoltageLevelData voltageLevels, Volt averageVoltage)
+		{
+
+			// if average voltage is outside of the voltage-level range, do not extrapolate but take the min voltage entry, or max voltage entry
+			if (averageVoltage < motorData.VoltageLevels.Min(x => x.VoltageLevel))
+			{
+				return CalculateOverloadBuffer(motorData.VoltageLevels.First(), count, voltageLevels);
+			}
+			if (averageVoltage > motorData.VoltageLevels.Max(x => x.VoltageLevel))
+			{
+				return CalculateOverloadBuffer(motorData.VoltageLevels.Last(), count, voltageLevels);
+			}
+
+			var (vLow, vHigh) = motorData.VoltageLevels.OrderBy(x => x.VoltageLevel).GetSection(x => x.VoltageLevel < averageVoltage);
+			var ovlLo = CalculateOverloadBuffer(vLow, count, voltageLevels);
+			var ovlHi = CalculateOverloadBuffer(vHigh, count, voltageLevels);
+
+			var retVal = new OverloadData()
+			{
+				OverloadBuffer = VectoMath.Interpolate(vLow.VoltageLevel, vHigh.VoltageLevel, ovlLo.OverloadBuffer, ovlHi.OverloadBuffer, averageVoltage),
+				ContinuousTorque = VectoMath.Interpolate(vLow.VoltageLevel, vHigh.VoltageLevel, ovlLo.ContinuousTorque, ovlHi.ContinuousTorque, averageVoltage),
+				ContinuousPowerLoss = VectoMath.Interpolate(vLow.VoltageLevel, vHigh.VoltageLevel, ovlLo.ContinuousPowerLoss, ovlHi.ContinuousPowerLoss, averageVoltage)
+			};
+			return retVal;
+		}
+
+		private OverloadData CalculateOverloadBuffer(IElectricMotorVoltageLevel voltageEntry,
+			int count, VoltageLevelData voltageLevels, Tuple<uint, double> gearUsedForMeasurement = null)
+		{
+			var gearRatioUsedForMeasurement = gearUsedForMeasurement?.Item2 ?? 1.0;
+			var gear = new GearshiftPosition(gearUsedForMeasurement?.Item1 ?? 1);
+			var continuousTorque = voltageEntry.ContinuousTorque * count / gearRatioUsedForMeasurement;
+			var continuousTorqueSpeed = voltageEntry.ContinuousTorqueSpeed * gearRatioUsedForMeasurement;
+			var overloadTorque = (voltageEntry.OverloadTorque ?? 0.SI<NewtonMeter>()) * count / gearRatioUsedForMeasurement;
+			var overloadTestSpeed = (voltageEntry.OverloadTestSpeed ?? 0.RPMtoRad()) * gearRatioUsedForMeasurement;
+
+
+			var peakElPwr = voltageLevels.LookupElectricPower(voltageEntry.VoltageLevel, overloadTestSpeed, -overloadTorque, gear, true)
+				.ElectricalPower;
+			var peakPwrLoss = -peakElPwr - overloadTorque * overloadTestSpeed; // losses need to be positive
+
+			var contElPwr = voltageLevels.LookupElectricPower(voltageEntry.VoltageLevel, continuousTorqueSpeed,
+								-continuousTorque, gear).ElectricalPower ??
+							voltageLevels.LookupElectricPower(voltageEntry.VoltageLevel, continuousTorqueSpeed,
+								voltageLevels.FullLoadDriveTorque(voltageEntry.VoltageLevel, continuousTorqueSpeed),
+								gear, true).ElectricalPower;
+			var continuousPowerLoss = -contElPwr - continuousTorque * continuousTorqueSpeed; // loss needs to be positive
+			var overloadBuffer = (peakPwrLoss - continuousPowerLoss) * voltageEntry.OverloadTime;
+			return new OverloadData()
+			{
+				OverloadBuffer = overloadBuffer,
+				ContinuousTorque = continuousTorque,
+				ContinuousPowerLoss = continuousPowerLoss
+			};
+		}
+	}
+
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/EngineDataAdapter.cs

@@ -195,15 +195,20 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 					});
 			}
 
-			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox.Type);
+			retVal.Inertia = DeclarationData.Engine.EngineInertia(retVal.Displacement, gearbox?.Type ?? GearboxType.NoGearbox);
+			//retVal.Inertia = engine.Inertia +
+			//				(gbx != null && gbx.Type.AutomaticTransmission()
+			//					? (gbx.Type == GearboxType.APTN || gbx.Type == GearboxType.IHPC ? 0.SI<KilogramSquareMeter>() : torqueConverter.Inertia)
+			//					: 0.SI<KilogramSquareMeter>());
+
 			retVal.EngineStartTime = DeclarationData.Engine.DefaultEngineStartTime;
 			var limits = vehicle.TorqueLimits?.ToDictionary(e => e.Gear) ??
 						new Dictionary<int, ITorqueLimitInputData>();
-			var numGears = gearbox.Gears.Count;
+			var numGears = gearbox?.Gears.Count ?? 0;
 			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)
+			foreach (var gear in gearbox?.Gears ?? new List<ITransmissionInputData>(0))
 			{
 				var maxTorque = VectoMath.Min(
 					GearboxDataAdapterBase.GbxMaxTorque(gear, numGears, fullLoadCurves[0].MaxTorque),

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/RetarderDataAdapter.cs

@@ -11,11 +11,11 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 {
 	public interface IRetarderDataAdapter
 	{
-		RetarderData CreateRetarderData(IRetarderInputData retarder);
+		RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position = PowertrainPosition.HybridPositionNotSet);
 	}
 	public class RetarderDataAdapter : IRetarderDataAdapter
 	{
-		public RetarderData CreateRetarderData(IRetarderInputData retarder)
+		public RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position)
 		{
 			return SetCommonRetarderData(retarder);
 		}
@@ -80,7 +80,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 	public class GenericRetarderDataAdapter : IRetarderDataAdapter
 	{
 		private readonly GenericBusRetarderData _genericRetarderData = new GenericBusRetarderData();
-		public  RetarderData CreateRetarderData(IRetarderInputData retarder)
+		public  RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position)
 		{
 			return _genericRetarderData.CreateGenericBusRetarderData(retarder);
 		}

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/StrategyDataAdapter/HybridStrategyParameterDataAdapter.cs

+using System;
+using System.ComponentModel;
+using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.HeavyLorry;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Battery;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.StrategyDataAdapter
+{
+
+	public abstract class HybridStrategyDataAdapter{
+
+	}
+
+	public class ParallelHybridStrategyParameterDataAdapter : HybridStrategyParameters
+	{
+		public HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData, SuperCapData superCap)
+		{
+			if (batterySystemData == null && superCap == null) {
+				return null;
+			}
+			if(batterySystemData != null && superCap != null) {
+				throw new VectoException("Supercap AND Batteries not supported");
+			}
+			var result = new HybridStrategyParameters();
+			if (batterySystemData != null) {
+				var tmpBatterySystem = new BatterySystem(null, batterySystemData);
+				result.MinSoC = tmpBatterySystem.MinSoC;
+				result.MaxSoC = tmpBatterySystem.MaxSoC;
+				result.TargetSoC = (result.MaxSoC - result.MinSoC) / 2;
+			} else {
+				result.MinSoC = superCap.MinVoltage / superCap.MaxVoltage;
+				result.MaxSoC = 1;// superCap.MaxVoltage / superCap.MaxVoltage;
+				
+				result.TargetSoC = Math.Sqrt(Math.Pow(superCap.MaxVoltage.Value(), 2) - Math.Pow(superCap.MaxVoltage.Value(), 2)) /
+									superCap.MaxVoltage.Value();
+			}
+
+			//TODO Move to DeclarationData.Hybridstrategy.Parallel
+			result.AuxReserveTime = 0.SI<Second>();
+			result.AuxReserveChargeTime = 0.SI<Second>();
+			result.MinICEOnTime = 10.SI<Second>();
+			result.ICEStartPenaltyFactor = 0.1;
+			result.CostFactorSOCExponent = 1;
+
+			
+
+			return result;
+		}
+	}
+
+	public class SerialHybridStrategyParameterDataAdapter : HybridStrategyParameters
+	{
+		public HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData,
+			SuperCapData superCap)
+		{
+			return new HybridStrategyParameters();
+		}
+	}
+}
\ No newline at end of file