using test-powertrain to calculate rating for certain em configurations

VectoCommon/VectoCommon/Models/IResponse.cs

@@ -61,21 +61,23 @@ namespace TUGraz.VectoCommon.Models
 
 	}
 
-	[DebuggerDisplay("n_ice: {EngineSpeed.AsRPM}; T_out: {EngineTorqueDemand}; T_ice: {EngineTorqueDemandTotal}; T_full_dyn: {EngineDynamicFullLoadTorque}; P_full_dyn: {DynamicFullLoadPower}; P_drag: {DragPower}; P_aux: {AuxiliariesPowerDemand}")]
+	[DebuggerDisplay("n_ice: {EngineSpeed.AsRPM}; T_out: {TorqueOutDemand}; T_ice: {TotalTorqueDemand}; T_full_dyn: {DynamicFullLoadTorque}; P_full_dyn: {DynamicFullLoadPower}; P_drag: {DragPower}; P_aux: {AuxiliariesPowerDemand}")]
 
 	public class EngineResponse : AbstractPowertrainComponentResponse
 	{
 		public PerSecond EngineSpeed { get; set; }
 
-		public NewtonMeter EngineTorqueDemand { get; set; }
-		public NewtonMeter EngineTorqueDemandTotal { get; set; }
-		public NewtonMeter EngineDynamicFullLoadTorque { get; set; }
+		public NewtonMeter TorqueOutDemand { get; set; }
+		public NewtonMeter TotalTorqueDemand { get; set; }
+		public NewtonMeter DynamicFullLoadTorque { get; set; }
 
-		public NewtonMeter EngineStationaryFullLoadTorque { get; set; }
+		public NewtonMeter StationaryFullLoadTorque { get; set; }
 
 		public Watt DynamicFullLoadPower { get; set; }
 		public Watt DragPower { get; set; }
 
+		public NewtonMeter DragTorque { get; set; }
+
 		public Watt AuxiliariesPowerDemand { get; set; }
 	}
 

VectoCore/VectoCore/Models/Connector/Ports/Impl/Response.cs

@@ -55,9 +55,27 @@ namespace TUGraz.VectoCore.Models.Connector.Ports.Impl
 			Vehicle = new VehicleResponse();
 			Brakes = new BrakesResponse();
 			ElectricMotor = new ElectricMotorResponse();
+			//ElectricSystem = new
 			TorqueConverter = new TorqueConverterResponse();
 		}
 
+		public AbstractResponse(object source, IResponse subResponse)
+		{
+			Source = source;
+			Driver = subResponse.Driver;
+			Engine = subResponse.Engine;
+			Clutch = subResponse.Clutch;
+			Gearbox = subResponse.Gearbox;
+			Axlegear = subResponse.Axlegear;
+			Angledrive = subResponse.Angledrive;
+			Wheels = subResponse.Wheels;
+			Vehicle = subResponse.Vehicle;
+			Brakes = subResponse.Brakes;
+			ElectricMotor = subResponse.ElectricMotor;
+			ElectricSystem = subResponse.ElectricSystem;
+			TorqueConverter = subResponse.TorqueConverter;
+		}
+
 		public Second AbsTime { get; set; }
 		public Second SimulationInterval { get; set; }
 		public Meter SimulationDistance { get; set; }
