diff --git a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
index 71d4a9dae72ccc1f06223893c4544e0874e60ebc..1b9354f611e4619f0a63cfa0f799f249ce5e0452 100644
--- a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
+++ b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
@@ -398,7 +398,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
string crosswindCorrectionParameters, SquareMeter aerodynamicDragAera, Meter vehicleHeight)
{
const int startSpeed = 60;
- const int maxSpeed = 130;
+ const int maxSpeed = 200;
const int speedStep = 5;
const int maxAlpha = 180;
diff --git a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
index cb06e513d75efd4d1d4d1247446fc9a605d56be5..e7ef87c095b62dea168c0ec2cfa7cd52ea64b25e 100644
--- a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
+++ b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs
@@ -199,9 +199,9 @@ namespace TUGraz.VectoCore.Models.Declaration
public const double ShiftPolygonRPMMargin = 7; // %
private const double ShiftPolygonEngineFldMargin = 0.98;
- public static readonly Second MinTimeBetweenGearshifts = 1.5.SI<Second>();
- public static readonly Second DownshiftAfterUpshiftDelay = 10.SI<Second>();
- public static readonly Second UpshiftAfterDownshiftDelay = 10.SI<Second>();
+ public static readonly Second MinTimeBetweenGearshifts = 2.SI<Second>();
+ public static readonly Second DownshiftAfterUpshiftDelay = 6.SI<Second>();
+ public static readonly Second UpshiftAfterDownshiftDelay = 6.SI<Second>();
public static readonly MeterPerSquareSecond UpshiftMinAcceleration = 0.1.SI<MeterPerSquareSecond>();
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyV2.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyV2.cs
index b4e5e879f033b7f7aefd65652aac2118f38f1935..f5a08a14ee02cc301a68a5b4c6e6715d54cd3711 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyV2.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/AMTShiftStrategyV2.cs
@@ -32,6 +32,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
protected MaxCardanTorqueLookup MaxCardanTorqueLookup;
protected DebugData DebugData = new DebugData();
+ private Dictionary<uint, GearRating> GearRatings = new Dictionary<uint, GearRating>();
+ private MeterPerSquareSecond accRsv;
public struct HistoryEntry
{
@@ -63,12 +65,27 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
dataBus.AddPreprocessor(new EngineSpeedDriveOffPreprocessor(EngineSpeedAtDriveOff, data, TestContainer));
AverageAccelerationTorqueLookup = new AverageAccelerationTorqueLookup();
- dataBus.AddPreprocessor(new AverageAccelerationTorquePreprocessor(AverageAccelerationTorqueLookup, data, GetEngineSpeedLimitHighMin()));
+ dataBus.AddPreprocessor(
+ new AverageAccelerationTorquePreprocessor(AverageAccelerationTorqueLookup, data, GetEngineSpeedLimitHighMin()));
MaxCardanTorqueLookup = new MaxCardanTorqueLookup();
dataBus.AddPreprocessor(new MaxCardanTorquePreprocessor(MaxCardanTorqueLookup, data, TestContainer));
}
+ private bool SpeedTooLowForEngine(uint gear, PerSecond outAngularSpeed)
+ {
+ return (outAngularSpeed * ModelData.Gears[gear].Ratio).IsSmaller(DataBus.EngineIdleSpeed);
+ }
+
+ private bool SpeedTooHighForEngine(uint gear, PerSecond outAngularSpeed)
+ {
+ return
+ (outAngularSpeed * ModelData.Gears[gear].Ratio).IsGreaterOrEqual(
+ VectoMath.Min(
+ ModelData.Gears[gear].MaxSpeed,
+ DataBus.EngineN95hSpeed));
+ }
+
#region Overrides of BaseShiftStrategy
public override bool ShiftRequired(
@@ -82,7 +99,29 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
UpdateHistoryBuffer(absTime, dt, currentCardanPower, velocity);
- // normal shift when all requirements are fullfilled ------------------
+ // no shift when vehicle stands
+ if (DataBus.VehicleStopped) {
+ return false;
+ }
+
+ // emergency shift to not stall the engine ------------------------
+ if (gear == 1 && SpeedTooLowForEngine(_nextGear, inAngularVelocity / ModelData.Gears[gear].Ratio)) {
+ return true;
+ }
+
+ _nextGear = gear;
+ while (_nextGear > 1 && SpeedTooLowForEngine(_nextGear, inAngularVelocity / ModelData.Gears[gear].Ratio)) {
+ _nextGear--;
+ }
+ while (_nextGear < ModelData.Gears.Count &&
+ SpeedTooHighForEngine(_nextGear, inAngularVelocity / ModelData.Gears[gear].Ratio)) {
+ _nextGear++;
+ }
+
+ if (_nextGear != gear) {
+ return true;
+ }
+
var minimumShiftTimePassed = (lastShiftTime + ModelData.ShiftTime).IsSmallerOrEqual(absTime);
if (!minimumShiftTimePassed) {
return false;
@@ -117,33 +156,46 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
Second absTime, Second dt, NewtonMeter outTorque, PerSecond outAngularVelocity, NewtonMeter inTorque,
PerSecond inAngularVelocity, uint gear, Second lastShiftTime)
{
- var lookAheadDistance = DataBus.VehicleSpeed * ShiftStrategyParameters.GearResidenceTime;
+ var lookAheadDistance = DataBus.VehicleSpeed * ModelData.TractionInterruption;//ShiftStrategyParameters.GearResidenceTime;
var roadGradient = DataBus.CycleLookAhead(lookAheadDistance).RoadGradient;
- var minRating = new GearRating(GearRatingCase.D, double.MaxValue, 0.RPMtoRad());
+ var minRating = new GearRating(GearRatingCase.E, double.MaxValue, 0.RPMtoRad());
var selectedGear = gear;
var debugData = new DebugData();
- for (var i = Math.Max(0, gear - ShiftStrategyParameters.AllowedGearRangeDown);
+
+ var currentVelocity = DataBus.VehicleSpeed;
+ var gradient = CalcGradientDuringGearshift(false, dt, currentVelocity);
+ var estimatedVelocityPostShift = VelocityDropData.Interpolate(currentVelocity, gradient);
+ var predictionVelocity = CalcPredictionVelocity(currentVelocity, estimatedVelocityPostShift);
+
+ accRsv = CalcAccelerationReserve(currentVelocity);
+
+ GearRatings.Clear();
+ for (var i = Math.Max(1, gear - ShiftStrategyParameters.AllowedGearRangeDown);
i <= Math.Min(ModelData.Gears.Count, gear + ShiftStrategyParameters.AllowedGearRangeUp);
i++) {
var nextGear = (uint)i;
var gradientBelowMaxGrad = roadGradient < MaxGradability.GradabilityLimitedTorque(nextGear);
- var engineSpeedAboveMin = outAngularVelocity * ModelData.Gears[nextGear].Ratio > GetEngineSpeedLimitLow(false);
+ var engineSpeedAboveMin =
+ outAngularVelocity * ModelData.Gears[nextGear].Ratio > PowertrainConfig.EngineData.IdleSpeed;
var engineSpeedBelowMax = outAngularVelocity * ModelData.Gears[nextGear].Ratio <
PowertrainConfig.EngineData.FullLoadCurves[0].N95hSpeed;
- if (nextGear > gear && !(gradientBelowMaxGrad && engineSpeedAboveMin && engineSpeedBelowMax)) {
+
+ if (!(gradientBelowMaxGrad && engineSpeedAboveMin && engineSpeedBelowMax)) {
debugData.Add(
string.Format(
"{0} - gear {1} exceeds speed limits / gradability {2}", absTime, nextGear,
outAngularVelocity * ModelData.Gears[nextGear].Ratio));
+ GearRatings[nextGear] = new GearRating(GearRatingCase.E, 0, null);
continue;
}
- var rating = RatingGear(false, nextGear, dt);
+ var rating = RatingGear(false, nextGear, gear, gradient, predictionVelocity, estimatedVelocityPostShift, accRsv);
if (nextGear == gear) {
if (rating.RatingCase == GearRatingCase.A) {
- rating = new GearRating(GearRatingCase.A, rating.Rating * ShiftStrategyParameters.RatingFactorCurrentGear, rating.MaxEngineSpeed);
+ rating = new GearRating(
+ GearRatingCase.A, rating.Rating * ShiftStrategyParameters.RatingFactorCurrentGear, rating.MaxEngineSpeed);
}
}
debugData.Add(string.Format("{0} - gear {1}: rating {2}", absTime, nextGear, rating));
@@ -151,7 +203,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
minRating = rating;
selectedGear = nextGear;
}
+ GearRatings[nextGear] = rating;
}
+
debugData.Add(string.Format("selected gear: {0} - {1}", selectedGear, minRating));
if (selectedGear < gear && (DownshiftAllowed(absTime) || inAngularVelocity < GetEngineSpeedLimitLow(false))) {
@@ -160,34 +214,25 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
if (selectedGear > gear && (UpshiftAllowed(absTime) || inAngularVelocity > minRating.MaxEngineSpeed)) {
_nextGear = selectedGear;
}
-
+
DebugData.Add(debugData);
return _nextGear != gear;
}
private bool UpshiftAllowed(Second absTime)
{
- return (absTime - _gearbox.LastDownshift).IsSmaller(_gearbox.ModelData.UpshiftAfterDownshiftDelay);
+ return (absTime - _gearbox.LastDownshift).IsGreaterOrEqual(_gearbox.ModelData.UpshiftAfterDownshiftDelay);
}
private bool DownshiftAllowed(Second absTime)
{
- return (absTime - _gearbox.LastUpshift).IsSmaller(_gearbox.ModelData.DownshiftAfterUpshiftDelay);
+ return (absTime - _gearbox.LastUpshift).IsGreaterOrEqual(_gearbox.ModelData.DownshiftAfterUpshiftDelay);
}
- private GearRating RatingGear(bool driveOff, uint gear, Second dt)
+ private GearRating RatingGear(
+ bool driveOff, uint gear, uint currentGear, Radian gradient, MeterPerSecond predictionVelocity,
+ MeterPerSecond velocityAfterGearshift, MeterPerSquareSecond accRsv)
{
- var currentVelocity = DataBus.VehicleSpeed;
- var gradient = CalcGradientDuringGearshift(driveOff, dt, currentVelocity);
-
- var predictionVelocity = ShiftStrategyParameters.StartVelocity;
- var accRsv = ShiftStrategyParameters.StartAcceleration;
- if (!driveOff) {
- predictionVelocity = CalcPredictionVelocity(currentVelocity, gradient);
-
- accRsv = CalcAccelerationReserve(currentVelocity);
- }
-
TestContainer.GearboxCtl.Gear = gear;
TestContainer.VehiclePort.Initialize(predictionVelocity, gradient);
var respAccRsv = (ResponseDryRun)TestContainer.VehiclePort.Request(
@@ -196,38 +241,55 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
var respConstVel = (ResponseDryRun)TestContainer.VehiclePort.Request(
0.SI<Second>(), Constants.SimulationSettings.TargetTimeInterval,
0.SI<MeterPerSquareSecond>(), gradient, true);
+ var respDriverDemand = (ResponseDryRun)TestContainer.VehiclePort.Request(
+ 0.SI<Second>(), Constants.SimulationSettings.TargetTimeInterval, DataBus.DriverAcceleration, gradient,
+ true);
if (respAccRsv.EngineSpeed < PowertrainConfig.EngineData.IdleSpeed ||
respAccRsv.EngineSpeed > PowertrainConfig.EngineData.FullLoadCurves[0].N95hSpeed) {
return new GearRating(GearRatingCase.E, 0, 0.RPMtoRad());
}
-
GearRating? retVal;
var engineSpeedLowThreshold = GetEngineSpeedLimitLow(driveOff);
- var engineSpeedHighThreshold = GetEngineSpeedLimitHigh(driveOff, gear, respAccRsv.EngineSpeed, respConstVel.CardanTorque);
+ var engineSpeedHighThreshold = GetEngineSpeedLimitHigh(
+ driveOff, gear, respAccRsv.EngineSpeed, respConstVel.CardanTorque);
if (respAccRsv.EngineSpeed < engineSpeedLowThreshold) {
- return new GearRating(GearRatingCase.D, (engineSpeedLowThreshold - respAccRsv.EngineSpeed).Value(), engineSpeedHighThreshold);
+ return new GearRating(
+ GearRatingCase.D, (engineSpeedLowThreshold - respAccRsv.EngineSpeed).Value(), engineSpeedHighThreshold);
}
if (respAccRsv.EngineSpeed > engineSpeedHighThreshold) {
- return new GearRating(GearRatingCase.D, (respAccRsv.EngineSpeed - engineSpeedHighThreshold).Value(), engineSpeedHighThreshold);
+ return new GearRating(
+ GearRatingCase.D, (respAccRsv.EngineSpeed - engineSpeedHighThreshold).Value(), engineSpeedHighThreshold);
}
if (respAccRsv.EngineTorqueDemandTotal <= respAccRsv.EngineDynamicFullLoadTorque) {
var fc = PowertrainConfig.EngineData.ConsumptionMap.GetFuelConsumption(
- VectoMath.Max(respAccRsv.EngineTorqueDemandTotal, PowertrainConfig.EngineData.FullLoadCurves[0].DragLoadStationaryTorque(respAccRsv.EngineSpeed)), respAccRsv.EngineSpeed);
- retVal = new GearRating(GearRatingCase.A, (fc.Value / respAccRsv.AxlegearPowerRequest).Value(), engineSpeedHighThreshold);
+ VectoMath.Max(
+ respAccRsv.EngineTorqueDemandTotal,
+ PowertrainConfig.EngineData.FullLoadCurves[0].DragLoadStationaryTorque(respAccRsv.EngineSpeed)),
+ respAccRsv.EngineSpeed);
+ retVal = new GearRating(
+ GearRatingCase.A,
+ (fc.Value.ConvertToGrammPerHour().Value / VectoMath.Max(respAccRsv.AxlegearPowerRequest, 1.SI<Watt>())).Value(),
+ engineSpeedHighThreshold);
} else {
- retVal = new GearRating(GearRatingCase.B, (respAccRsv.EnginePowerRequest - respAccRsv.DynamicFullLoadPower).Value(), engineSpeedHighThreshold);
- }
-
- var estimatedResidenceTime = EstimateResidenceTimeInGear(gear, respAccRsv, engineSpeedHighThreshold, gradient);
- if (estimatedResidenceTime < ShiftStrategyParameters.GearResidenceTime) {
retVal = new GearRating(
- GearRatingCase.C, (ShiftStrategyParameters.GearResidenceTime - estimatedResidenceTime).Value(), engineSpeedHighThreshold);
+ GearRatingCase.B, (respAccRsv.EnginePowerRequest - respAccRsv.DynamicFullLoadPower).Value(),
+ engineSpeedHighThreshold);
}
+ if (gear > currentGear) {
+ var estimatedResidenceTime =
+ EstimateResidenceTimeInGear(
+ gear, respDriverDemand, engineSpeedHighThreshold, velocityAfterGearshift, gradient, engineSpeedLowThreshold);
+ if (estimatedResidenceTime != null && estimatedResidenceTime < ShiftStrategyParameters.GearResidenceTime) {
+ retVal = new GearRating(
+ GearRatingCase.C, (ShiftStrategyParameters.GearResidenceTime - estimatedResidenceTime).Value(),
+ engineSpeedHighThreshold);
+ }
+ }
return retVal.Value;
}
@@ -258,9 +320,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
return accRsv;
}
- private MeterPerSecond CalcPredictionVelocity(MeterPerSecond currentVelocity, Radian gradient)
+ private MeterPerSecond CalcPredictionVelocity(
+ MeterPerSecond currentVelocity, MeterPerSecond estimatedVelocityPostShift)
{
- var estimatedVelocityPostShift = VelocityDropData.Interpolate(currentVelocity, gradient);
var ratioSpeedDrop = estimatedVelocityPostShift / VectoMath.Max(currentVelocity, 0.1.SI<MeterPerSecond>());
var predictionIntervalRatio = ShiftStrategyParameters.PredictionDurationLookup.Lookup(ratioSpeedDrop.Value());
var speedChange = estimatedVelocityPostShift - currentVelocity;
@@ -288,13 +350,24 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
{
var upperEngineSpeedLimit = (PowertrainConfig.EngineData.FullLoadCurves[0].NTq99lSpeed +
PowertrainConfig.EngineData.FullLoadCurves[0].NTq99hSpeed) / 2.0;
+
+ var currentVelocity = DataBus.VehicleSpeed;
+ var gradient = CalcGradientDuringGearshift(false, dt, currentVelocity);
+ var estimatedVelocityPostShift = VelocityDropData.Interpolate(currentVelocity, gradient);
+ var predictedVelocity = DataBus.DriverBehavior == DrivingBehavior.Braking
+ ? currentVelocity + PowertrainConfig.DriverData.AccelerationCurve.Lookup(currentVelocity).Deceleration *
+ ModelData.TractionInterruption
+ : CalcPredictionVelocity(currentVelocity, estimatedVelocityPostShift);
+
if (inAngularVelocity < GetEngineSpeedLimitLow(false)) {
for (var i = Math.Max(0, gear - ShiftStrategyParameters.AllowedGearRangeDown);
i <= Math.Min(ModelData.Gears.Count, gear + ShiftStrategyParameters.AllowedGearRangeUp);
i++) {
var nextGear = (uint)i;
- if (outAngularVelocity * ModelData.Gears[nextGear].Ratio > GetEngineSpeedLimitLow(false) &&
- outAngularVelocity * ModelData.Gears[nextGear].Ratio < upperEngineSpeedLimit) {
+ TestContainer.GearboxCtl.Gear = nextGear;
+ var init = TestContainer.VehiclePort.Initialize(predictedVelocity, gradient);
+ if (init.EngineSpeed > GetEngineSpeedLimitLow(false) &&
+ init.EngineSpeed < upperEngineSpeedLimit) {
_nextGear = nextGear;
return true;
}
@@ -306,8 +379,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
i >= Math.Max(0, gear + ShiftStrategyParameters.AllowedGearRangeDown);
i--) {
var nextGear = (uint)i;
- if (outAngularVelocity * ModelData.Gears[nextGear].Ratio > GetEngineSpeedLimitLow(false) &&
- outAngularVelocity * ModelData.Gears[nextGear].Ratio < upperEngineSpeedLimit) {
+ TestContainer.GearboxCtl.Gear = nextGear;
+ var init = TestContainer.VehiclePort.Initialize(predictedVelocity, gradient);
+ if (init.EngineSpeed > GetEngineSpeedLimitLow(false) &&
+ init.EngineSpeed < upperEngineSpeedLimit) {
_nextGear = nextGear;
return true;
}
@@ -352,9 +427,16 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
{
var maxStartGear = (int)Math.Round(ModelData.Gears.Count / 2.0, MidpointRounding.AwayFromZero);
+ var currentVelocity = DataBus.VehicleSpeed;
+ var gradient = CalcGradientDuringGearshift(true, null, null);
+ var estimatedVelocityPostShift = VelocityDropData.Interpolate(currentVelocity, gradient);
+ var predictionVelocity = ShiftStrategyParameters.StartVelocity;
+ accRsv = ShiftStrategyParameters.StartAcceleration;
+
var startGear = 1u;
- var minRating = new GearRating(GearRatingCase.D, double.MaxValue, 0.RPMtoRad());
+ var minRating = new GearRating(GearRatingCase.E, double.MaxValue, 0.RPMtoRad());
var roadGradient = DataBus.CycleData.LeftSample.RoadGradient; //CycleLookAhead(0.SI<Meter>()).RoadGradient;
+ GearRatings.Clear();
for (uint i = (uint)maxStartGear; i > 0; i--) {
var gradientBelowMaxGrad = roadGradient < MaxGradability.GradabilityLimitedTorque(i);
var engineSpeedLimitLow = GetEngineSpeedLimitLow(true);
@@ -362,7 +444,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
var engineSpeedAboveMin = engineSpeed > engineSpeedLimitLow;
var engineSpeedBelowN95h = engineSpeed < PowertrainConfig.EngineData.FullLoadCurves[0].N95hSpeed;
if (gradientBelowMaxGrad && engineSpeedAboveMin && engineSpeedBelowN95h) {
- var rating = RatingGear(true, i, null);
+ var rating = RatingGear(true, i, 0, roadGradient, predictionVelocity, estimatedVelocityPostShift, accRsv);
+ GearRatings[i] = rating;
if (rating < minRating) {
minRating = rating;
startGear = i;
@@ -389,40 +472,43 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
}
- private Second EstimateResidenceTimeInGear(uint gear, ResponseDryRun responseDriverDemand, PerSecond engineSpeedHighThreshold, Radian estimatedGradient)
+ private Second EstimateResidenceTimeInGear(
+ uint gear, ResponseDryRun responseDriverDemand, PerSecond engineSpeedHighThreshold,
+ MeterPerSecond velocityAfterGearshift, Radian estimatedGradient, PerSecond engineSpeedLowThreshold)
{
// get total 'transmission ratio' of powertrain
var engineSpeed = responseDriverDemand.EngineSpeed;
var vehicleSpeed = responseDriverDemand.VehicleSpeed;
var ratio = (vehicleSpeed / engineSpeed).Cast<Meter>();
+ var estimatedEngineSpeed = velocityAfterGearshift / ratio;
+ if (estimatedEngineSpeed < engineSpeedLowThreshold || estimatedEngineSpeed > engineSpeedHighThreshold) {
+ return null;
+ }
+
var averageAccelerationTorque = AverageAccelerationTorqueLookup.Interpolate(
responseDriverDemand.EngineSpeed, responseDriverDemand.EngineTorqueDemand);
+ TestContainer.GearboxCtl.Gear = gear;
var initResponse = TestContainer.VehiclePort.Initialize(vehicleSpeed, estimatedGradient);
var delta = initResponse.EngineTorqueDemand - averageAccelerationTorque;
var acceleration = SearchAlgorithm.Search(
0.SI<MeterPerSquareSecond>(), delta, 0.1.SI<MeterPerSquareSecond>(),
- getYValue: r => {
- return (r as AbstractResponse).EngineTorqueDemand - averageAccelerationTorque;
- },
+ getYValue: r => { return (r as AbstractResponse).EngineTorqueDemand - averageAccelerationTorque; },
evaluateFunction: a => {
return TestContainer.VehiclePort.Request(
0.SI<Second>(), Constants.SimulationSettings.TargetTimeInterval, a, estimatedGradient, true);
},
- criterion: r => {
- return ((r as AbstractResponse).EngineTorqueDemand - averageAccelerationTorque).Value();
- }
+ criterion: r => { return ((r as AbstractResponse).EngineTorqueDemand - averageAccelerationTorque).Value(); }
);
-
+
var engineAcceleration = (acceleration / ratio).Cast<PerSquareSecond>();
var deltaEngineSpeed = engineSpeedHighThreshold - engineSpeed;
if (engineAcceleration > 0 && deltaEngineSpeed > 0) {
return (deltaEngineSpeed / engineAcceleration).Cast<Second>();
}
- // TODO: make similar to matlab implementtion
- return 0.SI<Second>();
+ return null;
}
private PerSecond GetEngineSpeedLimitHighDriveOff(uint gear)
@@ -457,44 +543,20 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
}
#endregion
- }
- internal struct GearRating
- {
- public GearRating(GearRatingCase ratingCase, double rating, PerSecond maxEngineSpeed)
+ public void WriteModalResults(IModalDataContainer container)
{
- RatingCase = ratingCase;
- Rating = rating;
- MaxEngineSpeed = maxEngineSpeed;
- }
-
- public double Rating { get; }
-
- public GearRatingCase RatingCase { get; }
- public PerSecond MaxEngineSpeed { get; set; }
-
- public static bool operator <(GearRating first, GearRating second)
- {
- return first.RatingCase < second.RatingCase && first.Rating < second.Rating;
- }
-
- public static bool operator >(GearRating first, GearRating second)
- {
- return first.RatingCase > second.RatingCase && first.Rating > second.Rating;
- }
+ foreach (var gear in ModelData.Gears.Keys) {
+ container.SetDataValue(
+ string.Format("Gear{0}-Rating", gear),
+ GearRatings.ContainsKey(gear)
+ ? GearRatings[gear].NumericValue
+ : new GearRating(GearRatingCase.E, 0, null).NumericValue);
+ }
- public override string ToString()
- {
- return string.Format("{0} / {1}", RatingCase, Rating);
+ container.SetDataValue("acc_rsv", accRsv?.Value() ?? 0);
+ GearRatings.Clear();
+ accRsv = null;
}
}
-
- internal enum GearRatingCase
- {
- A = 1, // inside preferred speed range and inside torque range
- B, // inside engine speed limits, torque demand too high
- C, // valid gear, gear residience time below threshold
- D, // inside engine speed limits, outside preferred speed range
- E // outside engine speed limits
- }
}
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/GearRating.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/GearRating.cs
new file mode 100644
index 0000000000000000000000000000000000000000..25a8bfe40e23b860daa9629f5565da8c707a34ca
--- /dev/null
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/GearRating.cs
@@ -0,0 +1,49 @@
+using TUGraz.VectoCommon.Utils;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
+
+ internal enum GearRatingCase
+ {
+ A = 1, // inside preferred speed range and inside torque range
+ B, // inside engine speed limits, torque demand too high
+ C, // valid gear, gear residience time below threshold
+ D, // inside engine speed limits, outside preferred speed range
+ E // outside engine speed limits
+ }
+
+
+ internal struct GearRating
+ {
+ public GearRating(GearRatingCase ratingCase, double rating, PerSecond maxEngineSpeed)
+ {
+ RatingCase = ratingCase;
+ Rating = rating;
+ MaxEngineSpeed = maxEngineSpeed;
+ }
+
+ public double Rating { get; }
+
+ public GearRatingCase RatingCase { get; }
+ public PerSecond MaxEngineSpeed { get; set; }
+
+ public double NumericValue
+ {
+ get { return ((int)RatingCase - 1) * 1e3 + (Rating * 100).LimitTo(0, 1e3-10); }
+ }
+
+ public static bool operator <(GearRating first, GearRating second)
+ {
+ return first.RatingCase < second.RatingCase || (first.RatingCase == second.RatingCase && first.Rating < second.Rating);
+ }
+
+ public static bool operator >(GearRating first, GearRating second)
+ {
+ return first.RatingCase > second.RatingCase || (first.RatingCase == second.RatingCase && first.Rating > second.Rating);
+ }
+
+ public override string ToString()
+ {
+ return string.Format("{0} / {1} ({2})", RatingCase, Rating, NumericValue);
+ }
+ }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/Gearbox.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/Gearbox.cs
index bb191e376671ed05caa6c45fa9873be69f41f908..9f4a69383a9de4b55369ccfa33d9ae37cef889d8 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/Gearbox.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/Gearbox.cs
@@ -82,8 +82,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
_strategy.Gearbox = this;
}
- LastDownshift = -double.MaxValue.SI<Second>();
- LastUpshift = -double.MaxValue.SI<Second>();
+ LastDownshift = double.MaxValue.SI<Second>();
+ LastUpshift = double.MaxValue.SI<Second>();
}
public override IResponse Initialize(NewtonMeter outTorque, PerSecond outAngularVelocity)
@@ -175,8 +175,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
Log.Debug("Gearbox Power Request: torque: {0}, angularVelocity: {1}", outTorque, outAngularVelocity);
if (DataBus.VehicleStopped) {
EngageTime = absTime;
- LastDownshift = -double.MaxValue.SI<Second>();
- LastUpshift = -double.MaxValue.SI<Second>();
+ LastDownshift = double.MaxValue.SI<Second>();
+ LastUpshift = double.MaxValue.SI<Second>();
}
if (DataBus.DriverBehavior == DrivingBehavior.Halted) {
EngageTime = absTime + dt;
@@ -410,6 +410,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
container[ModalResultField.n_gbx_out_avg] = (PreviousState.OutAngularVelocity +
CurrentState.OutAngularVelocity) / 2.0;
container[ModalResultField.T_gbx_out] = CurrentState.OutTorque;
+ (_strategy as AMTShiftStrategyV2)?.WriteModalResults(container);
}
protected override void DoCommitSimulationStep()
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/MaxCardanTorquePreprocessor.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/MaxCardanTorquePreprocessor.cs
index 3f87881ddea3b598bf45f84aabc40d13f905c07e..f7973e6889fb02c754cf1dea115d7cad16b1ac61 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/MaxCardanTorquePreprocessor.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/MaxCardanTorquePreprocessor.cs
@@ -27,7 +27,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
TestContainer.GearboxCtl.Gear = 1;
var init = TestContainer.VehiclePort.Initialize(Data.GearshiftParameters.StartVelocity, 0.SI<Radian>());
- var powertrainRatioWOGearbox = (Data.GearshiftParameters.StartVelocity / init.EngineSpeed / Data.GearboxData.Gears[1].Ratio).Cast<Meter>();
+ var powertrainRatioWOGearbox = (Data.GearshiftParameters.StartVelocity / init.EngineSpeed * Data.GearboxData.Gears[1].Ratio).Cast<Meter>();
var engineSpeedSteps = (Data.EngineData.FullLoadCurves[0].N95hSpeed - Data.EngineData.IdleSpeed) / 250;
@@ -38,7 +38,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl {
engineSpeed < Data.EngineData.FullLoadCurves[0].N95hSpeed;
engineSpeed += engineSpeedSteps) {
var maxTorque = Data.EngineData.FullLoadCurves[gearData.Key].FullLoadStationaryTorque(engineSpeed);
- var vehicleSpeed = engineSpeed * powertrainRatioWOGearbox * gearData.Value.Ratio;
+ var vehicleSpeed = engineSpeed * powertrainRatioWOGearbox / gearData.Value.Ratio;
var first = TestContainer.VehiclePort.Initialize(vehicleSpeed, 0.SI<Radian>());
var delta = first.EngineTorqueDemandTotal - maxTorque;
var grad = SearchAlgorithm.Search(
diff --git a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
index 52e8001005b810438ec826091f85499cf3389f2f..3a8373979bd54f704e47abcff38f87af00e0ce6d 100644
--- a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
@@ -247,9 +247,9 @@ namespace TUGraz.VectoCore.OutputData
ModalResultField.FCMap, ModalResultField.FCAUXc, ModalResultField.FCWHTCc,
ModalResultField.FCAAUX, ModalResultField.FCFinal
}.Select(x => x.GetName()));
-#if TRACE
+//#if TRACE
strCols = strCols.Concat(_additionalColumns);
-#endif
+//#endif
if (WriteModalResults) {
var filteredData = Data;
foreach (var filter in _filters) {
diff --git a/VectoCore/VectoCore/VectoCore.csproj b/VectoCore/VectoCore/VectoCore.csproj
index e272c85b0a0197ed211f374e47939936274e51ba..2bd6a04f391af6f88154eb37cfed9260af06cf41 100644
--- a/VectoCore/VectoCore/VectoCore.csproj
+++ b/VectoCore/VectoCore/VectoCore.csproj
@@ -199,6 +199,7 @@
<Compile Include="Models\SimulationComponent\Impl\DrivingCycleEnumerator.cs" />
<Compile Include="Models\SimulationComponent\Impl\EngineFanAuxiliary.cs" />
<Compile Include="Models\SimulationComponent\Impl\EngineSpeedDriveOffPreprocessor.cs" />
+ <Compile Include="Models\SimulationComponent\Impl\GearRating.cs" />
<Compile Include="Models\SimulationComponent\Impl\MaxCardanTorqueLookup.cs" />
<Compile Include="Models\SimulationComponent\Impl\MaxCardanTorquePreprocessor.cs" />
<Compile Include="Models\SimulationComponent\Impl\MaxGradabilityLookup.cs" />
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/ShiftStrategyV2Test.cs b/VectoCore/VectoCoreTest/Models/Simulation/ShiftStrategyV2Test.cs
index 6a1a259304529bc432642340595172a4aa2ef698..95b3bbba793947753d70b2762fea18800527db3a 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/ShiftStrategyV2Test.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/ShiftStrategyV2Test.cs
@@ -1,9 +1,13 @@
using System;
+using System.Collections.Generic;
using System.IO;
+using System.Linq;
using NUnit.Framework;
using NUnit.Framework.Internal;
using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
using TUGraz.VectoCore.InputData.FileIO.JSON;
+using TUGraz.VectoCore.InputData.FileIO.XML.Declaration;
using TUGraz.VectoCore.Models.Simulation.Impl;
using TUGraz.VectoCore.OutputData;
using TUGraz.VectoCore.OutputData.FileIO;
@@ -24,27 +28,37 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
}
- [TestCase(Class9Decl),
+ [TestCase(Class9Decl, 0),
+ TestCase(@"E:\QUAM\Downloads\2018-07-13_Prototype-TCU-VECTO_R2016a\a_input_Data\Cl-5_tractor_directdr_axle_2p53.xml", 0),
+ TestCase(@"E:\QUAM\Downloads\2018-07-13_Prototype-TCU-VECTO_R2016a\a_input_Data\Cl-5_tractor_directdr_axle_2p53.xml", 1),
+ TestCase(@"E:\QUAM\Downloads\2018-07-13_Prototype-TCU-VECTO_R2016a\a_input_Data\Cl-5_tractor_directdr_axle_2p53.xml", 4)
]
- public void TestSShiftStrategyV2(string jobFile)
+ public void TestSShiftStrategyV2(string jobFile, int i)
{
var fileWriter = new FileOutputWriter(jobFile);
var sumWriter = new SummaryDataContainer(fileWriter);
var jobContainer = new JobContainer(sumWriter);
- var dataProvider = JSONInputDataFactory.ReadJsonJob(jobFile);
+ var dataProvider = Path.GetExtension(jobFile) == ".vecto"
+ ? JSONInputDataFactory.ReadJsonJob(jobFile)
+ : new XMLDeclarationInputDataProvider(jobFile, true);
var runsFactory = new SimulatorFactory(ExecutionMode.Declaration, dataProvider, fileWriter) {
ModalResults1Hz = false,
WriteModalResults = true,
ActualModalData = false,
Validate = false,
+ SumData = sumWriter,
};
- jobContainer.AddRuns(runsFactory);
+ var runs = runsFactory.SimulationRuns().ToArray();
+ jobContainer.AddRun(runs[i]);
- var i = 0;
+ jobContainer.Runs[0].Run.Run();
- jobContainer.Runs[i].Run.Run();
+ Assert.IsTrue(jobContainer.Runs[0].Run.FinishedWithoutErrors);
+ jobContainer.Execute();
+ jobContainer.WaitFinished();
}
}
+
}