Merge pull request #51 in VECTO/vecto-sim from...

Merge pull request #51 in VECTO/vecto-sim from ~EMQUARIMA/vecto-sim:feature/VECTO-83-adapt-engine-only-simulation-for to develop

* commit 'cf54cafe':
  make gearbox test work
  bugfix: crash due to stack overflow
  engine model works with variable time-steps. final approval of results still missing.
  full load jump works, jump back to idle load still open issue
  engine full load jump testcases with different timesteps work
  adding multiple full-load jump tests
  combustion engine test for full-load jump
  more work on variable-time simulation
  started test with variable time (engine only)
  engine-only cycle witht time info
  new cycle file for variable timesteps (engine only mode)
  transient behavior of engine (PT1) respects simulation step

VECTO.sln

@@ -59,4 +59,7 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 EndGlobal

VectoCore/Models/SimulationComponent/Impl/CombustionEngine.cs

@@ -51,6 +51,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			_previousState.OperationMode = EngineOperationMode.Idle;
 			_previousState.EnginePower = 0.SI<Watt>();
 			_previousState.EngineSpeed = _data.IdleSpeed;
+			_previousState.dt = TimeSpan.FromSeconds(0.1);
 		}
 
 		#region IEngineCockpit
@@ -75,6 +76,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		IResponse ITnOutPort.Request(TimeSpan absTime, TimeSpan dt, NewtonMeter torque, PerSecond engineSpeed)
 		{
+			_currentState.dt = dt;
 			_currentState.EngineSpeed = engineSpeed;
 			_currentState.AbsTime = absTime;
 
@@ -225,12 +227,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		protected void ComputeFullLoadPower(uint gear, PerSecond angularVelocity, TimeSpan dt)
 		{
 			if (dt.Ticks == 0) {
-				throw new VectoException("ComputeFullLoadPower cannot compute at time 0.");
-			}
-
-			// TODO @@@quam: handle dynamic timesteps
-			if (!dt.TotalSeconds.IsEqual(1)) {
-				throw new VectoException("simulation steps other than 1s can not be handled ATM");
+				throw new VectoException("ComputeFullLoadPower cannot compute for simulation interval length 0.");
 			}
 
 			//_currentState.StationaryFullLoadPower = _data.GetFullLoadCurve(gear).FullLoadStationaryPower(rpm);
@@ -239,10 +236,15 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			_currentState.StationaryFullLoadPower = Formulas.TorqueToPower(_currentState.StationaryFullLoadTorque,
 				angularVelocity);
 
-			double pt1 = _data.GetFullLoadCurve(gear).PT1(angularVelocity).Double() / dt.TotalSeconds;
+			double pt1 = _data.GetFullLoadCurve(gear).PT1(angularVelocity).Double();
 
-			var dynFullPowerCalculated = (1 / (pt1 + 1)) *
-										(_currentState.StationaryFullLoadPower + pt1 * _previousState.EnginePower);
+//			var dynFullPowerCalculated = (1 / (pt1 + 1)) *
+//										(_currentState.StationaryFullLoadPower + pt1 * _previousState.EnginePower);
+			var tStarPrev = pt1 *
+							Math.Log(1 / (1 - (_previousState.EnginePower / _currentState.StationaryFullLoadPower).Double()), Math.E)
+								.SI<Second>();
+			var tStar = tStarPrev + _previousState.dt.TotalSeconds.SI<Second>();
+			var dynFullPowerCalculated = _currentState.StationaryFullLoadPower * (1 - Math.Exp((-tStar / pt1).Double()));
 			_currentState.DynamicFullLoadPower = (dynFullPowerCalculated < _currentState.StationaryFullLoadPower)
 				? dynFullPowerCalculated
 				: _currentState.StationaryFullLoadPower;
@@ -330,6 +332,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			/// </summary>
 			public NewtonMeter EngineTorque { get; set; }
 
+			public TimeSpan dt { get; set; }
+
 			#region Equality members
 
 			protected bool Equals(EngineState other)

VectoCore/Utils/SI.cs

@@ -135,7 +135,7 @@ namespace TUGraz.VectoCore.Utils
 
 		public static T operator -(SIBase<T> si1, SI si2)
 		{
-			return si1 - si2;
+			return (-1 * si2) + si1;
 		}
 
 		public static T operator -(SI si1, SIBase<T> si2)

VectoCoreTest/Integration/EngineOnlyCycle/EngineOnlyCycleTest.cs

 using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting.Web;
 using TUGraz.VectoCore.Models.Simulation.Data;
 using TUGraz.VectoCore.Models.Simulation.Impl;
 using TUGraz.VectoCore.Models.SimulationComponent;
@@ -10,106 +11,107 @@ using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.Tests.Integration.EngineOnlyCycle
 {
-    [TestClass]
-    public class EngineOnlyCycleTest
-    {
-        private const string EngineFile = @"TestData\Components\24t Coach.veng";
-        public TestContext TestContext { get; set; }
+	[TestClass]
+	public class EngineOnlyCycleTest
+	{
+		private const string EngineFile = @"TestData\Components\24t Coach.veng";
+		public TestContext TestContext { get; set; }
 
-        [DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\TestData\\EngineTests.csv",
-            "EngineTests#csv", DataAccessMethod.Sequential)]
-        [TestMethod]
-        public void TestEngineOnlyDrivingCycle()
-        {
-            var data = DrivingCycleData.ReadFromFileEngineOnly(TestContext.DataRow["CycleFile"].ToString());
-            var expectedResults = ModalResults.ReadFromFile(TestContext.DataRow["ModalResultFile"].ToString());
+		[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\TestData\\EngineTests.csv",
+			"EngineTests#csv", DataAccessMethod.Sequential)]
+		[TestMethod]
+		public void TestEngineOnlyDrivingCycle()
+		{
+			var data = DrivingCycleData.ReadFromFileEngineOnly(TestContext.DataRow["CycleFile"].ToString());
+			var expectedResults = ModalResults.ReadFromFile(TestContext.DataRow["ModalResultFile"].ToString());
 
-            var vehicle = new VehicleContainer();
-            var engineData = CombustionEngineData.ReadFromFile(TestContext.DataRow["EngineFile"].ToString());
+			var vehicle = new VehicleContainer();
+			var engineData = CombustionEngineData.ReadFromFile(TestContext.DataRow["EngineFile"].ToString());
 
-            var aux = new EngineOnlyAuxiliary(vehicle, new AuxiliariesDemandAdapter(data));
-            var gearbox = new EngineOnlyGearbox(vehicle);
+			var aux = new EngineOnlyAuxiliary(vehicle, new AuxiliariesDemandAdapter(data));
+			var gearbox = new EngineOnlyGearbox(vehicle);
 
 
-            var engine = new CombustionEngine(vehicle, engineData);
+			var engine = new CombustionEngine(vehicle, engineData);
 
 			aux.InShaft().Connect(engine.OutShaft());
 			gearbox.InShaft().Connect(aux.OutShaft());
-            var port = aux.OutShaft();
+			var port = aux.OutShaft();
 
 //			IVectoJob job = SimulationFactory.CreateTimeBasedEngineOnlyJob(TestContext.DataRow["EngineFile"].ToString(),
 //				TestContext.DataRow["CycleFile"].ToString(), "test2.csv");
 
-            var absTime = new TimeSpan(seconds: 0, minutes: 0, hours: 0);
-            var dt = new TimeSpan(seconds: 1, minutes: 0, hours: 0);
-
-            var dataWriter = new TestModalDataWriter();
-
-            var i = 0;
-            var results = new[] {
-                ModalResultField.n, ModalResultField.PaEng, ModalResultField.Tq_drag, ModalResultField.Pe_drag,
-                ModalResultField.Pe_eng, ModalResultField.Tq_eng, ModalResultField.Tq_full, ModalResultField.Pe_full
-            };
-            //, ModalResultField.FC };
-            var siFactor = new[] { 1, 1000, 1, 1000, 1000, 1, 1, 1000, 1 };
-            var tolerances = new[] { 0.0001, 0.1, 0.0001, 0.1, 0.1, 0.001, 0.001, 0.1, 0.01 };
-            foreach (var cycle in data.Entries) {
-                port.Request(absTime, dt, cycle.EngineTorque, cycle.EngineSpeed);
-                foreach (var sc in vehicle.SimulationComponents()) {
-                    sc.CommitSimulationStep(dataWriter);
-                }
-
-                // TODO: handle initial state of engine
-                var row = expectedResults.Rows[i++];
-                if (i > 2) {
-                    for (var j = 0; j < results.Length; j++) {
-                        var field = results[j];
-//						if (!Double.IsNaN(dataWriter.GetDouble(field)))
-                        Assert.AreEqual((double) row[field.GetName()] * siFactor[j], dataWriter.GetDouble(field),
-                            tolerances[j],
-                            String.Format("t: {0}  field: {1}", i, field));
-                    }
-                    if (row[ModalResultField.FC.GetName()] is double) {
-                        Assert.AreEqual((double) row[ModalResultField.FC.GetName()],
-                            dataWriter.GetDouble(ModalResultField.FC), 0.01,
-                            "t: {0}  field: {1}", i, ModalResultField.FC);
-                    } else {
-                        Assert.IsTrue(Double.IsNaN(dataWriter.GetDouble(ModalResultField.FC)),
-                            String.Format("t: {0}", i));
-                    }
-                }
-
-                dataWriter.CommitSimulationStep(absTime, dt);
-                absTime += dt;
-            }
-            dataWriter.Data.WriteToFile("test2.csv");
-        }
-
-        [TestMethod]
-        public void AssembleEngineOnlyPowerTrain()
-        {
-            var dataWriter = new TestModalDataWriter();
-
-            var vehicleContainer = new VehicleContainer();
-
-            var gearbox = new EngineOnlyGearbox(vehicleContainer);
-            var engine = new CombustionEngine(vehicleContainer, CombustionEngineData.ReadFromFile(EngineFile));
-
-            gearbox.InShaft().Connect(engine.OutShaft());
-
-            var absTime = new TimeSpan();
-            var dt = TimeSpan.FromSeconds(1);
-
-            var angularVelocity = 644.4445.RPMtoRad();
-            var power = 2329.973.SI<Watt>();
-
-            gearbox.OutShaft().Request(absTime, dt, Formulas.PowerToTorque(power, angularVelocity), angularVelocity);
-
-            foreach (var sc in vehicleContainer.SimulationComponents()) {
-                sc.CommitSimulationStep(dataWriter);
-            }
-
-            Assert.IsNotNull(dataWriter.CurrentRow);
-        }
-    }
+			var absTime = new TimeSpan(seconds: 0, minutes: 0, hours: 0);
+			var dt = new TimeSpan(seconds: 1, minutes: 0, hours: 0);
+
+			var dataWriter = new TestModalDataWriter();
+
+			var i = 0;
+			var results = new[] {
+				ModalResultField.n, ModalResultField.PaEng, ModalResultField.Tq_drag, ModalResultField.Pe_drag,
+				ModalResultField.Pe_eng, ModalResultField.Tq_eng, ModalResultField.Tq_full, ModalResultField.Pe_full
+			};
+			//, ModalResultField.FC };
+			//var siFactor = new[] { 1, 1000, 1, 1000, 1000, 1, 1, 1000, 1 };
+			//var tolerances = new[] { 0.0001, 0.1, 0.0001, 0.1, 0.1, 0.001, 0.001, 0.1, 0.01 };
+			foreach (var cycle in data.Entries) {
+				port.Request(absTime, dt, cycle.EngineTorque, cycle.EngineSpeed);
+				foreach (var sc in vehicle.SimulationComponents()) {
+					sc.CommitSimulationStep(dataWriter);
+				}
+
+				// TODO: handle initial state of engine
+				var row = expectedResults.Rows[i++];
+				if (i > 2) {
+					for (var j = 0; j < results.Length; j++) {
+						var field = results[j];
+						//						if (!Double.IsNaN(dataWriter.GetDouble(field)))
+						Assert.AreEqual((double) row[field.GetName()], dataWriter.GetDouble(field),
+							0.0001,
+							String.Format("t: {0}  field: {1}", i, field));
+					}
+					if (row[ModalResultField.FC.GetName()] is double &&
+						!Double.IsNaN(Double.Parse(row[ModalResultField.FC.GetName()].ToString()))) {
+						Assert.AreEqual((double) row[ModalResultField.FC.GetName()],
+							dataWriter.GetDouble(ModalResultField.FC), 0.01,
+							"t: {0}  field: {1}", i, ModalResultField.FC);
+					} else {
+						Assert.IsTrue(Double.IsNaN(dataWriter.GetDouble(ModalResultField.FC)),
+							String.Format("t: {0}", i));
+					}
+				}
+
+				dataWriter.CommitSimulationStep(absTime, dt);
+				absTime += dt;
+			}
+			dataWriter.Data.WriteToFile(String.Format("result_{0}.csv", TestContext.DataRow["TestName"].ToString()));
+		}
+
+		[TestMethod]
+		public void AssembleEngineOnlyPowerTrain()
+		{
+			var dataWriter = new TestModalDataWriter();
+
+			var vehicleContainer = new VehicleContainer();
+
+			var gearbox = new EngineOnlyGearbox(vehicleContainer);
+			var engine = new CombustionEngine(vehicleContainer, CombustionEngineData.ReadFromFile(EngineFile));
+
+			gearbox.InShaft().Connect(engine.OutShaft());
+
+			var absTime = new TimeSpan();
+			var dt = TimeSpan.FromSeconds(1);
+
+			var angularVelocity = 644.4445.RPMtoRad();
+			var power = 2329.973.SI<Watt>();
+
+			gearbox.OutShaft().Request(absTime, dt, Formulas.PowerToTorque(power, angularVelocity), angularVelocity);
+
+			foreach (var sc in vehicleContainer.SimulationComponents()) {
+				sc.CommitSimulationStep(dataWriter);
+			}
+
+			Assert.IsNotNull(dataWriter.CurrentRow);
+		}
+	}
 }
