Code development platform for open source projects from the European Union institutions :large_blue_circle: EU Login authentication by SMS has been phased out. To see alternatives please check here

Skip to content
Snippets Groups Projects
Select Git revision
  • 63f0d770be42d9b0b8213e72c1f2acde1cf1874d
  • stable default
  • feat-fchv-bus
  • fix-h2-ice-bus
  • powertrains-multiple-axles
  • amdm3/develop
  • issue-1039
  • amdm3/main
  • test/nuget_publish
  • IEPC-experiments
  • amdm2/main
  • amdm2/develop
  • aptngearbox-not-auto
  • playground
  • official/main
  • official/develop
  • issue-templates
  • pdf-reports
  • HEV-timeruns-dev
  • timerun-empower-hybrids
  • timerun-pwheel-hybrids
  • Release/v5.0.3
  • Release/v5.0.1
  • Release/5.0.0-RC
  • Nuget/v0.11.4-DEV
  • Release/v0.11.4-DEV
  • Release/4.3.4-DEV
  • Release/4.3.3
  • Release/4.3.2-RC
  • Release/v4.3.0-DEV
  • Release/4.2.7
  • XMLConverterTool/4.2.6.0
  • Release/4.2.6-RC
  • Release/v4.2.5
  • Release/v4.2.3
  • Release/v4.2.2.3539-RC
  • Release/v4.2.1.3469
  • Release/v0.11.2.3456-DEV
  • Release/v4.2.0.3448-RC
  • Release/v4.1.3.3415
  • Release/v4.1.1.3413
41 results

ManufacturerReportXMLFile.cs

