refactoring: heavy lorry declaration data adapter: implement methods in base...

refactoring: heavy lorry declaration data adapter: implement methods in base class, get component data adapter via property implemented in derived class
refactoring: extract interfaces of data adapter in separate files
start implementation primary bus (PEV E2)

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/IEPCDataAdapter.cs → VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IEPCDataAdapter.cs

@@ -10,7 +10,7 @@ using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricMotor;
 
-namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
 {
     public class IEPCDataAdapter
     {

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IElectricMachinesDataAdapter.cs

+using System;
+using System.Collections.Generic;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IElectricMachinesDataAdapter
+    {
+        IList<Tuple<PowertrainPosition, ElectricMotorData>> CreateElectricMachines(
+            IElectricMachinesDeclarationInputData electricMachines,
+            IDictionary<PowertrainPosition, IList<Tuple<Volt, TableData>>> torqueLimits, Volt averageVoltage, GearList gearlist = null);
+
+		List<Tuple<PowertrainPosition, ElectricMotorData>> CreateIEPCElectricMachines(IIEPCDeclarationInputData iepc,
+			Volt averageVoltage);
+	}
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IEngineDataAdapter.cs

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IEngineDataAdapter
+    {
+        CombustionEngineData CreateEngineData(IVehicleDeclarationInputData primaryVehicle,
+            IEngineModeDeclarationInputData mode, Mission mission);
+
+        CombustionEngineData CreateEngineData(IVehicleDeclarationInputData primaryVehicle, int modeIdx, Mission mission);
+    }
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IGearboxDataAdapter.cs

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IGearboxDataAdapter
+    {
+        GearboxData CreateGearboxData(IVehicleDeclarationInputData inputData, VectoRunData runData,
+            IShiftPolygonCalculator shiftPolygonCalculator, GearboxType[] supportedGearboxTypes);
+
+        ShiftStrategyParameters CreateGearshiftData(double axleRatio,
+            PerSecond engineIdlingSpeed, GearboxType gearboxType, int gearsCount);
+    }
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IPTODataAdapter.cs

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IPTODataAdapter
+    {
+        PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto, IGearboxDeclarationInputData gbx);
+        PTOData CreateDefaultPTOData(IPTOTransmissionInputData pto, IGearboxDeclarationInputData gbx);
+    }
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IRetarderDataAdapter.cs

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IRetarderDataAdapter
+    {
+        RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position = PowertrainPosition.HybridPositionNotSet);
+    }
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/ITorqueConverterDataAdapter.cs

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface ITorqueConverterDataAdapter
+    {
+        TorqueConverterData CreateTorqueConverterData(GearboxType gearboxType,
+            ITorqueConverterDeclarationInputData torqueConverter, double ratio,
+            CombustionEngineData engineData);
+    }
+}
\ No newline at end of file

VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/SimulationComponents/Interfaces/IVehicleDataAdapter.cs

+using System;
+using System.Collections.Generic;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces
+{
+    public interface IVehicleDataAdapter
+    {
+        VehicleData CreateVehicleData(IVehicleDeclarationInputData data, Segment segment, Mission mission,
+            Kilogram loading, double? passengerCount, bool allowVocational);
+        VehicleData CreateExemptedVehicleData(IVehicleDeclarationInputData data);
+
+        VehicleData CreateVehicleData(IVehicleDeclarationInputData primaryVehicle,
+            IVehicleDeclarationInputData completedVehicle, Segment segment, Mission mission,
+            KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading);
+
+    }
+}
\ No newline at end of file

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