\ No newline at end of file

VectoCoreTest/Models/Simulation/DrivingCycleTests.cs

@@ -42,6 +42,65 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			Assert.AreEqual(0.SI<NewtonMeter>(), outPort.Torque);
 		}
 
+		[TestMethod, Ignore]
+		public void TestEngineOnlyWithTimestamps()
+		{
+			var container = new VehicleContainer();
+
+			var cycleData = DrivingCycleData.ReadFromFileEngineOnly(@"TestData\Cycles\Coach Engine Only Paux_var-dt.vdri");
+			var cycle = new EngineOnlyDrivingCycle(container, cycleData);
+
+			var outPort = new MockTnOutPort();
+			var inPort = cycle.InShaft();
+
+			inPort.Connect(outPort);
+
+			var absTime = TimeSpan.FromSeconds(10);
+			var dt = TimeSpan.FromSeconds(1);
+
+			var response = cycle.OutPort().Request(absTime, dt);
+			Assert.IsInstanceOfType(response, typeof (ResponseFailTimeInterval));
+
+			dt = TimeSpan.FromSeconds(0.25);
+			response = cycle.OutPort().Request(absTime, dt);
+			Assert.IsInstanceOfType(response, typeof (ResponseSuccess));
+
+			var dataWriter = new TestModalDataWriter();
+			container.CommitSimulationStep(dataWriter);
+
+			Assert.AreEqual(absTime, outPort.AbsTime);
+			Assert.AreEqual(dt, outPort.Dt);
+			Assert.AreEqual(743.2361.RPMtoRad(), outPort.AngularVelocity);
+			Assert.AreEqual(Formulas.PowerToTorque(2779.576.SI<Watt>(), 743.2361.RPMtoRad()), outPort.Torque);
+
+			// ========================
+
+			dt = TimeSpan.FromSeconds(1);
+			absTime = TimeSpan.FromSeconds(500);
+			response = cycle.OutPort().Request(absTime, dt);
+			Assert.IsInstanceOfType(response, typeof (ResponseFailTimeInterval));
+
+			dt = TimeSpan.FromSeconds(0.25);
+
+			for (int i = 0; i < 2; i++) {
+				response = cycle.OutPort().Request(absTime, dt);
+				Assert.IsInstanceOfType(response, typeof (ResponseSuccess));
+
+				dataWriter = new TestModalDataWriter();
+				container.CommitSimulationStep(dataWriter);
+
+				Assert.AreEqual(absTime, outPort.AbsTime);
+				Assert.AreEqual(dt, outPort.Dt);
+				Assert.AreEqual(1584.731.RPMtoRad(), outPort.AngularVelocity);
+				Assert.AreEqual(Formulas.PowerToTorque(3380.548.SI<Watt>(), 1584.731.RPMtoRad()), outPort.Torque);
+
+				absTime += dt;
+			}
+
+
+			// todo: test going backward in time, end of cycle
+		}
+
 		[TestMethod]
 		public void Test_TimeBased_FirstCycle()
 		{

VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs

 using System;
+using System.Globalization;
 using System.IO;
 using System.Reflection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -116,6 +117,61 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			dataWriter.Data.WriteToFile(@"test1.csv");
 		}
 
