adaptations to effshift algorithms

VectoCore/VectoCore/Models/Declaration/DeclarationData.cs

@@ -203,7 +203,7 @@ namespace TUGraz.VectoCore.Models.Declaration
 
 			public static readonly MeterPerSquareSecond DriverAccelerationThresholdLow = 0.1.SI<MeterPerSquareSecond>();
 			public static double VelocityDropFactor = 0.0;
-			public static double AccelerationFactor = 0.5;
+			public static double AccelerationFactor = 1.0;
 
 			public const double RatioEarlyUpshiftFC = 24;
 			public const double RatioEarlyDownshiftFC = 24;

VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyOptimized.cs

@@ -26,18 +26,22 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		private SimplePowertrainContainer TestContainer;
 		private Gearbox TestContainerGbx;
 
-		protected readonly VelocityRollingLookup VelocityDropData;
+		//protected readonly VelocityRollingLookup VelocityDropData;
 		private AccelerationCurveData accCurve;
 
+		private Kilogram vehicleMass;
+
 		public AMTShiftStrategyOptimized(VectoRunData runData, IVehicleContainer dataBus) : base(runData, dataBus)
 		{
 			if (runData.EngineData == null) {
 				return;
 			}
+
 			fcMap = runData.EngineData.ConsumptionMap;
 			fld = runData.EngineData.FullLoadCurves;
 			shiftStrategyParameters = runData.GearshiftParameters;
 			accCurve = runData.DriverData.AccelerationCurve;
+			vehicleMass = runData.VehicleData.TotalVehicleMass;
 			if (shiftStrategyParameters == null) {
 				throw new VectoException("Parameters for shift strategy missing!");
 			}
@@ -52,13 +56,12 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 
 			// register pre-processors
-			var maxG = runData.Cycle.Entries.Max(x => Math.Abs(x.RoadGradientPercent.Value())) + 1;
-			var grad = Convert.ToInt32(maxG / 2) * 2;
-
-			VelocityDropData = new VelocityRollingLookup();
-			dataBus.AddPreprocessor(
-				new VelocitySpeedGearshiftPreprocessor(VelocityDropData, runData.GearboxData.TractionInterruption, TestContainer, -grad, grad, 2));
+			//var maxG = runData.Cycle.Entries.Max(x => Math.Abs(x.RoadGradientPercent.Value())) + 1;
+			//var grad = Convert.ToInt32(maxG / 2) * 2;
 
+			//VelocityDropData = new VelocityRollingLookup();
+			//dataBus.AddPreprocessor(
+			//	new VelocitySpeedGearshiftPreprocessor(VelocityDropData, runData.GearboxData.TractionInterruption, TestContainer, -grad, grad, 2));
 
 			if (shiftStrategyParameters.AllowedGearRangeFC > 2 || shiftStrategyParameters.AllowedGearRangeFC < 1) {
 				Log.Warn("Gear-range for FC-based gearshift must be either 1 or 2!");
@@ -77,23 +80,24 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 			var fcUpshiftPossible = true;
 
-			var estimatedVelocityPostShift = VelocityDropData.Interpolate(DataBus.VehicleSpeed, DataBus.RoadGradient);
-			var vDrop = DataBus.VehicleSpeed - estimatedVelocityPostShift;
-			var vehicleSpeedForGearRating = DataBus.VehicleSpeed - vDrop * shiftStrategyParameters.VelocityDropFactor;
+			//var estimatedVelocityPostShift = VelocityDropData.Interpolate(DataBus.VehicleSpeed, DataBus.RoadGradient);
+			//var vDrop = DataBus.VehicleSpeed - estimatedVelocityPostShift;
+			//var vehicleSpeedForGearRating = DataBus.VehicleSpeed - vDrop * shiftStrategyParameters.VelocityDropFactor;
 
 			var totalTransmissionRatio = DataBus.EngineSpeed / DataBus.VehicleSpeed;
 
 			for (var i = 1; i <= shiftStrategyParameters.AllowedGearRangeFC; i++) {
 				var tryNextGear = (uint)(currentGear + i);
 
-				if (tryNextGear > ModelData.Gears.Keys.Max() || !(ModelData.Gears[tryNextGear].Ratio < shiftStrategyParameters.RatioEarlyUpshiftFC)) {
+				if (tryNextGear > ModelData.Gears.Keys.Max() ||
+					!(ModelData.Gears[tryNextGear].Ratio < shiftStrategyParameters.RatioEarlyUpshiftFC)) {
 					continue;
 				}
 
 				fcUpshiftPossible = true;
 
-				var response = RequestDryRunWithGear(absTime, dt, vehicleSpeedForGearRating, DataBus.DriverAcceleration, tryNextGear);
-				//var response = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, tryNextGear);
+				//var response = RequestDryRunWithGear(absTime, dt, vehicleSpeedForGearRating, DataBus.DriverAcceleration, tryNextGear);
+				var response = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, tryNextGear);
 
 				var inAngularVelocity = ModelData.Gears[tryNextGear].Ratio * outAngularVelocity;
 				var inTorque = response.ClutchPowerRequest / inAngularVelocity;
@@ -106,37 +110,48 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 				var fullLoadPower = response.EnginePowerRequest - response.DeltaFullLoad;
 				var reserve = 1 - response.EnginePowerRequest / fullLoadPower;
+
 				//var reserve = 1 - response.EngineTorqueDemandTotal / response.EngineStationaryFullLoadTorque;
 
-				if (reserve < ModelData.TorqueReserve && reserve > -0.1) {
+				if (reserve < ModelData.TorqueReserve /* && reserve > -0.1*/) {
 					//var acc = EstimateAcceleration(outAngularVelocity, outTorque);
 
-					//var estimatedEngineSpeed = vehicleSpeedForGearRating * (totalTransmissionRatio / ModelData.Gears[currentGear].Ratio * ModelData.Gears[tryNextGear].Ratio);
-					var accelerationFactor = outAngularVelocity * ModelData.Gears[currentGear].Ratio < fld[0].NTq98hSpeed ?
-						1.0 :
-						VectoMath.Interpolate(fld[0].NTq98hSpeed, fld[0].NP98hSpeed, 1.0, shiftStrategyParameters.AccelerationFactor, outAngularVelocity * ModelData.Gears[currentGear].Ratio);
-					var minAcc = VectoMath.Min(DataBus.DriverAcceleration, accCurve.Lookup(vehicleSpeedForGearRating).Acceleration * accelerationFactor);
+					//var estimatedEngineSpeed = DataBus.VehicleSpeed * (totalTransmissionRatio / ModelData.Gears[currentGear].Ratio * ModelData.Gears[tryNextGear].Ratio);
+					var accelerationFactor = outAngularVelocity * ModelData.Gears[currentGear].Ratio < fld[0].NTq98hSpeed
+						? 1.0
+						: VectoMath.Interpolate(
+							fld[0].NTq98hSpeed, fld[0].NP98hSpeed, 1.0, shiftStrategyParameters.AccelerationFactor,
+							outAngularVelocity * ModelData.Gears[currentGear].Ratio);
+					if (accelerationFactor.IsEqual(1, 1e-9)) {
+						continue;
+					}
+					//var minAcc = VectoMath.Min(DataBus.DriverAcceleration, accCurve.Lookup(DataBus.VehicleSpeed).Acceleration * accelerationFactor);
 					//var minAcc = DataBus.DriverAcceleration * accelerationFactor;
-					response = RequestDryRunWithGear(absTime, dt, vehicleSpeedForGearRating, minAcc, tryNextGear);
-					//response = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, tryNextGear);
+					//response = RequestDryRunWithGear(absTime, dt, vehicleSpeedForGearRating, minAcc, tryNextGear);
+					var accelerationTorque = vehicleMass * DataBus.DriverAcceleration * DataBus.VehicleSpeed / outAngularVelocity;
+					var reducedTorque = outTorque - accelerationTorque * (1 - accelerationFactor);
+
+					response = RequestDryRunWithGear(absTime, dt, reducedTorque, outAngularVelocity, tryNextGear);
 					fullLoadPower = response.EnginePowerRequest - response.DeltaFullLoad;
 					reserve = 1 - response.EnginePowerRequest / fullLoadPower;
 					if (reserve < ModelData.TorqueReserve) {
 						continue;
 					} else {
-						Log.Error("foo");
+						//Log.Error("foo");
 					}
 				}
 
 				if (fcCurrent == null) {
-					var responseCurrent = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, currentGear);
-					//var responseCurrent = RequestDryRunWithGear(absTime, dt,outTorque, outAngularVelocity, currentGear);
+					//var responseCurrent = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, currentGear);
+					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, currentGear);
 					var tqCurrent = responseCurrent.EngineTorqueDemandTotal.LimitTo(
 						fld[currentGear].DragLoadStationaryTorque(responseCurrent.EngineSpeed),
 						fld[currentGear].FullLoadStationaryTorque(responseCurrent.EngineSpeed));
 					var fcCurRes = fcMap.GetFuelConsumption(tqCurrent, responseCurrent.EngineSpeed, true);
 					if (fcCurRes.Extrapolated) {
-						Log.Warn("EffShift Strategy: Extrapolation of fuel consumption for current gear!n: {1}, Tq: {2}", responseCurrent.EngineSpeed, tqCurrent);
+						Log.Warn(
+							"EffShift Strategy: Extrapolation of fuel consumption for current gear!n: {1}, Tq: {2}",
+							responseCurrent.EngineSpeed, tqCurrent);
 					}
 					fcCurrent = fcCurRes.Value;
 				}
@@ -145,7 +160,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 					fld[tryNextGear].FullLoadStationaryTorque(response.EngineSpeed));
 				var fcNextRes = fcMap.GetFuelConsumption(tqNext, response.EngineSpeed, true);
 				if (fcNextRes.Extrapolated) {
-					Log.Warn("EffShift Strategy: Extrapolation of fuel consumption for gear {0}! n: {1}, Tq: {2}", tryNextGear, response.EngineSpeed, tqNext);
+					Log.Warn(
+						"EffShift Strategy: Extrapolation of fuel consumption for gear {0}! n: {1}, Tq: {2}", tryNextGear,
+						response.EngineSpeed, tqNext);
 				}
 				var fcNext = fcNextRes.Value;
 
@@ -162,7 +179,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				return minFcGear;
 			}
 
