diff --git a/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs b/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
index 882d1441f3a5285f93440efa2487758cd736fb55..c447ede96784975785bd5b7d2c2dabc35a414c83 100644
--- a/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
@@ -480,6 +480,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 	{
 		private static ConcurrentDictionary<ModalResultField, ModalResultFieldAttribute> _attributeDictionary =
 			new ConcurrentDictionary<ModalResultField, ModalResultFieldAttribute>();
+
 		public static string GetName(this ModalResultField field)
 		{
 			return GetAttribute(field).Name ?? field.ToString();
diff --git a/VectoCore/VectoCore/Models/Simulation/Data/VectoRunData.cs b/VectoCore/VectoCore/Models/Simulation/Data/VectoRunData.cs
index 3d2659fe3bca7ee6fb56456af1ec7d3415c28e1e..9dcc8106abe58d9e487cd6f037ec8ed83fc7c1e8 100644
--- a/VectoCore/VectoCore/Models/Simulation/Data/VectoRunData.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Data/VectoRunData.cs
@@ -48,6 +48,7 @@ using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Battery;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
 using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+using TUGraz.VectoCore.Models.SimulationComponent.Strategies;
 using TUGraz.VectoCore.OutputData;
 using DriverData = TUGraz.VectoCore.Models.SimulationComponent.Data.DriverData;
 
@@ -157,6 +158,9 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 		[JsonIgnore]
 		public IMultistageVIFInputData MultistageVIFInputData { get; internal set; }
 
+		// container to pass genset data from powertrain to post-processing, not filled by dataadapter/rundatafactory
+		public GenSetData GenSet { get; set; }
+
 		public class AuxData
 		{
 			// ReSharper disable once InconsistentNaming
@@ -175,6 +179,12 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 			public MissionType? MissionType;
 		}
 
+		// container to pass genset data from powertrain to post-processing, not filled by dataadapter/rundatafactory
+		public class GenSetData
+		{
+			public GenSetCharacteristics GenSetCharacteristics { get; set; }
+		}
+
 		public static ValidationResult ValidateRunData(VectoRunData runData, ValidationContext validationContext)
 		{
 			var gearboxData = runData.GearboxData;
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/JobContainer.cs b/VectoCore/VectoCore/Models/Simulation/Impl/JobContainer.cs
index 648327b84a905e71525c555d057443d30527ab8c..75c7e3e7f131c0cf441e6ac640683b87375a9e84 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/JobContainer.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/JobContainer.cs
@@ -349,8 +349,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 				_runsRwLock.EnterWriteLock();
 				//_unfinishedRuns.Remove(runId);
 				_unfinishedRuns.TryRemove(runId, out var tmpVal);
-				if (AllCompletedUnsafe())
-				{
+				if (AllCompletedUnsafe()) {
 					_sumWriter.Finish();
 				}
 			} finally {
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
index 1c27f14908a4ebb072c2273c556e5c8df3ce153f..e00723cf83d4b047f027181bb440e6df3c67693a 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
@@ -59,36 +59,36 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 	/// <summary>
 	/// Provides Methods to build a simulator with a powertrain step by step.
 	/// </summary>
-	public class PowertrainBuilder
+	public static class PowertrainBuilder
 	{
-		private readonly IModalDataContainer _modData;
-		private readonly WriteSumData _sumWriter;
+		//private readonly IModalDataContainer _modData;
+		//private readonly WriteSumData _sumWriter;
 
-		public PowertrainBuilder(IModalDataContainer modData, WriteSumData sumWriter = null)
-		{
-			_modData = modData ?? throw new VectoException("Modal Data Container can't be null");
-			_sumWriter = sumWriter;
-		}
+		//public PowertrainBuilder(IModalDataContainer modData, WriteSumData sumWriter = null)
+		//{
+		//	_modData = modData ?? throw new VectoException("Modal Data Container can't be null");
+		//	_sumWriter = sumWriter;
+		//}
 
-		public IVehicleContainer Build(VectoRunData data)
+		public static IVehicleContainer Build(VectoRunData data, IModalDataContainer modData, WriteSumData sumWriter = null)
 		{
 			switch (data.Cycle.CycleType) {
 				case CycleType.DistanceBased:
 					switch (data.JobType) {
-						case VectoSimulationJobType.ConventionalVehicle: return BuildFullPowertrainConventional(data);
-						case VectoSimulationJobType.ParallelHybridVehicle: return BuildFullPowertrainParallelHybrid(data);
-						case VectoSimulationJobType.SerialHybridVehicle: return BuildFullPowertrainSerialHybrid(data);
-						case VectoSimulationJobType.BatteryElectricVehicle: return BuildFulPowertrainBatteryElectric(data);
-						case VectoSimulationJobType.EngineOnlySimulation: return BuildEngineOnly(data);
-						case VectoSimulationJobType.IEPC_E: return BuildFullPowertrainIEPCE(data);
-						case VectoSimulationJobType.IEPC_S: return BuildFullPowertrainIEPCSerial(data);
+						case VectoSimulationJobType.ConventionalVehicle: return BuildFullPowertrainConventional(data, modData, sumWriter);
+						case VectoSimulationJobType.ParallelHybridVehicle: return BuildFullPowertrainParallelHybrid(data, modData, sumWriter);
+						case VectoSimulationJobType.SerialHybridVehicle: return BuildFullPowertrainSerialHybrid(data, modData, sumWriter);
+						case VectoSimulationJobType.BatteryElectricVehicle: return BuildFulPowertrainBatteryElectric(data, modData, sumWriter);
+						case VectoSimulationJobType.EngineOnlySimulation: return BuildEngineOnly(data, modData, sumWriter);
+						case VectoSimulationJobType.IEPC_E: return BuildFullPowertrainIEPCE(data, modData, sumWriter);
+						case VectoSimulationJobType.IEPC_S: return BuildFullPowertrainIEPCSerial(data, modData, sumWriter);
 						default: throw new ArgumentOutOfRangeException($"Powertrain Builder cannot build Powertrain for JobType: {data.JobType}");
 					}
-				case CycleType.EngineOnly: return BuildEngineOnly(data);
-				case CycleType.PWheel: return BuildPWheel(data);
-				case CycleType.VTP: return BuildVTP(data);
-				case CycleType.MeasuredSpeed: return BuildMeasuredSpeed(data);
-				case CycleType.MeasuredSpeedGear: return BuildMeasuredSpeedGear(data);
+				case CycleType.EngineOnly: return BuildEngineOnly(data, modData, sumWriter);
+				case CycleType.PWheel: return BuildPWheel(data, modData, sumWriter);
+				case CycleType.VTP: return BuildVTP(data, modData, sumWriter);
+				case CycleType.MeasuredSpeed: return BuildMeasuredSpeed(data, modData, sumWriter);
+				case CycleType.MeasuredSpeedGear: return BuildMeasuredSpeedGear(data, modData, sumWriter);
 				default: throw new VectoException("Powertrain Builder cannot build Powertrain for CycleType: {0}", data.Cycle.CycleType);
 			}
 		}
@@ -101,7 +101,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///  └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildEngineOnly(VectoRunData data)
+		private static IVehicleContainer BuildEngineOnly(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.EngineOnly) {
 				throw new VectoException("CycleType must be EngineOnly.");
@@ -139,7 +139,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///     └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildPWheel(VectoRunData data)
+		private static IVehicleContainer BuildPWheel(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.PWheel) {
 				throw new VectoException("CycleType must be PWheel.");
@@ -175,7 +175,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///     └(VTPTruckAuxiliaries or VTPBusAuxiliaries)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildVTP(VectoRunData data)
+		private static IVehicleContainer BuildVTP(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.VTP) {
 				throw new VectoException("CycleType must be VTP.");
@@ -204,7 +204,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			return container;
 		}
 
-		private void AddVTPBusAuxiliaries(VectoRunData data, VehicleContainer container, VTPCombustionEngine engine)
+		private static void AddVTPBusAuxiliaries(VectoRunData data, VehicleContainer container, VTPCombustionEngine engine)
 		{
 			var aux = new EngineAuxiliary(container);
 			foreach (var auxData in data.Aux) {
@@ -232,7 +232,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			engine.Connect(aux.Port());
 		}
 
-		private void AddVTPTruckAuxiliaries(VectoRunData data, VehicleContainer container, VTPCombustionEngine engine)
+		private static void AddVTPTruckAuxiliaries(VectoRunData data, VehicleContainer container, VTPCombustionEngine engine)
 		{
 			var aux = CreateSpeedDependentAuxiliaries(data, container);
 			var engineFan = new EngineFanAuxiliary(data.FanDataVTP.FanCoefficients.Take(3).ToArray(), data.FanDataVTP.FanDiameter);
@@ -271,7 +271,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildMeasuredSpeed(VectoRunData data)
+		private static IVehicleContainer BuildMeasuredSpeed(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.MeasuredSpeed) {
 				throw new VectoException("CycleType must be MeasuredSpeed.");
@@ -311,7 +311,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildMeasuredSpeedGear(VectoRunData data)
+		private static IVehicleContainer BuildMeasuredSpeedGear(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.MeasuredSpeedGear) {
 				throw new VectoException("CycleType must be MeasuredSpeed with Gear.");
@@ -353,7 +353,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///        └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFullPowertrainConventional(VectoRunData data)
+		private static IVehicleContainer BuildFullPowertrainConventional(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -403,7 +403,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///         └(Aux)
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFullPowertrainParallelHybrid(VectoRunData data)
+		private static IVehicleContainer BuildFullPowertrainParallelHybrid(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -527,7 +527,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///        └Engine E2
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFullPowertrainSerialHybrid(VectoRunData data)
+		private static IVehicleContainer BuildFullPowertrainSerialHybrid(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -663,7 +663,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └Engine E2
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFulPowertrainBatteryElectric(VectoRunData data)
+		private static IVehicleContainer BuildFulPowertrainBatteryElectric(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -756,7 +756,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			return container;
 		}
 
-		private IPowerTrainComponent GetPEVPTO(VehicleContainer container, VectoRunData data)
+		private static IPowerTrainComponent GetPEVPTO(VehicleContainer container, VectoRunData data)
 		{
 			if (data.PTO == null) {
 				return null;
@@ -802,7 +802,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		private static Retarder GetRetarder(RetarderType type, RetarderData data, IVehicleContainer container) =>
 			type == data.Type ? new Retarder(container, data.LossMap, data.Ratio) : null;
 
-		private IElectricMotor GetElectricMachine(PowertrainPosition pos, IList<Tuple<PowertrainPosition,
+		private static IElectricMotor GetElectricMachine(PowertrainPosition pos, IList<Tuple<PowertrainPosition,
 				ElectricMotorData>> electricMachinesData, VehicleContainer container, IElectricSystem es, IHybridController ctl)
 		{
 			var motorData = electricMachinesData.FirstOrDefault(x => x.Item1 == pos);
@@ -855,7 +855,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └Engine IEPC
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFullPowertrainIEPCE(VectoRunData data)
+		private static IVehicleContainer BuildFullPowertrainIEPCE(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -940,7 +940,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └Engine IEPC
 		/// </code>
 		/// </summary>
-		private IVehicleContainer BuildFullPowertrainIEPCSerial(VectoRunData data)
+		private static IVehicleContainer BuildFullPowertrainIEPCSerial(VectoRunData data, IModalDataContainer _modData, WriteSumData _sumWriter)
 		{
 			if (data.Cycle.CycleType != CycleType.DistanceBased) {
 				throw new VectoException("CycleType must be DistanceBased");
@@ -1036,7 +1036,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///       └(Aux)
 		/// </code>
 		/// </summary>
-		public void BuildSimplePowertrain(VectoRunData data, IVehicleContainer container)
+		public static void BuildSimplePowertrain(VectoRunData data, IVehicleContainer container)
 		{
 			IVehicle vehicle = new Vehicle(container, data.VehicleData, data.AirdragData);
 			// TODO: MQ 2018-11-19: engineering mode needs AUX power from cycle, use face cycle...
@@ -1085,7 +1085,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///      └Engine E2
 		/// </code>
 		/// </summary>
-		public void BuildSimpleSerialHybridPowertrain(VectoRunData data, VehicleContainer container)
+		public static void BuildSimpleSerialHybridPowertrain(VectoRunData data, VehicleContainer container)
 		{
 			var es = ConnectREESS(data, container);
 			var aux = new ElectricAuxiliary(container);
@@ -1170,7 +1170,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///      └Engine E2
 		/// </code>
 		/// </summary>
-		public void BuildSimpleIEPCHybridPowertrain(VectoRunData data, VehicleContainer container)
+		public static void BuildSimpleIEPCHybridPowertrain(VectoRunData data, VehicleContainer container)
 		{
 			var es = ConnectREESS(data, container);
 			var aux = new ElectricAuxiliary(container);
@@ -1205,7 +1205,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///  └CombustionEngine
 		/// </code>
 		/// </summary>
-		public void BuildSimpleGenSet(VectoRunData data, VehicleContainer container)
+		public static void BuildSimpleGenSet(VectoRunData data, VehicleContainer container)
 		{
 			var es = ConnectREESS(data, container);
 			var ctl = new GensetMotorController(container, es);
@@ -1240,7 +1240,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///         └(Aux)
 		/// </code>
 		/// </summary>
-		public void BuildSimpleHybridPowertrain(VectoRunData data, VehicleContainer container)
+		public static void BuildSimpleHybridPowertrain(VectoRunData data, VehicleContainer container)
 		{
 			var es = ConnectREESS(data, container);
 			var aux = new ElectricAuxiliary(container);
@@ -1331,7 +1331,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 		///      └Electric Motor
 		/// </code>
 		/// </summary>
-		public void BuildSimplePowertrainElectric(VectoRunData data, VehicleContainer container)
+		public static void BuildSimplePowertrainElectric(VectoRunData data, VehicleContainer container)
 		{
 			var es = ConnectREESS(data, container);
 			var aux = new ElectricAuxiliary(container);
@@ -1399,7 +1399,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			return es;
 		}
 
-		private DrivingCycleData GetMeasuredSpeedDummyCycle() =>
+		private static DrivingCycleData GetMeasuredSpeedDummyCycle() =>
 			DrivingCycleDataReader.ReadFromStream((
 				"<t>,<v>,<grad>\n" +
 				"0, 50, 0\n" +
@@ -1506,7 +1506,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			return aux;
 		}
 
-		private EngineAuxiliary CreateSpeedDependentAuxiliaries(VectoRunData data, IVehicleContainer container)
+		private static EngineAuxiliary CreateSpeedDependentAuxiliaries(VectoRunData data, IVehicleContainer container)
 		{
 			var aux = new EngineAuxiliary(container);
 			var auxData = data.Aux.ToArray();
@@ -1517,7 +1517,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			return aux;
 		}
 
-		private void AddSwitchingAux(EngineAuxiliary aux, IModalDataContainer modData, string auxId, VectoRunData.AuxData[] auxData)
+		private static void AddSwitchingAux(EngineAuxiliary aux, IModalDataContainer modData, string auxId, VectoRunData.AuxData[] auxData)
 		{
 			var urban = auxData.First(x => x.ID == auxId && x.MissionType == MissionType.UrbanDelivery);
 			var rural = auxData.First(x => x.ID == auxId && x.MissionType == MissionType.RegionalDelivery);
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/SimulatorFactory/SimulatorFactory.cs b/VectoCore/VectoCore/Models/Simulation/Impl/SimulatorFactory/SimulatorFactory.cs
index bba97fd261a4ea3aa2985af3b7a178bd7d494dff..dda1b99017f0fe9a8bc40588964b722709731f28 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/SimulatorFactory/SimulatorFactory.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/SimulatorFactory/SimulatorFactory.cs
@@ -203,14 +203,11 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory
 					JsonConvert.SerializeObject(data, Formatting.Indented));
 			}
 
-			var builder = new PowertrainBuilder(
-				modContainer, modData => {
-					if (SumData != null) {
-						SumData.Write(modData, JobNumber, current, d);
-					}
-				});
-
-			var run = GetVectoRun(data, builder);
+			var run = GetVectoRun(data, modContainer, modData => {
+				if (SumData != null) {
+					SumData.Write(modData, JobNumber, current, d);
+				}
+			});
 
 			if (Validate) {
 				ValidateVectoRunData(
@@ -241,7 +238,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory
 			}
 		}
 
-		private static VectoRun GetVectoRun(VectoRunData data, PowertrainBuilder builder)
+		private static VectoRun GetVectoRun(VectoRunData data, IModalDataContainer modData, WriteSumData sumWriter)
 		{
 			VectoRun run;
 			switch (data.Cycle.CycleType) {
@@ -249,19 +246,19 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory
 					if ((data.SimulationType & SimulationType.DistanceCycle) == 0) {
 						throw new VectoException("Distance-based cycle can not be simulated in {0} mode", data.SimulationType);
 					}
-					run = new DistanceRun(builder.Build(data));
+					run = new DistanceRun(PowertrainBuilder.Build(data, modData, sumWriter));
 					break;
 				case CycleType.EngineOnly:
 					if ((data.SimulationType & SimulationType.EngineOnly) == 0) {
 						throw new VectoException("Engine-only cycle can not be simulated in {0} mode", data.SimulationType);
 					}
-					run = new TimeRun(builder.Build(data));
+					run = new TimeRun(PowertrainBuilder.Build(data, modData, sumWriter));
 					break;
 				case CycleType.VTP:
 					if ((data.SimulationType & SimulationType.VerificationTest) == 0) {
 						throw new VectoException("VTP-cycle can not be simulated in {0} mode", data.SimulationType);
 					}
-					run = new TimeRun(builder.Build(data));
+					run = new TimeRun(PowertrainBuilder.Build(data, modData, sumWriter));
 					break;
 
 				case CycleType.PWheel:
@@ -270,7 +267,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory
 					if ((data.SimulationType & (SimulationType.PWheel | SimulationType.MeasuredSpeedCycle)) == 0) {
 						throw new VectoException("{1}-cycle can not be simulated in {0} mode", data.SimulationType, data.Cycle.CycleType);
 					}
-					run = new TimeRun(builder.Build(data));
+					run = new TimeRun(PowertrainBuilder.Build(data, modData, sumWriter));
 					break;
 				case CycleType.PTO:
 					throw new VectoException("PTO Cycle can not be used as main cycle!");
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyOptimized.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyOptimized.cs
index dc0a77b3e23a4b7bf0a1548166c9f94bda28a2dc..55b9974e750fb2884874cdaf446cfb27a14ee319 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyOptimized.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyOptimized.cs
@@ -61,10 +61,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		{
 			var runData = dataBus.RunData;
 			// MQ: 2019-11-29 - fuel used here has no effect as this is the modDatacontainer for the test-powertrain only!
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			TestContainer = new SimplePowertrainContainer(runData);
-			builder.BuildSimplePowertrain(runData, TestContainer);
+			PowertrainBuilder.BuildSimplePowertrain(runData, TestContainer);
 			TestContainerGbx = TestContainer.GearboxCtl as Gearbox;
 			if (TestContainerGbx == null) {
 				throw new VectoException("Unknown gearboxtype: {0}", TestContainer.GearboxCtl.GetType().FullName);
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyOptimized.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyOptimized.cs
index da97a2b2c7841ded9b88308bd6a24ca967734e72..472d7b0eccf667a0170d8ea79954c608538ee593 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyOptimized.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyOptimized.cs
@@ -107,11 +107,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		private void InitializeTestContainer(VectoRunData runData)
 		{
 			// fuel list here has no effect as this is the mod-container for the test-powertrain only
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			TestContainer = new SimplePowertrainContainer(runData);
 
-			builder.BuildSimplePowertrain(runData, TestContainer);
+			PowertrainBuilder.BuildSimplePowertrain(runData, TestContainer);
 			TestContainerGbx = TestContainer.GearboxCtl as ATGearbox;
 			if (TestContainerGbx == null) {
 				throw new VectoException("Unknown gearboxtype: {0}", TestContainer.GearboxCtl.GetType().FullName);
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/DefaultDriverStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/DefaultDriverStrategy.cs
index ded3a8981ed33da71043a8cef52596d1fed695e8..c29e39b125985a7d13abd1bc2b1a339ca52f4976 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/DefaultDriverStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/DefaultDriverStrategy.cs
@@ -113,13 +113,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 			if (ADAS.PredictiveCruiseControl != PredictiveCruiseControlType.None) {
 				// create a dummy powertrain for pre-processing and estimations
-				var modData = new ModalDataContainer(data, null, null);
-				var builder = new PowertrainBuilder(modData);
 				var testContainer = new SimplePowertrainContainer(data);
 				if (data.JobType != VectoSimulationJobType.BatteryElectricVehicle && data.JobType != VectoSimulationJobType.SerialHybridVehicle)
-					builder.BuildSimplePowertrain(data, testContainer);
+					PowertrainBuilder.BuildSimplePowertrain(data, testContainer);
 				else {
-					builder.BuildSimplePowertrainElectric(data, testContainer);
+					PowertrainBuilder.BuildSimplePowertrainElectric(data, testContainer);
 				}
 
 				container.AddPreprocessor(new PCCSegmentPreprocessor(testContainer, PCCSegments, data?.DriverData.PCC));
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/PEVAMTShiftStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/PEVAMTShiftStrategy.cs
index 428700872f33cd571cf725a2fe2d417beccca67d..26501658c316471ababf468afa74db57fa85a8fe 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/PEVAMTShiftStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/PEVAMTShiftStrategy.cs
@@ -105,10 +105,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		{
 			var runData = dataBus.RunData;
 			// MQ: 2019-11-29 - fuel used here has no effect as this is the modDatacontainer for the test-powertrain only!
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			TestContainer = new SimplePowertrainContainer(runData);
-			builder.BuildSimplePowertrainElectric(runData, TestContainer);
+			PowertrainBuilder.BuildSimplePowertrainElectric(runData, TestContainer);
 			TestContainerGbx = TestContainer.GearboxCtl as Gearbox;
 			TestContainerBattery = TestContainer.BatteryInfo as Battery;
 			TestContainerBatterySystem = TestContainer.BatteryInfo as BatterySystem;
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
index acb7ca724a6885ac0f2050498047a785b6b0c32d..f752c820dee32c1ebe5c5d32ee99aee228e2f8a6 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
@@ -36,10 +36,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 				grad = 2;
 			}
 
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var testContainer = new SimplePowertrainContainer(runData);
-			builder.BuildSimpleHybridPowertrain(runData, testContainer);
+			PowertrainBuilder.BuildSimpleHybridPowertrain(runData, testContainer);
 
 			return new VelocitySpeedGearshiftPreprocessor(VelocityDropData, runData.GearboxData.TractionInterruption,
 				testContainer, -grad, grad);
@@ -570,10 +568,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 					* x.FuelData.LowerHeatingValueVecto * StrategyParameters.MinICEOnTime).Value());
 
 			// create testcontainer
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var testContainer = new SimplePowertrainContainer(runData);
-			builder.BuildSimpleHybridPowertrain(runData, testContainer);
+			PowertrainBuilder.BuildSimpleHybridPowertrain(runData, testContainer);
 
 			TestPowertrain = new TestPowertrain<T>(testContainer, DataBus);
 
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/SerialHybridStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/SerialHybridStrategy.cs
index e835e31d6ef8bcfeb65165f336de543ae8d2ab5f..995b7b21150e34339e81981217bb4a5c7526618b 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/SerialHybridStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/SerialHybridStrategy.cs
@@ -277,22 +277,20 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 			var minGensetPower = emDtData.EfficiencyData.VoltageLevels.First().FullLoadCurve.MaxPower * StrategyParameters.GensetMinOptPowerFactor;
 
 			GenSetCharacteristics = new GenSetCharacteristics(minGensetPower);
-
+			runData.GenSet = new VectoRunData.GenSetData() { GenSetCharacteristics = GenSetCharacteristics };
 
 			// create testcontainer
-			var modData = new ModalDataContainer(runData, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var testContainer = new SimplePowertrainContainer(runData);
 			if (runData.JobType == VectoSimulationJobType.IEPC_S) {
-				builder.BuildSimpleIEPCHybridPowertrain(runData, testContainer);
+				PowertrainBuilder.BuildSimpleIEPCHybridPowertrain(runData, testContainer);
 			} else {
-				builder.BuildSimpleSerialHybridPowertrain(runData, testContainer);
+				PowertrainBuilder.BuildSimpleSerialHybridPowertrain(runData, testContainer);
 			}
 
 			TestPowertrain = new TestPowertrain<T>(testContainer, DataBus);
 
 			var gensetContainer = new SimplePowertrainContainer(runData);
-			builder.BuildSimpleGenSet(runData, gensetContainer);
+			PowertrainBuilder.BuildSimpleGenSet(runData, gensetContainer);
 			TestGenSet = new TestGenset(gensetContainer, DataBus);
 
 			
diff --git a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
index a201cbe2496c2cf276c83574b9d36b86ba6e2ec2..2a43cc64354cc05baaba5a1e14db4556d5933300 100644
--- a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
@@ -159,15 +159,14 @@ namespace TUGraz.VectoCore.OutputData
 			Data = new ModalResults(false);
 			CurrentRow = Data.NewRow();
 
+			PostProcessingCorrection = GetModDataPostprocessor(runData);
+
 			if (runData.JobType == VectoSimulationJobType.BatteryElectricVehicle ||
 				runData.JobType == VectoSimulationJobType.IEPC_E) {
-				PostProcessingCorrection = new BatteryElectricPostprocessingCorrection();
 				return;
 			}
-
-			PostProcessingCorrection = new ModalDataPostprocessingCorrection();
-
-			var multipleEngineModes = runData.EngineData?.MultipleEngineFuelModes ?? false;
+			
+            var multipleEngineModes = runData.EngineData?.MultipleEngineFuelModes ?? false;
 			var fuels = runData.EngineData?.Fuels ?? new List<CombustionEngineFuelData>();
 			foreach (var fuel in fuels) {
 				var entry = fuel.FuelData;
@@ -199,6 +198,20 @@ namespace TUGraz.VectoCore.OutputData
 
 		}
 
+		protected IModalDataPostProcessor GetModDataPostprocessor(VectoRunData runData)
+		{
+			switch (runData.JobType) {
+				case VectoSimulationJobType.BatteryElectricVehicle:
+				case VectoSimulationJobType.IEPC_E:
+					return new BatteryElectricPostprocessingCorrection();
+				case VectoSimulationJobType.IEPC_S:
+				case VectoSimulationJobType.SerialHybridVehicle:
+					return new SerialHybridModalDataPostprocessingCorrection();
+				default:
+					return new ModalDataPostprocessingCorrection();
+			}
+		}
+
 		public int JobRunId => _runData.JobRunId;
 
 		public string RunName => _runData.JobName;
diff --git a/VectoCore/VectoCore/OutputData/ModalDataPostprocessingCorrection.cs b/VectoCore/VectoCore/OutputData/ModalDataPostprocessingCorrection.cs
index 411fea3308fc5ae7234be802f8a9c011635400e5..e0aa4832bcdedac3fefe2ea5fe2bc21f66e9c994 100644
--- a/VectoCore/VectoCore/OutputData/ModalDataPostprocessingCorrection.cs
+++ b/VectoCore/VectoCore/OutputData/ModalDataPostprocessingCorrection.cs
@@ -3,6 +3,7 @@ using System.Data;
 using System.Linq;
 using TUGraz.VectoCommon.BusAuxiliaries;
 using TUGraz.VectoCommon.Exceptions;
+using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.Models.BusAuxiliaries;
@@ -13,6 +14,88 @@ using TUGraz.VectoCore.Models.SimulationComponent.Data;
 
 namespace TUGraz.VectoCore.OutputData
 {
+	public class SerialHybridModalDataPostprocessingCorrection : ModalDataPostprocessingCorrection
+	{
+
+        protected override void SetReesCorrectionDemand(IModalDataContainer modData, VectoRunData runData,
+            CorrectedModalData r)
+        {
+            var deltaEReess = modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int.GetName());
+            var startSoc = modData.REESSStartSoC();
+            var endSoc = modData.REESSEndSoC();
+            var emEff = 0.0;
+            if (endSoc < startSoc) {
+                var etaReessChg = modData.WorkREESSChargeInternal().Value() / modData.WorkREESSChargeTerminal().Value();
+                emEff = 1.0 / (etaReessChg);
+            }
+            if (endSoc > startSoc) {
+                var etaReessDischg = modData.WorkREESSDischargeTerminal().Value() / modData.WorkREESSDischargeInternal().Value();
+                emEff = etaReessDischg;
+            }
+
+            r.DeltaEReessMech = double.IsNaN(emEff) ? 0.SI<WattSecond>() : -deltaEReess * emEff;
+        }
+
+        protected override FuelConsumptionCorrection SetFuelConsumptionCorrection(IModalDataContainer modData, VectoRunData runData,
+            CorrectedModalData r, IFuelProperties fuel)
+        {
+            var duration = modData.Duration;
+            var distance = modData.Distance;
+            var essParams = runData.DriverData.EngineStopStart;
+            var engFuel = runData.EngineData.Fuels.First(x => x.FuelData.Equals(fuel));
+
+            var fcIceIdle = engFuel.ConsumptionMap.GetFuelConsumptionValue(
+                                            0.SI<NewtonMeter>(),
+                                            runData.EngineData.IdleSpeed) *
+                                        engFuel.FuelConsumptionCorrectionFactor;
+
+            var elPowerGenerated = modData.TimeIntegral<WattSecond>(string.Format(ModalResultField.P_EM_electricMotor_el_.GetCaption(), PowertrainPosition.GEN));
+            var fcGenCharging = modData.TotalFuelConsumption(ModalResultField.FCFinal, fuel);
+            var socCorr = elPowerGenerated.IsEqual(0)
+                ? (runData.GenSet.GenSetCharacteristics.OptimalPoint.FuelConsumption /
+                    runData.GenSet.GenSetCharacteristics.OptimalPoint.ElectricPower).Cast<KilogramPerWattSecond>()
+                : (fcGenCharging / elPowerGenerated).Cast<KilogramPerWattSecond>();
+            var engLine = modData.EngineLineCorrectionFactor(fuel);
+            var comp =
+                runData.BusAuxiliaries?.PneumaticUserInputsConfig.CompressorMap
+                    .Interpolate(runData.EngineData.IdleSpeed);
+
+            var f = new FuelConsumptionCorrection {
+                Fuel = fuel,
+                Distance = distance != null && distance.IsGreater(0) ? distance : null,
+                Duration = duration != null && duration.IsGreater(0) ? duration : null,
+                EngineLineCorrectionFactor = engLine,
+                VehicleLine = modData.VehicleLineSlope(fuel),
+                FcModSum = modData.TotalFuelConsumption(ModalResultField.FCFinal, fuel),
+                FcESS_EngineStart = engLine * modData.WorkEngineStart(),
+
+                FcESS_AuxStandstill_ICEOff = r.EnergyAuxICEOffStandstill_UF * engLine,
+                FcESS_AuxStandstill_ICEOn = r.EnergyAuxICEOnStandstill_UF * engLine +
+                                            fcIceIdle * r.ICEOffTimeStandstill * (1 - r.UtilityFactorStandstill),
+
+                FcESS_AuxDriving_ICEOff = r.EnergyAuxICEOffDriving_UF * engLine,
+                FcESS_AuxDriving_ICEOn = r.EnergyAuxICEOnDriving_UF * engLine +
+                                        fcIceIdle * r.ICEOffTimeDriving * (1 - r.UtilityFactorDriving),
+
+                FcESS_DCDCMissing = r.EnergyDCDCMissing * engLine,
+                FcBusAuxPSAirDemand = engLine * r.WorkBusAuxPSCorr,
+
+                FcBusAuxPSDragICEOffStandstill = comp == null
+                    ? 0.SI<Kilogram>()
+                    : comp.PowerOff * r.ICEOffTimeStandstill * engLine * (1 - essParams.UtilityFactorStandstill),
+                FcBusAuxPSDragICEOffDriving = comp == null
+                    ? 0.SI<Kilogram>()
+                    : comp.PowerOff * r.ICEOffTimeDriving * engLine * (1 - essParams.UtilityFactorDriving),
+                FcREESSSoc = r.DeltaEReessMech * socCorr,
+                FcBusAuxEs = engLine * r.WorkBusAuxESMech,
+                FcWHR = engLine * r.WorkWHR,
+                FcAuxHtr = 0.SI<Kilogram>()
+            };
+
+            return f;
+        }
+    }
+
 	public class ModalDataPostprocessingCorrection : IModalDataPostProcessor
 	{
 		
@@ -80,17 +163,17 @@ namespace TUGraz.VectoCore.OutputData
 			return r;
 		}
 
-		private void SetReesCorrectionDemand(IModalDataContainer modData, VectoRunData runData,
+		protected virtual void SetReesCorrectionDemand(IModalDataContainer modData, VectoRunData runData,
 			CorrectedModalData r)
 		{
-			var em = runData.ElectricMachinesData?.FirstOrDefault();
+			var em = runData.ElectricMachinesData?.FirstOrDefault(x => x.Item1 != PowertrainPosition.GEN);
 			
 			if (em != null) {
 				var deltaEReess = modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int.GetName());
 				var startSoc = modData.REESSStartSoC();
 				var endSoc = modData.REESSEndSoC();
-                var emEff = 0.0;
-                if (endSoc < startSoc) {
+				var emEff = 0.0;
+				if (endSoc < startSoc) {
 					var etaEmChg = modData.ElectricMotorEfficiencyGenerate(em.Item1);
 					var etaReessChg = modData.WorkREESSChargeInternal().Value() / modData.WorkREESSChargeTerminal().Value();
 					emEff = 1.0 / (etaEmChg * etaReessChg);
@@ -107,7 +190,7 @@ namespace TUGraz.VectoCore.OutputData
 			}
 		}
 
-		private static FuelConsumptionCorrection SetFuelConsumptionCorrection(IModalDataContainer modData, VectoRunData runData,
+		protected virtual FuelConsumptionCorrection SetFuelConsumptionCorrection(IModalDataContainer modData, VectoRunData runData,
 			CorrectedModalData r, IFuelProperties fuel)
 		{
 			var duration = modData.Duration;
@@ -163,7 +246,7 @@ namespace TUGraz.VectoCore.OutputData
 			return f;
 		}
 
-		private static void SetAuxHeaterDemand(IModalDataContainer modData, CorrectedModalData r, Second duration)
+		protected virtual void SetAuxHeaterDemand(IModalDataContainer modData, CorrectedModalData r, Second duration)
 		{
 			var engineWasteheatSum = modData.FuelData.Aggregate(
 				0.SI<Joule>(),
@@ -174,7 +257,7 @@ namespace TUGraz.VectoCore.OutputData
 				: modData.AuxHeaterDemandCalc(duration, engineWasteheatSum);
 		}
 
-		private static void SetMissingDCDCEnergy(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
+		protected virtual void SetMissingDCDCEnergy(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
 		{
 			// either case C1, C2a, or C3a
 			var missingDCDCEnergy = modData.TimeIntegral<WattSecond>(ModalResultField.P_DCDC_missing);
@@ -203,7 +286,7 @@ namespace TUGraz.VectoCore.OutputData
 			//}
 		}
 
-		private static void SetBusAuxMissingPSWork(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
+		protected virtual void SetBusAuxMissingPSWork(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
 		{
 			var actuations = new Actuations() {
 				Braking = runData.BusAuxiliaries.Actuations.Braking,
@@ -234,7 +317,7 @@ namespace TUGraz.VectoCore.OutputData
 			r.WorkBusAuxPSCorr = (r.kAir * r.DeltaAir).Cast<WattSecond>();
 		}
 
-		private static void SetMissingEnergyICEOFf(IModalDataContainer modData, CorrectedModalData r)
+		protected virtual void SetMissingEnergyICEOFf(IModalDataContainer modData, CorrectedModalData r)
 		{
 			var entriesAuxICEStandstill = modData.GetValues(x => new {
 				dt = x.Field<Second>(ModalResultField.simulationInterval.GetName()),
@@ -263,7 +346,7 @@ namespace TUGraz.VectoCore.OutputData
 			r.EnergyAuxICEOnDriving = entriesAuxICEDriving.Sum(x => x.P_on * x.dt) ?? 0.SI<WattSecond>();
 		}
 
-		private static void SetWHRWork(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
+		protected virtual void SetWHRWork(IModalDataContainer modData, VectoRunData runData, CorrectedModalData r)
 		{
 			// no post-processing correction for electric WHR for HEV (WHR is connected to REESS in simulation)
 			r.WorkWHREl = (runData.BatteryData != null || runData.SuperCapData != null) && runData.EngineData.WHRType.IsElectrical()
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/MeasuredSpeedModeTest.cs b/VectoCore/VectoCoreTest/Models/Simulation/MeasuredSpeedModeTest.cs
index 478489c4b6ff93a123bf0a4b9f484dc8d7f362d6..2347bc503caef67d8a8ae02ee3b425dd1095b561 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/MeasuredSpeedModeTest.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/MeasuredSpeedModeTest.cs
@@ -277,8 +277,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			};
 
 			// call builder (actual test)
-			var builder = new PowertrainBuilder(new MockModalDataContainer());
-			builder.Build(data);
+			PowertrainBuilder.Build(data, new MockModalDataContainer());
 		}
 
 		/// <summary>
@@ -363,8 +362,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			};
 
 			// call builder (actual test)
-			var builder = new PowertrainBuilder(new MockModalDataContainer());
-			var jobContainer = builder.Build(data);
+			var jobContainer = PowertrainBuilder.Build(data, new MockModalDataContainer());
 		}
 
 		private static void RunJob(string jobFile, string expectedModFile, string actualModFile, string expectedSumFile,
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/PowerTrainBuilderTest.cs b/VectoCore/VectoCoreTest/Models/Simulation/PowerTrainBuilderTest.cs
index 12d8e72d65ace7fc3f5cd9ac6c147646a35303f0..b96aef018182cfa4c73e2b2fb20758362f1e9b8c 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/PowerTrainBuilderTest.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/PowerTrainBuilderTest.cs
@@ -78,10 +78,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			var reader = new EngineeringModeVectoRunDataFactory(engineeringProvider);
 			var runData = reader.NextRun().First();
 
-			var writer = new MockModalDataContainer();
-			var builder = new PowertrainBuilder(writer);
-
-			var powerTrain = builder.Build(runData) as VehicleContainer;
+			var powerTrain = PowertrainBuilder.Build(runData, new MockModalDataContainer()) as VehicleContainer;
 
 			Assert.NotNull(powerTrain);
 			Assert.IsInstanceOf<IVehicleContainer>(powerTrain);
@@ -108,10 +105,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			if (!shouldFail) {
 				var runData = reader.NextRun().First();
 
-				var writer = new MockModalDataContainer();
-				var builder = new PowertrainBuilder(writer);
-
-				var powerTrain = builder.Build(runData) as VehicleContainer;
+				var powerTrain = PowertrainBuilder.Build(runData, new MockModalDataContainer()) as VehicleContainer;
 
 				Assert.NotNull(powerTrain);
 				Assert.IsInstanceOf<IVehicleContainer>(powerTrain);
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs b/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
index 9f02660a5851fb2b012a36c113b346332e61c4d4..304b051c8294fdf6506a8ed370425ac3133f6007 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
@@ -179,8 +179,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			};
 
 			// call builder (actual test)
-			var builder = new PowertrainBuilder(new MockModalDataContainer());
-			var jobContainer = builder.Build(data);
+			var jobContainer = PowertrainBuilder.Build(data, new MockModalDataContainer());
 		}
 
 		/// <summary>
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/SimulationPreprocessingTest.cs b/VectoCore/VectoCoreTest/Models/Simulation/SimulationPreprocessingTest.cs
index c37ea78d34b6c9858bba4ed31d4aba8877c84403..54b39cac2af7e6a28bf466e94d368b1e169f621d 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/SimulationPreprocessingTest.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/SimulationPreprocessingTest.cs
@@ -196,10 +196,8 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 		protected virtual Dictionary<MeterPerSecond, Radian> SimulationRunPreprocessingEcoRoll(IVectoRun run)
 		{
 			var data = run.GetContainer().RunData;
-			var modData = new ModalDataContainer(data, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var simpleContainer = new SimplePowertrainContainer(data);
-			builder.BuildSimplePowertrain(data, simpleContainer);
+			PowertrainBuilder.BuildSimplePowertrain(data, simpleContainer);
 
 			var tmp = new Dictionary<MeterPerSecond, Radian>();
 			var preprocessor = new PCCEcoRollEngineStopPreprocessor(simpleContainer, tmp, 50.KMPHtoMeterPerSecond(), 90.KMPHtoMeterPerSecond());
@@ -220,10 +218,8 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 		protected virtual PCCSegments SimulationRunPreprocessingPCCSegments(IVectoRun run)
 		{
 			var data = run.GetContainer().RunData;
-			var modData = new ModalDataContainer(data, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var simpleContainer = new SimplePowertrainContainer(data);
-			builder.BuildSimplePowertrain(data, simpleContainer);
+			PowertrainBuilder.BuildSimplePowertrain(data, simpleContainer);
 
 			var tmp = new PCCSegments();
 			var preprocessor = new PCCSegmentPreprocessor(simpleContainer, tmp, data.DriverData.PCC);
@@ -292,10 +288,8 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 		protected virtual VelocityRollingLookup SimulationRunPreprocessingVelocityTractionInterruption(IVectoRun run)
 		{
 			var data = run.GetContainer().RunData;
-			var modData = new ModalDataContainer(data, null, null);
-			var builder = new PowertrainBuilder(modData);
 			var simpleContainer = new SimplePowertrainContainer(data);
-			builder.BuildSimplePowertrain(data, simpleContainer);
+			PowertrainBuilder.BuildSimplePowertrain(data, simpleContainer);
 
 			var tmp = new VelocityRollingLookup();
 			var preprocessor = new VelocitySpeedGearshiftPreprocessor(tmp, 1.SI<Second>(), simpleContainer, minGradient: -12, maxGradient: 12);