+
+		[TestMethod]
+		[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", "|DataDirectory|\\TestData\\EngineFullLoadJumps.csv",
+			"EngineFullLoadJumps#csv", DataAccessMethod.Sequential)]
+		public void TestEngineFullLoadJump()
+		{
+			var vehicleContainer = new VehicleContainer();
+			var gearbox = new EngineOnlyGearbox(vehicleContainer);
+			var engineData = CombustionEngineData.ReadFromFile(TestContext.DataRow["EngineFile"].ToString());
+			var engine = new CombustionEngine(vehicleContainer, engineData);
+
+			gearbox.InShaft().Connect(engine.OutShaft());
+
+			var expectedResults = VectoCSVFile.Read(TestContext.DataRow["ResultFile"].ToString());
+
+			var requestPort = gearbox.OutShaft();
+
+			//var modalData = new ModalDataWriter(string.Format("load_jump_{0}.csv", TestContext.DataRow["TestName"].ToString()));
+			var modalData = new TestModalDataWriter();
+
+			var idlePower = Double.Parse(TestContext.DataRow["initialIdleLoad"].ToString()).SI<Watt>();
+
+			var angularSpeed = Double.Parse(TestContext.DataRow["rpm"].ToString()).RPMtoRad();
+
+			var t = TimeSpan.FromSeconds(0);
+			var dt = TimeSpan.FromSeconds(0.1);
+
+			for (; t.TotalSeconds < 2; t += dt) {
+				requestPort.Request(t, dt, Formulas.PowerToTorque(idlePower, angularSpeed), angularSpeed);
+				engine.CommitSimulationStep(modalData);
+			}
+
+			var i = 0;
+			// dt = TimeSpan.FromSeconds(double.Parse(TestContext.DataRow["dt"].ToString(), CultureInfo.InvariantCulture));
+			// dt = TimeSpan.FromSeconds(expectedResults.Rows[i].ParseDouble(0)) - t;
+			var engineLoadPower = engineData.GetFullLoadCurve(0).FullLoadStationaryPower(angularSpeed);
+			idlePower = Double.Parse(TestContext.DataRow["finalIdleLoad"].ToString()).SI<Watt>();
+			for (; t.TotalSeconds < 25; t += dt, i++) {
+				dt = TimeSpan.FromSeconds(expectedResults.Rows[i + 1].ParseDouble(0) - expectedResults.Rows[i].ParseDouble(0));
+				if (t >= TimeSpan.FromSeconds(10)) {
+					engineLoadPower = idlePower;
+				}
+				requestPort.Request(t, dt, Formulas.PowerToTorque(engineLoadPower, angularSpeed), angularSpeed);
+				modalData[ModalResultField.time] = t.TotalSeconds;
+				modalData[ModalResultField.simulationInterval] = dt.TotalSeconds;
+				engine.CommitSimulationStep(modalData);
+				// todo: compare results...
+				Assert.AreEqual(expectedResults.Rows[i].ParseDouble(0), t.TotalSeconds, 0.001, "Time");
+				Assert.AreEqual(expectedResults.Rows[i].ParseDouble(1), modalData.GetDouble(ModalResultField.Pe_full), 0.1,
+					String.Format("Load in timestep {0}", t));
+				modalData.CommitSimulationStep();
+			}
+			modalData.Finish();
+		}
+
 		[TestMethod]
 		public void TestEngineMemento()
 		{

VectoCoreTest/Models/SimulationComponentData/FullLoadCurveTest.cs

-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using TUGraz.VectoCore.Exceptions;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
 using TUGraz.VectoCore.Utils;

VectoCoreTest/Models/SimulationComponentData/GearboxDataTest.cs

@@ -41,18 +41,18 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData
 			"AxleGearLossInterpolation#csv", DataAccessMethod.Sequential)]
 		public void TestInterpolation()
 		{
-			var rdyn = Double.Parse(TestContext.DataRow["rDyn"].ToString());
+			var rdyn = double.Parse(TestContext.DataRow["rDyn"].ToString(), CultureInfo.InvariantCulture);
 			var speed = double.Parse(TestContext.DataRow["v"].ToString(), CultureInfo.InvariantCulture);
 
 			var gbxData = GearboxData.ReadFromFile(TestContext.DataRow["GearboxDataFile"].ToString());
 
 
-			var angSpeed = SpeedToAngularSpeed(speed, rdyn) * gbxData.AxleGearData.Ratio;
 			var PvD = Double.Parse(TestContext.DataRow["PowerGbxOut"].ToString(), CultureInfo.InvariantCulture).SI<Watt>();
 
-			var torqueToWheels = Formulas.PowerToTorque(PvD, angSpeed);
+			var torqueToWheels = Formulas.PowerToTorque(PvD, SpeedToAngularSpeed(speed, rdyn));
 			var torqueFromEngine = 0.SI<NewtonMeter>();
 
+			var angSpeed = SpeedToAngularSpeed(speed, rdyn) * gbxData.AxleGearData.Ratio;
 			if (TestContext.DataRow["Gear"].ToString() == "A") {
 				torqueFromEngine = gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
 			}
@@ -81,7 +81,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData
 				gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
 				Assert.Fail("angular Speed too high");
 			} catch (Exception e) {
-				Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
+				Assert.IsInstanceOfType(e, typeof (VectoSimulationException), "angular speed too high");
 			}
 
 			angSpeed = 1000.RPMtoRad();
