first version of engineIdleController

VectoCore/Models/Connector/Ports/IResponse.cs

@@ -18,6 +18,8 @@ namespace TUGraz.VectoCore.Models.Connector.Ports
 
 		Watt EnginePowerRequest { get; set; }
 
+		Watt AuxiliariesPowerDemand { get; set; }
+
 		Watt ClutchPowerRequest { get; set; }
 
 		Watt GearboxPowerRequest { get; set; }

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

@@ -15,6 +15,8 @@ namespace TUGraz.VectoCore.Models.Connector.Ports.Impl
 
 		public Watt EnginePowerRequest { get; set; }
 
+		public Watt AuxiliariesPowerDemand { get; set; }
+
 		public Watt ClutchPowerRequest { get; set; }
 
 		public Watt GearboxPowerRequest { get; set; }

VectoCore/Models/SimulationComponent/Impl/Auxiliary.cs

@@ -54,7 +54,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			var currentAngularVelocity = angularVelocity ?? DataBus.EngineSpeed;
 			var powerDemand = ComputePowerDemand(currentAngularVelocity);
 
-			return NextComponent.Request(absTime, dt, torque + powerDemand / currentAngularVelocity, angularVelocity, dryRun);
+			var retVal = NextComponent.Request(absTime, dt, torque + powerDemand / currentAngularVelocity, angularVelocity,
+				dryRun);
+			retVal.AuxiliariesPowerDemand = powerDemand;
+			return retVal;
 		}
 
 		private Watt ComputePowerDemand(PerSecond engineSpeed)

VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs

 using System;
 using System.Diagnostics;
+using System.Resources;
 using TUGraz.VectoCore.Configuration;
 using TUGraz.VectoCore.Exceptions;
 using TUGraz.VectoCore.Models.Connector.Ports;
@@ -81,7 +82,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		public ICombustionEngineIdleController IdleController
 		{
-			get { return EngineIdleController ?? new CombustionEngineIdleController(this); }
+			get { return EngineIdleController ?? (EngineIdleController = new CombustionEngineIdleController(this)); }
 		}
 
 		protected CombustionEngineIdleController EngineIdleController { get; set; }
