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

Skip to content
Snippets Groups Projects
Commit 6e2c5e12 authored by Michael KRISPER's avatar Michael KRISPER
Browse files

Renamed PCCSegments members (no functional changes)

parent 3e16dd31
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
VectoCore/VectoCore/Models/Simulation/Impl/PCCEcoRollEngineStopPreprocessor.cs
+ 3
− 5
View file @ 6e2c5e12
......@@ -184,13 +184,11 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
public class PCCSegment
{
public Meter StartDistance { get; set; }
public Meter DistanceMinSpeed { get; set; }
public Meter DistanceAtLowestSpeed { get; set; }
public Meter EndDistance { get; set; }
public MeterPerSecond TargetSpeed { get; set; }
public Meter Altitude { get; set; }
public Joule EnergyMinSpeed { get; set; }
public Joule EnergyEnd { get; set; }
public Joule EnergyAtLowestSpeed { get; set; }
public Joule EnergyAtEnd { get; set; }
}
}
VectoCore/VectoCore/Models/Simulation/Impl/PCCSegmentPreprocessor.cs
+ 8
− 9
View file @ 6e2c5e12
......@@ -75,7 +75,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
continue;
}
// target speed must not change within PCC segment
// target speed must not change within cycle pairs
if (!start.VehicleTargetSpeed.IsEqual(end.VehicleTargetSpeed)) {
targetSpeedChanged = end.Distance;
pccSegment = null;
......@@ -95,27 +95,26 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
+ slopeEngineDrag / start.VehicleTargetSpeed.Value()).SI<Radian>();
//DebugWriteLine($"MinSlope:{minSlope.ToInclinationPercent():P}");
var potentialEnergy = runData.VehicleData.TotalVehicleMass * Physics.GravityAccelleration * start.Altitude;
if (pccSegment is null && slope < minSlope) {
var lowestKineticEnergy = runData.VehicleData.TotalVehicleMass
* (start.VehicleTargetSpeed - PCCDriverData.UnderSpeed)
* (start.VehicleTargetSpeed - PCCDriverData.UnderSpeed) / 2;
var lowestSpeed = start.VehicleTargetSpeed - PCCDriverData.UnderSpeed;
var lowestKineticEnergy = runData.VehicleData.TotalVehicleMass * lowestSpeed * lowestSpeed / 2;
pccSegment = new PCCSegment {
DistanceMinSpeed = start.Distance,
DistanceAtLowestSpeed = start.Distance,
StartDistance = start.Distance - VectoMath.Min(
start.Distance - targetSpeedChanged - 1.SI<Meter>(),
PCCDriverData.PreviewDistanceUseCase1),
TargetSpeed = start.VehicleTargetSpeed,
Altitude = start.Altitude,
EnergyMinSpeed = potentialEnergy + lowestKineticEnergy,
EnergyAtLowestSpeed = potentialEnergy + lowestKineticEnergy,
};
}
if (pccSegment != null && slope > minSlope) {
pccSegment.EndDistance = start.Distance;
var currentKineticEnergy = runData.VehicleData.TotalVehicleMass
* start.VehicleTargetSpeed
* start.VehicleTargetSpeed / 2;
pccSegment.EnergyEnd = potentialEnergy + currentKineticEnergy;
* start.VehicleTargetSpeed * start.VehicleTargetSpeed / 2;
pccSegment.EnergyAtEnd = potentialEnergy + currentKineticEnergy;
PCCSegments.Segments.Add(pccSegment);
pccSegment = null;
}
......
VectoCore/VectoCore/Models/SimulationComponent/Impl/DefaultDriverStrategy.cs
+ 32
− 35
View file @ 6e2c5e12
......@@ -170,7 +170,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
var val = 0;
if (Driver.DataBus.MileageCounter.Distance > PCCSegments.Current.EndDistance) {
val = 0;
} else if (Driver.DataBus.MileageCounter.Distance > PCCSegments.Current.DistanceMinSpeed) {
} else if (Driver.DataBus.MileageCounter.Distance > PCCSegments.Current.DistanceAtLowestSpeed) {
val = 5;
} else if (Driver.DataBus.MileageCounter.Distance > PCCSegments.Current.StartDistance) {
val = -5;
......@@ -363,22 +363,22 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
// check for PCC usecase 1 -------------------------------------------------
var endUseCase1 = PCCSegments.Current.EndDistance;
var endEnergyUseCase1 = PCCSegments.Current.EnergyEnd;
var endEnergyUseCase1 = PCCSegments.Current.EnergyAtEnd;
if ((distance + Driver.DriverData.PCC.PreviewDistanceUseCase1).IsSmallerOrEqual(endUseCase1)) {
endUseCase1 = distance + Driver.DriverData.PCC.PreviewDistanceUseCase1;
var endCycleEntry = Driver.DataBus.DrivingCycleInfo.CycleLookAhead(Driver.DriverData.PCC.PreviewDistanceUseCase1);
endEnergyUseCase1 = CalculateEnergy(endCycleEntry.Altitude, endCycleEntry.VehicleTargetSpeed, Driver.DataBus.VehicleInfo.TotalMass);
}
var vehicleSpeed = Driver.DataBus.VehicleInfo.VehicleSpeed;
var coastingForce = CoastingForce(targetVelocity, vehicleSpeed);
var coastingForce = CalculateCoastingForce(targetVelocity, vehicleSpeed);
var energyCoastingEndUseCase1 = coastingForce * (endUseCase1 - distance);
var currentEnergy = CalculateEnergy(Driver.DataBus.DrivingCycleInfo.Altitude, vehicleSpeed, Driver.DataBus.VehicleInfo.TotalMass);
var energyCoastingLow = coastingForce * (PCCSegments.Current.DistanceMinSpeed - distance);
var energyCoastingLow = coastingForce * (PCCSegments.Current.DistanceAtLowestSpeed - distance);
var beforeVLow = distance.IsSmaller(PCCSegments.Current.DistanceMinSpeed);
var beforeVLow = distance.IsSmaller(PCCSegments.Current.DistanceAtLowestSpeed);
var speedSufficient = vehicleSpeed.IsGreaterOrEqual(targetVelocity - Driver.DriverData.PCC.UnderSpeed);
var currentEnergyHigherThanEndUseCase1 = currentEnergy.IsGreaterOrEqual(endEnergyUseCase1 + energyCoastingEndUseCase1);
var currentEnergyHigherThanMin = currentEnergy.IsGreaterOrEqual(PCCSegments.Current.EnergyMinSpeed + energyCoastingLow);
var currentEnergyHigherThanMin = currentEnergy.IsGreaterOrEqual(PCCSegments.Current.EnergyAtLowestSpeed + energyCoastingLow);
if (beforeVLow
&& speedSufficient
......@@ -390,7 +390,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
// check for PCC use case 2 ------------------------------------------------
var endUseCase2 = PCCSegments.Current.EndDistance;
var endEnergyUseCase2 = PCCSegments.Current.EnergyEnd;
var endEnergyUseCase2 = PCCSegments.Current.EnergyAtEnd;
if ((distance + Driver.DriverData.PCC.PreviewDistanceUseCase2).IsSmallerOrEqual(endUseCase2)) {
endUseCase2 = distance + Driver.DriverData.PCC.PreviewDistanceUseCase2;
var endCycleEntry = Driver.DataBus.DrivingCycleInfo.CycleLookAhead(Driver.DriverData.PCC.PreviewDistanceUseCase2);
......@@ -398,7 +398,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
}
var energyCoastingEndUseCase2 = coastingForce * (endUseCase2 - distance);
var beyondVLow = distance.IsGreaterOrEqual(PCCSegments.Current.DistanceMinSpeed);
var beyondVLow = distance.IsGreaterOrEqual(PCCSegments.Current.DistanceAtLowestSpeed);
var currentEnergyHigherThanEndUseCase2 = currentEnergy.IsGreaterOrEqual(endEnergyUseCase2 + energyCoastingEndUseCase2);
var speedSufficientUseCase2 = vehicleSpeed.IsGreaterOrEqual(VectoMath.Max(targetVelocity - Driver.DriverData.PCC.UnderSpeed, Driver.DriverData.PCC.MinSpeed));
var speedBelowTargetspeed = vehicleSpeed.IsSmallerOrEqual(targetVelocity - 1.KMPHtoMeterPerSecond());
......@@ -411,7 +411,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
}
}
private Newton CoastingForce(MeterPerSecond targetVelocity, MeterPerSecond vehicleSpeed)
private Newton CalculateCoastingForce(MeterPerSecond targetVelocity, MeterPerSecond vehicleSpeed)
{
var dataBus = Driver.DataBus;
var airDragForce = Driver.DataBus.VehicleInfo.AirDragResistance(vehicleSpeed, targetVelocity);
......@@ -626,7 +626,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
Log.Debug("Lookahead distance: {0} @ current speed {1}", lookaheadDistance, currentSpeed);
var nextActions = new List<DrivingBehaviorEntry>();
foreach (var entry in lookaheadData) {
var nextTargetSpeed = OverspeedAllowed(entry.VehicleTargetSpeed)
var nextTargetSpeed = IsOverspeedAllowed(entry.VehicleTargetSpeed)
? ApplyOverspeed(entry.VehicleTargetSpeed)
: entry.VehicleTargetSpeed;
if (nextTargetSpeed >= currentSpeed) {
......@@ -690,37 +690,33 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
protected internal virtual Meter ComputeCoastingDistance(MeterPerSecond vehicleSpeed,
DrivingCycleData.DrivingCycleEntry actionEntry)
{
var targetSpeed = OverspeedAllowed(actionEntry.VehicleTargetSpeed)
? actionEntry.VehicleTargetSpeed + Driver.DriverData.OverSpeed.OverSpeed
: actionEntry.VehicleTargetSpeed;
var targetSpeed = actionEntry.VehicleTargetSpeed;
if (IsOverspeedAllowed(actionEntry.VehicleTargetSpeed)) {
targetSpeed += Driver.DriverData.OverSpeed.OverSpeed;
}
var vehicleMass = Driver.DataBus.VehicleInfo.TotalMass + Driver.DataBus.WheelsInfo.ReducedMassWheels;
var targetAltitude = actionEntry.Altitude;
var vehicleAltitude = Driver.DataBus.DrivingCycleInfo.Altitude;
var targetEnergy = vehicleMass * Physics.GravityAccelleration * targetAltitude +
vehicleMass * targetSpeed * targetSpeed / 2;
var vehicleEnergy = vehicleMass * Physics.GravityAccelleration * vehicleAltitude +
vehicleMass * vehicleSpeed * vehicleSpeed / 2;
var energyDifference = vehicleEnergy - targetEnergy;
var kineticEnergyAtTarget = vehicleMass * Physics.GravityAccelleration * targetAltitude
+ vehicleMass * targetSpeed * targetSpeed / 2;
var currentKineticEnergy = vehicleMass * Physics.GravityAccelleration * vehicleAltitude
+ vehicleMass * vehicleSpeed * vehicleSpeed / 2;
var energyDifference = currentKineticEnergy - kineticEnergyAtTarget;
var airDragForce = Driver.DataBus.VehicleInfo.AirDragResistance(vehicleSpeed, targetSpeed);
var rollResistanceForce = Driver.DataBus.VehicleInfo.RollingResistance(
var rollingResistanceForce = Driver.DataBus.VehicleInfo.RollingResistance(
((targetAltitude - vehicleAltitude) / (actionEntry.Distance - Driver.DataBus.MileageCounter.Distance))
.Value().SI<Radian>());
var iceDragLoss = Driver.DataBus.PowertrainInfo.HasCombustionEngine
? Driver.DataBus.EngineInfo.EngineDragPower(Driver.DataBus.EngineInfo.EngineSpeed)
: 0.SI<Watt>();
var emDragLoss = CalculateElectricMotorDragLoss() ?? 0.SI<Watt>();
var gearboxLoss = Driver.DataBus.GearboxInfo?.GearboxLoss() ?? 0.SI<Watt>();
var axleLoss = Driver.DataBus.AxlegearInfo?.AxlegearLoss() ?? 0.SI<Watt>();
var gearboxLossPower = Driver.DataBus.GearboxInfo?.GearboxLoss() ?? 0.SI<Watt>();
var axleLossPower = Driver.DataBus.AxlegearInfo?.AxlegearLoss() ?? 0.SI<Watt>();
var emDragLossPower = CalculateElectricMotorDragLoss();
var iceDragLossPower = Driver.DataBus.EngineInfo?.EngineDragPower(Driver.DataBus.EngineInfo.EngineSpeed) ?? 0.SI<Watt>();
var coastingResistanceForce = airDragForce
+ rollResistanceForce
+ (gearboxLoss + axleLoss + emDragLoss - iceDragLoss) / vehicleSpeed;
var totalComponentLossPowers = gearboxLossPower + axleLossPower + emDragLossPower - iceDragLossPower;
var coastingResistanceForce = airDragForce + rollingResistanceForce + totalComponentLossPowers / vehicleSpeed;
var coastingDecisionFactor = Driver.DriverData.LookAheadCoasting.LookAheadDecisionFactor.Lookup(
targetSpeed, vehicleSpeed - targetSpeed);
......@@ -733,12 +729,13 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
var sum = 0.SI<Watt>();
var db = Driver.DataBus;
foreach (var pos in db.PowertrainInfo.ElectricMotorPositions)
sum += db.ElectricMotorInfo(pos).DragPower(db.BatteryInfo.InternalVoltage,
sum += db.ElectricMotorInfo(pos).DragPower(
db.BatteryInfo.InternalVoltage,
db.ElectricMotorInfo(pos).ElectricMotorSpeed);
return sum;
}
public bool OverspeedAllowed(MeterPerSecond velocity, bool prohibitOverspeed = false) =>
public bool IsOverspeedAllowed(MeterPerSecond velocity, bool prohibitOverspeed = false) =>
!prohibitOverspeed
&& Driver.DriverData.OverSpeed.Enabled
&& velocity > Driver.DriverData.OverSpeed.MinSpeed
......@@ -861,7 +858,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
Driver.DriverBehavior = DrivingBehavior.Driving;
var velocity = targetVelocity;
if (DriverStrategy.OverspeedAllowed(targetVelocity, prohibitOverspeed)) {
if (DriverStrategy.IsOverspeedAllowed(targetVelocity, prohibitOverspeed)) {
velocity = DriverStrategy.ApplyOverspeed(velocity);
}
......@@ -945,7 +942,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
var debugResponse = Driver.DrivingActionRoll(absTime, ds, velocityWithOverspeed, gradient);
}
if (DataBus.VehicleInfo.VehicleSpeed.IsGreater(0) && DriverStrategy.OverspeedAllowed(targetVelocity, prohibitOverspeed)) {
if (DataBus.VehicleInfo.VehicleSpeed.IsGreater(0) && DriverStrategy.IsOverspeedAllowed(targetVelocity, prohibitOverspeed)) {
second = Driver.DrivingActionCoast(absTime, ds, velocityWithOverspeed, gradient);
debug.Add(new { action = "first:(Underload & Overspeed)-> Coast", second });
second = HandleCoastAfterUnderloadWithOverspeed(absTime, ds, gradient, velocityWithOverspeed, debug, second);
......@@ -1046,7 +1043,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
}
IResponse first;
if (DriverStrategy.OverspeedAllowed(targetVelocity, prohibitOverspeed) &&
if (DriverStrategy.IsOverspeedAllowed(targetVelocity, prohibitOverspeed) &&
DataBus.VehicleInfo.VehicleSpeed.IsGreaterOrEqual(targetVelocity)) {
first = Driver.DrivingActionCoast(absTime, ds, velocityWithOverspeed, gradient);
debug.Add(new { action = "Coast", first });
......
VectoCore/VectoCoreTest/Models/Simulation/SimulationPreprocessingTest.cs
+ 3
− 3
View file @ 6e2c5e12
......@@ -139,7 +139,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
Console.WriteLine("run: {0}{1} vehicle mass: {2}", jobContainer.Runs[i].Run.RunName, jobContainer.Runs[i].Run.RunSuffix, jobContainer.Runs[i].Run.GetContainer().RunData.VehicleData.TotalVehicleMass);
foreach (var entry in segments.Segments) {
Console.WriteLine("x_start: {0}, x_vLow: {1}, x_end: {2}", entry.StartDistance, entry.DistanceMinSpeed, entry.EndDistance);
Console.WriteLine("x_start: {0}, x_vLow: {1}, x_end: {2}", entry.StartDistance, entry.DistanceAtLowestSpeed, entry.EndDistance);
}
Console.WriteLine();
......@@ -148,8 +148,8 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
foreach (var entry in segments.Segments) {
Console.WriteLine("{0},0", entry.StartDistance.Value());
Console.WriteLine("{0},-5", entry.StartDistance.Value());
Console.WriteLine("{0},-5", entry.DistanceMinSpeed.Value());
Console.WriteLine("{0},5", entry.DistanceMinSpeed.Value());
Console.WriteLine("{0},-5", entry.DistanceAtLowestSpeed.Value());
Console.WriteLine("{0},5", entry.DistanceAtLowestSpeed.Value());
Console.WriteLine("{0},5", entry.EndDistance.Value());
Console.WriteLine("{0},0", entry.EndDistance.Value());
}
......
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