@@ -90,16 +90,16 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData
 				gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
 				Assert.Fail("torque too high");
 			} catch (Exception e) {
-				Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
+				Assert.IsInstanceOfType(e, typeof (VectoSimulationException), "torque too high");
 			}
 
 			angSpeed = 1000.RPMtoRad();
-			torqueToWheels = -5000.SI<NewtonMeter>();
+			torqueToWheels = -10000.SI<NewtonMeter>();
 			try {
 				gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
 				Assert.Fail("torque too low");
 			} catch (Exception e) {
-				Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
+				Assert.IsInstanceOfType(e, typeof (VectoSimulationException), "torque too low");
 			}
 
 			angSpeed = -1000.RPMtoRad();
@@ -108,7 +108,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData
 				gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
 				Assert.Fail("negative angular speed");
 			} catch (Exception e) {
-				Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
+				Assert.IsInstanceOfType(e, typeof (VectoSimulationException), "negative angular speed");
 			}
 		}
 

VectoCoreTest/TestData/Cycles/Coach Engine Only FullLoad.vdri

+<n>,<Pe>
+600,0
+600,0
+600,0
+600,9999
+600,9999
+600,9999
+600,9999
+600,9999
+600,9999
+600,9999
+600,9999
+1200,0
+1200,0
+1200,0
+1200,9999
+1200,9999
+1200,9999
+1200,9999
+1200,9999
+1200,9999
+1200,9999
+1200,9999