@@ -442,24 +443,67 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		protected class CombustionEngineIdleController : ICombustionEngineIdleController
 		{
+			protected readonly double PeDropSlope = -0.75;
+			protected readonly double PeDropOffset = 1.0;
+
 			protected CombustionEngine Engine;
 
-			protected ITnOutPort OutPort;
+			protected Second IdleStart = null;
+			protected Watt LastEnginePower = null;
 
 			public CombustionEngineIdleController(CombustionEngine combustionEngine)
 			{
 				Engine = combustionEngine;
 			}
 
-			public ITnOutPort RequestPort
-			{
-				set { OutPort = value; }
-			}
+			public ITnOutPort RequestPort { private get; set; }
 
 			public IResponse Request(Second absTime, Second dt, NewtonMeter torque, PerSecond angularVelocity,
 				bool dryRun = false)
 			{
-				throw new NotImplementedException();
+				if (angularVelocity != null) {
+					throw new VectoException("IdleController can only handle idle requests, i.e. angularVelocity == null!");
+				}
+				if (IdleStart == null) {
+					IdleStart = absTime;
+					LastEnginePower = Engine.PreviousState.EnginePower;
+				}
+				IResponse retVal = null;
+
+				var idleTime = absTime - IdleStart + dt;
+				var prevEngineSpeed = Engine.PreviousState.EngineSpeed;
+				var nextEnginePower = ComputeNextEngineSpeed(idleTime, prevEngineSpeed);
+
+				var auxDemandResponse = RequestPort.Request(absTime, dt, torque, prevEngineSpeed, true);
+
+				var deltaEnginePower = nextEnginePower - auxDemandResponse.AuxiliariesPowerDemand;
+				var deltaTorque = deltaEnginePower / prevEngineSpeed;
+				var deltaAngularSpeed = (deltaTorque / Engine.Data.Inertia * dt).Cast<PerSecond>();
+
+				var nextAngularSpeed = prevEngineSpeed;
+				if (deltaAngularSpeed > 0) {
+					retVal = RequestPort.Request(absTime, dt, torque, nextAngularSpeed);
+					return retVal;
+				}
+
+				nextAngularSpeed = prevEngineSpeed + deltaAngularSpeed;
+				if (nextAngularSpeed < Engine.Data.IdleSpeed) {
+					// search for EnginePower such that nextAngularSpeed == Engine.Data.IdleSpeed
+					var tmp = RequestPort.Request(absTime, dt, torque, Engine.Data.IdleSpeed);
+					return tmp;
+					//throw new NotImplementedException("Search for PE s.t. n2 = n_idle");
+				}
+
+				retVal = RequestPort.Request(absTime, dt, torque, nextAngularSpeed);
+				return retVal;
+			}
+
+			protected Watt ComputeNextEngineSpeed(Second idleTime, PerSecond angularVelocity)
+			{
+				var dragLoad = Engine.Data.FullLoadCurve.DragLoadStationaryPower(angularVelocity);
+				var totalPower = LastEnginePower - dragLoad;
+
+				return totalPower * VectoMath.Max(idleTime.Value() * PeDropSlope + PeDropOffset, 0) + dragLoad;
 			}
 
 			public IResponse Initialize(NewtonMeter torque, PerSecond angularVelocity)

VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs

@@ -21,6 +21,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 	[TestClass]
 	public class CombustionEngineTest
 	{
+		protected double Tolerance = 1E-3;
+
 		private const string CoachEngine = @"TestData\Components\24t Coach.veng";
 		public TestContext TestContext { get; set; }
 
@@ -207,7 +209,6 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 
 			var engine = new CombustionEngine(container, engineData);
 			var clutch = new Clutch(container, engineData, engine.IdleController);
-			engine.IdleController.RequestPort = clutch.IdleControlPort;
 
 			var driver = new MockDriver(container);
 
@@ -220,6 +221,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			gearbox.InPort().Connect(clutch.OutPort());
 			clutch.InPort().Connect(aux.OutPort());
 			aux.InPort().Connect(engine.OutPort());
+			engine.IdleController.RequestPort = clutch.IdleControlPort;
 
 //			var expectedResults = VectoCSVFile.Read(TestContext.DataRow["ResultFile"].ToString());
 
@@ -266,6 +268,82 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			Assert.AreEqual(800.RPMtoRad(), row[ModalResultField.n.GetName()]);
 		}
 
+		[TestMethod]
+		public void EngineIdleControllerTest()
+		{
+			var container = new VehicleContainer();
+			var gearbox = new MockGearbox(container);
+			var engineData = EngineeringModeSimulationDataReader.CreateEngineDataFromFile(CoachEngine);
+
+			var engine = new CombustionEngine(container, engineData);
+			var clutch = new Clutch(container, engineData, engine.IdleController);
+
+			var driver = new MockDriver(container);
+
+			var aux = new Auxiliary(container);
+			aux.AddConstant("", 5000.SI<Watt>());
+
+			gearbox.Gear = 1;
+
+			//gearbox.InPort().Connect(engine.OutPort());
+			gearbox.InPort().Connect(clutch.OutPort());
+			clutch.InPort().Connect(aux.OutPort());
+			aux.InPort().Connect(engine.OutPort());
+
+			// has to be done after connecting components!
+			engine.IdleController.RequestPort = clutch.IdleControlPort;
+
+			var requestPort = gearbox.OutPort();
+
+			//vehicleContainer.DataWriter = new ModalDataWriter("engine_idle_test.csv");
+			var dataWriter = new MockModalDataWriter();
+			container.DataWriter = dataWriter;
+
+			var absTime = 0.SI<Second>();
+			var dt = Constants.SimulationSettings.TargetTimeInterval;
+
+			var angularVelocity = 800.RPMtoRad();
+			var torque = 100000.SI<Watt>() / angularVelocity;
+
+			var response = requestPort.Initialize(torque, angularVelocity);
+			Assert.IsInstanceOfType(response, typeof(ResponseSuccess));
+
+			response = requestPort.Request(absTime, dt, torque, angularVelocity);
+			Assert.IsInstanceOfType(response, typeof(ResponseSuccess));
+			Assert.AreEqual(105000, response.EnginePowerRequest.Value(), Tolerance);
+			container.CommitSimulationStep(absTime, dt);
+			absTime += dt;
+
+			// --------- first 'idle request'
+			torque = 0.SI<NewtonMeter>();
+
+			response = requestPort.Request(absTime, dt, torque, null);
+			container.CommitSimulationStep(absTime, dt);
+			absTime += dt;
+
+			Assert.IsInstanceOfType(response, typeof(ResponseSuccess));
+			Assert.AreEqual(800.RPMtoRad(), engine.PreviousState.EngineSpeed);
+			Assert.AreEqual(5000.SI<Watt>(), engine.PreviousState.EnginePower);
+
+			// --------- second 'idle request'
+			response = requestPort.Request(absTime, dt, torque, null);
+			container.CommitSimulationStep(absTime, dt);
+			absTime += dt;
+
+			Assert.IsInstanceOfType(response, typeof(ResponseSuccess));
+			Assert.AreEqual(800.RPMtoRad(), engine.PreviousState.EngineSpeed);
+			Assert.AreEqual(5000.SI<Watt>(), engine.PreviousState.EnginePower);
+
+			// --------- third 'idle request'
+			response = requestPort.Request(absTime, dt, torque, null);
+			container.CommitSimulationStep(absTime, dt);
+			absTime += dt;
+
+			Assert.IsInstanceOfType(response, typeof(ResponseSuccess));
+			Assert.AreEqual(560.RPMtoRad(), engine.PreviousState.EngineSpeed);
+			Assert.AreEqual(-8601.6308, engine.PreviousState.EnginePower.Value(), Tolerance);
+		}
+
 
 		[TestMethod, Ignore]
 		public void TestWriteToFile()