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
  • 3327be7aca103fa3a05c869ac62bc94c673427e9
  • 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

SerialHybridTest.cs

Blame
  • Forked from VECTO / VECTO Sim
    3524 commits behind the upstream repository.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    SerialHybridTest.cs 42.21 KiB
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using NUnit.Framework;
    using TUGraz.VectoCommon.Exceptions;
    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.Impl;
    using TUGraz.VectoCore.Models.Declaration;
    using TUGraz.VectoCore.Models.Simulation.Data;
    using TUGraz.VectoCore.Models.Simulation.Impl;
    using TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory;
    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.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 SerialHybridTest
    	{
    		public const string BatFile = @"TestData\Hybrids\GenericVehicle_Sx\GenericBattery.vreess";
    
    		public const string AccelerationFile = @"TestData\Hybrids\GenericVehicle_Sx\Truck.vacc";
    		public const string MotorFile = @"TestData\Hybrids\GenericVehicle_Sx\GenericEMotor.vem";
    
    		public const string GeneratorFile = @"TestData\Hybrids\GenericVehicle_Sx\GenericGen.vem";
    
    		public const string GearboxIndirectLoss = @"TestData\Components\Indirect Gear.vtlm";
    		public const string GearboxDirectLoss = @"TestData\Components\Direct Gear.vtlm";
    
    		public const string EngineFile = @"TestData\Hybrids\GenericVehicle_Sx\Group2_6l.veng";
    
    
    		public const bool PlotGraphs = true;
    
    		[OneTimeSetUp]
    		public void RunBeforeAnyTests()
    		{
    			Directory.SetCurrentDirectory(TestContext.CurrentContext.TestDirectory);
    		}
    
    		// - - - - - - - - - - - - - - - - - - - - - - - - - 
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 0, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 1, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 2, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 3, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 4, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 5, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 6, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_3speed.vecto", 7, TestName = "Generic Serial Hybrid S2 AMT 3Speed Job, Coach"),
    		]
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 0, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 1, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 2, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 3, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 4, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 5, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 6, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2.vecto", 7, TestName = "Generic Serial Hybrid S2 AMT 12speed Job, Coach"),
    		]
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 0, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 1, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 2, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 3, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 4, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 5, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 6, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_APTN\HEV_S2_Group5LH_rl_APTN.vecto", 7, TestName = "Generic Serial Hybrid S2 APT-N 3speed Job, Coach"),
    		]
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 0, TestName = "Generic Serial Hybrid S2 APT-S Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 1, TestName = "Generic Serial Hybrid S2 APT-S Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 2, TestName = "Generic Serial Hybrid S2 APT-S Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 3, TestName = "Generic Serial Hybrid S2 APT-S Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 4, TestName = "Generic Serial Hybrid S2 APT-S Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 5, TestName = "Generic Serial Hybrid S2 APT-S Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 6, TestName = "Generic Serial Hybrid S2 APT-S Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTS.vecto", 7, TestName = "Generic Serial Hybrid S2 APT-S Job, Coach"),
    		]
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 0, TestName = "Generic Serial Hybrid S2 APT-P Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 1, TestName = "Generic Serial Hybrid S2 APT-P Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 2, TestName = "Generic Serial Hybrid S2 APT-P Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 3, TestName = "Generic Serial Hybrid S2 APT-P Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 4, TestName = "Generic Serial Hybrid S2 APT-P Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 5, TestName = "Generic Serial Hybrid S2 APT-P Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 6, TestName = "Generic Serial Hybrid S2 APT-P Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_AT\HEV_S2_Group5LH_rl_APTP.vecto", 7, TestName = "Generic Serial Hybrid S2 APT-P Job, Coach"),
    		]
    
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_S2_Job\SerialHybrid_S2_WHR.vecto", 1, TestName = "Generic Serial Hybrid S2 AMT WHR 12speed Job, RegionalDelivery"),
    		]
    		public void S2SerialHybridJob(string jobFile, int runIdx)
    		{
    			RunHybridJob(jobFile, runIdx);
    		}
    
    
    		// =================================================
    
    		[
    			TestCase(30, 0.7, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.7, level"),
    			TestCase(50, 0.7, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 50km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 80km/h SoC: 0.7, level"),
    
    			TestCase(30, 0.25, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level"),
    			TestCase(50, 0.25, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 50km/h SoC: 0.25, level"),
    			TestCase(80, 0.25, 0, 0, TestName = "S3 Serial Hybrid ConstantSpeed 80km/h SoC: 0.25, level"),
    
    			TestCase(30, 0.5, 5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.5, UH 5%"),
    			TestCase(50, 0.5, 5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 50km/h SoC: 0.5, UH 5%"),
    			TestCase(80, 0.5, 5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 80km/h SoC: 0.5, UH 5%"),
    
    			TestCase(30, 0.5, -5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.5, DH 5%"),
    			TestCase(50, 0.5, -5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 50km/h SoC: 0.5, DH 5%"),
    			TestCase(80, 0.5, -5, 0, TestName = "S3 Serial Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
    
    			TestCase(30, 0.25, 0, 1000, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
    			TestCase(30, 0.25, 0, 5000, TestName = "S3 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
    		]
    		public void S3HybridConstantSpeed(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 = $"SimpleParallelHybrid-S3_constant_{vmax}-{initialSoC}_{slope}_{pAuxEl}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47, pAuxEl: pAuxEl);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B3, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase(30, 0.7, 0, TestName = "S3 Serial Hybrid DriveOff 30km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, TestName = "S3 Serial Hybrid DriveOff 80km/h SoC: 0.7, level"),
    			TestCase(30, 0.22, 0, TestName = "S3 Serial Hybrid DriveOff 30km/h SoC: 0.22, level")
    		]
    		public void S3HybridDriveOff(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 = $"SimpleParallelHybrid-S3_acc_{vmax}-{initialSoC}_{slope}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B3, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    		[TestCase(50, 0.79, 0, TestName = "S3 Serial Hybrid Brake Standstill 50km/h SoC: 0.79, level"),
    		TestCase(50, 0.25, 0, TestName = "S3 Serial Hybrid Brake Standstill 50km/h SoC: 0.25, level"),
    		TestCase(50, 0.65, 0, TestName = "S3 Serial Hybrid Brake Standstill 50km/h SoC: 0.65, level")
    		]
    		public void S3HybridBrakeStandstill(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 = $"SimpleParallelHybrid-S3_stop_{vmax}-{initialSoC}_{slope}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B3, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    
    		[
    			TestCase("LongHaul", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Construction", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Urban", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Suburban", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Interurban", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Coach", 2000, 0.5, 0, TestName = "S3 Serial Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    		]
    		public void S3HybridDriveCycle(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 = $"SimpleParallelHybrid-S3_cycle_{declarationMission}-{initialSoC}_{payload}_{pAuxEl}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE3;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47, pAuxEl: pAuxEl, payload: payload.SI<Kilogram>());
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B3, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    		// =================================================
    
    		[
    			TestCase(30, 0.7, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.7, level"),
    			TestCase(50, 0.7, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 50km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 80km/h SoC: 0.7, level"),
    
    			TestCase(30, 0.25, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level"),
    			TestCase(50, 0.25, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 50km/h SoC: 0.25, level"),
    			TestCase(80, 0.25, 0, 0, TestName = "S4 Serial Hybrid ConstantSpeed 80km/h SoC: 0.25, level"),
    
    			TestCase(30, 0.5, 5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.5, UH 5%"),
    			TestCase(50, 0.5, 5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 50km/h SoC: 0.5, UH 5%"),
    			TestCase(80, 0.5, 5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 80km/h SoC: 0.5, UH 5%"),
    
    			TestCase(30, 0.5, -5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.5, DH 5%"),
    			TestCase(50, 0.5, -5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 50km/h SoC: 0.5, DH 5%"),
    			TestCase(80, 0.5, -5, 0, TestName = "S4 Serial Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
    
    			TestCase(30, 0.25, 0, 1000, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
    			TestCase(30, 0.25, 0, 5000, TestName = "S4 Serial Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
    		]
    		public void S4HybridConstantSpeed(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 = $"SimpleParallelHybrid-S4_constant_{vmax}-{initialSoC}_{slope}_{pAuxEl}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47, pAuxEl: pAuxEl);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B4, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    		[
    			TestCase(30, 0.7, 0, TestName = "S4 Serial Hybrid DriveOff 30km/h SoC: 0.7, level"),
    			TestCase(80, 0.7, 0, TestName = "S4 Serial Hybrid DriveOff 80km/h SoC: 0.7, level"),
    			TestCase(30, 0.22, 0, TestName = "S4 Serial Hybrid DriveOff 30km/h SoC: 0.22, level")
    		]
    		public void S4HybridDriveOff(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 = $"SimpleParallelHybrid-S4_acc_{vmax}-{initialSoC}_{slope}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B4, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    		[TestCase(50, 0.79, 0, TestName = "S4 Serial Hybrid Brake Standstill 50km/h SoC: 0.79, level"),
    		TestCase(50, 0.25, 0, TestName = "S4 Serial Hybrid Brake Standstill 50km/h SoC: 0.25, level"),
    		TestCase(50, 0.65, 0, TestName = "S4 Serial Hybrid Brake Standstill 50km/h SoC: 0.65, level")
    		]
    		public void S4HybridBrakeStandstill(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 = $"SimpleParallelHybrid-S4_stop_{vmax}-{initialSoC}_{slope}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47);
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B4, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    
    
    
    		[
    			TestCase("LongHaul", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle LongHaul, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("RegionalDelivery", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle RegionalDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("UrbanDelivery", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle UrbanDelivery, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Construction", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle Construction, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Urban", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle Urban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Suburban", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle SubUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Interurban", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle InterUrban, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    			TestCase("Coach", 2000, 0.5, 0, TestName = "S4 Serial Hybrid DriveCycle Coach, SoC: 0.5 Payload: 2t P_auxEl: 0kW"),
    		]
    		public void S4HybridDriveCycle(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);
    
    			var modFilename = $"SimpleSerialHybrid-S4_cycle_{declarationMission}-{initialSoC}_{payload}_{pAuxEl}.vmod";
    			const PowertrainPosition pos = PowertrainPosition.BatteryElectricE4;
    			var job = CreateEngineeringRun(
    				cycle, modFilename, initialSoC, pos, 12.47, pAuxEl: pAuxEl, payload: payload.SI<Kilogram>());
    			var run = job.Runs.First().Run;
    
    			var hybridController = (SerialHybridController)((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_B4, ModalResultField.P_electricMotor_mech_Gen });
    			graphWriter.Write(modFilename);
    		}
    
    
    
    		// =================================================
    
    		[
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 0, TestName = "Generic Serial Hybrid S4 Job, LongHaul"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 1, TestName = "Generic Serial Hybrid S4 Job, RegionalDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 2, TestName = "Generic Serial Hybrid S4 Job, UrbanDelivery"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 3, TestName = "Generic Serial Hybrid S4 Job, Construction"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 4, TestName = "Generic Serial Hybrid S4 Job, Urban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 5, TestName = "Generic Serial Hybrid S4 Job, Suburban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 6, TestName = "Generic Serial Hybrid S4 Job, Interurban"),
    			TestCase(@"TestData\Hybrids\GenericVehicle_Sx_Job\SerialHybrid_S4.vecto", 7, TestName = "Generic Serial Hybrid S4 Job, Coach"),
    		]
    		public void S4SerialHybridJob(string jobFile, int runIdx)
    		{
    			RunHybridJob(jobFile, runIdx);
    		}
    
    
    		// =================================================
    
    		private void RunHybridJob(string jobFile, int runIdx, int? startDistance = null)
    		{
    			var inputProvider = JSONInputDataFactory.ReadJsonJob(jobFile);
    
    			var writer = new FileOutputWriter(jobFile);
    			var factory = SimulatorFactory.CreateSimulatorFactory(ExecutionMode.Engineering, inputProvider, writer);
    			factory.Validate = false;
    			factory.WriteModalResults = true;
    
    			var sumContainer = new SummaryDataContainer(writer);
    			var jobContainer = new JobContainer(sumContainer);
    
    			factory.SumData = sumContainer;
    
    			var run = factory.SimulationRuns().ToArray()[runIdx];
    
    			if (startDistance != null) {
    				//(run.GetContainer().BatteryInfo as Battery).PreviousState.StateOfCharge = 0.317781;
    				(run.GetContainer().RunData.Cycle as DrivingCycleProxy).Entries = run.GetContainer().RunData.Cycle
    					.Entries.Where(x => x.Distance >= startDistance.Value).ToList();
    				//run.GetContainer().MileageCounter.Distance = startDistance;
    				//run.GetContainer().DrivingCycleInfo.CycleStartDistance = startDistance;
    			}
    
    			Assert.NotNull(run);
    
    			var pt = run.GetContainer();
    
    			Assert.NotNull(pt);
    
    			run.Run();
    			Assert.IsTrue(run.FinishedWithoutErrors);
    		}
    
    		// =================================================
    
    		public static JobContainer CreateEngineeringRun(DrivingCycleData cycleData, string modFileName,
    			double initialSoc, PowertrainPosition pos, double ratio, double pAuxEl = 0,
    			Kilogram payload = null, Watt maxDriveTrainPower = null, GearboxType gearboxType = GearboxType.NoGearbox)
    		{
    			var fileWriter = new FileOutputWriter(Path.GetFileNameWithoutExtension(modFileName));
    			var sumData = new SummaryDataContainer(fileWriter);
    			var jobContainer = new JobContainer(sumData);
    			var container = CreateSerialHybridPowerTrain(
    				cycleData, modFileName, initialSoc, sumData, pAuxEl, pos, ratio, payload,
    				maxDriveTrainPower, gearboxType);
    			var run = new DistanceRun(container);
    			jobContainer.AddRun(run);
    			return jobContainer;
    		}
    
    		public static VehicleContainer CreateSerialHybridPowerTrain(DrivingCycleData cycleData, string modFileName,
    			double initialBatCharge, SummaryDataContainer sumData, double pAuxEl,
    			PowertrainPosition pos, double ratio, Kilogram payload = null, Watt maxDriveTrainPower = null, GearboxType gearboxType = GearboxType.NoGearbox)
    		{
    			var gearboxData = CreateGearboxData(gearboxType);
    			var axleGearData = CreateAxleGearData(gearboxType);
    
    			var vehicleData = CreateVehicleData(payload ?? 3300.SI<Kilogram>());
    			var airdragData = CreateAirdragData();
    			var driverData = CreateDriverData(AccelerationFile, true);
    
    			var emFile = MotorFile;
    			var correctedRatio = pos == PowertrainPosition.BatteryElectricE3
    				? ratio / axleGearData.AxleGear.Ratio
    				: ratio;
    			var electricMotorData = MockSimulationDataFactory.CreateElectricMotorData(emFile, 2, pos, correctedRatio, 1);
    
    			var genFile = GeneratorFile;
    			electricMotorData.AddRange(
    				MockSimulationDataFactory.CreateElectricMotorData(genFile, 1, PowertrainPosition.GEN, 2.6, 1));
    
    			var batFile = BatFile;
    			var batteryData = MockSimulationDataFactory.CreateBatteryData(batFile, initialBatCharge);
    			//batteryData.TargetSoC = 0.5;
    
    			var engineData = MockSimulationDataFactory.CreateEngineDataFromFile(
    				 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.SerialHybridVehicle,
    				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 SerialHybridStrategy(runData, container);
    			var es = new ElectricSystem(container);
    			var battery = new BatterySystem(container, batteryData);
    			battery.Initialize(initialBatCharge);
    
    			//var clutch = gearboxType.AutomaticTransmission() ? null : new SwitchableClutch(container, runData.EngineData);
    			var ctl = new SerialHybridController(container, strategy, es);
    
    			es.Connect(battery);
    
    			var engine = new StopStartCombustionEngine(container, runData.EngineData);
    			
    			//var hybridStrategy = new DelegateParallelHybridStrategy();
    
    			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);
    
    			var powertrain = 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));
    
    			switch (pos) {
    				case PowertrainPosition.HybridPositionNotSet:
    					throw new VectoException("invalid powertrain position");
    				case PowertrainPosition.BatteryElectricE2:
    					var gearbox = gearboxType.AutomaticTransmission()
    						? (IHybridControlledGearbox)new ATGearbox(container, ctl.ShiftStrategy)
    						: new Gearbox(container, ctl.ShiftStrategy);
    					powertrain = powertrain.AddComponent(new AxleGear(container, runData.AxleGearData))
    						.AddComponent(runData.AngledriveData != null
    							? new Angledrive(container, runData.AngledriveData)
    							: null)
    						.AddComponent((IGearbox)gearbox, runData.Retarder, container)
    						.AddComponent(GetElectricMachine(PowertrainPosition.BatteryElectricE2, runData.ElectricMachinesData,
    							container,
    							es, ctl));
    					ctl.Gearbox = gearbox;
    
    					break;
    					
    				case PowertrainPosition.BatteryElectricE3:
    					powertrain = powertrain.AddComponent(new AxleGear(container, runData.AxleGearData))
    						.AddComponent(GetElectricMachine(PowertrainPosition.BatteryElectricE3, runData.ElectricMachinesData,
    							container,
    							es, ctl));
    					new DummyGearboxInfo(container, new GearshiftPosition(0));
    					//new MockEngineInfo(container);
    					new ATClutchInfo(container);
    					runData.GearboxData = null;
    					break;
    				case PowertrainPosition.BatteryElectricE4:
    					powertrain = powertrain.AddComponent(GetElectricMachine(PowertrainPosition.BatteryElectricE4, runData.ElectricMachinesData,
    							container,
    							es, ctl));
    					new DummyGearboxInfo(container, new GearshiftPosition(0));
    					//new MockEngineInfo(container);
    					new ATClutchInfo(container);
    					runData.GearboxData = null;
    					break;
    				case PowertrainPosition.HybridP0:
    				case PowertrainPosition.HybridP1:
    				case PowertrainPosition.HybridP2_5:
    				case PowertrainPosition.HybridP2:
    				case PowertrainPosition.HybridP3:
    				case PowertrainPosition.HybridP4:
    				
    					throw new VectoException("testcase does not support parallel powertrain configurations");
    				default:
    					throw new ArgumentOutOfRangeException(nameof(pos), pos, null);
    			}
    
    			ctl.GenSet.AddComponent(GetElectricMachine(PowertrainPosition.GEN, runData.ElectricMachinesData, container,
    					es, ctl))
    				.AddComponent(engine, idleController)
    				.AddAuxiliaries(container, runData);
    
    			return container;
    		}
    
    		private static HybridStrategyParameters CreateHybridStrategyData()
    		{
    			return new HybridStrategyParameters() {
    				MinSoC = 0.24,
    				TargetSoC = 0.7,
    				GensetMinOptPowerFactor = 0,
    			};
    		}
    
    		public static ShiftStrategyParameters CreateGearshiftData(GearboxData gbx, double axleRatio, PerSecond engineIdlingSpeed)
    		{
    			var retVal = new ShiftStrategyParameters {
    				TimeBetweenGearshifts = 2.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>(),
    
    				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 = gbx.Type.AutomaticTransmission() ? 1 : DeclarationData.GearboxTCU.AllowedGearRangeUp,
    				AllowedGearRangeDown = gbx.Type.AutomaticTransmission() ? 1 : 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,
    			ElectricSystem 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);
    			if (pos == PowertrainPosition.GEN) {
    				es.Connect(new GensetChargerAdapter(motor));
    			} else {
    				motor.Connect(es);
    			}
    
    			return motor;
    		}
    
    		private static GearboxData CreateGearboxData(GearboxType gearboxType = GearboxType.NoGearbox)
    		{
    			switch (gearboxType) {
    
    				case GearboxType.NoGearbox:
    				case GearboxType.AMT:
    					return CreateAMTGearbox();
    				//case GearboxType.ATSerial:
    				//	return CreateATSerial();
    				//case GearboxType.ATPowerSplit:
    				//	return CreateATPowerSplit();
    				default:
    					throw new ArgumentOutOfRangeException(nameof(gearboxType), gearboxType, null);
    			}
    		}
    
    		private static GearboxData CreateAMTGearbox()
    		{
    			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,
    									$"Gear {i}"),
    							Ratio = ratio,
    							//ShiftPolygon = DeclarationData.Gearbox.ComputeEfficiencyShiftPolygon(i,)
    						})).ToDictionary(k => k.Item1 + 1, v => v.Item2),
    				Inertia = 0.SI<KilogramSquareMeter>(),
    				TractionInterruption = 1.SI<Second>(),
    			};
    		}
    
    
    		private static AxleGearData CreateAxleGearData(GearboxType gearboxType)
    		{
    			var ratio = 2.59;
    			switch (gearboxType) {
    				case GearboxType.ATSerial:
    					ratio = 6.2;
    					break;
    				case GearboxType.ATPowerSplit:
    					ratio = 5.8;
    					break;
    			}
    			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,
    				ADAS = new VehicleData.ADASData() {
    					EngineStopStart = true
    				}
    			};
    		}
    
    		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,
    					UtilityFactorStandstill = DeclarationData.Driver.EngineStopStart.UtilityFactor
    				}
    			};
    		}
    
    
    		// ======================
    
    		private GraphWriter GetGraphWriter(ModalResultField[] emYFields)
    		{
    			var Yfields = new[] {
    				ModalResultField.v_act, ModalResultField.altitude, ModalResultField.acc, ModalResultField.Gear,
    				ModalResultField.P_ice_out, ModalResultField.REESSStateOfCharge, 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;
    		}
    
    	}
    }