VectoCoreTest/TestData/EngineFullLoadJumps.csv

+TestName,EngineFile,rpm,initialIdleLoad,finalIdleLoad,ResultFile
+Test1Hz,TestData\Components\24t Coach.veng,1000,50,50,TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_1Hz.csv
+Test10Hz,TestData\Components\24t Coach.veng,1000,50,50,TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_10Hz.csv
+TestvarHz,TestData\Components\24t Coach.veng,1000,50,50,TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_varHz.csv
\ No newline at end of file

VectoCoreTest/TestData/EngineTests.csv

 TestName,EngineFile,CycleFile,ModalResultFile
-Test1,TestData\Components\24t Coach.veng,TestData\Cycles\Coach Engine Only.vdri,TestData\Results\EngineOnlyCycles\24tCoach_EngineOnly.vmod
-Test2,TestData\Components\24t Coach.veng,TestData\Cycles\Coach Engine Only Paux.vdri,TestData\Results\EngineOnlyCycles\24tCoach_EngineOnlyPaux.vmod
\ No newline at end of file
+24tCoach_EngineOnly,TestData\Components\24t Coach.veng,TestData\Cycles\Coach Engine Only.vdri,TestData\Results\EngineOnlyCycles\24tCoach_EngineOnly.vmod
+24tCoach_EngineOnlyPaux,TestData\Components\24t Coach.veng,TestData\Cycles\Coach Engine Only Paux.vdri,TestData\Results\EngineOnlyCycles\24tCoach_EngineOnlyPaux.vmod
+24tCoach_EngineOnlyFullLoad,TestData\Components\24t Coach.veng,TestData\Cycles\Coach Engine Only FullLoad.vdri,TestData\Results\EngineOnlyCycles\24tCoach_EngineOnlyFullLoad.vmod
\ No newline at end of file