-			return fcUpshiftPossible ? currentGear : base.CheckEarlyUpshift(absTime, dt, outTorque, outAngularVelocity, currentGear);
+			return fcUpshiftPossible
+				? currentGear
+				: base.CheckEarlyUpshift(absTime, dt, outTorque, outAngularVelocity, currentGear);
 		}
 
 		protected virtual uint OverdriveUpshift(
@@ -191,7 +210,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 						fld[tryNextGear].DragLoadStationaryTorque(response.EngineSpeed),
 						fld[tryNextGear].FullLoadStationaryTorque(response.EngineSpeed)), response.EngineSpeed);
 
-				if (reserve >= ModelData.TorqueReserve && fcNext.Value.IsSmaller(fcCurrent.Value * shiftStrategyParameters.RatingFactorCurrentGear)) {
+				if (reserve >= ModelData.TorqueReserve &&
+					fcNext.Value.IsSmaller(fcCurrent.Value * shiftStrategyParameters.RatingFactorCurrentGear)) {
 					currentGear = tryNextGear;
 				}
 			}
@@ -228,6 +248,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 				var response = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, tryNextGear);
 
+				//var response = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, tryNextGear);
+
 				var inAngularVelocity = ModelData.Gears[tryNextGear].Ratio * outAngularVelocity;
 				var inTorque = response.ClutchPowerRequest / inAngularVelocity;
 
