refactoring

VectoCore/VectoCore/Models/SimulationComponent/Impl/Clutch.cs

@@ -29,145 +29,152 @@
 *   Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
 */
 
-using TUGraz.VectoCommon.Models;
-using TUGraz.VectoCommon.Utils;
-using TUGraz.VectoCore.Configuration;
-using TUGraz.VectoCore.Models.Connector.Ports;
-using TUGraz.VectoCore.Models.Simulation;
-using TUGraz.VectoCore.Models.Simulation.Data;
-using TUGraz.VectoCore.Models.Simulation.DataBus;
-using TUGraz.VectoCore.Models.SimulationComponent.Data;
-using TUGraz.VectoCore.OutputData;
-using TUGraz.VectoCore.Utils;
-
-namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
-{
-	public class Clutch : StatefulProviderComponent<Clutch.ClutchState, ITnOutPort, ITnInPort, ITnOutPort>, IClutch,
-		ITnOutPort, ITnInPort
-	{
-		private readonly PerSecond _idleSpeed;
-		private readonly PerSecond _ratedSpeed;
-
-		public IIdleController IdleController {
-			get { return _idleController; }
-			set {
-				_idleController = value;
-				_idleController.RequestPort = NextComponent;
-			}
-		}
-
-		private readonly SI _clutchSpeedSlippingFactor;
-		private IIdleController _idleController;
-
-		public Clutch(IVehicleContainer container, CombustionEngineData engineData) : base(container)
-		{
-			_idleSpeed = engineData.IdleSpeed;
-			_ratedSpeed = engineData.FullLoadCurves[0].RatedSpeed;
-			_clutchSpeedSlippingFactor = Constants.SimulationSettings.ClutchClosingSpeedNorm * (_ratedSpeed - _idleSpeed) /
-										(_idleSpeed + Constants.SimulationSettings.ClutchClosingSpeedNorm * (_ratedSpeed - _idleSpeed));
-		}
-
-		public IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity)
-		{
-			NewtonMeter torqueIn;
-			PerSecond engineSpeedIn;
-			if (DataBus.DriverBehavior == DrivingBehavior.Halted /*DataBus.VehicleStopped*/) {
-				engineSpeedIn = _idleSpeed;
-				torqueIn = 0.SI<NewtonMeter>();
-			} else {
-				AddClutchLoss(outTorque, outAngularVelocity, true, out torqueIn, out engineSpeedIn);
-			}
-			PreviousState.SetState(torqueIn, outAngularVelocity, outTorque, outAngularVelocity);
-
-			var retVal = NextComponent.Initialize(torqueIn, engineSpeedIn);
-			retVal.ClutchPowerRequest = outTorque * outAngularVelocity;
-			return retVal;
-		}
-
-		public IResponse Request(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
-			bool dryRun = false)
-		{
-			var startClutch = DataBus.VehicleStopped || !PreviousState.ClutchLoss.IsEqual(0);
-			if (!DataBus.ClutchClosed(absTime) && !dryRun) {
-				Log.Debug("Invoking IdleController...");
-				var retval = IdleController.Request(absTime, dt, outTorque, null, dryRun);
-				retval.ClutchPowerRequest = 0.SI<Watt>();
-				CurrentState.SetState(0.SI<NewtonMeter>(), retval.EngineSpeed, outTorque, outAngularVelocity);
-				CurrentState.ClutchLoss = 0.SI<Watt>();
-				return retval;
-			}
-			if (IdleController != null) {
-				IdleController.Reset();
-			}
-
-			Log.Debug("from Wheels: torque: {0}, angularVelocity: {1}, power {2}", outTorque, outAngularVelocity,
-				Formulas.TorqueToPower(outTorque, outAngularVelocity));
-
-			NewtonMeter torqueIn;
-			PerSecond angularVelocityIn;
-			if (DataBus.DriverBehavior == DrivingBehavior.Halted /*DataBus.VehicleStopped*/) {
-				angularVelocityIn = _idleSpeed;
-				torqueIn = 0.SI<NewtonMeter>();
-			} else {
-				AddClutchLoss(outTorque, outAngularVelocity, (DataBus.Gear == 1 && outTorque > 0) ||startClutch || outAngularVelocity.IsEqual(0), out torqueIn, out angularVelocityIn);
-			}
-			Log.Debug("to Engine:   torque: {0}, angularVelocity: {1}, power {2}", torqueIn, angularVelocityIn,
-				Formulas.TorqueToPower(torqueIn, angularVelocityIn));
-
-			var avgOutAngularVelocity = (PreviousState.OutAngularVelocity + outAngularVelocity) / 2.0;
-			var avgInAngularVelocity = (PreviousState.InAngularVelocity + angularVelocityIn) / 2.0;
-			var clutchLoss = torqueIn * avgInAngularVelocity - outTorque * avgOutAngularVelocity;
-			if (!startClutch && !clutchLoss.IsEqual(0)) {
-				// we don't want to have negative clutch losses, so adapt input torque to match the average output power
-				torqueIn = outTorque * avgOutAngularVelocity / avgInAngularVelocity;
-			}
-
-			var retVal = NextComponent.Request(absTime, dt, torqueIn, angularVelocityIn, dryRun);
-			if (!dryRun) {
-				CurrentState.SetState(torqueIn, angularVelocityIn, outTorque, outAngularVelocity);
-				CurrentState.ClutchLoss = torqueIn * avgInAngularVelocity - outTorque * avgOutAngularVelocity;
-			}
-			retVal.ClutchPowerRequest = outTorque *
-										((PreviousState.OutAngularVelocity ?? 0.SI<PerSecond>()) + CurrentState.OutAngularVelocity) / 2.0;
-			return retVal;
-		}
-
-		private void AddClutchLoss(NewtonMeter torque, PerSecond angularVelocity, bool startClutch, out NewtonMeter torqueIn, out PerSecond angularVelocityIn)
-		{
-			torqueIn = torque;
-			angularVelocityIn = angularVelocity;
-
-			var engineSpeedNorm = (angularVelocity - _idleSpeed) / (_ratedSpeed - _idleSpeed);
-			if (startClutch && engineSpeedNorm < Constants.SimulationSettings.ClutchClosingSpeedNorm) {
-				// MQ: 27.5.2016: when angularVelocity is 0 (at the end of the simulation interval) don't use the 
-				//     angularVelocity but average angular velocity
-				//     Reason: if angularVelocity = 0 also the power (torque * angularVelocity) is 0 and then
-				//             the torque demand for the engine is 0. no drag torque although vehicle has to decelerate
-				//             "the clutch" eats up the whole torque
-				var engineSpeed = VectoMath.Max(_idleSpeed, angularVelocity);
-
-				angularVelocityIn = _clutchSpeedSlippingFactor * engineSpeed + _idleSpeed;
-				
-			}
-		}
-
-		protected override void DoWriteModalResults(IModalDataContainer container)
-		{
-			if (PreviousState.InAngularVelocity == null || CurrentState.InAngularVelocity == null) {
-				container[ModalResultField.P_clutch_out] = 0.SI<Watt>();
-				container[ModalResultField.P_clutch_loss] = 0.SI<Watt>();
-			} else {
-				var avgOutAngularVelocity = (PreviousState.OutAngularVelocity + CurrentState.OutAngularVelocity) / 2.0;
-				var avgInAngularVelocity = (PreviousState.InAngularVelocity + CurrentState.InAngularVelocity) / 2.0;
-				container[ModalResultField.P_clutch_out] = CurrentState.OutTorque * avgOutAngularVelocity;
-				container[ModalResultField.P_clutch_loss] = CurrentState.InTorque * avgInAngularVelocity -
-															CurrentState.OutTorque * avgOutAngularVelocity;
-			}
-		}
-
-		public class ClutchState : SimpleComponentState
-		{
-			public Watt ClutchLoss = 0.SI<Watt>();
-		}
-	}
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.Models.Connector.Ports;
+using TUGraz.VectoCore.Models.Simulation;
+using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.Simulation.DataBus;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.OutputData;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
+{
+	public class Clutch : StatefulProviderComponent<Clutch.ClutchState, ITnOutPort, ITnInPort, ITnOutPort>, IClutch,
+		ITnOutPort, ITnInPort
+	{
+		private readonly PerSecond _idleSpeed;
+		private readonly PerSecond _ratedSpeed;
+
+		public IIdleController IdleController
+		{
+			get { return _idleController; }
+			set
+			{
+				_idleController = value;
+				_idleController.RequestPort = NextComponent;
+			}
+		}
+
+		private readonly SI _clutchSpeedSlippingFactor;
+		private IIdleController _idleController;
+
+		public Clutch(IVehicleContainer container, CombustionEngineData engineData) : base(container)
+		{
+			_idleSpeed = engineData.IdleSpeed;
+			_ratedSpeed = engineData.FullLoadCurves[0].RatedSpeed;
+			_clutchSpeedSlippingFactor = Constants.SimulationSettings.ClutchClosingSpeedNorm * (_ratedSpeed - _idleSpeed) /
+										(_idleSpeed + Constants.SimulationSettings.ClutchClosingSpeedNorm * (_ratedSpeed - _idleSpeed));
+		}
+
+		public IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity)
+		{
+			NewtonMeter torqueIn;
+			PerSecond engineSpeedIn;
+			if (DataBus.DriverBehavior == DrivingBehavior.Halted /*DataBus.VehicleStopped*/) {
+				engineSpeedIn = _idleSpeed;
+				torqueIn = 0.SI<NewtonMeter>();
+			} else {
+				AddClutchLoss(outTorque, outAngularVelocity, true, out torqueIn, out engineSpeedIn);
+			}
+			PreviousState.SetState(torqueIn, outAngularVelocity, outTorque, outAngularVelocity);
+
+			var retVal = NextComponent.Initialize(torqueIn, engineSpeedIn);
+			retVal.ClutchPowerRequest = outTorque * outAngularVelocity;
+			return retVal;
+		}
+
+		public IResponse Request(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
+			bool dryRun = false)
+		{
+			var startClutch = DataBus.VehicleStopped || !PreviousState.ClutchLoss.IsEqual(0);
+			if (!DataBus.ClutchClosed(absTime) && !dryRun) {
+				Log.Debug("Invoking IdleController...");
+				var retval = IdleController.Request(absTime, dt, outTorque, null, dryRun);
+				retval.ClutchPowerRequest = 0.SI<Watt>();
+				CurrentState.SetState(0.SI<NewtonMeter>(), retval.EngineSpeed, outTorque, outAngularVelocity);
+				CurrentState.ClutchLoss = 0.SI<Watt>();
+				return retval;
+			}
+			if (IdleController != null) {
+				IdleController.Reset();
+			}
+
+			Log.Debug("from Wheels: torque: {0}, angularVelocity: {1}, power {2}", outTorque, outAngularVelocity,
+				Formulas.TorqueToPower(outTorque, outAngularVelocity));
+
+			NewtonMeter torqueIn;
+			PerSecond angularVelocityIn;
+
+			AddClutchLoss(outTorque, outAngularVelocity,
+				(DataBus.Gear == 1 && outTorque > 0) || startClutch || outAngularVelocity.IsEqual(0), out torqueIn,
+				out angularVelocityIn);
+
+			Log.Debug("to Engine:   torque: {0}, angularVelocity: {1}, power {2}", torqueIn, angularVelocityIn,
+				Formulas.TorqueToPower(torqueIn, angularVelocityIn));
+
+			var avgOutAngularVelocity = (PreviousState.OutAngularVelocity + outAngularVelocity) / 2.0;
+			var avgInAngularVelocity = (PreviousState.InAngularVelocity + angularVelocityIn) / 2.0;
+			var clutchLoss = torqueIn * avgInAngularVelocity - outTorque * avgOutAngularVelocity;
+			if (!startClutch && !clutchLoss.IsEqual(0)) {
+				// we don't want to have negative clutch losses, so adapt input torque to match the average output power
+				torqueIn = outTorque * avgOutAngularVelocity / avgInAngularVelocity;
+			}
+
+			var retVal = NextComponent.Request(absTime, dt, torqueIn, angularVelocityIn, dryRun);
+			if (!dryRun) {
+				CurrentState.SetState(torqueIn, angularVelocityIn, outTorque, outAngularVelocity);
+				CurrentState.ClutchLoss = torqueIn * avgInAngularVelocity - outTorque * avgOutAngularVelocity;
+			}
+			retVal.ClutchPowerRequest = outTorque *
+										((PreviousState.OutAngularVelocity ?? 0.SI<PerSecond>()) + CurrentState.OutAngularVelocity) / 2.0;
+			return retVal;
+		}
+
+		private void AddClutchLoss(NewtonMeter torque, PerSecond angularVelocity, bool startClutch, out NewtonMeter torqueIn,
+			out PerSecond angularVelocityIn)
+		{
+			if (DataBus.DriverBehavior == DrivingBehavior.Halted) {
+				angularVelocityIn = _idleSpeed;
+				torqueIn = 0.SI<NewtonMeter>();
+				return;
+			}
+
+			torqueIn = torque;
+			angularVelocityIn = angularVelocity;
+
+			var engineSpeedNorm = (angularVelocity - _idleSpeed) / (_ratedSpeed - _idleSpeed);
+			if (startClutch && engineSpeedNorm < Constants.SimulationSettings.ClutchClosingSpeedNorm) {
+				// MQ: 27.5.2016: when angularVelocity is 0 (at the end of the simulation interval) don't use the 
+				//     angularVelocity but average angular velocity
+				//     Reason: if angularVelocity = 0 also the power (torque * angularVelocity) is 0 and then
+				//             the torque demand for the engine is 0. no drag torque although vehicle has to decelerate
+				//             "the clutch" eats up the whole torque
+				var engineSpeed = VectoMath.Max(_idleSpeed, angularVelocity);
+
+				angularVelocityIn = _clutchSpeedSlippingFactor * engineSpeed + _idleSpeed;
+			}
+		}
+
+		protected override void DoWriteModalResults(IModalDataContainer container)
+		{
+			if (PreviousState.InAngularVelocity == null || CurrentState.InAngularVelocity == null) {
+				container[ModalResultField.P_clutch_out] = 0.SI<Watt>();
+				container[ModalResultField.P_clutch_loss] = 0.SI<Watt>();
+			} else {
+				var avgOutAngularVelocity = (PreviousState.OutAngularVelocity + CurrentState.OutAngularVelocity) / 2.0;
+				var avgInAngularVelocity = (PreviousState.InAngularVelocity + CurrentState.InAngularVelocity) / 2.0;
+				container[ModalResultField.P_clutch_out] = CurrentState.OutTorque * avgOutAngularVelocity;
+				container[ModalResultField.P_clutch_loss] = CurrentState.InTorque * avgInAngularVelocity -
+															CurrentState.OutTorque * avgOutAngularVelocity;
+			}
+		}
+
+		public class ClutchState : SimpleComponentState
+		{
+			public Watt ClutchLoss = 0.SI<Watt>();
+		}
+	}
 }