VectoCoreTest/TestData/Results/EngineFullLoadJumps/EngineFLJ_1000rpm_10Hz.csv

+t,Pe_FullDyn
+2.00,37018.0353
+2.10,68310.8016
+2.20,94799.5563
+2.30,117221.8032
+2.40,136201.8254
+2.50,152268.0673
+2.60,165867.8474
+2.70,177379.8128
+2.80,187124.4811
+2.90,195373.1647
+3.00,202355.5247
+3.10,208265.9648
+3.20,213269.0443
+3.30,217504.0597
+3.40,221088.9228
+3.50,224123.444
+3.60,226692.1106
+3.70,228866.44
+3.80,230706.9701
+3.90,232264.9452
+4.00,233583.7427
+4.10,234700.0806
+4.20,235645.0403
+4.30,236444.9314
+4.40,237122.0245
+4.50,237695.1715
+4.60,238180.33
+4.70,238591.0078
+4.80,238938.639
+4.90,239232.9025
+5.00,239481.9912
+5.10,239692.8402
+5.20,239871.32
+5.30,240022.3999
+5.40,240150.2863
+5.50,240258.5398
+5.60,240350.1744
+5.70,240427.7414
+5.80,240493.4004
+5.90,240548.9796
+6.00,240596.0264
+6.10,240635.8506
+6.20,240669.5611
+6.30,240698.0964
+6.40,240722.2511
+6.50,240742.6975
+6.60,240760.005
+6.70,240774.6556
+6.80,240787.0569
+6.90,240797.5545
+7.00,240806.4405
+7.10,240813.9623
+7.20,240820.3294
+7.30,240825.719
+7.40,240830.2812
+7.50,240834.1431
+7.60,240837.412
+7.70,240840.1792
+7.80,240842.5215
+7.90,240844.5042
+8.00,240846.1826
+8.10,240847.6033
+8.20,240848.8058
+8.30,240849.8238
+8.40,240850.6855
+8.50,240851.4149
+8.60,240852.0323
+8.70,240852.555
+8.80,240852.9974
+8.90,240853.3719
+9.00,240853.6889
+9.10,240853.9572
+9.20,240854.1844
+9.30,240854.3766
+9.40,240854.5394
+9.50,240854.6771
+9.60,240854.7938
+9.70,240854.8925
+9.80,240854.976
+9.90,240855.0468
+10.00,240855.1066
+10.10,37018.0353
+10.20,37018.0353
+10.30,37018.0353
+10.40,37018.0353
+10.50,37018.0353
+10.60,37018.0353
+10.70,37018.0353
+10.80,37018.0353
+10.90,37018.0353
+11.00,37018.0353
+11.10,37018.0353
+11.20,37018.0353
+11.30,37018.0353
+11.40,37018.0353
+11.50,37018.0353
+11.60,37018.0353
+11.70,37018.0353
+11.80,37018.0353
+11.90,37018.0353
+12.00,37018.0353
+12.10,37018.0353
+12.20,37018.0353
+12.30,37018.0353
+12.40,37018.0353
+12.50,37018.0353
+12.60,37018.0353
+12.70,37018.0353
+12.80,37018.0353
+12.90,37018.0353
+13.00,37018.0353
+13.10,37018.0353
+13.20,37018.0353
+13.30,37018.0353
+13.40,37018.0353
+13.50,37018.0353
+13.60,37018.0353
+13.70,37018.0353
+13.80,37018.0353
+13.90,37018.0353
+14.00,37018.0353
+14.10,37018.0353
+14.20,37018.0353
+14.30,37018.0353
+14.40,37018.0353
+14.50,37018.0353
+14.60,37018.0353
+14.70,37018.0353
+14.80,37018.0353
+14.90,37018.0353
+15.00,37018.0353
+15.10,37018.0353
+15.20,37018.0353
+15.30,37018.0353
+15.40,37018.0353
+15.50,37018.0353
+15.60,37018.0353
+15.70,37018.0353
+15.80,37018.0353
+15.90,37018.0353
+16.00,37018.0353
+16.10,37018.0353
+16.20,37018.0353
+16.30,37018.0353
+16.40,37018.0353
+16.50,37018.0353
+16.60,37018.0353
+16.70,37018.0353
+16.80,37018.0353
+16.90,37018.0353
+17.00,37018.0353
+17.10,37018.0353
+17.20,37018.0353
+17.30,37018.0353
+17.40,37018.0353
+17.50,37018.0353
+17.60,37018.0353
+17.70,37018.0353
+17.80,37018.0353
+17.90,37018.0353
+18.00,37018.0353
+18.10,37018.0353
+18.20,37018.0353
+18.30,37018.0353
+18.40,37018.0353
+18.50,37018.0353
+18.60,37018.0353
+18.70,37018.0353
+18.80,37018.0353
+18.90,37018.0353
+19.00,37018.0353
+19.10,37018.0353
+19.20,37018.0353
+19.30,37018.0353
+19.40,37018.0353
+19.50,37018.0353
+19.60,37018.0353
+19.70,37018.0353
+19.80,37018.0353
+19.90,37018.0353
+20.00,37018.0353
+20.10,37018.0353
+20.20,37018.0353
+20.30,37018.0353
+20.40,37018.0353
+20.50,37018.0353
+20.60,37018.0353
+20.70,37018.0353
+20.80,37018.0353
+20.90,37018.0353
+21.00,37018.0353
+21.10,37018.0353
+21.20,37018.0353
+21.30,37018.0353
+21.40,37018.0353
+21.50,37018.0353
+21.60,37018.0353
+21.70,37018.0353
+21.80,37018.0353
+21.90,37018.0353
+22.00,37018.0353
+22.10,37018.0353
+22.20,37018.0353
+22.30,37018.0353
+22.40,37018.0353
+22.50,37018.0353
+22.60,37018.0353
+22.70,37018.0353
+22.80,37018.0353
+22.90,37018.0353
+23.00,37018.0353
+23.10,37018.0353
+23.20,37018.0353
+23.30,37018.0353
+23.40,37018.0353
+23.50,37018.0353
+23.60,37018.0353
+23.70,37018.0353
+23.80,37018.0353
+23.90,37018.0353
+24.00,37018.0353
+24.10,37018.0353
+24.20,37018.0353
+24.30,37018.0353
+24.40,37018.0353
+24.50,37018.0353
+24.60,37018.0353
+24.70,37018.0353
+24.80,37018.0353
+24.90,37018.0353
+25.00,37018.0353