@@ -2,6 +2,7 @@
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
@@ -9,12 +10,6 @@ using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
 {
-	public interface IPTODataAdapter
-	{
-		PTOData CreatePTOTransmissionData(IPTOTransmissionInputData pto, IGearboxDeclarationInputData gbx);
-		PTOData CreateDefaultPTOData(IPTOTransmissionInputData pto, IGearboxDeclarationInputData gbx);
-	}
-
     public class PTODataAdapterLorry : IPTODataAdapter
 	{
 

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

@@ -4,15 +4,12 @@ using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
 {
-	public interface IRetarderDataAdapter
-	{
-		RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position = PowertrainPosition.HybridPositionNotSet);
-	}
     public class RetarderDataAdapter : IRetarderDataAdapter
 	{
 		public RetarderData CreateRetarderData(IRetarderInputData retarder, PowertrainPosition position = PowertrainPosition.HybridPositionNotSet)

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

@@ -16,8 +16,8 @@ using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.StrategyDataAdapter
 {
-
-    public abstract class HybridStrategyDataAdapter{
+	public abstract class HybridStrategyDataAdapter : IHybridStrategyDataAdapter
+	{
         protected internal static Dictionary<GearshiftPosition, VehicleMaxPropulsionTorque> CreateMaxPropulsionTorque(
 			ArchitectureID archId, CombustionEngineData engineData, GearboxData gearboxData, TableData boostingLimitations)
         {
@@ -168,11 +168,22 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 
             return entries;
         }
+
+		#region Implementation of IHybridStrategyDataAdapter
+
+		public abstract HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData, SuperCapData superCap,
+			VectoRunData.OvcHevMode ovcMode, LoadingType loading, VehicleClass vehicleClass, MissionType missionType, ArchitectureID archID,
+			CombustionEngineData engineData, GearboxData gearboxData, TableData boostingLimitations);
+
+		public abstract HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData, SuperCapData superCapData,
+			Kilogram vehicleMass, VectoRunData.OvcHevMode ovcMode);
+
+		#endregion
 	}
 
     public class ParallelHybridStrategyParameterDataAdapter : HybridStrategyDataAdapter
 	{
-		public HybridStrategyParameters CreateHybridStrategyParameters(
+		public override HybridStrategyParameters CreateHybridStrategyParameters(
 			BatterySystemData batterySystemData,
 			SuperCapData superCap, 
 			VectoRunData.OvcHevMode ovcMode, 
@@ -236,15 +247,23 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponen
 			return result;
 		}
 
-
-
-		
-
+		public override HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData, SuperCapData superCapData,
+			Kilogram vehicleMass, VectoRunData.OvcHevMode ovcMode)
+		{
+			throw new NotImplementedException("Not supported for parallel hybrid strategy");
+		}
 	}
 
 	public class SerialHybridStrategyParameterDataAdapter : HybridStrategyDataAdapter
 	{
-		public HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData,
+		public override HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData, SuperCapData superCap,
+			VectoRunData.OvcHevMode ovcMode, LoadingType loading, VehicleClass vehicleClass, MissionType missionType, ArchitectureID archID,
+			CombustionEngineData engineData, GearboxData gearboxData, TableData boostingLimitations)
+		{
+			throw new NotImplementedException("Not supported for serial hybrid strategy");
+		}
+
+		public override HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData,
 			SuperCapData superCapData, Kilogram vehicleMass, VectoRunData.OvcHevMode ovcMode)
 		{
 			if (batterySystemData == null && superCapData == null) {

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

+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricComponents.Battery;
+
+namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.StrategyDataAdapter
+{
+	public interface IHybridStrategyDataAdapter
+	{
+		// parallel hybrid params
+		HybridStrategyParameters CreateHybridStrategyParameters(
+			BatterySystemData batterySystemData,
+			SuperCapData superCap,
+			VectoRunData.OvcHevMode ovcMode,
+			LoadingType loading,
+			VehicleClass vehicleClass,
+			MissionType missionType, ArchitectureID archID, CombustionEngineData engineData, GearboxData gearboxData,
+			TableData boostingLimitations);
+
+		// serial hybrid params
+		HybridStrategyParameters CreateHybridStrategyParameters(BatterySystemData batterySystemData,
+			SuperCapData superCapData, Kilogram vehicleMass, VectoRunData.OvcHevMode ovcMode);
+	}
+}
\ No newline at end of file

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

 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
 {
-	public interface ITorqueConverterDataAdapter
-	{
-		TorqueConverterData CreateTorqueConverterData(GearboxType gearboxType,
-			ITorqueConverterDeclarationInputData torqueConverter, double ratio,
-			CombustionEngineData engineData);
-	}
     public class TorqueConverterDataAdapter : ITorqueConverterDataAdapter
 	{
 		public virtual TorqueConverterData CreateTorqueConverterData(GearboxType gearboxType,

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

@@ -6,23 +6,13 @@ using TUGraz.VectoCommon.Exceptions;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents
 {
-	public interface IVehicleDataAdapter
-	{
-		VehicleData CreateVehicleData(IVehicleDeclarationInputData data, Segment segment, Mission mission,
-			Kilogram loading, double? passengerCount, bool allowVocational);
-		VehicleData CreateExemptedVehicleData(IVehicleDeclarationInputData data);
-
-		VehicleData CreateVehicleData(IVehicleDeclarationInputData primaryVehicle,
-			IVehicleDeclarationInputData completedVehicle, Segment segment, Mission mission,
-			KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading);
-
-	}
     internal abstract class VehicleDataAdapter : ComponentDataAdapterBase, IVehicleDataAdapter
 	{
 		public static NewtonMeter VehMaxTorque(

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

@@ -8,6 +8,7 @@ using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter.SimulationComponents.Interfaces;
 using TUGraz.VectoCore.Models.Declaration;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.SimulationComponent;

VectoCore/VectoCore/InputData/Reader/Impl/DeclarationMode/HeavyLorryRunDataFactory/DeclarationModeHeavyLorryRunDataFactory.cs

@@ -95,6 +95,7 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.HeavyLorryRunDa
 					InputDataHash = InputDataProvider.XMLHash,
 					MaxChargingPower = InputDataProvider.JobInputData.Vehicle.MaxChargingPower,
 				};
+
 				return simulationRunData;
 			}
 

VectoCore/VectoCore/InputData/Reader/Impl/DeclarationMode/PrimaryBusRunDataFactory/DeclarationModePrimaryBusRunDataFactory.cs

@@ -38,32 +38,6 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				Report = report;
 			}
 
-
-			//protected abstract IEnumerable<VectoRunData> VectoRunDataHeavyBusPrimary();
-			//protected override IEnumerable<VectoRunData> GetNextRun()
-			//{
-			//	if (InputDataProvider.JobInputData.Vehicle.VehicleCategory == VehicleCategory.HeavyBusPrimaryVehicle)
-			//	{
-			//		//if (InputDataProvider.JobInputData.Vehicle.ExemptedVehicle)
-			//		//{
-			//		//	yield return CreateVectoRunData(InputDataProvider.JobInputData.Vehicle, 0, null,
-			//		//		new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>());
-			//		//}
-			//		//else
-			//		//{
-			//			foreach (var vectoRunData in VectoRunDataHeavyBusPrimary())
-			//			{
-			//				yield return vectoRunData;
-			//			}
-			//		//}
-			//	}
-
-			//	foreach (var entry in new List<VectoRunData>())
-			//	{
-			//		yield return entry;
-			//	}
-			//}
-
 			protected override VectoRunData GetPowertrainConfigForReportInit()
 			{
 				var vehicle = InputDataProvider.JobInputData.Vehicle;
@@ -166,6 +140,7 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 					//DriverData = _driverdata,
 					//GearshiftParameters = _gearshiftData,
 				};
+
 				return simulationRunData;
 			}
 
@@ -195,6 +170,9 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 					throw new VectoException("Super caps AND batteries are not supported");
 				}
 			}
+
+			protected abstract void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle,
+				VectoRunData runData);
 		}
 
 		public class Conventional : PrimaryBusBase
@@ -259,19 +237,28 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				simulationRunData.BusAuxiliaries = DataAdapter.CreateBusAuxiliariesData(
 					mission, InputDataProvider.JobInputData.Vehicle, simulationRunData);
 				
+				CreateGearboxAndGearshiftData(vehicle, simulationRunData);
+				return simulationRunData;
+			}
+
+			#region Overrides of PrimaryBusBase
+
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
 				var shiftStrategyName = PowertrainBuilder.GetShiftStrategyName(vehicle.Components.GearboxInputData.Type, vehicle.VehicleType);
-				simulationRunData.GearboxData = DataAdapter.CreateGearboxData(vehicle, simulationRunData,
-					ShiftPolygonCalculator.Create(shiftStrategyName, simulationRunData.GearshiftParameters));
-				simulationRunData.GearshiftParameters =
+				runData.GearboxData = DataAdapter.CreateGearboxData(vehicle, runData,
+					ShiftPolygonCalculator.Create(shiftStrategyName, runData.GearshiftParameters));
+				
+				runData.GearshiftParameters =
 					DataAdapter.CreateGearshiftData(
-						simulationRunData.GearboxData,
-						(simulationRunData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (simulationRunData.AngledriveData?.Angledrive.Ratio ?? 1.0),
-						vehicle.EngineIdleSpeed
-					);
+						(runData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (runData.AngledriveData?.Angledrive.Ratio ?? 1.0),
+						vehicle.EngineIdleSpeed, 
+						vehicle.Components.GearboxInputData.Type, 
+						vehicle.Components.GearboxInputData.Gears.Count);
 
-				return simulationRunData;
 			}
 
+			#endregion
 		}
 
 		public abstract class Hybrid : PrimaryBusBase