Blame
  • Forked from VECTO / VECTO Sim
    Source project has a limited visibility.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    ParallelHybridTest.cs 45.59 KiB
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using Newtonsoft.Json;
    using NUnit.Framework;
    using TUGraz.VectoCommon.InputData;
    using TUGraz.VectoCommon.Models;
    using TUGraz.VectoCommon.Utils;
    using TUGraz.VectoCore.Configuration;
    using TUGraz.VectoCore.InputData.FileIO.JSON;
    using TUGraz.VectoCore.InputData.Impl;
    using TUGraz.VectoCore.InputData.Reader.ComponentData;
    using TUGraz.VectoCore.InputData.Reader.ShiftStrategy;
    using TUGraz.VectoCore.Models.Declaration;
    using TUGraz.VectoCore.Models.Simulation.Data;
    using TUGraz.VectoCore.Models.Simulation.Impl;
    using TUGraz.VectoCore.Models.SimulationComponent;
    using TUGraz.VectoCore.Models.SimulationComponent.Data;
    using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
    using TUGraz.VectoCore.Models.SimulationComponent.Impl;
    using TUGraz.VectoCore.Models.SimulationComponent.Strategies;
    using TUGraz.VectoCore.OutputData;
    using TUGraz.VectoCore.OutputData.FileIO;
    using TUGraz.VectoCore.OutputData.ModFilter;
    using TUGraz.VectoCore.Tests.Utils;
    using TUGraz.VectoCore.Utils;
    using ElectricSystem = TUGraz.VectoCore.Models.SimulationComponent.ElectricSystem;
    using Wheels = TUGraz.VectoCore.Models.SimulationComponent.Impl.Wheels;
    
    namespace TUGraz.VectoCore.Tests.Integration.Hybrid
    {
    	[TestFixture]
    	[Parallelizable(ParallelScope.All)]
    	public class ParallelHybridTest
    	{
    		//private ModalResultField[] Yfields;
    		public const string MotorFile = @"TestData\Hybrids\ElectricMotor\GenericEMotor.vem";
    		public const string BatFile = @"TestData\Hybrids\Battery\GenericBattery.vbat";
    
    		public const string AccelerationFile = @"TestData\Components\Truck.vacc";
    		public const string MotorFile240kW = @"TestData\Hybrids\ElectricMotor\GenericEMotor240kW.vem";
    
    		public const string GearboxIndirectLoss = @"TestData\Components\Indirect Gear.vtlm";
    		public const string GearboxDirectLoss = @"TestData\Components\Direct Gear.vtlm";
    
    
    		public const bool PlotGraphs = true;
    
    		[OneTimeSetUp]
    		public void RunBeforeAnyTests()
    		{
    			Directory.SetCurrentDirectory(TestContext.CurrentContext.TestDirectory);
    
    
    			//InitGraphWriter();
    		}
    
    
    		private GraphWriter GetGraphWriter(ModalResultField[] emYFields)
    		{
    			var Yfields = new[] {
    				ModalResultField.v_act, ModalResultField.altitude, ModalResultField.acc, ModalResultField.Gear,
    				ModalResultField.P_ice_out, ModalResultField.BatterySOC, ModalResultField.FCMap
    			}.Concat(emYFields).ToArray();
    
    			var graphWriter = new GraphWriter();
    			graphWriter.Xfields = new[] { ModalResultField.dist };
    			graphWriter.Yfields = Yfields;
    			graphWriter.Series1Label = "Hybrid";
    			graphWriter.PlotIgnitionState = true;
    
    			if (PlotGraphs) {
    				graphWriter.Enable();
    			} else {
    				graphWriter.Disable();
    			}
    
    			return graphWriter;
    		}
    		
    
    		[
    			TestCase(30, 0.7, 0, TestName = "P2 Hybrid DriveOff 30km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, TestName = "P2 Hybrid DriveOff 80km/h SoC: 0.7, level"),
    		TestCase(30, 0.22, 0, TestName = "P2 Hybrid DriveOff 30km/h SoC: 0.22, level")
    			]
    		public void P2HybridDriveOff(double vmax, double initialSoC, double slope)
    		{
    			var GraphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P2 });
    			var cycleData = string.Format(
    				@"   0,   0, {1},    3
    				   700, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P2_acc_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP2;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    			
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			//run.Run();
    			job.Execute();
    			job.WaitFinished();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			GraphWriter.Write(modFilename);
    		}
    
    		[
    		TestCase(30, 0.7, 0, 0, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.7, level"),
    		TestCase(50, 0.7, 0, 0, TestName = "P2 Hybrid ConstantSpeed 50km/h SoC: 0.7, level"),
    		TestCase(80, 0.7, 0, 0, TestName = "P2 Hybrid ConstantSpeed 80km/h SoC: 0.7, level"),
    
    		TestCase(30, 0.25, 0, 0, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.25, level"),
    		TestCase(50, 0.25, 0, 0, TestName = "P2 Hybrid ConstantSpeed 50km/h SoC: 0.25, level"),
    		TestCase(80, 0.25, 0, 0, TestName = "P2 Hybrid ConstantSpeed 80km/h SoC: 0.25, level"),
    
    		TestCase(30, 0.5, 5, 0, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.5, UH 5%"),
    		TestCase(50, 0.5, 5, 0, TestName = "P2 Hybrid ConstantSpeed 50km/h SoC: 0.5, UH 5%"),
    		TestCase(80, 0.5, 5, 0, TestName = "P2 Hybrid ConstantSpeed 80km/h SoC: 0.5, UH 5%"),
    
    		TestCase(30, 0.5, -5, 0, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.5, DH 5%"),
    		TestCase(50, 0.5, -5, 0, TestName = "P2 Hybrid ConstantSpeed 50km/h SoC: 0.5, DH 5%"),
    		TestCase(80, 0.5, -5, 0, TestName = "P2 Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
    
    		TestCase(30, 0.25, 0, 1000, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
    			TestCase(30, 0.25, 0, 5000, TestName = "P2 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
    		]
    		public void P2HybridConstantSpeed(double vmax, double initialSoC, double slope, double  pAuxEl)
    		{
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				  7000, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P2_constant_{0}-{1}_{2}_{3}.vmod", vmax, initialSoC, slope, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP2;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    			
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P2 });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase("LongHaul", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Construction", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Urban", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Suburban", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Interurban", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Coach", 2000, 0.5, 0, TestName = "P2 Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    
    			TestCase("LongHaul", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("Construction", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("Urban", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("Suburban", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("Interurban", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    			TestCase("Coach", 2000, 0.5, 2000, TestName = "P2 Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 2kW"),
    		]
    		public void P2HybriDriveCycle(string declarationMission, double payload, double initialSoC, double pAuxEl)
    		{
    			var cycleData = RessourceHelper.ReadStream(
    				DeclarationData.DeclarationDataResourcePrefix + ".MissionCycles." +
    				declarationMission +
    				Constants.FileExtensions.CycleFile);
    			var cycle = DrivingCycleDataReader.ReadFromStream(cycleData, CycleType.DistanceBased, "", false);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P2_cycle_{0}-{1}_{2}_{3}.vmod", declarationMission, initialSoC, payload, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP2;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl, payload: payload.SI<Kilogram>());
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    			job.Execute();
    			job.WaitFinished();
    			Assert.IsTrue(modData.Rows.Count > 0);
    
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P2 });
    			graphWriter.Write(modFilename);
    		}
    
    
    
    		[TestCase(0, TestName = "P2 Hybrid Group 5 DriveCycle LongHaul"),
    		TestCase(1, TestName = "P2 Hybrid Group 5 DriveCycle Coach"),
    		TestCase(2, TestName = "P2 Hybrid Group 5 DriveCycle Construction"),
    		TestCase(3, TestName = "P2 Hybrid Group 5 DriveCycle HeavyUrban"),
    		TestCase(4, TestName = "P2 Hybrid Group 5 DriveCycle Interurban"),
    		TestCase(5, TestName = "P2 Hybrid Group 5 DriveCycle MunicipalUtility"),
    		TestCase(6, TestName = "P2 Hybrid Group 5 DriveCycle RegionalDelivery"),
    		TestCase(7, TestName = "P2 Hybrid Group 5 DriveCycle Suburban"),
    		TestCase(8, TestName = "P2 Hybrid Group 5 DriveCycle Urban"),
    		TestCase(9, TestName = "P2 Hybrid Group 5 DriveCycle UrbanDelivery"),
    			]
    		public void P2HybridGroup5DriveCycle(int cycleIdx)
    		{
    			var inputProvider = JSONInputDataFactory.ReadJsonJob(@"TestData\Hybrids\GenericVehicle_Group5_P2\P2 Group 5.vecto");
    
    			var factory = new SimulatorFactory(ExecutionMode.Engineering, inputProvider, null) {
    				Validate = false
    			};
    
    			var sumContainer = new SummaryDataContainer(null);
    			var jobContainer = new JobContainer(sumContainer);
    
    			factory.SumData = sumContainer;
    
    			var run = factory.SimulationRuns().ToArray()[cycleIdx];
    
    			Assert.NotNull(run);
    
    			var pt = run.GetContainer();
    
    			Assert.NotNull(pt);
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			//jobContainer.AddRuns(factory);
    			//jobContainer.Execute();
    			//jobContainer.WaitFinished();
    			//Assert.IsTrue(jobContainer.GetProgress().All(x => x.Value.Success));
    		}
    
    		[
    			TestCase(80, 0, TestName = "Conventional DriveOff 80km/h  level"),
    		]
    		public void ConventionalVehicleDriveOff(double vmax, double slope)
    		{
    			var cycleData = string.Format(
    				@"   0,   0, {1},    3
    				   700, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			//const bool largeMotor = true;
    
    			//const PowertrainPosition pos = PowertrainPosition.HybridP2;
    			var run = CreateConventionalEngineeringRun(
    				cycle, string.Format("ConventionalVehicle_acc_{0}_{1}.vmod", vmax, slope));
    
    			//var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			//Assert.NotNull(hybridController);
    			//var strategy = (DelegateParallelHybridStrategy)hybridController.Strategy;
    			//Assert.NotNull(strategy);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    		}
    
    
    		[TestCase(50, 0.79, 0, TestName = "P2 Hybrid Brake Standstill 50km/h SoC: 0.79, level"),
    		TestCase(50, 0.25, 0, TestName = "P2 Hybrid Brake Standstill 50km/h SoC: 0.25, level"),
    		TestCase(50, 0.65, 0, TestName = "P2 Hybrid Brake Standstill 50km/h SoC: 0.65, level")
    		]
    		public void P2HybridBrakeStandstill(double vmax, double initialSoC, double slope)
    		{
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				   200,   0, {1},    3", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P2_stop_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP2;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    			//var strategy = (DelegateParallelHybridStrategy)hybridController.Strategy;
    			//Assert.NotNull(strategy);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P2 });
    			graphWriter.Write(modFilename);
    		}
    
    		// - - - - - - - - - - - - - - - - - - - - - - - - - 
    
    
    		[
    			TestCase(30, 0.7, 0, 0, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.7, level"),
    			TestCase(50, 0.7, 0, 0, TestName = "P3 Hybrid ConstantSpeed 50km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, 0, TestName = "P3 Hybrid ConstantSpeed 80km/h SoC: 0.7, level"),
    
    			TestCase(30, 0.25, 0, 0, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.25, level"),
    			TestCase(50, 0.25, 0, 0, TestName = "P3 Hybrid ConstantSpeed 50km/h SoC: 0.25, level"),
    			TestCase(80, 0.25, 0, 0, TestName = "P3 Hybrid ConstantSpeed 80km/h SoC: 0.25, level"),
    
    			TestCase(30, 0.5, 5, 0, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.5, UH 5%"),
    			TestCase(50, 0.5, 5, 0, TestName = "P3 Hybrid ConstantSpeed 50km/h SoC: 0.5, UH 5%"),
    			TestCase(80, 0.5, 5, 0, TestName = "P3 Hybrid ConstantSpeed 80km/h SoC: 0.5, UH 5%"),
    
    			TestCase(30, 0.5, -5, 0, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.5, DH 5%"),
    			TestCase(50, 0.5, -5, 0, TestName = "P3 Hybrid ConstantSpeed 50km/h SoC: 0.5, DH 5%"),
    			TestCase(80, 0.5, -5, 0, TestName = "P3 Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
    
    			TestCase(30, 0.25, 0, 1000, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
    			TestCase(30, 0.25, 0, 5000, TestName = "P3 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
    		]
    		public void P3HybridConstantSpeed(double vmax, double initialSoC, double slope, double pAuxEl)
    		{
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				  7000, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P3_constant_{0}-{1}_{2}_{3}.vmod", vmax, initialSoC, slope, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P3 });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase(30, 0.7, 0, TestName = "P3 Hybrid DriveOff 30km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, TestName = "P3 Hybrid DriveOff 80km/h SoC: 0.7, level"),
    			TestCase(30, 0.22, 0, TestName = "P3 Hybrid DriveOff 30km/h SoC: 0.22, level")
    		]
    		public void P3HybridDriveOff(double vmax, double initialSoC, double slope)
    		{
    			var cycleData = string.Format(
    				@"   0,   0, {1},    3
    				   700, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P3_acc_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P3 });
    			graphWriter.Write(modFilename);
    		}
    
    		[TestCase(50, 0.79, 0, TestName = "P3 Hybrid Brake Standstill 50km/h SoC: 0.79, level"),
    		TestCase(50, 0.25, 0, TestName = "P3 Hybrid Brake Standstill 50km/h SoC: 0.25, level"),
    		TestCase(50, 0.65, 0, TestName = "P3 Hybrid Brake Standstill 50km/h SoC: 0.65, level")
    		]
    		public void P3HybridBrakeStandstill(double vmax, double initialSoC, double slope)
    		{
    			//var dst =
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				   200,   0, {1},    3", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P3_stop_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    			//var strategy = (DelegateParallelHybridStrategy)hybridController.Strategy;
    			//Assert.NotNull(strategy);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P3 });
    			graphWriter.Write(modFilename);
    		}
    
    
    		[
    			TestCase("LongHaul", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Construction", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Urban", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Suburban", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Interurban", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Coach", 2000, 0.5, 0, TestName = "P3 Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    		]
    		public void P3HybriDriveCycle(string declarationMission, double payload, double initialSoC, double pAuxEl)
    		{
    			var cycleData = RessourceHelper.ReadStream(
    				DeclarationData.DeclarationDataResourcePrefix + ".MissionCycles." +
    				declarationMission +
    				Constants.FileExtensions.CycleFile);
    			var cycle = DrivingCycleDataReader.ReadFromStream(cycleData, CycleType.DistanceBased, "", false);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P3_cycle_{0}-{1}_{2}_{3}.vmod", declarationMission, initialSoC, payload, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl, payload: payload.SI<Kilogram>());
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P3 });
    			graphWriter.Write(modFilename);
    		}
    
    		// - - - - - - - - - - - - - - - - - - - - - - - - - 
    
    		[
    			TestCase(30, 0.7, 0, 0, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.7, level"),
    			TestCase(50, 0.7, 0, 0, TestName = "P4 Hybrid ConstantSpeed 50km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, 0, TestName = "P4 Hybrid ConstantSpeed 80km/h SoC: 0.7, level"),
    
    			TestCase(30, 0.25, 0, 0, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level"),
    			TestCase(50, 0.25, 0, 0, TestName = "P4 Hybrid ConstantSpeed 50km/h SoC: 0.25, level"),
    			TestCase(80, 0.25, 0, 0, TestName = "P4 Hybrid ConstantSpeed 80km/h SoC: 0.25, level"),
    
    			TestCase(30, 0.5, 5, 0, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.5, UH 5%"),
    			TestCase(50, 0.5, 5, 0, TestName = "P4 Hybrid ConstantSpeed 50km/h SoC: 0.5, UH 5%"),
    			TestCase(80, 0.5, 5, 0, TestName = "P4 Hybrid ConstantSpeed 80km/h SoC: 0.5, UH 5%"),
    
    			TestCase(30, 0.5, -5, 0, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.5, DH 5%"),
    			TestCase(50, 0.5, -5, 0, TestName = "P4 Hybrid ConstantSpeed 50km/h SoC: 0.5, DH 5%"),
    			TestCase(80, 0.5, -5, 0, TestName = "P4 Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
    
    			TestCase(30, 0.25, 0, 1000, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
    			TestCase(30, 0.25, 0, 5000, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
    		]
    		public void P4HybridConstantSpeed(double vmax, double initialSoC, double slope, double pAuxEl)
    		{
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				  7000, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P4_constant_{0}-{1}_{2}_{3}.vmod", vmax, initialSoC, slope, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P3 });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase(30, 0.7, 0, TestName = "P4 Hybrid DriveOff 30km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, TestName = "P4 Hybrid DriveOff 80km/h SoC: 0.7, level"),
    			TestCase(30, 0.22, 0, TestName = "P4 Hybrid DriveOff 30km/h SoC: 0.22, level")
    		]
    		public void P4HybridDriveOff(double vmax, double initialSoC, double slope)
    		{
    			var cycleData = string.Format(
    				@"   0,   0, {1},    3
    				   700, {0}, {1},    0", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P4_acc_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P4 });
    			graphWriter.Write(modFilename);
    		}
    
    		[TestCase(50, 0.79, 0, TestName = "P4 Hybrid Brake Standstill 50km/h SoC: 0.79, level"),
    		TestCase(50, 0.25, 0, TestName = "P4 Hybrid Brake Standstill 50km/h SoC: 0.25, level"),
    		TestCase(50, 0.65, 0, TestName = "P4 Hybrid Brake Standstill 50km/h SoC: 0.65, level")
    		]
    		public void P4HybridBrakeStandstill(double vmax, double initialSoC, double slope)
    		{
    			var cycleData = string.Format(
    				@"   0, {0}, {1},    0
    				   200,   0, {1},    3", vmax, slope);
    			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P4_stop_{0}-{1}_{2}.vmod", vmax, initialSoC, slope);
    			const PowertrainPosition pos = PowertrainPosition.HybridP4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    			//var strategy = (DelegateParallelHybridStrategy)hybridController.Strategy;
    			//Assert.NotNull(strategy);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P4 });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase("LongHaul", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Construction", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Urban", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Suburban", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Interurban", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Coach", 2000, 0.5, 0, TestName = "P4 Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    		]
    		public void P4HybriDriveCycle(string declarationMission, double payload, double initialSoC, double pAuxEl)
    		{
    			var cycleData = RessourceHelper.ReadStream(
    				DeclarationData.DeclarationDataResourcePrefix + ".MissionCycles." +
    				declarationMission +
    				Constants.FileExtensions.CycleFile);
    			var cycle = DrivingCycleDataReader.ReadFromStream(cycleData, CycleType.DistanceBased, "", false);
    
    			const bool largeMotor = true;
    
    			var modFilename = string.Format("SimpleParallelHybrid-P4_cycle_{0}-{1}_{2}_{3}.vmod", declarationMission, initialSoC, payload, pAuxEl);
    			const PowertrainPosition pos = PowertrainPosition.HybridP4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 1.0, largeMotor: true, pAuxEl: pAuxEl, payload: payload.SI<Kilogram>());
    			var run = job.Runs.First().Run;
    
    			var hybridController = (HybridController)((VehicleContainer)run.GetContainer()).HybridController;
    			Assert.NotNull(hybridController);
    
    			var modData = ((ModalDataContainer)((VehicleContainer)run.GetContainer()).ModData).Data;
    
    			var data = run.GetContainer().RunData;
    			//File.WriteAllText(
    			//	$"{modFilename}.json",
    			//	JsonConvert.SerializeObject(data, Formatting.Indented));
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    
    			Assert.IsTrue(modData.Rows.Count > 0);
    			
    			var graphWriter = GetGraphWriter(new[] { ModalResultField.P_electricMotor_mech_P4 });
    			graphWriter.Write(modFilename);
    		}
    
    		// =================================================
    
    		public static JobContainer CreateEngineeringRun(DrivingCycleData cycleData, string modFileName, double initialSoc, PowertrainPosition pos, double ratio, bool largeMotor = false, double pAuxEl = 0, Kilogram payload = null)
    		{
    			var fileWriter = new FileOutputWriter(Path.GetFileNameWithoutExtension(modFileName));
    			var sumData = new SummaryDataContainer(fileWriter);
    			var jobContainer = new JobContainer(sumData);
    			var container = CreateParallelHybridPowerTrain(
    				cycleData,modFileName, initialSoc, largeMotor, sumData, pAuxEl, pos, ratio, payload);
    			var run = new DistanceRun(container);
    			jobContainer.AddRun(run);
    			return jobContainer;
    		}
    
    		public static VectoRun CreateConventionalEngineeringRun(DrivingCycleData cycleData, string modFileName, 
    			SummaryDataContainer sumData = null, double pAuxEl = 0)
    		{
    			var container = CreateConventionalPowerTrain(
    				cycleData, Path.GetFileNameWithoutExtension(modFileName), sumData, pAuxEl);
    			return new DistanceRun(container);
    		}
    
    		public static VehicleContainer CreateParallelHybridPowerTrain(DrivingCycleData cycleData, string modFileName,
    			double initialBatCharge, bool largeMotor, SummaryDataContainer sumData, double pAuxEl, PowertrainPosition pos, double ratio, Kilogram payload = null)
    		{ 
    			var gearboxData = CreateGearboxData();
    			var axleGearData = CreateAxleGearData();
    
    			var vehicleData = CreateVehicleData(payload ??3300.SI<Kilogram>());
    			var airdragData = CreateAirdragData();
    			var driverData = CreateDriverData(AccelerationFile, true);
    
    			var electricMotorData =
    				MockSimulationDataFactory.CreateElectricMotorData(largeMotor ? MotorFile240kW : MotorFile, 1, pos, ratio, 1);
    
    			var batteryData = MockSimulationDataFactory.CreateBatteryData(BatFile, initialBatCharge);
    			//batteryData.TargetSoC = 0.5;
    
    			var engineData = MockSimulationDataFactory.CreateEngineDataFromFile(
    				 Truck40tPowerTrain.EngineFile, gearboxData.Gears.Count);
    
    			foreach (var entry in gearboxData.Gears) {
    				entry.Value.ShiftPolygon = DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(
    					(int)entry.Key, engineData.FullLoadCurves[entry.Key], new TransmissionInputData().Repeat(gearboxData.Gears.Count + 1).Cast<ITransmissionInputData>().ToList(), engineData, axleGearData.AxleGear.Ratio,
    					vehicleData.DynamicTyreRadius);
    			}
    
    			var runData = new VectoRunData() {
    				//PowertrainConfiguration = PowertrainConfiguration.ParallelHybrid,
    				JobRunId = 0,
    				JobType = VectoSimulationJobType.ParallelHybridVehicle,
    				DriverData = driverData,
    				AxleGearData = axleGearData,
    				GearboxData = gearboxData,
    				VehicleData = vehicleData,
    				AirdragData = airdragData,
    				JobName = Path.GetFileNameWithoutExtension(modFileName),
    				Cycle = cycleData,
    				Retarder = new RetarderData() { Type = RetarderType.None },
    				Aux = new List<VectoRunData.AuxData>(),
    				ElectricMachinesData = electricMotorData,
    				EngineData = engineData,
    				BatteryData = batteryData,
    				GearshiftParameters = CreateGearshiftData(gearboxData, axleGearData.AxleGear.Ratio, engineData.IdleSpeed),
    				HybridStrategyParameters = CreateHybridStrategyData(),
    				ElectricAuxDemand = pAuxEl.SI<Watt>()
    			};
    			var fileWriter = new FileOutputWriter(modFileName);
    			var modDataFilter = new IModalDataFilter[] { }; //new IModalDataFilter[] { new ActualModalDataFilter(), };
    			var modData = new ModalDataContainer(runData, fileWriter, null, modDataFilter)
    			{
    				WriteModalResults = true,
    			};
    			var container = new VehicleContainer(
    				ExecutionMode.Engineering, modData, x => { sumData?.Write(x, 1, 1, runData); });
    			container.RunData = runData;
    
    			var strategy = new HybridStrategy(runData, container);
    			var es = new ElectricSystem(container);
    			var battery = new Battery(container, batteryData);
    			battery.Initialize(initialBatCharge);
    
    			var clutch = new SwitchableClutch(container, runData.EngineData);
    			var ctl = new HybridController(container, strategy, es, clutch);
    
    			es.Connect(battery);
    
    			var gearbox = new Gearbox(container, ctl.ShiftStrategy, runData);
    			//var hybridStrategy = new DelegateParallelHybridStrategy();
    			ctl.Gearbox = gearbox;
    
    			var engine = new StopStartCombustionEngine(container, runData.EngineData);
    			var idleController = engine.IdleController;
    			ctl.Engine = engine;
    
    			var cycle = new DistanceBasedDrivingCycle(container, cycleData);
    
    			var aux = new ElectricAuxiliary(container);
    			aux.AddConstant("P_aux_el", pAuxEl.SI<Watt>());
    			es.Connect(aux);
    
    			cycle
    				.AddComponent(new Driver(container, runData.DriverData, new DefaultDriverStrategy(container)))
    				.AddComponent(new Vehicle(container, runData.VehicleData, runData.AirdragData))
    				.AddComponent(new Wheels(container, runData.VehicleData.DynamicTyreRadius,
    					runData.VehicleData.WheelsInertia))
    				.AddComponent(ctl)
    				.AddComponent(new Brakes(container))
    				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP4, runData.ElectricMachinesData, container,
    					es, ctl))
    				.AddComponent(new AxleGear(container, runData.AxleGearData))
    				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP3, runData.ElectricMachinesData, container,
    					es, ctl))
    				.AddComponent(runData.AngledriveData != null ? new Angledrive(container, runData.AngledriveData) : null)
    				.AddComponent(gearbox, runData.Retarder, container)
    				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP2, runData.ElectricMachinesData, container,
    					es, ctl))
    				.AddComponent(clutch)
    				.AddComponent(GetElectricMachine(PowertrainPosition.HybridP1, runData.ElectricMachinesData, container,
    					es, ctl))
    				.AddComponent(engine, idleController)
    				.AddAuxiliaries(container, runData);
    
    			return container;
    		}
    
    		private static HybridStrategyParameters CreateHybridStrategyData()
    		{
    			return new HybridStrategyParameters() {
    				EquivalenceFactor = 2.5,
    				MinSoC = 0.22,
    				MaxSoC = 0.8,
    				TargetSoC = 0.5,
    				AuxReserveTime = 5.SI<Second>(),
    				AuxReserveChargeTime = 2.SI<Second>(),
    				MinICEOnTime = 3.SI<Second>()
    			};
    		}
    
    
    		public static VehicleContainer CreateConventionalPowerTrain(DrivingCycleData cycleData, string modFileName,
    			SummaryDataContainer sumData, double pAuxEl)
    		{
    			//var strategySettings = GetHybridStrategyParameters(largeMotor);
    
    			//strategySettings.StrategyName = "SimpleParallelHybridStrategy";
    
    			var gearboxData = CreateGearboxData();
    			var axleGearData = CreateAxleGearData();
    
    			var vehicleData = CreateVehicleData(3300.SI<Kilogram>());
    			var airdragData = CreateAirdragData();
    			var driverData = CreateDriverData(AccelerationFile, true);
    
    			var engineData = MockSimulationDataFactory.CreateEngineDataFromFile(
    				 Truck40tPowerTrain.EngineFile, gearboxData.Gears.Count);
    
    			foreach (var entry in gearboxData.Gears) {
    				entry.Value.ShiftPolygon = DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(
    					(int)entry.Key, engineData.FullLoadCurves[entry.Key], new TransmissionInputData().Repeat(gearboxData.Gears.Count + 1).Cast<ITransmissionInputData>().ToList(), engineData, axleGearData.AxleGear.Ratio,
    					vehicleData.DynamicTyreRadius);
    			}
    
    			var runData = new VectoRunData() {
    				//PowertrainConfiguration = PowertrainConfiguration.ParallelHybrid,
    				JobRunId = 0,
    				DriverData = driverData,
    				AxleGearData = axleGearData,
    				GearboxData = gearboxData,
    				VehicleData = vehicleData,
    				AirdragData = airdragData,
    				JobName = modFileName,
    				Cycle = cycleData,
    				Retarder = new RetarderData() { Type = RetarderType.None },
    				Aux = new List<VectoRunData.AuxData>(),
    				ElectricMachinesData = new List<Tuple<PowertrainPosition, ElectricMotorData>>(),
    				EngineData = engineData,
    				//BatteryData = batteryData,
    				//HybridStrategy = strategySettings
    				GearshiftParameters = CreateGearshiftData(gearboxData, axleGearData.AxleGear.Ratio, engineData.IdleSpeed)
    			};
    			var fileWriter = new FileOutputWriter(modFileName);
    			var modDataFilter = new IModalDataFilter[] { }; //new IModalDataFilter[] { new ActualModalDataFilter(), };
    			var modData = new ModalDataContainer(runData, fileWriter, null, modDataFilter)
    			{
    				WriteModalResults = true,
    			};
    
    			var container = new VehicleContainer(
    				ExecutionMode.Engineering, modData, x => { sumData?.Write(x, 1, 1, runData); });
    			container.RunData = runData;
    
    
    			var clutch = new SwitchableClutch(container, runData.EngineData);
    
    			var gbxStrategy = new AMTShiftStrategyOptimized(runData,container);
    			
    			var gearbox = new Gearbox(container, gbxStrategy, runData);
    
    			var engine = new StopStartCombustionEngine(container, runData.EngineData);
    			var idleController = engine.IdleController;
    			var cycle = new DistanceBasedDrivingCycle(container, cycleData);
    
    			var aux = new ElectricAuxiliary(container);
    			aux.AddConstant("P_aux_el", pAuxEl.SI<Watt>());
    			cycle
    				.AddComponent(new Driver(container, runData.DriverData, new DefaultDriverStrategy(container)))
    				.AddComponent(new Vehicle(container, runData.VehicleData, runData.AirdragData))
    				.AddComponent(new Wheels(container, runData.VehicleData.DynamicTyreRadius,
    					runData.VehicleData.WheelsInertia))
    				.AddComponent(new Brakes(container))
    				//.AddComponent(ctl)
    				//.AddComponent(GetElectricMachine(PowertrainPosition.HybridP4, runData.ElectricMachinesData, container,
    				//	es, ctl))
    				.AddComponent(new AxleGear(container, runData.AxleGearData))
    				//.AddComponent(GetElectricMachine(PowertrainPosition.HybridP3, runData.ElectricMachinesData, container,
    				//	es, ctl))
    				.AddComponent(runData.AngledriveData != null ? new Angledrive(container, runData.AngledriveData) : null)
    				.AddComponent(gearbox, runData.Retarder, container)
    				//.AddComponent(GetElectricMachine(PowertrainPosition.HybridP2, runData.ElectricMachinesData, container,
    				//	es, ctl))
    				.AddComponent(clutch)
    				//.AddComponent(GetElectricMachine(PowertrainPosition.HybridP1, runData.ElectricMachinesData, container,
    				//	es, ctl))
    				.AddComponent(engine, idleController)
    				.AddAuxiliaries(container, runData);
    
    			return container;
    		}
    
    		public static ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
    		{
    			var retVal = new ShiftStrategyParameters {
    				StartVelocity = DeclarationData.GearboxTCU.StartSpeed,
    				StartAcceleration = DeclarationData.GearboxTCU.StartAcceleration,
    				GearResidenceTime = DeclarationData.GearboxTCU.GearResidenceTime,
    				DnT99L_highMin1 = DeclarationData.GearboxTCU.DnT99L_highMin1,
    				DnT99L_highMin2 = DeclarationData.GearboxTCU.DnT99L_highMin2,
    				AllowedGearRangeUp = DeclarationData.GearboxTCU.AllowedGearRangeUp,
    				AllowedGearRangeDown = DeclarationData.GearboxTCU.AllowedGearRangeDown,
    				LookBackInterval = DeclarationData.GearboxTCU.LookBackInterval,
    				DriverAccelerationLookBackInterval = DeclarationData.GearboxTCU.DriverAccelerationLookBackInterval,
    				DriverAccelerationThresholdLow = DeclarationData.GearboxTCU.DriverAccelerationThresholdLow,
    				AverageCardanPowerThresholdPropulsion = DeclarationData.GearboxTCU.AverageCardanPowerThresholdPropulsion,
    				CurrentCardanPowerThresholdPropulsion = DeclarationData.GearboxTCU.CurrentCardanPowerThresholdPropulsion,
    				TargetSpeedDeviationFactor = DeclarationData.GearboxTCU.TargetSpeedDeviationFactor,
    				EngineSpeedHighDriveOffFactor = DeclarationData.GearboxTCU.EngineSpeedHighDriveOffFactor,
    				RatingFactorCurrentGear = gbx.Type.AutomaticTransmission()
    					? DeclarationData.GearboxTCU.RatingFactorCurrentGearAT
    					: DeclarationData.GearboxTCU.RatingFactorCurrentGear,
    				
    				//--------------------
    				RatioEarlyUpshiftFC = DeclarationData.GearboxTCU.RatioEarlyUpshiftFC / axleRatio,
    				RatioEarlyDownshiftFC = DeclarationData.GearboxTCU.RatioEarlyDownshiftFC / axleRatio,
    				AllowedGearRangeFC = gbx.Type.AutomaticTransmission()
    					? (gbx.Gears.Count > DeclarationData.GearboxTCU.ATSkipGearsThreshold
    						? DeclarationData.GearboxTCU.AllowedGearRangeFCATSkipGear
    						: DeclarationData.GearboxTCU.AllowedGearRangeFCAT)
    					: DeclarationData.GearboxTCU.AllowedGearRangeFCAMT,
    				VelocityDropFactor = DeclarationData.GearboxTCU.VelocityDropFactor,
    				AccelerationFactor = DeclarationData.GearboxTCU.AccelerationFactor,
    				MinEngineSpeedPostUpshift = 0.RPMtoRad(),
    				ATLookAheadTime = DeclarationData.GearboxTCU.ATLookAheadTime,
    
    				LoadStageThresoldsUp = DeclarationData.GearboxTCU.LoadStageThresholdsUp,
    				LoadStageThresoldsDown = DeclarationData.GearboxTCU.LoadStageThresoldsDown,
    				ShiftSpeedsTCToLocked = DeclarationData.GearboxTCU.ShiftSpeedsTCToLocked
    														.Select(x => x.Select(y => y + engineIdlingSpeed.AsRPM).ToArray()).ToArray(),
    			};
    
    			return retVal;
    		}
    
    		private static IElectricMotor GetElectricMachine(PowertrainPosition pos,
    			IList<Tuple<PowertrainPosition, ElectricMotorData>> electricMachinesData, VehicleContainer container,
    			IElectricSystem es, IHybridController ctl)
    		{
    			var motorData = electricMachinesData.FirstOrDefault(x => x.Item1 == pos);
    			if (motorData == null) {
    				return null;
    			}
    
    			container.ModData.AddElectricMotor(pos);
    			ctl.AddElectricMotor(pos, motorData.Item2);
    			var motor = new ElectricMotor(container, motorData.Item2, ctl.ElectricMotorControl(pos), pos);
    			motor.Connect(es);
    			return motor;
    		}
    
    		private static GearboxData CreateGearboxData()
    		{
    			var ratios = new[] { 14.93, 11.64, 9.02, 7.04, 5.64, 4.4, 3.39, 2.65, 2.05, 1.6, 1.28, 1.0 };
    
    			return new GearboxData {
    				Gears = ratios.Select(
    					(ratio, i) => Tuple.Create(
    						(uint)i, new GearData {
    							//MaxTorque = 2300.SI<NewtonMeter>(),
    							LossMap =
    								TransmissionLossMapReader.ReadFromFile(
    									ratio.IsEqual(1) ? GearboxIndirectLoss : GearboxDirectLoss, ratio,
    									string.Format("Gear {0}", i)),
    							Ratio = ratio,
    							//ShiftPolygon = DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(i,)
    						})).ToDictionary(k => k.Item1 + 1, v => v.Item2),
    				ShiftTime = 2.SI<Second>(),
    				Inertia = 0.SI<KilogramSquareMeter>(),
    				TractionInterruption = 1.SI<Second>(),
    				TorqueReserve = 0.2,
    				StartTorqueReserve = 0.2,
    				DownshiftAfterUpshiftDelay = DeclarationData.Gearbox.DownshiftAfterUpshiftDelay,
    				UpshiftAfterDownshiftDelay = DeclarationData.Gearbox.UpshiftAfterDownshiftDelay,
    				UpshiftMinAcceleration = DeclarationData.Gearbox.UpshiftMinAcceleration,
    				StartSpeed = 2.SI<MeterPerSecond>(),
    				StartAcceleration = 0.6.SI<MeterPerSquareSecond>(),
    			};
    		}
    
    		private static AxleGearData CreateAxleGearData()
    		{
    			var ratio = 2.59;
    			return new AxleGearData {
    				AxleGear = new GearData {
    					Ratio = ratio,
    					LossMap = TransmissionLossMapReader.Create(0.95, ratio, "Axlegear"),
    				}
    			};
    		}
    
    		private static VehicleData CreateVehicleData(Kilogram loading)
    		{
    			var axles = new List<Axle> {
    				new Axle {
    					AxleWeightShare = 0.38,
    					Inertia = 20.SI<KilogramSquareMeter>(),
    					RollResistanceCoefficient = 0.007,
    					TwinTyres = false,
    					TyreTestLoad = 30436.0.SI<Newton>()
    				},
    				new Axle {
    					AxleWeightShare = 0.62,
    					Inertia = 18.SI<KilogramSquareMeter>(),
    					RollResistanceCoefficient = 0.007,
    					TwinTyres = true,
    					TyreTestLoad = 30436.SI<Newton>()
    				},
    			};
    			return new VehicleData {
    				AirDensity = DeclarationData.AirDensity,
    				AxleConfiguration = AxleConfiguration.AxleConfig_4x2,
    				CurbMass = 11500.SI<Kilogram>(),
    				Loading = loading,
    				DynamicTyreRadius = 0.465.SI<Meter>(),
    				AxleData = axles,
    				SavedInDeclarationMode = false
    			};
    		}
    
    		private static AirdragData CreateAirdragData()
    		{
    			return new AirdragData() {
    				CrossWindCorrectionCurve =
    					new CrosswindCorrectionCdxALookup(
    						3.2634.SI<SquareMeter>(),
    						CrossWindCorrectionCurveReader.GetNoCorrectionCurve(3.2634.SI<SquareMeter>()),
    						CrossWindCorrectionMode.NoCorrection),
    			};
    		}
    
    		private static DriverData CreateDriverData(string accelerationFile, bool overspeed = false)
    		{
    			return new DriverData {
    				AccelerationCurve = AccelerationCurveReader.ReadFromFile(accelerationFile),
    				LookAheadCoasting = new DriverData.LACData {
    					Enabled = true,
    					MinSpeed = 50.KMPHtoMeterPerSecond(),
    
    					//Deceleration = -0.5.SI<MeterPerSquareSecond>()
    					LookAheadDistanceFactor = DeclarationData.Driver.LookAhead.LookAheadDistanceFactor,
    					LookAheadDecisionFactor = new LACDecisionFactor()
    				},
    				OverSpeed = new DriverData.OverSpeedData() {
    					Enabled = true,
    					MinSpeed = 50.KMPHtoMeterPerSecond(),
    					OverSpeed = 5.KMPHtoMeterPerSecond()
    				},
    				EngineStopStart = new DriverData.EngineStopStartData() {
    					EngineOffStandStillActivationDelay = DeclarationData.Driver.EngineStopStart.ActivationDelay,
    					MaxEngineOffTimespan = DeclarationData.Driver.EngineStopStart.MaxEngineOffTimespan,
    					UtilityFactor = DeclarationData.Driver.EngineStopStart.UtilityFactor
    				}
    			};
    		}
    	}
    }