VectoCoreTest/TestData/Results/EngineFullLoadJumps/EngineFLJ_1000rpm_1Hz.csv

 t,Pe_FullDyn
-0,150534.647985
-1,206985.140979
-2,228154.075852
-3,236092.426429
-4,239069.307895
-5,240185.638445
-6,240604.262401
-7,240761.246385
-8,240820.115379
-9,240842.191252
-10,240850.469704
-11,90362.676139
-12,33929.753552
-13,12767.407582
-14,4831.527843
-15,1855.572941
-16,739.589853
-17,321.096195
-18,164.161073
-19,105.310402
-20,83.241401
-21,74.965525
-22,71.862072
-23,70.698277
-24,70.261854
-25,70.098195
+2.0,37018.0353
+3.0,202355.5247
+4.0,233583.7427
+5.0,239481.9912
+6.0,240596.0264
+7.0,240806.4405
+8.0,240846.1826
+9.0,240853.6889
+10.0,240855.1066
+11.0,195373.1647
+12.0,195373.1647
+13.0,195373.1647
+14.0,195373.1647
+15.0,195373.1647
+16.0,195373.1647
+17.0,195373.1647
+18.0,195373.1647
+19.0,195373.1647
+20.0,195373.1647
+21.0,195373.1647
+22.0,195373.1647
+23.0,195373.1647
+24.0,195373.1647
+25.0,195373.1647

VectoCoreTest/TestData/Results/EngineFullLoadJumps/EngineFLJ_1000rpm_varHz.csv

+t,Pe_FullDyn
+2.00,37018.0353
+3.25,215474.7305
+3.65,227824.5477
+3.85,231518.3967
+4.55,237947.8524
+5.45,240206.667
+6.15,240653.4078
+6.25,240684.4229
+6.45,240732.9
+7.25,240823.1364
+7.95,240845.3783
+8.35,240850.2726
+8.65,240852.3045
+8.85,240853.1924
+9.65,240854.8452
+9.95,240855.078
+10.00,240855.1066
+10.40,117221.8032
+11.20,177379.8128
+12.00,177379.8128
+12.20,68310.8016
+13.20,195373.1647
+13.40,68310.8016
+14.10,165867.8474
+14.20,37018.0353
+14.90,165867.8474
+15.00,37018.0353
+15.90,187124.4811
+16.10,68310.8016
+16.50,117221.8032
+16.70,68310.8016
+17.30,152268.0673
+18.20,187124.4811
+18.60,117221.8032
+19.00,117221.8032
+19.50,136201.8254
+19.60,37018.0353
+20.00,117221.8032
+20.90,187124.4811
+21.70,177379.8128
+21.80,37018.0353
+21.90,37018.0353
+22.60,165867.8474
+23.50,187124.4811
+24.20,165867.8474
+24.90,165867.8474
+25,0

VectoCoreTest/TestData/Results/EngineOnlyCycles/24tCoach_EngineOnlyFullLoad.vmod