@@ -320,6 +307,16 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				throw new NotImplementedException();
 			}
 
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
+				if (vehicle.ArchitectureID.IsOneOf(ArchitectureID.S2, ArchitectureID.S_IEPC)) {
+					throw new ArgumentException(nameof(vehicle.ArchitectureID));
+				}
+				runData.GearshiftParameters = new ShiftStrategyParameters() {
+					StartSpeed = DeclarationData.GearboxTCU.StartSpeed,
+					StartAcceleration = DeclarationData.GearboxTCU.StartAcceleration
+				};
+			}
 		}
 
 
@@ -337,16 +334,27 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 
 			//#endregion
 
-			#region Overrides of PrimaryBusBase
-
-		
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
+				if (vehicle.ArchitectureID != ArchitectureID.E2) {
+					throw new ArgumentException(nameof(vehicle));
+				}
 
-			#endregion
+				runData.GearshiftParameters =
+					DataAdapter.CreateGearshiftData(
+						(runData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (runData.AngledriveData?.Angledrive.Ratio ?? 1.0),
+						null, 
+						vehicle.Components.GearboxInputData.Type,
+						vehicle.Components.GearboxInputData.Gears.Count);
 
-			#region Overrides of PrimaryBusBase
 
+				var shiftStrategyName =
+					PowertrainBuilder.GetShiftStrategyName(vehicle.Components.GearboxInputData.Type,
+						vehicle.VehicleType);
+				runData.GearboxData = DataAdapter.CreateGearboxData(vehicle, runData,
+					ShiftPolygonCalculator.Create(shiftStrategyName, runData.GearshiftParameters));
 
-			#endregion
+			}
 		}
 
 		public class HEV_S3 : SerialHybrid
