diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/EfficiencyMap.cs b/VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/EfficiencyMap.cs
index 2876372d97a50db48a154b82a7a588a402f3b0e0..2d0724cb45b025daf0226ab3c0e06ef4d609267b 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/EfficiencyMap.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/EfficiencyMap.cs
@@ -133,7 +133,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data {
 				return 0.SI<NewtonMeter>();
 			}
 			var retVal = SearchAlgorithm.Search(
-				maxEmTorque, elPowerMaxEM.ElectricalPower, maxEmTorque * 0.1,
+				maxEmTorque, elPowerMaxEM.ElectricalPower, maxEmTorque * 0.1 * (maxEmTorque > 0 ? -1 : 1),
 				getYValue: x => {
 					var myX = (EfficiencyResult)x;
 					return myX.ElectricalPower - batPower;
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs
index ba92c1e518fc2a9a1f41efbdfd53482d600782d9..b87419fdc4cdd1c6860c4b91c0333d7b8fcd5d36 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs
@@ -650,8 +650,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				if (outAngularVelocity != null) {
 					throw new VectoException("IdleController can only handle idle requests, i.e. angularVelocity == null!");
 				}
-				if (!outTorque.IsEqual(0, 1e-2)) {
-					throw new VectoException("Torque has to be 0 for idle requests!");
+				if (!outTorque.IsEqual(0, 5e-2)) {
+					throw new VectoException("Torque has to be 0 for idle requests! {0}", outTorque);
 				}
 
 				return DoHandleRequest(absTime, dt, outTorque, outAngularVelocity);
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
index 489f428e104dac02d229c6d2f57f509860b1b5e8..3d44327a70e2005b73436e6d6c258791284b3c39 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
@@ -100,7 +100,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			var electricSystemResponse = ElectricPower.Request(absTime, dt, 0.SI<Watt>(), true);
 			var maxBatPower = electricSystemResponse.MaxPowerDrag;
 
-			var maxBatRecuperationTorque = maxBatPower.IsEqual(0) ? 0.SI<NewtonMeter>() : ModelData.EfficiencyMap.LookupTorque(maxBatPower, avgSpeed, maxEmTorque);
+			var maxBatRecuperationTorque = maxBatPower.IsEqual(0) ? ModelData.DragCurve.Lookup(avgSpeed) : ModelData.EfficiencyMap.LookupTorque(maxBatPower, avgSpeed, maxEmTorque);
 			var maxTorqueRecuperate = VectoMath.Min(maxEmTorque, maxBatRecuperationTorque);
 			return maxTorqueRecuperate < 0 ? null : maxTorqueRecuperate;
 		}
@@ -120,7 +120,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		}
 
 
-		protected virtual IResponse HandleRequest(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, bool dryRun, NewtonMeter maxDriveTorque, NewtonMeter maxRecuperationTorque)
+		protected virtual IResponse HandleRequest(
+			Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, bool dryRun,
+			NewtonMeter maxDriveTorque, NewtonMeter maxRecuperationTorque)
 		{
 
 			var avgSpeed = (PreviousState.OutAngularVelocity + outAngularVelocity) / 2;
@@ -128,6 +130,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				? 0.SI<NewtonMeter>()
 				: Formulas.InertiaPower(outAngularVelocity, PreviousState.OutAngularVelocity, ModelData.Inertia, dt) / avgSpeed;
 			var inTorque = outTorque + inertiaTorqueLoss;
+
 			//var maxDriveTorque = ModelData.FullLoadCurve.FullLoadDriveTorque(avgSpeed);
 			//var maxDragTorque = ModelData.FullLoadCurve.FullGenerationTorque(avgSpeed);
 			if (!dryRun) {
@@ -139,20 +142,27 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				var retVal = ForwardRequest(absTime, dt, inTorque, inTorque, outAngularVelocity, null, dryRun);
 				return retVal;
 			}
-			var eMotorTorque = Control.MechanicalAssistPower(absTime, dt, inTorque, PreviousState.OutAngularVelocity, outAngularVelocity,  maxDriveTorque, maxRecuperationTorque, Position, dryRun);
 
-			if (Position == PowertrainPosition.HybridP2 && !DataBus.GearboxInfo.GearEngaged(absTime)/* && !DataBus.ClutchInfo.ClutchClosed(absTime)*/) {
+			var eMotorTorque = Control.MechanicalAssistPower(
+				absTime, dt, inTorque, PreviousState.OutAngularVelocity, outAngularVelocity, maxDriveTorque, maxRecuperationTorque,
+				Position, dryRun);
+
+			if (Position == PowertrainPosition.HybridP2 &&
+				!DataBus.GearboxInfo.GearEngaged(absTime) /* && !DataBus.ClutchInfo.ClutchClosed(absTime)*/) {
 				// electric motor is between gearbox and clutch, but no gear is engaged...
 				if (eMotorTorque != null) {
 					throw new VectoSimulationException("electric motor cannot provide torque when gearbox and clutch are disengaged");
 				}
+
 				var electricSystemResponse = ElectricPower.Request(absTime, dt, 0.SI<Watt>(), dryRun);
 				if (!dryRun) {
 					if (!(electricSystemResponse is ElectricSystemResponseSuccess)) {
 						throw new VectoException("unexpected response from electric system: {0}", electricSystemResponse);
 					}
+
 					SetState(inTorque, outAngularVelocity);
 				}
+
 				var retVal = NextComponent.Request(absTime, dt, outTorque, outAngularVelocity, dryRun);
 				retVal.ElectricMotor.ElectricMotorPowerMech = 0.SI<Watt>();
 				retVal.ElectricSystem = electricSystemResponse;
@@ -165,6 +175,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				retVal.ElectricMotor.InertiaPowerDemand = inertiaTorqueLoss * avgSpeed;
 				return retVal;
 			}
+
 			//if (eMotorTorque.IsEqual(0, 1e-3))
 			//{
 			//	var electricSystemResponse = ElectricPower.Request(absTime, dt, 0.SI<Watt>(), dryRun);
@@ -175,14 +186,24 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			//	return retVal;
 			//}
 
-			if (!dryRun && !eMotorTorque.IsBetween(maxDriveTorque ?? 0.SI<NewtonMeter>(), maxRecuperationTorque ?? 0.SI<NewtonMeter>())) {
-				throw new VectoException("Invalid operating point provided by strategy! SupportPower: {0}, max Power: {1}, min Power: {2}", eMotorTorque, maxDriveTorque, maxRecuperationTorque);
+			if (!dryRun && !eMotorTorque.IsBetween(
+					maxDriveTorque ?? 0.SI<NewtonMeter>(), maxRecuperationTorque ?? 0.SI<NewtonMeter>())) {
+				throw new VectoException(
+					"Invalid operating point provided by strategy! SupportPower: {0}, max Power: {1}, min Power: {2}", eMotorTorque,
+					maxDriveTorque, maxRecuperationTorque);
 			}
 
+
 			var electricPower = ModelData.EfficiencyMap
-				.LookupElectricPower(avgSpeed, eMotorTorque, DataBus.ExecutionMode != ExecutionMode.Declaration).ElectricalPower;
+										.LookupElectricPower(avgSpeed, eMotorTorque, DataBus.ExecutionMode != ExecutionMode.Declaration)
+										.ElectricalPower;
+
+			if (ModelData.DragCurve.Lookup(avgSpeed).IsEqual(eMotorTorque)) {
+				electricPower = 0.SI<Watt>();
+			}
+		
 
-			var electricSupplyResponse = ElectricPower.Request(absTime, dt, electricPower, dryRun);
+		var electricSupplyResponse = ElectricPower.Request(absTime, dt, electricPower, dryRun);
 			//if (!dryRun && !(electricSupplyResponse is ElectricSystemResponseSuccess) &&
 			//	electricPower > electricSupplyResponse.MaxPowerDrag) {
 			//	// can't charge all power into the battery - probably it's full
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/StopStartCombustionEngine.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/StopStartCombustionEngine.cs
index 23a35b3c886bd9441288df38d73fcaa19ebed4b5..8c646c98591f00692c3266203eae6e775b12bc68 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/StopStartCombustionEngine.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/StopStartCombustionEngine.cs
@@ -90,12 +90,14 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
 					DeltaFullLoad = 0.SI<Watt>(),
 					DeltaDragLoad = 0.SI<Watt>(),
 					Engine = {
-						TotalTorqueDemand = 0.SI<NewtonMeter>(),
-						PowerRequest = 0.SI<Watt>(),
+						TorqueOutDemand = outTorque,
+						PowerRequest = outTorque * outAngularVelocity,
 						DynamicFullLoadPower = 0.SI<Watt>(),
 						DragPower = 0.SI<Watt>(),
 						EngineSpeed = 0.RPMtoRad(),
 						AuxiliariesPowerDemand = 0.SI<Watt>(),
+						TotalTorqueDemand = 0.SI<NewtonMeter>(),
+						DragTorque = 0.SI<NewtonMeter>()
 					},
 					DeltaEngineSpeed = 0.RPMtoRad(),
 				};
@@ -103,6 +105,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
 
 			return new ResponseSuccess(this) {
 				Engine = {
+					TorqueOutDemand = outTorque,
 					PowerRequest = 0.SI<Watt>(),
 					DynamicFullLoadPower = 0.SI<Watt>(),
 					TotalTorqueDemand = 0.SI<NewtonMeter>(),
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
index 4d0ed61c627ba9996641c984d94d8104ba996038..dc4c8445ffe1215d8a0e961c7a49a7f484f267a7 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
@@ -214,7 +214,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 
 				var emPos = ModelData.ElectricMachinesData.First().Item1;
 				var currentGear = !DataBus.GearboxInfo.GearEngaged(absTime)
-					? Controller.ShiftStrategy.NextGear.Gear
+					? 0
 					: (PreviousState.GearboxEngaged
 						? DataBus.GearboxInfo.Gear
 						: Controller.ShiftStrategy.NextGear.Gear);
@@ -270,8 +270,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 				var maxRecuperationResponse = RequestDryRun(
 					absTime, dt, outTorque, outAngularVelocity, currentGear, maxRecuperation);
 
-				if (maxRecuperationResponse.DeltaDragLoad.IsSmaller(0)) {
-					// even with full recuperation (and no braking) the operating point is below the drag curve - use full recuperation
+				if (maxRecuperationResponse.DeltaDragLoad.IsSmaller(0) && 
+					maxRecuperationResponse.ElectricSystem.BatteryPowerDemand.IsBetween(maxRecuperationResponse.ElectricSystem.MaxPowerDrag, maxRecuperationResponse.ElectricSystem.MaxPowerDrive)) {
+					// even with full recuperation (and no braking) the operating point is below the drag curve (and the battery can handle it) - use full recuperation
 					eval.Add(
 						new HybridResultEntry() {
 							ICEOff = !DataBus.EngineInfo.EngineOn,
@@ -303,7 +304,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 								{ emPos, emTq }
 							}
 						};
-						return RequestDryRun(absTime, dt, outTorque, outAngularVelocity, currentGear, cfg);
+						return RequestDryRun(absTime, dt, outTorque, outAngularVelocity, DataBus.GearboxInfo.GearEngaged(absTime) ? currentGear : 0, cfg);
 					},
 					criterion: r => {
 						var response = r as ResponseDryRun;
@@ -389,10 +390,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 			List<HybridResultEntry> eval, Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, bool dryRun,
 			uint currentGear)
 		{
-			var best = eval.Where(x => !double.IsNaN(x.Score)).OrderBy(x => x.Score).FirstOrDefault();
+			var best = eval.Where(x => !double.IsNaN(x.Score) && (x.IgnoreReason & HybridConfigurationIgnoreReason.EngineSpeedTooHigh) == 0).OrderBy(x => x.Score).FirstOrDefault();
 			if (best == null) {
 				best = eval.OrderBy(x => Math.Abs((int)currentGear - x.Gear)).FirstOrDefault(
-					x => !(!x.ICEOff && x.IgnoreReason.InvalidEngineSpeed() && !(x.IgnoreReason.BatteryDemandExceeded())));
+					x => !(!x.ICEOff && x.IgnoreReason.InvalidEngineSpeed() && !(x.IgnoreReason.BatteryDemandExceeded() || (x.IgnoreReason & HybridConfigurationIgnoreReason.BatterySoCTooLow) != 0)));
 				if (best == null /*&& dryRun*/) {
 					var emEngaged = (!ElectricMotorCanPropellDuringTractionInterruption ||
 									(DataBus.GearboxInfo.GearEngaged(absTime) && eval.First().Response.Gearbox.Gear != 0));
@@ -664,16 +665,24 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 				var batEnergyAvailable = (DataBus.BatteryInfo.StoredEnergy - BatteryDischargeEnergyThreshold) / dt;
 				var emDrivePower = -(batEnergyAvailable - ModelData.ElectricAuxDemand);
 				if (maxEmTorque.IsSmaller(0) && (-emDrivePower).IsGreaterOrEqual(maxEmTorque * firstResponse.ElectricMotor.AngularVelocity)) {
+					// maxEmTorque < 0  ==> EM can still propell
+					// (-emDrivePower).IsGreaterOrEqual(maxEmTorque * firstResponse.ElectricMotor.AngularVelocity) ==> power available from battery for driving does not exceed max EM power (otherwise torque lookup may fail) 
 					var emDriveTorque = ModelData.ElectricMachinesData.Where(x => x.Item1 == emPos).First().Item2.EfficiencyMap
 												.LookupTorque(emDrivePower, firstResponse.ElectricMotor.AngularVelocity, maxEmTorque);
-					if (emDriveTorque != null && emDriveTorque.IsBetween(firstResponse.ElectricMotor.MaxRecuperationTorque, firstResponse.ElectricMotor.MaxDriveTorque)) {
+					var emDragTorque = ModelData.ElectricMachinesData.Where(x => x.Item1 == emPos).First().Item2
+												.DragCurve.Lookup(firstResponse.ElectricMotor.AngularVelocity);
+					if (emDriveTorque != null &&
+						emDriveTorque.IsBetween(
+							firstResponse.ElectricMotor.MaxRecuperationTorque, firstResponse.ElectricMotor.MaxDriveTorque) &&
+						!emDriveTorque.IsEqual(emDragTorque, 1.SI<NewtonMeter>())) {
 						var tmp = TryConfiguration(
-							absTime, dt, outTorque, outAngularVelocity, nextGear, emPos, emDriveTorque, emDriveTorque / emTqReq, allowIceOff);
+							absTime, dt, outTorque, outAngularVelocity, nextGear, emPos, emDriveTorque, emDriveTorque / emTqReq,
+							allowIceOff);
 						responses.Add(tmp);
 					}
 				}
 
-				if (ElectricMotorCanPropellDuringTractionInterruption && allowIceOff && DataBus.DriverInfo.DrivingAction != DrivingAction.Brake) {
+				if (ElectricMotorCanPropellDuringTractionInterruption && (allowIceOff || !DataBus.GearboxInfo.GearEngaged(absTime)) /*&& (DataBus.DriverInfo.DrivingAction != DrivingAction.Brake || !DataBus.EngineInfo.EngineOn)*/) {
 					// this means that the EM is between wheels and transmission
 					// search EM Torque that results in 0 torque at ICE out
 					try {
@@ -799,6 +808,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 		private ResponseDryRun RequestDryRun(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, uint nextGear, HybridStrategyResponse cfg)
 		{
 			TestPowertrain.Gearbox.Gear = PreviousState.GearboxEngaged ? DataBus.GearboxInfo.Gear : Controller.ShiftStrategy.NextGear.Gear;
+			TestPowertrain.Gearbox.Disengaged = nextGear == 0;
 			TestPowertrain.Gearbox.DisengageGearbox = nextGear == 0;
 			TestPowertrain.Container.VehiclePort.Initialize(DataBus.VehicleInfo.VehicleSpeed, DataBus.DrivingCycleInfo.RoadGradient ?? 0.SI<Radian>());
 			TestPowertrain.HybridController.ApplyStrategySettings(cfg);
@@ -832,6 +842,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 
 			if (nextGear == 0) {
 				TestPowertrain.Gearbox._nextGear = Controller.ShiftStrategy.NextGear;
+				TestPowertrain.Gearbox.Disengaged = nextGear == 0;
 			}
 
 			//if (!PreviousState.GearboxEngaged) {
@@ -860,7 +871,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 				TestPowertrain.ElectricMotorP2.PreviousState.OutAngularVelocity =
 					DataBus.ElectricMotorInfo(PowertrainPosition.HybridP2).ElectricMotorSpeed;
 			}
-			
+			if (/*nextGear != DataBus.GearboxInfo.Gear && */TestPowertrain.ElectricMotorP3 != null) {
+				TestPowertrain.ElectricMotorP3.PreviousState.OutAngularVelocity =
+					DataBus.ElectricMotorInfo(PowertrainPosition.HybridP3).ElectricMotorSpeed;
+			}
+
 			var retVal = TestPowertrain.HybridController.NextComponent.Request(absTime, dt, outTorque, outAngularVelocity, true);
 
 			return retVal as ResponseDryRun;
@@ -907,21 +922,43 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 			}
 
 			SetBatteryCosts(resp, dt, tmp);
+			var absTime = DataBus.AbsTime; // todo!
+			if (DataBus.GearboxInfo.GearEngaged(absTime)) {
 
-			if (allowIceOff && resp.Engine.TorqueOutDemand.IsEqual(0)) {
-				// no torque from ICE requested, ICE could be turned off
-				tmp.FuelCosts = 0;
-				tmp.ICEOff = true;
-			} else {
-				if (!double.IsNaN(tmp.FuelCosts)) {
-					//if (!allowIceOff || !resp.Engine.TorqueOutDemand.IsEqual(0)) {
+				if (allowIceOff && resp.Engine.TorqueOutDemand.IsEqual(0)) {
+					// no torque from ICE requested, ICE could be turned off
+					tmp.FuelCosts = 0;
+					tmp.ICEOff = true;
+				} else {
+					if (!double.IsNaN(tmp.FuelCosts)) {
+						//if (!allowIceOff || !resp.Engine.TorqueOutDemand.IsEqual(0)) {
 						tmp.FuelCosts = ModelData.EngineData.Fuels.Sum(
 							x => (x.ConsumptionMap.GetFuelConsumptionValue(resp.Engine.TotalTorqueDemand, resp.Engine.EngineSpeed)
 								* x.FuelData.LowerHeatingValueVecto * dt).Value());
-					//}
+
+						//}
+					}
+				}
+			} else {
+				if (!resp.Engine.TorqueOutDemand.IsEqual(0, 1e-3)) {
+					tmp.FuelCosts = double.NaN;
+					tmp.IgnoreReason |= resp.Engine.TorqueOutDemand.IsGreater(0)
+						? HybridConfigurationIgnoreReason.EngineTorqueDemandTooHigh
+						: HybridConfigurationIgnoreReason.EngineTorqueDemandTooLow;
+				}
+				if (allowIceOff && resp.Engine.TorqueOutDemand.IsEqual(0, 1e-3)) {
+					// no torque from ICE requested, ICE could be turned off
+					tmp.FuelCosts = 0;
+					tmp.ICEOff = true;
+				} else {
+					if (!double.IsNaN(tmp.FuelCosts)) {
+						tmp.FuelCosts = ModelData.EngineData.Fuels.Sum(
+							x => (x.ConsumptionMap.GetFuelConsumptionValue(0.SI<NewtonMeter>(), resp.Engine.EngineSpeed)
+								* x.FuelData.LowerHeatingValueVecto * dt).Value());
+					}
 				}
 			}
-			
+
 			var maxSoC = Math.Min(ModelData.BatteryData.MaxSOC, StrategyParameters.MaxSoC);
 			var minSoC = Math.Max(ModelData.BatteryData.MinSOC, StrategyParameters.MinSoC);
 			tmp.SoCPenalty = 1 - Math.Pow((DataBus.BatteryInfo.StateOfCharge - StrategyParameters.TargetSoC) / (0.5 * (maxSoC - minSoC)), 5);
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/TestPowertrain.cs b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/TestPowertrain.cs
index bf5115604393b2ebd5c7ac75f3457a8a92fa95d5..aa4e9d7bd211c072909489e2f6932fb63720e3d3 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Strategies/TestPowertrain.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Strategies/TestPowertrain.cs
@@ -24,6 +24,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies {
 
 		public StopStartCombustionEngine CombustionEngine;
 		public ElectricMotor ElectricMotorP2;
+		public ElectricMotor ElectricMotorP3;
 
 		public TestPowertrain(SimplePowertrainContainer container, IDataBus realContainer)
 		{
@@ -36,6 +37,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies {
 			ElectricMotorP2 = container.ElectricMotors.ContainsKey(PowertrainPosition.HybridP2)
 				? container.ElectricMotors[PowertrainPosition.HybridP2] as ElectricMotor
 				: null;
+			ElectricMotorP3 = container.ElectricMotors.ContainsKey(PowertrainPosition.HybridP3)
+				? container.ElectricMotors[PowertrainPosition.HybridP3] as ElectricMotor
+				: null;
 			if (Gearbox == null) {
 				throw new VectoException("Unknown gearboxtype in TestContainer: {0}", Container.GearboxCtl.GetType().FullName);
 			}
diff --git a/VectoCore/VectoCoreTest/FileIO/JsonReadHybridTest.cs b/VectoCore/VectoCoreTest/FileIO/JsonReadHybridTest.cs
index 330796592c2562b0028283d5d567c9fd7ad647ec..c5a7004c98738116b77a814874c660e15b449f98 100644
--- a/VectoCore/VectoCoreTest/FileIO/JsonReadHybridTest.cs
+++ b/VectoCore/VectoCoreTest/FileIO/JsonReadHybridTest.cs
@@ -125,7 +125,7 @@ namespace TUGraz.VectoCore.Tests.FileIO
 			Assert.NotNull(bat);
 			Assert.AreEqual(2, bat.Count);
 			Assert.AreEqual(50, bat.BatteryPack.MaxCurrentFactor);
-			Assert.AreEqual(0.4986666, ri.Lookup(0.5).Value());
+			Assert.AreEqual(0.04, ri.Lookup(0.5).Value());
 
 			var em = engineering.JobInputData.Vehicle.Components.ElectricMachines;
 
@@ -134,7 +134,7 @@ namespace TUGraz.VectoCore.Tests.FileIO
 
 			Assert.AreEqual(PowertrainPosition.HybridP2, em.Entries[0].Position);
 
-			Assert.AreEqual(0.15, em.Entries[0].ElectricMachine.Inertia.Value());
+			Assert.AreEqual(0.2, em.Entries[0].ElectricMachine.Inertia.Value());
 
 		}
 
diff --git a/VectoCore/VectoCoreTest/Integration/Hybrid/ParallelHybridTest.cs b/VectoCore/VectoCoreTest/Integration/Hybrid/ParallelHybridTest.cs
index c77d1e1d1023bf107598d4b1bef528c446e7fee3..cf7e465fc502c87ef07398268d3a2a9cb9255b21 100644
--- a/VectoCore/VectoCoreTest/Integration/Hybrid/ParallelHybridTest.cs
+++ b/VectoCore/VectoCoreTest/Integration/Hybrid/ParallelHybridTest.cs
@@ -586,7 +586,7 @@ namespace TUGraz.VectoCore.Tests.Integration.Hybrid
 			var sumData = new SummaryDataContainer(fileWriter);
 			var jobContainer = new JobContainer(sumData);
             var container = CreateParallelHybridPowerTrain(
-				cycleData, Path.GetFileNameWithoutExtension(modFileName), initialSoc, largeMotor, sumData, pAuxEl, pos, ratio, payload);
+				cycleData,modFileName, initialSoc, largeMotor, sumData, pAuxEl, pos, ratio, payload);
 			var run = new DistanceRun(container);
 			jobContainer.AddRun(run);
 			return jobContainer;
diff --git a/VectoCore/VectoCoreTest/TestData/Hybrids/GenericVehicle_Group2_P2/HybridStrategyParams.vhctl b/VectoCore/VectoCoreTest/TestData/Hybrids/GenericVehicle_Group2_P2/HybridStrategyParams.vhctl
index d63963762aef28110486aebef05b4c387515dd4a..e38a9d4f64e2f60dcec592f7cab47ebbcb228e7e 100644
--- a/VectoCore/VectoCoreTest/TestData/Hybrids/GenericVehicle_Group2_P2/HybridStrategyParams.vhctl
+++ b/VectoCore/VectoCoreTest/TestData/Hybrids/GenericVehicle_Group2_P2/HybridStrategyParams.vhctl
@@ -9,6 +9,9 @@
     "EquivalenceFactor": 2.5,
     "MinSoC": 20.0,
     "MaxSoC": 80.0,
-    "TargetSoC": 50.0
+    "TargetSoC": 50.0,
+    "MinICEOnTime": 3,
+    "AuxBufferTime": 5,
+    "AuxBufferChgTime":  3 
   }
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/VectoCoreTest.csproj b/VectoCore/VectoCoreTest/VectoCoreTest.csproj
index a632964fb764c137e5d5873aa8002b2151fdd870..3cd4b1e035d3e4c65644bd0f1acf1c3f9125766f 100644
--- a/VectoCore/VectoCoreTest/VectoCoreTest.csproj
+++ b/VectoCore/VectoCoreTest/VectoCoreTest.csproj
@@ -341,6 +341,12 @@
     <None Include="TestData\Hybrids\Battery\GenericBattery.vbat">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Hybrids\Battery\GenericBattery.vbatr">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Hybrids\Battery\GenericBattery.vbatv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Hybrids\Battery\GenericBatteryLarge.vbat">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>