fix testcases for AT measured speed: use default TC in case the cycle does not contain engine speed

VectoCore/VectoCore/Models/SimulationComponent/Impl/CycleGearbox.cs

@@ -29,6 +29,7 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
+using System.Linq;
 using TUGraz.VectoCommon.Exceptions;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
@@ -54,7 +55,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		protected bool? TorqueConverterActive;
 
-		protected internal readonly CycleTorqueConverter TorqueConverter;
+		protected internal readonly TorqueConverterWrapper TorqueConverter;
 
 		public CycleGearbox(IVehicleContainer container, VectoRunData runData)
 			: base(container, runData)
@@ -64,7 +65,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 
 			var strategy = new CycleShiftStrategy(ModelData, null);
-			TorqueConverter = new CycleTorqueConverter(container, ModelData.TorqueConverterData);
+
+			
+			TorqueConverter = new TorqueConverterWrapper(runData.Cycle.Entries.All(x => x.EngineSpeed != null),
+				new CycleTorqueConverter(container, ModelData.TorqueConverterData),
+				new TorqueConverter(this, strategy, container, ModelData.TorqueConverterData, runData));
 			if (TorqueConverter == null) {
 				throw new VectoException("Torque Converter required for AT transmission!");
 			}
@@ -536,69 +541,4 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			}
 		}
 	}
-
-	public class CycleTorqueConverter : StatefulVectoSimulationComponent<TorqueConverter.TorqueConverterComponentState>
-	{
-		protected internal ITnOutPort NextComponent;
-		private TorqueConverterData ModelData;
-
-		public CycleTorqueConverter(IVehicleContainer container, TorqueConverterData modelData) : base(container)
-		{
-			ModelData = modelData;
-		}
-
-		public IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity)
-		{
-			
-			var operatingPoint = ModelData.LookupOperatingPoint(outAngularVelocity, inAngularVelocity, outTorque);
-
-			PreviousState.OperatingPoint = operatingPoint;
-			return NextComponent.Initialize(operatingPoint.InTorque, inAngularVelocity);
-		}
-
-		public IResponse Request(
-			Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity,
-			bool dryRun = false)
-		{
-			var operatingPoint = ModelData.LookupOperatingPoint(outAngularVelocity, inAngularVelocity, outTorque);
-			if (!dryRun) {
-				CurrentState.OperatingPoint = operatingPoint;
-			}
-			return NextComponent.Request(absTime, dt, operatingPoint.InTorque, inAngularVelocity, dryRun);
-		}
-
-		public void Locked(
-			NewtonMeter inTorque, PerSecond inAngularVelocity, NewtonMeter outTorque,
-			PerSecond outAngularVelocity) { }
-
-		#region Overrides of VectoSimulationComponent
-
-		protected override void DoWriteModalResults(IModalDataContainer container)
-		{
-			if (CurrentState.OperatingPoint == null) {
-				container[ModalResultField.TorqueConverterTorqueRatio] = 1.0;
-				container[ModalResultField.TorqueConverterSpeedRatio] = 1.0;
-			} else {
-				container[ModalResultField.TorqueConverterTorqueRatio] = CurrentState.OperatingPoint.TorqueRatio;
-				container[ModalResultField.TorqueConverterSpeedRatio] = CurrentState.OperatingPoint.SpeedRatio;
-			}
-			container[ModalResultField.TC_TorqueIn] = CurrentState.InTorque;
-			container[ModalResultField.TC_TorqueOut] = CurrentState.OutTorque;
-			container[ModalResultField.TC_angularSpeedIn] = CurrentState.InAngularVelocity;
-			container[ModalResultField.TC_angularSpeedOut] = CurrentState.OutAngularVelocity;
-
-			var avgOutVelocity = (PreviousState.OutAngularVelocity + CurrentState.OutAngularVelocity) / 2.0;
-			var avgInVelocity = (PreviousState.InAngularVelocity + CurrentState.InAngularVelocity) / 2.0;
-			container[ModalResultField.P_TC_out] = CurrentState.OutTorque * avgOutVelocity;
-			container[ModalResultField.P_TC_loss] = CurrentState.InTorque * avgInVelocity -
-													CurrentState.OutTorque * avgOutVelocity;
-		}
-
-		protected override void DoCommitSimulationStep()
-		{
-			AdvanceState();
-		}
-
-		#endregion
-	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/Impl/CycleTorqueConverter.cs