@@ -374,10 +382,27 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 		{
 			public HEV_S_IEPC(IDeclarationInputDataProvider dataProvider, IDeclarationReport report, IPrimaryBusDeclarationDataAdapter declarationDataAdapter) : base(dataProvider, report, declarationDataAdapter) { }
 
-			#region Overrides of PrimaryBusBase
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
+				if (vehicle.ArchitectureID != ArchitectureID.E2) {
+					throw new ArgumentException(nameof(vehicle));
+				}
+
+				runData.GearshiftParameters =
+					DataAdapter.CreateGearshiftData(
+						(runData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (runData.AngledriveData?.Angledrive.Ratio ?? 1.0),
+						null, 
+						vehicle.Components.GearboxInputData.Type,
+						vehicle.Components.GearboxInputData.Gears.Count);
 
 
-			#endregion
+				var shiftStrategyName =
+					PowertrainBuilder.GetShiftStrategyName(vehicle.Components.GearboxInputData.Type,
+						vehicle.VehicleType);
+				runData.GearboxData = DataAdapter.CreateGearboxData(vehicle, runData,
+					ShiftPolygonCalculator.Create(shiftStrategyName, runData.GearshiftParameters));
+
+			}
 		}
 
 		public abstract class ParallelHybrid : Hybrid