\ No newline at end of file

VectoCore/VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs

@@ -175,9 +175,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				// if the clutch disengages the idle controller should take over!
 				throw new VectoSimulationException("angular velocity is null! Clutch open without IdleController?");
 			}
-			if (angularVelocity < ModelData.IdleSpeed.Value() - EngineIdleSpeedStopThreshold) {
-				CurrentState.OperationMode = EngineOperationMode.Stopped;
-			}
+			//if (angularVelocity < ModelData.IdleSpeed.Value() - EngineIdleSpeedStopThreshold) {
+			//	CurrentState.OperationMode = EngineOperationMode.Stopped;
+			//}
 
 			var avgEngineSpeed = (PreviousState.EngineSpeed + angularVelocity) / 2.0;
 
@@ -192,9 +192,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 			var fullDragTorque = ModelData.FullLoadCurves[DataBus.Gear].DragLoadStationaryTorque(avgEngineSpeed);
 			var dynamicFullLoadPower = ComputeFullLoadPower(avgEngineSpeed, dt, dryRun);
-			if (dynamicFullLoadPower < 0) {
-				dynamicFullLoadPower = 0.SI<Watt>();
-			}
+
 			var dynamicFullLoadTorque = dynamicFullLoadPower / avgEngineSpeed;
 			var inertiaTorqueLoss =
 				Formulas.InertiaPower(angularVelocity, PreviousState.EngineSpeed, ModelData.Inertia, dt) /
@@ -460,6 +458,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				dynFullPowerCalculated = stationaryFullLoadPower;
 			}
 
+			if (dynFullPowerCalculated < 0) {
+				return 0.SI<Watt>();
+			}
 			return dynFullPowerCalculated;
 		}
 
@@ -590,7 +591,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 						angularSpeed = angularSpeed.LimitTo(_engine.ModelData.IdleSpeed, _engine.EngineRatedSpeed);
 						retVal = RequestPort.Request(absTime, dt, 0.SI<NewtonMeter>(), angularSpeed);
 					}).
-					Default(r => { throw new UnexpectedResponseException("searching Idling point", r); });
+					Default(r => {
+						throw new UnexpectedResponseException("searching Idling point", r);
+					});
 
 				return retVal;
 			}
@@ -647,7 +650,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 							0.SI<NewtonMeter>(), angularSpeed);
 						retVal = RequestPort.Request(absTime, dt, 0.SI<NewtonMeter>(), angularSpeed);
 					}).
-					Default(r => { throw new UnexpectedResponseException("searching Idling point", r); });
+					Default(r => {
+						throw new UnexpectedResponseException("searching Idling point", r);
+					});
 
 				return retVal;
 			}