+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Connector.Ports;
+using TUGraz.VectoCore.Models.Simulation;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
+using TUGraz.VectoCore.OutputData;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
+	public class CycleTorqueConverter : StatefulVectoSimulationComponent<TorqueConverter.TorqueConverterComponentState>
+	{
+		protected internal ITnOutPort NextComponent;
+		private TorqueConverterData ModelData;
+
+		public CycleTorqueConverter(IVehicleContainer container, TorqueConverterData modelData) : base(container)
+		{
+			ModelData = modelData;
+		}
+
+		public IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity)
+		{
+			
+			var operatingPoint = ModelData.LookupOperatingPoint(outAngularVelocity, inAngularVelocity, outTorque);
+
+			PreviousState.OperatingPoint = operatingPoint;
+			return NextComponent.Initialize(operatingPoint.InTorque, inAngularVelocity);
+		}
+
+		public IResponse Request(
+			Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity,
+			bool dryRun = false)
+		{
+			var operatingPoint = ModelData.LookupOperatingPoint(outAngularVelocity, inAngularVelocity, outTorque);
+			if (!dryRun) {
+				CurrentState.OperatingPoint = operatingPoint;
+			}
+			return NextComponent.Request(absTime, dt, operatingPoint.InTorque, inAngularVelocity, dryRun);
+		}
+
+		public void Locked(
+			NewtonMeter inTorque, PerSecond inAngularVelocity, NewtonMeter outTorque,
+			PerSecond outAngularVelocity) { }
+
+		#region Overrides of VectoSimulationComponent
+
+		protected override void DoWriteModalResults(IModalDataContainer container)
+		{
+			if (CurrentState.OperatingPoint == null) {
+				container[ModalResultField.TorqueConverterTorqueRatio] = 1.0;
+				container[ModalResultField.TorqueConverterSpeedRatio] = 1.0;
+			} else {
+				container[ModalResultField.TorqueConverterTorqueRatio] = CurrentState.OperatingPoint.TorqueRatio;
+				container[ModalResultField.TorqueConverterSpeedRatio] = CurrentState.OperatingPoint.SpeedRatio;
+			}
+			container[ModalResultField.TC_TorqueIn] = CurrentState.InTorque;
+			container[ModalResultField.TC_TorqueOut] = CurrentState.OutTorque;
+			container[ModalResultField.TC_angularSpeedIn] = CurrentState.InAngularVelocity;
+			container[ModalResultField.TC_angularSpeedOut] = CurrentState.OutAngularVelocity;
+
+			var avgOutVelocity = (PreviousState.OutAngularVelocity + CurrentState.OutAngularVelocity) / 2.0;
+			var avgInVelocity = (PreviousState.InAngularVelocity + CurrentState.InAngularVelocity) / 2.0;
+			container[ModalResultField.P_TC_out] = CurrentState.OutTorque * avgOutVelocity;
+			container[ModalResultField.P_TC_loss] = CurrentState.InTorque * avgInVelocity -
+													CurrentState.OutTorque * avgOutVelocity;
+		}
+
+		protected override void DoCommitSimulationStep()
+		{
+			AdvanceState();
+		}
+
+		#endregion
+	}
+}
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/Impl/TorqueConverterWrapper.cs

+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Connector.Ports;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
+	public class TorqueConverterWrapper
+	{
+		protected internal CycleTorqueConverter CycleTorqueConverter;
+		protected internal TorqueConverter TorqueConverter;
+		protected bool UseCycleTorqueConverter;
+		
+		public TorqueConverterWrapper(bool useCycle, CycleTorqueConverter cycleTorqueConverter, TorqueConverter torqueConverter)
+		{
+			UseCycleTorqueConverter = useCycle;
+			if (useCycle) {
+				CycleTorqueConverter = cycleTorqueConverter;
+			} else {
+				TorqueConverter = torqueConverter;
+			}
+		}
+
+		public ITnOutPort NextComponent
+		{
+			set {
+				if (UseCycleTorqueConverter) {
+					CycleTorqueConverter.NextComponent = value;
+				} else {
+					TorqueConverter.NextComponent = value;
+				}
+			}
+		}
+
+		public IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity)
+		{
+			return UseCycleTorqueConverter
+				? CycleTorqueConverter.Initialize(outTorque, outAngularVelocity, inAngularVelocity)
+				: TorqueConverter.Initialize(outTorque, outAngularVelocity);
+		}
+
+		public IResponse Request(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, PerSecond inAngularVelocity, bool dryRun = false)
+		{
+			return UseCycleTorqueConverter
+				? CycleTorqueConverter.Request(absTime, dt, outTorque, outAngularVelocity, inAngularVelocity, dryRun)
+				: TorqueConverter.Request(absTime, dt, outTorque, outAngularVelocity, dryRun);
+		}
+
+		public void Locked(NewtonMeter outTorque, PerSecond outAngularVelocity, NewtonMeter inTorque, PerSecond inAngularVelocity)
+		{
+			if (UseCycleTorqueConverter) {
+				CycleTorqueConverter.Locked(outTorque, outAngularVelocity, inTorque, inAngularVelocity);
+			} else {
+				TorqueConverter.Locked(outTorque, outAngularVelocity, inTorque, inAngularVelocity);
+			}
+
+		}
+	}
+}
\ No newline at end of file