+time [s], simulation_interval [s], n [1/min], Tq_eng [Nm], Tq_clutch [Nm], Tq_full [Nm], Tq_drag [Nm], Pe_eng [kW], Pe_full [kW], Pe_drag [kW], Pe_clutch [kW], Pa [Eng], Paux [kW], FC [g/h], FC-AUXc [g/h], FC-WHTCc [g/h], dist, v_act, v_targ, acc, grad, Gear, Ploss GB, Ploss Diff, Ploss Retarder, Pa GB, Pa Veh, Proll, Pair, Pgrad, Pwheel, Pbrake, Paux_xxx, TCν, TCµ, TC_M_Out, TC_n_Out
+0.5,1,600,15.386822685582,,196.810428690233,-148,966.782582222265,12365.9639384619,-9299.11425462579,,966.782582222265,0,1605.0978813996,,,,,,,,,,,,,,,,,,,,,,,
+1.5,1,600,0,,1042.76767257274,-148,0,65519.0251911089,-9299.11425462579,,0,0,1459,,,,,,,,,,,,,,,,,,,,,,,
+2.5,1,600,0,,1039.86147716225,-148,0,65336.4235480788,-9299.11425462579,,0,0,1459,,,,,,,,,,,,,,,,,,,,,,,
+3.5,1,600,1039.86147716225,,1039.86147716225,-148,65336.4235480788,65336.4235480788,-9299.11425462579,,0,0,12495.5247317779,,,,,,,,,,,,,,,,,,,,,,,
+4.5,1,600,1236.26594052882,,1236.26594052882,-148,77676.8799329725,77676.8799329725,-9299.11425462579,,0,0,14688.8211268694,,,,,,,,,,,,,,,,,,,,,,,
+5.5,1,600,1273.36195194717,,1273.36195194717,-148,80007.6910719599,80007.6910719599,-9299.11425462579,,0,0,15187.8077194845,,,,,,,,,,,,,,,,,,,,,,,
+6.5,1,600,1280.36848346668,,1280.36848346668,-148,80447.9244309367,80447.9244309367,-9299.11425462579,,0,0,15282.0541129726,,,,,,,,,,,,,,,,,,,,,,,
+7.5,1,600,1281.69184633123,,1281.69184633123,-148,80531.0737720026,80531.0737720026,-9299.11425462579,,0,0,15299.8549573579,,,,,,,,,,,,,,,,,,,,,,,
+8.5,1,600,1281.94179729004,,1281.94179729004,-148,80546.778653922,80546.778653922,-9299.11425462579,,0,0,15303.2171025722,,,,,,,,,,,,,,,,,,,,,,,
+9.5,1,600,1281.98900692807,,1281.98900692807,-148,80549.744922962,80549.744922962,-9299.11425462579,,0,0,15303.8521297764,,,,,,,,,,,,,,,,,,,,,,,
+10.5,1,600,1281.99792367691,,1281.99792367691,-148,80550.3051788151,80550.3051788151,-9299.11425462579,,0,0,15303.9720709224,,,,,,,,,,,,,,,,,,,,,,,
+11.5,1,1200,179.070781254618,,1986.6551788091,-179,22502.6980344837,249650.452598511,-22493.8033997029,,22502.6980344837,0,6521.3205235204,,,,,,,,,,,,,,,,,,,,,,,
+12.5,1,1200,0,,1899.40821523367,-179,0,238686.675805848,-22493.8033997029,,0,0,3307,,,,,,,,,,,,,,,,,,,,,,,
+13.5,1,1200,0,,1865.58611347361,-179,0,234436.465149113,-22493.8033997029,,0,0,3307,,,,,,,,,,,,,,,,,,,,,,,
+14.5,1,1200,1865.58611347361,,1865.58611347361,-179,234436.465149113,234436.465149113,-22493.8033997029,,0,0,43404.1092839306,,,,,,,,,,,,,,,,,,,,,,,
+15.5,1,1200,2217.94981530132,,2217.94981530132,-179,278715.793831259,278715.793831259,-22493.8033997029,,0,0,52348.2396838385,,,,,,,,,,,,,,,,,,,,,,,
+16.5,1,1200,2284.5027219021,,2284.5027219021,-179,287079.078729341,287079.078729341,-22493.8033997029,,0,0,54443.9907126972,,,,,,,,,,,,,,,,,,,,,,,
+17.5,1,1200,2297.07294225692,,2297.07294225692,-179,288658.699206169,288658.699206169,-22493.8033997029,,0,0,54839.8269516703,,,,,,,,,,,,,,,,,,,,,,,
+18.5,1,1200,2299.44715020424,,2299.44715020424,-179,288957.050975984,288957.050975984,-22493.8033997029,,0,0,54914.5907599313,,,,,,,,,,,,,,,,,,,,,,,
+19.5,1,1200,2299.89558016155,,2299.89558016155,-179,289013.402346366,289013.402346366,-22493.8033997029,,0,0,54928.7118192871,,,,,,,,,,,,,,,,,,,,,,,
+20.5,1,1200,2299.98027764006,,2299.98027764006,-179,289024.045745418,289024.045745418,-22493.8033997029,,0,0,54931.3789428856,,,,,,,,,,,,,,,,,,,,,,,
+21.5,1,1200,2299.99627492738,,2299.99627492738,-179,289026.05602383,289026.05602383,-22493.8033997029,,0,0,54931.8826974631,,,,,,,,,,,,,,,,,,,,,,,

VectoCoreTest/VectoCoreTest.csproj

@@ -141,6 +141,12 @@
     <None Include="TestData\Components\ShiftPolygons.vgbs">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Cycles\Coach Engine Only FullLoad.vdri">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Cycles\Coach Engine Only Paux_var-dt.vdri">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Cycles\Coach time based.vdri">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -165,6 +171,21 @@
     <None Include="TestData\Cycles\Coach Engine Only.vdri">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\EngineFullLoadJumps.csv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_10Hz.csv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_1Hz.csv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Results\EngineFullLoadJumps\EngineFLJ_1000rpm_varHz.csv">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Results\EngineOnlyCycles\24tCoach_EngineOnlyFullLoad.vmod">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Results\EngineOnlyCycles\24tCoach_EngineOnlyPaux.vmod">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>