@@ -153,6 +171,8 @@ namespace TUGraz.VectoCore.Models.Connector.Ports.Impl
 	{
 		public ResponseDryRun(object source) : base(source) { }
 
+		public ResponseDryRun(object source, IResponse subResponse) : base(source, subResponse) { }
+
 		public Watt DeltaFullLoad { get; set; }
 		public Watt DeltaDragLoad { get; set; }
 		public PerSecond DeltaEngineSpeed { get; set; }

VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs

@@ -349,6 +349,10 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 
 		[ModalResultField(typeof(DrivingBehavior))] drivingBehavior,
 
+		[ModalResultField(typeof(double))] HybridStrategyScore,
+
+		[ModalResultField(typeof(double))]HybridStrategySolution,
+
 		//[ModalResultField(typeof(double), caption: "AA_NonSmartAlternatorsEfficiency [%]")] AA_NonSmartAlternatorsEfficiency,
 		//[ModalResultField(typeof(SI), caption: "AA_SmartIdleCurrent_Amps [A]")] AA_SmartIdleCurrent_Amps,
 		//[ModalResultField(typeof(double), caption: "AA_SmartIdleAlternatorsEfficiency [%]")] AA_SmartIdleAlternatorsEfficiency,

VectoCore/VectoCore/Models/Simulation/DataBus/IClutchInfo.cs

@@ -39,5 +39,7 @@ namespace TUGraz.VectoCore.Models.Simulation.DataBus
 		/// Returns if the clutch is closed in the current interval.
 		/// </summary>
 		bool ClutchClosed(Second absTime);
+
+		Watt ClutchLosses { get; }
 	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/Simulation/DataBus/IElectricMotorInfo.cs

@@ -5,7 +5,7 @@ namespace TUGraz.VectoCore.Models.Simulation.DataBus
 {
 	public interface IElectricMotorInfo
 	{
-		NewtonMeter ElectricDragTorque(PerSecond electricMotorSpeed, Second simulationInterval, DrivingBehavior drivingBehavior);
+		//NewtonMeter ElectricDragTorque(PerSecond electricMotorSpeed, Second simulationInterval, DrivingBehavior drivingBehavior);
 
 		PerSecond ElectricMotorSpeed { get; }
 		PowertrainPosition Position { get; }

VectoCore/VectoCore/Models/Simulation/DataBus/IGearboxInfo.cs

@@ -60,6 +60,10 @@ namespace TUGraz.VectoCore.Models.Simulation.DataBus
 
 		Second LastShift { get; }
 
+		Second LastUpshift { get; }
+
+		Second LastDownshift { get; }
+
 		GearData GetGearData(uint gear);
 
 		/// <summary>

VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs

@@ -384,7 +384,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 
 			ctl.Gearbox = gbx;
 			ctl.Engine = engine;
-
+			
 			// DistanceBasedDrivingCycle --> driver --> vehicle --> wheels 
 			// --> axleGear --> (retarder) --> gearBox --> (retarder) --> clutch --> engine <-- Aux
 			var cycle = new DistanceBasedDrivingCycle(container, data.Cycle);
@@ -423,7 +423,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 				return null;
 			}
 
-			container.ModData.AddElectricMotor(pos);
+			container.ModData?.AddElectricMotor(pos);
 			ctl.AddElectricMotor(pos, motorData.Item2);
 			var motor = new ElectricMotor(container, motorData.Item2, ctl.ElectricMotorControl(pos), pos);
 			motor.Connect(es);
@@ -474,6 +474,70 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 				.AddAuxiliaries(container, data);
 		}
 
+		public void BuildSimpleHybridPowertrain(VectoRunData data, VehicleContainer container)
+		{
+			//if (data.Cycle.CycleType != CycleType.DistanceBased) {
+			//	throw new VectoException("CycleType must be DistanceBased");
+			//}
+
+			var battery = new Battery(container, data.BatteryData);
+			battery.Initialize(data.BatteryData.InitialSoC);
+
+			var es = new ElectricSystem(container);
+			es.Connect(battery);
+
+			var clutch = data.GearboxData.Type.ManualTransmission() ? new SwitchableClutch(container, data.EngineData) : null;
+
+			var gearbox = GetSimpleGearbox(container, data);
+			var gbx = gearbox as IHybridControlledGearbox;
+			if (gbx == null) {
+				throw new VectoException("Gearbox can not be used for parallel hybrid");
+			}
+			var engine = new CombustionEngine(container, data.EngineData);
+
+			var ctl = new SimpleHybridController(container, es, clutch);
+
+			ctl.Gearbox = gbx;
+			ctl.Engine = engine;
+
+			var vehicle = new Vehicle(container, data.VehicleData, data.AirdragData);
+			//var dummyDriver = new Driver(container, data.DriverData, new DefaultDriverStrategy(container));
+			var powertrain = vehicle
+				.AddComponent(new Wheels(container, data.VehicleData.DynamicTyreRadius, data.VehicleData.WheelsInertia))
+				.AddComponent(ctl)
+				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP4, data.ElectricMachinesData, container, es, ctl))
+				.AddComponent(new AxleGear(container, data.AxleGearData))
+				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP3, data.ElectricMachinesData, container, es, ctl))
+				.AddComponent(data.AngledriveData != null ? new Angledrive(container, data.AngledriveData) : null)
+				.AddComponent(gearbox, data.Retarder, container)
+				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP2, data.ElectricMachinesData, container, es, ctl))
+				.AddComponent(clutch)
+				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP1, data.ElectricMachinesData, container, es, ctl));
+			
+			// DistanceBasedDrivingCycle --> driver --> vehicle --> wheels 
+			// --> axleGear --> (retarder) --> gearBox --> (retarder) --> clutch --> engine <-- Aux
+
+			// TODO: MQ 2018-11-19: engineering mode needs AUX power from cycle, use face cycle...
+			//       should be a reference/proxy to the main driving cyle. but how to access it?
+			switch (data.Cycle.CycleType) {
+				case CycleType.DistanceBased:
+					container.AddComponent(new DistanceBasedDrivingCycle(container, data.Cycle));
+					break;
+				case CycleType.MeasuredSpeed:
+					var dummyData = GetMeasuredSpeedDummnCycle();
+					var msCycle = new MeasuredSpeedDrivingCycle(container, dummyData);
+					msCycle.AddComponent(vehicle);
+					break;
+				case CycleType.EngineOnly: break;
+				default: throw new VectoException("Wrong CycleType for SimplePowertrain");
+			}
+			
+			var idleController = GetIdleController(data.PTO, engine, container);
+			//cycle.IdleController = idleController as IdleControllerSwitcher;
+
+			powertrain.AddComponent(engine, idleController)
+				.AddAuxiliaries(container, data);
+		}
 
 		private DrivingCycleData GetMeasuredSpeedDummnCycle()
 		{
@@ -769,6 +833,16 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 			get { throw new VectoException("No Gearbox available."); }
 		}
 