@@ -235,9 +257,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 					continue;
 				}
 
-				
 				if (fcCurrent == null) {
 					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, currentGear);
+
+					//var responseCurrent = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, currentGear);
 					fcCurrent = fcMap.GetFuelConsumption(
 						responseCurrent.EngineTorqueDemand.LimitTo(
 							fld[currentGear].DragLoadStationaryTorque(responseCurrent.EngineSpeed),
@@ -261,7 +284,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			return minFcGear;
 		}
 
-
 		#endregion
 
 		protected ResponseDryRun RequestDryRunWithGear(
@@ -296,15 +318,20 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			return response;
 		}
 
-		public new static string Name { get { return "AMT - EffShift"; } }
+		public new static string Name
+		{
+			get { return "AMT - EffShift"; }
+		}
 
 		#region Overrides of AMTShiftStrategy
 
 		public override ShiftPolygon ComputeDeclarationShiftPolygon(
-			GearboxType gearboxType, int i, EngineFullLoadCurve engineDataFullLoadCurve, IList<ITransmissionInputData> gearboxGears,
+			GearboxType gearboxType, int i, EngineFullLoadCurve engineDataFullLoadCurve,
+			IList<ITransmissionInputData> gearboxGears,
 			CombustionEngineData engineData, double axlegearRatio, Meter dynamicTyreRadius)
 		{
-			return DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(i, engineDataFullLoadCurve, gearboxGears, engineData, axlegearRatio, dynamicTyreRadius);
+			return DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(
+				i, engineDataFullLoadCurve, gearboxGears, engineData, axlegearRatio, dynamicTyreRadius);
 		}
 
 		#endregion

VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyOptimized.cs

@@ -31,6 +31,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		protected readonly List<GearshiftPosition> GearList;
 
+		private Kilogram vehicleMass;
+
 		public new static string Name
 		{
 			get { return "AT - EffShift"; }
@@ -43,6 +45,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 			fcMap = runData.EngineData.ConsumptionMap;
 			fld = runData.EngineData.FullLoadCurves;
+			vehicleMass = runData.VehicleData.TotalVehicleMass;
 			shiftStrategyParameters = runData.GearshiftParameters;
 			if (shiftStrategyParameters == null) {
 				throw new VectoException("Parameters for shift strategy missing!");
@@ -105,6 +108,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			var current = new GearshiftPosition(currentGear, _gearbox.TorqueConverterLocked);
 			var currentIdx = GearList.IndexOf(current);
 
+			var vDrop = DataBus.DriverAcceleration * DeclarationData.Gearbox.PowershiftShiftTime;
+			var vehicleSpeedForGearRating = DataBus.VehicleSpeed - vDrop * shiftStrategyParameters.VelocityDropFactor;
+
 			for (var i = 1; i <=  shiftStrategyParameters.AllowedGearRangeFC; i++) {
 
 				if (currentIdx + i >= GearList.Count) {
@@ -124,6 +130,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 
 				var response = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, next);
+				//var response = RequestDryRunWithGear(absTime, dt, vehicleSpeedForGearRating, DataBus.DriverAcceleration, next);
 
 				var inAngularVelocity = ModelData.Gears[next.Gear].Ratio * outAngularVelocity;
 				var inTorque = response.EnginePowerRequest / inAngularVelocity;
@@ -137,19 +144,47 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				var fullLoadPower = response.EnginePowerRequest - response.DeltaFullLoad;
 				var reserve = 1 - response.EnginePowerRequest / fullLoadPower;
 
+				if (reserve < ModelData.TorqueReserve) {
+					var accelerationFactor = outAngularVelocity * ModelData.Gears[currentGear].Ratio < fld[0].NTq98hSpeed
+						? 1.0
+						: VectoMath.Interpolate(
+							fld[0].NTq98hSpeed, fld[0].NP98hSpeed, 1.0, shiftStrategyParameters.AccelerationFactor,
+							outAngularVelocity * ModelData.Gears[currentGear].Ratio);
+					if (accelerationFactor.IsEqual(1, 1e-9)) {
+						continue;
+					}
+					var accelerationTorque = vehicleMass * DataBus.DriverAcceleration * DataBus.VehicleSpeed / outAngularVelocity;
+					var reducedTorque = outTorque - accelerationTorque * (1 - accelerationFactor);
+
+					response = RequestDryRunWithGear(absTime, dt, reducedTorque, outAngularVelocity, next);
+					fullLoadPower = response.EnginePowerRequest - response.DeltaFullLoad;
+					reserve = 1 - response.EnginePowerRequest / fullLoadPower;
+					if (reserve < ModelData.TorqueReserve) {
+						continue;
+					}
+				}
+
 				if (fcCurrent == null) {
-					var responseCurrent = RequestDryRunWithGear(
-						absTime, dt, outTorque, outAngularVelocity, current);
-					fcCurrent = fcMap.GetFuelConsumption(
-						responseCurrent.EngineTorqueDemand.LimitTo(
+					//var responseCurrent = RequestDryRunWithGear(
+					//	absTime, dt, vehicleSpeedForGearRating, DataBus.DriverAcceleration, current);
+					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, current);
+					var tqCurrent = responseCurrent.EngineTorqueDemand.LimitTo(
 						fld[currentGear].DragLoadStationaryTorque(responseCurrent.EngineSpeed),
-							fld[currentGear].FullLoadStationaryTorque(responseCurrent.EngineSpeed))
-						, responseCurrent.EngineSpeed).Value;
+						fld[currentGear].FullLoadStationaryTorque(responseCurrent.EngineSpeed));
+					var fcCurrentRes = fcMap.GetFuelConsumption(tqCurrent, responseCurrent.EngineSpeed, true);
+					if (fcCurrentRes.Extrapolated) {
+						Log.Warn("EffShift Strategy: Extrapolation of fuel consumption for current gear!n: {1}, Tq: {2}", responseCurrent.EngineSpeed, tqCurrent);
 					}
-				var fcNext = fcMap.GetFuelConsumption(
-					response.EngineTorqueDemand.LimitTo(
+					fcCurrent = fcCurrentRes.Value;
+				}
+				var tqNext = response.EngineTorqueDemand.LimitTo(
 					fld[next.Gear].DragLoadStationaryTorque(response.EngineSpeed),
-						fld[next.Gear].FullLoadStationaryTorque(response.EngineSpeed)), response.EngineSpeed).Value;
+					fld[next.Gear].FullLoadStationaryTorque(response.EngineSpeed));
+				var fcNextRes = fcMap.GetFuelConsumption(tqNext, response.EngineSpeed, true);
+				if (fcNextRes.Extrapolated) {
+					Log.Warn("EffShift Strategy: Extrapolation of fuel consumption for gear {0}! n: {1}, Tq: {2}", next, response.EngineSpeed, tqNext);
+				}
+				var fcNext = fcNextRes.Value;
 
 				if (reserve < ModelData.TorqueReserve ||
 					!fcNext.IsSmaller(fcCurrent * shiftStrategyParameters.RatingFactorCurrentGear) || !fcNext.IsSmaller(minFc)) {
@@ -259,6 +294,18 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			return response;
 		}
 
+		protected ResponseDryRun RequestDryRunWithGear(Second absTime, Second dt, MeterPerSecond vehicleSpeed, MeterPerSquareSecond acceleration, GearshiftPosition gear)
+		{
+			TestContainerGbx.Disengaged = false;
+			TestContainerGbx.Gear = gear.Gear;
+			TestContainerGbx.TorqueConverterLocked = gear.TorqueConverterLocked.Value;
+
+			TestContainer.VehiclePort.Initialize(vehicleSpeed, DataBus.RoadGradient);
+			var response = (ResponseDryRun)TestContainer.VehiclePort.Request(
+				0.SI<Second>(), dt, acceleration, DataBus.RoadGradient, true);
+			return response;
+		}
+
 		#region Overrides of ATShiftStrategy
 
 		public override ShiftPolygon ComputeDeclarationShiftPolygon(
@@ -275,7 +322,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				var maxDragTorque = engineDataFullLoadCurve.MaxDragTorque * 1.1;
 				var maxTorque = engineDataFullLoadCurve.MaxTorque * 1.1;
 
-				var speed = engineData.FullLoadCurves[0].RatedSpeed / gearboxGears[i].Ratio * gearboxGears[i + 1].Ratio;
+				var speed = engineData.FullLoadCurves[0].NP98hSpeed / gearboxGears[i].Ratio * gearboxGears[i + 1].Ratio;
 
 
 				upshift.Add(new ShiftPolygon.ShiftPolygonEntry(maxDragTorque, speed));

VectoCore/VectoCore/Models/SimulationComponent/Impl/Vehicle.cs

@@ -90,7 +90,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		public IResponse Initialize(MeterPerSecond vehicleSpeed, Radian roadGradient, MeterPerSquareSecond startAcceleration)
 		{
 			//CurrentState.Velocity = vehicleSpeed + startAcceleration * Constants.SimulationSettings.TargetTimeInterval;
-			var vehicleAccelerationForce = DriverAcceleration(startAcceleration)
+			var vehicleAccelerationForce = AccelerationForce(startAcceleration)
 											+ RollingResistance(roadGradient)
 											+
 											AirDragResistance(vehicleSpeed,
@@ -114,7 +114,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 			CurrentState.Distance = PreviousState.Distance + PreviousState.Velocity * dt + acceleration * dt * dt / 2;
 
-			CurrentState.DriverAcceleration = DriverAcceleration(acceleration);
+			CurrentState.DriverAcceleration = AccelerationForce(acceleration);
 			CurrentState.RollingResistance = (PreviousState.Velocity + CurrentState.Velocity).IsEqual(0, 1e-9) ? 0.SI<Newton>() : RollingResistance(gradient);
 			try {
 				CurrentState.AirDragResistance = AirDragResistance(PreviousState.Velocity, CurrentState.Velocity);
@@ -173,7 +173,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			return retVal;
 		}
 
-		protected internal Newton DriverAcceleration(MeterPerSquareSecond accelleration)
+		protected internal Newton AccelerationForce(MeterPerSquareSecond accelleration)
 		{
 			var retVal = ModelData.TotalVehicleMass * accelleration;
 			Log.Debug("DriverAcceleration: {0}", retVal);