From 56385b2b6f327a661d1dc23aa469725edb802b65 Mon Sep 17 00:00:00 2001
From: Markus Quaritsch <markus.quaritsch@tugraz.at>
Date: Wed, 6 Jul 2022 21:34:30 +0200
Subject: [PATCH] adding more writer functions for summary data registering
components with sum-data to add component-specific columns adding
component-specific columns in sum-data make auxiliary component register aux
with mod-data and sum-data
---
.../Models/Simulation/IVehicleContainer.cs | 1 +
.../Simulation/Impl/PowertrainBuilder.cs | 59 +-
.../Simulation/Impl/VehicleContainer.cs | 3 +-
.../Impl/EngineAuxiliary.cs | 8 +-
.../VectoCore/OutputData/SumDataFields.cs | 374 ++++-
.../OutputData/SummaryDataContainer.cs | 1276 ++++++-----------
.../Utils/MockVehicleContainer.cs | 2 +
7 files changed, 840 insertions(+), 883 deletions(-)
diff --git a/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs b/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
index 7adcd272a1..6000d8386c 100644
--- a/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
+++ b/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
@@ -79,6 +79,7 @@ namespace TUGraz.VectoCore.Models.Simulation
void StartSimulationRun();
IEnumerable<ISimulationPreprocessor> GetPreprocessingRuns { get; }
+ ISumData SumData { get; }
void AddPreprocessor(ISimulationPreprocessor simulationPreprocessor);
}
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
index 54ced6f78a..10459d3335 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
@@ -102,7 +102,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
}
var container = new VehicleContainer(ExecutionMode.Engineering, modData, _sumWriter) { RunData = data };
- container.ModalData.AddAuxiliary(Constants.Auxiliaries.Cycle);
+ //container.ModalData.AddAuxiliary(Constants.Auxiliaries.Cycle);
var cycle = new PowertrainDrivingCycle(container, data.Cycle);
var engine = new EngineOnlyCombustionEngine(container, data.EngineData);
@@ -221,10 +221,9 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
default:
throw new ArgumentOutOfRangeException("AuxiliaryDemandType", auxData.DemandType.ToString());
}
- container.ModalData?.AddAuxiliary(id);
+ //container.ModalData?.AddAuxiliary(id);
+ //container.SumData?.AddAuxiliary(id);
}
-
-
engine.Connect(aux.Port());
}
@@ -233,18 +232,23 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
var aux = CreateSpeedDependentAuxiliaries(data, container);
var engineFan = new EngineFanAuxiliary(data.FanDataVTP.FanCoefficients.Take(3).ToArray(), data.FanDataVTP.FanDiameter);
aux.AddCycle(Constants.Auxiliaries.IDs.Fan, cycleEntry => engineFan.PowerDemand(cycleEntry.FanSpeed));
- container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.Fan);
+ //container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.Fan);
+ //container.SumData?.AddAuxiliary(Constants.Auxiliaries.IDs.Fan);
if (data.PTO != null) {
aux.AddConstant(Constants.Auxiliaries.IDs.PTOTransmission,
- DeclarationData.PTOTransmission.Lookup(data.PTO.TransmissionType).PowerDemand);
- container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
+ DeclarationData.PTOTransmission.Lookup(data.PTO.TransmissionType).PowerDemand,
Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
+ //container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
+ // Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
+ //container.SumData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission);
aux.Add(Constants.Auxiliaries.IDs.PTOConsumer,
- (n, absTime, dt, dryRun) => container.DrivingCycleInfo.PTOActive ? null : data.PTO.LossMap.GetTorqueLoss(n) * n);
- container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
+ (n, absTime, dt, dryRun) => container.DrivingCycleInfo.PTOActive ? null : data.PTO.LossMap.GetTorqueLoss(n) * n,
Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
+ //container.ModalData.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
+ // Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
+ //container.SumData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer);
}
engine.Connect(aux.Port());
@@ -1443,7 +1447,8 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
throw new ArgumentOutOfRangeException("AuxiliaryDemandType", auxData.DemandType.ToString());
}
- container.ModalData?.AddAuxiliary(id);
+ //container.ModalData?.AddAuxiliary(id);
+ //container.SumData?.AddAuxiliary(id);
}
RoadSweeperAuxiliary rdSwpAux = null;
@@ -1454,8 +1459,11 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
throw new VectoSimulationException("PTO activity 'road sweeping' requested, but no min. engine speed or gear provided");
}
rdSwpAux = new RoadSweeperAuxiliary(container);
- aux.Add(Constants.Auxiliaries.IDs.PTORoadsweeping, (nEng, absTime, dt, dryRun) => rdSwpAux.PowerDemand(nEng, absTime, dt, dryRun));
- container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTORoadsweeping, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTORoadsweeping);
+ aux.Add(Constants.Auxiliaries.IDs.PTORoadsweeping,
+ (nEng, absTime, dt, dryRun) => rdSwpAux.PowerDemand(nEng, absTime, dt, dryRun),
+ Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTORoadsweeping);
+ //container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTORoadsweeping, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTORoadsweeping);
+ //container.SumData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTORoadsweeping);
}
if (data.ExecutionMode == ExecutionMode.Engineering &&
@@ -1465,19 +1473,28 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
}
ptoDrive = new PTODriveAuxiliary(container, data.PTOCycleWhileDrive);
- aux.Add(Constants.Auxiliaries.IDs.PTODuringDrive, (nEng, absTime, dt, dryRun) => ptoDrive.PowerDemand(nEng, absTime, dt, dryRun));
- container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTODuringDrive, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTODuringDrive);
+ aux.Add(Constants.Auxiliaries.IDs.PTODuringDrive,
+ (nEng, absTime, dt, dryRun) => ptoDrive.PowerDemand(nEng, absTime, dt, dryRun),
+ Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTODuringDrive);
+ //container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTODuringDrive, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTODuringDrive);
+ //container.SumData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTODuringDrive);
}
if (data.PTO != null) {
aux.AddConstant(Constants.Auxiliaries.IDs.PTOTransmission,
- DeclarationData.PTOTransmission.Lookup(data.PTO.TransmissionType).PowerDemand);
- container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
- Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
+ DeclarationData.PTOTransmission.Lookup(data.PTO.TransmissionType).PowerDemand, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
+ //container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
+ // Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
aux.Add(Constants.Auxiliaries.IDs.PTOConsumer,
- (n, absTime, dt, dryRun) => container.DrivingCycleInfo.PTOActive || (rdSwpAux?.Active(absTime) ?? false) || (ptoDrive?.Active(absTime) ?? false) ? null : data.PTO.LossMap.GetTorqueLoss(n) * n);
- container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
- Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
+ (n, absTime, dt, dryRun) =>
+ container.DrivingCycleInfo.PTOActive || (rdSwpAux?.Active(absTime) ?? false) ||
+ (ptoDrive?.Active(absTime) ?? false)
+ ? null
+ : data.PTO.LossMap.GetTorqueLoss(n) * n,
+ Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
+ //container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
+ // Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
+ //container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer);
}
return aux;
@@ -1502,7 +1519,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
throw new ArgumentOutOfRangeException("AuxiliaryDemandType", auxData.DemandType.ToString());
}
- container.ModalData?.AddAuxiliary(id);
+ //container.ModalData?.AddAuxiliary(id);
}
return aux;
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs b/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
index c542532f73..48c82b0a70 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
@@ -203,7 +203,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
}
if (WriteSumData != null) {
- WriteSumData.RegisterComponent(component);
+ WriteSumData.RegisterComponent(component, RunData);
}
}
@@ -239,6 +239,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
}
public virtual IEnumerable<ISimulationPreprocessor> GetPreprocessingRuns => new ReadOnlyCollection<ISimulationPreprocessor>(Preprocessors);
+ public ISumData SumData => WriteSumData;
public virtual void AddPreprocessor(ISimulationPreprocessor simulationPreprocessor)
{
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
index e7f82a552c..3f29f36024 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
@@ -70,9 +70,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
/// </summary>
/// <param name="auxId"></param>
/// <param name="powerDemand"></param>
- public void AddConstant(string auxId, Watt powerDemand)
+ public void AddConstant(string auxId, Watt powerDemand, string columnName = null)
{
- Add(auxId, (nEng, absTime, dt, dryRun) => powerDemand);
+ Add(auxId, (nEng, absTime, dt, dryRun) => powerDemand, columnName);
}
/// <summary>
@@ -95,9 +95,11 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
/// </summary>
/// <param name="auxId"></param>
/// <param name="powerLossFunction"></param>
- public void Add(string auxId, Func<PerSecond, Second, Second, bool, Watt> powerLossFunction)
+ public void Add(string auxId, Func<PerSecond, Second, Second, bool, Watt> powerLossFunction, string columnName = null)
{
Auxiliaries[auxId] = powerLossFunction;
+ (DataBus as IVehicleContainer)?.ModalData?.AddAuxiliary(auxId, columnName);
+ (DataBus as IVehicleContainer)?.SumData?.AddAuxiliary(auxId);
}
public NewtonMeter Initialize(NewtonMeter torque, PerSecond angularSpeed)
diff --git a/VectoCore/VectoCore/OutputData/SumDataFields.cs b/VectoCore/VectoCore/OutputData/SumDataFields.cs
index b9a3676918..12749ac202 100644
--- a/VectoCore/VectoCore/OutputData/SumDataFields.cs
+++ b/VectoCore/VectoCore/OutputData/SumDataFields.cs
@@ -1,7 +1,16 @@
using System;
using System.Collections.Generic;
+using System.Data;
using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using TUGraz.VectoCommon.BusAuxiliaries;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
+using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
namespace TUGraz.VectoCore.OutputData
{
@@ -290,6 +299,13 @@ namespace TUGraz.VectoCore.OutputData
public delegate object WriteSumEntry(VectoRunData r, IModalDataContainer m);
+ public delegate object WriteFuelEntry(VectoRunData r, IModalDataContainer m, IFuelProperties f);
+
+ public delegate object WriteEmEntry(VectoRunData r, IModalDataContainer m, PowertrainPosition emPos);
+
+
+ public delegate object WriteAuxEntry(VectoRunData r, IModalDataContainer m, DataColumn aux);
+
private static Tuple<ModalResultField[], WriteSumEntry> SumFunc(ModalResultField[] mrf, WriteSumEntry w)
{
return Tuple.Create(mrf, w);
@@ -300,14 +316,362 @@ namespace TUGraz.VectoCore.OutputData
return Tuple.Create<ModalResultField[], WriteSumEntry>(null, w);
}
+ private static Tuple<ModalResultField[], WriteFuelEntry> FuelFunc(WriteFuelEntry w)
+ {
+ return Tuple.Create<ModalResultField[], WriteFuelEntry>(null, w);
+ }
+
public static readonly Dictionary<string, Tuple<ModalResultField[], WriteSumEntry>> SumDataValue = new Dictionary<string, Tuple<ModalResultField[], WriteSumEntry>>() {
// common fields
- {SumDataFields.SORT, SumFunc((r, m) => r.JobNumber * 1000 + r.RunNumber)},
- {SumDataFields.JOB, SumFunc((r, m) => $"{r.JobNumber}-{r.RunNumber}")},
- {SumDataFields.INPUTFILE, SumFunc((r,m) => SummaryDataContainer.ReplaceNotAllowedCharacters(r.JobName)) },
- // engine Infos
- {SumDataFields.ENGINE_MANUFACTURER, SumFunc((r, m) => r.EngineData.Manufacturer)},
+ { SORT, SumFunc((r, m) => r.JobNumber * 1000 + r.RunNumber)},
+ { JOB, SumFunc((r, m) => $"{r.JobNumber}-{r.RunNumber}")},
+ { INPUTFILE, SumFunc((r,m) => SummaryDataContainer.ReplaceNotAllowedCharacters(r.JobName)) },
+ { CYCLE, SumFunc((r, m) => SummaryDataContainer.ReplaceNotAllowedCharacters(r.Cycle.Name + Constants.FileExtensions.CycleFile))},
+ { STATUS, SumFunc((r, m) => m.RunStatus)},
+
+ { TIME, SumFunc((r,m) => (ConvertedSI)m.Duration)},
+ { DISTANCE, SumFunc((r, m) => m.Distance.ConvertToKiloMeter())},
+ { SPEED, SumFunc((r, m) => m.Speed().ConvertToKiloMeterPerHour())},
+ { ALTITUDE_DELTA, SumFunc((r, m) => (ConvertedSI)m.AltitudeDelta())},
+
+
+ // Vehicle
+ { VEHICLE_FUEL_TYPE, SumFunc((r, m) => m.FuelData.Select(x => x.GetLabel()).Join())},
+ { P_WHEEL_POS, SumFunc((r, m) => m.PowerWheelPositive().ConvertToKiloWatt())},
+ { P_WHEEL, SumFunc((r, m) => m.PowerWheel().ConvertToKiloWatt())},
+ { VEHICLE_MANUFACTURER, SumFunc((r, m) => r.VehicleData.Manufacturer)},
+ { VIN_NUMBER, SumFunc((r, m) => r.VehicleData.VIN)},
+ { VEHICLE_MODEL, SumFunc((r, m) => r.VehicleData.ModelName)},
+ { HDV_CO2_VEHICLE_CLASS, SumFunc((r, m) => r.Mission?.BusParameter?.BusGroup.GetClassNumber() ?? r.VehicleData.VehicleClass.GetClassNumber())},
+ { CURB_MASS, SumFunc((r, m) => (ConvertedSI)r.VehicleData.CurbMass)},
+ { LOADING, SumFunc((r, m) => (ConvertedSI)r.VehicleData.Loading)},
+ { PassengerCount, SumFunc((r, m) => r.VehicleData.PassengerCount)},
+ { CARGO_VOLUME, SumFunc((r, m) => (ConvertedSI)r.VehicleData.CargoVolume)},
+ { TOTAL_VEHICLE_MASS, SumFunc((r, m) => (ConvertedSI)r.VehicleData.TotalVehicleMass)},
+ { SLEEPER_CAB, SumFunc((r, m) => r.VehicleData.SleeperCab.HasValue ? (r.VehicleData.SleeperCab.Value ? "yes" : "no") : "-")},
+ { ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER, SumFunc((r, m) => r.VehicleData.RollResistanceCoefficientWithoutTrailer)},
+ { ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER, SumFunc((r, m) => r.VehicleData.TotalRollResistanceCoefficient)},
+ { R_DYN, SumFunc((r, m) => (ConvertedSI)r.VehicleData.DynamicTyreRadius)},
+ { ADAS_TECHNOLOGY_COMBINATION, SumFunc((r, m) => r.VehicleData.ADAS != null ? DeclarationData.ADASCombinations.Lookup(r.VehicleData.ADAS, r.GearboxData?.Type ?? GearboxType.NoGearbox).ID : "")},
+ { REESS_CAPACITY, SumFunc((r, m) => r.BatteryData?.Capacity != null ? $"{r.BatteryData?.Capacity.AsAmpHour} Ah" : r.SuperCapData?.Capacity != null ? $"{r.SuperCapData.Capacity} F" : null)},
+ { TCU_MODEL, SumFunc((r, m) => r.ShiftStrategy)},
+ { PTO_TECHNOLOGY, SumFunc((r, m) => r.PTO?.TransmissionType ?? "")},
+
+ // air drag infos
+ { AIRDRAG_MODEL, SumFunc((r, m) => r.AirdragData.ModelName)},
+ { AIRDRAG_CERTIFICATION_METHOD, SumFunc((r, m) => r.AirdragData.CertificationMethod.GetName())},
+ { AIRDRAG_CERTIFICATION_NUMBER, SumFunc((r, m) => r.AirdragData.CertificationMethod == CertificationMethod.StandardValues ? "" : r.AirdragData.CertificationNumber)},
+ { CD_x_A_DECLARED, SumFunc((r, m) => (ConvertedSI)r.AirdragData.DeclaredAirdragArea)},
+ { CD_x_A, SumFunc((r, m) => (ConvertedSI)r.AirdragData.CrossWindCorrectionCurve.AirDragArea)},
+ // engine infos
+ { ENGINE_MANUFACTURER, SumFunc((r, m) => r.EngineData.Manufacturer)},
+ { ENGINE_MODEL, SumFunc((r, m) => r.EngineData.ModelName)},
+ { ENGINE_CERTIFICATION_NUMBER, SumFunc((r, m) => r.EngineData.CertificationNumber)},
+ { ENGINE_FUEL_TYPE, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.FuelData.GetLabel()).Join(" / "))},
+ { ENGINE_RATED_POWER, SumFunc((r, m) => r.EngineData.RatedPowerDeclared != null && r.EngineData.RatedPowerDeclared > 0 ? r.EngineData.RatedPowerDeclared.ConvertToKiloWatt() : r.EngineData.FullLoadCurves[0].MaxPower.ConvertToKiloWatt())},
+ { ENGINE_IDLING_SPEED, SumFunc((r, m) => (ConvertedSI)r.EngineData.IdleSpeed.AsRPM.SI<Scalar>())},
+ { ENGINE_RATED_SPEED, SumFunc((r, m) => r.EngineData.RatedSpeedDeclared != null && r.EngineData.RatedSpeedDeclared > 0 ? (ConvertedSI)r.EngineData.RatedSpeedDeclared.AsRPM.SI<Scalar>() : (ConvertedSI)r.EngineData.FullLoadCurves[0].RatedSpeed.AsRPM.SI<Scalar>())},
+ { ENGINE_DISPLACEMENT, SumFunc((r, m) => r.EngineData.Displacement.ConvertToCubicCentiMeter())},
+ { ENGINE_WHTC_URBAN, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.WHTCUrban).Join(" / "))},
+ { ENGINE_WHTC_RURAL, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.WHTCRural).Join(" / "))},
+ { ENGINE_WHTC_MOTORWAY, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.WHTCMotorway).Join(" / "))},
+ { ENGINE_BF_COLD_HOT, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.ColdHotCorrectionFactor).Join(" / "))},
+ { ENGINE_CF_REG_PER, SumFunc((r, m) => r.EngineData.Fuels.Select(x => x.CorrectionFactorRegPer).Join(" / "))},
+ { ENGINE_ACTUAL_CORRECTION_FACTOR, SumFunc((r, m) => {
+ if (r.Mission?.MissionType == MissionType.VerificationTest) {
+ var fuelsWhtc = r.EngineData.Fuels.Select(
+ fuel => m.TimeIntegral<Kilogram>(m.GetColumnName(fuel.FuelData, ModalResultField.FCWHTCc)) /
+ m.TimeIntegral<Kilogram>(m.GetColumnName(fuel.FuelData, ModalResultField.FCMap)))
+ .Select(dummy => (double)dummy).ToArray();
+ return fuelsWhtc.Join(" / ");
+ }
+ return r.EngineData.Fuels.Select(x => x.FuelConsumptionCorrectionFactor).Join(" / ");
+ })},
+
+ // axlegear infos
+ { AXLE_MANUFACTURER, SumFunc((r, m) => r.AxleGearData.Manufacturer)},
+ { AXLE_MODEL, SumFunc((r, m) => r.AxleGearData.ModelName)},
+ { AXLE_RATIO, SumFunc((r, m) => (ConvertedSI)r.AxleGearData.AxleGear.Ratio.SI<Scalar>())},
+ { AXLEGEAR_CERTIFICATION_METHOD, SumFunc((r, m) => r.AxleGearData.CertificationMethod.GetName())},
+ { AXLEGEAR_CERTIFICATION_NUMBER, SumFunc((r, m) => r.AxleGearData.CertificationMethod == CertificationMethod.StandardValues ? "" : r.AxleGearData.CertificationNumber)},
+
+ // axle/tyre infos
+ { NUM_AXLES_DRIVEN, SumFunc((r, m) => r.VehicleData.AxleData.Count(x => x.AxleType == AxleType.VehicleDriven))},
+ { NUM_AXLES_NON_DRIVEN, SumFunc((r, m) => r.VehicleData.AxleData.Count(x => x.AxleType == AxleType.VehicleNonDriven))},
+ { NUM_AXLES_TRAILER, SumFunc((r, m) => r.VehicleData.AxleData.Count(x => x.AxleType == AxleType.Trailer))},
+
+ { DECLARED_RRC_AXLE1, SumFunc((r, m) => r.VehicleData.AxleData.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[0].RollResistanceCoefficient : double.NaN) },
+ { DECLARED_RRC_AXLE2, SumFunc((r, m) => r.VehicleData.AxleData.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[1].RollResistanceCoefficient : double.NaN) },
+ { DECLARED_RRC_AXLE3, SumFunc((r, m) => r.VehicleData.AxleData.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[2].RollResistanceCoefficient : double.NaN) },
+ { DECLARED_RRC_AXLE4, SumFunc((r, m) => r.VehicleData.AxleData.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[3].RollResistanceCoefficient : double.NaN) },
+
+ { DECLARED_FZISO_AXLE1, SumFunc((r, m) => r.VehicleData.AxleData.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[0].TyreTestLoad : null) },
+ { DECLARED_FZISO_AXLE2, SumFunc((r, m) => r.VehicleData.AxleData.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[1].TyreTestLoad : null) },
+ { DECLARED_FZISO_AXLE3, SumFunc((r, m) => r.VehicleData.AxleData.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[2].TyreTestLoad : null) },
+ { DECLARED_FZISO_AXLE4, SumFunc((r, m) => r.VehicleData.AxleData.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[3].TyreTestLoad : null) },
+
+ // angle drive
+ { ANGLEDRIVE_MANUFACTURER, SumFunc((r, m) => r.AngledriveData?.Manufacturer ?? Constants.NOT_AVAILABLE)},
+ { ANGLEDRIVE_MODEL, SumFunc((r, m) => r.AngledriveData?.ModelName?? Constants.NOT_AVAILABLE)},
+ { ANGLEDRIVE_RATIO, SumFunc((r, m) => r.AngledriveData?.Angledrive.Ratio)},
+ { ANGLEDRIVE_CERTIFICATION_METHOD, SumFunc((r, m) => r.AngledriveData?.CertificationMethod.GetName() ?? "")},
+ { ANGLEDRIVE_CERTIFICATION_NUMBER, SumFunc((r, m) => r.AngledriveData == null || r.AngledriveData.CertificationMethod == CertificationMethod.StandardValues ? "" : r.AngledriveData.CertificationNumber)},
+
+ // retarder
+ { RETARDER_TYPE, SumFunc((r, m) => (r.Retarder?.Type ?? RetarderType.None).GetLabel())},
+ { RETARDER_MANUFACTURER, SumFunc((r, m) => r.Retarder != null && r.Retarder.Type.IsDedicatedComponent() ? r.Retarder.Manufacturer : Constants.NOT_AVAILABLE)},
+ { RETARDER_MODEL, SumFunc((r, m) => r.Retarder != null && r.Retarder.Type.IsDedicatedComponent() ? r.Retarder.ModelName : Constants.NOT_AVAILABLE)},
+ { RETARDER_CERTIFICATION_METHOD, SumFunc((r, m) => r.Retarder != null && r.Retarder.Type.IsDedicatedComponent() ? r.Retarder?.CertificationMethod.GetName() : "")},
+ { RETARDER_CERTIFICATION_NUMBER, SumFunc((r, m) => r.Retarder == null || !r.Retarder.Type.IsDedicatedComponent() || r.Retarder.CertificationMethod == CertificationMethod.StandardValues ? "" : r.Retarder.CertificationNumber)},
+
+ // gearbox
+ { GEARBOX_MANUFACTURER, SumFunc((r, m) => r.GearboxData.Manufacturer)},
+ { GEARBOX_MODEL, SumFunc((r, m) => r.GearboxData.ModelName)},
+ { GEARBOX_TYPE, SumFunc((r, m) => r.GearboxData.Type)},
+ { GEARBOX_CERTIFICATION_NUMBER, SumFunc((r, m) => r.GearboxData.CertificationMethod == CertificationMethod.StandardValues ? "" : r.GearboxData.CertificationNumber)},
+ { GEARBOX_CERTIFICATION_METHOD, SumFunc((r, m) => r.GearboxData.CertificationMethod.GetName())},
+
+ { GEAR_RATIO_FIRST_GEAR, SumFunc((r, m) => r.GearboxData.Gears.Count > 0
+ ? (double.IsNaN(r.GearboxData.Gears.First().Value.Ratio)
+ ? (ConvertedSI)r.GearboxData.Gears.First().Value.TorqueConverterRatio.SI<Scalar>()
+ : (ConvertedSI)r.GearboxData.Gears.First().Value.Ratio.SI<Scalar>())
+ : 0.SI<Scalar>())},
+ { GEAR_RATIO_LAST_GEAR, SumFunc((r, m) => r.GearboxData.Gears.Count > 0
+ ? (ConvertedSI) r.GearboxData.Gears.Last().Value.Ratio.SI<Scalar>()
+ : (ConvertedSI)0.SI<Scalar>())},
+
+ // torque converter
+ { TORQUECONVERTER_MANUFACTURER, SumFunc((r, m) => r.GearboxData?.TorqueConverterData?.Manufacturer ?? Constants.NOT_AVAILABLE)},
+ { TORQUECONVERTER_MODEL, SumFunc((r, m) => r.GearboxData?.TorqueConverterData?.ModelName ?? Constants.NOT_AVAILABLE)},
+ { TORQUE_CONVERTER_CERTIFICATION_NUMBER, SumFunc((r, m) => r.GearboxData?.TorqueConverterData?.CertificationMethod == CertificationMethod.StandardValues ? "" : r.GearboxData?.TorqueConverterData?.CertificationNumber ?? "")},
+ { TORQUE_CONVERTER_CERTIFICATION_METHOD, SumFunc((r, m) => r.GearboxData?.TorqueConverterData?.CertificationMethod.GetName() ?? "")},
+
+ // engine
+ { P_FCMAP_POS, SumFunc((r, m) => m.TotalPowerEnginePositiveAverage().ConvertToKiloWatt())},
+ { P_FCMAP, SumFunc((r, m) => m.TotalPowerEngineAverage().ConvertToKiloWatt())},
+
+ { E_FCMAP_POS, SumFunc((r, m) => m.TotalEngineWorkPositive().ConvertToKiloWattHour())},
+ { E_FCMAP_NEG, SumFunc((r, m) => (-m.TotalEngineWorkNegative()).ConvertToKiloWattHour())},
+ { E_ICE_START, SumFunc((r, m) => m.WorkEngineStart().ConvertToKiloWattHour())},
+
+ { E_WHR_EL, SumFunc((r, m) => m.CorrectedModalData.WorkWHREl.ConvertToKiloWattHour())},
+ { E_WHR_MECH, SumFunc((r, m) => m.CorrectedModalData.WorkWHRMech.ConvertToKiloWattHour())},
+ { E_BusAux_PS_corr, SumFunc((r, m) => m.CorrectedModalData.WorkBusAuxPSCorr.ConvertToKiloWattHour())},
+ { E_BusAux_ES_mech_corr, SumFunc((r, m) => m.CorrectedModalData.WorkBusAuxESMech.ConvertToKiloWattHour())},
+ { E_BusAux_AuxHeater, SumFunc((r, m) => m.CorrectedModalData.AuxHeaterDemand.Cast<WattSecond>().ConvertToKiloWattHour())},
+
+
+ { E_POWERTRAIN_INERTIA, SumFunc((r, m) => m.PowerAccelerations().ConvertToKiloWattHour())},
+
+ { E_AUX, SumFunc((r, m) => m.WorkAuxiliaries().ConvertToKiloWattHour())},
+ { E_AUX_EL_HV, SumFunc((r, m) => m.TimeIntegral<WattSecond>(ModalResultField.P_aux_el).ConvertToKiloWattHour())},
+ { E_CLUTCH_LOSS, SumFunc((r, m) => m.WorkClutch().ConvertToKiloWattHour())},
+ { E_TC_LOSS, SumFunc((r, m) => m.WorkTorqueConverter().ConvertToKiloWattHour())},
+ { E_SHIFT_LOSS, SumFunc((r, m) => m.WorkGearshift().ConvertToKiloWattHour())},
+ { E_GBX_LOSS, SumFunc((r, m) => m.WorkGearbox().ConvertToKiloWattHour())},
+ { E_RET_LOSS, SumFunc((r, m) => m.WorkRetarder().ConvertToKiloWattHour())},
+ { E_AXL_LOSS, SumFunc((r, m) => m.WorkAxlegear().ConvertToKiloWattHour())},
+ { E_ANGLE_LOSS, SumFunc((r, m) => m.WorkAngledrive().ConvertToKiloWattHour())},
+ { E_BRAKE, SumFunc((r, m) => m.WorkTotalMechanicalBrake().ConvertToKiloWattHour())},
+ { E_VEHICLE_INERTIA, SumFunc((r, m) => m.WorkVehicleInertia().ConvertToKiloWattHour())},
+ { E_AIR, SumFunc((r, m) => m.WorkAirResistance().ConvertToKiloWattHour())},
+ { E_ROLL, SumFunc((r, m) => m.WorkRollingResistance().ConvertToKiloWattHour())},
+ { E_GRAD, SumFunc((r, m) => m.WorkRoadGradientResistance().ConvertToKiloWattHour())},
+ { E_AUX_ESS_missing, SumFunc((r, m) => m.CorrectedModalData.WorkESSMissing.ConvertToKiloWattHour())},
+
+
+ {E_WHEEL, SumFunc((r, m) => m.WorkWheels().ConvertToKiloWattHour())},
+
+ // BusAux
+ { AirGenerated, SumFunc((r, m) => (ConvertedSI)m.AirGenerated())},
+ { AirConsumed, SumFunc((r, m) => (ConvertedSI)m.AirConsumed())},
+ { E_PS_CompressorOff, SumFunc((r, m) => m.EnergyPneumaticCompressorPowerOff().ConvertToKiloWattHour())},
+ { E_PS_CompressorOn, SumFunc((r, m) => m.EnergyPneumaticCompressorOn().ConvertToKiloWattHour())},
+ { E_BusAux_ES_generated, SumFunc((r, m) => m.EnergyBusAuxESGenerated().ConvertToKiloWattHour())},
+ { E_BusAux_ES_consumed, SumFunc((r, m) => m.EnergyBusAuxESConsumed().ConvertToKiloWattHour())},
+ { Delta_E_BusAux_Battery, SumFunc((r, m) => (r.BusAuxiliaries.ElectricalUserInputsConfig.AlternatorType == AlternatorType.Smart
+ ? m.DeltaSOCBusAuxBattery() * r.BusAuxiliaries.ElectricalUserInputsConfig.ElectricStorageCapacity
+ : 0.SI<WattSecond>())
+ .ConvertToKiloWattHour()) },
+ { E_BusAux_HVAC_Mech, SumFunc(new[] {ModalResultField.P_busAux_HVACmech_consumer}, (r, m) => m.TimeIntegral<WattSecond>(ModalResultField.P_busAux_HVACmech_consumer).ConvertToKiloWattHour())},
+ { E_BusAux_HVAC_El, SumFunc(new[] {ModalResultField.P_busAux_ES_HVAC}, (r, m) => m.TimeIntegral<WattSecond>(ModalResultField.P_busAux_ES_HVAC).ConvertToKiloWattHour())},
+
+ // REESS
+ { E_REESS_LOSS, SumFunc((r, m) => m.REESSLoss().ConvertToKiloWattHour())},
+ { E_REESS_T_chg, SumFunc((r, m) => m.WorkREESSChargeTerminal().ConvertToKiloWattHour())},
+ { E_REESS_T_dischg, SumFunc((r, m) => m.WorkREESSDischargeTerminal().ConvertToKiloWattHour())},
+ { E_REESS_int_chg, SumFunc((r, m) => m.WorkREESSChargeInternal().ConvertToKiloWattHour())},
+ { E_REESS_int_dischg, SumFunc((r, m) => m.WorkREESSDischargeInternal().ConvertToKiloWattHour())},
+
+ { REESS_StartSoC, SumFunc((r, m) => r.BatteryData != null ? r.BatteryData.InitialSoC * 100 : r.SuperCapData.InitialSoC * 100)},
+ { REESS_EndSoC, SumFunc((r, m) => m.REESSEndSoC())},
+ { REESS_DeltaEnergy, SumFunc((r, m) => m.TimeIntegral<WattSecond>(ModalResultField.P_reess_int.GetName()).ConvertToKiloWattHour())},
+
+ // performance entries
+ { ACC, SumFunc((r, m) => (ConvertedSI)m.AccelerationAverage())},
+ { ACC_POS, SumFunc((r, m) => (ConvertedSI)m.AccelerationsPositive())},
+ { ACC_NEG, SumFunc((r, m) => (ConvertedSI)m.AccelerationsNegative())},
+ { ACC_TIMESHARE, SumFunc((r, m) => (ConvertedSI)m.AccelerationTimeShare())},
+ { DEC_TIMESHARE, SumFunc((r, m) => (ConvertedSI)m.DecelerationTimeShare())},
+ { CRUISE_TIMESHARE, SumFunc((r, m) => (ConvertedSI)m.CruiseTimeShare())},
+ { STOP_TIMESHARE, SumFunc((r, m) => (ConvertedSI)m.StopTimeShare())},
+ { MAX_SPEED, SumFunc((r, m) => (ConvertedSI)m.MaxSpeed().AsKmph.SI<Scalar>())},
+ { MAX_ACCELERATION, SumFunc((r, m) => (ConvertedSI)m.MaxAcceleration())},
+ { MAX_DECELERATION, SumFunc((r, m) => (ConvertedSI)m.MaxDeceleration())},
+ { AVG_ENGINE_SPEED, SumFunc((r, m) => (ConvertedSI)m.AvgEngineSpeed().AsRPM.SI<Scalar>())},
+ { MAX_ENGINE_SPEED, SumFunc((r, m) => (ConvertedSI)m.MaxEngineSpeed().AsRPM.SI<Scalar>())},
+ { AVERAGE_POS_ACC, SumFunc((r, m) => (ConvertedSI)m.AverageAccelerationBelowTargetSpeed())},
+
+ { AVERAGE_ENGINE_EFFICIENCY, SumFunc((r, m) => {
+ var eFC = 0.SI<Joule>();
+ foreach (var fuel in m.FuelData) {
+ eFC += m.TimeIntegral<Kilogram>(m.GetColumnName(fuel, ModalResultField.FCFinal)) * fuel.LowerHeatingValueVecto;
+ }
+ var eIcePos = m.TimeIntegral<WattSecond>(ModalResultField.P_ice_fcmap, x => x > 0);
+ return eFC.IsEqual(0, 1e-9) ? 0 : (eIcePos / eFC).Value();
+ }) },
+ { AVERAGE_GEARBOX_EFFICIENCY, SumFunc(new[] { ModalResultField.P_gbx_in }, (r, m) => {
+ var gbxOutSignal = r.Retarder != null && r.Retarder.Type == RetarderType.TransmissionOutputRetarder
+ ? ModalResultField.P_retarder_in
+ : (r.AngledriveData == null ? ModalResultField.P_axle_in : ModalResultField.P_angle_in);
+ var eGbxIn = m.TimeIntegral<WattSecond>(ModalResultField.P_gbx_in, x => x > 0);
+ var eGbxOut = m.TimeIntegral<WattSecond>(gbxOutSignal, x => x > 0);
+ return eGbxIn.IsEqual(0, 1e-9) ? 0 : (eGbxOut / eGbxIn).Value();
+ })},
+ { AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP, SumFunc(new[] { ModalResultField.P_gbx_in, ModalResultField.P_TC_in }, (r, m) => {
+ var eTcIn = m.TimeIntegral<WattSecond>(ModalResultField.P_TC_in, x => x > 0);
+ var eTcOut = m.TimeIntegral<WattSecond>(ModalResultField.P_gbx_in, x => x > 0);;
+ return eTcIn.IsEqual(0, 1e-9) ? 0 : (eTcOut / eTcIn).Value();
+ })},
+ { AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP, SumFunc(new[] {ModalResultField.P_TC_in, ModalResultField.P_TC_out, ModalResultField.TC_Locked}, (r, m) => {
+ var tcData = m.GetValues(
+ x => new {
+ dt = x.Field<Second>(ModalResultField.simulationInterval.GetName()),
+ locked = x.Field<int>(ModalResultField.TC_Locked.GetName()),
+ P_TCin = x.Field<Watt>(ModalResultField.P_TC_in.GetName()),
+ P_TCout = x.Field<Watt>(ModalResultField.P_TC_out.GetName())
+ });
+ var eTcIn = 0.SI<WattSecond>();
+ var eTcOut = 0.SI<WattSecond>();
+ foreach (var entry in tcData.Where(x => x.locked == 0)) {
+ eTcIn += entry.dt * entry.P_TCin;
+ eTcOut += entry.dt * entry.P_TCout;
+ }
+
+ return eTcIn.IsEqual(0, 1e-9) ? 0 : (eTcOut / eTcIn).Value();
+ }
+ )},
+ { AVERAGE_ANGLEDRIVE_EFFICIENCY, SumFunc(new[] {ModalResultField.P_angle_in, ModalResultField.P_axle_in},(r, m) => {
+ if (r.AngledriveData == null) {
+ return null;
+ }
+ var eAngleIn = m.TimeIntegral<WattSecond>(ModalResultField.P_angle_in, x => x > 0);
+ var eAngleOut = m.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
+ return (eAngleOut / eAngleIn).Value();
+ })
+ },
+ { AVERAGE_AXLEGEAR_EFFICIENCY, SumFunc(new[] {ModalResultField.P_axle_in, ModalResultField.P_brake_in},
+ (r, m) => {
+ if (r.AxleGearData == null) {
+ return null;
+ }
+ var eAxlIn = m.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
+ var eAxlOut = m.TimeIntegral<WattSecond>(ModalResultField.P_brake_in, x => x > 0);
+ return eAxlIn.IsEqual(0, 1e-9) ? 0 : (eAxlOut / eAxlIn).Value();
+ })
+ },
+
+ { NUM_GEARSHIFTS, SumFunc((r, m) => ((uint?)r.GearboxData?.Gears.Count ?? 0u) == 1 ? 0.SI<Scalar>() : (ConvertedSI)m.GearshiftCount())},
+
+ { COASTING_TIME_SHARE, SumFunc((r, m) => (ConvertedSI)m.CoastingTimeShare()) },
+ { BRAKING_TIME_SHARE, SumFunc((r, m) => (ConvertedSI)m.BrakingTimeShare()) },
+ { ICE_FULL_LOAD_TIME_SHARE, SumFunc((r, m) => (ConvertedSI)m.ICEMaxLoadTimeShare()) },
+ { ICE_OFF_TIME_SHARE, SumFunc((r, m) => (ConvertedSI)m.ICEOffTimeShare()) },
+ { NUM_ICE_STARTS, SumFunc((r, m) => (ConvertedSI)m.NumICEStarts().SI<Scalar>()) },
+
+ // CO2
+ { CO2_KM, SumFunc((r, m) => m.CorrectedModalData.KilogramCO2PerMeter.ConvertToGrammPerKiloMeter()) },
+ { CO2_TKM, SumFunc((r, m) => r.VehicleData.Loading == null || r.VehicleData.Loading.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.Loading).ConvertToGrammPerTonKilometer()) },
+ { CO2_M3KM, SumFunc((r, m) => r.VehicleData.CargoVolume == null || r.VehicleData.CargoVolume.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.CargoVolume).ConvertToGrammPerCubicMeterKiloMeter()) },
+ { CO2_PKM, SumFunc((r, m) => r.VehicleData.PassengerCount == null ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.PassengerCount.Value).ConvertToGrammPerKiloMeter()) },
+
+ // electric consumption
+ { ElectricEnergyConsumptionPerKm, SumFunc(new[] {ModalResultField.P_reess_int}, (r, m) => (-m.TimeIntegral<WattSecond>(ModalResultField.P_reess_int) / m.Distance).Cast<JoulePerMeter>().ConvertToKiloWattHourPerKiloMeter())},
+
+ // {, SumFunc((r, m) =>)},
+
};
+
+
+ public static readonly Dictionary<string, Tuple<ModalResultField[], WriteFuelEntry>> FuelDataValue = new Dictionary<string, Tuple<ModalResultField[], WriteFuelEntry>>() {
+ { FCMAP_H, FuelFunc((r, m, f) => m.FuelConsumptionPerSecond(ModalResultField.FCMap, f)?.ConvertToGrammPerHour())},
+ { FCMAP_KM, FuelFunc((r, m, f) => m.FuelConsumptionPerMeter(ModalResultField.FCMap, f)?.ConvertToGrammPerKiloMeter())},
+ { FCNCVC_H, FuelFunc((r, m, f) => m.FuelConsumptionPerSecond(ModalResultField.FCNCVc, f)?.ConvertToGrammPerHour())},
+ { FCNCVC_KM, FuelFunc((r, m, f) => m.FuelConsumptionPerMeter(ModalResultField.FCNCVc, f)?.ConvertToGrammPerKiloMeter())},
+ { FCWHTCC_H, FuelFunc((r, m, f) => m.FuelConsumptionPerSecond(ModalResultField.FCWHTCc, f)?.ConvertToGrammPerHour())},
+ { FCWHTCC_KM, FuelFunc((r, m, f) => m.FuelConsumptionPerMeter(ModalResultField.FCWHTCc, f)?.ConvertToGrammPerKiloMeter())},
+ { K_ENGLINE, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).EngineLineCorrectionFactor.ConvertToGramPerKiloWattHour())},
+ { K_VEHLINE, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).VehicleLine?.ConvertToGramPerKiloWattHour())},
+ { FCESS_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_ESS_H?.ConvertToGrammPerHour())},
+ { FCESS_H_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_ESS_CORR_H?.ConvertToGrammPerHour())},
+ { FC_BusAux_PS_CORR_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_BusAux_PS_CORR_H?.ConvertToGrammPerHour())},
+ { FC_BusAux_ES_CORR_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_BusAux_ES_CORR_H?.ConvertToGrammPerHour())},
+ { FCWHR_H_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_WHR_CORR_H?.ConvertToGrammPerHour())},
+ { FC_HEV_SOC_CORR_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_REESS_SOC_CORR_H?.ConvertToGrammPerHour())},
+ { FC_HEV_SOC_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_REESS_SOC_H?.ConvertToGrammPerHour())},
+ { FC_AUXHTR_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_AUXHTR_H?.ConvertToGrammPerHour())},
+ { FC_AUXHTR_H_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_AUXHTR_H_CORR?.ConvertToGrammPerHour())},
+ { FCFINAL_H, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_FINAL_H?.ConvertToGrammPerHour())},
+ { FCWHR_KM_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_WHR_CORR_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_BusAux_PS_CORR_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_BusAux_PS_CORR_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_BusAux_ES_CORR_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_BusAux_ES_CORR_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_HEV_SOC_CORR_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_REESS_SOC_CORR_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_HEV_SOC_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_REESS_SOC_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_AUXHTR_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_AUXHTR_KM?.ConvertToGrammPerKiloMeter())},
+ { FC_AUXHTR_KM_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_AUXHTR_KM_CORR?.ConvertToGrammPerKiloMeter())},
+ { FCESS_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_ESS_KM?.ConvertToGrammPerKiloMeter())},
+ { FCESS_KM_CORR, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_ESS_CORR_KM?.ConvertToGrammPerKiloMeter())},
+ { FCFINAL_KM, FuelFunc((r, m, f) => m.CorrectedModalData.FuelConsumptionCorrection(f).FC_FINAL_KM?.ConvertToGrammPerKiloMeter())},
+
+ { FCFINAL_LITERPER100KM, FuelFunc((r, m, f) => f.FuelDensity == null ? null : m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter.ConvertToLiterPer100Kilometer()) },
+ { FCFINAL_LITERPER100TKM, FuelFunc((r, m, f) => f.FuelDensity == null || r.VehicleData.Loading == null || r.VehicleData.Loading.IsEqual(0) || m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter == null ? null : (m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter / r.VehicleData.Loading).ConvertToLiterPer100TonKiloMeter()) },
+ { FCFINAL_LiterPer100M3KM, FuelFunc((r, m, f) => f.FuelDensity == null || r.VehicleData.CargoVolume == null || r.VehicleData.CargoVolume.IsEqual(0) || m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter == null ? null : (m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter / r.VehicleData.CargoVolume).ConvertToLiterPerCubicMeter100KiloMeter()) },
+ { FCFINAL_LiterPer100PassengerKM, FuelFunc((r, m, f) => f.FuelDensity == null || r.VehicleData.PassengerCount == null || m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter == null ? null :(m.CorrectedModalData.FuelConsumptionCorrection(f).FuelVolumePerMeter / r.VehicleData.PassengerCount.Value).ConvertToLiterPer100Kilometer()) },
+
+ { SPECIFIC_FC, FuelFunc((r, m, f) => r.Cycle.CycleType == CycleType.VTP ? (m.TotalFuelConsumption(ModalResultField.FCFinal, f) / m.WorkWheelsPos()).ConvertToGramPerKiloWattHour() : null) },
+
+ };
+
+ public static readonly Dictionary<string, WriteEmEntry> ElectricMotorValue = new Dictionary<string, WriteEmEntry>() {
+ { EM_AVG_SPEED_FORMAT, (r, m, em) => m.ElectricMotorAverageSpeed(em).ConvertToRoundsPerMinute() },
+ { E_EM_Mot_DRIVE_FORMAT, (r, m, em) => m.TotalElectricMotorMotWorkDrive(em).ConvertToKiloWattHour() },
+ { E_EM_Mot_GENERATE_FORMAT, (r, m, em) => m.TotalElectricMotorMotWorkRecuperate(em).ConvertToKiloWattHour() },
+ { ETA_EM_Mot_DRIVE_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorMotEfficiencyDrive(em), "") },
+ { ETA_EM_Mot_GEN_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorMotEfficiencyGenerate(em), "") },
+ { E_EM_DRIVE_FORMAT, (r, m, em) => m.TotalElectricMotorWorkDrive(em).ConvertToKiloWattHour() },
+ { E_EM_GENERATE_FORMAT, (r, m, em) => m.TotalElectricMotorWorkRecuperate(em).ConvertToKiloWattHour() },
+ { ETA_EM_DRIVE_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorEfficiencyDrive(em), "") },
+ { ETA_EM_GEN_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorEfficiencyGenerate(em), "") },
+ { E_EM_OFF_Loss_Format, (r, m, em) => m.ElectricMotorOffLosses(em).ConvertToKiloWattHour() },
+ { E_EM_LOSS_TRANSM_FORMAT, (r, m, em) => m.ElectricMotorTransmissionLosses(em).ConvertToKiloWattHour() },
+ { E_EM_Mot_LOSS_FORMAT, (r, m, em) => m.ElectricMotorMotLosses(em).ConvertToKiloWattHour() },
+ { E_EM_LOSS_FORMAT, (r, m, em) => m.ElectricMotorLosses(em).ConvertToKiloWattHour() },
+ { E_EM_OFF_TIME_SHARE, (r, m, em) => (ConvertedSI)m.ElectricMotorOffTimeShare(em) },
+ };
+
+ public static readonly Dictionary<string, WriteEmEntry> IEPCValue = new Dictionary<string, WriteEmEntry>() {
+ { IEPC_AVG_SPEED_FORMAT, (r, m, em) => m.ElectricMotorAverageSpeed(em).ConvertToRoundsPerMinute() },
+ { E_IEPC_DRIVE_FORMAT, (r, m, em) => m.TotalElectricMotorWorkDrive(em).ConvertToKiloWattHour() },
+ { E_IEPC_GENERATE_FORMAT, (r, m, em) => m.TotalElectricMotorWorkRecuperate(em).ConvertToKiloWattHour() },
+ { ETA_IEPC_DRIVE_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorEfficiencyDrive(em), "") },
+ { ETA_IEPC_GEN_FORMAT, (r, m, em) => new ConvertedSI(m.ElectricMotorEfficiencyGenerate(em), "") },
+ { E_IEPC_OFF_Loss_Format, (r, m, em) => m.ElectricMotorOffLosses(em).ConvertToKiloWattHour() },
+ { E_IEPC_LOSS_FORMAT, (r, m, em) => m.ElectricMotorLosses(em).ConvertToKiloWattHour() },
+ { E_IEPC_OFF_TIME_SHARE, (r, m, em) => (ConvertedSI)m.ElectricMotorOffTimeShare(em) },
+ };
+
+ public static readonly WriteAuxEntry AuxDataValue = (r, m, a) => m.AuxiliaryWork(a).ConvertToKiloWattHour();
}
+
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
index 5a3196d1ca..575cb42558 100644
--- a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
@@ -41,8 +41,10 @@ using TUGraz.VectoCore.Configuration;
using TUGraz.VectoCore.InputData.Reader.Impl;
using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.Simulation.Data;
+using TUGraz.VectoCore.Models.Simulation.DataBus;
using TUGraz.VectoCore.Models.SimulationComponent;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
using TUGraz.VectoCore.Utils;
// ReSharper disable MemberCanBePrivate.Global -- used by API!
@@ -54,7 +56,8 @@ namespace TUGraz.VectoCore.OutputData
public interface ISumData
{
void Write(IModalDataContainer modData, VectoRunData runData);
- void RegisterComponent(VectoSimulationComponent component);
+ void RegisterComponent(VectoSimulationComponent component, VectoRunData runData);
+ void AddAuxiliary(string id);
}
/// <summary>
@@ -130,6 +133,7 @@ namespace TUGraz.VectoCore.OutputData
Tuple.Create(SumDataFields.GEARBOX_MANUFACTURER, typeof(string)),
Tuple.Create(SumDataFields.GEARBOX_MODEL, typeof(string)),
Tuple.Create(SumDataFields.GEARBOX_TYPE, typeof(string)),
+ Tuple.Create(SumDataFields.AVERAGE_GEARBOX_EFFICIENCY, typeof(double)),
Tuple.Create(SumDataFields.GEAR_RATIO_FIRST_GEAR, typeof(ConvertedSI)),
Tuple.Create(SumDataFields.GEAR_RATIO_LAST_GEAR, typeof(ConvertedSI)),
Tuple.Create(SumDataFields.TORQUECONVERTER_MANUFACTURER, typeof(string)),
@@ -137,31 +141,126 @@ namespace TUGraz.VectoCore.OutputData
Tuple.Create(SumDataFields.RETARDER_MANUFACTURER, typeof(string)),
Tuple.Create(SumDataFields.RETARDER_MODEL, typeof(string)),
Tuple.Create(SumDataFields.RETARDER_TYPE, typeof(string)),
+ Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_NUMBER, typeof(string)),
Tuple.Create(SumDataFields.ANGLEDRIVE_MANUFACTURER, typeof(string)),
Tuple.Create(SumDataFields.ANGLEDRIVE_MODEL, typeof(string)),
Tuple.Create(SumDataFields.ANGLEDRIVE_RATIO, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(SumDataFields.AVERAGE_ANGLEDRIVE_EFFICIENCY, typeof(double)),
Tuple.Create(SumDataFields.AXLE_MANUFACTURER, typeof(string)),
Tuple.Create(SumDataFields.AXLE_MODEL, typeof(string)),
Tuple.Create(SumDataFields.AXLE_RATIO, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(SumDataFields.AVERAGE_AXLEGEAR_EFFICIENCY, typeof(double)),
Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.SteeringPump), typeof(string)),
Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.Fan), typeof(string)),
Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.HeatingVentilationAirCondition), typeof(string)),
Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.PneumaticSystem), typeof(string)),
Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.ElectricSystem), typeof(string)),
+ Tuple.Create(SumDataFields.E_AUX, typeof(ConvertedSI)),
Tuple.Create(SumDataFields.TCU_MODEL, typeof(string)),
Tuple.Create(SumDataFields.ADAS_TECHNOLOGY_COMBINATION, typeof(string)),
Tuple.Create(SumDataFields.PTO_TECHNOLOGY, typeof(string)),
Tuple.Create(SumDataFields.REESS_CAPACITY, typeof(string)),
- Tuple.Create(SumDataFields.CARGO_VOLUME, typeof(ConvertedSI))
+ Tuple.Create(SumDataFields.CARGO_VOLUME, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.COASTING_TIME_SHARE, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.BRAKING_TIME_SHARE, typeof(ConvertedSI)),
};
public static Tuple<string, Type>[] CombustionEngineColumns = {
-
-
+ Tuple.Create(SumDataFields.ICE_FULL_LOAD_TIME_SHARE, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ICE_OFF_TIME_SHARE, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.NUM_ICE_STARTS, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.P_FCMAP, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.P_FCMAP_POS, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_FCMAP_POS, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_FCMAP_NEG, typeof(ConvertedSI)),
};
public static Tuple<string, Type>[] VehilceColumns = {
+ Tuple.Create(SumDataFields.E_VEHICLE_INERTIA, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_AIR, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_ROLL, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_GRAD, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_POWERTRAIN_INERTIA, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] ClutchColumns = {
+ Tuple.Create(SumDataFields.E_CLUTCH_LOSS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] GearboxColumns = {
+ Tuple.Create(SumDataFields.NUM_GEARSHIFTS, typeof(ConvertedSI)),
+
+ };
+
+ public static Tuple<string, Type>[] IEPCTransmissionColumns = { };
+
+ public static Tuple<string, Type>[] TorqueConverterColumns = {
+ Tuple.Create(SumDataFields.E_TC_LOSS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] AngledriveColumns = {
+ Tuple.Create(SumDataFields.E_ANGLE_LOSS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] AxlegearColumns = {
+ Tuple.Create(SumDataFields.E_AXL_LOSS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] RetarderColumns = {
+ Tuple.Create(SumDataFields.E_RET_LOSS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] WheelColumns = {
+ Tuple.Create(SumDataFields.P_WHEEL, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.P_WHEEL_POS, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] BrakeColumns = {
+ Tuple.Create(SumDataFields.E_BRAKE, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] BatteryColumns = {
+ Tuple.Create(SumDataFields.REESS_StartSoC, typeof(double)),
+ Tuple.Create(SumDataFields.REESS_EndSoC, typeof(double)),
+ Tuple.Create(SumDataFields.REESS_DeltaEnergy, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_REESS_LOSS, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_REESS_T_chg, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_REESS_T_dischg, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_REESS_int_chg, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_REESS_int_dischg, typeof(ConvertedSI)),
+ };
+
+ public static Tuple<string, Type>[] ElectricMotorColumns = {
+ Tuple.Create(SumDataFields.EM_AVG_SPEED_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_Mot_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_Mot_GENERATE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_EM_Mot_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_EM_Mot_GEN_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_GENERATE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_EM_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_EM_GEN_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_OFF_Loss_Format, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_LOSS_TRANSM_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_Mot_LOSS_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_LOSS_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_EM_OFF_TIME_SHARE, typeof(ConvertedSI)),
+ };
+ public static Tuple<string, Type>[] IEPCColumns = {
+ Tuple.Create(SumDataFields.IEPC_AVG_SPEED_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_IEPC_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_IEPC_GENERATE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_IEPC_DRIVE_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.ETA_IEPC_GEN_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_IEPC_OFF_Loss_Format, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_IEPC_LOSS_FORMAT, typeof(ConvertedSI)),
+ Tuple.Create(SumDataFields.E_IEPC_OFF_TIME_SHARE, typeof(ConvertedSI)),
};
private object _tableLock = new object();
@@ -182,12 +281,102 @@ namespace TUGraz.VectoCore.OutputData
CreateColumns(CommonColumns);
}
- public void RegisterComponent(VectoSimulationComponent component)
+ public void RegisterComponent(VectoSimulationComponent component, VectoRunData runData)
{
switch (component) {
case ICombustionEngine _:
CreateColumns(CombustionEngineColumns);
break;
+ case EngineAuxiliary _:
+ break;
+ case IClutch _:
+ CreateColumns(ClutchColumns);
+ break;
+ case IGearbox _ when runData.JobType != VectoSimulationJobType.IEPC_E && runData.JobType != VectoSimulationJobType.IEPC_S:
+ CreateColumns(GearboxColumns);
+ CreateGearTimeShareColumns(runData.GearboxData.GearList);
+ break;
+ case IGearbox _ when runData.JobType == VectoSimulationJobType.IEPC_E:
+ case IGearbox _ when runData.JobType == VectoSimulationJobType.IEPC_S:
+ CreateColumns(IEPCTransmissionColumns);
+ break;
+ case ITorqueConverter _:
+ CreateColumns(TorqueConverterColumns);
+ break;
+ case IAngledrive _:
+ CreateColumns(AngledriveColumns);
+ break;
+ case IAxlegear _:
+ CreateColumns(AxlegearColumns);
+ break;
+ case Retarder _:
+ CreateColumns(RetarderColumns);
+ break;
+ case IWheels _:
+ CreateColumns(WheelColumns);
+ break;
+ case IBrakes _:
+ CreateColumns(BrakeColumns);
+ break;
+ case IDriver _:
+ //CreateColumns(DriverSignals);
+ break;
+ case IVehicle _:
+ CreateColumns(VehilceColumns);
+ break;
+ case IElectricMotor c3 when c3.Position == PowertrainPosition.IEPC:
+ CreateElectricMotorColumns(c3, runData, IEPCColumns);
+ break;
+ case IElectricMotor c4 when c4.Position != PowertrainPosition.IEPC:
+ CreateElectricMotorColumns(c4, runData, ElectricMotorColumns);
+ break;
+ case IElectricEnergyStorage c5 when c5 is BatterySystem:
+ CreateColumns(BatteryColumns);
+ break;
+ case IElectricEnergyStorage _:
+ CreateColumns(BatteryColumns);
+ break;
+ case IElectricSystem _:
+ //CreateColumns(ElectricSystemSignals);
+ break;
+ case IHybridController _:
+ //CreateColumns(HybridControllerSignals);
+ break;
+ case IDCDCConverter _:
+ //CreateColumns(DCDCConverterSignals);
+ break;
+ }
+ }
+
+ public void AddAuxiliary(string id)
+ {
+ lock (Table) {
+ var colName = GetAuxColName(id);
+ if (Table.Columns.Contains(colName)) {
+ return;
+ }
+ Table.Columns.Add(colName, typeof(ConvertedSI));
+ }
+ }
+
+ private void CreateElectricMotorColumns(IElectricMotor em, VectoRunData runData, Tuple<string, Type>[] cols)
+ {
+ lock (Table) {
+ Table.Columns.AddRange(cols
+ .Select(x => Tuple.Create(string.Format(x.Item1, em.Position.GetName()), x.Item2))
+ .Where(x => !Table.Columns.Contains(x.Item1)).Select(x => new DataColumn(x.Item1, x.Item2))
+ .ToArray());
+ }
+ }
+
+ private void CreateGearTimeShareColumns(GearList gears)
+ {
+ lock (Table) {
+ Table.Columns.AddRange(gears
+ .Select(x => string.Format(SumDataFields.TIME_SHARE_PER_GEAR_FORMAT, x.Gear))
+ .Concat(new [] {string.Format(SumDataFields.TIME_SHARE_PER_GEAR_FORMAT, 0)}).Distinct()
+ .Where(x => !Table.Columns.Contains(x)).Select(x => new DataColumn(x, typeof(ConvertedSI)))
+ .ToArray());
}
}
@@ -372,130 +561,130 @@ namespace TUGraz.VectoCore.OutputData
private void InitTableColumns()
{
- lock (Table) {
- Table.Columns.AddRange(
- new[] {
- Tuple.Create(SumDataFields.SORT, typeof(int)),
- Tuple.Create(SumDataFields.JOB, typeof(string)),
- Tuple.Create(SumDataFields.INPUTFILE, typeof(string)),
- Tuple.Create(SumDataFields.CYCLE, typeof(string)),
- Tuple.Create(SumDataFields.STATUS, typeof(string)),
- Tuple.Create(SumDataFields.VEHICLE_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.VIN_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.VEHICLE_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.HDV_CO2_VEHICLE_CLASS, typeof(string)),
- Tuple.Create(SumDataFields.CURB_MASS, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.LOADING, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.PassengerCount, typeof(double)),
- Tuple.Create(SumDataFields.TOTAL_VEHICLE_MASS, typeof(ConvertedSI)),
+ //lock (Table) {
+ // Table.Columns.AddRange(
+ // new[] {
+ // Tuple.Create(SumDataFields.SORT, typeof(int)),
+ // Tuple.Create(SumDataFields.JOB, typeof(string)),
+ // Tuple.Create(SumDataFields.INPUTFILE, typeof(string)),
+ // Tuple.Create(SumDataFields.CYCLE, typeof(string)),
+ // Tuple.Create(SumDataFields.STATUS, typeof(string)),
+ // Tuple.Create(SumDataFields.VEHICLE_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.VIN_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.VEHICLE_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.HDV_CO2_VEHICLE_CLASS, typeof(string)),
+ // Tuple.Create(SumDataFields.CURB_MASS, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.LOADING, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.PassengerCount, typeof(double)),
+ // Tuple.Create(SumDataFields.TOTAL_VEHICLE_MASS, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.AIRDRAG_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.CD_x_A_DECLARED, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.CD_x_A, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.SLEEPER_CAB, typeof(string)),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE1, typeof(double)),
- Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE1, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE2, typeof(double)),
- Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE2, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE3, typeof(double)),
- Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE3, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE4, typeof(double)),
- Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE4, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER, typeof(double)),
- Tuple.Create(SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER, typeof(double)),
- Tuple.Create(SumDataFields.R_DYN, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.NUM_AXLES_DRIVEN, typeof(int)),
- Tuple.Create(SumDataFields.NUM_AXLES_NON_DRIVEN, typeof(int)),
- Tuple.Create(SumDataFields.NUM_AXLES_TRAILER, typeof(int)),
- Tuple.Create(SumDataFields.GEARBOX_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.GEARBOX_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.GEARBOX_TYPE, typeof(string)),
- Tuple.Create(SumDataFields.GEAR_RATIO_FIRST_GEAR, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.GEAR_RATIO_LAST_GEAR, typeof(ConvertedSI)),
- Tuple.Create(SumDataFields.TORQUECONVERTER_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.TORQUECONVERTER_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.RETARDER_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.RETARDER_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.RETARDER_TYPE, typeof(string)),
- Tuple.Create(SumDataFields.ANGLEDRIVE_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.ANGLEDRIVE_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.ANGLEDRIVE_RATIO, typeof(string)),
- Tuple.Create(SumDataFields.AXLE_MANUFACTURER, typeof(string)),
- Tuple.Create(SumDataFields.AXLE_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.AXLE_RATIO, typeof(ConvertedSI)),
- Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.SteeringPump),
- typeof(string)),
- Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.Fan),
- typeof(string)),
- Tuple.Create(
- string.Format(SumDataFields.AUX_TECH_FORMAT,
- Constants.Auxiliaries.IDs.HeatingVentilationAirCondition),
- typeof(string)),
- Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.PneumaticSystem),
- typeof(string)),
- Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.ElectricSystem),
- typeof(string)),
- Tuple.Create(SumDataFields.TCU_MODEL, typeof(string)),
- Tuple.Create(SumDataFields.ADAS_TECHNOLOGY_COMBINATION, typeof(string)),
- Tuple.Create(SumDataFields.PTO_TECHNOLOGY, typeof(string)),
- Tuple.Create(SumDataFields.REESS_CAPACITY, typeof(string)),
- //Tuple.Create(PTO_OTHER_ELEMENTS, typeof(string)),
- }.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
-
- Table.Columns.AddRange(
- new[] {
- SumDataFields.CARGO_VOLUME, SumDataFields.TIME, SumDataFields.DISTANCE, SumDataFields.SPEED, SumDataFields.ALTITUDE_DELTA,
- }.Select(x => new DataColumn(x, typeof(ConvertedSI))).ToArray());
-
-
- Table.Columns.AddRange(
- new[] {
- SumDataFields.CO2_KM, SumDataFields.CO2_TKM, SumDataFields.CO2_M3KM, SumDataFields.CO2_PKM, SumDataFields.P_WHEEL,
- SumDataFields.P_WHEEL_POS, SumDataFields.P_FCMAP, SumDataFields.P_FCMAP_POS,
- SumDataFields.E_FCMAP_POS, SumDataFields.E_FCMAP_NEG, SumDataFields.E_POWERTRAIN_INERTIA, SumDataFields.E_AUX,
- SumDataFields.E_AUX_EL_HV, SumDataFields.E_CLUTCH_LOSS,
- SumDataFields.E_TC_LOSS, SumDataFields.E_SHIFT_LOSS, SumDataFields.E_GBX_LOSS, SumDataFields.E_RET_LOSS,
- SumDataFields.E_ANGLE_LOSS,
- SumDataFields.E_AXL_LOSS, SumDataFields.E_BRAKE, SumDataFields.E_VEHICLE_INERTIA, SumDataFields.E_WHEEL, SumDataFields.E_AIR,
- SumDataFields.E_ROLL, SumDataFields.E_GRAD,
- SumDataFields.AirConsumed, SumDataFields.AirGenerated, SumDataFields.E_PS_CompressorOff, SumDataFields.E_PS_CompressorOn,
- SumDataFields.E_BusAux_ES_consumed, SumDataFields.E_BusAux_ES_generated, SumDataFields.Delta_E_BusAux_Battery,
- SumDataFields.E_BusAux_PS_corr, SumDataFields.E_BusAux_ES_mech_corr,
- SumDataFields.E_BusAux_HVAC_Mech, SumDataFields.E_BusAux_HVAC_El,
- SumDataFields.E_BusAux_AuxHeater,
- SumDataFields.E_WHR_EL, SumDataFields.E_WHR_MECH, SumDataFields.E_ICE_START, SumDataFields.E_AUX_ESS_missing,
- SumDataFields.NUM_ICE_STARTS, SumDataFields.ACC,
- SumDataFields.ACC_POS, SumDataFields.ACC_NEG, SumDataFields.ACC_TIMESHARE, SumDataFields.DEC_TIMESHARE,
- SumDataFields.CRUISE_TIMESHARE,
- SumDataFields.MAX_SPEED, SumDataFields.MAX_ACCELERATION, SumDataFields.MAX_DECELERATION, SumDataFields.AVG_ENGINE_SPEED,
- SumDataFields.MAX_ENGINE_SPEED, SumDataFields.NUM_GEARSHIFTS, SumDataFields.STOP_TIMESHARE,
- SumDataFields.ICE_FULL_LOAD_TIME_SHARE, SumDataFields.ICE_OFF_TIME_SHARE,
- SumDataFields.COASTING_TIME_SHARE, SumDataFields.BRAKING_TIME_SHARE, SumDataFields.AVERAGE_POS_ACC
- }.Select(x => new DataColumn(x, typeof(ConvertedSI))).ToArray());
-
- Table.Columns.AddRange(
- new[] {
- Tuple.Create(SumDataFields.ENGINE_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AVERAGE_ENGINE_EFFICIENCY, typeof(double)),
- Tuple.Create(SumDataFields.TORQUE_CONVERTER_CERTIFICATION_METHOD, typeof(string)),
- Tuple.Create(SumDataFields.TORQUE_CONVERTER_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP, typeof(double)),
- Tuple.Create(SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP, typeof(double)),
- Tuple.Create(SumDataFields.GEARBOX_CERTIFICATION_METHOD, typeof(string)),
- Tuple.Create(SumDataFields.GEARBOX_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AVERAGE_GEARBOX_EFFICIENCY, typeof(double)),
- Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_METHOD, typeof(string)),
- Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_METHOD, typeof(string)),
- Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AVERAGE_ANGLEDRIVE_EFFICIENCY, typeof(double)),
- Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_METHOD, typeof(string)),
- Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AVERAGE_AXLEGEAR_EFFICIENCY, typeof(double)),
- Tuple.Create(SumDataFields.AIRDRAG_CERTIFICATION_NUMBER, typeof(string)),
- Tuple.Create(SumDataFields.AIRDRAG_CERTIFICATION_METHOD, typeof(string)),
- }.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
- }
+ // Tuple.Create(SumDataFields.AIRDRAG_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.CD_x_A_DECLARED, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.CD_x_A, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.SLEEPER_CAB, typeof(string)),
+ // Tuple.Create(SumDataFields.DECLARED_RRC_AXLE1, typeof(double)),
+ // Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE1, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.DECLARED_RRC_AXLE2, typeof(double)),
+ // Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE2, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.DECLARED_RRC_AXLE3, typeof(double)),
+ // Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE3, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.DECLARED_RRC_AXLE4, typeof(double)),
+ // Tuple.Create(SumDataFields.DECLARED_FZISO_AXLE4, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER, typeof(double)),
+ // Tuple.Create(SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER, typeof(double)),
+ // Tuple.Create(SumDataFields.R_DYN, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.NUM_AXLES_DRIVEN, typeof(int)),
+ // Tuple.Create(SumDataFields.NUM_AXLES_NON_DRIVEN, typeof(int)),
+ // Tuple.Create(SumDataFields.NUM_AXLES_TRAILER, typeof(int)),
+ // Tuple.Create(SumDataFields.GEARBOX_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.GEARBOX_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.GEARBOX_TYPE, typeof(string)),
+ // Tuple.Create(SumDataFields.GEAR_RATIO_FIRST_GEAR, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.GEAR_RATIO_LAST_GEAR, typeof(ConvertedSI)),
+ // Tuple.Create(SumDataFields.TORQUECONVERTER_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.TORQUECONVERTER_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.RETARDER_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.RETARDER_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.RETARDER_TYPE, typeof(string)),
+ // Tuple.Create(SumDataFields.ANGLEDRIVE_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.ANGLEDRIVE_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.ANGLEDRIVE_RATIO, typeof(string)),
+ // Tuple.Create(SumDataFields.AXLE_MANUFACTURER, typeof(string)),
+ // Tuple.Create(SumDataFields.AXLE_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.AXLE_RATIO, typeof(ConvertedSI)),
+ // Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.SteeringPump),
+ // typeof(string)),
+ // Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.Fan),
+ // typeof(string)),
+ // Tuple.Create(
+ // string.Format(SumDataFields.AUX_TECH_FORMAT,
+ // Constants.Auxiliaries.IDs.HeatingVentilationAirCondition),
+ // typeof(string)),
+ // Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.PneumaticSystem),
+ // typeof(string)),
+ // Tuple.Create(string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.ElectricSystem),
+ // typeof(string)),
+ // Tuple.Create(SumDataFields.TCU_MODEL, typeof(string)),
+ // Tuple.Create(SumDataFields.ADAS_TECHNOLOGY_COMBINATION, typeof(string)),
+ // Tuple.Create(SumDataFields.PTO_TECHNOLOGY, typeof(string)),
+ // Tuple.Create(SumDataFields.REESS_CAPACITY, typeof(string)),
+ // //Tuple.Create(PTO_OTHER_ELEMENTS, typeof(string)),
+ // }.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
+
+ // Table.Columns.AddRange(
+ // new[] {
+ // SumDataFields.CARGO_VOLUME, SumDataFields.TIME, SumDataFields.DISTANCE, SumDataFields.SPEED, SumDataFields.ALTITUDE_DELTA,
+ // }.Select(x => new DataColumn(x, typeof(ConvertedSI))).ToArray());
+
+
+ // Table.Columns.AddRange(
+ // new[] {
+ // SumDataFields.CO2_KM, SumDataFields.CO2_TKM, SumDataFields.CO2_M3KM, SumDataFields.CO2_PKM, SumDataFields.P_WHEEL,
+ // SumDataFields.P_WHEEL_POS, SumDataFields.P_FCMAP, SumDataFields.P_FCMAP_POS,
+ // SumDataFields.E_FCMAP_POS, SumDataFields.E_FCMAP_NEG, SumDataFields.E_POWERTRAIN_INERTIA, SumDataFields.E_AUX,
+ // SumDataFields.E_AUX_EL_HV, SumDataFields.E_CLUTCH_LOSS,
+ // SumDataFields.E_TC_LOSS, SumDataFields.E_SHIFT_LOSS, SumDataFields.E_GBX_LOSS, SumDataFields.E_RET_LOSS,
+ // SumDataFields.E_ANGLE_LOSS,
+ // SumDataFields.E_AXL_LOSS, SumDataFields.E_BRAKE, SumDataFields.E_VEHICLE_INERTIA, SumDataFields.E_WHEEL, SumDataFields.E_AIR,
+ // SumDataFields.E_ROLL, SumDataFields.E_GRAD,
+ // SumDataFields.AirConsumed, SumDataFields.AirGenerated, SumDataFields.E_PS_CompressorOff, SumDataFields.E_PS_CompressorOn,
+ // SumDataFields.E_BusAux_ES_consumed, SumDataFields.E_BusAux_ES_generated, SumDataFields.Delta_E_BusAux_Battery,
+ // SumDataFields.E_BusAux_PS_corr, SumDataFields.E_BusAux_ES_mech_corr,
+ // SumDataFields.E_BusAux_HVAC_Mech, SumDataFields.E_BusAux_HVAC_El,
+ // SumDataFields.E_BusAux_AuxHeater,
+ // SumDataFields.E_WHR_EL, SumDataFields.E_WHR_MECH, SumDataFields.E_ICE_START, SumDataFields.E_AUX_ESS_missing,
+ // SumDataFields.NUM_ICE_STARTS, SumDataFields.ACC,
+ // SumDataFields.ACC_POS, SumDataFields.ACC_NEG, SumDataFields.ACC_TIMESHARE, SumDataFields.DEC_TIMESHARE,
+ // SumDataFields.CRUISE_TIMESHARE,
+ // SumDataFields.MAX_SPEED, SumDataFields.MAX_ACCELERATION, SumDataFields.MAX_DECELERATION, SumDataFields.AVG_ENGINE_SPEED,
+ // SumDataFields.MAX_ENGINE_SPEED, SumDataFields.NUM_GEARSHIFTS, SumDataFields.STOP_TIMESHARE,
+ // SumDataFields.ICE_FULL_LOAD_TIME_SHARE, SumDataFields.ICE_OFF_TIME_SHARE,
+ // SumDataFields.COASTING_TIME_SHARE, SumDataFields.BRAKING_TIME_SHARE, SumDataFields.AVERAGE_POS_ACC
+ // }.Select(x => new DataColumn(x, typeof(ConvertedSI))).ToArray());
+
+ // Table.Columns.AddRange(
+ // new[] {
+ // Tuple.Create(SumDataFields.ENGINE_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AVERAGE_ENGINE_EFFICIENCY, typeof(double)),
+ // Tuple.Create(SumDataFields.TORQUE_CONVERTER_CERTIFICATION_METHOD, typeof(string)),
+ // Tuple.Create(SumDataFields.TORQUE_CONVERTER_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP, typeof(double)),
+ // Tuple.Create(SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP, typeof(double)),
+ // Tuple.Create(SumDataFields.GEARBOX_CERTIFICATION_METHOD, typeof(string)),
+ // Tuple.Create(SumDataFields.GEARBOX_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AVERAGE_GEARBOX_EFFICIENCY, typeof(double)),
+ // Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_METHOD, typeof(string)),
+ // Tuple.Create(SumDataFields.RETARDER_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_METHOD, typeof(string)),
+ // Tuple.Create(SumDataFields.ANGLEDRIVE_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AVERAGE_ANGLEDRIVE_EFFICIENCY, typeof(double)),
+ // Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_METHOD, typeof(string)),
+ // Tuple.Create(SumDataFields.AXLEGEAR_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AVERAGE_AXLEGEAR_EFFICIENCY, typeof(double)),
+ // Tuple.Create(SumDataFields.AIRDRAG_CERTIFICATION_NUMBER, typeof(string)),
+ // Tuple.Create(SumDataFields.AIRDRAG_CERTIFICATION_METHOD, typeof(string)),
+ // }.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
+ //}
}
/// <summary>
@@ -507,29 +696,7 @@ namespace TUGraz.VectoCore.OutputData
lock (Table) {
var outputColumns = GetOutputColumnsOrdered().ToArray();
var view = new DataView(Table, "", SumDataFields.SORT, DataViewRowState.CurrentRows).ToTable(false, outputColumns);
-
- //var probablyEmptyCols = new[] { SumDataFields.E_WHEEL, SumDataFields.SPECIFIC_FC }.Select(x =>
- // x.Contains("{") ? x.Substring(0, x.IndexOf("{", StringComparison.Ordinal)) : x).ToArray();
- //var removeCandidates =
- // view.Columns.Cast<DataColumn>()
- // .Where(column => probablyEmptyCols.Any(x => column.ColumnName.StartsWith(x))).ToList();
- //var toRemove = new List<string>();
- //foreach (var column in removeCandidates) {
- // //var column = view.Columns[colName];
- // if (view.AsEnumerable().All(dr => dr.IsNull(column))) {
- // toRemove.Add(column.ColumnName);
- // }
- //}
-
- //toRemove = toRemove.Concat(
- // view.Columns.Cast<DataColumn>()
- // .Where(column => column.ColumnName.StartsWith(SumDataFields.INTERNAL_PREFIX))
- // .Select(x => x.ColumnName)).ToList();
-
- //foreach (var dataColumn in toRemove) {
- // view.Columns.Remove(dataColumn);
- //}
-
+
try {
_sumWriter.WriteSumData(view);
} catch (Exception e) {
@@ -563,20 +730,20 @@ namespace TUGraz.VectoCore.OutputData
/// Writes the result of one run into the summary data container.
/// </summary>
//[MethodImpl(MethodImplOptions.Synchronized)]
- protected DataRow GetResultRow(IModalDataContainer modData, VectoRunData runData)
- {
- lock (_tableLock) {
- if (modData.HasCombustionEngine) {
- UpdateTableColumns(modData.FuelData, runData.EngineData.MultipleEngineFuelModes);
- }
- }
-
- lock (Table) {
- var row = Table.NewRow();
- //Table.Rows.Add(row);
- return row;
- }
- }
+ //protected DataRow GetResultRow(IModalDataContainer modData, VectoRunData runData)
+ //{
+ // lock (_tableLock) {
+ // if (modData.HasCombustionEngine) {
+ // UpdateTableColumns(modData.FuelData, runData.EngineData.MultipleEngineFuelModes);
+ // }
+ // }
+
+ // lock (Table) {
+ // var row = Table.NewRow();
+ // //Table.Rows.Add(row);
+ // return row;
+ // }
+ //}
protected Dictionary<string, object> GetResultDictionary(IModalDataContainer modData, VectoRunData runData)
{
@@ -589,12 +756,12 @@ namespace TUGraz.VectoCore.OutputData
return new Dictionary<string, object>();
}
- protected void AddResultRow(DataRow row)
- {
- lock (_tableLock) {
- Table.Rows.Add(row);
- }
- }
+ //protected void AddResultRow(DataRow row)
+ //{
+ // lock (_tableLock) {
+ // Table.Rows.Add(row);
+ // }
+ //}
private void AddResultDictionary(Dictionary<string, object> row)
{
@@ -619,13 +786,56 @@ namespace TUGraz.VectoCore.OutputData
}
if (func.Item1 == null || func.Item1.All(x => modData.ContainsColumn(x.GetName()))) {
- row[col.ColumnName] = func.Item2(runData, modData);
+ var value = func.Item2(runData, modData);
+ if (value != null) {
+ row[col.ColumnName] = value;
+ }
+ }
+ }
+
+ var multipleEngineModes = runData.EngineData.MultipleEngineFuelModes;
+ foreach (var fuel in modData.FuelData) {
+ var suffix = modData.FuelData.Count <= 1 && !multipleEngineModes ? "" : "_" + fuel.FuelType.GetLabel();
+ foreach (var tuple in SumDataFields.FuelDataValue) {
+ if (tuple.Value.Item1 == null || tuple.Value.Item1.All(x => modData.ContainsColumn(x.GetName()))) {
+ var value = tuple.Value.Item2(runData, modData, fuel);
+ if (value != null) {
+ row[FcCol(tuple.Key, suffix)] = value;
+ }
+ }
+ }
+ }
+
+ foreach (var em in runData.ElectricMachinesData) {
+ var fields = em.Item1 == PowertrainPosition.IEPC
+ ? SumDataFields.IEPCValue
+ : SumDataFields.ElectricMotorValue;
+ foreach (var entry in fields) {
+ var value = entry.Value(runData, modData, em.Item1);
+ row[string.Format(entry.Key, em.Item1.GetName())] = value;
}
}
+ foreach (var aux in modData.Auxiliaries) {
+ var colName = GetAuxColName(aux.Key);
+ row[colName] = SumDataFields.AuxDataValue(runData, modData, aux.Value);
+ }
+
+ WriteGearshiftStats(modData, row, (uint?)runData.GearboxData?.Gears.Count ?? 0u);
+
+
AddResultDictionary(row);
}
+ private string GetAuxColName(string auxKey)
+ {
+ return string.Format(
+ auxKey.IsOneOf(new[]
+ { Constants.Auxiliaries.IDs.PTOConsumer, Constants.Auxiliaries.IDs.PTOTransmission })
+ ? SumDataFields.E_FORMAT
+ : SumDataFields.E_AUX_FORMAT, auxKey);
+ }
+
//[MethodImpl(MethodImplOptions.Synchronized)]
public virtual void WriteXXX(IModalDataContainer modData, VectoRunData runData)
@@ -633,19 +843,19 @@ namespace TUGraz.VectoCore.OutputData
//var row = GetResultRow(modData, runData); // Replace row with dictionary
var row = GetResultDictionary(modData, runData);
- row[SumDataFields.SORT] = runData.JobNumber * 1000 + runData.RunNumber;
- row[SumDataFields.JOB] = $"{runData.JobNumber}-{runData.RunNumber}"; //ReplaceNotAllowedCharacters(current);
- row[SumDataFields.INPUTFILE] = ReplaceNotAllowedCharacters(runData.JobName);
- row[SumDataFields.CYCLE] = ReplaceNotAllowedCharacters(runData.Cycle.Name + Constants.FileExtensions.CycleFile);
+ //row[SumDataFields.SORT] = runData.JobNumber * 1000 + runData.RunNumber;
+ //row[SumDataFields.JOB] = $"{runData.JobNumber}-{runData.RunNumber}"; //ReplaceNotAllowedCharacters(current);
+ //row[SumDataFields.INPUTFILE] = ReplaceNotAllowedCharacters(runData.JobName);
+ //row[SumDataFields.CYCLE] = ReplaceNotAllowedCharacters(runData.Cycle.Name + Constants.FileExtensions.CycleFile);
- row[SumDataFields.STATUS] = modData.RunStatus;
+ //row[SumDataFields.STATUS] = modData.RunStatus;
var vehicleLoading = 0.SI<Kilogram>();
var cargoVolume = 0.SI<CubicMeter>();
var gearCount = 0u;
double? passengerCount = null;
if (runData.Cycle.CycleType != CycleType.EngineOnly) {
- WriteFullPowertrain(runData, row);
+ //WriteFullPowertrain(runData, row);
cargoVolume = runData.VehicleData.CargoVolume;
vehicleLoading = runData.VehicleData.Loading;
@@ -653,70 +863,70 @@ namespace TUGraz.VectoCore.OutputData
passengerCount = runData.VehicleData.PassengerCount;
}
- row[SumDataFields.VEHICLE_FUEL_TYPE] = modData.FuelData.Select(x => x.GetLabel()).Join();
+ //row[SumDataFields.VEHICLE_FUEL_TYPE] = modData.FuelData.Select(x => x.GetLabel()).Join();
var totalTime = modData.Duration;
- row[SumDataFields.TIME] = (ConvertedSI)totalTime;
+ //row[SumDataFields.TIME] = (ConvertedSI)totalTime;
var distance = modData.Distance;
if (distance != null) {
- row[SumDataFields.DISTANCE] = distance.ConvertToKiloMeter();
+ //row[SumDataFields.DISTANCE] = distance.ConvertToKiloMeter();
}
var speed = modData.Speed();
if (speed != null) {
- row[SumDataFields.SPEED] = speed.ConvertToKiloMeterPerHour();
+ //row[SumDataFields.SPEED] = speed.ConvertToKiloMeterPerHour();
}
- row[SumDataFields.ALTITUDE_DELTA] = (ConvertedSI)modData.AltitudeDelta();
+ //row[SumDataFields.ALTITUDE_DELTA] = (ConvertedSI)modData.AltitudeDelta();
if (modData.HasCombustionEngine) {
- WriteFuelConsumptionEntries(modData, row, vehicleLoading, cargoVolume, passengerCount, runData);
+ //WriteFuelConsumptionEntries(modData, row, vehicleLoading, cargoVolume, passengerCount, runData);
} else {
if (runData.ElectricMachinesData.Count > 0) {
- lock (Table) {
- if (!Table.Columns.Contains(SumDataFields.ElectricEnergyConsumptionPerKm)) {
- lock (_tableLock) {
- var col = Table.Columns.Add(SumDataFields.ElectricEnergyConsumptionPerKm, typeof(ConvertedSI));
- col.SetOrdinal(Table.Columns[SumDataFields.CO2_KM].Ordinal);
- }
- }
- }
+ //lock (Table) {
+ // if (!Table.Columns.Contains(SumDataFields.ElectricEnergyConsumptionPerKm)) {
+ // lock (_tableLock) {
+ // var col = Table.Columns.Add(SumDataFields.ElectricEnergyConsumptionPerKm, typeof(ConvertedSI));
+ // col.SetOrdinal(Table.Columns[SumDataFields.CO2_KM].Ordinal);
+ // }
+ // }
+ //}
- row[SumDataFields.ElectricEnergyConsumptionPerKm] =
- (-modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int) / modData.Distance).Cast<JoulePerMeter>().ConvertToKiloWattHourPerKiloMeter();
+ //row[SumDataFields.ElectricEnergyConsumptionPerKm] =
+ // (-modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int) / modData.Distance).Cast<JoulePerMeter>().ConvertToKiloWattHourPerKiloMeter();
}
}
if (runData.Mission?.MissionType == MissionType.VerificationTest) {
- var fuelsWhtc = runData.EngineData.Fuels.Select(
- fuel => modData.TimeIntegral<Kilogram>(modData.GetColumnName(fuel.FuelData, ModalResultField.FCWHTCc)) /
- modData.TimeIntegral<Kilogram>(modData.GetColumnName(fuel.FuelData, ModalResultField.FCMap)))
- .Select(dummy => (double)dummy).ToArray();
- row[SumDataFields.ENGINE_ACTUAL_CORRECTION_FACTOR] = fuelsWhtc.Join(" / ");
+ //var fuelsWhtc = runData.EngineData.Fuels.Select(
+ // fuel => modData.TimeIntegral<Kilogram>(modData.GetColumnName(fuel.FuelData, ModalResultField.FCWHTCc)) /
+ // modData.TimeIntegral<Kilogram>(modData.GetColumnName(fuel.FuelData, ModalResultField.FCMap)))
+ // .Select(dummy => (double)dummy).ToArray();
+ // row[SumDataFields.ENGINE_ACTUAL_CORRECTION_FACTOR] = fuelsWhtc.Join(" / ");
}
- row[SumDataFields.P_WHEEL_POS] = modData.PowerWheelPositive().ConvertToKiloWatt();
- row[SumDataFields.P_WHEEL] = modData.PowerWheel().ConvertToKiloWatt();
+ //row[SumDataFields.P_WHEEL_POS] = modData.PowerWheelPositive().ConvertToKiloWatt();
+ //row[SumDataFields.P_WHEEL] = modData.PowerWheel().ConvertToKiloWatt();
if (modData.HasCombustionEngine) {
- row[SumDataFields.P_FCMAP_POS] = modData.TotalPowerEnginePositiveAverage().ConvertToKiloWatt();
- row[SumDataFields.P_FCMAP] = modData.TotalPowerEngineAverage().ConvertToKiloWatt();
+ //row[SumDataFields.P_FCMAP_POS] = modData.TotalPowerEnginePositiveAverage().ConvertToKiloWatt();
+ //row[SumDataFields.P_FCMAP] = modData.TotalPowerEngineAverage().ConvertToKiloWatt();
}
WriteAuxiliaries(modData, row, runData.BusAuxiliaries != null);
- WriteWorkEntries(modData, row, runData);
+ //WriteWorkEntries(modData, row, runData);
- WritePerformanceEntries(runData, modData, row);
+ //WritePerformanceEntries(runData, modData, row);
- row[SumDataFields.COASTING_TIME_SHARE] = (ConvertedSI)modData.CoastingTimeShare();
- row[SumDataFields.BRAKING_TIME_SHARE] = (ConvertedSI)modData.BrakingTimeShare();
+ //row[SumDataFields.COASTING_TIME_SHARE] = (ConvertedSI)modData.CoastingTimeShare();
+ //row[SumDataFields.BRAKING_TIME_SHARE] = (ConvertedSI)modData.BrakingTimeShare();
if (runData.EngineData != null) {
- row[SumDataFields.ICE_FULL_LOAD_TIME_SHARE] = (ConvertedSI)modData.ICEMaxLoadTimeShare();
- row[SumDataFields.ICE_OFF_TIME_SHARE] = (ConvertedSI)modData.ICEOffTimeShare();
- row[SumDataFields.NUM_ICE_STARTS] = (ConvertedSI)modData.NumICEStarts().SI<Scalar>();
+ //row[SumDataFields.ICE_FULL_LOAD_TIME_SHARE] = (ConvertedSI)modData.ICEMaxLoadTimeShare();
+ //row[SumDataFields.ICE_OFF_TIME_SHARE] = (ConvertedSI)modData.ICEOffTimeShare();
+ //row[SumDataFields.NUM_ICE_STARTS] = (ConvertedSI)modData.NumICEStarts().SI<Scalar>();
}
if (gearCount > 0) {
@@ -728,121 +938,6 @@ namespace TUGraz.VectoCore.OutputData
}
- private void WriteFuelConsumptionEntries(
- IModalDataContainer modData, Dictionary<string, object> row, Kilogram vehicleLoading,
- CubicMeter cargoVolume, double? passengers, VectoRunData runData)
- {
- var multipleEngineModes = runData.EngineData.MultipleEngineFuelModes;
- var vtpCycle = runData.Cycle.CycleType == CycleType.VTP;
-
-
- row[SumDataFields.E_WHR_EL] = modData.CorrectedModalData.WorkWHREl.ConvertToKiloWattHour();
- row[SumDataFields.E_WHR_MECH] = modData.CorrectedModalData.WorkWHRMech.ConvertToKiloWattHour();
-
- row[SumDataFields.E_BusAux_PS_corr] = modData.CorrectedModalData.WorkBusAuxPSCorr.ConvertToKiloWattHour();
- row[SumDataFields.E_BusAux_ES_mech_corr] = modData.CorrectedModalData.WorkBusAuxESMech.ConvertToKiloWattHour();
-
- row[SumDataFields.E_BusAux_AuxHeater] = modData.CorrectedModalData.AuxHeaterDemand.Cast<WattSecond>().ConvertToKiloWattHour();
-
- foreach (var fuel in modData.FuelData) {
- var suffix = modData.FuelData.Count <= 1 && !multipleEngineModes ? "" : "_" + fuel.FuelType.GetLabel();
-
- row[FcCol(SumDataFields.FCMAP_H, suffix)] =
- modData.FuelConsumptionPerSecond(ModalResultField.FCMap, fuel)?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FCMAP_KM, suffix)] =
- modData.FuelConsumptionPerMeter(ModalResultField.FCMap, fuel)?.ConvertToGrammPerKiloMeter();
-
-
- row[FcCol(SumDataFields.FCNCVC_H, suffix)] =
- modData.FuelConsumptionPerSecond(ModalResultField.FCNCVc, fuel)?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FCNCVC_KM, suffix)] =
- modData.FuelConsumptionPerMeter(ModalResultField.FCNCVc, fuel)?.ConvertToGrammPerKiloMeter();
-
- row[FcCol(SumDataFields.FCWHTCC_H, suffix)] =
- modData.FuelConsumptionPerSecond(ModalResultField.FCWHTCc, fuel)?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FCWHTCC_KM, suffix)] =
- modData.FuelConsumptionPerMeter(ModalResultField.FCWHTCc, fuel)?.ConvertToGrammPerKiloMeter();
-
- //modData.FuelConsumptionPerSecond(ModalResultField.FCICEStopStart, fuel)
- // ?.ConvertToGrammPerHour();
- //modData.FuelConsumptionPerMeter(ModalResultField.FCICEStopStart, fuel)
- // ?.ConvertToGrammPerKiloMeter();
-
- var fuelConsumption = modData.CorrectedModalData.FuelConsumptionCorrection(fuel);
-
- row[FcCol(SumDataFields.K_ENGLINE, suffix)] = fuelConsumption.EngineLineCorrectionFactor.ConvertToGramPerKiloWattHour();
- row[FcCol(SumDataFields.K_VEHLINE, suffix)] = fuelConsumption.VehicleLine?.ConvertToGramPerKiloWattHour();
-
- var vehLine = modData.VehicleLineSlope(fuel);
- if (vehLine != null) {
- row[FcCol(SumDataFields.K_VEHLINE, suffix)] = vehLine.ConvertToGramPerKiloWattHour();
- }
-
- row[FcCol(SumDataFields.FCESS_H, suffix)] = fuelConsumption.FC_ESS_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FCESS_H_CORR, suffix)] = fuelConsumption.FC_ESS_CORR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_BusAux_PS_CORR_H, suffix)] = fuelConsumption.FC_BusAux_PS_CORR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_BusAux_ES_CORR_H, suffix)] = fuelConsumption.FC_BusAux_ES_CORR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FCWHR_H_CORR, suffix)] = fuelConsumption.FC_WHR_CORR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_HEV_SOC_CORR_H, suffix)] = fuelConsumption.FC_REESS_SOC_CORR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_HEV_SOC_H, suffix)] = fuelConsumption.FC_REESS_SOC_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_AUXHTR_H, suffix)] = fuelConsumption.FC_AUXHTR_H?.ConvertToGrammPerHour();
- row[FcCol(SumDataFields.FC_AUXHTR_H_CORR, suffix)] = fuelConsumption.FC_AUXHTR_H_CORR?.ConvertToGrammPerHour();
-
- row[FcCol(SumDataFields.FCFINAL_H, suffix)] = fuelConsumption.FC_FINAL_H?.ConvertToGrammPerHour();
-
- row[FcCol(SumDataFields.FCWHR_KM_CORR, suffix)] = fuelConsumption.FC_WHR_CORR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_BusAux_PS_CORR_KM, suffix)] = fuelConsumption.FC_BusAux_PS_CORR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_BusAux_ES_CORR_KM, suffix)] = fuelConsumption.FC_BusAux_ES_CORR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_HEV_SOC_CORR_KM, suffix)] = fuelConsumption.FC_REESS_SOC_CORR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_HEV_SOC_KM, suffix)] = fuelConsumption.FC_REESS_SOC_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_AUXHTR_KM, suffix)] = fuelConsumption.FC_AUXHTR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FC_AUXHTR_KM_CORR, suffix)] = fuelConsumption.FC_AUXHTR_KM_CORR?.ConvertToGrammPerKiloMeter();
-
- row[FcCol(SumDataFields.FCESS_KM, suffix)] = fuelConsumption.FC_ESS_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FCESS_KM_CORR, suffix)] = fuelConsumption.FC_ESS_CORR_KM?.ConvertToGrammPerKiloMeter();
- row[FcCol(SumDataFields.FCFINAL_KM, suffix)] = fuelConsumption.FC_FINAL_KM?.ConvertToGrammPerKiloMeter();
-
- if (fuel.FuelDensity != null) {
-
- var fcVolumePerMeter = fuelConsumption.FuelVolumePerMeter;
- row[FcCol(SumDataFields.FCFINAL_LITERPER100KM, suffix)] = fcVolumePerMeter?.ConvertToLiterPer100Kilometer();
-
- if (vehicleLoading != null && !vehicleLoading.IsEqual(0) && fcVolumePerMeter != null) {
- row[FcCol(SumDataFields.FCFINAL_LITERPER100TKM, suffix)] =
- (fcVolumePerMeter / vehicleLoading).ConvertToLiterPer100TonKiloMeter();
- }
- if (cargoVolume > 0 && fcVolumePerMeter != null) {
- row[FcCol(SumDataFields.FCFINAL_LiterPer100M3KM, suffix)] =
- (fcVolumePerMeter / cargoVolume).ConvertToLiterPerCubicMeter100KiloMeter();
- }
-
- if (passengers != null && fcVolumePerMeter != null) {
- // subtract driver!
- row[FcCol(SumDataFields.FCFINAL_LiterPer100PassengerKM, suffix)] =
- (fcVolumePerMeter / passengers.Value).ConvertToLiterPer100Kilometer();
- }
- }
-
- if (vtpCycle) {
- row[FcCol(SumDataFields.SPECIFIC_FC, suffix)] = (modData.TotalFuelConsumption(ModalResultField.FCFinal, fuel) / modData.WorkWheelsPos())
- .ConvertToGramPerKiloWattHour();
- }
- }
-
-
-
- row[SumDataFields.CO2_KM] = modData.CorrectedModalData.KilogramCO2PerMeter.ConvertToGrammPerKiloMeter();
- if (vehicleLoading != null && !vehicleLoading.IsEqual(0)) {
- row[SumDataFields.CO2_TKM] = (modData.CorrectedModalData.KilogramCO2PerMeter / vehicleLoading).ConvertToGrammPerTonKilometer();
- }
- if (cargoVolume > 0) {
- row[SumDataFields.CO2_M3KM] = (modData.CorrectedModalData.KilogramCO2PerMeter / cargoVolume).ConvertToGrammPerCubicMeterKiloMeter();
- }
- if (passengers != null) {
- row[SumDataFields.CO2_PKM] = (modData.CorrectedModalData.KilogramCO2PerMeter / passengers.Value).ConvertToGrammPerKiloMeter();
- }
- }
-
private static string FcCol(string col, string suffix)
{
return string.Format(col, suffix);
@@ -872,547 +967,22 @@ namespace TUGraz.VectoCore.OutputData
}
if (writeBusAux) {
- row[SumDataFields.E_BusAux_HVAC_Mech] = modData.TimeIntegral<WattSecond>(ModalResultField.P_busAux_HVACmech_consumer).ConvertToKiloWattHour();
- row[SumDataFields.E_BusAux_HVAC_El] = modData.TimeIntegral<WattSecond>(ModalResultField.P_busAux_ES_HVAC).ConvertToKiloWattHour();
+ //row[SumDataFields.E_BusAux_HVAC_Mech] = modData.TimeIntegral<WattSecond>(ModalResultField.P_busAux_HVACmech_consumer).ConvertToKiloWattHour();
+ //row[SumDataFields.E_BusAux_HVAC_El] = modData.TimeIntegral<WattSecond>(ModalResultField.P_busAux_ES_HVAC).ConvertToKiloWattHour();
}
}
private void WriteGearshiftStats(IModalDataContainer modData, Dictionary<string, object> row, uint gearCount)
{
- row[SumDataFields.NUM_GEARSHIFTS] = gearCount == 1 ? 0.SI<Scalar>() : (ConvertedSI)modData.GearshiftCount();
+ //row[SumDataFields.NUM_GEARSHIFTS] = gearCount == 1 ? 0.SI<Scalar>() : (ConvertedSI)modData.GearshiftCount();
var timeSharePerGear = modData.TimeSharePerGear(gearCount);
for (uint i = 0; i <= gearCount; i++) {
var colName = string.Format(SumDataFields.TIME_SHARE_PER_GEAR_FORMAT, i);
- lock (Table)
- if (!Table.Columns.Contains(colName)) {
- lock (_tableLock) {
- Table.Columns.Add(colName, typeof(ConvertedSI));
- }
- }
row[colName] = (ConvertedSI)timeSharePerGear[i];
}
}
- private void WritePerformanceEntries(VectoRunData runData, IModalDataContainer modData, Dictionary<string, object> row)
- {
- row[SumDataFields.ACC] = (ConvertedSI)modData.AccelerationAverage();
- row[SumDataFields.ACC_POS] = (ConvertedSI)modData.AccelerationsPositive();
- row[SumDataFields.ACC_NEG] = (ConvertedSI)modData.AccelerationsNegative();
- var accTimeShare = modData.AccelerationTimeShare();
- row[SumDataFields.ACC_TIMESHARE] = (ConvertedSI)accTimeShare;
- var decTimeShare = modData.DecelerationTimeShare();
- row[SumDataFields.DEC_TIMESHARE] = (ConvertedSI)decTimeShare;
- var cruiseTimeShare = modData.CruiseTimeShare();
- row[SumDataFields.CRUISE_TIMESHARE] = (ConvertedSI)cruiseTimeShare;
- var stopTimeShare = modData.StopTimeShare();
- row[SumDataFields.STOP_TIMESHARE] = (ConvertedSI)stopTimeShare;
-
- row[SumDataFields.MAX_SPEED] = (ConvertedSI)modData.MaxSpeed().AsKmph.SI<Scalar>();
- row[SumDataFields.MAX_ACCELERATION] = (ConvertedSI)modData.MaxAcceleration();
- row[SumDataFields.MAX_DECELERATION] = (ConvertedSI)modData.MaxDeceleration();
- if (runData.EngineData != null) {
- row[SumDataFields.AVG_ENGINE_SPEED] = (ConvertedSI)modData.AvgEngineSpeed().AsRPM.SI<Scalar>();
- row[SumDataFields.MAX_ENGINE_SPEED] = (ConvertedSI)modData.MaxEngineSpeed().AsRPM.SI<Scalar>();
- }
-
- row[SumDataFields.AVERAGE_POS_ACC] = (ConvertedSI)modData.AverageAccelerationBelowTargetSpeed();
- if (accTimeShare != null && decTimeShare != null && cruiseTimeShare != null) {
- var shareSum = accTimeShare + decTimeShare + cruiseTimeShare + stopTimeShare;
- if (!shareSum.IsEqual(100, 1e-2)) {
- Log.Warn(
- "Sumfile Error: driving behavior timeshares must sum up to 100%: acc: {0}%, dec: {1}%, cruise: {2}%, stop: {3}%, sum: {4}%",
- accTimeShare.ToOutputFormat(1, null, false), decTimeShare.ToOutputFormat(1, null, false),
- cruiseTimeShare.ToOutputFormat(1, null, false), stopTimeShare.ToOutputFormat(1, null, false),
- shareSum.ToOutputFormat(1, null, false));
- }
- }
-
- var eFC = 0.SI<Joule>();
- foreach (var fuel in modData.FuelData) {
- eFC += modData.TimeIntegral<Kilogram>(modData.GetColumnName(fuel, ModalResultField.FCFinal)) * fuel.LowerHeatingValueVecto;
- }
- var eIcePos = modData.TimeIntegral<WattSecond>(ModalResultField.P_ice_fcmap, x => x > 0);
- row[SumDataFields.AVERAGE_ENGINE_EFFICIENCY] = eFC.IsEqual(0, 1e-9) ? 0 : (eIcePos / eFC).Value();
-
- if (runData.SimulationType == SimulationType.EngineOnly) {
- return;
- }
-
- var gbxOutSignal = runData.Retarder != null && runData.Retarder.Type == RetarderType.TransmissionOutputRetarder
- ? ModalResultField.P_retarder_in
- : (runData.AngledriveData == null ? ModalResultField.P_axle_in : ModalResultField.P_angle_in);
- var eGbxIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_gbx_in, x => x > 0);
- var eGbxOut = modData.TimeIntegral<WattSecond>(gbxOutSignal, x => x > 0);
- row[SumDataFields.AVERAGE_GEARBOX_EFFICIENCY] = eGbxIn.IsEqual(0, 1e-9) ? 0 : (eGbxOut / eGbxIn).Value();
-
- if (runData.GearboxData != null && runData.GearboxData.Type.AutomaticTransmission() && runData.GearboxData.Type != GearboxType.APTN && runData.GearboxData.Type != GearboxType.IHPC) {
- var eTcIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_TC_in, x => x > 0);
- var eTcOut = eGbxIn;
- row[SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP] = eTcIn.IsEqual(0, 1e-9) ? 0 : (eTcOut / eTcIn).Value();
-
- var tcData = modData.GetValues(
- x => new {
- dt = x.Field<Second>(ModalResultField.simulationInterval.GetName()),
- locked = x.Field<int>(ModalResultField.TC_Locked.GetName()),
- P_TCin = x.Field<Watt>(ModalResultField.P_TC_in.GetName()),
- P_TCout = x.Field<Watt>(ModalResultField.P_TC_out.GetName())
- });
- eTcIn = 0.SI<WattSecond>();
- eTcOut = 0.SI<WattSecond>();
- foreach (var entry in tcData.Where(x => x.locked == 0)) {
- eTcIn += entry.dt * entry.P_TCin;
- eTcOut += entry.dt * entry.P_TCout;
- }
-
- row[SumDataFields.AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP] = eTcIn.IsEqual(0, 1e-9) ? 0 : (eTcOut / eTcIn).Value();
- }
-
- if (runData.AngledriveData != null) {
- var eAngleIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_angle_in, x => x > 0);
- var eAngleOut = modData.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
-
- row[SumDataFields.AVERAGE_ANGLEDRIVE_EFFICIENCY] = (eAngleOut / eAngleIn).Value();
- }
-
- var eAxlIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
- var eAxlOut = modData.TimeIntegral<WattSecond>(ModalResultField.P_brake_in, x => x > 0);
- row[SumDataFields.AVERAGE_AXLEGEAR_EFFICIENCY] = eAxlIn.IsEqual(0, 1e-9) ? 0 : (eAxlOut / eAxlIn).Value();
- }
-
- private void WriteWorkEntries(IModalDataContainer modData, Dictionary<string, object> row, VectoRunData runData)
- {
- row[SumDataFields.E_FCMAP_POS] = modData.TotalEngineWorkPositive().ConvertToKiloWattHour();
- row[SumDataFields.E_FCMAP_NEG] = (-modData.TotalEngineWorkNegative()).ConvertToKiloWattHour();
- row[SumDataFields.E_POWERTRAIN_INERTIA] = modData.PowerAccelerations().ConvertToKiloWattHour();
- row[SumDataFields.E_AUX] = modData.WorkAuxiliaries().ConvertToKiloWattHour();
- row[SumDataFields.E_AUX_EL_HV] = modData.TimeIntegral<WattSecond>(ModalResultField.P_aux_el).ConvertToKiloWattHour();
- row[SumDataFields.E_CLUTCH_LOSS] = modData.WorkClutch().ConvertToKiloWattHour();
- row[SumDataFields.E_TC_LOSS] = modData.WorkTorqueConverter().ConvertToKiloWattHour();
- row[SumDataFields.E_SHIFT_LOSS] = modData.WorkGearshift().ConvertToKiloWattHour();
- row[SumDataFields.E_GBX_LOSS] = modData.WorkGearbox().ConvertToKiloWattHour();
- row[SumDataFields.E_RET_LOSS] = modData.WorkRetarder().ConvertToKiloWattHour();
- row[SumDataFields.E_AXL_LOSS] = modData.WorkAxlegear().ConvertToKiloWattHour();
- row[SumDataFields.E_ANGLE_LOSS] = modData.WorkAngledrive().ConvertToKiloWattHour();
- row[SumDataFields.E_BRAKE] = modData.WorkTotalMechanicalBrake().ConvertToKiloWattHour();
- row[SumDataFields.E_VEHICLE_INERTIA] = modData.WorkVehicleInertia().ConvertToKiloWattHour();
- row[SumDataFields.E_AIR] = modData.WorkAirResistance().ConvertToKiloWattHour();
- row[SumDataFields.E_ROLL] = modData.WorkRollingResistance().ConvertToKiloWattHour();
- row[SumDataFields.E_GRAD] = modData.WorkRoadGradientResistance().ConvertToKiloWattHour();
- row[SumDataFields.E_AUX_ESS_missing] = modData.CorrectedModalData.WorkESSMissing.ConvertToKiloWattHour();
- if (runData.Cycle.CycleType == CycleType.VTP) {
- row[SumDataFields.E_WHEEL] = modData.WorkWheels().ConvertToKiloWattHour();
- }
-
- if (runData.BusAuxiliaries != null) {
- row[SumDataFields.AirGenerated] = (ConvertedSI)modData.AirGenerated();
- row[SumDataFields.AirConsumed] = (ConvertedSI)modData.AirConsumed();
- row[SumDataFields.E_PS_CompressorOff] = modData.EnergyPneumaticCompressorPowerOff().ConvertToKiloWattHour();
- row[SumDataFields.E_PS_CompressorOn] = modData.EnergyPneumaticCompressorOn().ConvertToKiloWattHour();
-
- row[SumDataFields.E_BusAux_ES_generated] = modData.EnergyBusAuxESGenerated().ConvertToKiloWattHour();
- row[SumDataFields.E_BusAux_ES_consumed] = modData.EnergyBusAuxESConsumed().ConvertToKiloWattHour();
- row[SumDataFields.Delta_E_BusAux_Battery] = (runData.BusAuxiliaries.ElectricalUserInputsConfig.AlternatorType == AlternatorType.Smart
- ? modData.DeltaSOCBusAuxBattery() * runData.BusAuxiliaries.ElectricalUserInputsConfig.ElectricStorageCapacity
- : 0.SI<WattSecond>())
- .ConvertToKiloWattHour();
- }
-
- row[SumDataFields.E_ICE_START] = modData.WorkEngineStart().ConvertToKiloWattHour();
-
- foreach (var em in runData.ElectricMachinesData) {
- var fields = em.Item1 == PowertrainPosition.IEPC
- ? GetIEPCWorkEntries(modData, row, em)
- : GetElectricMachineWorkEntries(modData, row, em);
- fields.Reverse();
- foreach (var entry in fields) {
- var colName = string.Format(entry.Item1, em.Item1.GetName());
- lock (Table) {
- if (!Table.Columns.Contains(colName)) {
- lock (_tableLock) {
- var col = Table.Columns.Add(colName, typeof(ConvertedSI));
- col.SetOrdinal(Table.Columns[SumDataFields.E_GRAD].Ordinal + 1);
- }
- }
- }
-
- row[colName] = entry.Item2;
- }
- }
-
- if (runData.BatteryData != null || runData.SuperCapData != null) {
- foreach (var field in new[] { SumDataFields.REESS_StartSoC, SumDataFields.REESS_EndSoC }) {
- lock (Table) {
- if (Table.Columns.Contains(field)) {
- continue;
- }
-
- lock (_tableLock) {
- var col = Table.Columns.Add(field, typeof(double));
- col.SetOrdinal(Table.Columns[SumDataFields.P_WHEEL].Ordinal);
- }
- }
- }
-
- foreach (var field in new[] {
- SumDataFields.REESS_DeltaEnergy, SumDataFields.E_REESS_LOSS, SumDataFields.E_REESS_T_chg, SumDataFields.E_REESS_T_dischg,
- SumDataFields.E_REESS_int_chg, SumDataFields.E_REESS_int_dischg
- }) {
- lock (Table) {
- if (Table.Columns.Contains(field)) {
- continue;
- }
-
- lock (_tableLock) {
- var col = Table.Columns.Add(field, typeof(ConvertedSI));
- col.SetOrdinal(Table.Columns[SumDataFields.P_WHEEL].Ordinal);
- }
- }
- }
- row[SumDataFields.E_REESS_LOSS] = modData.REESSLoss().ConvertToKiloWattHour();
- row[SumDataFields.E_REESS_T_chg] = modData.WorkREESSChargeTerminal().ConvertToKiloWattHour();
- row[SumDataFields.E_REESS_T_dischg] = modData.WorkREESSDischargeTerminal().ConvertToKiloWattHour();
- row[SumDataFields.E_REESS_int_chg] = modData.WorkREESSChargeInternal().ConvertToKiloWattHour();
- row[SumDataFields.E_REESS_int_dischg] = modData.WorkREESSDischargeInternal().ConvertToKiloWattHour();
- }
-
- if (runData.BatteryData != null) {
- row[SumDataFields.REESS_StartSoC] = runData.BatteryData.InitialSoC * 100;
- row[SumDataFields.REESS_EndSoC] = modData.REESSEndSoC();
- row[SumDataFields.REESS_DeltaEnergy] = modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int.GetName())
- .ConvertToKiloWattHour();
-
- }
- if (runData.SuperCapData != null) {
- row[SumDataFields.REESS_StartSoC] = runData.SuperCapData.InitialSoC * 100;
- row[SumDataFields.REESS_EndSoC] = modData.REESSEndSoC();
- row[SumDataFields.REESS_DeltaEnergy] = modData.TimeIntegral<WattSecond>(ModalResultField.P_reess_int.GetName())
- .ConvertToKiloWattHour();
- }
- }
-
- private List<Tuple<string, ConvertedSI>> GetIEPCWorkEntries(IModalDataContainer modData, Dictionary<string, object> row, Tuple<PowertrainPosition, ElectricMotorData> em)
- {
- var emColumns = new List<Tuple<string, ConvertedSI>>() {
- Tuple.Create(SumDataFields.IEPC_AVG_SPEED_FORMAT,
- modData.ElectricMotorAverageSpeed(em.Item1).ConvertToRoundsPerMinute()),
-
- Tuple.Create(SumDataFields.E_IEPC_DRIVE_FORMAT, modData.TotalElectricMotorWorkDrive(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_IEPC_GENERATE_FORMAT,
- modData.TotalElectricMotorWorkRecuperate(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.ETA_IEPC_DRIVE_FORMAT, new ConvertedSI(modData.ElectricMotorEfficiencyDrive(em.Item1), "")),
- Tuple.Create(SumDataFields.ETA_IEPC_GEN_FORMAT, new ConvertedSI(modData.ElectricMotorEfficiencyGenerate(em.Item1), "")),
-
- Tuple.Create(SumDataFields.E_IEPC_OFF_Loss_Format, modData.ElectricMotorOffLosses(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.E_IEPC_LOSS_FORMAT, modData.ElectricMotorLosses(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.E_IEPC_OFF_TIME_SHARE, (ConvertedSI)modData.ElectricMotorOffTimeShare(em.Item1))
- };
- return emColumns;
- }
-
- private List<Tuple<string, ConvertedSI>> GetElectricMachineWorkEntries(IModalDataContainer modData, Dictionary<string, object> row, Tuple<PowertrainPosition, ElectricMotorData> em)
- {
- var emColumns = new List<Tuple<string, ConvertedSI>>() {
- Tuple.Create(SumDataFields.EM_AVG_SPEED_FORMAT,
- modData.ElectricMotorAverageSpeed(em.Item1).ConvertToRoundsPerMinute()),
-
- Tuple.Create(SumDataFields.E_EM_Mot_DRIVE_FORMAT,
- modData.TotalElectricMotorMotWorkDrive(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_EM_Mot_GENERATE_FORMAT,
- modData.TotalElectricMotorMotWorkRecuperate(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.ETA_EM_Mot_DRIVE_FORMAT,
- new ConvertedSI(modData.ElectricMotorMotEfficiencyDrive(em.Item1), "")),
- Tuple.Create(SumDataFields.ETA_EM_Mot_GEN_FORMAT,
- new ConvertedSI(modData.ElectricMotorMotEfficiencyGenerate(em.Item1), "")),
-
-
- Tuple.Create(SumDataFields.E_EM_DRIVE_FORMAT, modData.TotalElectricMotorWorkDrive(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_EM_GENERATE_FORMAT,
- modData.TotalElectricMotorWorkRecuperate(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.ETA_EM_DRIVE_FORMAT, new ConvertedSI(modData.ElectricMotorEfficiencyDrive(em.Item1), "")),
- Tuple.Create(SumDataFields.ETA_EM_GEN_FORMAT, new ConvertedSI(modData.ElectricMotorEfficiencyGenerate(em.Item1), "")),
-
- Tuple.Create(SumDataFields.E_EM_OFF_Loss_Format, modData.ElectricMotorOffLosses(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_EM_LOSS_TRANSM_FORMAT,
- modData.ElectricMotorTransmissionLosses(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_EM_Mot_LOSS_FORMAT, modData.ElectricMotorMotLosses(em.Item1).ConvertToKiloWattHour()),
- Tuple.Create(SumDataFields.E_EM_LOSS_FORMAT, modData.ElectricMotorLosses(em.Item1).ConvertToKiloWattHour()),
-
- Tuple.Create(SumDataFields.E_EM_OFF_TIME_SHARE, (ConvertedSI)modData.ElectricMotorOffTimeShare(em.Item1))
- };
- return emColumns;
-
- }
-
- private void WriteFullPowertrain(VectoRunData runData, Dictionary<string, object> row)
- {
- WriteVehicleData(runData, row);
-
- if (runData.BusAuxiliaries?.InputData != null) {
- // only write in declaration mode - if input data is set
- // subtract driver!
- row[SumDataFields.PassengerCount] = runData.VehicleData.PassengerCount;
- }
-
- row[SumDataFields.TCU_MODEL] = runData.ShiftStrategy;
- row[SumDataFields.PTO_TECHNOLOGY] = runData.PTO?.TransmissionType ?? "";
-
- WriteEngineData(runData.EngineData, row);
-
- WriteGearboxData(runData.GearboxData, row);
-
- WriteRetarderData(runData.Retarder, row);
-
- WriteAngledriveData(runData.AngledriveData, row);
-
- WriteAxlegearData(runData.AxleGearData, row);
-
- WriteAuxTechnologies(runData, row);
-
- WriteAxleWheelsData(runData.VehicleData.AxleData, row);
-
- WriteAirdragData(runData.AirdragData, row);
-
- }
-
- private static void WriteVehicleData(VectoRunData runData, Dictionary<string, object> row)
- {
- var data = runData.VehicleData;
- //if (runData.VehicleData.b)
- var gbxType = runData.GearboxData?.Type ?? GearboxType.NoGearbox;
-
- row[SumDataFields.VEHICLE_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.VIN_NUMBER] = data.VIN;
- row[SumDataFields.VEHICLE_MODEL] = data.ModelName;
-
- row[SumDataFields.HDV_CO2_VEHICLE_CLASS] = runData.Mission?.BusParameter?.BusGroup.GetClassNumber() ?? data.VehicleClass.GetClassNumber();
- row[SumDataFields.CURB_MASS] = (ConvertedSI)data.CurbMass;
-
- // - (data.BodyAndTrailerWeight ?? 0.SI<Kilogram>());
- row[SumDataFields.LOADING] = (ConvertedSI)data.Loading;
- row[SumDataFields.CARGO_VOLUME] = (ConvertedSI)data.CargoVolume;
-
- row[SumDataFields.TOTAL_VEHICLE_MASS] = (ConvertedSI)data.TotalVehicleMass;
-
- row[SumDataFields.SLEEPER_CAB] = data.SleeperCab.HasValue ? (data.SleeperCab.Value ? "yes" : "no") : "-";
-
- row[SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER] =
- data.RollResistanceCoefficientWithoutTrailer;
- row[SumDataFields.ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER] =
- data.TotalRollResistanceCoefficient;
-
- row[SumDataFields.R_DYN] = (ConvertedSI)data.DynamicTyreRadius;
-
- row[SumDataFields.ADAS_TECHNOLOGY_COMBINATION] = data.ADAS != null ? DeclarationData.ADASCombinations.Lookup(data.ADAS, gbxType).ID : "";
-
- var cap = "";
- if (runData.BatteryData?.Capacity != null) {
- cap = $"{runData.BatteryData.Capacity.AsAmpHour} Ah";
- }
-
- if (runData.SuperCapData?.Capacity != null) {
- cap = $"{runData.SuperCapData.Capacity} F";
- }
-
- row[SumDataFields.REESS_CAPACITY] = cap;
- }
-
- private static void WriteAirdragData(AirdragData data, Dictionary<string, object> row)
- {
- row[SumDataFields.AIRDRAG_MODEL] = data.ModelName;
- row[SumDataFields.AIRDRAG_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
- row[SumDataFields.AIRDRAG_CERTIFICATION_NUMBER] =
- data.CertificationMethod == CertificationMethod.StandardValues ? "" : data.CertificationNumber;
- row[SumDataFields.CD_x_A_DECLARED] = (ConvertedSI)data.DeclaredAirdragArea;
- row[SumDataFields.CD_x_A] = (ConvertedSI)data.CrossWindCorrectionCurve.AirDragArea;
- }
-
- private static void WriteEngineData(CombustionEngineData data, Dictionary<string, object> row)
- {
- if (data == null) {
- return;
- }
- row[SumDataFields.ENGINE_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.ENGINE_MODEL] = data.ModelName;
- row[SumDataFields.ENGINE_CERTIFICATION_NUMBER] = data.CertificationNumber;
- row[SumDataFields.ENGINE_FUEL_TYPE] = data.Fuels.Select(x => x.FuelData.GetLabel()).Join(" / ");
- row[SumDataFields.ENGINE_RATED_POWER] = data.RatedPowerDeclared != null && data.RatedPowerDeclared > 0
- ? data.RatedPowerDeclared.ConvertToKiloWatt()
- : data.FullLoadCurves[0].MaxPower.ConvertToKiloWatt();
- row[SumDataFields.ENGINE_IDLING_SPEED] = (ConvertedSI)data.IdleSpeed.AsRPM.SI<Scalar>();
- row[SumDataFields.ENGINE_RATED_SPEED] = data.RatedSpeedDeclared != null && data.RatedSpeedDeclared > 0
- ? (ConvertedSI)data.RatedSpeedDeclared.AsRPM.SI<Scalar>()
- : (ConvertedSI)data.FullLoadCurves[0].RatedSpeed.AsRPM.SI<Scalar>();
- row[SumDataFields.ENGINE_DISPLACEMENT] = data.Displacement.ConvertToCubicCentiMeter();
-
- row[SumDataFields.ENGINE_WHTC_URBAN] = data.Fuels.Select(x => x.WHTCUrban).Join(" / ");
- row[SumDataFields.ENGINE_WHTC_RURAL] = data.Fuels.Select(x => x.WHTCRural).Join(" / ");
- row[SumDataFields.ENGINE_WHTC_MOTORWAY] = data.Fuels.Select(x => x.WHTCMotorway).Join(" / ");
- row[SumDataFields.ENGINE_BF_COLD_HOT] = data.Fuels.Select(x => x.ColdHotCorrectionFactor).Join(" / ");
- row[SumDataFields.ENGINE_CF_REG_PER] = data.Fuels.Select(x => x.CorrectionFactorRegPer).Join(" / ");
- row[SumDataFields.ENGINE_ACTUAL_CORRECTION_FACTOR] = data.Fuels.Select(x => x.FuelConsumptionCorrectionFactor).Join(" / ");
- }
-
- private static void WriteAxleWheelsData(List<Axle> data, Dictionary<string, object> row)
- {
- var fields = new[] {
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE1, SumDataFields.DECLARED_FZISO_AXLE1),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE2, SumDataFields.DECLARED_FZISO_AXLE2),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE3, SumDataFields.DECLARED_FZISO_AXLE3),
- Tuple.Create(SumDataFields.DECLARED_RRC_AXLE4, SumDataFields.DECLARED_FZISO_AXLE4),
- };
- for (var i = 0; i < Math.Min(fields.Length, data.Count); i++) {
- if (data[i].AxleType == AxleType.Trailer) {
- continue;
- }
-
- row[fields[i].Item1] = data[i].RollResistanceCoefficient;
- row[fields[i].Item2] = (ConvertedSI)data[i].TyreTestLoad;
- }
-
- row[SumDataFields.NUM_AXLES_DRIVEN] = data.Count(x => x.AxleType == AxleType.VehicleDriven);
- row[SumDataFields.NUM_AXLES_NON_DRIVEN] = data.Count(x => x.AxleType == AxleType.VehicleNonDriven);
- row[SumDataFields.NUM_AXLES_TRAILER] = data.Count(x => x.AxleType == AxleType.Trailer);
- }
-
- private static void WriteAxlegearData(AxleGearData data, Dictionary<string, object> row)
- {
- if (data == null) {
- return;
- }
- row[SumDataFields.AXLE_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.AXLE_MODEL] = data.ModelName;
- row[SumDataFields.AXLE_RATIO] = (ConvertedSI)data.AxleGear.Ratio.SI<Scalar>();
- row[SumDataFields.AXLEGEAR_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
- row[SumDataFields.AXLEGEAR_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
- ? ""
- : data.CertificationNumber;
- }
-
- private void WriteAuxTechnologies(VectoRunData runData, Dictionary<string, object> row)
- {
- var auxData = runData.Aux;
- var busAux = runData.BusAuxiliaries;
- foreach (var aux in auxData) {
- if (aux.ID == Constants.Auxiliaries.IDs.PTOConsumer || aux.ID == Constants.Auxiliaries.IDs.PTOTransmission) {
- continue;
- }
-
- var colName = string.Format(SumDataFields.AUX_TECH_FORMAT, aux.ID);
-
- lock (Table)
- if (!Table.Columns.Contains(colName)) {
- lock (_tableLock) {
- var col = Table.Columns.Add(colName, typeof(string));
-
- // move the new column to correct position
- col.SetOrdinal(Table.Columns[SumDataFields.CARGO_VOLUME].Ordinal);
- }
- }
-
- row[colName] = aux.Technology == null ? "" : aux.Technology.Join("; ");
- }
-
- if (busAux == null) {
- return;
- }
-
- row[string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.HeatingVentilationAirCondition)] =
- busAux.SSMInputs is ISSMDeclarationInputs inputs ? inputs.HVACTechnology : "engineering mode";
- row[string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.ElectricSystem)] =
- busAux.ElectricalUserInputsConfig.AlternatorType.GetLabel();
- row[string.Format(SumDataFields.AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.PneumaticSystem)] = runData.JobType == VectoSimulationJobType.BatteryElectricVehicle ? "-" :
- busAux.PneumaticUserInputsConfig.CompressorMap.Technology;
- }
-
- private static void WriteAngledriveData(AngledriveData data, Dictionary<string, object> row)
- {
- if (data != null) {
- row[SumDataFields.ANGLEDRIVE_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.ANGLEDRIVE_MODEL] = data.ModelName;
- row[SumDataFields.ANGLEDRIVE_RATIO] = data.Angledrive.Ratio;
- row[SumDataFields.ANGLEDRIVE_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
- row[SumDataFields.ANGLEDRIVE_CERTIFICATION_NUMBER] =
- data.CertificationMethod == CertificationMethod.StandardValues
- ? ""
- : data.CertificationNumber;
- } else {
- row[SumDataFields.ANGLEDRIVE_MANUFACTURER] = Constants.NOT_AVAILABLE;
- row[SumDataFields.ANGLEDRIVE_MODEL] = Constants.NOT_AVAILABLE;
- row[SumDataFields.ANGLEDRIVE_RATIO] = Constants.NOT_AVAILABLE;
- row[SumDataFields.ANGLEDRIVE_CERTIFICATION_METHOD] = "";
- row[SumDataFields.ANGLEDRIVE_CERTIFICATION_NUMBER] = "";
- }
- }
-
- private static void WriteRetarderData(RetarderData data, Dictionary<string, object> row)
- {
- row[SumDataFields.RETARDER_TYPE] = (data?.Type ?? RetarderType.None).GetLabel();
- if (data != null && data.Type.IsDedicatedComponent()) {
- row[SumDataFields.RETARDER_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.RETARDER_MODEL] = data.ModelName;
- row[SumDataFields.RETARDER_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
- row[SumDataFields.RETARDER_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
- ? ""
- : data.CertificationNumber;
- } else {
- row[SumDataFields.RETARDER_MANUFACTURER] = Constants.NOT_AVAILABLE;
- row[SumDataFields.RETARDER_MODEL] = Constants.NOT_AVAILABLE;
- row[SumDataFields.RETARDER_CERTIFICATION_METHOD] = "";
- row[SumDataFields.RETARDER_CERTIFICATION_NUMBER] = "";
- }
- }
-
- private static void WriteGearboxData(GearboxData data, Dictionary<string, object> row)
- {
- if (data == null) {
- return;
- }
- row[SumDataFields.GEARBOX_MANUFACTURER] = data.Manufacturer;
- row[SumDataFields.GEARBOX_MODEL] = data.ModelName;
- row[SumDataFields.GEARBOX_TYPE] = data.Type;
- row[SumDataFields.GEARBOX_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
- ? ""
- : data.CertificationNumber;
- row[SumDataFields.GEARBOX_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
- if (data.Type.AutomaticTransmission()) {
- row[SumDataFields.GEAR_RATIO_FIRST_GEAR] = data.Gears.Count > 0
- ? (double.IsNaN(data.Gears.First().Value.Ratio)
- ? (ConvertedSI)data.Gears.First().Value.TorqueConverterRatio.SI<Scalar>()
- : (ConvertedSI)data.Gears.First().Value.Ratio.SI<Scalar>())
- : 0.SI<Scalar>();
- row[SumDataFields.GEAR_RATIO_LAST_GEAR] = data.Gears.Count > 0
- ? (ConvertedSI)data.Gears.Last().Value.Ratio.SI<Scalar>()
- : (ConvertedSI)0.SI<Scalar>();
- if (data.Type != GearboxType.APTN && data.Type != GearboxType.IHPC) {
- row[SumDataFields.TORQUECONVERTER_MANUFACTURER] = data.TorqueConverterData.Manufacturer;
- row[SumDataFields.TORQUECONVERTER_MODEL] = data.TorqueConverterData.ModelName;
- row[SumDataFields.TORQUE_CONVERTER_CERTIFICATION_NUMBER] =
- data.TorqueConverterData.CertificationMethod == CertificationMethod.StandardValues
- ? ""
- : data.TorqueConverterData.CertificationNumber;
- row[SumDataFields.TORQUE_CONVERTER_CERTIFICATION_METHOD] =
- data.TorqueConverterData.CertificationMethod.GetName();
- }
- } else {
- row[SumDataFields.GEAR_RATIO_FIRST_GEAR] = data.Gears.Count > 0
- ? (ConvertedSI)data.Gears.First().Value.Ratio.SI<Scalar>()
- : (ConvertedSI)0.SI<Scalar>();
- row[SumDataFields.GEAR_RATIO_LAST_GEAR] = data.Gears.Count > 0
- ? (ConvertedSI)data.Gears.Last().Value.Ratio.SI<Scalar>()
- : (ConvertedSI)0.SI<Scalar>();
- row[SumDataFields.TORQUECONVERTER_MANUFACTURER] = Constants.NOT_AVAILABLE;
- row[SumDataFields.TORQUECONVERTER_MODEL] = Constants.NOT_AVAILABLE;
- row[SumDataFields.TORQUE_CONVERTER_CERTIFICATION_METHOD] = "";
- row[SumDataFields.TORQUE_CONVERTER_CERTIFICATION_NUMBER] = "";
- }
- }
-
public static string ReplaceNotAllowedCharacters(string text)
{
return text.Replace('#', '_').Replace(',', '_').Replace('\n', '_').Replace('\r', '_');
diff --git a/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs b/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
index 54b0580661..2ed1530d61 100644
--- a/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
+++ b/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
@@ -318,6 +318,8 @@ namespace TUGraz.VectoCore.Tests.Utils
#endregion
public IEnumerable<ISimulationPreprocessor> GetPreprocessingRuns { get { return new ISimulationPreprocessor[] { }; } }
+ public ISumData SumData { get; }
+
public void AddPreprocessor(ISimulationPreprocessor simulationPreprocessor)
{
throw new NotImplementedException();
--
GitLab