Code development platform for open source projects from the European Union institutions

Skip to content
Snippets Groups Projects
Commit 5792db04 authored by Markus Quaritsch's avatar Markus Quaritsch
Browse files

hybrid strategy: chage gearshift check for AT transmissions

parent bc1af6f9
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
VectoCore/VectoCore/Models/SimulationComponent/Impl/Clutch.cs
+ 1
− 1
View file @ 5792db04
......@@ -118,7 +118,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
return HandleClutchClosed(absTime, dt, outTorque, outAngularVelocity, dryRun);
}
private IResponse HandleClutchOpen(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
protected IResponse HandleClutchOpen(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity,
bool dryRun)
{
var avgOutAngularVelocity = (PreviousState.OutAngularVelocity + outAngularVelocity) / 2.0;
......
VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs
+ 115
− 16
View file @ 5792db04
......@@ -14,6 +14,7 @@ using TUGraz.VectoCore.Models.Simulation.Data;
using TUGraz.VectoCore.Models.Simulation.DataBus;
using TUGraz.VectoCore.Models.Simulation.Impl;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
using TUGraz.VectoCore.Models.SimulationComponent.Impl;
using TUGraz.VectoCore.OutputData;
using TUGraz.VectoCore.Utils;
......@@ -159,6 +160,27 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
return retVal;
}
protected override void CheckGearshiftLimits(HybridResultEntry tmp, IResponse resp)
{
if (resp.Engine.EngineSpeed != null && resp.Gearbox.Gear.Engaged &&
GearList.HasSuccessor(resp.Gearbox.Gear) && ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear]
.ShiftPolygon.IsAboveUpshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
//lastShiftTime = absTime;
//tmp.FuelCosts = double.NaN; // Tuple.Create(true, response.Gearbox.Gear + 1);
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedAboveUpshift;
}
if (resp.Engine.EngineSpeed != null && GearList.HasPredecessor(resp.Gearbox.Gear) && ModelData.GearboxData
.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon
.IsBelowDownshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
//lastShiftTime = absTime;
//tmp.FuelCosts = double.NaN; // = Tuple.Create(true, response.Gearbox.Gear - 1);
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedBelowDownshift;
}
}
}
// =====================================================
......@@ -167,8 +189,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
public class HybridStrategyAT : AbstractHybridStrategy<ATGearbox>
{
public HybridStrategyAT(VectoRunData runData, IVehicleContainer vehicleContainer) : base(runData,
vehicleContainer)
{
......@@ -336,6 +356,82 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
return null;
}
}
protected override void CheckGearshiftLimits(HybridResultEntry tmp, IResponse resp)
{
if (resp.Engine.EngineSpeed == null) {
return;
}
if (resp.Gearbox.Gear.Engaged && GearList.HasSuccessor(resp.Gearbox.Gear)) {
var current = resp.Gearbox.Gear;
var successor = GearList.Successor(current);
if (successor.IsLockedGear()) {
// C/L -> L shift
var nextEngineSpeed = resp.Gearbox.OutputSpeed * ModelData.GearboxData.Gears[successor.Gear].Ratio;
if (nextEngineSpeed.IsEqual(0)) {
return;
}
var nextEngineTorque = resp.Engine.EngineSpeed * resp.Engine.TotalTorqueDemand / nextEngineSpeed;
if (ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear]
.ShiftPolygon.IsAboveUpshiftCurve(nextEngineTorque, nextEngineSpeed)) {
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedAboveUpshift;
}
} else {
// C -> C shift
//throw new NotImplementedException("TC-TC upshift not implemented");
}
}
if (GearList.HasPredecessor(resp.Gearbox.Gear) && ModelData.GearboxData
.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon
.IsBelowDownshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
//lastShiftTime = absTime;
//tmp.FuelCosts = double.NaN; // = Tuple.Create(true, response.Gearbox.Gear - 1);
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedBelowDownshift;
}
}
//protected virtual bool? CheckUpshiftTcTc(
// Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, NewtonMeter inTorque,
// PerSecond inAngularVelocity, GearshiftPosition gear, GearData currentGear, IResponse response)
//{
// // C -> C+1
// var nextGearPos = GearList.Successor(gear); // GearboxModelData.Gears[gear + 1];
// var nextGear = ModelData.GearboxData.Gears[nextGearPos.Gear];
// var gearRatio = nextGear.TorqueConverterRatio / currentGear.TorqueConverterRatio;
// var minEngineSpeed = VectoMath.Min(700.RPMtoRad(), gearRatio * (DataBus.EngineInfo.EngineN80hSpeed - 150.RPMtoRad()));
// var nextGearboxInSpeed = outAngularVelocity * nextGear.TorqueConverterRatio;
// var nextGearboxInTorque = outTorque / nextGear.TorqueConverterRatio;
// var shiftLosses = _gearbox.ComputeShiftLosses(outTorque, outAngularVelocity, nextGearPos) /
// ModelData.GearboxData.PowershiftShiftTime / nextGearboxInSpeed;
// nextGearboxInTorque += shiftLosses;
// var tcOperatingPoint =
// _gearbox.TorqueConverter.FindOperatingPoint(absTime, dt, nextGearboxInTorque, nextGearboxInSpeed);
// var engineSpeedOverMin = tcOperatingPoint.InAngularVelocity.IsGreater(minEngineSpeed);
// var avgSpeed = (DataBus.EngineInfo.EngineSpeed + tcOperatingPoint.InAngularVelocity) / 2;
// var engineMaxTorque = DataBus.EngineInfo.EngineStationaryFullPower(avgSpeed) / avgSpeed;
// var engineInertiaTorque = Formulas.InertiaPower(
// DataBus.EngineInfo.EngineSpeed, tcOperatingPoint.InAngularVelocity, ModelData.EngineData.Inertia, dt) / avgSpeed;
// var engineTorqueBelowMax =
// tcOperatingPoint.InTorque.IsSmallerOrEqual(engineMaxTorque - engineInertiaTorque);
// var reachableAcceleration =
// EstimateAcceleration(
// outAngularVelocity, outTorque, inAngularVelocity, inTorque, gear.Gear, response); // EstimateAccelerationForGear(gear + 1, outAngularVelocity);
// var minAcceleration = VectoMath.Min(
// ModelData.GearboxData.TorqueConverterData.CCUpshiftMinAcceleration,
// DataBus.DriverInfo.DriverAcceleration);
// var minAccelerationReachable = reachableAcceleration.IsGreaterOrEqual(minAcceleration);
// if (engineSpeedOverMin && engineTorqueBelowMax && minAccelerationReachable) {
// return true;
// }
// return null;
//}
}
// =====================================================
......@@ -1115,7 +1211,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
var gbxOutSpeed = firstResponse.Engine.EngineSpeed /
ModelData.GearboxData.Gears[tmpGear.Gear].Ratio;
var firstGear = GearList.Predecessor(nextGear, 1);
var lastGear = GearList.Predecessor(nextGear, (uint)ModelData.GearshiftParameters.AllowedGearRangeDown);
var lastGear = GearList.Predecessor(nextGear, (uint)ModelData.GearshiftParameters.AllowedGearRangeFC);
//while (GearList.HasPredecessor(tmpGear)) {
foreach (var gear in GearList.IterateGears(firstGear, lastGear)) {
var ratio = gear.IsLockedGear()
......@@ -1526,8 +1622,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
{
var minimumShiftTimePassed =
(DataBus.GearboxInfo.LastShift + ModelData.GearshiftParameters.TimeBetweenGearshifts).IsSmallerOrEqual(absTime);
var gearRangeUpshift = ModelData.GearshiftParameters.AllowedGearRangeUp;
var gearRangeDownshift = ModelData.GearshiftParameters.AllowedGearRangeDown;
var gearRangeUpshift = ModelData.GearshiftParameters.AllowedGearRangeFC;
var gearRangeDownshift = ModelData.GearshiftParameters.AllowedGearRangeFC;
if (!AllowEmergencyShift) {
if (dryRun || !minimumShiftTimePassed ||
(absTime - DataBus.GearboxInfo.LastUpshift).IsSmaller(
......@@ -1890,16 +1986,17 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedTooLow;
}
if (resp.Engine.EngineSpeed != null && resp.Gearbox.Gear.Engaged && GearList.HasSuccessor(resp.Gearbox.Gear) && ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon.IsAboveUpshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
//lastShiftTime = absTime;
//tmp.FuelCosts = double.NaN; // Tuple.Create(true, response.Gearbox.Gear + 1);
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedAboveUpshift;
}
if (resp.Engine.EngineSpeed != null && GearList.HasPredecessor(resp.Gearbox.Gear) && ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon.IsBelowDownshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
//lastShiftTime = absTime;
//tmp.FuelCosts = double.NaN; // = Tuple.Create(true, response.Gearbox.Gear - 1);
tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedBelowDownshift;
}
//if (resp.Engine.EngineSpeed != null && resp.Gearbox.Gear.Engaged && GearList.HasSuccessor(resp.Gearbox.Gear) && ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon.IsAboveUpshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
// //lastShiftTime = absTime;
// //tmp.FuelCosts = double.NaN; // Tuple.Create(true, response.Gearbox.Gear + 1);
// tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedAboveUpshift;
//}
//if (resp.Engine.EngineSpeed != null && GearList.HasPredecessor(resp.Gearbox.Gear) && ModelData.GearboxData.Gears[resp.Gearbox.Gear.Gear].ShiftPolygon.IsBelowDownshiftCurve(resp.Engine.TorqueOutDemand, resp.Engine.EngineSpeed)) {
// //lastShiftTime = absTime;
// //tmp.FuelCosts = double.NaN; // = Tuple.Create(true, response.Gearbox.Gear - 1);
// tmp.IgnoreReason |= HybridConfigurationIgnoreReason.EngineSpeedBelowDownshift;
//}
CheckGearshiftLimits(tmp, resp);
if (resp.Source is TorqueConverter) {
if (resp is ResponseUnderload) {
......@@ -1951,7 +2048,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
var maxSoC = Math.Min(DataBus.BatteryInfo.MaxSoC, StrategyParameters.MaxSoC);
var minSoC = Math.Max(DataBus.BatteryInfo.MinSoC , StrategyParameters.MinSoC);
tmp.SoCPenalty = 1 - Math.Pow((DataBus.BatteryInfo.StateOfCharge - StrategyParameters.TargetSoC) / (0.5 * (maxSoC - minSoC)), 5);
tmp.SoCPenalty = 1 - Math.Pow((DataBus.BatteryInfo.StateOfCharge - StrategyParameters.TargetSoC) / (0.5 * (maxSoC - minSoC)), StrategyParameters.CostFactorSOCExponent);
var socthreshold = StrategyParameters.MinSoC + (StrategyParameters.MaxSoC - StrategyParameters.MinSoC) * 0.1;
var minSoCPenalty = 10.0;
......@@ -1993,6 +2090,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
}
}
protected abstract void CheckGearshiftLimits(HybridResultEntry tmp, IResponse resp);
private void SetBatteryCosts(IResponse resp, Second dt, HybridResultEntry tmp)
{
var batEnergyStored = DataBus.BatteryInfo.StoredEnergy;
......
VectoCore/VectoCore/Models/SimulationComponent/SwitchableClutch.cs
+ 3
− 4
View file @ 5792db04
......@@ -44,9 +44,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent
public override IResponse Request(Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, bool dryRun)
{
var avgOutSpeed = (PreviousState.OutAngularVelocity + outAngularVelocity) / 2.0;
if (ClutchOpen)
{
if (ClutchOpen) {
if (dryRun)
{
return new ResponseDryRun(this)
......@@ -82,7 +80,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent
{
if (DataBus.DriverInfo.DriverBehavior == DrivingBehavior.Halted && !ClutchOpen)
{
return HandleClutchClosed(absTime, dt, outTorque, outAngularVelocity, dryRun);
//return HandleClutchClosed(absTime, dt, outTorque, outAngularVelocity, dryRun);
return base.HandleClutchOpen(absTime, dt, outTorque, outAngularVelocity, dryRun);
}
return base.Request(absTime, dt, outTorque, outAngularVelocity, dryRun);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

For further information about the platform and support, please see https://code.europa.eu/info/about