+		public Second LastUpshift
+		{
+			get { throw new VectoException("No Gearbox available."); }
+		}
+
+		public Second LastDownshift
+		{
+			get { throw new VectoException("No Gearbox available."); }
+		}
+
 		public GearData GetGearData(uint gear)
 		{
 			throw new VectoException("No Gearbox available.");

VectoCore/VectoCore/Models/SimulationComponent/Data/Battery/BatteryData.cs

@@ -24,6 +24,8 @@ namespace TUGraz.VectoCore.InputData.Reader.ComponentData {
 		public Ampere MaxCurrent { get; internal set; }
 
 		public double InitialSoC { get; internal set; }
+
+		public double TargetSoC { get; internal set; }
 	}
 
 	public class SOCMap

VectoCore/VectoCore/Models/SimulationComponent/IBattery.cs

@@ -5,7 +5,7 @@ using TUGraz.VectoCore.Models.Simulation.DataBus;
 
 namespace TUGraz.VectoCore.Models.SimulationComponent
 {
-	public interface IElectricSystemInfo : IBatteryInfo
+	public interface IElectricSystemInfo 
 	{
 
 

VectoCore/VectoCore/Models/SimulationComponent/IElectricMotorControl.cs

@@ -22,22 +22,25 @@ namespace TUGraz.VectoCore.Models.SimulationComponent
 			PerSecond prevOutAngularVelocity, PerSecond currOutAngularVelocity,
 			PowertrainPosition position, bool dryRun);
 
-		/// <summary>
-		/// required for electric-only powertrain (i.e., serial hybrids) 
-		/// returns the maximum power the engine may provide (i.e., full-load)
-		/// </summary>
-		/// <param name="avgSpeed"></param>
-		/// <param name="dt"></param>
-		/// <returns>power at full drive, has to be less than 0! </returns>
-		NewtonMeter MaxDriveTorque(PerSecond avgSpeed, Second dt);
 
-		/// <summary>
-		/// required for electric-only powertrain (i.e., serial hybrids)
-		/// returns the maximum power the engine may apply during retardation (i.e., drag-load)
-		/// </summary>
-		/// <param name="avgSpeed"></param>
-		/// <param name="dt"></param>
-		/// <returns>power at full retardation (for current driving situation), has to be greater than 0!</returns>
-		NewtonMeter MaxDragTorque(PerSecond avgSpeed, Second dt);
+		// TODO: MQ 2020-0618 - still needed?
+
+		///// <summary>
+		///// required for electric-only powertrain (i.e., serial hybrids) 
+		///// returns the maximum power the engine may provide (i.e., full-load)
+		///// </summary>
+		///// <param name="avgSpeed"></param>
+		///// <param name="dt"></param>
+		///// <returns>power at full drive, has to be less than 0! </returns>
+		//NewtonMeter MaxDriveTorque(PerSecond avgSpeed, Second dt);
+
+		///// <summary>
+		///// required for electric-only powertrain (i.e., serial hybrids)
+		///// returns the maximum power the engine may apply during retardation (i.e., drag-load)
+		///// </summary>
+		///// <param name="avgSpeed"></param>
+		///// <param name="dt"></param>
+		///// <returns>power at full retardation (for current driving situation), has to be greater than 0!</returns>
+		//NewtonMeter MaxDragTorque(PerSecond avgSpeed, Second dt);
 	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/IHybridControlStrategy.cs

@@ -3,6 +3,7 @@ using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 using TUGraz.VectoCore.Models.SimulationComponent.Strategies;
+using TUGraz.VectoCore.OutputData;
 
 namespace TUGraz.VectoCore.Models.SimulationComponent
 {
@@ -21,5 +22,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent
 		HybridStrategyResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity);
 		void CommitSimulationStep(Second time, Second simulationInterval);
 		IHybridController Controller { set; }
+		void WriteModalResults(Second time, Second simulationInterval, IModalDataContainer container);
 	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/IHybridController.cs

@@ -8,6 +8,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent {
 	{
 		IShiftStrategy ShiftStrategy { get; }
 
+		SimpleComponentState PreviousState { get; }
+
 		IElectricMotorControl ElectricMotorControl(PowertrainPosition pos);
 		void AddElectricMotor(PowertrainPosition pos, ElectricMotorData motorDataItem2);
 		ResponseDryRun RequestDryRun(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, HybridStrategyResponse strategySettings);

VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyACEA.cs

@@ -364,11 +364,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 
 			ResponseDryRun respDriverDemand = null;
-			if (respAccRsv.Engine.EngineTorqueDemandTotal <= respAccRsv.Engine.EngineDynamicFullLoadTorque) {
+			if (respAccRsv.Engine.TotalTorqueDemand <= respAccRsv.Engine.DynamicFullLoadTorque) {
 				respDriverDemand = DriverDemandResponse(gradient, driverAccelerationAvg);
 				
 				var fc = PowertrainConfig.EngineData.Fuels.First().ConsumptionMap.GetFuelConsumption(
-					respDriverDemand.Engine.EngineTorqueDemandTotal.LimitTo(
+					respDriverDemand.Engine.TotalTorqueDemand.LimitTo(
 						PowertrainConfig.EngineData.FullLoadCurves[0].DragLoadStationaryTorque(respAccRsv.Engine.EngineSpeed),
 						PowertrainConfig.EngineData.FullLoadCurves[0].FullLoadStationaryTorque(respAccRsv.Engine.EngineSpeed)),
 					respAccRsv.Engine.EngineSpeed);
@@ -661,19 +661,19 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 
 			var averageAccelerationTorque = AverageAccelerationTorqueLookup.Interpolate(
-				responseDriverDemand.Engine.EngineSpeed, responseDriverDemand.Engine.EngineTorqueDemand);
+				responseDriverDemand.Engine.EngineSpeed, responseDriverDemand.Engine.TorqueOutDemand);
 
 			TestContainerGbx.Gear = gear;
 			var initResponse = TestContainer.VehiclePort.Initialize(vehicleSpeed, estimatedGradient);
-			var delta = initResponse.Engine.EngineTorqueDemand - averageAccelerationTorque;
+			var delta = initResponse.Engine.TorqueOutDemand - averageAccelerationTorque;
 			var acceleration = SearchAlgorithm.Search(
 				0.SI<MeterPerSquareSecond>(), delta, 0.1.SI<MeterPerSquareSecond>(),
-				getYValue: r => { return (r as AbstractResponse).Engine.EngineTorqueDemand - averageAccelerationTorque; },
+				getYValue: r => { return (r as AbstractResponse).Engine.TorqueOutDemand - averageAccelerationTorque; },
 				evaluateFunction: a => {
 					return TestContainer.VehiclePort.Request(
 						0.SI<Second>(), Constants.SimulationSettings.TargetTimeInterval, a, estimatedGradient, true);
 				},
-				criterion: r => { return ((r as AbstractResponse).Engine.EngineTorqueDemand - averageAccelerationTorque).Value(); }
+				criterion: r => { return ((r as AbstractResponse).Engine.TorqueOutDemand - averageAccelerationTorque).Value(); }
 			);
 
 			var engineAcceleration = (acceleration / ratio).Cast<PerSquareSecond>();

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

@@ -86,7 +86,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 			var fcUpshiftPossible = true;
 
-			if (response1.Engine.EngineTorqueDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
+			if (response1.Engine.TorqueOutDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
 				return currentGear;
 			}
 
@@ -169,12 +169,12 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				if (double.IsNaN(fcCurrent)) {
 					//var responseCurrent = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, currentGear);
 					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, currentGear);
-					var tqCurrent = responseCurrent.Engine.EngineTorqueDemandTotal.LimitTo(
+					var tqCurrent = responseCurrent.Engine.TotalTorqueDemand.LimitTo(
 						fld[currentGear].DragLoadStationaryTorque(responseCurrent.Engine.EngineSpeed),
 						fld[currentGear].FullLoadStationaryTorque(responseCurrent.Engine.EngineSpeed));
 					fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, tqCurrent);
 				}
-				var tqNext = response.Engine.EngineTorqueDemandTotal.LimitTo(
+				var tqNext = response.Engine.TotalTorqueDemand.LimitTo(
 					fld[tryNextGear].DragLoadStationaryTorque(response.Engine.EngineSpeed),
 					fld[tryNextGear].FullLoadStationaryTorque(response.Engine.EngineSpeed));
 				var fcNext = GetFCRating(response.Engine.EngineSpeed, tqNext);
@@ -238,7 +238,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				return currentGear;
 			}
 
-			if (response1.Engine.EngineTorqueDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
+			if (response1.Engine.TorqueOutDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
 				return currentGear;
 			}
 
@@ -264,11 +264,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, currentGear);
 
 					//var responseCurrent = RequestDryRunWithGear(absTime, dt, DataBus.VehicleSpeed, DataBus.DriverAcceleration, currentGear);
-					fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, responseCurrent.Engine.EngineTorqueDemand.LimitTo(
+					fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, responseCurrent.Engine.TorqueOutDemand.LimitTo(
 							fld[currentGear].DragLoadStationaryTorque(responseCurrent.Engine.EngineSpeed),
 							fld[currentGear].FullLoadStationaryTorque(responseCurrent.Engine.EngineSpeed)));
 				}
-				var fcNext = GetFCRating(response.Engine.EngineSpeed, response.Engine.EngineTorqueDemand.LimitTo(
+				var fcNext = GetFCRating(response.Engine.EngineSpeed, response.Engine.TorqueOutDemand.LimitTo(
 						fld[tryNextGear].DragLoadStationaryTorque(response.Engine.EngineSpeed),
 						fld[tryNextGear].FullLoadStationaryTorque(response.Engine.EngineSpeed)));
 

VectoCore/VectoCore/Models/SimulationComponent/Impl/ATClutchInfo.cs

@@ -31,6 +31,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
 			return true;
 		}
 
+		public Watt ClutchLosses
+		{
+			get { return 0.SI<Watt>(); }
+		}
+
 		#endregion
 	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/Impl/ATGearbox.cs

@@ -103,6 +103,18 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			TorqueConverter.NextComponent = other;
 		}
 
+		public override Second LastUpshift
+		{
+			get { throw new System.NotImplementedException(); }
+			protected internal set { throw new System.NotImplementedException(); }
+		}
+
+		public override Second LastDownshift
+		{
+			get { throw new System.NotImplementedException(); }
+			protected internal set { throw new System.NotImplementedException(); }
+		}
+
 		public override GearInfo NextGear
 		{
 			get { return _strategy.NextGear; }

VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategy.cs

@@ -514,7 +514,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			var nextTcOutSpeed = gbxOutSpeed * ModelData.Gears[currentGear + 1].TorqueConverterRatio;
 			
 			var tcNext = ModelData.TorqueConverterData.LookupOperatingPointOut(
-				nextTcOutSpeed, response.Engine.EngineSpeed, response.Engine.EngineTorqueDemand);
+				nextTcOutSpeed, response.Engine.EngineSpeed, response.Engine.TorqueOutDemand);
 			var tcLossesNextGear = tcNext.InAngularVelocity * tcNext.InTorque - tcNext.OutAngularVelocity * tcNext.OutTorque;
 			var deltaTcLosses = tcLossesNextGear - tcLossesCurrentGear;
 

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

@@ -187,7 +187,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			var _accMin = (accPower / DataBus.VehicleInfo.VehicleSpeed / (MaxMass + DataBus.WheelsInfo.ReducedMassWheels)).Cast<MeterPerSquareSecond>();
 			var _accMax = (accPower / DataBus.VehicleInfo.VehicleSpeed / (MinMass + DataBus.WheelsInfo.ReducedMassWheels)).Cast<MeterPerSquareSecond>();
 
-			var engineLoadPercent = inTorque / response.Engine.EngineDynamicFullLoadTorque;
+			var engineLoadPercent = inTorque / response.Engine.DynamicFullLoadTorque;
 			var _loadStage = GetLoadStage(engineLoadPercent);
 
 			var shiftSpeed = UpshiftLineTCLocked.LookupShiftSpeed(
@@ -239,7 +239,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			if (DataBus.DriverInfo.DriverAcceleration < 0) {
 				return null;
 			}
-			if (response1.Engine.EngineTorqueDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
+			if (response1.Engine.TorqueOutDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
 				return null;
 			}
 
@@ -331,12 +331,12 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 					//	absTime, dt, vehicleSpeedForGearRating, DataBus.DriverAcceleration, current);
 					//var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, current);
 					var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorqueEst, outAngularVelocityEst, current);
-					var tqCurrent = responseCurrent.Engine.EngineTorqueDemand.LimitTo(
+					var tqCurrent = responseCurrent.Engine.TorqueOutDemand.LimitTo(
 						fld[currentGear].DragLoadStationaryTorque(responseCurrent.Engine.EngineSpeed),
 						fld[currentGear].FullLoadStationaryTorque(responseCurrent.Engine.EngineSpeed));
 					fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, tqCurrent);
 				}
-				var tqNext = response.Engine.EngineTorqueDemand.LimitTo(
+				var tqNext = response.Engine.TorqueOutDemand.LimitTo(
 					fld[next.Gear].DragLoadStationaryTorque(response.Engine.EngineSpeed),
 					fld[next.Gear].FullLoadStationaryTorque(response.Engine.EngineSpeed));
 				var fcNext = GetFCRating(response.Engine.EngineSpeed, tqNext);
@@ -379,7 +379,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, NewtonMeter origInTorque,
 			PerSecond origInAngularVelocity, uint currentGear, Second lastShiftTime, IResponse response1)
 		{
-			if (response1.Engine.EngineTorqueDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
+			if (response1.Engine.TorqueOutDemand.IsSmaller(DeclarationData.GearboxTCU.DragMarginFactor * fld[currentGear].DragLoadStationaryTorque(response1.Engine.EngineSpeed))) {
 				return null;
 			}
 
@@ -417,11 +417,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				if (!IsAboveUpShiftCurve(next.Gear, inTorque, inAngularVelocity, next.TorqueConverterLocked.Value)) {
 					if (double.IsNaN(fcCurrent)) {
 						var responseCurrent = RequestDryRunWithGear(absTime, dt, outTorque, outAngularVelocity, current);
-						fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, responseCurrent.Engine.EngineTorqueDemand.LimitTo(
+						fcCurrent = GetFCRating(responseCurrent.Engine.EngineSpeed, responseCurrent.Engine.TorqueOutDemand.LimitTo(
 								fld[currentGear].DragLoadStationaryTorque(responseCurrent.Engine.EngineSpeed),
 								fld[currentGear].FullLoadStationaryTorque(responseCurrent.Engine.EngineSpeed)));
 					}
-					var fcNext = GetFCRating(response.Engine.EngineSpeed, response.Engine.EngineTorqueDemand.LimitTo(
+					var fcNext = GetFCRating(response.Engine.EngineSpeed, response.Engine.TorqueOutDemand.LimitTo(
 							fld[next.Gear].DragLoadStationaryTorque(response.Engine.EngineSpeed),
 							fld[next.Gear].FullLoadStationaryTorque(response.Engine.EngineSpeed)));
 

VectoCore/VectoCore/Models/SimulationComponent/Impl/ATShiftStrategyVoith.cs

@@ -173,7 +173,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			_accMax = (accPower / DataBus.VehicleInfo.VehicleSpeed / (MinMass + DataBus.WheelsInfo.ReducedMassWheels)).Cast<MeterPerSquareSecond>();
 
 			//var engineLoadPercent = inTorque / FullLoadCurve.FullLoadStationaryTorque(inAngularVelocity);
-			var engineLoadPercent = inTorque / response.Engine.EngineDynamicFullLoadTorque;
+			var engineLoadPercent = inTorque / response.Engine.DynamicFullLoadTorque;
 			_loadStage = GetLoadStage(engineLoadPercent);
 
 			return base.ShiftRequired(

VectoCore/VectoCore/Models/SimulationComponent/Impl/AbstractGearbox.cs

@@ -110,6 +110,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		public virtual Second LastShift { get; protected set; }
 
+		public abstract Second LastUpshift { get; protected internal set; }
+
+		public abstract Second LastDownshift { get; protected internal set; }
+
 		public GearData GetGearData(uint gear)
 		{
 			return ModelData.Gears[gear];