@@ -400,6 +425,22 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				throw new NotImplementedException();
 			}
 
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
+				var shiftStrategyName = PowertrainBuilder.GetShiftStrategyName(vehicle.Components.GearboxInputData.Type, vehicle.VehicleType);
+				
+				runData.GearshiftParameters =
+					DataAdapter.CreateGearshiftData(
+						(runData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (runData.AngledriveData?.Angledrive.Ratio ?? 1.0),
+						vehicle.EngineIdleSpeed,
+						vehicle.Components.GearboxInputData.Type,
+						vehicle.Components.GearboxInputData.Gears.Count);
+				
+				runData.GearboxData = DataAdapter.CreateGearboxData(vehicle, runData,
+					ShiftPolygonCalculator.Create(shiftStrategyName, runData.GearshiftParameters));
+
+			}
+
 		}
 
 		public class HEV_P1 : ParallelHybrid
@@ -484,66 +525,54 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 			protected override VectoRunData CreateVectoRunData(IVehicleDeclarationInputData vehicle, Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading,
 				int? modeIdx = null, VectoRunData.OvcHevMode ovcMode = VectoRunData.OvcHevMode.NotApplicable)
 			{
-				var simulationRunData = CreateCommonRunData(vehicle, mission, loading, _segment);
+				var result = CreateCommonRunData(vehicle, mission, loading, _segment);
 
 
 				DataAdapter.CreateREESSData(
 					componentsElectricStorage: vehicle.Components.ElectricStorage,
 					vehicle.VehicleType,
 					true,
-					(bs) => simulationRunData.BatteryData = bs,
-					(sc) => simulationRunData.SuperCapData = sc);
+					(bs) => result.BatteryData = bs,
+					(sc) => result.SuperCapData = sc);
 
-				simulationRunData.ElectricMachinesData = DataAdapter.CreateElectricMachines(vehicle.Components.ElectricMachines, 
-					vehicle.ElectricMotorTorqueLimits, simulationRunData.BatteryData.CalculateAverageVoltage(), null);
+				result.ElectricMachinesData = DataAdapter.CreateElectricMachines(vehicle.Components.ElectricMachines, 
+					vehicle.ElectricMotorTorqueLimits, result.BatteryData.CalculateAverageVoltage(), null);
 				if (vehicle.VehicleType == VectoSimulationJobType.IEPC_E) {
-					simulationRunData.ElectricMachinesData = DataAdapter.CreateIEPCElectricMachines(vehicle.Components.IEPC,
-						simulationRunData.BatteryData.CalculateAverageVoltage());
+					result.ElectricMachinesData = DataAdapter.CreateIEPCElectricMachines(vehicle.Components.IEPC,
+						result.BatteryData.CalculateAverageVoltage());
 				}
 
-				simulationRunData.VehicleData = DataAdapter.CreateVehicleData(vehicle, _segment, mission, loading, _allowVocational);
-				simulationRunData.AirdragData = DataAdapter.CreateAirdragData(null, mission, new Segment());
-				//EngineData = DataAdapter.CreateEngineData(InputDataProvider.JobInputData.Vehicle, engineMode, mission),
-				simulationRunData.ElectricMachinesData = new List<Tuple<PowertrainPosition, ElectricMotorData>>();
-				simulationRunData.GearboxData = _gearboxData;
+				result.VehicleData = DataAdapter.CreateVehicleData(vehicle, _segment, mission, loading, _allowVocational);
+				result.AirdragData = DataAdapter.CreateAirdragData(null, mission, new Segment());
+				result.ElectricMachinesData = DataAdapter.CreateElectricMachines(vehicle.Components.ElectricMachines, vehicle.ElectricMotorTorqueLimits, result.BatteryData.CalculateAverageVoltage(), null);
+				result.GearboxData = _gearboxData;
 				if (AxleGearRequired() || vehicle.Components.AxleGearInputData != null) {
-					simulationRunData.AxleGearData = _axlegearData;
+					result.AxleGearData = _axlegearData;
 				}
 
