Select Git revision
DeclarationDataTest.cs
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
}
};
}
}
}