-				simulationRunData.AngledriveData = _angledriveData;
-				simulationRunData.Aux = DataAdapter.CreateAuxiliaryData(
+				result.AngledriveData = _angledriveData;
+				result.Aux = DataAdapter.CreateAuxiliaryData(
 					vehicle.Components.AuxiliaryInputData,
 					vehicle.Components.BusAuxiliaries, mission.MissionType, _segment.VehicleClass,
 					vehicle.Length ?? mission.BusParameter.VehicleLength,
 					vehicle.Components.AxleWheels.NumSteeredAxles, vehicle.VehicleType);
-				simulationRunData.Retarder = _retarderData;
-				simulationRunData.DriverData = _driverdata;
-				simulationRunData.GearshiftParameters = _gearshiftData;
+				result.Retarder = _retarderData;
+				result.DriverData = _driverdata;
+				result.GearshiftParameters = _gearshiftData;
 
-				//simulationRunData.EngineData.FuelMode = modeIdx.Value;
-				simulationRunData.VehicleData.VehicleClass = _segment.VehicleClass;
-				simulationRunData.BusAuxiliaries = DataAdapter.CreateBusAuxiliariesData(
-					mission, InputDataProvider.JobInputData.Vehicle, simulationRunData);
-				var shiftStrategyName =
-					PowertrainBuilder.GetShiftStrategyName(vehicle.Components.GearboxInputData.Type,
-						vehicle.VehicleType);
-				simulationRunData.GearboxData = DataAdapter.CreateGearboxData(vehicle, simulationRunData,
-					ShiftPolygonCalculator.Create(shiftStrategyName, simulationRunData.GearshiftParameters));
-				simulationRunData.GearshiftParameters =
-					DataAdapter.CreateGearshiftData(
-						simulationRunData.GearboxData,
-						(simulationRunData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (simulationRunData.AngledriveData?.Angledrive.Ratio ?? 1.0),
-						vehicle.EngineIdleSpeed
-					);
+				result.VehicleData.VehicleClass = _segment.VehicleClass;
+				result.BusAuxiliaries = DataAdapter.CreateBusAuxiliariesData(
+					mission, InputDataProvider.JobInputData.Vehicle, result);
+				CreateGearboxAndGearshiftData(vehicle, result);
 				
-				return simulationRunData;
+				return result;
 			}
 			protected virtual bool AxleGearRequired()
 			{
 				return InputDataProvider.JobInputData.Vehicle.ArchitectureID != ArchitectureID.E4;
 			}
 
-			protected virtual void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
 			{
 				if (vehicle.ArchitectureID == ArchitectureID.E2) {
 					throw new ArgumentException();
@@ -574,9 +603,11 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				}
 
 				runData.GearshiftParameters =
-					DataAdapter.CreateGearshiftData(runData.GearboxData,
-						runData.AxleGearData?.AxleGear.Ratio ?? 1.0,
-						null);
+					DataAdapter.CreateGearshiftData(
+						(runData.AxleGearData?.AxleGear.Ratio ?? 1.0) * (runData.AngledriveData?.Angledrive.Ratio ?? 1.0),
+						null,
+						vehicle.Components.GearboxInputData.Type,
+						vehicle.Components.GearboxInputData.Gears.Count);
 
 
 				var shiftStrategyName =
@@ -643,6 +674,11 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl.DeclarationMode.PrimaryBusRunDa
 				return CreateVectoRunData(vehicle, null, new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>(), 0);
 			}
 
+			protected override void CreateGearboxAndGearshiftData(IVehicleDeclarationInputData vehicle, VectoRunData runData)
+			{
+				throw new NotImplementedException();
+			}
+
 			//protected override IEnumerable<VectoRunData> VectoRunDataHeavyBusPrimary()
 			//{
 			//	yield return new VectoRunData {

VectoCore/VectoCore/InputData/Reader/Impl/DeclarationVTPModeVectoRunDataFactoryHeavyBusPrimary.cs

@@ -77,7 +77,10 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl
             //    DataAdapter.CreatePTOTransmissionData(vehicle.Components.PTOTransmissionInputData);
 
             GearshiftData = DataAdapter.CreateGearshiftData(
-                GearboxData, AxlegearData.AxleGear.Ratio * (AngledriveData?.Angledrive.Ratio ?? 1.0), EngineData.IdleSpeed);
+				AxlegearData.AxleGear.Ratio * (AngledriveData?.Angledrive.Ratio ?? 1.0), 
+				EngineData.IdleSpeed, 
+				vehicle.Components.GearboxInputData.Type,
+				vehicle.Components.GearboxInputData.Gears.Count);
 
             AuxVTP = CreateVTPAuxData(vehicle);
         }
@@ -157,7 +160,7 @@ namespace TUGraz.VectoCore.InputData.Reader.Impl
             });
 
             var busAux = vehicle.Components.BusAuxiliaries;
-            var psCompressor = DeclarationData.BusAuxiliaries.GetCompressorMap(busAux.PneumaticSupply.CompressorSize, busAux.PneumaticSupply.Clutch);
+            var psCompressor = DeclarationData.BusAuxiliaries.GetCompressorMap(busAux.PneumaticSupply);
             retVal.Add(new VectoRunData.AuxData()
             {
                 DemandType = AuxiliaryDemandType.Direct,

VectoCore/VectoCore/Models/Declaration/DeclarationData.cs

@@ -285,8 +285,19 @@ namespace TUGraz.VectoCore.Models.Declaration
 			//	}
 			//}
 
-			public static ICompressorMap GetCompressorMap(string compressorSize, string clutchType)
+			public static ICompressorMap GetCompressorMap(
+				IPneumaticSupplyDeclarationData pneumaticSupply)
 			{
+				var compressorSize = pneumaticSupply.CompressorSize;
+				var clutchType = pneumaticSupply.Clutch;
+
+				if (pneumaticSupply.CompressorDrive == CompressorDrive.electrically) {
+					return null;
+					//var size = GetCompressorResourceForSize("Small");
+					//return CompressorMapReader.ReadStream(
+					//	RessourceHelper.ReadStream(DeclarationDataResourcePrefix + ".VAUXBus." + size), 1, $"{compressorSize} - {clutchType}");
+				}
+
 				var resource = GetCompressorResourceForSize(compressorSize);
 
 				var dragCurveFactorClutch = 1.0;

VectoCore/VectoCoreTest/Reports/ModDataPostprocessingTest.cs

@@ -4,6 +4,7 @@ using System.Data;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using Moq;
 using NUnit.Framework;
 using TUGraz.VectoCommon.BusAuxiliaries;
 using TUGraz.VectoCommon.InputData;
@@ -2826,9 +2827,14 @@ namespace TUGraz.VectoCore.Tests.Reports
 
 		protected PneumaticUserInputsConfig CreatePneumaticUserInputsConfig(bool smartCompressor)
 		{
+			var mock = new Mock<IPneumaticSupplyDeclarationData>();
+			mock.Setup(x => x.CompressorDrive).Returns(CompressorDrive.mechanically);
+			mock.Setup(x => x.CompressorSize).Returns("Medium Supply 2-stage");
+			mock.Setup(x => x.Clutch).Returns("visco");
+
 			return new PneumaticUserInputsConfig() {
 				CompressorMap =
-					DeclarationData.BusAuxiliaries.GetCompressorMap("Medium Supply 2-stage", "visco"),
+					DeclarationData.BusAuxiliaries.GetCompressorMap(mock.Object),
 				CompressorGearEfficiency = Constants.BusAuxiliaries.PneumaticUserConfig.CompressorGearEfficiency,
 				CompressorGearRatio = 1.0,
 				SmartAirCompression = smartCompressor,